TWxSoftware/twx-linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ice: add parser internal helper functions

Browse Source 
Add the following internal helper functions:

- ice_bst_tcam_match():
  to perform ternary match on boost TCAM.

- ice_pg_cam_match():
  to perform parse graph key match in cam table.

- ice_pg_nm_cam_match():
  to perform parse graph key no match in cam table.

- ice_ptype_mk_tcam_match():
  to perform ptype markers match in tcam table.

- ice_flg_redirect():
  to redirect parser flags to packet flags.

- ice_xlt_kb_flag_get():
  to aggregate 64 bit packet flag into 16 bit key builder flags.

Reviewed-by: Simon Horman <horms@kernel.org>
Reviewed-by: Aleksandr Loktionov <aleksandr.loktionov@intel.com>
Reviewed-by: Wojciech Drewek <wojciech.drewek@intel.com>
Reviewed-by: Marcin Szycik <marcin.szycik@linux.intel.com>
Signed-off-by: Qi Zhang <qi.z.zhang@intel.com>
Signed-off-by: Junfeng Guo <junfeng.guo@intel.com>
Signed-off-by: Ahmed Zaki <ahmed.zaki@intel.com>
Tested-by: Rafal Romanowski <rafal.romanowski@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
This commit is contained in:
Junfeng Guo
2024-07-25 16:08:00 -06:00
committed by Tony Nguyen
parent 68add28818
commit 4851f12c8d
2 changed files with 244 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/net/ethernet/intel/ice/ice_parser.c
+208
View File
@@ -957,6 +957,109 @@ static struct ice_pg_nm_cam_item *ice_pg_nm_sp_cam_table_get(struct ice_hw *hw)
ice_pg_nm_sp_cam_parse_item, false);
}
static bool __ice_pg_cam_match(struct ice_pg_cam_item *item,
struct ice_pg_cam_key *key)
{
return (item->key.valid &&
!memcmp(&item->key.val, &key->val, sizeof(key->val)));
}
static bool __ice_pg_nm_cam_match(struct ice_pg_nm_cam_item *item,
struct ice_pg_cam_key *key)
{
return (item->key.valid &&
!memcmp(&item->key.val, &key->val, sizeof(item->key.val)));
}
/**
* ice_pg_cam_match - search parse graph cam table by key
* @table: parse graph cam table to search
* @size: cam table size
* @key: search key
*
* Return: a pointer to the matching PG CAM item or NULL.
*/
struct ice_pg_cam_item *ice_pg_cam_match(struct ice_pg_cam_item *table,
int size, struct ice_pg_cam_key *key)
{
int i;
for (i = 0; i < size; i++) {
struct ice_pg_cam_item *item = &table[i];
if (__ice_pg_cam_match(item, key))
return item;
}
return NULL;
}
/**
* ice_pg_nm_cam_match - search parse graph no match cam table by key
* @table: parse graph no match cam table to search
* @size: cam table size
* @key: search key
*
* Return: a pointer to the matching PG No Match CAM item or NULL.
*/
struct ice_pg_nm_cam_item *
ice_pg_nm_cam_match(struct ice_pg_nm_cam_item *table, int size,
struct ice_pg_cam_key *key)
{
int i;
for (i = 0; i < size; i++) {
struct ice_pg_nm_cam_item *item = &table[i];
if (__ice_pg_nm_cam_match(item, key))
return item;
}
return NULL;
}
/*** Ternary match ***/
/* Perform a ternary match on a 1-byte pattern (@pat) given @key and @key_inv
* Rules (per bit):
* Key == 0 and Key_inv == 0 : Never match (Don't care)
* Key == 0 and Key_inv == 1 : Match on bit == 1
* Key == 1 and Key_inv == 0 : Match on bit == 0
* Key == 1 and Key_inv == 1 : Always match (Don't care)
*
* Return: true if all bits match, false otherwise.
*/
static bool ice_ternary_match_byte(u8 key, u8 key_inv, u8 pat)
{
u8 bit_key, bit_key_inv, bit_pat;
int i;
for (i = 0; i < BITS_PER_BYTE; i++) {
bit_key = key & BIT(i);
bit_key_inv = key_inv & BIT(i);
bit_pat = pat & BIT(i);
if (bit_key != 0 && bit_key_inv != 0)
continue;
if ((bit_key == 0 && bit_key_inv == 0) || bit_key == bit_pat)
return false;
}
return true;
}
static bool ice_ternary_match(const u8 *key, const u8 *key_inv,
const u8 *pat, int len)
{
int i;
for (i = 0; i < len; i++)
if (!ice_ternary_match_byte(key[i], key_inv[i], pat[i]))
return false;
return true;
}
/*** ICE_SID_RXPARSER_BOOST_TCAM and ICE_SID_LBL_RXPARSER_TMEM sections ***/
static void ice_bst_np_kb_dump(struct ice_hw *hw, struct ice_np_keybuilder *kb)
{
@@ -1259,6 +1362,31 @@ static struct ice_lbl_item *ice_bst_lbl_table_get(struct ice_hw *hw)
ice_parse_lbl_item, true);
}
/**
* ice_bst_tcam_match - match a pattern on the boost tcam table
* @tcam_table: boost tcam table to search
* @pat: pattern to match
*
* Return: a pointer to the matching Boost TCAM item or NULL.
*/
struct ice_bst_tcam_item *
ice_bst_tcam_match(struct ice_bst_tcam_item *tcam_table, u8 *pat)
{
int i;
for (i = 0; i < ICE_BST_TCAM_TABLE_SIZE; i++) {
struct ice_bst_tcam_item *item = &tcam_table[i];
if (item->hit_idx_grp == 0)
continue;
if (ice_ternary_match(item->key, item->key_inv, pat,
ICE_BST_TCAM_KEY_SIZE))
return item;
}
return NULL;
}
/*** ICE_SID_RXPARSER_MARKER_PTYPE section ***/
/**
* ice_ptype_mk_tcam_dump - dump an ptype marker tcam info
@@ -1312,6 +1440,30 @@ struct ice_ptype_mk_tcam_item *ice_ptype_mk_tcam_table_get(struct ice_hw *hw)
ice_parse_ptype_mk_tcam_item, true);
}
/**
* ice_ptype_mk_tcam_match - match a pattern on a ptype marker tcam table
* @table: ptype marker tcam table to search
* @pat: pattern to match
* @len: length of the pattern
*
* Return: a pointer to the matching Marker PType item or NULL.
*/
struct ice_ptype_mk_tcam_item *
ice_ptype_mk_tcam_match(struct ice_ptype_mk_tcam_item *table,
u8 *pat, int len)
{
int i;
for (i = 0; i < ICE_PTYPE_MK_TCAM_TABLE_SIZE; i++) {
struct ice_ptype_mk_tcam_item *item = &table[i];
if (ice_ternary_match(item->key, item->key_inv, pat, len))
return item;
}
return NULL;
}
/*** ICE_SID_RXPARSER_MARKER_GRP section ***/
/**
* ice_mk_grp_dump - dump an marker group item info
@@ -1504,6 +1656,31 @@ static struct ice_flg_rd_item *ice_flg_rd_table_get(struct ice_hw *hw)
ice_flg_rd_parse_item, false);
}
/**
* ice_flg_redirect - redirect a parser flag to packet flag
* @table: flag redirect table
* @psr_flg: parser flag to redirect
*
* Return: flag or 0 if @psr_flag = 0.
*/
u64 ice_flg_redirect(struct ice_flg_rd_item *table, u64 psr_flg)
{
u64 flg = 0;
int i;
for (i = 0; i < ICE_FLG_RDT_SIZE; i++) {
struct ice_flg_rd_item *item = &table[i];
if (!item->expose)
continue;
if (psr_flg & BIT(item->intr_flg_id))
flg |= BIT(i);
}
return flg;
}
/*** ICE_SID_XLT_KEY_BUILDER_SW, ICE_SID_XLT_KEY_BUILDER_ACL,
* ICE_SID_XLT_KEY_BUILDER_FD and ICE_SID_XLT_KEY_BUILDER_RSS
* sections ***/
@@ -1737,6 +1914,37 @@ static struct ice_xlt_kb *ice_xlt_kb_get_rss(struct ice_hw *hw)
return ice_xlt_kb_get(hw, ICE_SID_XLT_KEY_BUILDER_RSS);
}
#define ICE_XLT_KB_MASK GENMASK_ULL(5, 0)
/**
* ice_xlt_kb_flag_get - aggregate 64 bits packet flag into 16 bits xlt flag
* @kb: xlt key build
* @pkt_flag: 64 bits packet flag
*
* Return: XLT flag or 0 if @pkt_flag = 0.
*/
u16 ice_xlt_kb_flag_get(struct ice_xlt_kb *kb, u64 pkt_flag)
{
struct ice_xlt_kb_entry *entry = &kb->entries[0];
u16 flag = 0;
int i;
/* check flag 15 */
if (kb->flag15 & pkt_flag)
flag = BIT(ICE_XLT_KB_FLAG0_14_CNT);
/* check flag 0 - 14 */
for (i = 0; i < ICE_XLT_KB_FLAG0_14_CNT; i++) {
/* only check first entry */
u16 idx = entry->flg0_14_sel[i] & ICE_XLT_KB_MASK;
if (pkt_flag & BIT(idx))
flag |= (u16)BIT(i);
}
return flag;
}
/*** Parser API ***/
/**
* ice_parser_create - create a parser instance
drivers/net/ethernet/intel/ice/ice_parser.h
+36 -15
View File
@@ -197,25 +197,29 @@ struct ice_metainit_item {
struct ice_pg_cam_key {
bool valid;
u16 node_id; /* Node ID of protocol in parse graph */
bool flag0;
bool flag1;
bool flag2;
bool flag3;
u8 boost_idx; /* Boost TCAM match index */
u16 alu_reg;
u32 next_proto; /* next Protocol value */
struct_group_attr(val, __packed,
u16 node_id; /* Node ID of protocol in parse graph */
bool flag0;
bool flag1;
bool flag2;
bool flag3;
u8 boost_idx; /* Boost TCAM match index */
u16 alu_reg;
u32 next_proto; /* next Protocol value (must be last) */
);
};
struct ice_pg_nm_cam_key {
bool valid;
u16 node_id;
bool flag0;
bool flag1;
bool flag2;
bool flag3;
u8 boost_idx;
u16 alu_reg;
struct_group_attr(val, __packed,
u16 node_id;
bool flag0;
bool flag1;
bool flag2;
bool flag3;
u8 boost_idx;
u16 alu_reg;
);
};
struct ice_pg_cam_action {
@@ -244,6 +248,12 @@ struct ice_pg_nm_cam_item {
struct ice_pg_cam_action action;
};
struct ice_pg_cam_item *ice_pg_cam_match(struct ice_pg_cam_item *table,
int size, struct ice_pg_cam_key *key);
struct ice_pg_nm_cam_item *
ice_pg_nm_cam_match(struct ice_pg_nm_cam_item *table, int size,
struct ice_pg_cam_key *key);
/*** ICE_SID_RXPARSER_BOOST_TCAM and ICE_SID_LBL_RXPARSER_TMEM sections ***/
#define ICE_BST_TCAM_TABLE_SIZE 256
#define ICE_BST_TCAM_KEY_SIZE 20
@@ -269,6 +279,9 @@ struct ice_lbl_item {
char label[ICE_LBL_LEN];
};
struct ice_bst_tcam_item *
ice_bst_tcam_match(struct ice_bst_tcam_item *tcam_table, u8 *pat);
/*** ICE_SID_RXPARSER_MARKER_PTYPE section ***/
#define ICE_PTYPE_MK_TCAM_TABLE_SIZE 1024
#define ICE_PTYPE_MK_TCAM_KEY_SIZE 10
@@ -280,6 +293,9 @@ struct ice_ptype_mk_tcam_item {
u8 key_inv[ICE_PTYPE_MK_TCAM_KEY_SIZE];
} __packed;
struct ice_ptype_mk_tcam_item *
ice_ptype_mk_tcam_match(struct ice_ptype_mk_tcam_item *table,
u8 *pat, int len);
/*** ICE_SID_RXPARSER_MARKER_GRP section ***/
#define ICE_MK_GRP_TABLE_SIZE 128
#define ICE_MK_COUNT_PER_GRP 8
@@ -308,6 +324,7 @@ struct ice_proto_grp_item {
/*** ICE_SID_RXPARSER_FLAG_REDIR section ***/
#define ICE_FLG_RD_TABLE_SIZE 64
#define ICE_FLG_RDT_SIZE 64
/* Flags Redirection item */
struct ice_flg_rd_item {
@@ -316,6 +333,8 @@ struct ice_flg_rd_item {
u8 intr_flg_id; /* Internal Flag ID */
};
u64 ice_flg_redirect(struct ice_flg_rd_item *table, u64 psr_flg);
/*** ICE_SID_XLT_KEY_BUILDER_SW, ICE_SID_XLT_KEY_BUILDER_ACL,
* ICE_SID_XLT_KEY_BUILDER_FD and ICE_SID_XLT_KEY_BUILDER_RSS
* sections ***/
@@ -341,6 +360,8 @@ struct ice_xlt_kb {
struct ice_xlt_kb_entry entries[ICE_XLT_KB_TBL_CNT];
};
u16 ice_xlt_kb_flag_get(struct ice_xlt_kb *kb, u64 pkt_flag);
/*** Parser API ***/
struct ice_parser {
struct ice_hw *hw; /* pointer to the hardware structure */