net/bnxt: add core changes for EM and EEM lookups
[dpdk.git] / drivers / net / bnxt / tf_core / tf_core.h
index ac8b784..bb456bb 100644 (file)
@@ -10,7 +10,7 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #include <stdio.h>
-
+#include "hcapi/hcapi_cfa.h"
 #include "tf_project.h"
 
 /**
 
 /********** BEGIN Truflow Core DEFINITIONS **********/
 
+
+#define TF_KILOBYTE  1024
+#define TF_MEGABYTE  (1024 * 1024)
+
 /**
  * direction
  */
@@ -31,30 +35,30 @@ enum tf_dir {
 };
 
 /**
- * External pool size
- *
- * Defines a single pool of external action records of
- * fixed size.  Currently, this is an index.
+ * memory choice
  */
-#define TF_EXT_POOL_ENTRY_SZ_BYTES 1
+enum tf_mem {
+       TF_MEM_INTERNAL, /**< Internal */
+       TF_MEM_EXTERNAL, /**< External */
+       TF_MEM_MAX
+};
 
 /**
- *  External pool entry count
+ * EEM record AR helper
+ *
+ * Helper to handle the Action Record Pointer in the EEM Record Entry.
  *
- *  Defines the number of entries in the external action pool
+ * Convert absolute offset to action record pointer in EEM record entry
+ * Convert action record pointer in EEM record entry to absolute offset
  */
-#define TF_EXT_POOL_ENTRY_CNT (1 * 1024)
+#define TF_ACT_REC_OFFSET_2_PTR(offset) ((offset) >> 4)
+#define TF_ACT_REC_PTR_2_OFFSET(offset) ((offset) << 4)
 
-/**
- * Number of external pools
- */
-#define TF_EXT_POOL_CNT_MAX 1
 
-/**
- * External pool Id
+/*
+ * Helper Macros
  */
-#define TF_EXT_POOL_0      0 /**< matches TF_TBL_TYPE_EXT   */
-#define TF_EXT_POOL_1      1 /**< matches TF_TBL_TYPE_EXT_0 */
+#define TF_BITS_2_BYTES(num_bits) (((num_bits) + 7) / 8)
 
 /********** BEGIN API FUNCTION PROTOTYPES/PARAMETERS **********/
 
