1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2019-2020 Broadcom
14 #include "tf_project.h"
19 * Truflow Core API Header File
22 /********** BEGIN Truflow Core DEFINITIONS **********/
25 #define TF_KILOBYTE 1024
26 #define TF_MEGABYTE (1024 * 1024)
32 TF_DIR_RX, /**< Receive */
33 TF_DIR_TX, /**< Transmit */
41 TF_MEM_INTERNAL, /**< Internal */
42 TF_MEM_EXTERNAL, /**< External */
47 * EEM record AR helper
49 * Helper to handle the Action Record Pointer in the EEM Record Entry.
51 * Convert absolute offset to action record pointer in EEM record entry
52 * Convert action record pointer in EEM record entry to absolute offset
54 #define TF_ACT_REC_OFFSET_2_PTR(offset) ((offset) >> 4)
55 #define TF_ACT_REC_PTR_2_OFFSET(offset) ((offset) << 4)
60 #define TF_BITS_2_BYTES(num_bits) (((num_bits) + 7) / 8)
62 /********** BEGIN API FUNCTION PROTOTYPES/PARAMETERS **********/
65 * @page general General
67 * @ref tf_open_session
69 * @ref tf_attach_session
71 * @ref tf_close_session
76 * Session Version defines
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.
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 */
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()
92 #define TF_SESSION_NAME_MAX 64
94 #define TF_FW_SESSION_ID_INVALID 0xFF /**< Invalid FW Session ID define */
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().
105 union tf_session_id {
111 uint8_t fw_session_id;
118 * The version controls the format of the tf_session and
119 * tf_session_info structure. This is to assure upgrade between
120 * versions can be supported.
122 * Please see the TF_VER_MAJOR/MINOR and UPDATE defines.
124 struct tf_session_version {
131 * Session supported device types
133 enum tf_device_type {
134 TF_DEVICE_TYPE_WH = 0, /**< Whitney+ */
135 TF_DEVICE_TYPE_BRD2, /**< TBD */
136 TF_DEVICE_TYPE_BRD3, /**< TBD */
137 TF_DEVICE_TYPE_BRD4, /**< TBD */
138 TF_DEVICE_TYPE_MAX /**< Maximum */
141 /** Identifier resource types
143 enum tf_identifier_type {
144 /** The L2 Context is returned from the L2 Ctxt TCAM lookup
145 * and can be used in WC TCAM or EM keys to virtualize further
148 TF_IDENT_TYPE_L2_CTXT,
149 /** The WC profile func is returned from the L2 Ctxt TCAM lookup
150 * to enable virtualization of the profile TCAM.
152 TF_IDENT_TYPE_PROF_FUNC,
153 /** The WC profile ID is included in the WC lookup key
154 * to enable virtualization of the WC TCAM hardware.
156 TF_IDENT_TYPE_WC_PROF,
157 /** The EM profile ID is included in the EM lookup key
158 * to enable virtualization of the EM hardware. (not required for SR2
159 * as it has table scope)
161 TF_IDENT_TYPE_EM_PROF,
162 /** The L2 func is included in the ILT result and from recycling to
163 * enable virtualization of further lookups.
165 TF_IDENT_TYPE_L2_FUNC,
170 * Enumeration of TruFlow table types. A table type is used to identify a
173 * NOTE: The table type TF_TBL_TYPE_EXT is unique in that it is
174 * the only table type that is connected with a table scope.
179 /** Wh+/SR Action Record */
180 TF_TBL_TYPE_FULL_ACT_RECORD,
181 /** Wh+/SR/Th Multicast Groups */
182 TF_TBL_TYPE_MCAST_GROUPS,
183 /** Wh+/SR Action Encap 8 Bytes */
184 TF_TBL_TYPE_ACT_ENCAP_8B,
185 /** Wh+/SR Action Encap 16 Bytes */
186 TF_TBL_TYPE_ACT_ENCAP_16B,
187 /** Action Encap 32 Bytes */
188 TF_TBL_TYPE_ACT_ENCAP_32B,
189 /** Wh+/SR Action Encap 64 Bytes */
190 TF_TBL_TYPE_ACT_ENCAP_64B,
191 /** Action Source Properties SMAC */
192 TF_TBL_TYPE_ACT_SP_SMAC,
193 /** Wh+/SR Action Source Properties SMAC IPv4 */
194 TF_TBL_TYPE_ACT_SP_SMAC_IPV4,
195 /** Action Source Properties SMAC IPv6 */
196 TF_TBL_TYPE_ACT_SP_SMAC_IPV6,
197 /** Wh+/SR Action Statistics 64 Bits */
198 TF_TBL_TYPE_ACT_STATS_64,
199 /** Wh+/SR Action Modify L4 Src Port */
200 TF_TBL_TYPE_ACT_MODIFY_SPORT,
201 /** Wh+/SR Action Modify L4 Dest Port */
202 TF_TBL_TYPE_ACT_MODIFY_DPORT,
203 /** Wh+/SR Action Modify IPv4 Source */
204 TF_TBL_TYPE_ACT_MODIFY_IPV4_SRC,
205 /** Wh+/SR Action _Modify L4 Dest Port */
206 TF_TBL_TYPE_ACT_MODIFY_IPV4_DEST,
207 /** Action Modify IPv6 Source */
208 TF_TBL_TYPE_ACT_MODIFY_IPV6_SRC,
209 /** Action Modify IPv6 Destination */
210 TF_TBL_TYPE_ACT_MODIFY_IPV6_DEST,
211 /** Meter Profiles */
212 TF_TBL_TYPE_METER_PROF,
213 /** Meter Instance */
214 TF_TBL_TYPE_METER_INST,
216 TF_TBL_TYPE_MIRROR_CONFIG,
219 /** SR2 Epoch 0 table */
221 /** SR2 Epoch 1 table */
224 TF_TBL_TYPE_METADATA,
226 TF_TBL_TYPE_CT_STATE,
227 /** SR2 Range Profile */
228 TF_TBL_TYPE_RANGE_PROF,
229 /** SR2 Range Entry */
230 TF_TBL_TYPE_RANGE_ENTRY,
233 /** SR2 VNIC/SVIF Table */
234 TF_TBL_TYPE_VNIC_SVIF,
235 /** Th/SR2 EM Flexible Key builder */
237 /** Th/SR2 WC Flexible Key builder */
242 /** External table type - initially 1 poolsize entries.
243 * All External table types are associated with a table
244 * scope. Internal types are not.
253 enum tf_tcam_tbl_type {
254 /** L2 Context TCAM */
255 TF_TCAM_TBL_TYPE_L2_CTXT_TCAM,
257 TF_TCAM_TBL_TYPE_PROF_TCAM,
259 TF_TCAM_TBL_TYPE_WC_TCAM,
260 /** Source Properties TCAM */
261 TF_TCAM_TBL_TYPE_SP_TCAM,
262 /** Connection Tracking Rule TCAM */
263 TF_TCAM_TBL_TYPE_CT_RULE_TCAM,
264 /** Virtual Edge Bridge TCAM */
265 TF_TCAM_TBL_TYPE_VEB_TCAM,
271 * These defines are provisioned during
274 enum tf_em_tbl_type {
275 /** The number of internal EM records for the session */
276 TF_EM_TBL_TYPE_EM_RECORD,
277 /** The number of table scopes reequested */
278 TF_EM_TBL_TYPE_TBL_SCOPE,
282 /** TruFlow Session Information
284 * Structure defining a TruFlow Session, also known as a Management
285 * session. This structure is initialized at time of
286 * tf_open_session(). It is passed to all of the TruFlow APIs as way
287 * to prescribe and isolate resources between different TruFlow ULP
290 struct tf_session_info {
292 * TrueFlow Version. Used to control the structure layout when
293 * sharing sessions. No guarantee that a secondary process
294 * would come from the same version of an executable.
295 * TruFlow initializes this variable on tf_open_session().
300 struct tf_session_version ver;
302 * will be STAILQ_ENTRY(tf_session_info) next
309 * Session ID is a unique identifier for the session. TruFlow
310 * initializes this variable during tf_open_session()
314 * Access: Truflow & ULP
316 union tf_session_id session_id;
318 * Protects access to core_data. Lock is initialized and owned
319 * by ULP. TruFlow can access the core_data without checking
327 * The core_data holds the TruFlow tf_session data
328 * structure. This memory is allocated and owned by TruFlow on
331 * TruFlow uses this memory for session management control
332 * until the session is closed by ULP. Access control is done
333 * by the spin_lock which ULP controls ahead of TruFlow API
336 * Please see tf_open_session_parms for specification details
344 * The core_data_sz_bytes specifies the size of core_data in
347 * The size is set by TruFlow on tf_open_session().
349 * Please see tf_open_session_parms for specification details
355 uint32_t core_data_sz_bytes;
360 * Contains a pointer to the session info. Allocated by ULP and passed
361 * to TruFlow using tf_open_session(). TruFlow will populate the
362 * session info at that time. Additional 'opens' can be done using
363 * same session_info by using tf_attach_session().
365 * It is expected that ULP allocates this memory as shared memory.
367 * NOTE: This struct must be within the BNXT PMD struct bnxt
368 * (bp). This allows use of container_of() to get access to the PMD.
371 struct tf_session_info *session;
375 * tf_session_resources parameter definition.
377 struct tf_session_resources {
378 /** [in] Requested Identifier Resources
380 * The number of identifier resources requested for the session.
381 * The index used is tf_identifier_type.
383 uint16_t identifier_cnt[TF_IDENT_TYPE_MAX][TF_DIR_MAX];
384 /** [in] Requested Index Table resource counts
386 * The number of index table resources requested for the session.
387 * The index used is tf_tbl_type.
389 uint16_t tbl_cnt[TF_TBL_TYPE_MAX][TF_DIR_MAX];
390 /** [in] Requested TCAM Table resource counts
392 * The number of TCAM table resources requested for the session.
393 * The index used is tf_tcam_tbl_type.
395 uint16_t tcam_tbl_cnt[TF_TCAM_TBL_TYPE_MAX][TF_DIR_MAX];
396 /** [in] Requested EM resource counts
398 * The number of internal EM table resources requested for the session
399 * The index used is tf_em_tbl_type.
401 uint16_t em_tbl_cnt[TF_EM_TBL_TYPE_MAX][TF_DIR_MAX];
405 * tf_open_session parameters definition.
407 struct tf_open_session_parms {
408 /** [in] ctrl_chan_name
410 * String containing name of control channel interface to be
411 * used for this session to communicate with firmware.
413 * The ctrl_chan_name can be looked up by using
414 * rte_eth_dev_get_name_by_port() within the ULP.
416 * ctrl_chan_name will be used as part of a name for any
417 * shared memory allocation.
419 char ctrl_chan_name[TF_SESSION_NAME_MAX];
422 * Boolean controlling the use and availability of shadow
423 * copy. Shadow copy will allow the TruFlow to keep track of
424 * resource content on the firmware side without having to
425 * query firmware. Additional private session core_data will
426 * be allocated if this boolean is set to 'true', default
429 * Size of memory depends on the NVM Resource settings for the
433 /** [in/out] session_id
435 * Session_id is unique per session.
437 * Session_id is composed of domain, bus, device and
438 * fw_session_id. The construction is done by parsing the
439 * ctrl_chan_name together with allocation of a fw_session_id.
441 * The session_id allows a session to be shared between devices.
443 union tf_session_id session_id;
446 * Device type is passed, one of Wh+, SR, Thor, SR2
448 enum tf_device_type device_type;
451 * Resource allocation
453 struct tf_session_resources resources;
457 * Opens a new TruFlow management session.
459 * TruFlow will allocate session specific memory, shared memory, to
460 * hold its session data. This data is private to TruFlow.
462 * Multiple PFs can share the same session. An association, refcount,
463 * between session and PFs is maintained within TruFlow. Thus, a PF
464 * can attach to an existing session, see tf_attach_session().
466 * No other TruFlow APIs will succeed unless this API is first called and
469 * tf_open_session() returns a session id that can be used on attach.
472 * Pointer to TF handle
474 * Pointer to open parameters
477 * - (0) if successful.
478 * - (-EINVAL) on failure.
480 int tf_open_session(struct tf *tfp,
481 struct tf_open_session_parms *parms);
483 int tf_open_session_new(struct tf *tfp,
484 struct tf_open_session_parms *parms);
486 struct tf_attach_session_parms {
487 /** [in] ctrl_chan_name
489 * String containing name of control channel interface to be
490 * used for this session to communicate with firmware.
492 * The ctrl_chan_name can be looked up by using
493 * rte_eth_dev_get_name_by_port() within the ULP.
495 * ctrl_chan_name will be used as part of a name for any
496 * shared memory allocation.
498 char ctrl_chan_name[TF_SESSION_NAME_MAX];
500 /** [in] attach_chan_name
502 * String containing name of attach channel interface to be
503 * used for this session.
505 * The attach_chan_name must be given to a 2nd process after
506 * the primary process has been created. This is the
507 * ctrl_chan_name of the primary process and is used to find
508 * the shared memory for the session that the attach is going
511 char attach_chan_name[TF_SESSION_NAME_MAX];
515 * Session_id is unique per session. For Attach the session_id
516 * should be the session_id that was returned on the first
519 * Session_id is composed of domain, bus, device and
520 * fw_session_id. The construction is done by parsing the
521 * ctrl_chan_name together with allocation of a fw_session_id
522 * during tf_open_session().
524 * A reference count will be incremented on attach. A session
525 * is first fully closed when reference count is zero by
526 * calling tf_close_session().
528 union tf_session_id session_id;
532 * Attaches to an existing session. Used when more than one PF wants
533 * to share a single session. In that case all TruFlow management
534 * traffic will be sent to the TruFlow firmware using the 'PF' that
535 * did the attach not the session ctrl channel.
537 * Attach will increment a ref count as to manage the shared session data.
539 * [in] tfp, pointer to TF handle
540 * [in] parms, pointer to attach parameters
543 * - (0) if successful.
544 * - (-EINVAL) on failure.
546 int tf_attach_session(struct tf *tfp,
547 struct tf_attach_session_parms *parms);
548 int tf_attach_session_new(struct tf *tfp,
549 struct tf_attach_session_parms *parms);
552 * Closes an existing session. Cleans up all hardware and firmware
553 * state associated with the TruFlow application session when the last
554 * PF associated with the session results in refcount to be zero.
556 * Returns success or failure code.
558 int tf_close_session(struct tf *tfp);
559 int tf_close_session_new(struct tf *tfp);
562 * @page ident Identity Management
564 * @ref tf_alloc_identifier
566 * @ref tf_free_identifier
568 /** tf_alloc_identifier parameter definition
570 struct tf_alloc_identifier_parms {
572 * [in] receive or transmit direction
576 * [in] Identifier type
578 enum tf_identifier_type ident_type;
580 * [out] Identifier allocated
585 /** tf_free_identifier parameter definition
587 struct tf_free_identifier_parms {
589 * [in] receive or transmit direction
593 * [in] Identifier type
595 enum tf_identifier_type ident_type;
602 /** allocate identifier resource
604 * TruFlow core will allocate a free id from the per identifier resource type
605 * pool reserved for the session during tf_open(). No firmware is involved.
607 * Returns success or failure code.
609 int tf_alloc_identifier(struct tf *tfp,
610 struct tf_alloc_identifier_parms *parms);
611 int tf_alloc_identifier_new(struct tf *tfp,
612 struct tf_alloc_identifier_parms *parms);
614 /** free identifier resource
616 * TruFlow core will return an id back to the per identifier resource type pool
617 * reserved for the session. No firmware is involved. During tf_close, the
618 * complete pool is returned to the firmware.
620 * Returns success or failure code.
622 int tf_free_identifier(struct tf *tfp,
623 struct tf_free_identifier_parms *parms);
624 int tf_free_identifier_new(struct tf *tfp,
625 struct tf_free_identifier_parms *parms);
628 * @page dram_table DRAM Table Scope Interface
630 * @ref tf_alloc_tbl_scope
632 * @ref tf_free_tbl_scope
634 * If we allocate the EEM memory from the core, we need to store it in
635 * the shared session data structure to make sure it can be freed later.
636 * (for example if the PF goes away)
638 * Current thought is that memory is allocated within core.
642 /** tf_alloc_tbl_scope_parms definition
644 struct tf_alloc_tbl_scope_parms {
646 * [in] All Maximum key size required.
648 uint16_t rx_max_key_sz_in_bits;
650 * [in] Maximum Action size required (includes inlined items)
652 uint16_t rx_max_action_entry_sz_in_bits;
654 * [in] Memory size in Megabytes
655 * Total memory size allocated by user to be divided
656 * up for actions, hash, counters. Only inline external actions.
657 * Use this variable or the number of flows, do not set both.
659 uint32_t rx_mem_size_in_mb;
661 * [in] Number of flows * 1000. If set, rx_mem_size_in_mb must equal 0.
663 uint32_t rx_num_flows_in_k;
665 * [in] Brd4 only receive table access interface id
667 uint32_t rx_tbl_if_id;
669 * [in] All Maximum key size required.
671 uint16_t tx_max_key_sz_in_bits;
673 * [in] Maximum Action size required (includes inlined items)
675 uint16_t tx_max_action_entry_sz_in_bits;
677 * [in] Memory size in Megabytes
678 * Total memory size allocated by user to be divided
679 * up for actions, hash, counters. Only inline external actions.
681 uint32_t tx_mem_size_in_mb;
683 * [in] Number of flows * 1000
685 uint32_t tx_num_flows_in_k;
687 * [in] Brd4 only receive table access interface id
689 uint32_t tx_tbl_if_id;
691 * [in] Flush pending HW cached flows every 1/10th of value
692 * set in seconds, both idle and active flows are flushed
693 * from the HW cache. If set to 0, this feature will be disabled.
695 uint8_t hw_flow_cache_flush_timer;
697 * [out] table scope identifier
699 uint32_t tbl_scope_id;
702 struct tf_free_tbl_scope_parms {
704 * [in] table scope identifier
706 uint32_t tbl_scope_id;
710 * allocate a table scope
712 * On Brd4 Firmware will allocate a scope ID. On other devices, the scope
713 * is a software construct to identify an EEM table. This function will
714 * divide the hash memory/buckets and records according to the device
715 * device constraints based upon calculations using either the number of flows
716 * requested or the size of memory indicated. Other parameters passed in
717 * determine the configuration (maximum key size, maximum external action record
720 * This API will allocate the table region in
721 * DRAM, program the PTU page table entries, and program the number of static
722 * buckets (if Brd4) in the RX and TX CFAs. Buckets are assumed to start at
723 * 0 in the EM memory for the scope. Upon successful completion of this API,
724 * hash tables are fully initialized and ready for entries to be inserted.
726 * A single API is used to allocate a common table scope identifier in both
727 * receive and transmit CFA. The scope identifier is common due to nature of
728 * connection tracking sending notifications between RX and TX direction.
730 * The receive and transmit table access identifiers specify which rings will
731 * be used to initialize table DRAM. The application must ensure mutual
732 * exclusivity of ring usage for table scope allocation and any table update
735 * The hash table buckets, EM keys, and EM lookup results are stored in the
736 * memory allocated based on the rx_em_hash_mb/tx_em_hash_mb parameters. The
737 * hash table buckets are stored at the beginning of that memory.
739 * NOTE: No EM internal setup is done here. On chip EM records are managed
740 * internally by TruFlow core.
742 * Returns success or failure code.
744 int tf_alloc_tbl_scope(struct tf *tfp,
745 struct tf_alloc_tbl_scope_parms *parms);
751 * Firmware checks that the table scope ID is owned by the TruFlow
752 * session, verifies that no references to this table scope remains
753 * (Brd4 ILT) or Profile TCAM entries for either CFA (RX/TX) direction,
754 * then frees the table scope ID.
756 * Returns success or failure code.
758 int tf_free_tbl_scope(struct tf *tfp,
759 struct tf_free_tbl_scope_parms *parms);
763 * @page tcam TCAM Access
765 * @ref tf_alloc_tcam_entry
767 * @ref tf_set_tcam_entry
769 * @ref tf_get_tcam_entry
771 * @ref tf_free_tcam_entry
774 /** tf_alloc_tcam_entry parameter definition
776 struct tf_alloc_tcam_entry_parms {
778 * [in] receive or transmit direction
782 * [in] TCAM table type
784 enum tf_tcam_tbl_type tcam_tbl_type;
786 * [in] Enable search for matching entry
788 uint8_t search_enable;
790 * [in] Key data to match on (if search)
794 * [in] key size in bits (if search)
796 uint16_t key_sz_in_bits;
798 * [in] Mask data to match on (if search)
802 * [in] Priority of entry requested
803 * 0: index from top i.e. highest priority first
804 * !0: index from bottom i.e lowest priority first
808 * [out] If search, set if matching entry found
812 * [out] Current refcnt after allocation
816 * [out] Idx allocated
822 /** allocate TCAM entry
824 * Allocate a TCAM entry - one of these types:
831 * This function allocates a TCAM table record. This function
832 * will attempt to allocate a TCAM table entry from the session
833 * owned TCAM entries or search a shadow copy of the TCAM table for a
834 * matching entry if search is enabled. Key, mask and result must match for
835 * hit to be set. Only TruFlow core data is accessed.
836 * A hash table to entry mapping is maintained for search purposes. If
837 * search is not enabled, the first available free entry is returned based
838 * on priority and alloc_cnt is set to 1. If search is enabled and a matching
839 * entry to entry_data is found, hit is set to TRUE and alloc_cnt is set to 1.
840 * RefCnt is also returned.
842 * Also returns success or failure code.
844 int tf_alloc_tcam_entry(struct tf *tfp,
845 struct tf_alloc_tcam_entry_parms *parms);
847 /** tf_set_tcam_entry parameter definition
849 struct tf_set_tcam_entry_parms {
851 * [in] receive or transmit direction
855 * [in] TCAM table type
857 enum tf_tcam_tbl_type tcam_tbl_type;
859 * [in] base index of the entry to program
863 * [in] struct containing key
867 * [in] struct containing mask fields
871 * [in] key size in bits (if search)
873 uint16_t key_sz_in_bits;
875 * [in] struct containing result
879 * [in] struct containing result size in bits
881 uint16_t result_sz_in_bits;
886 * Program a TCAM table entry for a TruFlow session.
888 * If the entry has not been allocated, an error will be returned.
890 * Returns success or failure code.
892 int tf_set_tcam_entry(struct tf *tfp,
893 struct tf_set_tcam_entry_parms *parms);
895 /** tf_get_tcam_entry parameter definition
897 struct tf_get_tcam_entry_parms {
899 * [in] receive or transmit direction
903 * [in] TCAM table type
905 enum tf_tcam_tbl_type tcam_tbl_type;
907 * [in] index of the entry to get
911 * [out] struct containing key
915 * [out] struct containing mask fields
919 * [out] key size in bits
921 uint16_t key_sz_in_bits;
923 * [out] struct containing result
927 * [out] struct containing result size in bits
929 uint16_t result_sz_in_bits;
935 * Program a TCAM table entry for a TruFlow session.
937 * If the entry has not been allocated, an error will be returned.
939 * Returns success or failure code.
941 int tf_get_tcam_entry(struct tf *tfp,
942 struct tf_get_tcam_entry_parms *parms);
945 * tf_free_tcam_entry parameter definition
947 struct tf_free_tcam_entry_parms {
949 * [in] receive or transmit direction
953 * [in] TCAM table type
955 enum tf_tcam_tbl_type tcam_tbl_type;
961 * [out] reference count after free
969 * Firmware checks to ensure the TCAM entries are owned by the TruFlow
970 * session. TCAM entry will be invalidated. All-ones mask.
973 * WCTCAM profile id of 0 must be used to invalidate an entry.
975 * Returns success or failure code.
977 int tf_free_tcam_entry(struct tf *tfp,
978 struct tf_free_tcam_entry_parms *parms);
981 * @page table Table Access
983 * @ref tf_alloc_tbl_entry
985 * @ref tf_free_tbl_entry
987 * @ref tf_set_tbl_entry
989 * @ref tf_get_tbl_entry
993 * tf_alloc_tbl_entry parameter definition
995 struct tf_alloc_tbl_entry_parms {
997 * [in] Receive or transmit direction
1001 * [in] Type of the allocation
1003 enum tf_tbl_type type;
1005 * [in] Table scope identifier (ignored unless TF_TBL_TYPE_EXT)
1007 uint32_t tbl_scope_id;
1009 * [in] Enable search for matching entry. If the table type is
1010 * internal the shadow copy will be searched before
1011 * alloc. Session must be configured with shadow copy enabled.
1013 uint8_t search_enable;
1015 * [in] Result data to search for (if search_enable)
1019 * [in] Result data size in bytes (if search_enable)
1021 uint16_t result_sz_in_bytes;
1023 * [out] If search_enable, set if matching entry found
1027 * [out] Current ref count after allocation (if search_enable)
1031 * [out] Idx of allocated entry or found entry (if search_enable)
1037 * allocate index table entries
1041 * Allocate an on chip index table entry or search for a matching
1042 * entry of the indicated type for this TruFlow session.
1044 * Allocates an index table record. This function will attempt to
1045 * allocate an entry or search an index table for a matching entry if
1046 * search is enabled (only the shadow copy of the table is accessed).
1048 * If search is not enabled, the first available free entry is
1049 * returned. If search is enabled and a matching entry to entry_data
1050 * is found hit is set to TRUE and success is returned.
1054 * These are used to allocate inlined action record memory.
1056 * Allocates an external index table action record.
1059 * Implementation of the internals of this function will be a stack with push
1062 * Returns success or failure code.
1064 int tf_alloc_tbl_entry(struct tf *tfp,
1065 struct tf_alloc_tbl_entry_parms *parms);
1068 * tf_free_tbl_entry parameter definition
1070 struct tf_free_tbl_entry_parms {
1072 * [in] Receive or transmit direction
1076 * [in] Type of the allocation type
1078 enum tf_tbl_type type;
1080 * [in] Table scope identifier (ignored unless TF_TBL_TYPE_EXT)
1082 uint32_t tbl_scope_id;
1084 * [in] Index to free
1088 * [out] Reference count after free, only valid if session has been
1089 * created with shadow_copy.
1095 * free index table entry
1097 * Used to free a previously allocated table entry.
1101 * If session has shadow_copy enabled the shadow DB is searched and if
1102 * found the element ref_cnt is decremented. If ref_cnt goes to
1103 * zero then the element is returned to the session pool.
1105 * If the session does not have a shadow DB the element is free'ed and
1106 * given back to the session pool.
1110 * Free's an external index table action record.
1113 * Implementation of the internals of this function will be a stack with push
1116 * Returns success or failure code.
1118 int tf_free_tbl_entry(struct tf *tfp,
1119 struct tf_free_tbl_entry_parms *parms);
1122 * tf_set_tbl_entry parameter definition
1124 struct tf_set_tbl_entry_parms {
1126 * [in] Table scope identifier
1128 uint32_t tbl_scope_id;
1130 * [in] Receive or transmit direction
1134 * [in] Type of object to set
1136 enum tf_tbl_type type;
1144 uint16_t data_sz_in_bytes;
1146 * [in] Entry index to write to
1152 * set index table entry
1154 * Used to insert an application programmed index table entry into a
1155 * previous allocated table location. A shadow copy of the table
1156 * is maintained (if enabled) (only for internal objects)
1158 * Returns success or failure code.
1160 int tf_set_tbl_entry(struct tf *tfp,
1161 struct tf_set_tbl_entry_parms *parms);
1164 * tf_get_tbl_entry parameter definition
1166 struct tf_get_tbl_entry_parms {
1168 * [in] Receive or transmit direction
1172 * [in] Type of object to get
1174 enum tf_tbl_type type;
1182 uint16_t data_sz_in_bytes;
1184 * [in] Entry index to read
1190 * get index table entry
1192 * Used to retrieve a previous set index table entry.
1194 * Reads and compares with the shadow table copy (if enabled) (only
1195 * for internal objects).
1197 * Returns success or failure code. Failure will be returned if the
1198 * provided data buffer is too small for the data type requested.
1200 int tf_get_tbl_entry(struct tf *tfp,
1201 struct tf_get_tbl_entry_parms *parms);
1204 * tf_get_bulk_tbl_entry parameter definition
1206 struct tf_get_bulk_tbl_entry_parms {
1208 * [in] Receive or transmit direction
1212 * [in] Type of object to get
1214 enum tf_tbl_type type;
1216 * [in] Clear hardware entries on reads only
1217 * supported for TF_TBL_TYPE_ACT_STATS_64
1221 * [in] Starting index to read from
1223 uint32_t starting_idx;
1225 * [in] Number of sequential entries
1227 uint16_t num_entries;
1229 * [in] Size of the single entry
1231 uint16_t entry_sz_in_bytes;
1233 * [out] Host physical address, where the data
1234 * will be copied to by the firmware.
1235 * Use tfp_calloc() API and mem_pa
1236 * variable of the tfp_calloc_parms
1237 * structure for the physical address.
1239 uint64_t physical_mem_addr;
1243 * Bulk get index table entry
1245 * Used to retrieve a previous set index table entry.
1247 * Reads and compares with the shadow table copy (if enabled) (only
1248 * for internal objects).
1250 * Returns success or failure code. Failure will be returned if the
1251 * provided data buffer is too small for the data type requested.
1253 int tf_get_bulk_tbl_entry(struct tf *tfp,
1254 struct tf_get_bulk_tbl_entry_parms *parms);
1257 * @page exact_match Exact Match Table
1259 * @ref tf_insert_em_entry
1261 * @ref tf_delete_em_entry
1263 * @ref tf_search_em_entry
1267 * tf_insert_em_entry parameter definition
1269 struct tf_insert_em_entry_parms {
1271 * [in] receive or transmit direction
1275 * [in] internal or external
1279 * [in] ID of table scope to use (external only)
1281 uint32_t tbl_scope_id;
1283 * [in] ID of table interface to use (Brd4 only)
1287 * [in] ptr to structure containing key fields
1291 * [in] key bit length
1293 uint16_t key_sz_in_bits;
1295 * [in] ptr to structure containing result field
1299 * [out] result size in bits
1301 uint16_t em_record_sz_in_bits;
1303 * [in] duplicate check flag
1307 * [out] Flow handle value for the inserted entry. This is encoded
1308 * as the entries[4]:bucket[2]:hashId[1]:hash[14]
1310 uint64_t flow_handle;
1312 * [out] Flow id is returned as null (internal)
1313 * Flow id is the GFID value for the inserted entry (external)
1314 * This is the value written to the BD and useful information for mark.
1319 * tf_delete_em_entry parameter definition
1321 struct tf_delete_em_entry_parms {
1323 * [in] receive or transmit direction
1327 * [in] internal or external
1331 * [in] ID of table scope to use (external only)
1333 uint32_t tbl_scope_id;
1335 * [in] ID of table interface to use (Brd4 only)
1339 * [in] epoch group IDs of entry to delete
1340 * 2 element array with 2 ids. (Brd4 only)
1344 * [out] The index of the entry
1348 * [in] structure containing flow delete handle information
1350 uint64_t flow_handle;
1353 * tf_search_em_entry parameter definition
1355 struct tf_search_em_entry_parms {
1357 * [in] receive or transmit direction
1361 * [in] internal or external
1365 * [in] ID of table scope to use (external only)
1367 uint32_t tbl_scope_id;
1369 * [in] ID of table interface to use (Brd4 only)
1373 * [in] ptr to structure containing key fields
1377 * [in] key bit length
1379 uint16_t key_sz_in_bits;
1381 * [in/out] ptr to structure containing EM record fields
1385 * [out] result size in bits
1387 uint16_t em_record_sz_in_bits;
1389 * [in] epoch group IDs of entry to lookup
1390 * 2 element array with 2 ids. (Brd4 only)
1394 * [in] ptr to structure containing flow delete handle
1396 uint64_t flow_handle;
1400 * insert em hash entry in internal table memory
1404 * This API inserts an exact match entry into internal EM table memory
1405 * of the specified direction.
1407 * Note: The EM record is managed within the TruFlow core and not the
1410 * Shadow copy of internal record table an association with hash and 1,2, or 4
1411 * associated buckets
1414 * This API inserts an exact match entry into DRAM EM table memory of the
1415 * specified direction and table scope.
1417 * When inserting an entry into an exact match table, the TruFlow library may
1418 * need to allocate a dynamic bucket for the entry (Brd4 only).
1420 * The insertion of duplicate entries in an EM table is not permitted. If a
1421 * TruFlow application can guarantee that it will never insert duplicates, it
1422 * can disable duplicate checking by passing a zero value in the dup_check
1423 * parameter to this API. This will optimize performance. Otherwise, the
1424 * TruFlow library will enforce protection against inserting duplicate entries.
1426 * Flow handle is defined in this document:
1428 * https://docs.google.com
1429 * /document/d/1NESu7RpTN3jwxbokaPfYORQyChYRmJgs40wMIRe8_-Q/edit
1431 * Returns success or busy code.
1434 int tf_insert_em_entry(struct tf *tfp,
1435 struct tf_insert_em_entry_parms *parms);
1438 * delete em hash entry table memory
1442 * This API deletes an exact match entry from internal EM table memory of the
1443 * specified direction. If a valid flow ptr is passed in then that takes
1444 * precedence over the pointer to the complete key passed in.
1449 * This API deletes an exact match entry from EM table memory of the specified
1450 * direction and table scope. If a valid flow handle is passed in then that
1451 * takes precedence over the pointer to the complete key passed in.
1453 * The TruFlow library may release a dynamic bucket when an entry is deleted.
1456 * Returns success or not found code
1460 int tf_delete_em_entry(struct tf *tfp,
1461 struct tf_delete_em_entry_parms *parms);
1464 * search em hash entry table memory
1468 * This API looks up an EM entry in table memory with the specified EM
1469 * key or flow (flow takes precedence) and direction.
1471 * The status will be one of: success or entry not found. If the lookup
1472 * succeeds, a pointer to the matching entry and the result record associated
1473 * with the matching entry will be provided.
1475 * If flow_handle is set, search shadow copy.
1477 * Otherwise, query the fw with key to get result.
1481 * This API looks up an EM entry in table memory with the specified EM
1482 * key or flow_handle (flow takes precedence), direction and table scope.
1484 * The status will be one of: success or entry not found. If the lookup
1485 * succeeds, a pointer to the matching entry and the result record associated
1486 * with the matching entry will be provided.
1488 * Returns success or not found code
1491 int tf_search_em_entry(struct tf *tfp,
1492 struct tf_search_em_entry_parms *parms);
1493 #endif /* _TF_CORE_H_ */