drivers/net/bnxt/tf_core/tf_core.h

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