/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2019-2021 Broadcom * All rights reserved. */ /*! * \file * \brief Exported functions for CFA HW programming */ #ifndef _HCAPI_CFA_DEFS_H_ #define _HCAPI_CFA_DEFS_H_ #include #include #include #include #include #if !defined(__GNUC__) #pragma anon_unions #endif #define CFA_BITS_PER_BYTE (8) #define CFA_BITS_PER_WORD (sizeof(uint32_t) * CFA_BITS_PER_BYTE) #define __CFA_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask)) #define CFA_ALIGN(x, a) __CFA_ALIGN_MASK((x), (a) - 1) #define CFA_ALIGN_256(x) CFA_ALIGN(x, 256) #define CFA_ALIGN_128(x) CFA_ALIGN(x, 128) #define CFA_ALIGN_32(x) CFA_ALIGN(x, 32) #define NUM_WORDS_ALIGN_32BIT(x) (CFA_ALIGN_32(x) / CFA_BITS_PER_WORD) #define NUM_WORDS_ALIGN_128BIT(x) (CFA_ALIGN_128(x) / CFA_BITS_PER_WORD) #define NUM_WORDS_ALIGN_256BIT(x) (CFA_ALIGN_256(x) / CFA_BITS_PER_WORD) /* TODO: redefine according to chip variant */ #define CFA_GLOBAL_CFG_DATA_SZ (100) #ifndef SUPPORT_CFA_HW_P4 #define SUPPORT_CFA_HW_P4 (0) #endif #ifndef SUPPORT_CFA_HW_P45 #define SUPPORT_CFA_HW_P45 (0) #endif #ifndef SUPPORT_CFA_HW_P58 #define SUPPORT_CFA_HW_P58 (0) #endif #if SUPPORT_CFA_HW_ALL #include "hcapi_cfa_p4.h" #include "hcapi_cfa_p58.h" #endif /* SUPPORT_CFA_HW_ALL */ /* * Hashing defines */ #define HCAPI_CFA_LKUP_SEED_MEM_SIZE 512 /* CRC32i support for Key0 hash */ #define ucrc32(ch, crc) (crc32tbl[((crc) ^ (ch)) & 0xff] ^ ((crc) >> 8)) #define crc32(x, y) crc32i(~0, x, y) /** * CFA HW version definition */ enum hcapi_cfa_ver { HCAPI_CFA_P40 = 0, /**< CFA phase 4.0 */ HCAPI_CFA_P45 = 1, /**< CFA phase 4.5 */ HCAPI_CFA_P58 = 2, /**< CFA phase 5.8 */ HCAPI_CFA_PMAX = 3 }; /** * CFA direction definition */ enum hcapi_cfa_dir { HCAPI_CFA_DIR_RX = 0, /**< Receive */ HCAPI_CFA_DIR_TX = 1, /**< Transmit */ HCAPI_CFA_DIR_MAX = 2 }; /** * CFA HW OPCODE definition */ enum hcapi_cfa_hwops { HCAPI_CFA_HWOPS_PUT, /**< Write to HW operation */ HCAPI_CFA_HWOPS_GET, /**< Read from HW operation */ HCAPI_CFA_HWOPS_ADD, /*< * For operations which require more then * simple writes to HW, this operation is * used. The distinction with this operation * when compared to the PUT ops is that this * operation is used in conjunction with * the HCAPI_CFA_HWOPS_DEL op to remove * the operations issued by the ADD OP. */ HCAPI_CFA_HWOPS_DEL, /*< * Beside to delete from the hardware, this * operation is also undo the add operation * performed by the HCAPI_CFA_HWOPS_ADD op. */ HCAPI_CFA_HWOPS_EVICT, /*< This operation is used to evict entries from * CFA cache memories. This operation is only * applicable to tables that use CFA caches. */ HCAPI_CFA_HWOPS_MAX }; /** * CFA HW KEY CONTROL OPCODE definition */ enum hcapi_cfa_key_ctrlops { HCAPI_CFA_KEY_CTRLOPS_INSERT, /**< insert control bits */ HCAPI_CFA_KEY_CTRLOPS_STRIP, /**< strip control bits */ HCAPI_CFA_KEY_CTRLOPS_MAX }; /** * CFA HW definition */ struct hcapi_cfa_hw { /** [in] HW table base address for the operation with optional device * handle. For on-chip HW table operation, this is the either the TX * or RX CFA HW base address. For off-chip table, this field is the * base memory address of the off-chip table. */ uint64_t base_addr; /** [in] Optional opaque device handle. It is generally used to access * an GRC register space through PCIE BAR and passed to the BAR memory * accessor routine. */ void *handle; }; /** * CFA HW operation definition * */ struct hcapi_cfa_hwop { /** [in] HW opcode */ enum hcapi_cfa_hwops opcode; /** [in] CFA HW information used by accessor routines. */ struct hcapi_cfa_hw hw; }; /** * CFA HW data structure definition */ struct hcapi_cfa_data { /** [in] physical offset to the HW table for the data to be * written to. If this is an array of registers, this is the * index into the array of registers. For writing keys, this * is the byte pointer into the memory where the key should be * written. */ union { uint32_t index; uint32_t byte_offset; }; /** [in] HW data buffer pointer */ uint8_t *data; /** [in] HW data mask buffer pointer. * When the CFA data is a FKB and data_mask pointer * is NULL, then the default mask to enable all bit will * be used. */ uint8_t *data_mask; /** [in/out] size of the HW data buffer in bytes */ uint16_t data_sz; }; /*********************** Truflow start ***************************/ enum hcapi_cfa_pg_tbl_lvl { TF_PT_LVL_0, TF_PT_LVL_1, TF_PT_LVL_2, TF_PT_LVL_MAX }; enum hcapi_cfa_em_table_type { TF_KEY0_TABLE, TF_KEY1_TABLE, TF_RECORD_TABLE, TF_EFC_TABLE, TF_ACTION_TABLE, TF_EM_LKUP_TABLE, TF_MAX_TABLE }; struct hcapi_cfa_em_page_tbl { uint32_t pg_count; uint32_t pg_size; void **pg_va_tbl; uint64_t *pg_pa_tbl; }; struct hcapi_cfa_em_table { int type; uint32_t num_entries; uint16_t ctx_id; uint32_t entry_size; int num_lvl; uint32_t page_cnt[TF_PT_LVL_MAX]; uint64_t num_data_pages; void *l0_addr; uint64_t l0_dma_addr; struct hcapi_cfa_em_page_tbl pg_tbl[TF_PT_LVL_MAX]; }; struct hcapi_cfa_em_ctx_mem_info { struct hcapi_cfa_em_table em_tables[TF_MAX_TABLE]; }; /*********************** Truflow end ****************************/ /** * CFA HW key table definition * * Applicable to EEM and off-chip EM table only. */ struct hcapi_cfa_key_tbl { /** [in] For EEM, this is the KEY0 base mem pointer. For off-chip EM, * this is the base mem pointer of the key table. */ uint8_t *base0; /** [in] total size of the key table in bytes. For EEM, this size is * same for both KEY0 and KEY1 table. */ uint32_t size; /** [in] number of key buckets, applicable for newer chips */ uint32_t num_buckets; /** [in] For EEM, this is KEY1 base mem pointer. For off-chip EM, * this is the key record memory base pointer within the key table, * applicable for newer chip */ uint8_t *base1; /** [in] Optional - If the table is managed by a Backing Store * database, then this object can be use to configure the EM Key. */ struct hcapi_cfa_bs_db *bs_db; /** [in] Page size for EEM tables */ uint32_t page_size; }; /** * CFA HW key buffer definition */ struct hcapi_cfa_key_obj { /** [in] pointer to the key data buffer */ uint32_t *data; /** [in] buffer len in bytes */ uint32_t len; /** [in] Pointer to the key layout */ struct hcapi_cfa_key_layout *layout; }; /** * CFA HW key data definition */ struct hcapi_cfa_key_data { /** [in] For on-chip key table, it is the offset in unit of smallest * key. For off-chip key table, it is the byte offset relative * to the key record memory base and adjusted for page and entry size. */ uint32_t offset; /** [in] HW key data buffer pointer */ uint8_t *data; /** [in] size of the key in bytes */ uint16_t size; /** [in] optional table scope ID */ uint8_t tbl_scope; /** [in] the fid owner of the key */ uint64_t metadata; /** [in] stored with the bucket which can be used by * the caller to retrieve later via the GET HW OP. */ }; /** * CFA HW key location definition */ struct hcapi_cfa_key_loc { /** [out] on-chip EM bucket offset or off-chip EM bucket mem pointer */ uint64_t bucket_mem_ptr; /** [out] off-chip EM key offset mem pointer */ uint64_t mem_ptr; /** [out] index within the array of the EM buckets */ uint32_t bucket_mem_idx; /** [out] index within the EM bucket */ uint8_t bucket_idx; /** [out] index within the EM records */ uint32_t mem_idx; }; /** * Action record info */ struct hcapi_cfa_action_addr { /** [in] action SRAM block ID for on-chip action records or table * scope of the action backing store */ uint16_t blk_id; /** [in] ar_id or cache line aligned address offset for the action * record */ uint32_t offset; }; /** * Action data definition */ struct hcapi_cfa_action_data { /** [in] action record addr info for on-chip action records */ struct hcapi_cfa_action_addr addr; /** [in/out] pointer to the action data buffer */ uint32_t *data; /** [in] action data buffer len in bytes */ uint32_t len; }; /** * Action object definition */ struct hcapi_cfa_action_obj { /** [in] pointer to the action data buffer */ uint32_t *data; /** [in] buffer len in bytes */ uint32_t len; /** [in] pointer to the action layout */ struct hcapi_cfa_action_layout *layout; }; /** * This function is used to hash E/EM keys * * * @param[in] key_data * A pointer of the key * * @param[in] bitlen * Number of bits in the key * * @return * CRC32 and Lookup3 hashes of the input key */ uint64_t hcapi_cfa_key_hash(uint64_t *key_data, uint16_t bitlen); /** * This function is used to execute an operation * * * @param[in] op * Operation * * @param[in] key_tbl * Table * * @param[in] key_obj * Key data * * @param[in] key_key_loc * * @return * 0 for SUCCESS, negative value for FAILURE */ int hcapi_cfa_key_hw_op(struct hcapi_cfa_hwop *op, struct hcapi_cfa_key_tbl *key_tbl, struct hcapi_cfa_key_data *key_obj, struct hcapi_cfa_key_loc *key_loc); uint64_t hcapi_get_table_page(struct hcapi_cfa_em_table *mem, uint32_t page); uint32_t hcapi_cfa_crc32i(uint32_t crc, const uint8_t *buf, size_t len); uint64_t hcapi_cfa_p4_key_hash(uint64_t *key_data, uint16_t bitlen); uint64_t hcapi_cfa_p58_key_hash(uint64_t *key_data, uint16_t bitlen); #endif /* HCAPI_CFA_DEFS_H_ */