1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2019-2021 Broadcom 3 * All rights reserved. 4 */ 5 6 #ifndef _TF_SESSION_H_ 7 #define _TF_SESSION_H_ 8 9 #include <stdint.h> 10 #include <stdlib.h> 11 12 #include "bitalloc.h" 13 #include "tf_core.h" 14 #include "tf_device.h" 15 #include "tf_rm.h" 16 #include "tf_resources.h" 17 #include "stack.h" 18 #include "ll.h" 19 20 /** 21 * The Session module provides session control support. A session is 22 * to the ULP layer known as a session_info instance. The session 23 * private data is the actual session. 24 * 25 * Session manages: 26 * - The device and all the resources related to the device. 27 * - Any session sharing between ULP applications 28 */ 29 30 /** Session defines 31 */ 32 #define TF_SESSION_ID_INVALID 0xFFFFFFFF /** Invalid Session ID define */ 33 34 /** 35 * At this stage we are using fixed size entries so that each 36 * stack entry represents either 2 or 4 RT (f/n)blocks. So we 37 * take the total block allocation for truflow and divide that 38 * by either 2 or 4. 39 */ 40 #ifdef TF_EM_ENTRY_IPV4_ONLY 41 #define TF_SESSION_EM_ENTRY_SIZE 2 /* 2 blocks per entry */ 42 #else 43 #define TF_SESSION_EM_ENTRY_SIZE 4 /* 4 blocks per entry */ 44 #endif 45 46 /** 47 * Session 48 * 49 * Shared memory containing private TruFlow session information. 50 * Through this structure the session can keep track of resource 51 * allocations and (if so configured) any shadow copy of flow 52 * information. It also holds info about Session Clients. 53 * 54 * Memory is assigned to the Truflow instance by way of 55 * tf_open_session. Memory is allocated and owned by i.e. ULP. 56 * 57 * Access control to this shared memory is handled by the spin_lock in 58 * tf_session_info. 59 */ 60 struct tf_session { 61 /** TruFlow Version. Used to control the structure layout 62 * when sharing sessions. No guarantee that a secondary 63 * process would come from the same version of an executable. 64 */ 65 struct tf_session_version ver; 66 67 /** 68 * Session ID, allocated by FW on tf_open_session() 69 */ 70 union tf_session_id session_id; 71 72 /** 73 * Boolean controlling the use and availability of shared session. 74 * Shared session will allow the application to share resources 75 * on the firmware side without having to allocate them on firmware. 76 * Additional private session core_data will be allocated if this 77 * boolean is set to 'true', default 'false'. 78 * 79 */ 80 bool shared_session; 81 82 /** 83 * This flag indicates the shared session on firmware side is created 84 * by this session. Some privileges may be assigned to this session. 85 * 86 */ 87 bool shared_session_creator; 88 89 /** 90 * Boolean controlling the use and availability of shadow 91 * copy. Shadow copy will allow the TruFlow Core to keep track 92 * of resource content on the firmware side without having to 93 * query firmware. Additional private session core_data will 94 * be allocated if this boolean is set to 'true', default 95 * 'false'. 96 * 97 * Size of memory depends on the NVM Resource settings for the 98 * control channel. 99 */ 100 bool shadow_copy; 101 102 /** 103 * Session Reference Count. To keep track of functions per 104 * session the ref_count is updated. There is also a 105 * parallel TruFlow Firmware ref_count in case the TruFlow 106 * Core goes away without informing the Firmware. 107 */ 108 uint8_t ref_count; 109 110 /** 111 * Session Reference Count for attached sessions. To keep 112 * track of application sharing of a session the 113 * ref_count_attach is updated. 114 */ 115 uint8_t ref_count_attach; 116 117 /** 118 * Device handle 119 */ 120 struct tf_dev_info dev; 121 /** 122 * Device init flag. False if Device is not fully initialized, 123 * else true. 124 */ 125 bool dev_init; 126 127 /** 128 * Linked list of clients registered for this session 129 */ 130 struct ll client_ll; 131 132 /** 133 * em ext db reference for the session 134 */ 135 void *em_ext_db_handle; 136 137 /** 138 * tcam db reference for the session 139 */ 140 void *tcam_db_handle; 141 142 /** 143 * table db reference for the session 144 */ 145 void *tbl_db_handle; 146 147 /** 148 * identifier db reference for the session 149 */ 150 void *id_db_handle; 151 152 /** 153 * em db reference for the session 154 */ 155 void *em_db_handle; 156 157 /** 158 * EM allocator for session 159 */ 160 void *em_pool[TF_DIR_MAX]; 161 162 #ifdef TF_TCAM_SHARED 163 /** 164 * tcam db reference for the session 165 */ 166 void *tcam_shared_db_handle; 167 #endif /* TF_TCAM_SHARED */ 168 169 /** 170 * SRAM db reference for the session 171 */ 172 void *sram_handle; 173 174 /** 175 * if table db reference for the session 176 */ 177 void *if_tbl_db_handle; 178 179 /** 180 * global db reference for the session 181 */ 182 void *global_db_handle; 183 184 /** 185 * Number of slices per row for WC TCAM 186 */ 187 uint16_t wc_num_slices_per_row; 188 }; 189 190 /** 191 * Session Client 192 * 193 * Shared memory for each of the Session Clients. A session can have 194 * one or more clients. 195 */ 196 struct tf_session_client { 197 /** 198 * Linked list of clients 199 */ 200 struct ll_entry ll_entry; /* For inserting in link list, must be 201 * first field of struct. 202 */ 203 204 /** 205 * String containing name of control channel interface to be 206 * used for this session to communicate with firmware. 207 * 208 * ctrl_chan_name will be used as part of a name for any 209 * shared memory allocation. 210 */ 211 char ctrl_chan_name[TF_SESSION_NAME_MAX]; 212 213 /** 214 * Firmware FID, learned at time of Session Client create. 215 */ 216 uint16_t fw_fid; 217 218 /** 219 * Session Client ID, allocated by FW on tf_register_session() 220 */ 221 union tf_session_client_id session_client_id; 222 }; 223 224 /** 225 * Session open parameter definition 226 */ 227 struct tf_session_open_session_parms { 228 /** 229 * [in] Pointer to the TF open session configuration 230 */ 231 struct tf_open_session_parms *open_cfg; 232 }; 233 234 /** 235 * Session attach parameter definition 236 */ 237 struct tf_session_attach_session_parms { 238 /** 239 * [in] Pointer to the TF attach session configuration 240 */ 241 struct tf_attach_session_parms *attach_cfg; 242 }; 243 244 /** 245 * Session close parameter definition 246 */ 247 struct tf_session_close_session_parms { 248 /** 249 * [] 250 */ 251 uint8_t *ref_count; 252 /** 253 * [] 254 */ 255 union tf_session_id *session_id; 256 }; 257 258 /** 259 * @page session Session Management 260 * 261 * @ref tf_session_open_session 262 * 263 * @ref tf_session_attach_session 264 * 265 * @ref tf_session_close_session 266 * 267 * @ref tf_session_is_fid_supported 268 * 269 * @ref tf_session_get_session_internal 270 * 271 * @ref tf_session_get_session 272 * 273 * @ref tf_session_get_session_client 274 * 275 * @ref tf_session_find_session_client_by_name 276 * 277 * @ref tf_session_find_session_client_by_fid 278 * 279 * @ref tf_session_get_device 280 * 281 * @ref tf_session_get_fw_session_id 282 * 283 * @ref tf_session_get_session_id 284 * 285 * @ref tf_session_is_shared_session_creator 286 * 287 * @ref tf_session_get_db 288 * 289 * @ref tf_session_set_db 290 * 291 * @ref tf_session_get_bp 292 * 293 * @ref tf_session_is_shared_session 294 * 295 * #define TF_SHARED 296 * @ref tf_session_get_tcam_shared_db 297 * 298 * @ref tf_session_set_tcam_shared_db 299 * #endif 300 * 301 * @ref tf_session_get_sram_db 302 * 303 * @ref tf_session_set_sram_db 304 */ 305 306 /** 307 * Creates a host session with a corresponding firmware session. 308 * 309 * [in] tfp 310 * Pointer to TF handle 311 * 312 * [in] parms 313 * Pointer to the session open parameters 314 * 315 * Returns 316 * - (0) if successful. 317 * - (-EINVAL) on failure. 318 */ 319 int tf_session_open_session(struct tf *tfp, 320 struct tf_session_open_session_parms *parms); 321 322 /** 323 * Attaches a previous created session. 324 * 325 * [in] tfp 326 * Pointer to TF handle 327 * 328 * [in] parms 329 * Pointer to the session attach parameters 330 * 331 * Returns 332 * - (0) if successful. 333 * - (-EINVAL) on failure. 334 */ 335 int tf_session_attach_session(struct tf *tfp, 336 struct tf_session_attach_session_parms *parms); 337 338 /** 339 * Closes a previous created session. Only possible if previous 340 * registered Clients had been unregistered first. 341 * 342 * [in] tfp 343 * Pointer to TF handle 344 * 345 * [in/out] parms 346 * Pointer to the session close parameters. 347 * 348 * Returns 349 * - (0) if successful. 350 * - (-EUSERS) if clients are still registered with the session. 351 * - (-EINVAL) on failure. 352 */ 353 int tf_session_close_session(struct tf *tfp, 354 struct tf_session_close_session_parms *parms); 355 356 /** 357 * Verifies that the fid is supported by the session. Used to assure 358 * that a function i.e. client/control channel is registered with the 359 * session. 360 * 361 * [in] tfs 362 * Pointer to TF Session handle 363 * 364 * [in] fid 365 * FID value to check 366 * 367 * Returns 368 * - (true) if successful, else false 369 * - (-EINVAL) on failure. 370 */ 371 bool 372 tf_session_is_fid_supported(struct tf_session *tfs, 373 uint16_t fid); 374 375 /** 376 * Looks up the private session information from the TF session 377 * info. Does not perform a fid check against the registered 378 * clients. Should be used if tf_session_get_session() was used 379 * previously i.e. at the TF API boundary. 380 * 381 * [in] tfp 382 * Pointer to TF handle 383 * 384 * [out] tfs 385 * Pointer pointer to the session 386 * 387 * Returns 388 * - (0) if successful. 389 * - (-EINVAL) on failure. 390 */ 391 int tf_session_get_session_internal(struct tf *tfp, 392 struct tf_session **tfs); 393 394 /** 395 * Looks up the private session information from the TF session 396 * info. Performs a fid check against the clients on the session. 397 * 398 * [in] tfp 399 * Pointer to TF handle 400 * 401 * [out] tfs 402 * Pointer pointer to the session 403 * 404 * Returns 405 * - (0) if successful. 406 * - (-EINVAL) on failure. 407 */ 408 int tf_session_get_session(struct tf *tfp, 409 struct tf_session **tfs); 410 411 /** 412 * Looks up client within the session. 413 * 414 * [in] tfs 415 * Pointer pointer to the session 416 * 417 * [in] session_client_id 418 * Client id to look for within the session 419 * 420 * Returns 421 * client if successful. 422 * - (NULL) on failure, client not found. 423 */ 424 struct tf_session_client * 425 tf_session_get_session_client(struct tf_session *tfs, 426 union tf_session_client_id session_client_id); 427 428 /** 429 * Looks up client using name within the session. 430 * 431 * [in] session, pointer to the session 432 * 433 * [in] session_client_name, name of the client to lookup in the session 434 * 435 * Returns: 436 * - Pointer to the session, if found. 437 * - (NULL) on failure, client not found. 438 */ 439 struct tf_session_client * 440 tf_session_find_session_client_by_name(struct tf_session *tfs, 441 const char *ctrl_chan_name); 442 443 /** 444 * Looks up client using the fid. 445 * 446 * [in] session, pointer to the session 447 * 448 * [in] fid, fid of the client to find 449 * 450 * Returns: 451 * - Pointer to the session, if found. 452 * - (NULL) on failure, client not found. 453 */ 454 struct tf_session_client * 455 tf_session_find_session_client_by_fid(struct tf_session *tfs, 456 uint16_t fid); 457 458 /** 459 * Looks up the device information from the TF Session. 460 * 461 * [in] tfs 462 * Pointer to session handle 463 * 464 * [out] tfd 465 * Pointer to the device 466 * 467 * Returns 468 * - (0) if successful. 469 * - (-EINVAL) on failure. 470 */ 471 int tf_session_get_device(struct tf_session *tfs, 472 struct tf_dev_info **tfd); 473 474 /** 475 * Returns the session and the device from the tfp. 476 * 477 * [in] tfp 478 * Pointer to TF handle 479 * 480 * [out] tfs 481 * Pointer to the session 482 * 483 * [out] tfd 484 * Pointer to the device 485 486 * Returns 487 * - (0) if successful. 488 * - (-EINVAL) on failure. 489 */ 490 int tf_session_get(struct tf *tfp, 491 struct tf_session **tfs, 492 struct tf_dev_info **tfd); 493 494 /** 495 * Looks up the FW Session id the requested TF handle. 496 * 497 * [in] tfp 498 * Pointer to TF handle 499 * 500 * [out] session_id 501 * Pointer to the session_id 502 * 503 * Returns 504 * - (0) if successful. 505 * - (-EINVAL) on failure. 506 */ 507 int tf_session_get_fw_session_id(struct tf *tfp, 508 uint8_t *fw_session_id); 509 510 /** 511 * Looks up the Session id the requested TF handle. 512 * 513 * [in] tfp 514 * Pointer to TF handle 515 * 516 * [out] session_id 517 * Pointer to the session_id 518 * 519 * Returns 520 * - (0) if successful. 521 * - (-EINVAL) on failure. 522 */ 523 int tf_session_get_session_id(struct tf *tfp, 524 union tf_session_id *session_id); 525 526 /** 527 * API to get the em_ext_db from tf_session. 528 * 529 * [in] tfp 530 * Pointer to TF handle 531 * 532 * [out] em_ext_db_handle, pointer to eem handle 533 * 534 * Returns: 535 * - (0) if successful. 536 * - (-EINVAL) on failure. 537 */ 538 int 539 tf_session_get_em_ext_db(struct tf *tfp, 540 void **em_ext_db_handle); 541 542 /** 543 * API to set the em_ext_db in tf_session. 544 * 545 * [in] tfp 546 * Pointer to TF handle 547 * 548 * [in] em_ext_db_handle, pointer to eem handle 549 * 550 * Returns: 551 * - (0) if successful. 552 * - (-EINVAL) on failure. 553 */ 554 int 555 tf_session_set_em_ext_db(struct tf *tfp, 556 void *em_ext_db_handle); 557 558 /** 559 * API to get the db from tf_session. 560 * 561 * [in] tfp 562 * Pointer to TF handle 563 * 564 * [out] db_handle, pointer to db handle 565 * 566 * Returns: 567 * - (0) if successful. 568 * - (-EINVAL) on failure. 569 */ 570 int 571 tf_session_get_db(struct tf *tfp, 572 enum tf_module_type type, 573 void **db_handle); 574 575 /** 576 * API to set the db in tf_session. 577 * 578 * [in] tfp 579 * Pointer to TF handle 580 * 581 * [in] db_handle, pointer to db handle 582 * 583 * Returns: 584 * - (0) if successful. 585 * - (-EINVAL) on failure. 586 */ 587 int 588 tf_session_set_db(struct tf *tfp, 589 enum tf_module_type type, 590 void *db_handle); 591 592 /** 593 * Check if the session is shared session. 594 * 595 * [in] session, pointer to the session 596 * 597 * Returns: 598 * - true if it is shared session 599 * - false if it is not shared session 600 */ 601 static inline bool 602 tf_session_is_shared_session(struct tf_session *tfs) 603 { 604 return tfs->shared_session; 605 } 606 607 /** 608 * Check if the session is the shared session creator 609 * 610 * [in] session, pointer to the session 611 * 612 * Returns: 613 * - true if it is the shared session creator 614 * - false if it is not the shared session creator 615 */ 616 static inline bool 617 tf_session_is_shared_session_creator(struct tf_session *tfs) 618 { 619 return tfs->shared_session_creator; 620 } 621 622 /** 623 * Get the pointer to the parent bnxt struct 624 * 625 * [in] session, pointer to the session 626 * 627 * Returns: 628 * - the pointer to the parent bnxt struct 629 */ 630 static inline struct bnxt* 631 tf_session_get_bp(struct tf *tfp) 632 { 633 return tfp->bp; 634 } 635 636 /** 637 * Set the pointer to the tcam shared database 638 * 639 * [in] session, pointer to the session 640 * 641 * Returns: 642 * - the pointer to the parent bnxt struct 643 */ 644 int 645 tf_session_set_tcam_shared_db(struct tf *tfp, 646 void *tcam_shared_db_handle); 647 648 /** 649 * Get the pointer to the tcam shared database 650 * 651 * [in] session, pointer to the session 652 * 653 * Returns: 654 * - the pointer to the parent bnxt struct 655 */ 656 int 657 tf_session_get_tcam_shared_db(struct tf *tfp, 658 void **tcam_shared_db_handle); 659 660 /** 661 * Set the pointer to the SRAM database 662 * 663 * [in] session, pointer to the session 664 * 665 * Returns: 666 * - the pointer to the parent bnxt struct 667 */ 668 int 669 tf_session_set_sram_db(struct tf *tfp, 670 void *sram_handle); 671 672 /** 673 * Get the pointer to the SRAM database 674 * 675 * [in] session, pointer to the session 676 * 677 * Returns: 678 * - the pointer to the parent bnxt struct 679 */ 680 int 681 tf_session_get_sram_db(struct tf *tfp, 682 void **sram_handle); 683 684 /** 685 * Set the pointer to the global cfg database 686 * 687 * [in] session, pointer to the session 688 * 689 * Returns: 690 * - (0) if successful. 691 * - (-EINVAL) on failure. 692 */ 693 int 694 tf_session_set_global_db(struct tf *tfp, 695 void *global_handle); 696 697 /** 698 * Get the pointer to the global cfg database 699 * 700 * [in] session, pointer to the session 701 * 702 * Returns: 703 * - (0) if successful. 704 * - (-EINVAL) on failure. 705 */ 706 int 707 tf_session_get_global_db(struct tf *tfp, 708 void **global_handle); 709 710 /** 711 * Set the pointer to the if table cfg database 712 * 713 * [in] session, pointer to the session 714 * 715 * Returns: 716 * - (0) if successful. 717 * - (-EINVAL) on failure. 718 */ 719 int 720 tf_session_set_if_tbl_db(struct tf *tfp, 721 void *if_tbl_handle); 722 723 /** 724 * Get the pointer to the if table cfg database 725 * 726 * [in] session, pointer to the session 727 * 728 * Returns: 729 * - (0) if successful. 730 * - (-EINVAL) on failure. 731 */ 732 int 733 tf_session_get_if_tbl_db(struct tf *tfp, 734 void **if_tbl_handle); 735 736 #endif /* _TF_SESSION_H_ */ 737