From: Dan Nowlin <dan.nowlin@intel.com>

Date: Fri, 6 Aug 2021 10:49:00 +0200

Subject: ice: create advanced switch recipe

Patch-mainline: v5.16-rc1

Git-commit: fd2a6b71e3008360c7b26a3d7002fe03dbdc61fd

References: jsc#SLE-18375

These changes introduce code for creating advanced recipes for the

switch in hardware.

There are a couple of recipes already defined in the HW. They apply to

matching on basic protocol headers, like MAC, VLAN, MACVLAN,

ethertype or direction (promiscuous), etc.. If the user wants to match on

other protocol headers (eg. ip address, src/dst port etc.) or different

variation of already supported protocols, there is a need to create

new, more complex recipe. That new recipe is referred as

'advanced recipe', and the filtering rule created on top of that recipe

is called 'advanced rule'.

One recipe can have up to 5 words, but the first word is always reserved

for match on switch id, so the driver can define up to 4 words for one

recipe. To support recipes with more words up to 5 recipes can be

chained, so 20 words can be programmed for look up.

Input for adding recipe function is a list of protocols to support. Based

on this list correct profile is being chosen. Correct profile means

that it contains all protocol types from a list. Each profile have up to

48 field vector words and each of this word have protocol id and offset.

These two fields need to match with input data for adding recipe

function. If the correct profile can't be found the function returns an

error.

The next step after finding the correct profile is grouping words into

groups. One group can have up to 4 words. This is done to simplify

sending recipes to HW (because recipe also can have up to 4 words).

In case of chaining (so when look up consists of more than 4 words) last

recipe will always have results from the previous recipes used as words.

A recipe to profile map is used to store information about which profile

is associate with this recipe. This map is an array of 64 elements (max

number of recipes) and each element is a 256 bits bitmap (max number of

profiles)

Profile to recipe map is used to store information about which recipe is

associate with this profile. This map is an array of 256 elements (max

number of profiles) and each element is a 64 bits bitmap (max number of

recipes)

Signed-off-by: Dan Nowlin <dan.nowlin@intel.com>

Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>

Tested-by: Sandeep Penigalapati <sandeep.penigalapati@intel.com>

Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>

Acked-by: Thomas Bogendoerfer <tbogendoerfer@suse.de>

---

 drivers/net/ethernet/intel/ice/ice_flex_pipe.c     |   33 

 drivers/net/ethernet/intel/ice/ice_flex_pipe.h     |    6 

 drivers/net/ethernet/intel/ice/ice_protocol_type.h |  169 +++

 drivers/net/ethernet/intel/ice/ice_switch.c        | 1116 ++++++++++++++++++++-

 drivers/net/ethernet/intel/ice/ice_switch.h        |  110 +-

 5 files changed, 1412 insertions(+), 22 deletions(-)

--- a/drivers/net/ethernet/intel/ice/ice_flex_pipe.c

+++ b/drivers/net/ethernet/intel/ice/ice_flex_pipe.c

