drivers/net/bnxt/tf_core/tf_core.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019-2021 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 #ifndef _TF_CORE_H_
   7 #define _TF_CORE_H_
   8
   9 #include <stdint.h>
  10 #include <stdlib.h>
  11 #include <stdbool.h>
  12 #include <stdio.h>
  13 #include "hcapi_cfa_defs.h"
  14 #include "tf_project.h"
  15
  16 /**
  17  * @file
  18  *
  19  * Truflow Core API Header File
  20  */
  21
  22 /********** BEGIN Truflow Core DEFINITIONS **********/
  23
  24 #define TF_KILOBYTE  1024
  25 #define TF_MEGABYTE  (1024 * 1024)
  26
  27 /**
  28  * direction
  29  */
  30 enum tf_dir {
  31         TF_DIR_RX,  /**< Receive */
  32         TF_DIR_TX,  /**< Transmit */
  33         TF_DIR_MAX
  34 };
  35
  36 /**
  37  * memory choice
  38  */
  39 enum tf_mem {
  40         TF_MEM_INTERNAL, /**< Internal */
  41         TF_MEM_EXTERNAL, /**< External */
  42         TF_MEM_MAX
  43 };
  44
  45 /**
  46  * External memory control channel type
  47  */
  48 enum tf_ext_mem_chan_type {
  49         /**
  50          * Direct memory write(Wh+/SR)
  51          */
  52         TF_EXT_MEM_CHAN_TYPE_DIRECT = 0,
  53         /**
  54          * Ring interface MPC
  55          */
  56         TF_EXT_MEM_CHAN_TYPE_RING_IF,
  57         /**
  58          * Use HWRM message to firmware
  59          */
  60         TF_EXT_MEM_CHAN_TYPE_FW,
  61         /**
  62          * Use ring_if message to firmware
  63          */
  64         TF_EXT_MEM_CHAN_TYPE_RING_IF_FW,
  65         TF_EXT_MEM_CHAN_TYPE_MAX
  66 };
  67
  68 /**
  69  * EEM record AR helper
  70  *
  71  * Helper to handle the Action Record Pointer in the EEM Record Entry.
  72  *
  73  * Convert absolute offset to action record pointer in EEM record entry
  74  * Convert action record pointer in EEM record entry to absolute offset
  75  */
  76 #define TF_ACT_REC_OFFSET_2_PTR(offset) ((offset) >> 4)
  77 #define TF_ACT_REC_PTR_2_OFFSET(offset) ((offset) << 4)
  78
  79 /*
  80  * Helper Macros
  81  */
  82 #define TF_BITS_2_BYTES(num_bits) (((num_bits) + 7) / 8)
  83
  84 /********** BEGIN API FUNCTION PROTOTYPES/PARAMETERS **********/
  85
  86 /**
  87  * @page general General
  88  *
  89  * @ref tf_open_session
  90  *
  91  * @ref tf_attach_session
  92  *
  93  * @ref tf_close_session
  94  */
  95
  96 /**
  97  * Session Version defines
  98  *
  99  * The version controls the format of the tf_session and
 100  * tf_session_info structure. This is to assure upgrade between
 101  * versions can be supported.
 102  */
 103 #define TF_SESSION_VER_MAJOR  1   /**< Major Version */
 104 #define TF_SESSION_VER_MINOR  0   /**< Minor Version */
 105 #define TF_SESSION_VER_UPDATE 0   /**< Update Version */
 106
 107 /**
 108  * Session Name
 109  *
 110  * Name of the TruFlow control channel interface.  Expects
 111  * format to be RTE Name specific, i.e. rte_eth_dev_get_name_by_port()
 112  */
 113 #define TF_SESSION_NAME_MAX       64
 114
 115 #define TF_FW_SESSION_ID_INVALID  0xFF  /**< Invalid FW Session ID define */
 116
 117 /**
 118  * Session Identifier
 119  *
 120  * Unique session identifier which includes PCIe bus info to
 121  * distinguish the PF and session info to identify the associated
 122  * TruFlow session. Session ID is constructed from the passed in
 123  * ctrl_chan_name in tf_open_session() together with an allocated
 124  * fw_session_id. Done by TruFlow on tf_open_session().
 125  */
 126 union tf_session_id {
 127         uint32_t id;
 128         struct {
 129                 uint8_t domain;
 130                 uint8_t bus;
 131                 uint8_t device;
 132                 uint8_t fw_session_id;
 133         } internal;
 134 };
 135
 136 /**
 137  * Session Client Identifier
 138  *
 139  * Unique identifier for a client within a session. Session Client ID
 140  * is constructed from the passed in session and a firmware allocated
 141  * fw_session_client_id. Done by TruFlow on tf_open_session().
 142  */
 143 union tf_session_client_id {
 144         uint16_t id;
 145         struct {
 146                 uint8_t fw_session_id;
 147                 uint8_t fw_session_client_id;
 148         } internal;
 149 };
 150
 151 /**
 152  * Session Version
 153  *
 154  * The version controls the format of the tf_session and
 155  * tf_session_info structure. This is to assure upgrade between
 156  * versions can be supported.
 157  *
 158  * Please see the TF_VER_MAJOR/MINOR and UPDATE defines.
 159  */
 160 struct tf_session_version {
 161         uint8_t major;
 162         uint8_t minor;
 163         uint8_t update;
 164 };
 165
 166 /**
 167  * Session supported device types
 168  */
 169 enum tf_device_type {
 170         TF_DEVICE_TYPE_WH = 0, /**< Whitney+  */
 171         TF_DEVICE_TYPE_SR,     /**< Stingray  */
 172         TF_DEVICE_TYPE_THOR,   /**< Thor      */
 173         TF_DEVICE_TYPE_MAX     /**< Maximum   */
 174 };
 175
 176 /**
 177  * Module types
 178  */
 179 enum tf_module_type {
 180         /**
 181          * Identifier module
 182          */
 183         TF_MODULE_TYPE_IDENTIFIER,
 184         /**
 185          * Table type module
 186          */
 187         TF_MODULE_TYPE_TABLE,
 188         /**
 189          * TCAM module
 190          */
 191         TF_MODULE_TYPE_TCAM,
 192         /**
 193          * EM module
 194          */
 195         TF_MODULE_TYPE_EM,
 196         TF_MODULE_TYPE_MAX
 197 };
 198
 199 /**
 200  * Identifier resource types
 201  */
 202 enum tf_identifier_type {
 203         /**
 204          *  WH/SR/TH
 205          *  The L2 Context is returned from the L2 Ctxt TCAM lookup
 206          *  and can be used in WC TCAM or EM keys to virtualize further
 207          *  lookups.
 208          */
 209         TF_IDENT_TYPE_L2_CTXT_HIGH,
 210         /**
 211          *  WH/SR/TH
 212          *  The L2 Context is returned from the L2 Ctxt TCAM lookup
 213          *  and can be used in WC TCAM or EM keys to virtualize further
 214          *  lookups.
 215          */
 216         TF_IDENT_TYPE_L2_CTXT_LOW,
 217         /**
 218          *  WH/SR/TH
 219          *  The WC profile func is returned from the L2 Ctxt TCAM lookup
 220          *  to enable virtualization of the profile TCAM.
 221          */
 222         TF_IDENT_TYPE_PROF_FUNC,
 223         /**
 224          *  WH/SR/TH
 225          *  The WC profile ID is included in the WC lookup key
 226          *  to enable virtualization of the WC TCAM hardware.
 227          */
 228         TF_IDENT_TYPE_WC_PROF,
 229         /**
 230          *  WH/SR/TH
 231          *  The EM profile ID is included in the EM lookup key
 232          *  to enable virtualization of the EM hardware.
 233          */
 234         TF_IDENT_TYPE_EM_PROF,
 235         /**
 236          *  TH
 237          *  The L2 func is included in the ILT result and from recycling to
 238          *  enable virtualization of further lookups.
 239          */
 240         TF_IDENT_TYPE_L2_FUNC,
 241         TF_IDENT_TYPE_MAX
 242 };
 243
 244 /**
 245  * Enumeration of TruFlow table types. A table type is used to identify a
 246  * resource object.
 247  *
 248  * NOTE: The table type TF_TBL_TYPE_EXT is unique in that it is
 249  * the only table type that is connected with a table scope.
 250  */
 251 enum tf_tbl_type {
 252         /* Internal */
 253
 254         /** Wh+/SR/TH Action Record */
 255         TF_TBL_TYPE_FULL_ACT_RECORD,
 256         /** TH Compact Action Record */
 257         TF_TBL_TYPE_COMPACT_ACT_RECORD,
 258         /** (Future) Multicast Groups */
 259         TF_TBL_TYPE_MCAST_GROUPS,
 260         /** Wh+/SR/TH Action Encap 8 Bytes */
 261         TF_TBL_TYPE_ACT_ENCAP_8B,
 262         /** Wh+/SR/TH Action Encap 16 Bytes */
 263         TF_TBL_TYPE_ACT_ENCAP_16B,
 264         /** WH+/SR/TH Action Encap 32 Bytes */
 265         TF_TBL_TYPE_ACT_ENCAP_32B,
 266         /** Wh+/SR/TH Action Encap 64 Bytes */
 267         TF_TBL_TYPE_ACT_ENCAP_64B,
 268         /** WH+/SR/TH Action Source Properties SMAC */
 269         TF_TBL_TYPE_ACT_SP_SMAC,
 270         /** Wh+/SR/TH Action Source Properties SMAC IPv4 */
 271         TF_TBL_TYPE_ACT_SP_SMAC_IPV4,
 272         /** WH+/SR/TH Action Source Properties SMAC IPv6 */
 273         TF_TBL_TYPE_ACT_SP_SMAC_IPV6,
 274         /** Wh+/SR/TH Action Statistics 64 Bits */
 275         TF_TBL_TYPE_ACT_STATS_64,
 276         /** Wh+/SR Action Modify IPv4 Source */
 277         TF_TBL_TYPE_ACT_MODIFY_IPV4,
 278         /** TH 8B Modify Record */
 279         TF_TBL_TYPE_ACT_MODIFY_8B,
 280         /** TH 16B Modify Record */
 281         TF_TBL_TYPE_ACT_MODIFY_16B,
 282         /** TH 32B Modify Record */
 283         TF_TBL_TYPE_ACT_MODIFY_32B,
 284         /** TH 64B Modify Record */
 285         TF_TBL_TYPE_ACT_MODIFY_64B,
 286         /** (Future) Meter Profiles */
 287         TF_TBL_TYPE_METER_PROF,
 288         /** (Future) Meter Instance */
 289         TF_TBL_TYPE_METER_INST,
 290         /** Wh+/SR/Th Mirror Config */
 291         TF_TBL_TYPE_MIRROR_CONFIG,
 292         /** (Future) UPAR */
 293         TF_TBL_TYPE_UPAR,
 294         /** (Future) TH Metadata  */
 295         TF_TBL_TYPE_METADATA,
 296         /** (Future) TH CT State  */
 297         TF_TBL_TYPE_CT_STATE,
 298         /** (Future) TH Range Profile  */
 299         TF_TBL_TYPE_RANGE_PROF,
 300         /** TH EM Flexible Key builder */
 301         TF_TBL_TYPE_EM_FKB,
 302         /** TH WC Flexible Key builder */
 303         TF_TBL_TYPE_WC_FKB,
 304
 305         /* External */
 306
 307         /**
 308          * External table type - initially 1 poolsize entries.
 309          * All External table types are associated with a table
 310          * scope. Internal types are not.  Currently this is
 311          * a pool of 64B entries.
 312          */
 313         TF_TBL_TYPE_EXT,
 314         TF_TBL_TYPE_MAX
 315 };
 316
 317 /** Enable Shared TCAM Management
 318  *
 319  *  This feature allows for management of high and low pools within
 320  *  the WC TCAM.  These pools are only valid when this feature is enabled.
 321  *
 322  *  For normal OVS-DPDK operation, this feature is not required and can
 323  *  be disabled by commenting out TF_TCAM_SHARED in this header file.
 324  *
 325  *  Operation:
 326  *
 327  *  When a shared session is created with WC TCAM entries allocated during
 328  *  tf_open_session(), the TF_TCAM_TBL_TYPE_WC_TCAM pool entries will be divided
 329  *  into 2 equal pools - TF_TCAM_TBL_TYPE_WC_TCAM_HIGH and
 330  *  TF_TCAM_TBL_TYPE_WC_TCAM_LOW.
 331  *
 332  *  The user will allocate and free entries from either of these pools to obtain
 333  *  WC_TCAM entry offsets.  For the WC_TCAM_HI/LO management, alloc/free is done
 334  *  using the tf_alloc_tcam_entry()/tf_free_tcam_entry() APIs for the shared
 335  *  session.
 336  *
 337  *  The use case for this feature is so that applications can have a shared
 338  *  session and use the TF core to allocate/set/free entries within a given
 339  *  region of the WC_TCAM within the shared session.  Application A only writes
 340  *  to the LOW region for example and Application B only writes to the HIGH
 341  *  region during normal operation.  After Application A goes down, Application
 342  *  B may decide to overwrite the LOW region with the HIGH region's entries
 343  *  and switch to the low region.
 344  *
 345  *  For other TCAM types in the  shared session, no alloc/free operations are
 346  *  permitted. Only set should be used for other TCAM table types after getting
 347  *  the range as provided by the tf_get_resource_info() API.
 348  *
 349  */
 350 #define TF_TCAM_SHARED 1
 351
 352 /**
 353  * TCAM table type
 354  */
 355 enum tf_tcam_tbl_type {
 356         /** L2 Context TCAM */
 357         TF_TCAM_TBL_TYPE_L2_CTXT_TCAM_HIGH,
 358         /** L2 Context TCAM */
 359         TF_TCAM_TBL_TYPE_L2_CTXT_TCAM_LOW,
 360         /** Profile TCAM */
 361         TF_TCAM_TBL_TYPE_PROF_TCAM,
 362         /** Wildcard TCAM */
 363         TF_TCAM_TBL_TYPE_WC_TCAM,
 364         /** Source Properties TCAM */
 365         TF_TCAM_TBL_TYPE_SP_TCAM,
 366         /** Connection Tracking Rule TCAM */
 367         TF_TCAM_TBL_TYPE_CT_RULE_TCAM,
 368         /** Virtual Edge Bridge TCAM */
 369         TF_TCAM_TBL_TYPE_VEB_TCAM,
 370 #ifdef TF_TCAM_SHARED
 371         /** Wildcard TCAM HI Priority */
 372         TF_TCAM_TBL_TYPE_WC_TCAM_HIGH,
 373         /** Wildcard TCAM Low Priority */
 374         TF_TCAM_TBL_TYPE_WC_TCAM_LOW,
 375 #endif /* TF_TCAM_SHARED */
 376         TF_TCAM_TBL_TYPE_MAX
 377 };
 378
 379 /**
 380  * SEARCH STATUS
 381  */
 382 enum tf_search_status {
 383         /** The entry was not found, but an idx was allocated if requested. */
 384         MISS,
 385         /** The entry was found, and the result/idx are valid */
 386         HIT,
 387         /** The entry was not found and the table is full */
 388         REJECT
 389 };
 390
 391 /**
 392  * EM Resources
 393  * These defines are provisioned during
 394  * tf_open_session()
 395  */
 396 enum tf_em_tbl_type {
 397         /** The number of internal EM records for the session */
 398         TF_EM_TBL_TYPE_EM_RECORD,
 399         /** The number of table scopes reequested */
 400         TF_EM_TBL_TYPE_TBL_SCOPE,
 401         TF_EM_TBL_TYPE_MAX
 402 };
 403
 404 /**
 405  * TruFlow Session Information
 406  *
 407  * Structure defining a TruFlow Session, also known as a Management
 408  * session. This structure is initialized at time of
 409  * tf_open_session(). It is passed to all of the TruFlow APIs as way
 410  * to prescribe and isolate resources between different TruFlow ULP
 411  * Applications.
 412  *
 413  * Ownership of the elements is split between ULP and TruFlow. Please
 414  * see the individual elements.
 415  */
 416 struct tf_session_info {
 417         /**
 418          * TrueFlow Version. Used to control the structure layout when
 419          * sharing sessions. No guarantee that a secondary process
 420          * would come from the same version of an executable.
 421          * TruFlow initializes this variable on tf_open_session().
 422          *
 423          * Owner:  TruFlow
 424          * Access: TruFlow
 425          */
 426         struct tf_session_version ver;
 427         /**
 428          * will be STAILQ_ENTRY(tf_session_info) next
 429          *
 430          * Owner:  ULP
 431          * Access: ULP
 432          */
 433         void                 *next;
 434         /**
 435          * Session ID is a unique identifier for the session. TruFlow
 436          * initializes this variable during tf_open_session()
 437          * processing.
 438          *
 439          * Owner:  TruFlow
 440          * Access: Truflow & ULP
 441          */
 442         union tf_session_id   session_id;
 443         /**
 444          * Protects access to core_data. Lock is initialized and owned
 445          * by ULP. TruFlow can access the core_data without checking
 446          * the lock.
 447          *
 448          * Owner:  ULP
 449          * Access: ULP
 450          */
 451         uint8_t               spin_lock;
 452         /**
 453          * The core_data holds the TruFlow tf_session data
 454          * structure. This memory is allocated and owned by TruFlow on
 455          * tf_open_session().
 456          *
 457          * TruFlow uses this memory for session management control
 458          * until the session is closed by ULP. Access control is done
 459          * by the spin_lock which ULP controls ahead of TruFlow API
 460          * calls.
 461          *
 462          * Please see tf_open_session_parms for specification details
 463          * on this variable.
 464          *
 465          * Owner:  TruFlow
 466          * Access: TruFlow
 467          */
 468         void                 *core_data;
 469         /**
 470          * The core_data_sz_bytes specifies the size of core_data in
 471          * bytes.
 472          *
 473          * The size is set by TruFlow on tf_open_session().
 474          *
 475          * Please see tf_open_session_parms for specification details
 476          * on this variable.
 477          *
 478          * Owner:  TruFlow
 479          * Access: TruFlow
 480          */
 481         uint32_t              core_data_sz_bytes;
 482 };
 483
 484 /**
 485  * TruFlow handle
 486  *
 487  * Contains a pointer to the session info. Allocated by ULP and passed
 488  * to TruFlow using tf_open_session(). TruFlow will populate the
 489  * session info at that time. A TruFlow Session can be used by more
 490  * than one PF/VF by using the tf_open_session().
 491  *
 492  * It is expected that ULP allocates this memory as shared memory.
 493  *
 494  * NOTE: This struct must be within the BNXT PMD struct bnxt
 495  *       (bp). This allows use of container_of() to get access to the PMD.
 496  */
 497 struct tf {
 498         struct tf_session_info *session;
 499         /**
 500          * the pointer to the parent bp struct
 501          */
 502         void *bp;
 503 };
 504
 505 /**
 506  * Identifier resource definition
 507  */
 508 struct tf_identifier_resources {
 509         /**
 510          * Array of TF Identifiers where each entry is expected to be
 511          * set to the requested resource number of that specific type.
 512          * The index used is tf_identifier_type.
 513          */
 514         uint16_t cnt[TF_IDENT_TYPE_MAX];
 515 };
 516
 517 /**
 518  * Table type resource definition
 519  */
 520 struct tf_tbl_resources {
 521         /**
 522          * Array of TF Table types where each entry is expected to be
 523          * set to the requeste resource number of that specific
 524          * type. The index used is tf_tbl_type.
 525          */
 526         uint16_t cnt[TF_TBL_TYPE_MAX];
 527 };
 528
 529 /**
 530  * TCAM type resource definition
 531  */
 532 struct tf_tcam_resources {
 533         /**
 534          * Array of TF TCAM types where each entry is expected to be
 535          * set to the requested resource number of that specific
 536          * type. The index used is tf_tcam_tbl_type.
 537          */
 538         uint16_t cnt[TF_TCAM_TBL_TYPE_MAX];
 539 };
 540
 541 /**
 542  * EM type resource definition
 543  */
 544 struct tf_em_resources {
 545         /**
 546          * Array of TF EM table types where each entry is expected to
 547          * be set to the requested resource number of that specific
 548          * type. The index used is tf_em_tbl_type.
 549          */
 550         uint16_t cnt[TF_EM_TBL_TYPE_MAX];
 551 };
 552
 553 /**
 554  * tf_session_resources parameter definition.
 555  */
 556 struct tf_session_resources {
 557         /**
 558          * [in] Requested Identifier Resources
 559          *
 560          * Number of identifier resources requested for the
 561          * session.
 562          */
 563         struct tf_identifier_resources ident_cnt[TF_DIR_MAX];
 564         /**
 565          * [in] Requested Index Table resource counts
 566          *
 567          * The number of index table resources requested for the
 568          * session.
 569          */
 570         struct tf_tbl_resources tbl_cnt[TF_DIR_MAX];
 571         /**
 572          * [in] Requested TCAM Table resource counts
 573          *
 574          * The number of TCAM table resources requested for the
 575          * session.
 576          */
 577
 578         struct tf_tcam_resources tcam_cnt[TF_DIR_MAX];
 579         /**
 580          * [in] Requested EM resource counts
 581          *
 582          * The number of internal EM table resources requested for the
 583          * session.
 584          */
 585         struct tf_em_resources em_cnt[TF_DIR_MAX];
 586 };
 587
 588 /**
 589  * tf_open_session parameters definition.
 590  */
 591 struct tf_open_session_parms {
 592         /**
 593          * [in] ctrl_chan_name
 594          *
 595          * String containing name of control channel interface to be
 596          * used for this session to communicate with firmware.
 597          *
 598          * The ctrl_chan_name can be looked up by using
 599          * rte_eth_dev_get_name_by_port() within the ULP.
 600          *
 601          * ctrl_chan_name will be used as part of a name for any
 602          * shared memory allocation. The ctrl_chan_name is usually in format
 603          * 0000:02:00.0. The name for shared session is 0000:02:00.0-tf_shared.
 604          */
 605         char ctrl_chan_name[TF_SESSION_NAME_MAX];
 606         /**
 607          * [in] shadow_copy
 608          *
 609          * Boolean controlling the use and availability of shadow
 610          * copy. Shadow copy will allow the TruFlow to keep track of
 611          * resource content on the firmware side without having to
 612          * query firmware. Additional private session core_data will
 613          * be allocated if this boolean is set to 'true', default
 614          * 'false'.
 615          *
 616          * Size of memory depends on the NVM Resource settings for the
 617          * control channel.
 618          */
 619         bool shadow_copy;
 620         /**
 621          * [in/out] session_id
 622          *
 623          * Session_id is unique per session.
 624          *
 625          * Session_id is composed of domain, bus, device and
 626          * fw_session_id. The construction is done by parsing the
 627          * ctrl_chan_name together with allocation of a fw_session_id.
 628          *
 629          * The session_id allows a session to be shared between devices.
 630          */
 631         union tf_session_id session_id;
 632         /**
 633          * [in/out] session_client_id
 634          *
 635          * Session_client_id is unique per client.
 636          *
 637          * Session_client_id is composed of session_id and the
 638          * fw_session_client_id fw_session_id. The construction is
 639          * done by parsing the ctrl_chan_name together with allocation
 640          * of a fw_session_client_id during tf_open_session().
 641          *
 642          * A reference count will be incremented in the session on
 643          * which a client is created.
 644          *
 645          * A session can first be closed if there is one Session
 646          * Client left. Session Clients should closed using
 647          * tf_close_session().
 648          */
 649         union tf_session_client_id session_client_id;
 650         /**
 651          * [in] device type
 652          *
 653          * Device type for the session.
 654          */
 655         enum tf_device_type device_type;
 656         /**
 657          * [in] resources
 658          *
 659          * Resource allocation for the session.
 660          */
 661         struct tf_session_resources resources;
 662
 663         /**
 664          * [in] bp
 665          * The pointer to the parent bp struct. This is only used for HWRM
 666          * message passing within the portability layer. The type is struct
 667          * bnxt.
 668          */
 669         void *bp;
 670
 671         /**
 672          * [out] shared_session_creator
 673          *
 674          * Indicates whether the application created the session if set.
 675          * Otherwise the shared session already existed.  Just for information
 676          * purposes.
 677          */
 678         int shared_session_creator;
 679 };
 680
 681 /**
 682  * Opens a new TruFlow Session or session client.
 683  *
 684  * What gets created depends on the passed in tfp content. If the tfp does not
 685  * have prior session data a new session with associated session client. If tfp
 686  * has a session already a session client will be created. In both cases the
 687  * session client is created using the provided ctrl_chan_name.
 688  *
 689  * In case of session creation TruFlow will allocate session specific memory to
 690  * hold its session data. This data is private to TruFlow.
 691  *
 692  * No other TruFlow APIs will succeed unless this API is first called
 693  * and succeeds.
 694  *
 695  * tf_open_session() returns a session id and session client id.  These are
 696  * also stored within the tfp structure passed in to all other APIs.
 697  *
 698  * A Session or session client can be closed using tf_close_session().
 699  *
 700  * There are 2 types of sessions - shared and not.  For non-shared all
 701  * the allocated resources are owned and managed by a single session instance.
 702  * No other applications have access to the resources owned by the non-shared
 703  * session.  For a shared session, resources are shared between 2 applications.
 704  *
 705  * When the caller of tf_open_session() sets the ctrl_chan_name[] to a name
 706  * like "0000:02:00.0-tf_shared", it is a request to create a new "shared"
 707  * session in the firmware or access the existing shared session. There is
 708  * only 1 shared session that can be created. If the shared session has
 709  * already been created in the firmware, this API will return this indication
 710  * by clearing the shared_session_creator flag. Only the first shared session
 711  * create will have the shared_session_creator flag set.
 712  *
 713  * The shared session should always be the first session to be created by
 714  * application and the last session closed due to RM management preference.
 715  *
 716  * Sessions remain open in the firmware until the last client of the session
 717  * closes the session (tf_close_session()).
 718  *
 719  * [in] tfp
 720  *   Pointer to TF handle
 721  *
 722  * [in] parms
 723  *   Pointer to open parameters
 724  *
 725  * Returns
 726  *   - (0) if successful.
 727  *   - (-EINVAL) on failure.
 728  */
 729 int tf_open_session(struct tf *tfp,
 730                     struct tf_open_session_parms *parms);
 731
 732 /**
 733  * General internal resource info
 734  *
 735  * TODO: remove tf_rm_new_entry structure and use this structure
 736  * internally.
 737  */
 738 struct tf_resource_info {
 739         uint16_t start;
 740         uint16_t stride;
 741 };
 742
 743 /**
 744  * Identifier resource definition
 745  */
 746 struct tf_identifier_resource_info {
 747         /**
 748          * Array of TF Identifiers. The index used is tf_identifier_type.
 749          */
 750         struct tf_resource_info info[TF_IDENT_TYPE_MAX];
 751 };
 752
 753 /**
 754  * Table type resource info definition
 755  */
 756 struct tf_tbl_resource_info {
 757         /**
 758          * Array of TF Table types. The index used is tf_tbl_type.
 759          */
 760         struct tf_resource_info info[TF_TBL_TYPE_MAX];
 761 };
 762
 763 /**
 764  * TCAM type resource definition
 765  */
 766 struct tf_tcam_resource_info {
 767         /**
 768          * Array of TF TCAM types. The index used is tf_tcam_tbl_type.
 769          */
 770         struct tf_resource_info info[TF_TCAM_TBL_TYPE_MAX];
 771 };
 772
 773 /**
 774  * EM type resource definition
 775  */
 776 struct tf_em_resource_info {
 777         /**
 778          * Array of TF EM table types. The index used is tf_em_tbl_type.
 779          */
 780         struct tf_resource_info info[TF_EM_TBL_TYPE_MAX];
 781 };
 782
 783 /**
 784  * tf_session_resources parameter definition.
 785  */
 786 struct tf_session_resource_info {
 787         /**
 788          * [in] Requested Identifier Resources
 789          *
 790          * Number of identifier resources requested for the
 791          * session.
 792          */
 793         struct tf_identifier_resource_info ident[TF_DIR_MAX];
 794         /**
 795          * [in] Requested Index Table resource counts
 796          *
 797          * The number of index table resources requested for the
 798          * session.
 799          */
 800         struct tf_tbl_resource_info tbl[TF_DIR_MAX];
 801         /**
 802          * [in] Requested TCAM Table resource counts
 803          *
 804          * The number of TCAM table resources requested for the
 805          * session.
 806          */
 807
 808         struct tf_tcam_resource_info tcam[TF_DIR_MAX];
 809         /**
 810          * [in] Requested EM resource counts
 811          *
 812          * The number of internal EM table resources requested for the
 813          * session.
 814          */
 815         struct tf_em_resource_info em[TF_DIR_MAX];
 816 };
 817
 818 /**
 819  * tf_get_session_resources parameter definition.
 820  */
 821 struct tf_get_session_info_parms {
 822         /**
 823          * [out] the structure is used to return the information of
 824          * allocated resources.
 825          *
 826          */
 827         struct tf_session_resource_info session_info;
 828 };
 829
 830 /** (experimental)
 831  * Gets info about a TruFlow Session
 832  *
 833  * Get info about the session which has been created.  Whether it exists and
 834  * what resource start and stride offsets are in use.  This API is primarily
 835  * intended to be used by an application which has created a shared session
 836  * This application needs to obtain the resources which have already been
 837  * allocated for the shared session.
 838  *
 839  * [in] tfp
 840  *   Pointer to TF handle
 841  *
 842  * [in] parms
 843  *   Pointer to get parameters
 844  *
 845  * Returns
 846  *   - (0) if successful.
 847  *   - (-EINVAL) on failure.
 848  */
 849 int tf_get_session_info(struct tf *tfp,
 850                         struct tf_get_session_info_parms *parms);
 851 /**
 852  * Experimental
 853  *
 854  * tf_attach_session parameters definition.
 855  */
 856 struct tf_attach_session_parms {
 857         /**
 858          * [in] ctrl_chan_name
 859          *
 860          * String containing name of control channel interface to be
 861          * used for this session to communicate with firmware.
 862          *
 863          * The ctrl_chan_name can be looked up by using
 864          * rte_eth_dev_get_name_by_port() within the ULP.
 865          *
 866          * ctrl_chan_name will be used as part of a name for any
 867          * shared memory allocation.
 868          */
 869         char ctrl_chan_name[TF_SESSION_NAME_MAX];
 870
 871         /**
 872          * [in] attach_chan_name
 873          *
 874          * String containing name of attach channel interface to be
 875          * used for this session.
 876          *
 877          * The attach_chan_name must be given to a 2nd process after
 878          * the primary process has been created. This is the
 879          * ctrl_chan_name of the primary process and is used to find
 880          * the shared memory for the session that the attach is going
 881          * to use.
 882          */
 883         char attach_chan_name[TF_SESSION_NAME_MAX];
 884
 885         /**
 886          * [in] session_id
 887          *
 888          * Session_id is unique per session. For Attach the session_id
 889          * should be the session_id that was returned on the first
 890          * open.
 891          *
 892          * Session_id is composed of domain, bus, device and
 893          * fw_session_id. The construction is done by parsing the
 894          * ctrl_chan_name together with allocation of a fw_session_id
 895          * during tf_open_session().
 896          *
 897          * A reference count will be incremented on attach. A session
 898          * is first fully closed when reference count is zero by
 899          * calling tf_close_session().
 900          */
 901         union tf_session_id session_id;
 902 };
 903
 904 /**
 905  * Experimental
 906  *
 907  * Allows a 2nd application instance to attach to an existing
 908  * session. Used when a session is to be shared between two processes.
 909  *
 910  * Attach will increment a ref count as to manage the shared session data.
 911  *
 912  * [in] tfp
 913  *   Pointer to TF handle
 914  *
 915  * [in] parms
 916  *   Pointer to attach parameters
 917  *
 918  * Returns
 919  *   - (0) if successful.
 920  *   - (-EINVAL) on failure.
 921  */
 922 int tf_attach_session(struct tf *tfp,
 923                       struct tf_attach_session_parms *parms);
 924
 925 /**
 926  * Closes an existing session client or the session it self. The
 927  * session client is default closed and if the session reference count
 928  * is 0 then the session is closed as well.
 929  *
 930  * On session close all hardware and firmware state associated with
 931  * the TruFlow application is cleaned up.
 932  *
 933  * The session client is extracted from the tfp. Thus tf_close_session()
 934  * cannot close a session client on behalf of another function.
 935  *
 936  * Returns success or failure code.
 937  */
 938 int tf_close_session(struct tf *tfp);
 939
 940 /**
 941  * @page  ident Identity Management
 942  *
 943  * @ref tf_alloc_identifier
 944  *
 945  * @ref tf_free_identifier
 946  */
 947 /**
 948  * tf_alloc_identifier parameter definition
 949  */
 950 struct tf_alloc_identifier_parms {
 951         /**
 952          * [in]  receive or transmit direction
 953          */
 954         enum tf_dir dir;
 955         /**
 956          * [in] Identifier type
 957          */
 958         enum tf_identifier_type ident_type;
 959         /**
 960          * [out] Allocated identifier
 961          */
 962         uint32_t id;
 963 };
 964
 965 /**
 966  * tf_free_identifier parameter definition
 967  */
 968 struct tf_free_identifier_parms {
 969         /**
 970          * [in]  receive or transmit direction
 971          */
 972         enum tf_dir dir;
 973         /**
 974          * [in] Identifier type
 975          */
 976         enum tf_identifier_type ident_type;
 977         /**
 978          * [in] ID to free
 979          */
 980         uint32_t id;
 981         /**
 982          * (experimental)
 983          * [out] Current refcnt after free
 984          */
 985         uint32_t ref_cnt;
 986 };
 987
 988 /**
 989  * tf_search_identifier parameter definition (experimental)
 990  */
 991 struct tf_search_identifier_parms {
 992         /**
 993          * [in]  receive or transmit direction
 994          */
 995         enum tf_dir dir;
 996         /**
 997          * [in] Identifier type
 998          */
 999         enum tf_identifier_type ident_type;
1000         /**
1001          * [in] Identifier data to search for
1002          */
1003         uint32_t search_id;
1004         /**
1005          * [out] Set if matching identifier found
1006          */
1007         bool hit;
1008         /**
1009          * [out] Current ref count after allocation
1010          */
1011         uint32_t ref_cnt;
1012 };
1013
1014 /**
1015  * allocate identifier resource
1016  *
1017  * TruFlow core will allocate a free id from the per identifier resource type
1018  * pool reserved for the session during tf_open().  No firmware is involved.
1019  *
1020  * If shadow copy is enabled, the internal ref_cnt is set to 1 in the
1021  * shadow table for a newly allocated resource.
1022  *
1023  * Returns success or failure code.
1024  */
1025 int tf_alloc_identifier(struct tf *tfp,
1026                         struct tf_alloc_identifier_parms *parms);
1027
1028 /**
1029  * free identifier resource
1030  *
1031  * TruFlow core will return an id back to the per identifier resource type pool
1032  * reserved for the session.  No firmware is involved.  During tf_close, the
1033  * complete pool is returned to the firmware.
1034  *
1035  * additional operation (experimental)
1036  * Decrement reference count.  Only release resource once refcnt goes to 0 if
1037  * shadow copy is enabled.
1038  *
1039  * Returns success or failure code.
1040  */
1041 int tf_free_identifier(struct tf *tfp,
1042                        struct tf_free_identifier_parms *parms);
1043
1044 /**
1045  * Search identifier resource (experimental)
1046  *
1047  * If the shadow copy is enabled search_id is used to search for a matching
1048  * entry in the shadow table.  The shadow table consists of an array of
1049  * reference counts indexed by identifier.  If a matching entry is found hit is
1050  * set to TRUE, refcnt is increased by 1 and returned.  Otherwise, hit is
1051  * set to false and refcnt is set to 0.
1052  *
1053  * TODO: we may need a per table internal shadow copy enable flag to stage
1054  * the shadow table implementation.  We do not need the shadow table for other
1055  * tables at this time so we may only want to enable the identifier shadow.
1056  *
1057  * TODO: remove this pseudocode below added to show that if search fails
1058  * we shouldn't allocate a new entry but return.
1059  *
1060  * identifier alloc (search_en=1)
1061  * if (ident is allocated and ref_cnt >=1)
1062  *      return ident - hit is set, incr refcnt
1063  * else (not found)
1064  *      return
1065  *
1066  */
1067 int tf_search_identifier(struct tf *tfp,
1068                          struct tf_search_identifier_parms *parms);
1069
1070 /**
1071  * @page dram_table DRAM Table Scope Interface
1072  *
1073  * @ref tf_alloc_tbl_scope
1074  *
1075  * @ref tf_free_tbl_scope
1076  *
1077  * If we allocate the EEM memory from the core, we need to store it in
1078  * the shared session data structure to make sure it can be freed later.
1079  * (for example if the PF goes away)
1080  *
1081  * Current thought is that memory is allocated within core.
1082  */
1083
1084 /**
1085  * tf_alloc_tbl_scope_parms definition
1086  */
1087 struct tf_alloc_tbl_scope_parms {
1088         /**
1089          * [in] All Maximum key size required.
1090          */
1091         uint16_t rx_max_key_sz_in_bits;
1092         /**
1093          * [in] Maximum Action size required (includes inlined items)
1094          */
1095         uint16_t rx_max_action_entry_sz_in_bits;
1096         /**
1097          * [in] Memory size in Megabytes
1098          * Total memory size allocated by user to be divided
1099          * up for actions, hash, counters.  Only inline external actions.
1100          * Use this variable or the number of flows, do not set both.
1101          */
1102         uint32_t rx_mem_size_in_mb;
1103         /**
1104          * [in] Number of flows * 1000. If set, rx_mem_size_in_mb must equal 0.
1105          */
1106         uint32_t rx_num_flows_in_k;
1107         /**
1108          * [in] SR2 only receive table access interface id
1109          */
1110         uint32_t rx_tbl_if_id;
1111         /**
1112          * [in] All Maximum key size required.
1113          */
1114         uint16_t tx_max_key_sz_in_bits;
1115         /**
1116          * [in] Maximum Action size required (includes inlined items)
1117          */
1118         uint16_t tx_max_action_entry_sz_in_bits;
1119         /**
1120          * [in] Memory size in Megabytes
1121          * Total memory size allocated by user to be divided
1122          * up for actions, hash, counters.  Only inline external actions.
1123          */
1124         uint32_t tx_mem_size_in_mb;
1125         /**
1126          * [in] Number of flows * 1000
1127          */
1128         uint32_t tx_num_flows_in_k;
1129         /**
1130          * [in] SR2 only receive table access interface id
1131          */
1132         uint32_t tx_tbl_if_id;
1133         /**
1134          * [in] Flush pending HW cached flows every 1/10th of value
1135          * set in seconds, both idle and active flows are flushed
1136          * from the HW cache. If set to 0, this feature will be disabled.
1137          */
1138         uint8_t hw_flow_cache_flush_timer;
1139         /**
1140          * [out] table scope identifier
1141          */
1142         uint32_t tbl_scope_id;
1143 };
1144 /**
1145  * tf_free_tbl_scope_parms definition
1146  */
1147 struct tf_free_tbl_scope_parms {
1148         /**
1149          * [in] table scope identifier
1150          */
1151         uint32_t tbl_scope_id;
1152 };
1153
1154 /**
1155  * tf_map_tbl_scope_parms definition
1156  */
1157 struct tf_map_tbl_scope_parms {
1158         /**
1159          * [in] table scope identifier
1160          */
1161         uint32_t tbl_scope_id;
1162         /**
1163          * [in] Which parifs are associated with this table scope.  Bit 0
1164          *      indicates parif 0.
1165          */
1166         uint16_t parif_bitmask;
1167 };
1168
1169 /**
1170  * allocate a table scope
1171  *
1172  * The scope is a software construct to identify an EEM table.  This function will
1173  * divide the hash memory/buckets and records according to the device
1174  * device constraints based upon calculations using either the number of flows
1175  * requested or the size of memory indicated.  Other parameters passed in
1176  * determine the configuration (maximum key size, maximum external action record
1177  * size).
1178  *
1179  * A single API is used to allocate a common table scope identifier in both
1180  * receive and transmit CFA. The scope identifier is common due to nature of
1181  * connection tracking sending notifications between RX and TX direction.
1182  *
1183  * The receive and transmit table access identifiers specify which rings will
1184  * be used to initialize table DRAM.  The application must ensure mutual
1185  * exclusivity of ring usage for table scope allocation and any table update
1186  * operations.
1187  *
1188  * The hash table buckets, EM keys, and EM lookup results are stored in the
1189  * memory allocated based on the rx_em_hash_mb/tx_em_hash_mb parameters.  The
1190  * hash table buckets are stored at the beginning of that memory.
1191  *
1192  * NOTE:  No EM internal setup is done here. On chip EM records are managed
1193  * internally by TruFlow core.
1194  *
1195  * Returns success or failure code.
1196  */
1197 int tf_alloc_tbl_scope(struct tf *tfp,
1198                        struct tf_alloc_tbl_scope_parms *parms);
1199
1200 /**
1201  * map a table scope (legacy device only Wh+/SR)
1202  *
1203  * Map a table scope to one or more partition interfaces (parifs).
1204  * The parif can be remapped in the L2 context lookup for legacy devices.  This
1205  * API allows a number of parifs to be mapped to the same table scope.  On
1206  * legacy devices a table scope identifies one of 16 sets of EEM table base
1207  * addresses and is associated with a PF communication channel.  The associated
1208  * PF must be configured for the table scope to operate.
1209  *
1210  * An L2 context TCAM lookup returns a remapped parif value used to
1211  * index into the set of 16 parif_to_pf registers which are used to map to one
1212  * of the 16 table scopes.  This API allows the user to map the parifs in the
1213  * mask to the previously allocated table scope (EEM table).
1214
1215  * Returns success or failure code.
1216  */
1217 int tf_map_tbl_scope(struct tf *tfp,
1218                       struct tf_map_tbl_scope_parms *parms);
1219 /**
1220  * free a table scope
1221  *
1222  * Firmware checks that the table scope ID is owned by the TruFlow
1223  * session, verifies that no references to this table scope remains
1224  * or Profile TCAM entries for either CFA (RX/TX) direction,
1225  * then frees the table scope ID.
1226  *
1227  * Returns success or failure code.
1228  */
1229 int tf_free_tbl_scope(struct tf *tfp,
1230                       struct tf_free_tbl_scope_parms *parms);
1231
1232 /**
1233  * @page tcam TCAM Access
1234  *
1235  * @ref tf_search_tcam_entry
1236  *
1237  * @ref tf_alloc_tcam_entry
1238  *
1239  * @ref tf_set_tcam_entry
1240  *
1241  * @ref tf_get_tcam_entry
1242  *
1243  * @ref tf_free_tcam_entry
1244  *
1245 #ifdef TF_TCAM_SHARED
1246  * @ref tf_move_tcam_shared_entries
1247 #endif
1248  */
1249
1250 /**
1251  * tf_search_tcam_entry parameter definition (experimental)
1252  */
1253 struct tf_search_tcam_entry_parms {
1254         /**
1255          * [in] receive or transmit direction
1256          */
1257         enum tf_dir dir;
1258         /**
1259          * [in] TCAM table type
1260          */
1261         enum tf_tcam_tbl_type tcam_tbl_type;
1262         /**
1263          * [in] Key data to match on
1264          */
1265         uint8_t *key;
1266         /**
1267          * [in] key size in bits
1268          */
1269         uint16_t key_sz_in_bits;
1270         /**
1271          * [in] Mask data to match on
1272          */
1273         uint8_t *mask;
1274         /**
1275          * [in] Priority of entry requested (definition TBD)
1276          */
1277         uint32_t priority;
1278         /**
1279          * [in] Allocate on miss.
1280          */
1281         uint8_t alloc;
1282         /**
1283          * [out] Set if matching entry found
1284          */
1285         uint8_t hit;
1286         /**
1287          * [out] Search result status (hit, miss, reject)
1288          */
1289         enum tf_search_status search_status;
1290         /**
1291          * [out] Current refcnt after allocation
1292          */
1293         uint16_t ref_cnt;
1294         /**
1295          * [in out] The result data from the search is copied here
1296          */
1297         uint8_t *result;
1298         /**
1299          * [in out] result size in bits for the result data
1300          */
1301         uint16_t result_sz_in_bits;
1302         /**
1303          * [out] Index found
1304          */
1305         uint16_t idx;
1306 };
1307
1308 /**
1309  * search TCAM entry (experimental)
1310  *
1311  * Search for a TCAM entry
1312  *
1313  * This function searches the shadow copy of the TCAM table for a matching
1314  * entry.  Key and mask must match for hit to be set.  Only TruFlow core data
1315  * is accessed.  If shadow_copy is not enabled, an error is returned.
1316  *
1317  * Implementation:
1318  *
1319  * A hash is performed on the key/mask data and mapped to a shadow copy entry
1320  * where the full key/mask is populated.  If the full key/mask matches the
1321  * entry, hit is set, ref_cnt is incremented, and search_status indicates what
1322  * action the caller can take regarding setting the entry.
1323  *
1324  * search_status should be used as follows:
1325  * - On Miss, the caller should create a result and call tf_set_tcam_entry with
1326  * returned index.
1327  *
1328  * - On Reject, the hash table is full and the entry cannot be added.
1329  *
1330  * - On Hit, the result data is returned to the caller.  Additionally, the
1331  * ref_cnt is updated.
1332  *
1333  * Also returns success or failure code.
1334  */
1335 int tf_search_tcam_entry(struct tf *tfp,
1336                          struct tf_search_tcam_entry_parms *parms);
1337
1338 /**
1339  * tf_alloc_tcam_entry parameter definition
1340  */
1341 struct tf_alloc_tcam_entry_parms {
1342         /**
1343          * [in] receive or transmit direction
1344          */
1345         enum tf_dir dir;
1346         /**
1347          * [in] TCAM table type
1348          */
1349         enum tf_tcam_tbl_type tcam_tbl_type;
1350         /**
1351          * [in] Enable search for matching entry
1352          */
1353         uint8_t search_enable;
1354         /**
1355          * [in] Key data to match on (if search)
1356          */
1357         uint8_t *key;
1358         /**
1359          * [in] key size in bits (if search)
1360          */
1361         uint16_t key_sz_in_bits;
1362         /**
1363          * [in] Mask data to match on (if search)
1364          */
1365         uint8_t *mask;
1366         /**
1367          * [in] Priority of entry requested (definition TBD)
1368          */
1369         uint32_t priority;
1370         /**
1371          * [out] If search, set if matching entry found
1372          */
1373         uint8_t hit;
1374         /**
1375          * [out] Current refcnt after allocation
1376          */
1377         uint16_t ref_cnt;
1378         /**
1379          * [out] Idx allocated
1380          *
1381          */
1382         uint16_t idx;
1383 };
1384
1385 /**
1386  * allocate TCAM entry
1387  *
1388  * Allocate a TCAM entry - one of these types:
1389  *
1390  * L2 Context
1391  * Profile TCAM
1392  * WC TCAM
1393  * VEB TCAM
1394  *
1395  * This function allocates a TCAM table record.  This function
1396  * will attempt to allocate a TCAM table entry from the session
1397  * owned TCAM entries or search a shadow copy of the TCAM table for a
1398  * matching entry if search is enabled.  Key, mask and result must match for
1399  * hit to be set.  Only TruFlow core data is accessed.
1400  * A hash table to entry mapping is maintained for search purposes.  If
1401  * search is not enabled, the first available free entry is returned based
1402  * on priority and alloc_cnt is set to 1.  If search is enabled and a matching
1403  * entry to entry_data is found, hit is set to TRUE and alloc_cnt is set to 1.
1404  * RefCnt is also returned.
1405  *
1406  * Also returns success or failure code.
1407  */
1408 int tf_alloc_tcam_entry(struct tf *tfp,
1409                         struct tf_alloc_tcam_entry_parms *parms);
1410
1411 /**
1412  * tf_set_tcam_entry parameter definition
1413  */
1414 struct  tf_set_tcam_entry_parms {
1415         /**
1416          * [in] receive or transmit direction
1417          */
1418         enum tf_dir dir;
1419         /**
1420          * [in] TCAM table type
1421          */
1422         enum tf_tcam_tbl_type tcam_tbl_type;
1423         /**
1424          * [in] base index of the entry to program
1425          */
1426         uint16_t idx;
1427         /**
1428          * [in] struct containing key
1429          */
1430         uint8_t *key;
1431         /**
1432          * [in] struct containing mask fields
1433          */
1434         uint8_t *mask;
1435         /**
1436          * [in] key size in bits (if search)
1437          */
1438         uint16_t key_sz_in_bits;
1439         /**
1440          * [in] struct containing result
1441          */
1442         uint8_t *result;
1443         /**
1444          * [in] struct containing result size in bits
1445          */
1446         uint16_t result_sz_in_bits;
1447 };
1448
1449 /**
1450  * set TCAM entry
1451  *
1452  * Program a TCAM table entry for a TruFlow session.
1453  *
1454  * If the entry has not been allocated, an error will be returned.
1455  *
1456  * Returns success or failure code.
1457  */
1458 int tf_set_tcam_entry(struct tf *tfp,
1459                       struct tf_set_tcam_entry_parms *parms);
1460
1461 /**
1462  * tf_get_tcam_entry parameter definition
1463  */
1464 struct tf_get_tcam_entry_parms {
1465         /**
1466          * [in] receive or transmit direction
1467          */
1468         enum tf_dir dir;
1469         /**
1470          * [in] TCAM table type
1471          */
1472         enum tf_tcam_tbl_type  tcam_tbl_type;
1473         /**
1474          * [in] index of the entry to get
1475          */
1476         uint16_t idx;
1477         /**
1478          * [out] struct containing key
1479          */
1480         uint8_t *key;
1481         /**
1482          * [out] struct containing mask fields
1483          */
1484         uint8_t *mask;
1485         /**
1486          * [in/out] key size in bits
1487          */
1488         uint16_t key_sz_in_bits;
1489         /**
1490          * [out] struct containing result
1491          */
1492         uint8_t *result;
1493         /**
1494          * [in/out] struct containing result size in bits
1495          */
1496         uint16_t result_sz_in_bits;
1497 };
1498
1499 /**
1500  * get TCAM entry
1501  *
1502  * Program a TCAM table entry for a TruFlow session.
1503  *
1504  * If the entry has not been allocated, an error will be returned.
1505  *
1506  * Returns success or failure code.
1507  */
1508 int tf_get_tcam_entry(struct tf *tfp,
1509                       struct tf_get_tcam_entry_parms *parms);
1510
1511 /**
1512  * tf_free_tcam_entry parameter definition
1513  */
1514 struct tf_free_tcam_entry_parms {
1515         /**
1516          * [in] receive or transmit direction
1517          */
1518         enum tf_dir dir;
1519         /**
1520          * [in] TCAM table type
1521          */
1522         enum tf_tcam_tbl_type tcam_tbl_type;
1523         /**
1524          * [in] Index to free
1525          */
1526         uint16_t idx;
1527         /**
1528          * [out] reference count after free
1529          */
1530         uint16_t ref_cnt;
1531 };
1532
1533 /**
1534  * free TCAM entry
1535  *
1536  * Free TCAM entry.
1537  *
1538  * Firmware checks to ensure the TCAM entries are owned by the TruFlow
1539  * session.  TCAM entry will be invalidated.  All-ones mask.
1540  * writes to hw.
1541  *
1542  * WCTCAM profile id of 0 must be used to invalidate an entry.
1543  *
1544  * Returns success or failure code.
1545  */
1546 int tf_free_tcam_entry(struct tf *tfp,
1547                        struct tf_free_tcam_entry_parms *parms);
1548
1549 #ifdef TF_TCAM_SHARED
1550 /**
1551  * tf_move_tcam_shared_entries parameter definition
1552  */
1553 struct tf_move_tcam_shared_entries_parms {
1554         /**
1555          * [in] receive or transmit direction
1556          */
1557         enum tf_dir dir;
1558         /**
1559          * [in] TCAM table type
1560          */
1561         enum tf_tcam_tbl_type tcam_tbl_type;
1562 };
1563
1564 /**
1565  * Move TCAM entries
1566  *
1567  * This API only affects the following TCAM pools within a shared session:
1568  *
1569  * TF_TCAM_TBL_TYPE_WC_TCAM_HIGH
1570  * TF_TCAM_TBL_TYPE_WC_TCAM_LOW
1571  *
1572  * When called, all allocated entries from the high pool will be moved to
1573  * the low pool.  Then the allocated entries in the high pool will be
1574  * cleared and freed.
1575  *
1576  * This API is not supported on a non-shared session.
1577  *
1578  * Returns success or failure code.
1579  */
1580 int tf_move_tcam_shared_entries(struct tf *tfp,
1581                                 struct tf_move_tcam_shared_entries_parms *parms);
1582
1583 #endif /* TF_TCAM_SHARED */
1584 /**
1585  * @page table Table Access
1586  *
1587  * @ref tf_alloc_tbl_entry
1588  *
1589  * @ref tf_free_tbl_entry
1590  *
1591  * @ref tf_set_tbl_entry
1592  *
1593  * @ref tf_get_tbl_entry
1594  *
1595  * @ref tf_bulk_get_tbl_entry
1596  *
1597  * @ref tf_get_shared_tbl_increment
1598  */
1599
1600 /**
1601  * tf_alloc_tbl_entry parameter definition
1602  */
1603 struct tf_search_tbl_entry_parms {
1604         /**
1605          * [in] Receive or transmit direction
1606          */
1607         enum tf_dir dir;
1608         /**
1609          * [in] Type of the allocation
1610          */
1611         enum tf_tbl_type type;
1612         /**
1613          * [in] Table scope identifier (ignored unless TF_TBL_TYPE_EXT)
1614          */
1615         uint32_t tbl_scope_id;
1616         /**
1617          * [in] Result data to search for
1618          */
1619         uint8_t *result;
1620         /**
1621          * [in] Result data size in bytes
1622          */
1623         uint16_t result_sz_in_bytes;
1624         /**
1625          * [in] Allocate on miss.
1626          */
1627         uint8_t alloc;
1628         /**
1629          * [out] Set if matching entry found
1630          */
1631         uint8_t hit;
1632         /**
1633          * [out] Search result status (hit, miss, reject)
1634          */
1635         enum tf_search_status search_status;
1636         /**
1637          * [out] Current ref count after allocation
1638          */
1639         uint16_t ref_cnt;
1640         /**
1641          * [out] Idx of allocated entry or found entry
1642          */
1643         uint32_t idx;
1644 };
1645
1646 /**
1647  * search Table Entry (experimental)
1648  *
1649  * This function searches the shadow copy of an index table for a matching
1650  * entry.  The result data must match for hit to be set.  Only TruFlow core
1651  * data is accessed.  If shadow_copy is not enabled, an error is returned.
1652  *
1653  * Implementation:
1654  *
1655  * A hash is performed on the result data and mappe3d to a shadow copy entry
1656  * where the result is populated.  If the result matches the entry, hit is set,
1657  * ref_cnt is incremented (if alloc), and the search status indicates what
1658  * action the caller can take regarding setting the entry.
1659  *
1660  * search status should be used as follows:
1661  * - On MISS, the caller should set the result into the returned index.
1662  *
1663  * - On REJECT, the caller should reject the flow since there are no resources.
1664  *
1665  * - On Hit, the matching index is returned to the caller.  Additionally, the
1666  *   ref_cnt is updated.
1667  *
1668  * Also returns success or failure code.
1669  */
1670 int tf_search_tbl_entry(struct tf *tfp,
1671                         struct tf_search_tbl_entry_parms *parms);
1672
1673 /**
1674  * tf_alloc_tbl_entry parameter definition
1675  */
1676 struct tf_alloc_tbl_entry_parms {
1677         /**
1678          * [in] Receive or transmit direction
1679          */
1680         enum tf_dir dir;
1681         /**
1682          * [in] Type of the allocation
1683          */
1684         enum tf_tbl_type type;
1685         /**
1686          * [in] Table scope identifier (ignored unless TF_TBL_TYPE_EXT)
1687          */
1688         uint32_t tbl_scope_id;
1689         /**
1690          * [in] Enable search for matching entry. If the table type is
1691          * internal the shadow copy will be searched before
1692          * alloc. Session must be configured with shadow copy enabled.
1693          */
1694         uint8_t search_enable;
1695         /**
1696          * [in] Result data to search for (if search_enable)
1697          */
1698         uint8_t *result;
1699         /**
1700          * [in] Result data size in bytes (if search_enable)
1701          */
1702         uint16_t result_sz_in_bytes;
1703         /**
1704          * [out] If search_enable, set if matching entry found
1705          */
1706         uint8_t hit;
1707         /**
1708          * [out] Current ref count after allocation (if search_enable)
1709          */
1710         uint16_t ref_cnt;
1711         /**
1712          * [out] Idx of allocated entry or found entry (if search_enable)
1713          */
1714         uint32_t idx;
1715 };
1716
1717 /**
1718  * allocate index table entries
1719  *
1720  * Internal types:
1721  *
1722  * Allocate an on chip index table entry or search for a matching
1723  * entry of the indicated type for this TruFlow session.
1724  *
1725  * Allocates an index table record. This function will attempt to
1726  * allocate an entry or search an index table for a matching entry if
1727  * search is enabled (only the shadow copy of the table is accessed).
1728  *
1729  * If search is not enabled, the first available free entry is
1730  * returned. If search is enabled and a matching entry to entry_data
1731  * is found hit is set to TRUE and success is returned.
1732  *
1733  * External types:
1734  *
1735  * These are used to allocate inlined action record memory.
1736  *
1737  * Allocates an external index table action record.
1738  *
1739  * NOTE:
1740  * Implementation of the internals of this function will be a stack with push
1741  * and pop.
1742  *
1743  * Returns success or failure code.
1744  */
1745 int tf_alloc_tbl_entry(struct tf *tfp,
1746                        struct tf_alloc_tbl_entry_parms *parms);
1747
1748 /**
1749  * tf_free_tbl_entry parameter definition
1750  */
1751 struct tf_free_tbl_entry_parms {
1752         /**
1753          * [in] Receive or transmit direction
1754          */
1755         enum tf_dir dir;
1756         /**
1757          * [in] Type of the allocation type
1758          */
1759         enum tf_tbl_type type;
1760         /**
1761          * [in] Table scope identifier (ignored unless TF_TBL_TYPE_EXT)
1762          */
1763         uint32_t tbl_scope_id;
1764         /**
1765          * [in] Index to free
1766          */
1767         uint32_t idx;
1768         /**
1769          * [out] Reference count after free, only valid if session has been
1770          * created with shadow_copy.
1771          */
1772         uint16_t ref_cnt;
1773 };
1774
1775 /**
1776  * free index table entry
1777  *
1778  * Used to free a previously allocated table entry.
1779  *
1780  * Internal types:
1781  *
1782  * If session has shadow_copy enabled the shadow DB is searched and if
1783  * found the element ref_cnt is decremented. If ref_cnt goes to
1784  * zero then the element is returned to the session pool.
1785  *
1786  * If the session does not have a shadow DB the element is free'ed and
1787  * given back to the session pool.
1788  *
1789  * External types:
1790  *
1791  * Free's an external index table action record.
1792  *
1793  * NOTE:
1794  * Implementation of the internals of this function will be a stack with push
1795  * and pop.
1796  *
1797  * Returns success or failure code.
1798  */
1799 int tf_free_tbl_entry(struct tf *tfp,
1800                       struct tf_free_tbl_entry_parms *parms);
1801
1802 /**
1803  * tf_set_tbl_entry parameter definition
1804  */
1805 struct tf_set_tbl_entry_parms {
1806         /**
1807          * [in] Table scope identifier
1808          */
1809         uint32_t tbl_scope_id;
1810         /**
1811          * [in] Receive or transmit direction
1812          */
1813         enum tf_dir dir;
1814         /**
1815          * [in] Type of object to set
1816          */
1817         enum tf_tbl_type type;
1818         /**
1819          * [in] Entry data
1820          */
1821         uint8_t *data;
1822         /**
1823          * [in] Entry size
1824          */
1825         uint16_t data_sz_in_bytes;
1826         /**
1827          * [in] External memory channel type to use
1828          */
1829         enum tf_ext_mem_chan_type chan_type;
1830         /**
1831          * [in] Entry index to write to
1832          */
1833         uint32_t idx;
1834 };
1835
1836 /**
1837  * set index table entry
1838  *
1839  * Used to insert an application programmed index table entry into a
1840  * previous allocated table location.  A shadow copy of the table
1841  * is maintained (if enabled) (only for internal objects)
1842  *
1843  * Returns success or failure code.
1844  */
1845 int tf_set_tbl_entry(struct tf *tfp,
1846                      struct tf_set_tbl_entry_parms *parms);
1847
1848 /**
1849  * tf_get_shared_tbl_increment parameter definition
1850  */
1851 struct tf_get_shared_tbl_increment_parms {
1852         /**
1853          * [in] Receive or transmit direction
1854          */
1855         enum tf_dir dir;
1856         /**
1857          * [in] Type of object to set
1858          */
1859         enum tf_tbl_type type;
1860         /**
1861          * [out] Value to increment by for resource type
1862          */
1863         uint32_t increment_cnt;
1864 };
1865
1866 /**
1867  * tf_get_shared_tbl_increment
1868  *
1869  * This API is currently only required for use in the shared
1870  * session for Thor (p58) actions.  An increment count is returned per
1871  * type to indicate how much to increment the start by for each
1872  * entry (see tf_resource_info)
1873  *
1874  * Returns success or failure code.
1875  */
1876 int tf_get_shared_tbl_increment(struct tf *tfp,
1877                                 struct tf_get_shared_tbl_increment_parms *parms);
1878
1879 /**
1880  * tf_get_tbl_entry parameter definition
1881  */
1882 struct tf_get_tbl_entry_parms {
1883         /**
1884          * [in] Receive or transmit direction
1885          */
1886         enum tf_dir dir;
1887         /**
1888          * [in] Type of object to get
1889          */
1890         enum tf_tbl_type type;
1891         /**
1892          * [out] Entry data
1893          */
1894         uint8_t *data;
1895         /**
1896          * [in] Entry size
1897          */
1898         uint16_t data_sz_in_bytes;
1899         /**
1900          * [in] External memory channel type to use
1901          */
1902         enum tf_ext_mem_chan_type chan_type;
1903         /**
1904          * [in] Entry index to read
1905          */
1906         uint32_t idx;
1907 };
1908
1909 /**
1910  * get index table entry
1911  *
1912  * Used to retrieve a previous set index table entry.
1913  *
1914  * Reads and compares with the shadow table copy (if enabled) (only
1915  * for internal objects).
1916  *
1917  * Returns success or failure code. Failure will be returned if the
1918  * provided data buffer is too small for the data type requested.
1919  */
1920 int tf_get_tbl_entry(struct tf *tfp,
1921                      struct tf_get_tbl_entry_parms *parms);
1922
1923 /**
1924  * tf_bulk_get_tbl_entry parameter definition
1925  */
1926 struct tf_bulk_get_tbl_entry_parms {
1927         /**
1928          * [in] Receive or transmit direction
1929          */
1930         enum tf_dir dir;
1931         /**
1932          * [in] Type of object to get
1933          */
1934         enum tf_tbl_type type;
1935         /**
1936          * [in] Starting index to read from
1937          */
1938         uint32_t starting_idx;
1939         /**
1940          * [in] Number of sequential entries
1941          */
1942         uint16_t num_entries;
1943         /**
1944          * [in] Size of the single entry
1945          */
1946         uint16_t entry_sz_in_bytes;
1947         /**
1948          * [out] Host physical address, where the data
1949          * will be copied to by the firmware.
1950          * Use tfp_calloc() API and mem_pa
1951          * variable of the tfp_calloc_parms
1952          * structure for the physical address.
1953          */
1954         uint64_t physical_mem_addr;
1955         /**
1956          * [in] External memory channel type to use
1957          */
1958         enum tf_ext_mem_chan_type chan_type;
1959 };
1960
1961 /**
1962  * Bulk get index table entry
1963  *
1964  * Used to retrieve a set of index table entries.
1965  *
1966  * Entries within the range may not have been allocated using
1967  * tf_alloc_tbl_entry() at the time of access. But the range must
1968  * be within the bounds determined from tf_open_session() for the
1969  * given table type.  Currently, this is only used for collecting statistics.
1970  *
1971  * Returns success or failure code. Failure will be returned if the
1972  * provided data buffer is too small for the data type requested.
1973  */
1974 int tf_bulk_get_tbl_entry(struct tf *tfp,
1975                           struct tf_bulk_get_tbl_entry_parms *parms);
1976
1977 /**
1978  * @page exact_match Exact Match Table
1979  *
1980  * @ref tf_insert_em_entry
1981  *
1982  * @ref tf_delete_em_entry
1983  *
1984  * @ref tf_search_em_entry
1985  *
1986  */
1987 /**
1988  * tf_insert_em_entry parameter definition
1989  */
1990 struct tf_insert_em_entry_parms {
1991         /**
1992          * [in] receive or transmit direction
1993          */
1994         enum tf_dir dir;
1995         /**
1996          * [in] internal or external
1997          */
1998         enum tf_mem mem;
1999         /**
2000          * [in] ID of table scope to use (external only)
2001          */
2002         uint32_t tbl_scope_id;
2003         /**
2004          * [in] ptr to structure containing key fields
2005          */
2006         uint8_t *key;
2007         /**
2008          * [in] key bit length
2009          */
2010         uint16_t key_sz_in_bits;
2011         /**
2012          * [in] ptr to structure containing result field
2013          */
2014         uint8_t *em_record;
2015         /**
2016          * [out] result size in bits
2017          */
2018         uint16_t em_record_sz_in_bits;
2019         /**
2020          * [in] duplicate check flag
2021          */
2022         uint8_t dup_check;
2023         /**
2024          * [in] External memory channel type to use
2025          */
2026         enum tf_ext_mem_chan_type chan_type;
2027         /**
2028          * [out] Flow handle value for the inserted entry.  This is encoded
2029          * as the entries[4]:bucket[2]:hashId[1]:hash[14]
2030          */
2031         uint64_t flow_handle;
2032         /**
2033          * [out] Flow id is returned as null (internal)
2034          * Flow id is the GFID value for the inserted entry (external)
2035          * This is the value written to the BD and useful information for mark.
2036          */
2037         uint64_t flow_id;
2038 };
2039 /**
2040  * tf_delete_em_entry parameter definition
2041  */
2042 struct tf_delete_em_entry_parms {
2043         /**
2044          * [in] receive or transmit direction
2045          */
2046         enum tf_dir dir;
2047         /**
2048          * [in] internal or external
2049          */
2050         enum tf_mem mem;
2051         /**
2052          * [in] ID of table scope to use (external only)
2053          */
2054         uint32_t tbl_scope_id;
2055         /**
2056          * [out] The index of the entry
2057          */
2058         uint16_t index;
2059         /**
2060          * [in] External memory channel type to use
2061          */
2062         enum tf_ext_mem_chan_type chan_type;
2063         /**
2064          * [in] structure containing flow delete handle information
2065          */
2066         uint64_t flow_handle;
2067 };
2068 /**
2069  * tf_move_em_entry parameter definition
2070  */
2071 struct tf_move_em_entry_parms {
2072         /**
2073          * [in] receive or transmit direction
2074          */
2075         enum tf_dir dir;
2076         /**
2077          * [in] internal or external
2078          */
2079         enum tf_mem mem;
2080         /**
2081          * [in] ID of table scope to use (external only)
2082          */
2083         uint32_t tbl_scope_id;
2084         /**
2085          * [in] ID of table interface to use (SR2 only)
2086          */
2087         uint32_t tbl_if_id;
2088         /**
2089          * [in] epoch group IDs of entry to delete
2090          * 2 element array with 2 ids. (SR2 only)
2091          */
2092         uint16_t *epochs;
2093         /**
2094          * [out] The index of the entry
2095          */
2096         uint16_t index;
2097         /**
2098          * [in] External memory channel type to use
2099          */
2100         enum tf_ext_mem_chan_type chan_type;
2101         /**
2102          * [in] The index of the new EM record
2103          */
2104         uint32_t new_index;
2105         /**
2106          * [in] structure containing flow delete handle information
2107          */
2108         uint64_t flow_handle;
2109 };
2110 /**
2111  * tf_search_em_entry parameter definition
2112  */
2113 struct tf_search_em_entry_parms {
2114         /**
2115          * [in] receive or transmit direction
2116          */
2117         enum tf_dir dir;
2118         /**
2119          * [in] internal or external
2120          */
2121         enum tf_mem mem;
2122         /**
2123          * [in] ID of table scope to use (external only)
2124          */
2125         uint32_t tbl_scope_id;
2126         /**
2127          * [in] ptr to structure containing key fields
2128          */
2129         uint8_t *key;
2130         /**
2131          * [in] key bit length
2132          */
2133         uint16_t key_sz_in_bits;
2134         /**
2135          * [in/out] ptr to structure containing EM record fields
2136          */
2137         uint8_t *em_record;
2138         /**
2139          * [out] result size in bits
2140          */
2141         uint16_t em_record_sz_in_bits;
2142         /**
2143          * [in] External memory channel type to use
2144          */
2145         enum tf_ext_mem_chan_type chan_type;
2146         /**
2147          * [in] ptr to structure containing flow delete handle
2148          */
2149         uint64_t flow_handle;
2150 };
2151
2152 /**
2153  * insert em hash entry in internal table memory
2154  *
2155  * Internal:
2156  *
2157  * This API inserts an exact match entry into internal EM table memory
2158  * of the specified direction.
2159  *
2160  * Note: The EM record is managed within the TruFlow core and not the
2161  * application.
2162  *
2163  * Shadow copy of internal record table an association with hash and 1,2, or 4
2164  * associated buckets
2165  *
2166  * External:
2167  * This API inserts an exact match entry into DRAM EM table memory of the
2168  * specified direction and table scope.
2169  *
2170  * The insertion of duplicate entries in an EM table is not permitted.  If a
2171  * TruFlow application can guarantee that it will never insert duplicates, it
2172  * can disable duplicate checking by passing a zero value in the  dup_check
2173  * parameter to this API.  This will optimize performance. Otherwise, the
2174  * TruFlow library will enforce protection against inserting duplicate entries.
2175  *
2176  * Flow handle is defined in this document:
2177  *
2178  * https://docs.google.com
2179  * /document/d/1NESu7RpTN3jwxbokaPfYORQyChYRmJgs40wMIRe8_-Q/edit
2180  *
2181  * Returns success or busy code.
2182  *
2183  */
2184 int tf_insert_em_entry(struct tf *tfp,
2185                        struct tf_insert_em_entry_parms *parms);
2186
2187 /**
2188  * delete em hash entry table memory
2189  *
2190  * Internal:
2191  *
2192  * This API deletes an exact match entry from internal EM table memory of the
2193  * specified direction. If a valid flow ptr is passed in then that takes
2194  * precedence over the pointer to the complete key passed in.
2195  *
2196  *
2197  * External:
2198  *
2199  * This API deletes an exact match entry from EM table memory of the specified
2200  * direction and table scope. If a valid flow handle is passed in then that
2201  * takes precedence over the pointer to the complete key passed in.
2202  *
2203  * The TruFlow library may release a dynamic bucket when an entry is deleted.
2204  *
2205  *
2206  * Returns success or not found code
2207  *
2208  *
2209  */
2210 int tf_delete_em_entry(struct tf *tfp,
2211                        struct tf_delete_em_entry_parms *parms);
2212
2213 /**
2214  * search em hash entry table memory
2215  *
2216  * Internal:
2217
2218  * This API looks up an EM entry in table memory with the specified EM
2219  * key or flow (flow takes precedence) and direction.
2220  *
2221  * The status will be one of: success or entry not found.  If the lookup
2222  * succeeds, a pointer to the matching entry and the result record associated
2223  * with the matching entry will be provided.
2224  *
2225  * If flow_handle is set, search shadow copy.
2226  *
2227  * Otherwise, query the fw with key to get result.
2228  *
2229  * External:
2230  *
2231  * This API looks up an EM entry in table memory with the specified EM
2232  * key or flow_handle (flow takes precedence), direction and table scope.
2233  *
2234  * The status will be one of: success or entry not found.  If the lookup
2235  * succeeds, a pointer to the matching entry and the result record associated
2236  * with the matching entry will be provided.
2237  *
2238  * Returns success or not found code
2239  *
2240  */
2241 int tf_search_em_entry(struct tf *tfp,
2242                        struct tf_search_em_entry_parms *parms);
2243
2244 /**
2245  * @page global Global Configuration
2246  *
2247  * @ref tf_set_global_cfg
2248  *
2249  * @ref tf_get_global_cfg
2250  */
2251 /**
2252  * Tunnel Encapsulation Offsets
2253  */
2254 enum tf_tunnel_encap_offsets {
2255         TF_TUNNEL_ENCAP_L2,
2256         TF_TUNNEL_ENCAP_NAT,
2257         TF_TUNNEL_ENCAP_MPLS,
2258         TF_TUNNEL_ENCAP_VXLAN,
2259         TF_TUNNEL_ENCAP_GENEVE,
2260         TF_TUNNEL_ENCAP_NVGRE,
2261         TF_TUNNEL_ENCAP_GRE,
2262         TF_TUNNEL_ENCAP_FULL_GENERIC
2263 };
2264 /**
2265  * Global Configuration Table Types
2266  */
2267 enum tf_global_config_type {
2268         TF_TUNNEL_ENCAP,  /**< Tunnel Encap Config(TECT) */
2269         TF_ACTION_BLOCK,  /**< Action Block Config(ABCR) */
2270         TF_COUNTER_CFG,   /**< Counter Configuration (CNTRS_CTRL) */
2271         TF_GLOBAL_CFG_TYPE_MAX
2272 };
2273
2274 /**
2275  * tf_global_cfg parameter definition
2276  */
2277 struct tf_global_cfg_parms {
2278         /**
2279          * [in] receive or transmit direction
2280          */
2281         enum tf_dir dir;
2282         /**
2283          * [in] Global config type
2284          */
2285         enum tf_global_config_type type;
2286         /**
2287          * [in] Offset @ the type
2288          */
2289         uint32_t offset;
2290         /**
2291          * [in/out] Value of the configuration
2292          * set - Read, Modify and Write
2293          * get - Read the full configuration
2294          */
2295         uint8_t *config;
2296         /**
2297          * [in] Configuration mask
2298          * set - Read, Modify with mask and Write
2299          * get - unused
2300          */
2301         uint8_t *config_mask;
2302         /**
2303          * [in] struct containing size
2304          */
2305         uint16_t config_sz_in_bytes;
2306 };
2307
2308 /**
2309  * Get global configuration
2310  *
2311  * Retrieve the configuration
2312  *
2313  * Returns success or failure code.
2314  */
2315 int tf_get_global_cfg(struct tf *tfp,
2316                       struct tf_global_cfg_parms *parms);
2317
2318 /**
2319  * Update the global configuration table
2320  *
2321  * Read, modify write the value.
2322  *
2323  * Returns success or failure code.
2324  */
2325 int tf_set_global_cfg(struct tf *tfp,
2326                       struct tf_global_cfg_parms *parms);
2327
2328 /**
2329  * @page if_tbl Interface Table Access
2330  *
2331  * @ref tf_set_if_tbl_entry
2332  *
2333  * @ref tf_get_if_tbl_entry
2334  *
2335  * @ref tf_restore_if_tbl_entry
2336  */
2337 /**
2338  * Enumeration of TruFlow interface table types.
2339  */
2340 enum tf_if_tbl_type {
2341         /** Default Profile L2 Context Entry */
2342         TF_IF_TBL_TYPE_PROF_SPIF_DFLT_L2_CTXT,
2343         /** Default Profile TCAM/Lookup Action Record Pointer Table */
2344         TF_IF_TBL_TYPE_PROF_PARIF_DFLT_ACT_REC_PTR,
2345         /** Error Profile TCAM Miss Action Record Pointer Table */
2346         TF_IF_TBL_TYPE_PROF_PARIF_ERR_ACT_REC_PTR,
2347         /** Default Error Profile TCAM Miss Action Record Pointer Table */
2348         TF_IF_TBL_TYPE_LKUP_PARIF_DFLT_ACT_REC_PTR,
2349         /** Ingress lookup table */
2350         TF_IF_TBL_TYPE_ILT,
2351         /** VNIC/SVIF Properties Table */
2352         TF_IF_TBL_TYPE_VSPT,
2353         TF_IF_TBL_TYPE_MAX
2354 };
2355
2356 /**
2357  * tf_set_if_tbl_entry parameter definition
2358  */
2359 struct tf_set_if_tbl_entry_parms {
2360         /**
2361          * [in] Receive or transmit direction
2362          */
2363         enum tf_dir dir;
2364         /**
2365          * [in] Type of object to set
2366          */
2367         enum tf_if_tbl_type type;
2368         /**
2369          * [in] Entry data
2370          */
2371         uint8_t *data;
2372         /**
2373          * [in] Entry size
2374          */
2375         uint16_t data_sz_in_bytes;
2376         /**
2377          * [in] Interface to write
2378          */
2379         uint32_t idx;
2380 };
2381
2382 /**
2383  * set interface table entry
2384  *
2385  * Used to set an interface table. This API is used for managing tables indexed
2386  * by SVIF/SPIF/PARIF interfaces. In current implementation only the value is
2387  * set.
2388  * Returns success or failure code.
2389  */
2390 int tf_set_if_tbl_entry(struct tf *tfp,
2391                         struct tf_set_if_tbl_entry_parms *parms);
2392
2393 /**
2394  * tf_get_if_tbl_entry parameter definition
2395  */
2396 struct tf_get_if_tbl_entry_parms {
2397         /**
2398          * [in] Receive or transmit direction
2399          */
2400         enum tf_dir dir;
2401         /**
2402          * [in] Type of table to get
2403          */
2404         enum tf_if_tbl_type type;
2405         /**
2406          * [out] Entry data
2407          */
2408         uint8_t *data;
2409         /**
2410          * [in] Entry size
2411          */
2412         uint16_t data_sz_in_bytes;
2413         /**
2414          * [in] Entry index to read
2415          */
2416         uint32_t idx;
2417 };
2418
2419 /**
2420  * get interface table entry
2421  *
2422  * Used to retrieve an interface table entry.
2423  *
2424  * Reads the interface table entry value
2425  *
2426  * Returns success or failure code. Failure will be returned if the
2427  * provided data buffer is too small for the data type requested.
2428  */
2429 int tf_get_if_tbl_entry(struct tf *tfp,
2430                         struct tf_get_if_tbl_entry_parms *parms);
2431
2432 #endif /* _TF_CORE_H_ */