d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

net/bnxt: add hashing changes for Thor

Browse Source 
- Move HCAPI hashing code to common file and add Thor support.
- Change DPDK EM insert for FKB to use limited size Type 3 key.
- Update FKB builder to be able to tell between EM and WC keys
  during transform.
FKB is the Flexible Key Builder in Thor used while inserting flows.

Signed-off-by: Peter Spreadborough <peter.spreadborough@broadcom.com>
Signed-off-by: Venkat Duvvuru <venkatkumar.duvvuru@broadcom.com>
Reviewed-by: Randy Schacher <stuart.schacher@broadcom.com>
Reviewed-by: Farah Smith <farah.smith@broadcom.com>
Reviewed-by: Ajit Khaparde <ajit.khaparde@broadcom.com>
This commit is contained in:
Peter Spreadborough 2021-05-30 14:28:42 +05:30 committed by Ajit Khaparde
parent 20339b09cf
commit b56a897575
13 changed files with 373 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
drivers/net/bnxt/hcapi/cfa/hcapi_cfa.h
View File

@ -58,10 +58,74 @@ struct hcapi_cfa_devops {
*/
uint64_t (*hcapi_cfa_key_hash)(uint64_t *key_data, uint16_t bitlen);
/** hardware operation on the CFA EM key
*
* This API provides the functionality to program the exact match and
* key data to exact match record memory.
int hcapi_cfa_action_hw_op(struct hcapi_cfa_hwop *op,
uint8_t *act_tbl,
struct hcapi_cfa_data *act_obj);
int hcapi_cfa_dev_hw_op(struct hcapi_cfa_hwop *op, uint16_t tbl_id,
struct hcapi_cfa_data *obj_data);
int hcapi_cfa_rm_register_client(hcapi_cfa_rm_data_t *data,
const char *client_name,
int *client_id);
int hcapi_cfa_rm_unregister_client(hcapi_cfa_rm_data_t *data,
int client_id);
int hcapi_cfa_rm_query_resources(hcapi_cfa_rm_data_t *data,
int client_id,
uint16_t chnl_id,
struct hcapi_cfa_resc_req_db *req_db);
int hcapi_cfa_rm_query_resources_one(hcapi_cfa_rm_data_t *data,
int clien_id,
struct hcapi_cfa_resc_db *resc_db);
int hcapi_cfa_rm_reserve_resources(hcapi_cfa_rm_data_t *data,
int client_id,
struct hcapi_cfa_resc_req_db *resc_req,
struct hcapi_cfa_resc_db *resc_db);
int hcapi_cfa_rm_release_resources(hcapi_cfa_rm_data_t *data,
int client_id,
struct hcapi_cfa_resc_req_db *resc_req,
struct hcapi_cfa_resc_db *resc_db);
int hcapi_cfa_rm_initialize(hcapi_cfa_rm_data_t *data);
#if SUPPORT_CFA_HW_P4
int hcapi_cfa_p4_dev_hw_op(struct hcapi_cfa_hwop *op, uint16_t tbl_id,
struct hcapi_cfa_data *obj_data);
int hcapi_cfa_p4_prof_l2ctxt_hwop(struct hcapi_cfa_hwop *op,
struct hcapi_cfa_data *obj_data);
int hcapi_cfa_p4_prof_l2ctxtrmp_hwop(struct hcapi_cfa_hwop *op,
struct hcapi_cfa_data *obj_data);
int hcapi_cfa_p4_prof_tcam_hwop(struct hcapi_cfa_hwop *op,
struct hcapi_cfa_data *obj_data);
int hcapi_cfa_p4_prof_tcamrmp_hwop(struct hcapi_cfa_hwop *op,
struct hcapi_cfa_data *obj_data);
int hcapi_cfa_p4_wc_tcam_hwop(struct hcapi_cfa_hwop *op,
struct hcapi_cfa_data *obj_data);
int hcapi_cfa_p4_wc_tcam_rec_hwop(struct hcapi_cfa_hwop *op,
struct hcapi_cfa_data *obj_data);
int hcapi_cfa_p4_mirror_hwop(struct hcapi_cfa_hwop *op,
struct hcapi_cfa_data *mirror);
int hcapi_cfa_p4_global_cfg_hwop(struct hcapi_cfa_hwop *op,
uint32_t type,
struct hcapi_cfa_data *config);
/* SUPPORT_CFA_HW_P4 */
#elif SUPPORT_CFA_HW_P45
int hcapi_cfa_p45_mirror_hwop(struct hcapi_cfa_hwop *op,
struct hcapi_cfa_data *mirror);
int hcapi_cfa_p45_global_cfg_hwop(struct hcapi_cfa_hwop *op,
uint32_t type,
struct hcapi_cfa_data *config);
/* SUPPORT_CFA_HW_P45 */
#endif
/**
* HCAPI CFA device HW operation function callback definition
* This is standardized function callback hook to install different
* CFA HW table programming function callback.
*/
struct hcapi_cfa_tbl_cb {
/**
* This function callback provides the functionality to read/write
* HW table entry from a HW table.
*
* @param[in] op
* A pointer to the Hardware operation parameter

85
drivers/net/bnxt/hcapi/cfa/hcapi_cfa_common.c Normal file
View File

@ -0,0 +1,85 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2021 Broadcom
* All rights reserved.
*/
#include "hcapi_cfa_defs.h"
#include <errno.h>
#include "assert.h"
const uint32_t crc32tbl[] = { /* CRC polynomial 0xedb88320 */
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
uint32_t hcapi_cfa_crc32i(uint32_t crc, const uint8_t *buf, size_t len)
{
int l;
for (l = (len - 1); l >= 0; l--)
crc = ucrc32(buf[l], crc);
return ~crc;
}

15
drivers/net/bnxt/hcapi/cfa/hcapi_cfa_defs.h
View File

@ -54,6 +54,16 @@ enum hcapi_cfa_dir {
HCAPI_CFA_DIR_MAX = 2
};
/*
* 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 OPCODE definition
*/
@ -282,4 +292,9 @@ int hcapi_cfa_key_hw_op(struct hcapi_cfa_hwop *op,
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_ */

107
drivers/net/bnxt/hcapi/cfa/hcapi_cfa_p4.c
View File

@ -12,10 +12,9 @@
#include "hcapi_cfa_defs.h"
#define HCAPI_CFA_LKUP_SEED_MEM_SIZE 512
uint32_t hcapi_cfa_lkup_lkup3_init_cfg;
uint32_t hcapi_cfa_lkup_em_seed_mem[HCAPI_CFA_LKUP_SEED_MEM_SIZE];
bool hcapi_cfa_lkup_init;
static uint32_t hcapi_cfa_lkup_lkup3_init_cfg;
static uint32_t hcapi_cfa_lkup_em_seed_mem[HCAPI_CFA_LKUP_SEED_MEM_SIZE];
static bool hcapi_cfa_lkup_init;
static inline uint32_t SWAP_WORDS32(uint32_t val32)
{
@ -47,102 +46,6 @@ static void hcapi_cfa_seeds_init(void)
}
}
/* CRC32i support for Key0 hash */
#define ucrc32(ch, crc) (crc32tbl[((crc) ^ (ch)) & 0xff] ^ ((crc) >> 8))
#define crc32(x, y) crc32i(~0, x, y)
static const uint32_t crc32tbl[] = { /* CRC polynomial 0xedb88320 */
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
static uint32_t hcapi_cfa_crc32i(uint32_t crc, const uint8_t *buf, size_t len)
{
int l;
#ifdef TF_EEM_DEBUG
TFP_DRV_LOG(DEBUG, "CRC2:");
#endif
for (l = (len - 1); l >= 0; l--) {
crc = ucrc32(buf[l], crc);
#ifdef TF_EEM_DEBUG
TFP_DRV_LOG(DEBUG,
"%02X %08X %08X\n",
(buf[l] & 0xff),
crc,
~crc);
#endif
}
#ifdef TF_EEM_DEBUG
TFP_DRV_LOG(DEBUG, "\n");
#endif
return ~crc;
}
static uint32_t hcapi_cfa_crc32_hash(uint8_t *key)
{
int i;
@ -221,8 +124,8 @@ uint64_t hcapi_get_table_page(struct hcapi_cfa_em_table *mem,
* Return:
*
*/
uint64_t hcapi_cfa_key_hash(uint64_t *key_data,
uint16_t bitlen)
uint64_t hcapi_cfa_p4_key_hash(uint64_t *key_data,
uint16_t bitlen)
{
uint32_t key0_hash;
uint32_t key1_hash;

120
drivers/net/bnxt/hcapi/cfa/hcapi_cfa_p58.c Normal file
View File

@ -0,0 +1,120 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2019-2021 Broadcom
* All rights reserved.
*/
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include "lookup3.h"
#include "rand.h"
#include "hcapi_cfa_defs.h"
static uint32_t hcapi_cfa_lkup_lkup3_init_cfg;
static uint32_t hcapi_cfa_lkup_em_seed_mem[HCAPI_CFA_LKUP_SEED_MEM_SIZE];
static bool hcapi_cfa_lkup_init;
static void hcapi_cfa_seeds_init(void)
{
int i;
uint32_t r;
if (hcapi_cfa_lkup_init)
return;
hcapi_cfa_lkup_init = true;
/* Initialize the lfsr */
rand_init();
/* RX and TX use the same seed values */
hcapi_cfa_lkup_lkup3_init_cfg = rand32();
for (i = 0; i < HCAPI_CFA_LKUP_SEED_MEM_SIZE / 2; i++) {
r = rand32();
hcapi_cfa_lkup_em_seed_mem[i * 2] = r;
r = rand32();
hcapi_cfa_lkup_em_seed_mem[i * 2 + 1] = (r & 0x1);
}
}
static uint32_t hcapi_cfa_crc32_hash(uint8_t *key)
{
int i;
uint32_t index;
uint32_t val1, val2;
uint8_t temp[4];
uint8_t *kptr = key;
/* Do byte-wise XOR of the 52-byte HASH key first. */
index = *key;
kptr--;
for (i = CFA_P58_EEM_KEY_MAX_SIZE - 2; i >= 0; i--) {
index = index ^ *kptr;
kptr--;
}
/* Get seeds */
val1 = hcapi_cfa_lkup_em_seed_mem[index * 2];
val2 = hcapi_cfa_lkup_em_seed_mem[index * 2 + 1];
temp[3] = (uint8_t)(val1 >> 24);
temp[2] = (uint8_t)(val1 >> 16);
temp[1] = (uint8_t)(val1 >> 8);
temp[0] = (uint8_t)(val1 & 0xff);
val1 = 0;
/* Start with seed */
if (!(val2 & 0x1))
val1 = hcapi_cfa_crc32i(~val1, temp, 4);
val1 = hcapi_cfa_crc32i(~val1,
(key - (CFA_P58_EEM_KEY_MAX_SIZE - 1)),
CFA_P58_EEM_KEY_MAX_SIZE);
/* End with seed */
if (val2 & 0x1)
val1 = hcapi_cfa_crc32i(~val1, temp, 4);
return val1;
}
static uint32_t hcapi_cfa_lookup3_hash(uint8_t *in_key)
{
uint32_t val1;
val1 = hashword(((uint32_t *)in_key) + 1,
CFA_P58_EEM_KEY_MAX_SIZE / (sizeof(uint32_t)),
hcapi_cfa_lkup_lkup3_init_cfg);
return val1;
}
/** Approximation of HCAPI hcapi_cfa_key_hash()
*
* Return:
*
*/
uint64_t hcapi_cfa_p58_key_hash(uint64_t *key_data,
uint16_t bitlen)
{
uint32_t key0_hash;
uint32_t key1_hash;
/*
* Init the seeds if needed
*/
if (!hcapi_cfa_lkup_init)
hcapi_cfa_seeds_init();
key0_hash = hcapi_cfa_crc32_hash(((uint8_t *)key_data) +
(bitlen / 8) - 1);
key1_hash = hcapi_cfa_lookup3_hash((uint8_t *)key_data);
return ((uint64_t)key0_hash) << 32 | (uint64_t)key1_hash;
}

6
drivers/net/bnxt/hcapi/cfa/hcapi_cfa_p58.h
View File

@ -6,6 +6,12 @@
#ifndef _HCAPI_CFA_P58_H_
#define _HCAPI_CFA_P58_H_
/**
* EEM Key entry sizes
*/
#define CFA_P58_EEM_KEY_MAX_SIZE 80
#define CFA_P58_EEM_KEY_RECORD_SIZE 80
/** CFA phase 5.8 fix formatted table(layout) ID definition
*
*/

4
drivers/net/bnxt/hcapi/cfa/meson.build
View File

@ -7,4 +7,6 @@ includes += include_directories('.')
#Add the source files
sources += files(
'hcapi_cfa_p4.c')
'hcapi_cfa_p4.c',
'hcapi_cfa_p58.c',
'hcapi_cfa_common.c')

15
drivers/net/bnxt/tf_core/tf_device.h
View File

@ -752,6 +752,21 @@ struct tf_dev_ops {
* Size in byte
*/
int (*tf_dev_word_align)(uint16_t size);
/**
* Hash key using crc32 and lookup3
*
* [in] key_data
* Pointer to key
*
* [in] bitlen
* Number of key bits
*
* Returns
* Hashes
*/
uint64_t (*tf_dev_cfa_key_hash)(uint64_t *key_data,
uint16_t bitlen);
};
/**

1
drivers/net/bnxt/tf_core/tf_device_p4.c
View File

@ -276,4 +276,5 @@ const struct tf_dev_ops tf_dev_ops_p4 = {
.tf_dev_get_global_cfg = tf_global_cfg_get,
.tf_dev_get_mailbox = tf_dev_p4_get_mailbox,
.tf_dev_word_align = tf_dev_p4_word_align,
.tf_dev_cfa_key_hash = hcapi_cfa_p4_key_hash
};

1
drivers/net/bnxt/tf_core/tf_device_p58.c
View File

@ -297,4 +297,5 @@ const struct tf_dev_ops tf_dev_ops_p58 = {
.tf_dev_get_global_cfg = tf_global_cfg_get,
.tf_dev_get_mailbox = tf_dev_p58_get_mailbox,
.tf_dev_word_align = tf_dev_p58_word_align,
.tf_dev_cfa_key_hash = hcapi_cfa_p58_key_hash
};

8
drivers/net/bnxt/tf_core/tf_em.h
View File

@ -14,8 +14,10 @@
#define TF_EM_MIN_ENTRIES (1 << 15) /* 32K */
#define TF_EM_MAX_ENTRIES (1 << 27) /* 128M */
#define TF_HW_EM_KEY_MAX_SIZE 52
#define TF_EM_KEY_RECORD_SIZE 64
#define TF_P4_HW_EM_KEY_MAX_SIZE 52
#define TF_P4_EM_KEY_RECORD_SIZE 64
#define TF_P58_HW_EM_KEY_MAX_SIZE 80
#define TF_EM_MAX_MASK 0x7FFF
#define TF_EM_MAX_ENTRY (128 * 1024 * 1024)
@ -95,7 +97,7 @@ struct tf_em_64b_entry {
/** Header is 8 bytes long */
struct cfa_p4_eem_entry_hdr hdr;
/** Key is 448 bits - 56 bytes */
uint8_t key[TF_EM_KEY_RECORD_SIZE - sizeof(struct cfa_p4_eem_entry_hdr)];
uint8_t key[TF_P4_EM_KEY_RECORD_SIZE - sizeof(struct cfa_p4_eem_entry_hdr)];
};
/** EEM Memory Type

42
drivers/net/bnxt/tf_core/tf_em_common.c
View File

@ -284,7 +284,7 @@ tf_em_create_key_entry(struct cfa_p4_eem_entry_hdr *result,
{
key_entry->hdr.word1 = result->word1;
key_entry->hdr.pointer = result->pointer;
memcpy(key_entry->key, in_key, TF_HW_EM_KEY_MAX_SIZE + 4);
memcpy(key_entry->key, in_key, TF_P4_HW_EM_KEY_MAX_SIZE + 4);
}
@ -680,7 +680,8 @@ tf_em_validate_num_entries(struct tf_tbl_scope_cb *tbl_scope_cb,
* TF_ERR_EM_DUP - key is already in table
*/
static int
tf_insert_eem_entry(struct tf_tbl_scope_cb *tbl_scope_cb,
tf_insert_eem_entry(struct tf_dev_info *dev,
struct tf_tbl_scope_cb *tbl_scope_cb,
struct tf_insert_em_entry_parms *parms)
{
uint32_t mask;
@ -706,11 +707,14 @@ tf_insert_eem_entry(struct tf_tbl_scope_cb *tbl_scope_cb,
return -EINVAL;
#ifdef TF_EEM_DEBUG
dump_raw((uint8_t *)parms->key, TF_HW_EM_KEY_MAX_SIZE + 4, "In Key");
dump_raw((uint8_t *)parms->key, TF_P4_HW_EM_KEY_MAX_SIZE + 4, "In Key");
#endif
big_hash = hcapi_cfa_key_hash((uint64_t *)parms->key,
(TF_HW_EM_KEY_MAX_SIZE + 4) * 8);
if (dev->ops->tf_dev_cfa_key_hash == NULL)
return -EINVAL;
big_hash = dev->ops->tf_dev_cfa_key_hash((uint64_t *)parms->key,
(TF_P4_HW_EM_KEY_MAX_SIZE + 4) * 8);
key0_hash = (uint32_t)(big_hash >> 32);
key1_hash = (uint32_t)(big_hash & 0xFFFFFFFF);
@ -739,9 +743,9 @@ tf_insert_eem_entry(struct tf_tbl_scope_cb *tbl_scope_cb,
key_tbl.base0 =
(uint8_t *)&tbl_scope_cb->em_ctx_info[parms->dir].em_tables[TF_KEY0_TABLE];
key_tbl.page_size = TF_EM_PAGE_SIZE;
key_obj.offset = index * TF_EM_KEY_RECORD_SIZE;
key_obj.offset = index * TF_P4_EM_KEY_RECORD_SIZE;
key_obj.data = (uint8_t *)&key_entry;
key_obj.size = TF_EM_KEY_RECORD_SIZE;
key_obj.size = TF_P4_EM_KEY_RECORD_SIZE;
rc = hcapi_cfa_key_hw_op(&op,
&key_tbl,
@ -755,7 +759,7 @@ tf_insert_eem_entry(struct tf_tbl_scope_cb *tbl_scope_cb,
key_tbl.base0 =
(uint8_t *)&tbl_scope_cb->em_ctx_info[parms->dir].em_tables[TF_KEY1_TABLE];
key_obj.offset = index * TF_EM_KEY_RECORD_SIZE;
key_obj.offset = index * TF_P4_EM_KEY_RECORD_SIZE;
rc = hcapi_cfa_key_hw_op(&op,
&key_tbl,
@ -818,9 +822,9 @@ tf_delete_eem_entry(struct tf_tbl_scope_cb *tbl_scope_cb,
(uint8_t *)&tbl_scope_cb->em_ctx_info[parms->dir].em_tables
[(hash_type == 0 ? TF_KEY0_TABLE : TF_KEY1_TABLE)];
key_tbl.page_size = TF_EM_PAGE_SIZE;
key_obj.offset = index * TF_EM_KEY_RECORD_SIZE;
key_obj.offset = index * TF_P4_EM_KEY_RECORD_SIZE;
key_obj.data = NULL;
key_obj.size = TF_EM_KEY_RECORD_SIZE;
key_obj.size = TF_P4_EM_KEY_RECORD_SIZE;
rc = hcapi_cfa_key_hw_op(&op,
&key_tbl,
@ -843,7 +847,10 @@ int
tf_em_insert_ext_entry(struct tf *tfp __rte_unused,
struct tf_insert_em_entry_parms *parms)
{
int rc;
struct tf_tbl_scope_cb *tbl_scope_cb;
struct tf_session *tfs;
struct tf_dev_info *dev;
tbl_scope_cb = tbl_scope_cb_find(parms->tbl_scope_id);
if (tbl_scope_cb == NULL) {
@ -851,9 +858,20 @@ tf_em_insert_ext_entry(struct tf *tfp __rte_unused,
return -EINVAL;
}
/* Retrieve the session information */
rc = tf_session_get_session_internal(tfp, &tfs);
if (rc)
return rc;
/* Retrieve the device information */
rc = tf_session_get_device(tfs, &dev);
if (rc)
return rc;
return tf_insert_eem_entry
(tbl_scope_cb,
parms);
(dev,
tbl_scope_cb,
parms);
}
/** Delete EM hash entry API

22
drivers/net/bnxt/tf_core/tf_em_hash_internal.c
View File

@ -15,6 +15,7 @@
#include "tf_msg.h"
#include "tfp.h"
#include "tf_ext_flow_handle.h"
#include "tf_device.h"
#include "bnxt.h"
@ -43,6 +44,18 @@ tf_em_hash_insert_int_entry(struct tf *tfp,
uint32_t key0_hash;
uint32_t key1_hash;
uint64_t big_hash;
struct tf_dev_info *dev;
struct tf_session *tfs;
/* Retrieve the session information */
rc = tf_session_get_session_internal(tfp, &tfs);
if (rc)
return rc;
/* Retrieve the device information */
rc = tf_session_get_device(tfs, &dev);
if (rc)
return rc;
rc = stack_pop(pool, &index);
if (rc) {
@ -52,8 +65,11 @@ tf_em_hash_insert_int_entry(struct tf *tfp,
return rc;
}
big_hash = hcapi_cfa_key_hash((uint64_t *)parms->key,
(TF_HW_EM_KEY_MAX_SIZE + 4) * 8);
if (dev->ops->tf_dev_cfa_key_hash == NULL)
return -EINVAL;
big_hash = dev->ops->tf_dev_cfa_key_hash((uint64_t *)parms->key,
TF_P58_HW_EM_KEY_MAX_SIZE * 8);
key0_hash = (uint32_t)(big_hash >> 32);
key1_hash = (uint32_t)(big_hash & 0xFFFFFFFF);
@ -93,7 +109,7 @@ tf_em_hash_insert_int_entry(struct tf *tfp,
TF_SET_FIELDS_IN_FLOW_HANDLE(parms->flow_handle,
(uint32_t)num_of_entries,
0,
0,
TF_FLAGS_FLOW_HANDLE_INTERNAL,
rptr_index,
rptr_entry,
0);