net/ice/base: search field vector indices for result slots

Previously, switch code would use only pre-reserved index
slots at the end of each field vector for recipe result index
locations. This patch adds code that detects other internal
empty index slots that could potentially be used. For each
recipe that is added, a determ ination is made as to whether
any of these additional index slots alige with all the profiles
selected for the recipe; if alignment is achieved, then these
result index slots can be used.

Signed-off-by: Dan Nowlin <dan.nowlin@intel.com>
Signed-off-by: Paul M Stillwell Jr <paul.m.stillwell.jr@intel.com>
Signed-off-by: Qi Zhang <qi.z.zhang@intel.com>
Acked-by: Qiming Yang <qiming.yang@intel.com>

diff --git a/drivers/net/ice/base/ice_flex_pipe.c b/drivers/net/ice/base/ice_flex_pipe.c
index 76c26fd4e11b832b828e8518bdf9e3b5e5b235dc..3181689109cf49e104e4815824b87bfef74812d3 100644 (file)
--- a/drivers/net/ice/base/ice_flex_pipe.c
+++ b/drivers/net/ice/base/ice_flex_pipe.c
@@ -1660,6 +1660,47 @@ err:
        return ICE_ERR_NO_MEMORY;
 }
 
+/**
+ * ice_init_profile_to_result_bm - Initialize the profile result index bitmap
+ * @hw: pointer to hardware structure
+ */
+void
+ice_init_prof_result_bm(struct ice_hw *hw)
+{
+       struct ice_pkg_enum state;
+       struct ice_seg *ice_seg;
+       struct ice_fv *fv;
+
+       if (!hw->seg)
+               return;
+
+       ice_seg = hw->seg;
+       do {
+               u32 off;
+               u16 i;
+
+               fv = (struct ice_fv *)
+                       ice_pkg_enum_entry(ice_seg, &state, ICE_SID_FLD_VEC_SW,
+                                          &off, ice_sw_fv_handler);
+               ice_seg = NULL;
+               if (!fv)
+                       break;
+
+               ice_zero_bitmap(hw->switch_info->prof_res_bm[off],
+                               ICE_MAX_FV_WORDS);
+
+               /* Determine empty field vector indices, these can be
+                * used for recipe results. Skip index 0, since it is
+                * always used for Switch ID.
+                */
+               for (i = 1; i < ICE_MAX_FV_WORDS; i++)
+                       if (fv->ew[i].prot_id == ICE_PROT_INVALID &&
+                           fv->ew[i].off == ICE_FV_OFFSET_INVAL)
+                               ice_set_bit(i,
+                                           hw->switch_info->prof_res_bm[off]);
+       } while (fv);
+}
+
 /**
  * ice_pkg_buf_free
  * @hw: pointer to the HW structure

diff --git a/drivers/net/ice/base/ice_flex_pipe.h b/drivers/net/ice/base/ice_flex_pipe.h
index 137eaa7f836e5ed300488156460c1dc7079cfb56..e7d42e3de448ef2d4feee7396f83ea5bd17bb11f 100644 (file)
--- a/drivers/net/ice/base/ice_flex_pipe.h
+++ b/drivers/net/ice/base/ice_flex_pipe.h
@@ -33,6 +33,8 @@ ice_find_label_value(struct ice_seg *ice_seg, char const *name, u32 type,
 void
 ice_get_sw_fv_bitmap(struct ice_hw *hw, enum ice_prof_type type,
                     ice_bitmap_t *bm);
+void
+ice_init_prof_result_bm(struct ice_hw *hw);
 enum ice_status
 ice_get_sw_fv_list(struct ice_hw *hw, u16 *prot_ids, u8 ids_cnt,
                   ice_bitmap_t *bm, struct LIST_HEAD_TYPE *fv_list);

diff --git a/drivers/net/ice/base/ice_flex_type.h b/drivers/net/ice/base/ice_flex_type.h
index c30d407c2e5229b9585042922645a53b023a4021..48c1e5184b0cfd66cf1d1e7991f7a53af3431a14 100644 (file)
--- a/drivers/net/ice/base/ice_flex_type.h
+++ b/drivers/net/ice/base/ice_flex_type.h
@@ -16,6 +16,8 @@ struct ice_fv_word {
 };
 #pragma pack()
 
+#define ICE_MAX_NUM_PROFILES 256
+
 #define ICE_MAX_FV_WORDS 48
 struct ice_fv {
        struct ice_fv_word ew[ICE_MAX_FV_WORDS];

diff --git a/drivers/net/ice/base/ice_protocol_type.h b/drivers/net/ice/base/ice_protocol_type.h
index c6caa85628990660804190ca84e063c3d9cd64eb..98185c9de03a9d4f11a5691cea138bc5a1cb1bcf 100644 (file)
--- a/drivers/net/ice/base/ice_protocol_type.h
+++ b/drivers/net/ice/base/ice_protocol_type.h
@@ -110,7 +110,7 @@ enum ice_prot_id {
        ICE_PROT_ARP_OF         = 118,
        ICE_PROT_EAPOL_OF       = 120,
        ICE_PROT_META_ID        = 255, /* when offset == metaddata */
