1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2019-2021 Broadcom 3 * All rights reserved. 4 */ 5 6 #include <string.h> 7 8 #include <rte_common.h> 9 10 #include "tf_session.h" 11 #include "tf_common.h" 12 #include "tf_msg.h" 13 #include "tfp.h" 14 #include "bnxt.h" 15 16 struct tf_session_client_create_parms { 17 /** 18 * [in] Pointer to the control channel name string 19 */ 20 char *ctrl_chan_name; 21 22 /** 23 * [out] Firmware Session Client ID 24 */ 25 union tf_session_client_id *session_client_id; 26 }; 27 28 struct tf_session_client_destroy_parms { 29 /** 30 * FW Session Client Identifier 31 */ 32 union tf_session_client_id session_client_id; 33 }; 34 35 /** 36 * Creates a Session and the associated client. 37 * 38 * [in] tfp 39 * Pointer to TF handle 40 * 41 * [in] parms 42 * Pointer to session client create parameters 43 * 44 * Returns 45 * - (0) if successful. 46 * - (-EINVAL) on failure. 47 * - (-ENOMEM) if max session clients has been reached. 48 */ 49 static int 50 tf_session_create(struct tf *tfp, 51 struct tf_session_open_session_parms *parms) 52 { 53 int rc; 54 struct tf_session *session = NULL; 55 struct tf_session_client *client; 56 struct tfp_calloc_parms cparms; 57 uint8_t fw_session_id; 58 uint8_t fw_session_client_id; 59 union tf_session_id *session_id; 60 struct tf_dev_info dev; 61 bool shared_session_creator; 62 int name_len; 63 char *name; 64 65 TF_CHECK_PARMS2(tfp, parms); 66 67 tf_dev_bind_ops(parms->open_cfg->device_type, 68 &dev); 69 70 /* Open FW session and get a new session_id */ 71 rc = tf_msg_session_open(parms->open_cfg->bp, 72 parms->open_cfg->ctrl_chan_name, 73 &fw_session_id, 74 &fw_session_client_id, 75 &dev, 76 &shared_session_creator); 77 if (rc) { 78 /* Log error */ 79 if (rc == -EEXIST) 80 TFP_DRV_LOG(ERR, 81 "Session is already open, rc:%s\n", 82 strerror(-rc)); 83 else 84 TFP_DRV_LOG(ERR, 85 "Open message send failed, rc:%s\n", 86 strerror(-rc)); 87 88 parms->open_cfg->session_id.id = TF_FW_SESSION_ID_INVALID; 89 return rc; 90 } 91 92 /* Allocate session */ 93 cparms.nitems = 1; 94 cparms.size = sizeof(struct tf_session_info); 95 cparms.alignment = 0; 96 rc = tfp_calloc(&cparms); 97 if (rc) { 98 /* Log error */ 99 TFP_DRV_LOG(ERR, 100 "Failed to allocate session info, rc:%s\n", 101 strerror(-rc)); 102 goto cleanup; 103 } 104 tfp->session = (struct tf_session_info *)cparms.mem_va; 105 106 /* Allocate core data for the session */ 107 cparms.nitems = 1; 108 cparms.size = sizeof(struct tf_session); 109 cparms.alignment = 0; 110 rc = tfp_calloc(&cparms); 111 if (rc) { 112 /* Log error */ 113 TFP_DRV_LOG(ERR, 114 "Failed to allocate session data, rc:%s\n", 115 strerror(-rc)); 116 goto cleanup; 117 } 118 tfp->session->core_data = cparms.mem_va; 119 session_id = &parms->open_cfg->session_id; 120 121 /* Update Session Info, which is what is visible to the caller */ 122 tfp->session->ver.major = 0; 123 tfp->session->ver.minor = 0; 124 tfp->session->ver.update = 0; 125 126 tfp->session->session_id.internal.domain = session_id->internal.domain; 127 tfp->session->session_id.internal.bus = session_id->internal.bus; 128 tfp->session->session_id.internal.device = session_id->internal.device; 129 tfp->session->session_id.internal.fw_session_id = fw_session_id; 130 131 /* Initialize Session and Device, which is private */ 132 session = (struct tf_session *)tfp->session->core_data; 133 session->ver.major = 0; 134 session->ver.minor = 0; 135 session->ver.update = 0; 136 137 session->session_id.internal.domain = session_id->internal.domain; 138 session->session_id.internal.bus = session_id->internal.bus; 139 session->session_id.internal.device = session_id->internal.device; 140 session->session_id.internal.fw_session_id = fw_session_id; 141 /* Return the allocated session id */ 142 session_id->id = session->session_id.id; 143 144 session->shadow_copy = parms->open_cfg->shadow_copy; 145 146 /* Init session client list */ 147 ll_init(&session->client_ll); 148 149 /* Create the local session client, initialize and attach to 150 * the session 151 */ 152 cparms.nitems = 1; 153 cparms.size = sizeof(struct tf_session_client); 154 cparms.alignment = 0; 155 rc = tfp_calloc(&cparms); 156 if (rc) { 157 /* Log error */ 158 TFP_DRV_LOG(ERR, 159 "Failed to allocate session client, rc:%s\n", 160 strerror(-rc)); 161 goto cleanup; 162 } 163 client = cparms.mem_va; 164 165 /* Register FID with the client */ 166 rc = tfp_get_fid(tfp, &client->fw_fid); 167 if (rc) 168 return rc; 169 170 client->session_client_id.internal.fw_session_id = fw_session_id; 171 client->session_client_id.internal.fw_session_client_id = 172 fw_session_client_id; 173 174 tfp_memcpy(client->ctrl_chan_name, 175 parms->open_cfg->ctrl_chan_name, 176 TF_SESSION_NAME_MAX); 177 178 ll_insert(&session->client_ll, &client->ll_entry); 179 session->ref_count++; 180 181 /* Init session em_ext_db */ 182 session->em_ext_db_handle = NULL; 183 184 /* Populate the request */ 185 name_len = strnlen(parms->open_cfg->ctrl_chan_name, 186 TF_SESSION_NAME_MAX); 187 name = &parms->open_cfg->ctrl_chan_name[name_len - strlen("tf_shared")]; 188 if (!strncmp(name, "tf_shared", strlen("tf_shared"))) 189 session->shared_session = true; 190 191 name = &parms->open_cfg->ctrl_chan_name[name_len - 192 strlen("tf_shared-wc_tcam")]; 193 if (!strncmp(name, "tf_shared-wc_tcam", strlen("tf_shared-wc_tcam"))) 194 session->shared_session = true; 195 196 if (session->shared_session && shared_session_creator) { 197 session->shared_session_creator = true; 198 parms->open_cfg->shared_session_creator = true; 199 } 200 201 rc = tf_dev_bind(tfp, 202 parms->open_cfg->device_type, 203 session->shadow_copy, 204 &parms->open_cfg->resources, 205 parms->open_cfg->wc_num_slices, 206 &session->dev); 207 208 /* Logging handled by dev_bind */ 209 if (rc) 210 goto cleanup; 211 212 if (session->dev.ops->tf_dev_get_mailbox == NULL) { 213 /* Log error */ 214 TFP_DRV_LOG(ERR, 215 "No tf_dev_get_mailbox() defined for device\n"); 216 goto cleanup; 217 } 218 219 session->dev_init = true; 220 221 return 0; 222 223 cleanup: 224 rc = tf_msg_session_close(tfp, 225 fw_session_id, 226 dev.ops->tf_dev_get_mailbox()); 227 if (rc) { 228 /* Log error */ 229 TFP_DRV_LOG(ERR, 230 "FW Session close failed, rc:%s\n", 231 strerror(-rc)); 232 } 233 234 tfp_free(tfp->session->core_data); 235 tfp_free(tfp->session); 236 tfp->session = NULL; 237 return rc; 238 } 239 240 /** 241 * Creates a Session Client on an existing Session. 242 * 243 * [in] tfp 244 * Pointer to TF handle 245 * 246 * [in] parms 247 * Pointer to session client create parameters 248 * 249 * Returns 250 * - (0) if successful. 251 * - (-EINVAL) on failure. 252 * - (-ENOMEM) if max session clients has been reached. 253 */ 254 static int 255 tf_session_client_create(struct tf *tfp, 256 struct tf_session_client_create_parms *parms) 257 { 258 int rc; 259 struct tf_session *session = NULL; 260 struct tf_session_client *client; 261 struct tfp_calloc_parms cparms; 262 union tf_session_client_id session_client_id; 263 264 TF_CHECK_PARMS2(tfp, parms); 265 266 /* Using internal version as session client may not exist yet */ 267 rc = tf_session_get_session_internal(tfp, &session); 268 if (rc) { 269 TFP_DRV_LOG(ERR, 270 "Failed to lookup session, rc:%s\n", 271 strerror(-rc)); 272 return rc; 273 } 274 275 client = tf_session_find_session_client_by_name(session, 276 parms->ctrl_chan_name); 277 if (client) { 278 TFP_DRV_LOG(ERR, 279 "Client %s, already registered with this session\n", 280 parms->ctrl_chan_name); 281 return -EOPNOTSUPP; 282 } 283 284 rc = tf_msg_session_client_register 285 (tfp, 286 session, 287 parms->ctrl_chan_name, 288 &session_client_id.internal.fw_session_client_id); 289 if (rc) { 290 TFP_DRV_LOG(ERR, 291 "Failed to create client on session, rc:%s\n", 292 strerror(-rc)); 293 return rc; 294 } 295 296 /* Create the local session client, initialize and attach to 297 * the session 298 */ 299 cparms.nitems = 1; 300 cparms.size = sizeof(struct tf_session_client); 301 cparms.alignment = 0; 302 rc = tfp_calloc(&cparms); 303 if (rc) { 304 TFP_DRV_LOG(ERR, 305 "Failed to allocate session client, rc:%s\n", 306 strerror(-rc)); 307 goto cleanup; 308 } 309 client = cparms.mem_va; 310 311 /* Register FID with the client */ 312 rc = tfp_get_fid(tfp, &client->fw_fid); 313 if (rc) 314 return rc; 315 316 /* Build the Session Client ID by adding the fw_session_id */ 317 rc = tf_session_get_fw_session_id 318 (tfp, 319 &session_client_id.internal.fw_session_id); 320 if (rc) { 321 TFP_DRV_LOG(ERR, 322 "Session Firmware id lookup failed, rc:%s\n", 323 strerror(-rc)); 324 return rc; 325 } 326 327 tfp_memcpy(client->ctrl_chan_name, 328 parms->ctrl_chan_name, 329 TF_SESSION_NAME_MAX); 330 331 client->session_client_id.id = session_client_id.id; 332 333 ll_insert(&session->client_ll, &client->ll_entry); 334 335 session->ref_count++; 336 337 /* Build the return value */ 338 parms->session_client_id->id = session_client_id.id; 339 340 cleanup: 341 /* TBD - Add code to unregister newly create client from fw */ 342 343 return rc; 344 } 345 346 347 /** 348 * Destroys a Session Client on an existing Session. 349 * 350 * [in] tfp 351 * Pointer to TF handle 352 * 353 * [in] parms 354 * Pointer to the session client destroy parameters 355 * 356 * Returns 357 * - (0) if successful. 358 * - (-EINVAL) on failure. 359 * - (-ENOTFOUND) error, client not owned by the session. 360 * - (-ENOTSUPP) error, unable to destroy client as its the last 361 * client. Please use the tf_session_close(). 362 */ 363 static int 364 tf_session_client_destroy(struct tf *tfp, 365 struct tf_session_client_destroy_parms *parms) 366 { 367 int rc; 368 struct tf_session *tfs; 369 struct tf_session_client *client; 370 371 TF_CHECK_PARMS2(tfp, parms); 372 373 rc = tf_session_get_session(tfp, &tfs); 374 if (rc) { 375 TFP_DRV_LOG(ERR, 376 "Failed to lookup session, rc:%s\n", 377 strerror(-rc)); 378 return rc; 379 } 380 381 /* Check session owns this client and that we're not the last client */ 382 client = tf_session_get_session_client(tfs, 383 parms->session_client_id); 384 if (client == NULL) { 385 TFP_DRV_LOG(ERR, 386 "Client %d, not found within this session\n", 387 parms->session_client_id.id); 388 return -EINVAL; 389 } 390 391 /* If last client the request is rejected and cleanup should 392 * be done by session close. 393 */ 394 if (tfs->ref_count == 1) 395 return -EOPNOTSUPP; 396 397 rc = tf_msg_session_client_unregister 398 (tfp, 399 tfs, 400 parms->session_client_id.internal.fw_session_client_id); 401 402 /* Log error, but continue. If FW fails we do not really have 403 * a way to fix this but the client would no longer be valid 404 * thus we remove from the session. 405 */ 406 if (rc) { 407 TFP_DRV_LOG(ERR, 408 "Client destroy on FW Failed, rc:%s\n", 409 strerror(-rc)); 410 } 411 412 ll_delete(&tfs->client_ll, &client->ll_entry); 413 414 /* Decrement the session ref_count */ 415 tfs->ref_count--; 416 417 tfp_free(client); 418 419 return rc; 420 } 421 422 int 423 tf_session_open_session(struct tf *tfp, 424 struct tf_session_open_session_parms *parms) 425 { 426 int rc; 427 struct tf_session_client_create_parms scparms; 428 429 TF_CHECK_PARMS3(tfp, parms, parms->open_cfg->bp); 430 431 tfp->bp = parms->open_cfg->bp; 432 /* Decide if we're creating a new session or session client */ 433 if (tfp->session == NULL) { 434 rc = tf_session_create(tfp, parms); 435 if (rc) { 436 TFP_DRV_LOG(ERR, 437 "Failed to create session, ctrl_chan_name:%s, rc:%s\n", 438 parms->open_cfg->ctrl_chan_name, 439 strerror(-rc)); 440 return rc; 441 } 442 443 TFP_DRV_LOG(INFO, 444 "Session created, session_client_id:%d," 445 "session_id:0x%08x, fw_session_id:%d\n", 446 parms->open_cfg->session_client_id.id, 447 parms->open_cfg->session_id.id, 448 parms->open_cfg->session_id.internal.fw_session_id); 449 } else { 450 scparms.ctrl_chan_name = parms->open_cfg->ctrl_chan_name; 451 scparms.session_client_id = &parms->open_cfg->session_client_id; 452 453 /* Create the new client and get it associated with 454 * the session. 455 */ 456 rc = tf_session_client_create(tfp, &scparms); 457 if (rc) { 458 TFP_DRV_LOG(ERR, 459 "Failed to create client on session 0x%x, rc:%s\n", 460 parms->open_cfg->session_id.id, 461 strerror(-rc)); 462 return rc; 463 } 464 465 TFP_DRV_LOG(INFO, 466 "Session Client:%d registered on session:0x%8x\n", 467 scparms.session_client_id->internal.fw_session_client_id, 468 tfp->session->session_id.id); 469 } 470 471 return 0; 472 } 473 474 int 475 tf_session_attach_session(struct tf *tfp __rte_unused, 476 struct tf_session_attach_session_parms *parms __rte_unused) 477 { 478 int rc = -EOPNOTSUPP; 479 480 TF_CHECK_PARMS2(tfp, parms); 481 482 TFP_DRV_LOG(ERR, 483 "Attach not yet supported, rc:%s\n", 484 strerror(-rc)); 485 return rc; 486 } 487 488 int 489 tf_session_close_session(struct tf *tfp, 490 struct tf_session_close_session_parms *parms) 491 { 492 int rc; 493 struct tf_session *tfs = NULL; 494 struct tf_session_client *client; 495 struct tf_dev_info *tfd = NULL; 496 struct tf_session_client_destroy_parms scdparms; 497 uint16_t fid; 498 uint8_t fw_session_id = 1; 499 int mailbox = 0; 500 501 TF_CHECK_PARMS2(tfp, parms); 502 503 rc = tf_session_get_session(tfp, &tfs); 504 if (rc) { 505 TFP_DRV_LOG(ERR, 506 "Session lookup failed, rc:%s\n", 507 strerror(-rc)); 508 return rc; 509 } 510 511 if (tfs->session_id.id == TF_SESSION_ID_INVALID) { 512 rc = -EINVAL; 513 TFP_DRV_LOG(ERR, 514 "Invalid session id, unable to close, rc:%s\n", 515 strerror(-rc)); 516 return rc; 517 } 518 519 /* Get the client, we need it independently of the closure 520 * type (client or session closure). 521 * 522 * We find the client by way of the fid. Thus one cannot close 523 * a client on behalf of someone else. 524 */ 525 rc = tfp_get_fid(tfp, &fid); 526 if (rc) 527 return rc; 528 529 client = tf_session_find_session_client_by_fid(tfs, 530 fid); 531 if (!client) { 532 rc = -EINVAL; 533 TFP_DRV_LOG(ERR, 534 "Client not part of the session, unable to close, rc:%s\n", 535 strerror(-rc)); 536 return rc; 537 } 538 539 /* In case multiple clients we chose to close those first */ 540 if (tfs->ref_count > 1) { 541 /* Linaro gcc can't static init this structure */ 542 memset(&scdparms, 543 0, 544 sizeof(struct tf_session_client_destroy_parms)); 545 546 scdparms.session_client_id = client->session_client_id; 547 /* Destroy requested client so its no longer 548 * registered with this session. 549 */ 550 rc = tf_session_client_destroy(tfp, &scdparms); 551 if (rc) { 552 TFP_DRV_LOG(ERR, 553 "Failed to unregister Client %d, rc:%s\n", 554 client->session_client_id.id, 555 strerror(-rc)); 556 return rc; 557 } 558 559 TFP_DRV_LOG(INFO, 560 "Closed session client, session_client_id:%d\n", 561 client->session_client_id.id); 562 563 TFP_DRV_LOG(INFO, 564 "session_id:0x%08x, ref_count:%d\n", 565 tfs->session_id.id, 566 tfs->ref_count); 567 568 return 0; 569 } 570 571 /* Record the session we're closing so the caller knows the 572 * details. 573 */ 574 *parms->session_id = tfs->session_id; 575 576 rc = tf_session_get_device(tfs, &tfd); 577 if (rc) { 578 TFP_DRV_LOG(ERR, 579 "Device lookup failed, rc:%s\n", 580 strerror(-rc)); 581 return rc; 582 } 583 584 mailbox = tfd->ops->tf_dev_get_mailbox(); 585 586 rc = tf_session_get_fw_session_id(tfp, &fw_session_id); 587 if (rc) { 588 TFP_DRV_LOG(ERR, 589 "Unable to lookup FW id, rc:%s\n", 590 strerror(-rc)); 591 return rc; 592 } 593 594 /* Unbind the device */ 595 rc = tf_dev_unbind(tfp, tfd); 596 if (rc) { 597 /* Log error */ 598 TFP_DRV_LOG(ERR, 599 "Device unbind failed, rc:%s\n", 600 strerror(-rc)); 601 } 602 603 rc = tf_msg_session_close(tfp, fw_session_id, mailbox); 604 if (rc) { 605 /* Log error */ 606 TFP_DRV_LOG(ERR, 607 "FW Session close failed, rc:%s\n", 608 strerror(-rc)); 609 } 610 611 /* Final cleanup as we're last user of the session thus we 612 * also delete the last client. 613 */ 614 ll_delete(&tfs->client_ll, &client->ll_entry); 615 tfp_free(client); 616 617 tfs->ref_count--; 618 619 TFP_DRV_LOG(INFO, 620 "Closed session, session_id:0x%08x, ref_count:%d\n", 621 tfs->session_id.id, 622 tfs->ref_count); 623 624 tfs->dev_init = false; 625 626 tfp_free(tfp->session->core_data); 627 tfp_free(tfp->session); 628 tfp->session = NULL; 629 630 return 0; 631 } 632 633 bool 634 tf_session_is_fid_supported(struct tf_session *tfs, 635 uint16_t fid) 636 { 637 struct ll_entry *c_entry; 638 struct tf_session_client *client; 639 640 for (c_entry = tfs->client_ll.head; 641 c_entry != NULL; 642 c_entry = c_entry->next) { 643 client = (struct tf_session_client *)c_entry; 644 if (client->fw_fid == fid) 645 return true; 646 } 647 648 return false; 649 } 650 651 int 652 tf_session_get_session_internal(struct tf *tfp, 653 struct tf_session **tfs) 654 { 655 int rc = 0; 656 657 /* Skip using the check macro as we want to control the error msg */ 658 if (tfp->session == NULL || tfp->session->core_data == NULL) { 659 rc = -EINVAL; 660 TFP_DRV_LOG(ERR, 661 "Session not created, rc:%s\n", 662 strerror(-rc)); 663 return rc; 664 } 665 666 *tfs = (struct tf_session *)(tfp->session->core_data); 667 668 return rc; 669 } 670 671 int 672 tf_session_get_session(struct tf *tfp, 673 struct tf_session **tfs) 674 { 675 int rc; 676 uint16_t fw_fid; 677 bool supported = false; 678 679 rc = tf_session_get_session_internal(tfp, 680 tfs); 681 /* Logging done by tf_session_get_session_internal */ 682 if (rc) 683 return rc; 684 685 /* As session sharing among functions aka 'individual clients' 686 * is supported we have to assure that the client is indeed 687 * registered before we get deep in the TruFlow api stack. 688 */ 689 rc = tfp_get_fid(tfp, &fw_fid); 690 if (rc) { 691 TFP_DRV_LOG(ERR, 692 "Internal FID lookup\n, rc:%s\n", 693 strerror(-rc)); 694 return rc; 695 } 696 697 supported = tf_session_is_fid_supported(*tfs, fw_fid); 698 if (!supported) { 699 TFP_DRV_LOG 700 (ERR, 701 "Ctrl channel not registered with session\n, rc:%s\n", 702 strerror(-rc)); 703 return -EINVAL; 704 } 705 706 return rc; 707 } 708 709 int tf_session_get(struct tf *tfp, 710 struct tf_session **tfs, 711 struct tf_dev_info **tfd) 712 { 713 int rc; 714 rc = tf_session_get_session_internal(tfp, tfs); 715 716 /* Logging done by tf_session_get_session_internal */ 717 if (rc) 718 return rc; 719 720 rc = tf_session_get_device(*tfs, tfd); 721 722 return rc; 723 } 724 725 struct tf_session_client * 726 tf_session_get_session_client(struct tf_session *tfs, 727 union tf_session_client_id session_client_id) 728 { 729 struct ll_entry *c_entry; 730 struct tf_session_client *client; 731 732 /* Skip using the check macro as we just want to return */ 733 if (tfs == NULL) 734 return NULL; 735 736 for (c_entry = tfs->client_ll.head; 737 c_entry != NULL; 738 c_entry = c_entry->next) { 739 client = (struct tf_session_client *)c_entry; 740 if (client->session_client_id.id == session_client_id.id) 741 return client; 742 } 743 744 return NULL; 745 } 746 747 struct tf_session_client * 748 tf_session_find_session_client_by_name(struct tf_session *tfs, 749 const char *ctrl_chan_name) 750 { 751 struct ll_entry *c_entry; 752 struct tf_session_client *client; 753 754 /* Skip using the check macro as we just want to return */ 755 if (tfs == NULL || ctrl_chan_name == NULL) 756 return NULL; 757 758 for (c_entry = tfs->client_ll.head; 759 c_entry != NULL; 760 c_entry = c_entry->next) { 761 client = (struct tf_session_client *)c_entry; 762 if (strncmp(client->ctrl_chan_name, 763 ctrl_chan_name, 764 TF_SESSION_NAME_MAX) == 0) 765 return client; 766 } 767 768 return NULL; 769 } 770 771 struct tf_session_client * 772 tf_session_find_session_client_by_fid(struct tf_session *tfs, 773 uint16_t fid) 774 { 775 struct ll_entry *c_entry; 776 struct tf_session_client *client; 777 778 /* Skip using the check macro as we just want to return */ 779 if (tfs == NULL) 780 return NULL; 781 782 for (c_entry = tfs->client_ll.head; 783 c_entry != NULL; 784 c_entry = c_entry->next) { 785 client = (struct tf_session_client *)c_entry; 786 if (client->fw_fid == fid) 787 return client; 788 } 789 790 return NULL; 791 } 792 793 int 794 tf_session_get_device(struct tf_session *tfs, 795 struct tf_dev_info **tfd) 796 { 797 *tfd = &tfs->dev; 798 799 return 0; 800 } 801 802 int 803 tf_session_get_fw_session_id(struct tf *tfp, 804 uint8_t *fw_session_id) 805 { 806 int rc; 807 struct tf_session *tfs = NULL; 808 809 /* Skip using the check macro as we want to control the error msg */ 810 if (tfp->session == NULL) { 811 rc = -EINVAL; 812 TFP_DRV_LOG(ERR, 813 "Session not created, rc:%s\n", 814 strerror(-rc)); 815 return rc; 816 } 817 818 if (fw_session_id == NULL) { 819 rc = -EINVAL; 820 TFP_DRV_LOG(ERR, 821 "Invalid Argument(s), rc:%s\n", 822 strerror(-rc)); 823 return rc; 824 } 825 826 rc = tf_session_get_session_internal(tfp, &tfs); 827 if (rc) 828 return rc; 829 830 *fw_session_id = tfs->session_id.internal.fw_session_id; 831 832 return 0; 833 } 834 835 int 836 tf_session_get_session_id(struct tf *tfp, 837 union tf_session_id *session_id) 838 { 839 int rc; 840 struct tf_session *tfs = NULL; 841 842 if (tfp->session == NULL) { 843 rc = -EINVAL; 844 TFP_DRV_LOG(ERR, 845 "Session not created, rc:%s\n", 846 strerror(-rc)); 847 return rc; 848 } 849 850 if (session_id == NULL) { 851 rc = -EINVAL; 852 TFP_DRV_LOG(ERR, 853 "Invalid Argument(s), rc:%s\n", 854 strerror(-rc)); 855 return rc; 856 } 857 858 /* Using internal version as session client may not exist yet */ 859 rc = tf_session_get_session_internal(tfp, &tfs); 860 if (rc) 861 return rc; 862 863 *session_id = tfs->session_id; 864 865 return 0; 866 } 867 868 int 869 tf_session_get_em_ext_db(struct tf *tfp, 870 void **em_ext_db_handle) 871 { 872 struct tf_session *tfs = NULL; 873 int rc = 0; 874 875 *em_ext_db_handle = NULL; 876 877 if (tfp == NULL) 878 return (-EINVAL); 879 880 rc = tf_session_get_session_internal(tfp, &tfs); 881 if (rc) 882 return rc; 883 884 *em_ext_db_handle = tfs->em_ext_db_handle; 885 return rc; 886 } 887 888 int 889 tf_session_set_em_ext_db(struct tf *tfp, 890 void *em_ext_db_handle) 891 { 892 struct tf_session *tfs = NULL; 893 int rc = 0; 894 895 if (tfp == NULL) 896 return (-EINVAL); 897 898 rc = tf_session_get_session_internal(tfp, &tfs); 899 if (rc) 900 return rc; 901 902 tfs->em_ext_db_handle = em_ext_db_handle; 903 return rc; 904 } 905 906 int 907 tf_session_get_db(struct tf *tfp, 908 enum tf_module_type type, 909 void **db_handle) 910 { 911 struct tf_session *tfs = NULL; 912 int rc = 0; 913 914 *db_handle = NULL; 915 916 if (tfp == NULL) 917 return (-EINVAL); 918 919 rc = tf_session_get_session_internal(tfp, &tfs); 920 if (rc) 921 return rc; 922 923 switch (type) { 924 case TF_MODULE_TYPE_IDENTIFIER: 925 if (tfs->id_db_handle) 926 *db_handle = tfs->id_db_handle; 927 else 928 rc = -ENOMEM; 929 break; 930 case TF_MODULE_TYPE_TABLE: 931 if (tfs->tbl_db_handle) 932 *db_handle = tfs->tbl_db_handle; 933 else 934 rc = -ENOMEM; 935 936 break; 937 case TF_MODULE_TYPE_TCAM: 938 if (tfs->tcam_db_handle) 939 *db_handle = tfs->tcam_db_handle; 940 else 941 rc = -ENOMEM; 942 break; 943 case TF_MODULE_TYPE_EM: 944 if (tfs->em_db_handle) 945 *db_handle = tfs->em_db_handle; 946 else 947 rc = -ENOMEM; 948 break; 949 default: 950 rc = -EINVAL; 951 break; 952 } 953 954 return rc; 955 } 956 957 int 958 tf_session_set_db(struct tf *tfp, 959 enum tf_module_type type, 960 void *db_handle) 961 { 962 struct tf_session *tfs = NULL; 963 int rc = 0; 964 965 if (tfp == NULL) 966 return (-EINVAL); 967 968 rc = tf_session_get_session_internal(tfp, &tfs); 969 if (rc) 970 return rc; 971 972 switch (type) { 973 case TF_MODULE_TYPE_IDENTIFIER: 974 tfs->id_db_handle = db_handle; 975 break; 976 case TF_MODULE_TYPE_TABLE: 977 tfs->tbl_db_handle = db_handle; 978 break; 979 case TF_MODULE_TYPE_TCAM: 980 tfs->tcam_db_handle = db_handle; 981 break; 982 case TF_MODULE_TYPE_EM: 983 tfs->em_db_handle = db_handle; 984 break; 985 default: 986 rc = -EINVAL; 987 break; 988 } 989 990 return rc; 991 } 992 993 #ifdef TF_TCAM_SHARED 994 995 int 996 tf_session_get_tcam_shared_db(struct tf *tfp, 997 void **tcam_shared_db_handle) 998 { 999 struct tf_session *tfs = NULL; 1000 int rc = 0; 1001 1002 *tcam_shared_db_handle = NULL; 1003 1004 if (tfp == NULL) 1005 return (-EINVAL); 1006 1007 rc = tf_session_get_session_internal(tfp, &tfs); 1008 if (rc) 1009 return rc; 1010 1011 *tcam_shared_db_handle = tfs->tcam_shared_db_handle; 1012 return rc; 1013 } 1014 1015 int 1016 tf_session_set_tcam_shared_db(struct tf *tfp, 1017 void *tcam_shared_db_handle) 1018 { 1019 struct tf_session *tfs = NULL; 1020 int rc = 0; 1021 1022 if (tfp == NULL) 1023 return (-EINVAL); 1024 1025 rc = tf_session_get_session_internal(tfp, &tfs); 1026 if (rc) 1027 return rc; 1028 1029 tfs->tcam_shared_db_handle = tcam_shared_db_handle; 1030 return rc; 1031 } 1032 1033 int 1034 tf_session_get_sram_db(struct tf *tfp, 1035 void **sram_handle) 1036 { 1037 struct tf_session *tfs = NULL; 1038 int rc = 0; 1039 1040 *sram_handle = NULL; 1041 1042 if (tfp == NULL) 1043 return (-EINVAL); 1044 1045 rc = tf_session_get_session_internal(tfp, &tfs); 1046 if (rc) 1047 return rc; 1048 1049 *sram_handle = tfs->sram_handle; 1050 return rc; 1051 } 1052 1053 int 1054 tf_session_set_sram_db(struct tf *tfp, 1055 void *sram_handle) 1056 { 1057 struct tf_session *tfs = NULL; 1058 int rc = 0; 1059 1060 if (tfp == NULL) 1061 return (-EINVAL); 1062 1063 rc = tf_session_get_session_internal(tfp, &tfs); 1064 if (rc) 1065 return rc; 1066 1067 tfs->sram_handle = sram_handle; 1068 return rc; 1069 } 1070 1071 #endif /* TF_TCAM_SHARED */ 1072