@@ -735,7 +735,7 @@ static void ice_release_global_cfg_lock(

  *

  * This function will request ownership of the change lock.

  */

-static enum ice_status

+enum ice_status

 ice_acquire_change_lock(struct ice_hw *hw, enum ice_aq_res_access_type access)

 {

 	return ice_acquire_res(hw, ICE_CHANGE_LOCK_RES_ID, access,

@@ -748,7 +748,7 @@ ice_acquire_change_lock(struct ice_hw *h

  *

  * This function will release the change lock using the proper Admin Command.

  */

-static void ice_release_change_lock(struct ice_hw *hw)

+void ice_release_change_lock(struct ice_hw *hw)

 {

 	ice_release_res(hw, ICE_CHANGE_LOCK_RES_ID);

 }

@@ -2104,6 +2104,35 @@ int ice_udp_tunnel_unset_port(struct net

 	return 0;

 }

+

+/**

+ * ice_find_prot_off - find prot ID and offset pair, based on prof and FV index

+ * @hw: pointer to the hardware structure

+ * @blk: hardware block

+ * @prof: profile ID

+ * @fv_idx: field vector word index

+ * @prot: variable to receive the protocol ID

+ * @off: variable to receive the protocol offset

+ */

+enum ice_status

+ice_find_prot_off(struct ice_hw *hw, enum ice_block blk, u8 prof, u16 fv_idx,

+		  u8 *prot, u16 *off)

+{

+	struct ice_fv_word *fv_ext;

+

+	if (prof >= hw->blk[blk].es.count)

+		return ICE_ERR_PARAM;

+

+	if (fv_idx >= hw->blk[blk].es.fvw)

+		return ICE_ERR_PARAM;

+

+	fv_ext = hw->blk[blk].es.t + (prof * hw->blk[blk].es.fvw);

+

+	*prot = fv_ext[fv_idx].prot_id;

+	*off = fv_ext[fv_idx].off;

+

+	return 0;

+}

 /* PTG Management */

--- a/drivers/net/ethernet/intel/ice/ice_flex_pipe.h

+++ b/drivers/net/ethernet/intel/ice/ice_flex_pipe.h

@@ -18,6 +18,12 @@

 #define ICE_PKG_CNT 4

+enum ice_status

+ice_acquire_change_lock(struct ice_hw *hw, enum ice_aq_res_access_type access);

+void ice_release_change_lock(struct ice_hw *hw);

+enum ice_status

+ice_find_prot_off(struct ice_hw *hw, enum ice_block blk, u8 prof, u16 fv_idx,

+		  u8 *prot, u16 *off);

 void

 ice_get_sw_fv_bitmap(struct ice_hw *hw, enum ice_prof_type type,

 		     unsigned long *bm);

--- a/drivers/net/ethernet/intel/ice/ice_protocol_type.h

+++ b/drivers/net/ethernet/intel/ice/ice_protocol_type.h

@@ -3,6 +3,44 @@

 #ifndef _ICE_PROTOCOL_TYPE_H_

 #define _ICE_PROTOCOL_TYPE_H_

+#define ICE_IPV6_ADDR_LENGTH 16

+

+/* Each recipe can match up to 5 different fields. Fields to match can be meta-

+ * data, values extracted from packet headers, or results from other recipes.

+ * One of the 5 fields is reserved for matching the switch ID. So, up to 4

+ * recipes can provide intermediate results to another one through chaining,

+ * e.g. recipes 0, 1, 2, and 3 can provide intermediate results to recipe 4.

+ */

+#define ICE_NUM_WORDS_RECIPE 4

+

+/* Max recipes that can be chained */

+#define ICE_MAX_CHAIN_RECIPE 5

+

+/* 1 word reserved for switch ID from allowed 5 words.

+ * So a recipe can have max 4 words. And you can chain 5 such recipes

+ * together. So maximum words that can be programmed for look up is 5 * 4.

+ */

+#define ICE_MAX_CHAIN_WORDS (ICE_NUM_WORDS_RECIPE * ICE_MAX_CHAIN_RECIPE)

+

+/* Field vector index corresponding to chaining */

+#define ICE_CHAIN_FV_INDEX_START 47

+

+enum ice_protocol_type {

+	ICE_MAC_OFOS = 0,

+	ICE_MAC_IL,

+	ICE_ETYPE_OL,

+	ICE_VLAN_OFOS,

+	ICE_IPV4_OFOS,

+	ICE_IPV4_IL,

+	ICE_IPV6_OFOS,

+	ICE_IPV6_IL,

+	ICE_TCP_IL,

+	ICE_UDP_OF,

+	ICE_UDP_ILOS,

+	ICE_SCTP_IL,

+	ICE_PROTOCOL_LAST

+};

+

 /* Decoders for ice_prot_id:

  * - F: First

  * - I: Inner

@@ -35,4 +73,135 @@ enum ice_prot_id {

 	ICE_PROT_META_ID	= 255, /* when offset == metadata */

 	ICE_PROT_INVALID	= 255  /* when offset == ICE_FV_OFFSET_INVAL */

 };

+

+#define ICE_MAC_OFOS_HW		1

+#define ICE_MAC_IL_HW		4

+#define ICE_ETYPE_OL_HW		9

+#define ICE_VLAN_OF_HW		16

+#define ICE_VLAN_OL_HW		17

+#define ICE_IPV4_OFOS_HW	32

+#define ICE_IPV4_IL_HW		33

+#define ICE_IPV6_OFOS_HW	40

+#define ICE_IPV6_IL_HW		41

+#define ICE_TCP_IL_HW		49

+#define ICE_UDP_ILOS_HW		53

+

+#define ICE_UDP_OF_HW	52 /* UDP Tunnels */

+

+#define ICE_TUN_FLAG_FV_IND 2

+

+/* Mapping of software defined protocol ID to hardware defined protocol ID */

+struct ice_protocol_entry {

+	enum ice_protocol_type type;

+	u8 protocol_id;

+};

+

+struct ice_ether_hdr {

+	u8 dst_addr[ETH_ALEN];

+	u8 src_addr[ETH_ALEN];

+};

+

+struct ice_ethtype_hdr {

+	__be16 ethtype_id;

+};

+

+struct ice_ether_vlan_hdr {

+	u8 dst_addr[ETH_ALEN];

+	u8 src_addr[ETH_ALEN];

+	__be32 vlan_id;

+};

+

+struct ice_vlan_hdr {

+	__be16 type;

+	__be16 vlan;

+};

+

+struct ice_ipv4_hdr {

+	u8 version;

+	u8 tos;

+	__be16 total_length;

+	__be16 id;

+	__be16 frag_off;

+	u8 time_to_live;

+	u8 protocol;

+	__be16 check;

+	__be32 src_addr;

+	__be32 dst_addr;

+};

+

+struct ice_ipv6_hdr {

+	__be32 be_ver_tc_flow;

+	__be16 payload_len;

+	u8 next_hdr;

+	u8 hop_limit;

+	u8 src_addr[ICE_IPV6_ADDR_LENGTH];

+	u8 dst_addr[ICE_IPV6_ADDR_LENGTH];

+};

+

+struct ice_sctp_hdr {

+	__be16 src_port;

+	__be16 dst_port;

+	__be32 verification_tag;

+	__be32 check;

+};

+

+struct ice_l4_hdr {

+	__be16 src_port;

+	__be16 dst_port;

+	__be16 len;

+	__be16 check;

+};

+

+union ice_prot_hdr {

+	struct ice_ether_hdr eth_hdr;

+	struct ice_ethtype_hdr ethertype;

+	struct ice_vlan_hdr vlan_hdr;

+	struct ice_ipv4_hdr ipv4_hdr;

+	struct ice_ipv6_hdr ipv6_hdr;

+	struct ice_l4_hdr l4_hdr;

+	struct ice_sctp_hdr sctp_hdr;

+};

+

+/* This is mapping table entry that maps every word within a given protocol

+ * structure to the real byte offset as per the specification of that

+ * protocol header.

+ * for e.g. dst address is 3 words in ethertype header and corresponding bytes

+ * are 0, 2, 3 in the actual packet header and src address is at 4, 6, 8

+ */

+struct ice_prot_ext_tbl_entry {

+	enum ice_protocol_type prot_type;

+	/* Byte offset into header of given protocol type */

+	u8 offs[sizeof(union ice_prot_hdr)];

+};

+

+/* Extractions to be looked up for a given recipe */

+struct ice_prot_lkup_ext {

+	u16 prot_type;

+	u8 n_val_words;

+	/* create a buffer to hold max words per recipe */

+	u16 field_off[ICE_MAX_CHAIN_WORDS];

+	u16 field_mask[ICE_MAX_CHAIN_WORDS];

+

+	struct ice_fv_word fv_words[ICE_MAX_CHAIN_WORDS];

+

+	/* Indicate field offsets that have field vector indices assigned */

+	DECLARE_BITMAP(done, ICE_MAX_CHAIN_WORDS);

+};

+

+struct ice_pref_recipe_group {

+	u8 n_val_pairs;		/* Number of valid pairs */

+	struct ice_fv_word pairs[ICE_NUM_WORDS_RECIPE];

+	u16 mask[ICE_NUM_WORDS_RECIPE];

+};

+

+struct ice_recp_grp_entry {

+	struct list_head l_entry;

+

+#define ICE_INVAL_CHAIN_IND 0xFF

+	u16 rid;

+	u8 chain_idx;

+	u16 fv_idx[ICE_NUM_WORDS_RECIPE];

+	u16 fv_mask[ICE_NUM_WORDS_RECIPE];

+	struct ice_pref_recipe_group r_group;

+};

 #endif /* _ICE_PROTOCOL_TYPE_H_ */

--- a/drivers/net/ethernet/intel/ice/ice_switch.c

+++ b/drivers/net/ethernet/intel/ice/ice_switch.c

@@ -42,6 +42,14 @@ static const u8 dummy_eth_header[DUMMY_E

 	(offsetof(struct ice_aqc_sw_rules_elem, pdata.vsi_list.vsi) + \

 	 ((n) * sizeof(((struct ice_sw_rule_vsi_list *)0)->vsi[0])))

+/* this is a recipe to profile association bitmap */

+static DECLARE_BITMAP(recipe_to_profile[ICE_MAX_NUM_RECIPES],

+			  ICE_MAX_NUM_PROFILES);

+

+/* this is a profile to recipe association bitmap */

+static DECLARE_BITMAP(profile_to_recipe[ICE_MAX_NUM_PROFILES],

+			  ICE_MAX_NUM_RECIPES);

+

 /**

  * ice_init_def_sw_recp - initialize the recipe book keeping tables

  * @hw: pointer to the HW struct

@@ -553,7 +561,7 @@ ice_aq_sw_rules(struct ice_hw *hw, void

  *

  * Add(0x0290)

  */

-static enum ice_status __maybe_unused

+static enum ice_status

 ice_aq_add_recipe(struct ice_hw *hw,

 		  struct ice_aqc_recipe_data_elem *s_recipe_list,

 		  u16 num_recipes, struct ice_sq_cd *cd)

@@ -590,7 +598,7 @@ ice_aq_add_recipe(struct ice_hw *hw,

  * The caller must supply enough space in s_recipe_list to hold all possible

  * recipes and *num_recipes must equal ICE_MAX_NUM_RECIPES.

  */

-static enum ice_status __maybe_unused

+static enum ice_status

 ice_aq_get_recipe(struct ice_hw *hw,

 		  struct ice_aqc_recipe_data_elem *s_recipe_list,

 		  u16 *num_recipes, u16 recipe_root, struct ice_sq_cd *cd)

@@ -625,7 +633,7 @@ ice_aq_get_recipe(struct ice_hw *hw,

  * @cd: pointer to command details structure or NULL

  * Recipe to profile association (0x0291)

  */

-static enum ice_status __maybe_unused

+static enum ice_status

 ice_aq_map_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u8 *r_bitmap,

 			     struct ice_sq_cd *cd)

 {

@@ -651,7 +659,7 @@ ice_aq_map_recipe_to_profile(struct ice_

  * @cd: pointer to command details structure or NULL

  * Associate profile ID with given recipe (0x0293)

  */

-static enum ice_status __maybe_unused

+static enum ice_status

 ice_aq_get_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u8 *r_bitmap,

 			     struct ice_sq_cd *cd)

 {

@@ -675,7 +683,7 @@ ice_aq_get_recipe_to_profile(struct ice_

  * @hw: pointer to the hardware structure

  * @rid: recipe ID returned as response to AQ call

  */

-static enum ice_status __maybe_unused ice_alloc_recipe(struct ice_hw *hw, u16 *rid)

+static enum ice_status ice_alloc_recipe(struct ice_hw *hw, u16 *rid)

 {

 	struct ice_aqc_alloc_free_res_elem *sw_buf;

 	enum ice_status status;

@@ -699,6 +707,203 @@ static enum ice_status __maybe_unused ic

 	return status;

 }

+/**

+ * ice_get_recp_to_prof_map - updates recipe to profile mapping

+ * @hw: pointer to hardware structure

+ *

+ * This function is used to populate recipe_to_profile matrix where index to

+ * this array is the recipe ID and the element is the mapping of which profiles

+ * is this recipe mapped to.

+ */

+static void ice_get_recp_to_prof_map(struct ice_hw *hw)

+{

+	DECLARE_BITMAP(r_bitmap, ICE_MAX_NUM_RECIPES);

+	u16 i;

+

+	for (i = 0; i < hw->switch_info->max_used_prof_index + 1; i++) {

+		u16 j;

+

+		bitmap_zero(profile_to_recipe[i], ICE_MAX_NUM_RECIPES);

+		bitmap_zero(r_bitmap, ICE_MAX_NUM_RECIPES);

+		if (ice_aq_get_recipe_to_profile(hw, i, (u8 *)r_bitmap, NULL))

+			continue;

+		bitmap_copy(profile_to_recipe[i], r_bitmap,

+			    ICE_MAX_NUM_RECIPES);

+		for_each_set_bit(j, r_bitmap, ICE_MAX_NUM_RECIPES)

+			set_bit(i, recipe_to_profile[j]);

+	}

+}

+

+/**

+ * ice_collect_result_idx - copy result index values

+ * @buf: buffer that contains the result index

+ * @recp: the recipe struct to copy data into

+ */

+static void

+ice_collect_result_idx(struct ice_aqc_recipe_data_elem *buf,

+		       struct ice_sw_recipe *recp)

+{

+	if (buf->content.result_indx & ICE_AQ_RECIPE_RESULT_EN)

+		set_bit(buf->content.result_indx & ~ICE_AQ_RECIPE_RESULT_EN,

+			recp->res_idxs);

+}

+

+/**

+ * ice_get_recp_frm_fw - update SW bookkeeping from FW recipe entries

+ * @hw: pointer to hardware structure

+ * @recps: struct that we need to populate

+ * @rid: recipe ID that we are populating

+ * @refresh_required: true if we should get recipe to profile mapping from FW

+ *

+ * This function is used to populate all the necessary entries into our

+ * bookkeeping so that we have a current list of all the recipes that are

+ * programmed in the firmware.

+ */

+static enum ice_status

+ice_get_recp_frm_fw(struct ice_hw *hw, struct ice_sw_recipe *recps, u8 rid,

+		    bool *refresh_required)

+{

+	DECLARE_BITMAP(result_bm, ICE_MAX_FV_WORDS);

+	struct ice_aqc_recipe_data_elem *tmp;

+	u16 num_recps = ICE_MAX_NUM_RECIPES;

+	struct ice_prot_lkup_ext *lkup_exts;

+	enum ice_status status;

+	u8 fv_word_idx = 0;

+	u16 sub_recps;

+

+	bitmap_zero(result_bm, ICE_MAX_FV_WORDS);

+

+	/* we need a buffer big enough to accommodate all the recipes */

+	tmp = kcalloc(ICE_MAX_NUM_RECIPES, sizeof(*tmp), GFP_KERNEL);

+	if (!tmp)

+		return ICE_ERR_NO_MEMORY;

+

+	tmp[0].recipe_indx = rid;

+	status = ice_aq_get_recipe(hw, tmp, &num_recps, rid, NULL);

+	/* non-zero status meaning recipe doesn't exist */

+	if (status)

+		goto err_unroll;

+

+	/* Get recipe to profile map so that we can get the fv from lkups that

+	 * we read for a recipe from FW. Since we want to minimize the number of

+	 * times we make this FW call, just make one call and cache the copy

+	 * until a new recipe is added. This operation is only required the

+	 * first time to get the changes from FW. Then to search existing

+	 * entries we don't need to update the cache again until another recipe

+	 * gets added.

+	 */

+	if (*refresh_required) {

+		ice_get_recp_to_prof_map(hw);

+		*refresh_required = false;

+	}

+

+	/* Start populating all the entries for recps[rid] based on lkups from

+	 * firmware. Note that we are only creating the root recipe in our

+	 * database.

+	 */

+	lkup_exts = &recps[rid].lkup_exts;

+

+	for (sub_recps = 0; sub_recps < num_recps; sub_recps++) {

+		struct ice_aqc_recipe_data_elem root_bufs = tmp[sub_recps];

+		struct ice_recp_grp_entry *rg_entry;

+		u8 i, prof, idx, prot = 0;

+		bool is_root;

+		u16 off = 0;

+

+		rg_entry = devm_kzalloc(ice_hw_to_dev(hw), sizeof(*rg_entry),

+					GFP_KERNEL);

+		if (!rg_entry) {

+			status = ICE_ERR_NO_MEMORY;

+			goto err_unroll;

+		}

+

+		idx = root_bufs.recipe_indx;

+		is_root = root_bufs.content.rid & ICE_AQ_RECIPE_ID_IS_ROOT;

+

+		/* Mark all result indices in this chain */

+		if (root_bufs.content.result_indx & ICE_AQ_RECIPE_RESULT_EN)

+			set_bit(root_bufs.content.result_indx & ~ICE_AQ_RECIPE_RESULT_EN,

+				result_bm);

+

+		/* get the first profile that is associated with rid */

+		prof = find_first_bit(recipe_to_profile[idx],

+				      ICE_MAX_NUM_PROFILES);

+		for (i = 0; i < ICE_NUM_WORDS_RECIPE; i++) {

+			u8 lkup_indx = root_bufs.content.lkup_indx[i + 1];

+

+			rg_entry->fv_idx[i] = lkup_indx;

+			rg_entry->fv_mask[i] =

+				le16_to_cpu(root_bufs.content.mask[i + 1]);

+

+			/* If the recipe is a chained recipe then all its

+			 * child recipe's result will have a result index.

+			 * To fill fv_words we should not use those result

+			 * index, we only need the protocol ids and offsets.

+			 * We will skip all the fv_idx which stores result

+			 * index in them. We also need to skip any fv_idx which

+			 * has ICE_AQ_RECIPE_LKUP_IGNORE or 0 since it isn't a

+			 * valid offset value.

+			 */

+			if (test_bit(rg_entry->fv_idx[i], hw->switch_info->prof_res_bm[prof]) ||

+			    rg_entry->fv_idx[i] & ICE_AQ_RECIPE_LKUP_IGNORE ||

+			    rg_entry->fv_idx[i] == 0)

+				continue;

+

+			ice_find_prot_off(hw, ICE_BLK_SW, prof,

+					  rg_entry->fv_idx[i], &prot, &off;;

+			lkup_exts->fv_words[fv_word_idx].prot_id = prot;

+			lkup_exts->fv_words[fv_word_idx].off = off;

+			lkup_exts->field_mask[fv_word_idx] =

+				rg_entry->fv_mask[i];

+			fv_word_idx++;

+		}

+		/* populate rg_list with the data from the child entry of this

+		 * recipe

+		 */

+		list_add(&rg_entry->l_entry, &recps[rid].rg_list);

+

+		/* Propagate some data to the recipe database */

+		recps[idx].is_root = !!is_root;

+		recps[idx].priority = root_bufs.content.act_ctrl_fwd_priority;

+		bitmap_zero(recps[idx].res_idxs, ICE_MAX_FV_WORDS);

+		if (root_bufs.content.result_indx & ICE_AQ_RECIPE_RESULT_EN) {

+			recps[idx].chain_idx = root_bufs.content.result_indx &

+				~ICE_AQ_RECIPE_RESULT_EN;

+			set_bit(recps[idx].chain_idx, recps[idx].res_idxs);

+		} else {

+			recps[idx].chain_idx = ICE_INVAL_CHAIN_IND;

+		}

+

+		if (!is_root)

+			continue;

+

+		/* Only do the following for root recipes entries */

+		memcpy(recps[idx].r_bitmap, root_bufs.recipe_bitmap,

+		       sizeof(recps[idx].r_bitmap));

+		recps[idx].root_rid = root_bufs.content.rid &

+			~ICE_AQ_RECIPE_ID_IS_ROOT;

+		recps[idx].priority = root_bufs.content.act_ctrl_fwd_priority;

+	}

+

+	/* Complete initialization of the root recipe entry */

+	lkup_exts->n_val_words = fv_word_idx;

+	recps[rid].big_recp = (num_recps > 1);

+	recps[rid].n_grp_count = (u8)num_recps;

+	recps[rid].root_buf = devm_kmemdup(ice_hw_to_dev(hw), tmp,

+					   recps[rid].n_grp_count * sizeof(*recps[rid].root_buf),

+					   GFP_KERNEL);

+	if (!recps[rid].root_buf)

+		goto err_unroll;

+

+	/* Copy result indexes */

+	bitmap_copy(recps[rid].res_idxs, result_bm, ICE_MAX_FV_WORDS);

+	recps[rid].recp_created = true;

+

+err_unroll:

+	kfree(tmp);

+	return status;

+}

+

 /* ice_init_port_info - Initialize port_info with switch configuration data

  * @pi: pointer to port_info

  * @vsi_port_num: VSI number or port number

@@ -2929,6 +3134,907 @@ ice_free_res_cntr(struct ice_hw *hw, u8

 	return status;

 }

+/* This is mapping table entry that maps every word within a given protocol

+ * structure to the real byte offset as per the specification of that

+ * protocol header.

+ * for example dst address is 3 words in ethertype header and corresponding

+ * bytes are 0, 2, 3 in the actual packet header and src address is at 4, 6, 8

+ * IMPORTANT: Every structure part of "ice_prot_hdr" union should have a

+ * matching entry describing its field. This needs to be updated if new

+ * structure is added to that union.

+ */

+static const struct ice_prot_ext_tbl_entry ice_prot_ext[ICE_PROTOCOL_LAST] = {

+	{ ICE_MAC_OFOS,		{ 0, 2, 4, 6, 8, 10, 12 } },

+	{ ICE_MAC_IL,		{ 0, 2, 4, 6, 8, 10, 12 } },

+	{ ICE_ETYPE_OL,		{ 0 } },

+	{ ICE_VLAN_OFOS,	{ 2, 0 } },

+	{ ICE_IPV4_OFOS,	{ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 } },

+	{ ICE_IPV4_IL,		{ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 } },

+	{ ICE_IPV6_OFOS,	{ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24,

+				 26, 28, 30, 32, 34, 36, 38 } },

+	{ ICE_IPV6_IL,		{ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24,

+				 26, 28, 30, 32, 34, 36, 38 } },

+	{ ICE_TCP_IL,		{ 0, 2 } },

+	{ ICE_UDP_OF,		{ 0, 2 } },

+	{ ICE_UDP_ILOS,		{ 0, 2 } },

+};

+

+static struct ice_protocol_entry ice_prot_id_tbl[ICE_PROTOCOL_LAST] = {

+	{ ICE_MAC_OFOS,		ICE_MAC_OFOS_HW },

+	{ ICE_MAC_IL,		ICE_MAC_IL_HW },

+	{ ICE_ETYPE_OL,		ICE_ETYPE_OL_HW },

+	{ ICE_VLAN_OFOS,	ICE_VLAN_OL_HW },

+	{ ICE_IPV4_OFOS,	ICE_IPV4_OFOS_HW },

+	{ ICE_IPV4_IL,		ICE_IPV4_IL_HW },

+	{ ICE_IPV6_OFOS,	ICE_IPV6_OFOS_HW },

+	{ ICE_IPV6_IL,		ICE_IPV6_IL_HW },

+	{ ICE_TCP_IL,		ICE_TCP_IL_HW },

+	{ ICE_UDP_OF,		ICE_UDP_OF_HW },

+	{ ICE_UDP_ILOS,		ICE_UDP_ILOS_HW },

+};

+

+/**

+ * ice_find_recp - find a recipe

+ * @hw: pointer to the hardware structure

+ * @lkup_exts: extension sequence to match

+ *

+ * Returns index of matching recipe, or ICE_MAX_NUM_RECIPES if not found.

+ */

+static u16 ice_find_recp(struct ice_hw *hw, struct ice_prot_lkup_ext *lkup_exts)

+{

+	bool refresh_required = true;

+	struct ice_sw_recipe *recp;

+	u8 i;

+

+	/* Walk through existing recipes to find a match */

+	recp = hw->switch_info->recp_list;

+	for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) {

+		/* If recipe was not created for this ID, in SW bookkeeping,

+		 * check if FW has an entry for this recipe. If the FW has an

+		 * entry update it in our SW bookkeeping and continue with the

+		 * matching.

+		 */

+		if (!recp[i].recp_created)

+			if (ice_get_recp_frm_fw(hw,

+						hw->switch_info->recp_list, i,

+						&refresh_required))

+				continue;

+

+		/* Skip inverse action recipes */

+		if (recp[i].root_buf && recp[i].root_buf->content.act_ctrl &

+		    ICE_AQ_RECIPE_ACT_INV_ACT)

+			continue;

+

+		/* if number of words we are looking for match */

+		if (lkup_exts->n_val_words == recp[i].lkup_exts.n_val_words) {

+			struct ice_fv_word *ar = recp[i].lkup_exts.fv_words;

+			struct ice_fv_word *be = lkup_exts->fv_words;

+			u16 *cr = recp[i].lkup_exts.field_mask;

+			u16 *de = lkup_exts->field_mask;

+			bool found = true;

+			u8 pe, qr;

+

+			/* ar, cr, and qr are related to the recipe words, while

+			 * be, de, and pe are related to the lookup words

+			 */

+			for (pe = 0; pe < lkup_exts->n_val_words; pe++) {

+				for (qr = 0; qr < recp[i].lkup_exts.n_val_words;

+				     qr++) {

+					if (ar[qr].off == be[pe].off &&

+					    ar[qr].prot_id == be[pe].prot_id &&

+					    cr[qr] == de[pe])

+						/* Found the "pe"th word in the

+						 * given recipe

+						 */

+						break;

+				}

+				/* After walking through all the words in the

+				 * "i"th recipe if "p"th word was not found then

+				 * this recipe is not what we are looking for.

+				 * So break out from this loop and try the next

+				 * recipe

+				 */

+				if (qr >= recp[i].lkup_exts.n_val_words) {

+					found = false;

+					break;

+				}

+			}

+			/* If for "i"th recipe the found was never set to false

+			 * then it means we found our match

+			 */

+			if (found)

+				return i; /* Return the recipe ID */

+		}

+	}

+	return ICE_MAX_NUM_RECIPES;

+}

+

+/**

+ * ice_prot_type_to_id - get protocol ID from protocol type

+ * @type: protocol type

+ * @id: pointer to variable that will receive the ID

+ *

+ * Returns true if found, false otherwise

+ */

+static bool ice_prot_type_to_id(enum ice_protocol_type type, u8 *id)

+{

+	u8 i;

+

+	for (i = 0; i < ARRAY_SIZE(ice_prot_id_tbl); i++)

+		if (ice_prot_id_tbl[i].type == type) {

+			*id = ice_prot_id_tbl[i].protocol_id;

+			return true;

+		}

+	return false;

+}

+

+/**

+ * ice_fill_valid_words - count valid words

+ * @rule: advanced rule with lookup information

+ * @lkup_exts: byte offset extractions of the words that are valid

+ *

+ * calculate valid words in a lookup rule using mask value

+ */

+static u8

+ice_fill_valid_words(struct ice_adv_lkup_elem *rule,

+		     struct ice_prot_lkup_ext *lkup_exts)

+{

+	u8 j, word, prot_id, ret_val;

+

+	if (!ice_prot_type_to_id(rule->type, &prot_id))

+		return 0;

+

+	word = lkup_exts->n_val_words;

+

+	for (j = 0; j < sizeof(rule->m_u) / sizeof(u16); j++)

+		if (((u16 *)&rule->m_u)[j] &&

+		    rule->type < ARRAY_SIZE(ice_prot_ext)) {

+			/* No more space to accommodate */

+			if (word >= ICE_MAX_CHAIN_WORDS)

+				return 0;

+			lkup_exts->fv_words[word].off =

+				ice_prot_ext[rule->type].offs[j];

+			lkup_exts->fv_words[word].prot_id =

+				ice_prot_id_tbl[rule->type].protocol_id;

+			lkup_exts->field_mask[word] =

+				be16_to_cpu(((__force __be16 *)&rule->m_u)[j]);

+			word++;

+		}

+

+	ret_val = word - lkup_exts->n_val_words;

+	lkup_exts->n_val_words = word;

+

+	return ret_val;

+}

+

+/**

+ * ice_create_first_fit_recp_def - Create a recipe grouping

+ * @hw: pointer to the hardware structure

+ * @lkup_exts: an array of protocol header extractions

+ * @rg_list: pointer to a list that stores new recipe groups

+ * @recp_cnt: pointer to a variable that stores returned number of recipe groups

+ *

+ * Using first fit algorithm, take all the words that are still not done

+ * and start grouping them in 4-word groups. Each group makes up one

+ * recipe.

+ */

+static enum ice_status

+ice_create_first_fit_recp_def(struct ice_hw *hw,

+			      struct ice_prot_lkup_ext *lkup_exts,

+			      struct list_head *rg_list,

+			      u8 *recp_cnt)

+{

+	struct ice_pref_recipe_group *grp = NULL;

+	u8 j;

+

+	*recp_cnt = 0;

+

+	/* Walk through every word in the rule to check if it is not done. If so

+	 * then this word needs to be part of a new recipe.

+	 */

+	for (j = 0; j < lkup_exts->n_val_words; j++)

+		if (!test_bit(j, lkup_exts->done)) {

+			if (!grp ||

+			    grp->n_val_pairs == ICE_NUM_WORDS_RECIPE) {

+				struct ice_recp_grp_entry *entry;

+

+				entry = devm_kzalloc(ice_hw_to_dev(hw),

+						     sizeof(*entry),

+						     GFP_KERNEL);

+				if (!entry)

+					return ICE_ERR_NO_MEMORY;

+				list_add(&entry->l_entry, rg_list);

+				grp = &entry->r_group;

+				(*recp_cnt)++;

+			}

+

+			grp->pairs[grp->n_val_pairs].prot_id =

+				lkup_exts->fv_words[j].prot_id;

+			grp->pairs[grp->n_val_pairs].off =

+				lkup_exts->fv_words[j].off;

+			grp->mask[grp->n_val_pairs] = lkup_exts->field_mask[j];

+			grp->n_val_pairs++;

+		}

+

+	return 0;

+}

+

+/**

+ * ice_fill_fv_word_index - fill in the field vector indices for a recipe group

+ * @hw: pointer to the hardware structure

+ * @fv_list: field vector with the extraction sequence information

+ * @rg_list: recipe groupings with protocol-offset pairs

+ *

+ * Helper function to fill in the field vector indices for protocol-offset

+ * pairs. These indexes are then ultimately programmed into a recipe.

+ */

+static enum ice_status

+ice_fill_fv_word_index(struct ice_hw *hw, struct list_head *fv_list,

+		       struct list_head *rg_list)

+{

+	struct ice_sw_fv_list_entry *fv;

+	struct ice_recp_grp_entry *rg;

+	struct ice_fv_word *fv_ext;

+

+	if (list_empty(fv_list))

+		return 0;

+

+	fv = list_first_entry(fv_list, struct ice_sw_fv_list_entry,

+			      list_entry);

+	fv_ext = fv->fv_ptr->ew;

+

+	list_for_each_entry(rg, rg_list, l_entry) {

+		u8 i;

+

+		for (i = 0; i < rg->r_group.n_val_pairs; i++) {

+			struct ice_fv_word *pr;

+			bool found = false;

+			u16 mask;

+			u8 j;

+

+			pr = &rg->r_group.pairs[i];

+			mask = rg->r_group.mask[i];

+

+			for (j = 0; j < hw->blk[ICE_BLK_SW].es.fvw; j++)

+				if (fv_ext[j].prot_id == pr->prot_id &&

+				    fv_ext[j].off == pr->off) {

+					found = true;

+

+					/* Store index of field vector */

+					rg->fv_idx[i] = j;

+					rg->fv_mask[i] = mask;

+					break;

+				}

+

+			/* Protocol/offset could not be found, caller gave an

+			 * invalid pair

+			 */

+			if (!found)

+				return ICE_ERR_PARAM;

+		}

+	}

+

+	return 0;

+}

+

+/**

+ * ice_find_free_recp_res_idx - find free result indexes for recipe

+ * @hw: pointer to hardware structure

+ * @profiles: bitmap of profiles that will be associated with the new recipe

+ * @free_idx: pointer to variable to receive the free index bitmap

+ *

+ * The algorithm used here is:

+ *	1. When creating a new recipe, create a set P which contains all

+ *	   Profiles that will be associated with our new recipe