-       ICE_PROT_INVALID        = 255  /* when offset == 0xFF */
+       ICE_PROT_INVALID        = 255  /* when offset == ICE_FV_OFFSET_INVAL */
 };
 
 #define ICE_VNI_OFFSET         12 /* offset of VNI from ICE_PROT_UDP_OF */

diff --git a/drivers/net/ice/base/ice_switch.c b/drivers/net/ice/base/ice_switch.c
index 62ccf533c9a7a22caa0fd0ee6f37c232d0d90124..9681d959009333cd49a12fa6c13b3bb67b4baf68 100644 (file)
--- a/drivers/net/ice/base/ice_switch.c
+++ b/drivers/net/ice/base/ice_switch.c
@@ -466,21 +466,6 @@ static void ice_collect_result_idx(struct ice_aqc_recipe_data_elem *buf,
                            ~ICE_AQ_RECIPE_RESULT_EN, recp->res_idxs);
 }
 
-/**
- * ice_init_possible_res_bm - initialize possible result bitmap
- * @pos_result_bm: pointer to the bitmap to initialize
- */
-static void ice_init_possible_res_bm(ice_bitmap_t *pos_result_bm)
-{
-       u16 bit;
-
-       ice_zero_bitmap(pos_result_bm, ICE_MAX_FV_WORDS);
-
-       for (bit = 0; bit < ICE_MAX_FV_WORDS; bit++)
-               if (ICE_POSSIBLE_RES_IDX & BIT_ULL(bit))
-                       ice_set_bit(bit, pos_result_bm);
-}
-
 /**
  * ice_get_recp_frm_fw - update SW bookkeeping from FW recipe entries
  * @hw: pointer to hardware structure
@@ -496,7 +481,6 @@ static enum ice_status
 ice_get_recp_frm_fw(struct ice_hw *hw, struct ice_sw_recipe *recps, u8 rid,
                    bool *refresh_required)
 {
-       ice_declare_bitmap(possible_idx, ICE_MAX_FV_WORDS);
        ice_declare_bitmap(result_bm, ICE_MAX_FV_WORDS);
        struct ice_aqc_recipe_data_elem *tmp;
        u16 num_recps = ICE_MAX_NUM_RECIPES;
@@ -505,7 +489,6 @@ ice_get_recp_frm_fw(struct ice_hw *hw, struct ice_sw_recipe *recps, u8 rid,
        enum ice_status status;
 
        ice_zero_bitmap(result_bm, ICE_MAX_FV_WORDS);
-       ice_init_possible_res_bm(possible_idx);
 
        /* we need a buffer big enough to accommodate all the recipes */
        tmp = (struct ice_aqc_recipe_data_elem *)ice_calloc(hw,
@@ -541,7 +524,7 @@ ice_get_recp_frm_fw(struct ice_hw *hw, struct ice_sw_recipe *recps, u8 rid,
        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 prof_id, idx, prot = 0;
+               u8 prof, idx, prot = 0;
                bool is_root;
                u16 off = 0;
 
@@ -561,8 +544,8 @@ ice_get_recp_frm_fw(struct ice_hw *hw, struct ice_sw_recipe *recps, u8 rid,
                                    ~ICE_AQ_RECIPE_RESULT_EN, result_bm);
 
                /* get the first profile that is associated with rid */
-               prof_id = ice_find_first_bit(recipe_to_profile[idx],
-                                            ICE_MAX_NUM_PROFILES);
+               prof = ice_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];
 
@@ -579,12 +562,13 @@ ice_get_recp_frm_fw(struct ice_hw *hw, struct ice_sw_recipe *recps, u8 rid,
                         * has ICE_AQ_RECIPE_LKUP_IGNORE or 0 since it isn't a
                         * valid offset value.
                         */
-                       if (ice_is_bit_set(possible_idx, rg_entry->fv_idx[i]) ||
+                       if (ice_is_bit_set(hw->switch_info->prof_res_bm[prof],
+                                          rg_entry->fv_idx[i]) ||
                            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_id,
+                       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;
@@ -4950,30 +4934,32 @@ ice_find_free_recp_res_idx(struct ice_hw *hw, const ice_bitmap_t *profiles,
                           ice_bitmap_t *free_idx)
 {
        ice_declare_bitmap(possible_idx, ICE_MAX_FV_WORDS);
-       ice_declare_bitmap(used_idx, ICE_MAX_FV_WORDS);
        ice_declare_bitmap(recipes, ICE_MAX_NUM_RECIPES);
+       ice_declare_bitmap(used_idx, ICE_MAX_FV_WORDS);
        u16 count = 0;
        u16 bit;
 
-       ice_zero_bitmap(free_idx, ICE_MAX_FV_WORDS);
-       ice_zero_bitmap(used_idx, ICE_MAX_FV_WORDS);
+       ice_zero_bitmap(possible_idx, ICE_MAX_FV_WORDS);
        ice_zero_bitmap(recipes, ICE_MAX_NUM_RECIPES);
-       ice_init_possible_res_bm(possible_idx);
+       ice_zero_bitmap(used_idx, ICE_MAX_FV_WORDS);
+       ice_zero_bitmap(free_idx, ICE_MAX_FV_WORDS);
 
-       for (bit = 0; bit < ICE_MAX_FV_WORDS; bit++)
-               if (ICE_POSSIBLE_RES_IDX & BIT_ULL(bit))
-                       ice_set_bit(bit, possible_idx);
+       for (count = 0; count < ICE_MAX_FV_WORDS; count++)
+               ice_set_bit(count, possible_idx);
 
        /* For each profile we are going to associate the recipe with, add the
         * recipes that are associated with that profile. This will give us
-        * the set of recipes that our recipe may collide with.
+        * the set of recipes that our recipe may collide with. Also, determine
+        * what possible result indexes are usable given this set of profiles.
         */
        bit = 0;
        while (ICE_MAX_NUM_PROFILES >
               (bit = ice_find_next_bit(profiles, ICE_MAX_NUM_PROFILES, bit))) {
                ice_or_bitmap(recipes, recipes, profile_to_recipe[bit],
                              ICE_MAX_NUM_RECIPES);
-
+               ice_and_bitmap(possible_idx, possible_idx,
+                              hw->switch_info->prof_res_bm[bit],
+                              ICE_MAX_FV_WORDS);
                bit++;
        }
 
@@ -4981,14 +4967,16 @@ ice_find_free_recp_res_idx(struct ice_hw *hw, const ice_bitmap_t *profiles,
         * which indexes have been used.
         */
        for (bit = 0; bit < ICE_MAX_NUM_RECIPES; bit++)
-               if (ice_is_bit_set(recipes, bit))
+               if (ice_is_bit_set(recipes, bit)) {
                        ice_or_bitmap(used_idx, used_idx,
                                      hw->switch_info->recp_list[bit].res_idxs,
                                      ICE_MAX_FV_WORDS);
+               }
 
        ice_xor_bitmap(free_idx, used_idx, possible_idx, ICE_MAX_FV_WORDS);
 
        /* return number of free indexes */
+       count = 0;
        bit = 0;
        while (ICE_MAX_FV_WORDS >
               (bit = ice_find_next_bit(free_idx, ICE_MAX_FV_WORDS, bit))) {
@@ -5029,6 +5017,9 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
        ice_zero_bitmap(result_idx_bm, ICE_MAX_FV_WORDS);
        free_res_idx = ice_find_free_recp_res_idx(hw, profiles, result_idx_bm);
 
+       ice_debug(hw, ICE_DBG_SW, "Result idx slots: %d, need %d\n",
+                 free_res_idx, rm->n_grp_count);
+
        if (rm->n_grp_count > 1) {
                if (rm->n_grp_count > free_res_idx)
                        return ICE_ERR_MAX_LIMIT;
@@ -6081,6 +6072,12 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups,
        u32 act = 0;
        u8 q_rgn;
 
+       /* Initialize profile to result index bitmap */
+       if (!hw->switch_info->prof_res_bm_init) {
+               hw->switch_info->prof_res_bm_init = 1;
+               ice_init_prof_result_bm(hw);
+       }
+
        if (!lkups_cnt)
                return ICE_ERR_PARAM;
 

diff --git a/drivers/net/ice/base/ice_switch.h b/drivers/net/ice/base/ice_switch.h
index 0f0a1e98eee8f1aedab5581b6f051caebe7963a8..61083738ab00da6ecbc26522948d95adf7ca9b0e 100644 (file)
--- a/drivers/net/ice/base/ice_switch.h
+++ b/drivers/net/ice/base/ice_switch.h
@@ -222,7 +222,6 @@ struct ice_sw_recipe {
        /* Profiles this recipe should be associated with */
        struct LIST_HEAD_TYPE fv_list;
 
-#define ICE_MAX_NUM_PROFILES 256
        /* Profiles this recipe is associated with */
        u8 num_profs, *prof_ids;
 

diff --git a/drivers/net/ice/base/ice_type.h b/drivers/net/ice/base/ice_type.h
index 8322d88a024168a126b6aaf9efb74f8adc5dc281..a8e4229a19f650aebc01a75d101195b04de8a6ed 100644 (file)
--- a/drivers/net/ice/base/ice_type.h
+++ b/drivers/net/ice/base/ice_type.h
@@ -730,6 +730,9 @@ struct ice_port_info {
 struct ice_switch_info {
        struct LIST_HEAD_TYPE vsi_list_map_head;
        struct ice_sw_recipe *recp_list;
+       u16 prof_res_bm_init;
+
+       ice_declare_bitmap(prof_res_bm[ICE_MAX_NUM_PROFILES], ICE_MAX_FV_WORDS);
 };
 
 /* Port hardware description */