#include "ice_flex_type.h"
#include "ice_flow.h"
-
#define ICE_ETH_DA_OFFSET 0
#define ICE_ETH_ETHTYPE_OFFSET 12
#define ICE_ETH_VLAN_TCI_OFFSET 14
{ ICE_UDP_OF, 34 },
{ ICE_VXLAN, 42 },
{ ICE_GENEVE, 42 },
+ { ICE_VXLAN_GPE, 42 },
{ ICE_MAC_IL, 50 },
{ ICE_IPV4_IL, 64 },
{ ICE_TCP_IL, 84 },
{ ICE_UDP_OF, 34 },
{ ICE_VXLAN, 42 },
{ ICE_GENEVE, 42 },
+ { ICE_VXLAN_GPE, 42 },
{ ICE_MAC_IL, 50 },
{ ICE_IPV4_IL, 64 },
{ ICE_UDP_ILOS, 84 },
static const
struct ice_dummy_pkt_offsets dummy_pppoe_packet_offsets[] = {
- { ICE_MAC_OFOS, 0 },
- { ICE_PPPOE, 14 },
+ { ICE_MAC_OFOS, 0 },
+ { ICE_VLAN_OFOS, 14},
+ { ICE_PPPOE, 18 },
{ ICE_PROTOCOL_LAST, 0 },
};
0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
- 0x88, 0x64,
+ 0x81, 0x00,
- 0x11, 0x00, 0x00, 0x01, /* ICE_PPPOE 14 */
+ 0x00, 0x00, 0x88, 0x64, /* ICE_VLAN_OFOS 14 */
+
+ 0x11, 0x00, 0x00, 0x01, /* ICE_PPPOE 18 */
0x00, 0x4e, 0x00, 0x21,
0x45, 0x00, 0x00, 0x30, /* PDU */
0x00, 0x11, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
+
+ 0x00, 0x00, /* 2 bytes for 4 byte alignment */
};
/* this is a recipe to profile association bitmap */
~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
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;
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,
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;
~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];
* 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;
recps[rid].big_recp = (num_recps > 1);
recps[rid].n_grp_count = num_recps;
recps[rid].root_buf = (struct ice_aqc_recipe_data_elem *)
- ice_calloc(hw, recps[rid].n_grp_count,
- sizeof(struct ice_aqc_recipe_data_elem));
+ ice_memdup(hw, tmp, recps[rid].n_grp_count *
+ sizeof(*recps[rid].root_buf), ICE_NONDMA_TO_NONDMA);
if (!recps[rid].root_buf)
goto err_unroll;
- ice_memcpy(recps[rid].root_buf, tmp, recps[rid].n_grp_count *
- sizeof(*recps[rid].root_buf), ICE_NONDMA_TO_NONDMA);
-
/* Copy result indexes */
- ice_memcpy(recps[rid].res_idxs, result_bm, sizeof(recps[rid].res_idxs),
- ICE_NONDMA_TO_NONDMA);
+ ice_cp_bitmap(recps[rid].res_idxs, result_bm, ICE_MAX_FV_WORDS);
recps[rid].recp_created = true;
err_unroll:
ice_zero_bitmap(r_bitmap, ICE_MAX_NUM_RECIPES);
if (ice_aq_get_recipe_to_profile(hw, i, (u8 *)r_bitmap, NULL))
continue;
- ice_memcpy(profile_to_recipe[i], r_bitmap,
- sizeof(profile_to_recipe[i]), ICE_NONDMA_TO_NONDMA);
+ ice_cp_bitmap(profile_to_recipe[i], r_bitmap,
+ ICE_MAX_NUM_RECIPES);
for (j = 0; j < ICE_MAX_NUM_RECIPES; j++)
if (ice_is_bit_set(r_bitmap, j))
ice_set_bit(i, recipe_to_profile[j]);
return status;
}
-
/**
* ice_alloc_sw - allocate resources specific to switch
* @hw: pointer to the HW struct
}
} while (req_desc && !status);
-
out:
ice_free(hw, (void *)rbuf);
return status;
}
-
/**
* ice_fill_sw_info - Helper function to populate lb_en and lan_en
* @hw: pointer to the hardware structure
return ICE_SUCCESS;
}
-
/**
* ice_rem_sw_rule_info
* @hw: pointer to the hardware structure
return status;
}
-
/**
* ice_determine_promisc_mask
* @fi: filter info to parse
* 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[] = {
+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, { 0, 2 } },
{ 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_IL, { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24,
- 26, 28, 30, 32, 34, 36, 38 } },
{ 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 } },
{ ICE_NVGRE, { 0, 2, 4, 6 } },
{ ICE_GTP, { 8, 10, 12, 14, 16, 18, 20 } },
{ ICE_PPPOE, { 0, 2, 4, 6 } },
- { ICE_PROTOCOL_LAST, { 0 } }
};
/* The following table describes preferred grouping of recipes.
* following policy.
*/
-static const struct ice_protocol_entry ice_prot_id_tbl[] = {
+static const 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_NVGRE, ICE_GRE_OF_HW },
{ ICE_GTP, ICE_UDP_OF_HW },
{ ICE_PPPOE, ICE_PPPOE_HW },
- { ICE_PROTOCOL_LAST, 0 }
};
/**
&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 *a = lkup_exts->fv_words;
return ret_val;
}
-
-
/**
* ice_create_first_fit_recp_def - Create a recipe grouping
* @hw: pointer to the hardware structure
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++;
}
* 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))) {
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;
if (status)
goto err_unroll;
- ice_or_bitmap(rm->r_bitmap, r_bitmap, rm->r_bitmap,
+ ice_or_bitmap(r_bitmap, r_bitmap, rm->r_bitmap,
ICE_MAX_NUM_RECIPES);
status = ice_acquire_change_lock(hw, ICE_RES_WRITE);
if (status)
goto err_unroll;
status = ice_aq_map_recipe_to_profile(hw, fvit->profile_id,
- (u8 *)rm->r_bitmap,
+ (u8 *)r_bitmap,
NULL);
ice_release_change_lock(hw);
goto err_unroll;
/* Update profile to recipe bitmap array */
- ice_memcpy(profile_to_recipe[fvit->profile_id], rm->r_bitmap,
- sizeof(rm->r_bitmap), ICE_NONDMA_TO_NONDMA);
+ ice_cp_bitmap(profile_to_recipe[fvit->profile_id], r_bitmap,
+ ICE_MAX_NUM_RECIPES);
/* Update recipe to profile bitmap array */
for (j = 0; j < ICE_MAX_NUM_RECIPES; j++)
- if (ice_is_bit_set(rm->r_bitmap, j))
+ if (ice_is_bit_set(r_bitmap, j))
ice_set_bit((u16)fvit->profile_id,
recipe_to_profile[j]);
}
case ICE_ETYPE_OL:
len = sizeof(struct ice_ethtype_hdr);
break;
+ case ICE_VLAN_OFOS:
+ len = sizeof(struct ice_vlan_hdr);
+ break;
case ICE_IPV4_OFOS:
case ICE_IPV4_IL:
len = sizeof(struct ice_ipv4_hdr);
break;
case ICE_IPV6_OFOS:
case ICE_IPV6_IL:
+ /* Based on the same mechanism below, if tc (Traffic
+ * Class) for IPv6 has mask, it means tc field is set.
+ * Since tc is only one byte, we have to handle the
+ * big/little endian issue before it can be inserted.
+ */
+ if (lkups[i].m_u.ipv6_hdr.tc) {
+ ((u16 *)&lkups[i].h_u)[0] =
+ (((u16 *)&lkups[i].h_u)[0] << 8) |
+ (((u16 *)&lkups[i].h_u)[0] >> 8);
+ ((u16 *)&lkups[i].m_u)[0] =
+ (((u16 *)&lkups[i].m_u)[0] << 8) |
+ (((u16 *)&lkups[i].m_u)[0] >> 8);
+ }
len = sizeof(struct ice_ipv6_hdr);
break;
case ICE_TCP_IL:
case ICE_GTP:
len = sizeof(struct ice_udp_gtp_hdr);
break;
+ case ICE_PPPOE:
+ len = sizeof(struct ice_pppoe_hdr);
+ break;
default:
return ICE_ERR_PARAM;
}
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;
s_rule->pdata.lkup_tx_rx.recipe_id = CPU_TO_LE16(rid);
s_rule->pdata.lkup_tx_rx.act = CPU_TO_LE32(act);
- ice_fill_adv_dummy_packet(lkups, lkups_cnt, s_rule, pkt, pkt_len,
- pkt_offsets);
+ status = ice_fill_adv_dummy_packet(lkups, lkups_cnt, s_rule, pkt,
+ pkt_len, pkt_offsets);
+ if (status)
+ goto err_ice_add_adv_rule;
if (rinfo->tun_type != ICE_NON_TUN) {
status = ice_fill_adv_packet_tun(hw, rinfo->tun_type,
git.droids-corp.org / dpdk.git / blobdiff