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