@@ -69,7 +73,8 @@ enum tf_dir {
  */
 
 
-/** Session Version defines
+/**
+ * Session Version defines
  *
  * The version controls the format of the tf_session and
  * tf_session_info structure. This is to assure upgrade between
@@ -79,7 +84,8 @@ enum tf_dir {
 #define TF_SESSION_VER_MINOR  0   /**< Minor Version */
 #define TF_SESSION_VER_UPDATE 0   /**< Update Version */
 
-/** Session Name
+/**
+ * Session Name
  *
  * Name of the TruFlow control channel interface.  Expects
  * format to be RTE Name specific, i.e. rte_eth_dev_get_name_by_port()
@@ -88,7 +94,8 @@ enum tf_dir {
 
 #define TF_FW_SESSION_ID_INVALID  0xFF  /**< Invalid FW Session ID define */
 
-/** Session Identifier
+/**
+ * Session Identifier
  *
  * Unique session identifier which includes PCIe bus info to
  * distinguish the PF and session info to identify the associated
@@ -106,7 +113,8 @@ union tf_session_id {
        } internal;
 };
 
-/** Session Version
+/**
+ * Session Version
  *
  * The version controls the format of the tf_session and
  * tf_session_info structure. This is to assure upgrade between
@@ -120,24 +128,176 @@ struct tf_session_version {
        uint8_t update;
 };
 
-/** Session supported device types
- *
+/**
+ * Session supported device types
  */
 enum tf_device_type {
        TF_DEVICE_TYPE_WH = 0, /**< Whitney+  */
-       TF_DEVICE_TYPE_BRD2,   /**< TBD       */
-       TF_DEVICE_TYPE_BRD3,   /**< TBD       */
-       TF_DEVICE_TYPE_BRD4,   /**< TBD       */
+       TF_DEVICE_TYPE_SR,     /**< Stingray  */
+       TF_DEVICE_TYPE_THOR,   /**< Thor      */
+       TF_DEVICE_TYPE_SR2,    /**< Stingray2 */
        TF_DEVICE_TYPE_MAX     /**< Maximum   */
 };
 
-/** TruFlow Session Information
+/**
+ * Identifier resource types
+ */
+enum tf_identifier_type {
+       /**
+        *  The L2 Context is returned from the L2 Ctxt TCAM lookup
+        *  and can be used in WC TCAM or EM keys to virtualize further
+        *  lookups.
+        */
+       TF_IDENT_TYPE_L2_CTXT,
+       /**
+        *  The WC profile func is returned from the L2 Ctxt TCAM lookup
+        *  to enable virtualization of the profile TCAM.
+        */
+       TF_IDENT_TYPE_PROF_FUNC,
+       /**
+        *  The WC profile ID is included in the WC lookup key
+        *  to enable virtualization of the WC TCAM hardware.
+        */
+       TF_IDENT_TYPE_WC_PROF,
+       /**
+        *  The EM profile ID is included in the EM lookup key
+        *  to enable virtualization of the EM hardware. (not required for SR2
+        *  as it has table scope)
+        */
+       TF_IDENT_TYPE_EM_PROF,
+       /**
+        *  The L2 func is included in the ILT result and from recycling to
+        *  enable virtualization of further lookups.
+        */
+       TF_IDENT_TYPE_L2_FUNC,
+       TF_IDENT_TYPE_MAX
+};
+
+/**
+ * Enumeration of TruFlow table types. A table type is used to identify a
+ * resource object.
+ *
+ * NOTE: The table type TF_TBL_TYPE_EXT is unique in that it is
+ * the only table type that is connected with a table scope.
+ */
+enum tf_tbl_type {
+       /* Internal */
+
+       /** Wh+/SR Action Record */
+       TF_TBL_TYPE_FULL_ACT_RECORD,
+       /** Wh+/SR/Th Multicast Groups */
+       TF_TBL_TYPE_MCAST_GROUPS,
+       /** Wh+/SR Action Encap 8 Bytes */
+       TF_TBL_TYPE_ACT_ENCAP_8B,
+       /** Wh+/SR Action Encap 16 Bytes */
+       TF_TBL_TYPE_ACT_ENCAP_16B,
+       /** Action Encap 32 Bytes */
+       TF_TBL_TYPE_ACT_ENCAP_32B,
+       /** Wh+/SR Action Encap 64 Bytes */
+       TF_TBL_TYPE_ACT_ENCAP_64B,
+       /** Action Source Properties SMAC */
+       TF_TBL_TYPE_ACT_SP_SMAC,
+       /** Wh+/SR Action Source Properties SMAC IPv4 */
+       TF_TBL_TYPE_ACT_SP_SMAC_IPV4,
+       /** Action Source Properties SMAC IPv6 */
+       TF_TBL_TYPE_ACT_SP_SMAC_IPV6,
+       /** Wh+/SR Action Statistics 64 Bits */
+       TF_TBL_TYPE_ACT_STATS_64,
+       /** Wh+/SR Action Modify L4 Src Port */
+       TF_TBL_TYPE_ACT_MODIFY_SPORT,
+       /** Wh+/SR Action Modify L4 Dest Port */
+       TF_TBL_TYPE_ACT_MODIFY_DPORT,
+       /** Wh+/SR Action Modify IPv4 Source */
+       TF_TBL_TYPE_ACT_MODIFY_IPV4_SRC,
+       /** Wh+/SR Action _Modify L4 Dest Port */
+       TF_TBL_TYPE_ACT_MODIFY_IPV4_DEST,
+       /** Action Modify IPv6 Source */
+       TF_TBL_TYPE_ACT_MODIFY_IPV6_SRC,
+       /** Action Modify IPv6 Destination */
+       TF_TBL_TYPE_ACT_MODIFY_IPV6_DEST,
+       /** Meter Profiles */
+       TF_TBL_TYPE_METER_PROF,
+       /** Meter Instance */
+       TF_TBL_TYPE_METER_INST,
+       /** Mirror Config */
+       TF_TBL_TYPE_MIRROR_CONFIG,
+       /** UPAR */
+       TF_TBL_TYPE_UPAR,
+       /** SR2 Epoch 0 table */
+       TF_TBL_TYPE_EPOCH0,
+       /** SR2 Epoch 1 table  */
+       TF_TBL_TYPE_EPOCH1,
+       /** SR2 Metadata  */
+       TF_TBL_TYPE_METADATA,
+       /** SR2 CT State  */
+       TF_TBL_TYPE_CT_STATE,
+       /** SR2 Range Profile  */
+       TF_TBL_TYPE_RANGE_PROF,
+       /** SR2 Range Entry  */
+       TF_TBL_TYPE_RANGE_ENTRY,
+       /** SR2 LAG Entry  */
+       TF_TBL_TYPE_LAG,
+       /** SR2 VNIC/SVIF Table */
+       TF_TBL_TYPE_VNIC_SVIF,
+       /** Th/SR2 EM Flexible Key builder */
+       TF_TBL_TYPE_EM_FKB,
+       /** Th/SR2 WC Flexible Key builder */
+       TF_TBL_TYPE_WC_FKB,
+
+       /* External */
+
+       /**
+        * External table type - initially 1 poolsize entries.
+        * All External table types are associated with a table
+        * scope. Internal types are not.
+        */
+       TF_TBL_TYPE_EXT,
+       TF_TBL_TYPE_MAX
+};
+
+/**
+ * TCAM table type
+ */
+enum tf_tcam_tbl_type {
+       /** L2 Context TCAM */
+       TF_TCAM_TBL_TYPE_L2_CTXT_TCAM,
+       /** Profile TCAM */
+       TF_TCAM_TBL_TYPE_PROF_TCAM,
+       /** Wildcard TCAM */
+       TF_TCAM_TBL_TYPE_WC_TCAM,
+       /** Source Properties TCAM */
+       TF_TCAM_TBL_TYPE_SP_TCAM,
+       /** Connection Tracking Rule TCAM */
+       TF_TCAM_TBL_TYPE_CT_RULE_TCAM,
+       /** Virtual Edge Bridge TCAM */
+       TF_TCAM_TBL_TYPE_VEB_TCAM,
+       TF_TCAM_TBL_TYPE_MAX
+};
+
+/**
+ * EM Resources
+ * These defines are provisioned during
+ * tf_open_session()
+ */
+enum tf_em_tbl_type {
+       /** The number of internal EM records for the session */
+       TF_EM_TBL_TYPE_EM_RECORD,
+       /** The number of table scopes reequested */
+       TF_EM_TBL_TYPE_TBL_SCOPE,
+       TF_EM_TBL_TYPE_MAX
+};
+
+/**
+ * TruFlow Session Information
  *
  * Structure defining a TruFlow Session, also known as a Management
  * session. This structure is initialized at time of
  * tf_open_session(). It is passed to all of the TruFlow APIs as way
  * to prescribe and isolate resources between different TruFlow ULP
  * Applications.
+ *
+ * Ownership of the elements is split between ULP and TruFlow. Please
+ * see the individual elements.
  */
 struct tf_session_info {
        /**
@@ -207,7 +367,8 @@ struct tf_session_info {
        uint32_t              core_data_sz_bytes;
 };
 
-/** TruFlow handle
+/**
+ * TruFlow handle
  *
  * Contains a pointer to the session info. Allocated by ULP and passed
  * to TruFlow using tf_open_session(). TruFlow will populate the
@@ -223,12 +384,42 @@ struct tf {
        struct tf_session_info *session;
 };
 
+/**
+ * tf_session_resources parameter definition.
+ */
+struct tf_session_resources {
+       /** [in] Requested Identifier Resources
+        *
+        * The number of identifier resources requested for the session.
+        * The index used is tf_identifier_type.
+        */
+       uint16_t identifier_cnt[TF_IDENT_TYPE_MAX][TF_DIR_MAX];
+       /** [in] Requested Index Table resource counts
+        *
+        * The number of index table resources requested for the session.
+        * The index used is tf_tbl_type.
+        */
+       uint16_t tbl_cnt[TF_TBL_TYPE_MAX][TF_DIR_MAX];
+       /** [in] Requested TCAM Table resource counts
+        *
+        * The number of TCAM table resources requested for the session.
+        * The index used is tf_tcam_tbl_type.
+        */
+       uint16_t tcam_tbl_cnt[TF_TCAM_TBL_TYPE_MAX][TF_DIR_MAX];
+       /** [in] Requested EM resource counts
+        *
+        * The number of internal EM table resources requested for the session
+        * The index used is tf_em_tbl_type.
+        */
+       uint16_t em_tbl_cnt[TF_EM_TBL_TYPE_MAX][TF_DIR_MAX];
+};
 
 /**
  * tf_open_session parameters definition.
  */
 struct tf_open_session_parms {
-       /** [in] ctrl_chan_name
+       /**
+        * [in] ctrl_chan_name
         *
         * String containing name of control channel interface to be
         * used for this session to communicate with firmware.
@@ -240,7 +431,8 @@ struct tf_open_session_parms {
         * shared memory allocation.
         */
        char ctrl_chan_name[TF_SESSION_NAME_MAX];
-       /** [in] shadow_copy
+       /**
+        * [in] shadow_copy
         *
         * Boolean controlling the use and availability of shadow
         * copy. Shadow copy will allow the TruFlow to keep track of
@@ -253,7 +445,8 @@ struct tf_open_session_parms {
         * control channel.
         */
        bool shadow_copy;
-       /** [in/out] session_id
+       /**
+        * [in/out] session_id
         *
         * Session_id is unique per session.
         *
@@ -264,11 +457,17 @@ struct tf_open_session_parms {
         * The session_id allows a session to be shared between devices.
         */
        union tf_session_id session_id;
-       /** [in] device type
+       /**
+        * [in] device type
         *
-        * Device type is passed, one of Wh+, Brd2, Brd3, Brd4
+        * Device type is passed, one of Wh+, SR, Thor, SR2
         */
        enum tf_device_type device_type;
+       /** [in] resources
+        *
+        * Resource allocation
+        */
+       struct tf_session_resources resources;
 };
 
 /**
@@ -298,8 +497,12 @@ struct tf_open_session_parms {
 int tf_open_session(struct tf *tfp,
                    struct tf_open_session_parms *parms);
 
+int tf_open_session_new(struct tf *tfp,
+                       struct tf_open_session_parms *parms);
+
 struct tf_attach_session_parms {
-       /** [in] ctrl_chan_name
+       /**
+        * [in] ctrl_chan_name
         *
         * String containing name of control channel interface to be
         * used for this session to communicate with firmware.
@@ -312,7 +515,8 @@ struct tf_attach_session_parms {
         */
        char ctrl_chan_name[TF_SESSION_NAME_MAX];
 
-       /** [in] attach_chan_name
+       /**
+        * [in] attach_chan_name
         *
         * String containing name of attach channel interface to be
         * used for this session.
@@ -325,7 +529,8 @@ struct tf_attach_session_parms {
         */
        char attach_chan_name[TF_SESSION_NAME_MAX];
 
-       /** [in] session_id
+       /**
+        * [in] session_id
         *
         * Session_id is unique per session. For Attach the session_id
         * should be the session_id that was returned on the first
@@ -360,6 +565,8 @@ struct tf_attach_session_parms {
  */
 int tf_attach_session(struct tf *tfp,
                      struct tf_attach_session_parms *parms);
+int tf_attach_session_new(struct tf *tfp,
+                         struct tf_attach_session_parms *parms);
 
 /**
  * Closes an existing session. Cleans up all hardware and firmware
@@ -369,6 +576,7 @@ int tf_attach_session(struct tf *tfp,
  * Returns success or failure code.
  */
 int tf_close_session(struct tf *tfp);
+int tf_close_session_new(struct tf *tfp);
 
 /**
  * @page  ident Identity Management
@@ -377,32 +585,8 @@ int tf_close_session(struct tf *tfp);
  *
  * @ref tf_free_identifier
  */
-enum tf_identifier_type {
-       /** The L2 Context is returned from the L2 Ctxt TCAM lookup
-        *  and can be used in WC TCAM or EM keys to virtualize further
-        *  lookups.
-        */
-       TF_IDENT_TYPE_L2_CTXT,
-       /** The WC profile func is returned from the L2 Ctxt TCAM lookup
-        *  to enable virtualization of the profile TCAM.
-        */
-       TF_IDENT_TYPE_PROF_FUNC,
-       /** The WC profile ID is included in the WC lookup key
-        *  to enable virtualization of the WC TCAM hardware.
-        */
-       TF_IDENT_TYPE_WC_PROF,
-       /** The EM profile ID is included in the EM lookup key
-        *  to enable virtualization of the EM hardware. (not required for Brd4
-        *  as it has table scope)
-        */
-       TF_IDENT_TYPE_EM_PROF,
-       /** The L2 func is included in the ILT result and from recycling to
-        *  enable virtualization of further lookups.
-        */
-       TF_IDENT_TYPE_L2_FUNC
-};
-
-/** tf_alloc_identifier parameter definition
+/**
+ * tf_alloc_identifier parameter definition
  */
 struct tf_alloc_identifier_parms {
        /**
@@ -419,7 +603,8 @@ struct tf_alloc_identifier_parms {
        uint16_t id;
 };
 
-/** tf_free_identifier parameter definition
+/**
+ * tf_free_identifier parameter definition
  */
 struct tf_free_identifier_parms {
        /**
@@ -436,7 +621,8 @@ struct tf_free_identifier_parms {
        uint16_t id;
 };
 
-/** allocate identifier resource
+/**
+ * allocate identifier resource
  *
  * TruFlow core will allocate a free id from the per identifier resource type
  * pool reserved for the session during tf_open().  No firmware is involved.
@@ -445,8 +631,11 @@ struct tf_free_identifier_parms {
  */
 int tf_alloc_identifier(struct tf *tfp,
                        struct tf_alloc_identifier_parms *parms);
+int tf_alloc_identifier_new(struct tf *tfp,
+                           struct tf_alloc_identifier_parms *parms);
 
-/** free identifier resource
+/**
+ * free identifier resource
  *
  * TruFlow core will return an id back to the per identifier resource type pool
  * reserved for the session.  No firmware is involved.  During tf_close, the
@@ -456,21 +645,144 @@ int tf_alloc_identifier(struct tf *tfp,
  */
 int tf_free_identifier(struct tf *tfp,
                       struct tf_free_identifier_parms *parms);
+int tf_free_identifier_new(struct tf *tfp,
+                          struct tf_free_identifier_parms *parms);
 
 /**
- * TCAM table type
+ * @page dram_table DRAM Table Scope Interface
+ *
+ * @ref tf_alloc_tbl_scope
+ *
+ * @ref tf_free_tbl_scope
+ *
+ * If we allocate the EEM memory from the core, we need to store it in
+ * the shared session data structure to make sure it can be freed later.
+ * (for example if the PF goes away)
+ *
+ * Current thought is that memory is allocated within core.
  */
-enum tf_tcam_tbl_type {
-       TF_TCAM_TBL_TYPE_L2_CTXT_TCAM,
-       TF_TCAM_TBL_TYPE_PROF_TCAM,
-       TF_TCAM_TBL_TYPE_WC_TCAM,
-       TF_TCAM_TBL_TYPE_SP_TCAM,
-       TF_TCAM_TBL_TYPE_CT_RULE_TCAM,
-       TF_TCAM_TBL_TYPE_VEB_TCAM,
-       TF_TCAM_TBL_TYPE_MAX
 
+
+/**
+ * tf_alloc_tbl_scope_parms definition
+ */
+struct tf_alloc_tbl_scope_parms {
+       /**
+        * [in] All Maximum key size required.
+        */
+       uint16_t rx_max_key_sz_in_bits;
+       /**
+        * [in] Maximum Action size required (includes inlined items)
+        */
+       uint16_t rx_max_action_entry_sz_in_bits;
+       /**
+        * [in] Memory size in Megabytes
+        * Total memory size allocated by user to be divided
+        * up for actions, hash, counters.  Only inline external actions.
+        * Use this variable or the number of flows, do not set both.
+        */
+       uint32_t rx_mem_size_in_mb;
+       /**
+        * [in] Number of flows * 1000. If set, rx_mem_size_in_mb must equal 0.
+        */
+       uint32_t rx_num_flows_in_k;
+       /**
+        * [in] SR2 only receive table access interface id
+        */
+       uint32_t rx_tbl_if_id;
+       /**
+        * [in] All Maximum key size required.
+        */
+       uint16_t tx_max_key_sz_in_bits;
+       /**
+        * [in] Maximum Action size required (includes inlined items)
+        */
+       uint16_t tx_max_action_entry_sz_in_bits;
+       /**
+        * [in] Memory size in Megabytes
+        * Total memory size allocated by user to be divided
+        * up for actions, hash, counters.  Only inline external actions.
+        */
+       uint32_t tx_mem_size_in_mb;
+       /**
+        * [in] Number of flows * 1000
+        */
+       uint32_t tx_num_flows_in_k;
+       /**
+        * [in] SR2 only receive table access interface id
+        */
+       uint32_t tx_tbl_if_id;
+       /**
+        * [in] Flush pending HW cached flows every 1/10th of value
+        * set in seconds, both idle and active flows are flushed
+        * from the HW cache. If set to 0, this feature will be disabled.
+        */
+       uint8_t hw_flow_cache_flush_timer;
+       /**
+        * [out] table scope identifier
+        */
+       uint32_t tbl_scope_id;
+};
+
+struct tf_free_tbl_scope_parms {
+       /**
+        * [in] table scope identifier
+        */
+       uint32_t tbl_scope_id;
 };
 
+/**
+ * allocate a table scope
+ *
+ * On SR2 Firmware will allocate a scope ID.  On other devices, the scope
+ * is a software construct to identify an EEM table.  This function will
+ * divide the hash memory/buckets and records according to the device
+ * device constraints based upon calculations using either the number of flows
+ * requested or the size of memory indicated.  Other parameters passed in
+ * determine the configuration (maximum key size, maximum external action record
+ * size.
+ *
+ * This API will allocate the table region in
+ * DRAM, program the PTU page table entries, and program the number of static
+ * buckets (if SR2) in the RX and TX CFAs.  Buckets are assumed to start at
+ * 0 in the EM memory for the scope.  Upon successful completion of this API,
+ * hash tables are fully initialized and ready for entries to be inserted.
+ *
+ * A single API is used to allocate a common table scope identifier in both
+ * receive and transmit CFA. The scope identifier is common due to nature of
+ * connection tracking sending notifications between RX and TX direction.
+ *
+ * The receive and transmit table access identifiers specify which rings will
+ * be used to initialize table DRAM.  The application must ensure mutual
+ * exclusivity of ring usage for table scope allocation and any table update
+ * operations.
+ *
+ * The hash table buckets, EM keys, and EM lookup results are stored in the
+ * memory allocated based on the rx_em_hash_mb/tx_em_hash_mb parameters.  The
+ * hash table buckets are stored at the beginning of that memory.
+ *
+ * NOTE:  No EM internal setup is done here. On chip EM records are managed
+ * internally by TruFlow core.
+ *
+ * Returns success or failure code.
+ */
+int tf_alloc_tbl_scope(struct tf *tfp,
+                      struct tf_alloc_tbl_scope_parms *parms);
+
+
+/**
+ * free a table scope
+ *
+ * Firmware checks that the table scope ID is owned by the TruFlow
+ * session, verifies that no references to this table scope remains
+ * (SR2 ILT) or Profile TCAM entries for either CFA (RX/TX) direction,
+ * then frees the table scope ID.
+ *
+ * Returns success or failure code.
+ */
+int tf_free_tbl_scope(struct tf *tfp,
+                     struct tf_free_tbl_scope_parms *parms);
+
 /**
  * @page tcam TCAM Access
  *
@@ -483,7 +795,9 @@ enum tf_tcam_tbl_type {
  * @ref tf_free_tcam_entry
  */
 
-/** tf_alloc_tcam_entry parameter definition
+
+/**
+ * tf_alloc_tcam_entry parameter definition
  */
 struct tf_alloc_tcam_entry_parms {
        /**
@@ -529,7 +843,8 @@ struct tf_alloc_tcam_entry_parms {
        uint16_t idx;
 };
 
-/** allocate TCAM entry
+/**
+ * allocate TCAM entry
  *
  * Allocate a TCAM entry - one of these types:
  *
@@ -554,7 +869,8 @@ struct tf_alloc_tcam_entry_parms {
 int tf_alloc_tcam_entry(struct tf *tfp,
                        struct tf_alloc_tcam_entry_parms *parms);
 
-/** tf_set_tcam_entry parameter definition
+/**
+ * tf_set_tcam_entry parameter definition
  */
 struct tf_set_tcam_entry_parms {
        /**
@@ -591,7 +907,8 @@ struct      tf_set_tcam_entry_parms {
        uint16_t result_sz_in_bits;
 };
 
-/** set TCAM entry
+/**
+ * set TCAM entry
  *
  * Program a TCAM table entry for a TruFlow session.
  *
@@ -602,7 +919,8 @@ struct      tf_set_tcam_entry_parms {
 int tf_set_tcam_entry(struct tf        *tfp,
                      struct tf_set_tcam_entry_parms *parms);
 
-/** tf_get_tcam_entry parameter definition
+/**
+ * tf_get_tcam_entry parameter definition
  */
 struct tf_get_tcam_entry_parms {
        /**
@@ -639,7 +957,8 @@ struct tf_get_tcam_entry_parms {
        uint16_t result_sz_in_bits;
 };
 
-/** get TCAM entry
+/**
+ * get TCAM entry
  *
  * Program a TCAM table entry for a TruFlow session.
  *
@@ -650,7 +969,8 @@ struct tf_get_tcam_entry_parms {
 int tf_get_tcam_entry(struct tf *tfp,
                      struct tf_get_tcam_entry_parms *parms);
 
-/** tf_free_tcam_entry parameter definition
+/**
+ * tf_free_tcam_entry parameter definition
  */
 struct tf_free_tcam_entry_parms {
        /**
@@ -671,7 +991,8 @@ struct tf_free_tcam_entry_parms {
        uint16_t ref_cnt;
 };
 
-/** free TCAM entry
+/**
+ * free TCAM entry
  *
  * Free TCAM entry.
  *
@@ -698,83 +1019,502 @@ int tf_free_tcam_entry(struct tf *tfp,
  * @ref tf_get_tbl_entry
  */
 
+
 /**
- * Enumeration of TruFlow table types. A table type is used to identify a
- * resource object.
- *
- * NOTE: The table type TF_TBL_TYPE_EXT is unique in that it is
- * the only table type that is connected with a table scope.
+ * tf_alloc_tbl_entry parameter definition
  */
-enum tf_tbl_type {
-       /** Wh+/Brd2 Action Record */
-       TF_TBL_TYPE_FULL_ACT_RECORD,
-       /** Multicast Groups */
-       TF_TBL_TYPE_MCAST_GROUPS,
-       /** Action Encap 8 Bytes */
-       TF_TBL_TYPE_ACT_ENCAP_8B,
-       /** Action Encap 16 Bytes */
-       TF_TBL_TYPE_ACT_ENCAP_16B,
-       /** Action Encap 64 Bytes */
-       TF_TBL_TYPE_ACT_ENCAP_32B,
-       /** Action Encap 64 Bytes */
-       TF_TBL_TYPE_ACT_ENCAP_64B,
-       /** Action Source Properties SMAC */
-       TF_TBL_TYPE_ACT_SP_SMAC,
-       /** Action Source Properties SMAC IPv4 */
-       TF_TBL_TYPE_ACT_SP_SMAC_IPV4,
-       /** Action Source Properties SMAC IPv6 */
-       TF_TBL_TYPE_ACT_SP_SMAC_IPV6,
-       /** Action Statistics 64 Bits */
-       TF_TBL_TYPE_ACT_STATS_64,
-       /** Action Modify L4 Src Port */
-       TF_TBL_TYPE_ACT_MODIFY_SPORT,
-       /** Action Modify L4 Dest Port */
-       TF_TBL_TYPE_ACT_MODIFY_DPORT,
-       /** Action Modify IPv4 Source */
-       TF_TBL_TYPE_ACT_MODIFY_IPV4_SRC,
-       /** Action _Modify L4 Dest Port */
-       TF_TBL_TYPE_ACT_MODIFY_IPV4_DEST,
-       /** Action Modify IPv6 Source */
-       TF_TBL_TYPE_ACT_MODIFY_IPV6_SRC,
-       /** Action Modify IPv6 Destination */
-       TF_TBL_TYPE_ACT_MODIFY_IPV6_DEST,
+struct tf_alloc_tbl_entry_parms {
+       /**
+        * [in] Receive or transmit direction
+        */
+       enum tf_dir dir;
+       /**
+        * [in] Type of the allocation
+        */
+       enum tf_tbl_type type;
+       /**
+        * [in] Table scope identifier (ignored unless TF_TBL_TYPE_EXT)
+        */
+       uint32_t tbl_scope_id;
+       /**
+        * [in] Enable search for matching entry. If the table type is
+        * internal the shadow copy will be searched before
+        * alloc. Session must be configured with shadow copy enabled.
+        */
+       uint8_t search_enable;
+       /**
+        * [in] Result data to search for (if search_enable)
+        */
+       uint8_t *result;
+       /**
+        * [in] Result data size in bytes (if search_enable)
+        */
+       uint16_t result_sz_in_bytes;
+       /**
+        * [out] If search_enable, set if matching entry found
+        */
+       uint8_t hit;
+       /**
+        * [out] Current ref count after allocation (if search_enable)
+        */
+       uint16_t ref_cnt;
+       /**
+        * [out] Idx of allocated entry or found entry (if search_enable)
+        */
+       uint32_t idx;
+};
 
-       /* HW */
+/**
+ * allocate index table entries
+ *
+ * Internal types:
+ *
+ * Allocate an on chip index table entry or search for a matching
+ * entry of the indicated type for this TruFlow session.
+ *
+ * Allocates an index table record. This function will attempt to
+ * allocate an entry or search an index table for a matching entry if
+ * search is enabled (only the shadow copy of the table is accessed).
+ *
+ * If search is not enabled, the first available free entry is
+ * returned. If search is enabled and a matching entry to entry_data
+ * is found hit is set to TRUE and success is returned.
+ *
+ * External types:
+ *
+ * These are used to allocate inlined action record memory.
+ *
+ * Allocates an external index table action record.
+ *
+ * NOTE:
+ * Implementation of the internals of this function will be a stack with push
+ * and pop.
+ *
+ * Returns success or failure code.
+ */
+int tf_alloc_tbl_entry(struct tf *tfp,
+                      struct tf_alloc_tbl_entry_parms *parms);
 
-       /** Meter Profiles */
-       TF_TBL_TYPE_METER_PROF,
-       /** Meter Instance */
-       TF_TBL_TYPE_METER_INST,
-       /** Mirror Config */
-       TF_TBL_TYPE_MIRROR_CONFIG,
-       /** UPAR */
-       TF_TBL_TYPE_UPAR,
-       /** Brd4 Epoch 0 table */
-       TF_TBL_TYPE_EPOCH0,
-       /** Brd4 Epoch 1 table  */
-       TF_TBL_TYPE_EPOCH1,
-       /** Brd4 Metadata  */
-       TF_TBL_TYPE_METADATA,
-       /** Brd4 CT State  */
-       TF_TBL_TYPE_CT_STATE,
-       /** Brd4 Range Profile  */
-       TF_TBL_TYPE_RANGE_PROF,
-       /** Brd4 Range Entry  */
-       TF_TBL_TYPE_RANGE_ENTRY,
-       /** Brd4 LAG Entry  */
-       TF_TBL_TYPE_LAG,
-       /** Brd4 only VNIC/SVIF Table */
-       TF_TBL_TYPE_VNIC_SVIF,
+/**
+ * tf_free_tbl_entry parameter definition
+ */
+struct tf_free_tbl_entry_parms {
+       /**
+        * [in] Receive or transmit direction
+        */
+       enum tf_dir dir;
+       /**
+        * [in] Type of the allocation type
+        */
+       enum tf_tbl_type type;
+       /**
+        * [in] Table scope identifier (ignored unless TF_TBL_TYPE_EXT)
+        */
+       uint32_t tbl_scope_id;
+       /**
+        * [in] Index to free
+        */
+       uint32_t idx;
+       /**
+        * [out] Reference count after free, only valid if session has been
+        * created with shadow_copy.
+        */
+       uint16_t ref_cnt;
+};
 
-       /* External */
+/**
+ * free index table entry
+ *
+ * Used to free a previously allocated table entry.
+ *
+ * Internal types:
+ *
+ * If session has shadow_copy enabled the shadow DB is searched and if
+ * found the element ref_cnt is decremented. If ref_cnt goes to
+ * zero then the element is returned to the session pool.
+ *
+ * If the session does not have a shadow DB the element is free'ed and
+ * given back to the session pool.
+ *
+ * External types:
+ *
+ * Free's an external index table action record.
+ *
+ * NOTE:
+ * Implementation of the internals of this function will be a stack with push
+ * and pop.
+ *
+ * Returns success or failure code.
+ */
+int tf_free_tbl_entry(struct tf *tfp,
+                     struct tf_free_tbl_entry_parms *parms);
 
-       /** External table type - initially 1 poolsize entries.
-        * All External table types are associated with a table
-        * scope. Internal types are not.
+/**
+ * tf_set_tbl_entry parameter definition
+ */
+struct tf_set_tbl_entry_parms {
+       /**
+        * [in] Table scope identifier
         */
-       TF_TBL_TYPE_EXT,
-       /** Future - external pool of size0 entries */
-       TF_TBL_TYPE_EXT_0,
-       TF_TBL_TYPE_MAX
+       uint32_t tbl_scope_id;
+       /**
+        * [in] Receive or transmit direction
+        */
+       enum tf_dir dir;
+       /**
+        * [in] Type of object to set
+        */
+       enum tf_tbl_type type;
+       /**
+        * [in] Entry data
+        */
+       uint8_t *data;
+       /**
+        * [in] Entry size
+        */
+       uint16_t data_sz_in_bytes;
+       /**
+        * [in] Entry index to write to
+        */
+       uint32_t idx;
+};
+
+/**
+ * set index table entry
+ *
+ * Used to insert an application programmed index table entry into a
+ * previous allocated table location.  A shadow copy of the table
+ * is maintained (if enabled) (only for internal objects)
+ *
+ * Returns success or failure code.
+ */
+int tf_set_tbl_entry(struct tf *tfp,
+                    struct tf_set_tbl_entry_parms *parms);
+
+/**
+ * tf_get_tbl_entry parameter definition
+ */
+struct tf_get_tbl_entry_parms {
+       /**
+        * [in] Receive or transmit direction
+        */
+       enum tf_dir dir;
+       /**
+        * [in] Type of object to get
+        */
+       enum tf_tbl_type type;
+       /**
+        * [out] Entry data
+        */
+       uint8_t *data;
+       /**
+        * [in] Entry size
+        */
+       uint16_t data_sz_in_bytes;
+       /**
+        * [in] Entry index to read
+        */
+       uint32_t idx;
+};
+
+/**
+ * get index table entry
+ *
+ * Used to retrieve a previous set index table entry.
+ *
+ * Reads and compares with the shadow table copy (if enabled) (only
+ * for internal objects).
+ *
+ * Returns success or failure code. Failure will be returned if the
+ * provided data buffer is too small for the data type requested.
+ */
+int tf_get_tbl_entry(struct tf *tfp,
+                    struct tf_get_tbl_entry_parms *parms);
+
+/**
+ * tf_bulk_get_tbl_entry parameter definition
+ */
+struct tf_bulk_get_tbl_entry_parms {
+       /**
+        * [in] Receive or transmit direction
+        */
+       enum tf_dir dir;
+       /**
+        * [in] Type of object to get
+        */
+       enum tf_tbl_type type;
+       /**
+        * [in] Starting index to read from
+        */
+       uint32_t starting_idx;
+       /**
+        * [in] Number of sequential entries
+        */
+       uint16_t num_entries;
+       /**
+        * [in] Size of the single entry
+        */
+       uint16_t entry_sz_in_bytes;
+       /**
+        * [out] Host physical address, where the data
+        * will be copied to by the firmware.
+        * Use tfp_calloc() API and mem_pa
+        * variable of the tfp_calloc_parms
+        * structure for the physical address.
+        */
+       uint64_t physical_mem_addr;
+};
+
+/**
+ * Bulk get index table entry
+ *
+ * Used to retrieve a previous set index table entry.
+ *
+ * Reads and compares with the shadow table copy (if enabled) (only
+ * for internal objects).
+ *
+ * Returns success or failure code. Failure will be returned if the
+ * provided data buffer is too small for the data type requested.
+ */
+int tf_bulk_get_tbl_entry(struct tf *tfp,
+                    struct tf_bulk_get_tbl_entry_parms *parms);
+
+/**
+ * @page exact_match Exact Match Table
+ *
+ * @ref tf_insert_em_entry
+ *
+ * @ref tf_delete_em_entry
+ *
+ * @ref tf_search_em_entry
+ *
+ */
+/**
+ * tf_insert_em_entry parameter definition
+ */
+struct tf_insert_em_entry_parms {
+       /**
+        * [in] receive or transmit direction
+        */
+       enum tf_dir dir;
+       /**
+        * [in] internal or external
+        */
+       enum tf_mem mem;
+       /**
+        * [in] ID of table scope to use (external only)
+        */
+       uint32_t tbl_scope_id;
+       /**
+        * [in] ID of table interface to use (SR2 only)
+        */
+       uint32_t tbl_if_id;
+       /**
+        * [in] ptr to structure containing key fields
+        */
+       uint8_t *key;
+       /**
+        * [in] key bit length
+        */
+       uint16_t key_sz_in_bits;
+       /**
+        * [in] ptr to structure containing result field
+        */
+       uint8_t *em_record;
+       /**
+        * [out] result size in bits
+        */
+       uint16_t em_record_sz_in_bits;
+       /**
+        * [in] duplicate check flag
+        */
+       uint8_t dup_check;
+       /**
+        * [out] Flow handle value for the inserted entry.  This is encoded
+        * as the entries[4]:bucket[2]:hashId[1]:hash[14]
+        */
+       uint64_t flow_handle;
+       /**
+        * [out] Flow id is returned as null (internal)
+        * Flow id is the GFID value for the inserted entry (external)
+        * This is the value written to the BD and useful information for mark.
+        */
+       uint64_t flow_id;
+};
+/**
+ * tf_delete_em_entry parameter definition
+ */
+struct tf_delete_em_entry_parms {
+       /**
+        * [in] receive or transmit direction
+        */
+       enum tf_dir dir;
+       /**
+        * [in] internal or external
+        */
+       enum tf_mem mem;
+       /**
+        * [in] ID of table scope to use (external only)
+        */
+       uint32_t tbl_scope_id;
+       /**
+        * [in] ID of table interface to use (SR2 only)
+        */
+       uint32_t tbl_if_id;
+       /**
+        * [in] epoch group IDs of entry to delete
+        * 2 element array with 2 ids. (SR2 only)
+        */
+       uint16_t *epochs;
+       /**
+        * [out] The index of the entry
+        */
+       uint16_t index;
+       /**
+        * [in] structure containing flow delete handle information
+        */
+       uint64_t flow_handle;
 };
+/**
+ * tf_search_em_entry parameter definition
+ */
+struct tf_search_em_entry_parms {
+       /**
+        * [in] receive or transmit direction
+        */
+       enum tf_dir dir;
+       /**
+        * [in] internal or external
+        */
+       enum tf_mem mem;
+       /**
+        * [in] ID of table scope to use (external only)
+        */
+       uint32_t tbl_scope_id;
+       /**
+        * [in] ID of table interface to use (SR2 only)
+        */
+       uint32_t tbl_if_id;
+       /**
+        * [in] ptr to structure containing key fields
+        */
+       uint8_t *key;
+       /**
+        * [in] key bit length
+        */
+       uint16_t key_sz_in_bits;
+       /**
+        * [in/out] ptr to structure containing EM record fields
+        */
+       uint8_t *em_record;
+       /**
+        * [out] result size in bits
+        */
+       uint16_t em_record_sz_in_bits;
+       /**
+        * [in] epoch group IDs of entry to lookup
+        * 2 element array with 2 ids. (SR2 only)
+        */
+       uint16_t *epochs;
+       /**
+        * [in] ptr to structure containing flow delete handle
+        */
+       uint64_t flow_handle;
+};
+
+/**
+ * insert em hash entry in internal table memory
+ *
+ * Internal:
+ *
+ * This API inserts an exact match entry into internal EM table memory
+ * of the specified direction.
+ *
+ * Note: The EM record is managed within the TruFlow core and not the
+ * application.
+ *
+ * Shadow copy of internal record table an association with hash and 1,2, or 4
+ * associated buckets
+ *
+ * External:
+ * This API inserts an exact match entry into DRAM EM table memory of the
+ * specified direction and table scope.
+ *
+ * When inserting an entry into an exact match table, the TruFlow library may
+ * need to allocate a dynamic bucket for the entry (SR2 only).
+ *
+ * The insertion of duplicate entries in an EM table is not permitted. If a
+ * TruFlow application can guarantee that it will never insert duplicates, it
+ * can disable duplicate checking by passing a zero value in the  dup_check
+ * parameter to this API.  This will optimize performance. Otherwise, the
+ * TruFlow library will enforce protection against inserting duplicate entries.
+ *
+ * Flow handle is defined in this document:
+ *
+ * https://docs.google.com
+ * /document/d/1NESu7RpTN3jwxbokaPfYORQyChYRmJgs40wMIRe8_-Q/edit
+ *
+ * Returns success or busy code.
+ *
+ */
+int tf_insert_em_entry(struct tf *tfp,
+                      struct tf_insert_em_entry_parms *parms);
+
+/**
+ * delete em hash entry table memory
+ *
+ * Internal:
+ *
+ * This API deletes an exact match entry from internal EM table memory of the
+ * specified direction. If a valid flow ptr is passed in then that takes
+ * precedence over the pointer to the complete key passed in.
+ *
+ *
+ * External:
+ *
+ * This API deletes an exact match entry from EM table memory of the specified
+ * direction and table scope. If a valid flow handle is passed in then that
+ * takes precedence over the pointer to the complete key passed in.
+ *
+ * The TruFlow library may release a dynamic bucket when an entry is deleted.
+ *
+ *
+ * Returns success or not found code
+ *
+ *
+ */
+int tf_delete_em_entry(struct tf *tfp,
+                      struct tf_delete_em_entry_parms *parms);
+
+/**
+ * search em hash entry table memory
+ *
+ * Internal:
+
+ * This API looks up an EM entry in table memory with the specified EM
+ * key or flow (flow takes precedence) and direction.
+ *
+ * The status will be one of: success or entry not found.  If the lookup
+ * succeeds, a pointer to the matching entry and the result record associated
+ * with the matching entry will be provided.
+ *
+ * If flow_handle is set, search shadow copy.
+ *
+ * Otherwise, query the fw with key to get result.
+ *
+ * External:
+ *
+ * This API looks up an EM entry in table memory with the specified EM
+ * key or flow_handle (flow takes precedence), direction and table scope.
+ *
+ * The status will be one of: success or entry not found.  If the lookup
+ * succeeds, a pointer to the matching entry and the result record associated
+ * with the matching entry will be provided.
+ *
+ * Returns success or not found code
+ *
+ */
+int tf_search_em_entry(struct tf *tfp,
+                      struct tf_search_em_entry_parms *parms);
+
 #endif /* _TF_CORE_H_ */