#define ICE_IPV4_NVGRE_PROTO_ID 0x002F
#define ICE_PPP_IPV6_PROTO_ID 0x0057
#define ICE_IPV6_ETHER_ID 0x86DD
+#define ICE_TCP_PROTO_ID 0x06
/* Dummy ethernet header needed in the ice_aqc_sw_rules_elem
* struct to configure any switch filter rules.
~ICE_AQ_RECIPE_RESULT_EN, recp->res_idxs);
}
+/**
+ * ice_get_tun_type_for_recipe - get tunnel type for the recipe
+ * @rid: recipe ID that we are populating
+ */
+static enum ice_sw_tunnel_type ice_get_tun_type_for_recipe(u8 rid)
+{
+ u8 vxlan_profile[12] = {10, 11, 12, 16, 17, 18, 22, 23, 24, 25, 26, 27};
+ u8 gre_profile[12] = {13, 14, 15, 19, 20, 21, 28, 29, 30, 31, 32, 33};
+ u8 pppoe_profile[7] = {34, 35, 36, 37, 38, 39, 40};
+ u8 non_tun_profile[6] = {4, 5, 6, 7, 8, 9};
+ enum ice_sw_tunnel_type tun_type = ICE_NON_TUN;
+ u16 i, j, profile_num = 0;
+ bool non_tun_valid = false;
+ bool pppoe_valid = false;
+ bool vxlan_valid = false;
+ bool gre_valid = false;
+ bool gtp_valid = false;
+ bool flag_valid = false;
+
+ for (j = 0; j < ICE_MAX_NUM_PROFILES; j++) {
+ if (!ice_is_bit_set(recipe_to_profile[rid], j))
+ continue;
+ else
+ profile_num++;
+
+ for (i = 0; i < 12; i++) {
+ if (gre_profile[i] == j)
+ gre_valid = true;
+ }
+
+ for (i = 0; i < 12; i++) {
+ if (vxlan_profile[i] == j)
+ vxlan_valid = true;
+ }
+
+ for (i = 0; i < 7; i++) {
+ if (pppoe_profile[i] == j)
+ pppoe_valid = true;
+ }
+
+ for (i = 0; i < 6; i++) {
+ if (non_tun_profile[i] == j)
+ non_tun_valid = true;
+ }
+
+ if (j >= ICE_PROFID_IPV4_GTPU_EH_IPV4_OTHER &&
+ j <= ICE_PROFID_IPV6_GTPU_IPV6_OTHER)
+ gtp_valid = true;
+
+ if (j >= ICE_PROFID_IPV4_ESP &&
+ j <= ICE_PROFID_IPV6_PFCP_SESSION)
+ flag_valid = true;
+ }
+
+ if (!non_tun_valid && vxlan_valid)
+ tun_type = ICE_SW_TUN_VXLAN;
+ else if (!non_tun_valid && gre_valid)
+ tun_type = ICE_SW_TUN_NVGRE;
+ else if (!non_tun_valid && pppoe_valid)
+ tun_type = ICE_SW_TUN_PPPOE;
+ else if (!non_tun_valid && gtp_valid)
+ tun_type = ICE_SW_TUN_GTP;
+ else if (non_tun_valid &&
+ (vxlan_valid || gre_valid || gtp_valid || pppoe_valid))
+ tun_type = ICE_SW_TUN_AND_NON_TUN;
+ else if (non_tun_valid && !vxlan_valid && !gre_valid && !gtp_valid &&
+ !pppoe_valid)
+ tun_type = ICE_NON_TUN;
+
+ if (profile_num > 1 && tun_type == ICE_SW_TUN_PPPOE) {
+ i = ice_is_bit_set(recipe_to_profile[rid],
+ ICE_PROFID_PPPOE_IPV4_OTHER);
+ j = ice_is_bit_set(recipe_to_profile[rid],
+ ICE_PROFID_PPPOE_IPV6_OTHER);
+ if (i && !j)
+ tun_type = ICE_SW_TUN_PPPOE_IPV4;
+ else if (!i && j)
+ tun_type = ICE_SW_TUN_PPPOE_IPV6;
+ }
+
+ if (profile_num == 1 && (flag_valid || non_tun_valid || pppoe_valid)) {
+ for (j = 0; j < ICE_MAX_NUM_PROFILES; j++) {
+ if (ice_is_bit_set(recipe_to_profile[rid], j)) {
+ switch (j) {
+ case ICE_PROFID_IPV4_TCP:
+ tun_type = ICE_SW_IPV4_TCP;
+ break;
+ case ICE_PROFID_IPV4_UDP:
+ tun_type = ICE_SW_IPV4_UDP;
+ break;
+ case ICE_PROFID_IPV6_TCP:
+ tun_type = ICE_SW_IPV6_TCP;
+ break;
+ case ICE_PROFID_IPV6_UDP:
+ tun_type = ICE_SW_IPV6_UDP;
+ break;
+ case ICE_PROFID_PPPOE_PAY:
+ tun_type = ICE_SW_TUN_PPPOE_PAY;
+ break;
+ case ICE_PROFID_PPPOE_IPV4_TCP:
+ tun_type = ICE_SW_TUN_PPPOE_IPV4_TCP;
+ break;
+ case ICE_PROFID_PPPOE_IPV4_UDP:
+ tun_type = ICE_SW_TUN_PPPOE_IPV4_UDP;
+ break;
+ case ICE_PROFID_PPPOE_IPV4_OTHER:
+ tun_type = ICE_SW_TUN_PPPOE_IPV4;
+ break;
+ case ICE_PROFID_PPPOE_IPV6_TCP:
+ tun_type = ICE_SW_TUN_PPPOE_IPV6_TCP;
+ break;
+ case ICE_PROFID_PPPOE_IPV6_UDP:
+ tun_type = ICE_SW_TUN_PPPOE_IPV6_UDP;
+ break;
+ case ICE_PROFID_PPPOE_IPV6_OTHER:
+ tun_type = ICE_SW_TUN_PPPOE_IPV6;
+ break;
+ case ICE_PROFID_IPV4_ESP:
+ tun_type = ICE_SW_TUN_IPV4_ESP;
+ break;
+ case ICE_PROFID_IPV6_ESP:
+ tun_type = ICE_SW_TUN_IPV6_ESP;
+ break;
+ case ICE_PROFID_IPV4_AH:
+ tun_type = ICE_SW_TUN_IPV4_AH;
+ break;
+ case ICE_PROFID_IPV6_AH:
+ tun_type = ICE_SW_TUN_IPV6_AH;
+ break;
+ case ICE_PROFID_IPV4_NAT_T:
+ tun_type = ICE_SW_TUN_IPV4_NAT_T;
+ break;
+ case ICE_PROFID_IPV6_NAT_T:
+ tun_type = ICE_SW_TUN_IPV6_NAT_T;
+ break;
+ case ICE_PROFID_IPV4_PFCP_NODE:
+ tun_type =
+ ICE_SW_TUN_PROFID_IPV4_PFCP_NODE;
+ break;
+ case ICE_PROFID_IPV6_PFCP_NODE:
+ tun_type =
+ ICE_SW_TUN_PROFID_IPV6_PFCP_NODE;
+ break;
+ case ICE_PROFID_IPV4_PFCP_SESSION:
+ tun_type =
+ ICE_SW_TUN_PROFID_IPV4_PFCP_SESSION;
+ break;
+ case ICE_PROFID_IPV6_PFCP_SESSION:
+ tun_type =
+ ICE_SW_TUN_PROFID_IPV6_PFCP_SESSION;
+ break;
+ case ICE_PROFID_MAC_IPV4_L2TPV3:
+ tun_type = ICE_SW_TUN_IPV4_L2TPV3;
+ break;
+ case ICE_PROFID_MAC_IPV6_L2TPV3:
+ tun_type = ICE_SW_TUN_IPV6_L2TPV3;
+ break;
+ default:
+ break;
+ }
+
+ return tun_type;
+ }
+ }
+ }
+
+ return tun_type;
+}
+
/**
* ice_get_recp_frm_fw - update SW bookkeeping from FW recipe entries
* @hw: pointer to hardware structure
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].tun_type = ice_get_tun_type_for_recipe(rid);
recps[rid].root_buf = (struct ice_aqc_recipe_data_elem *)
ice_memdup(hw, tmp, recps[rid].n_grp_count *
sizeof(*recps[rid].root_buf), ICE_NONDMA_TO_NONDMA);
ice_remove_vsi_list_rule(struct ice_hw *hw, u16 vsi_list_id,
enum ice_sw_lkup_type lkup_type)
{
- struct ice_aqc_sw_rules_elem *s_rule;
- enum ice_status status;
- u16 s_rule_size;
-
- s_rule_size = (u16)ICE_SW_RULE_VSI_LIST_SIZE(0);
- s_rule = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, s_rule_size);
- if (!s_rule)
- return ICE_ERR_NO_MEMORY;
-
- s_rule->type = CPU_TO_LE16(ICE_AQC_SW_RULES_T_VSI_LIST_CLEAR);
- s_rule->pdata.vsi_list.index = CPU_TO_LE16(vsi_list_id);
-
/* Free the vsi_list resource that we allocated. It is assumed that the
* list is empty at this point.
*/
- status = ice_aq_alloc_free_vsi_list(hw, &vsi_list_id, lkup_type,
+ return ice_aq_alloc_free_vsi_list(hw, &vsi_list_id, lkup_type,
ice_aqc_opc_free_res);
-
- ice_free(hw, s_rule);
- return status;
}
/**
ice_rem_sw_rule_info(hw, rule_head);
else
ice_rem_adv_rule_info(hw, rule_head);
+ if (sw->recp_list[i].adv_rule &&
+ LIST_EMPTY(&sw->recp_list[i].filt_rules))
+ sw->recp_list[i].adv_rule = false;
}
}
/* If for "i"th recipe the found was never set to false
* then it means we found our match
*/
- if ((tun_type == recp[i].tun_type ||
- tun_type == ICE_SW_TUN_AND_NON_TUN) && found)
+ if (tun_type == recp[i].tun_type && found)
return i; /* Return the recipe ID */
}
}
* ice_add_sw_recipe - function to call AQ calls to create switch recipe
* @hw: pointer to hardware structure
* @rm: recipe management list entry
- * @match_tun_mask: tunnel mask that needs to be programmed
* @profiles: bitmap of profiles that will be associated.
*/
static enum ice_status
ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
- u16 match_tun_mask, ice_bitmap_t *profiles)
+ ice_bitmap_t *profiles)
{
ice_declare_bitmap(result_idx_bm, ICE_MAX_FV_WORDS);
struct ice_aqc_recipe_data_elem *tmp;
}
buf[recps].content.act_ctrl_fwd_priority = rm->priority;
- /* To differentiate among different UDP tunnels, a meta data ID
- * flag is used.
- */
- if (match_tun_mask) {
- buf[recps].content.lkup_indx[i] = ICE_TUN_FLAG_FV_IND;
- buf[recps].content.mask[i] =
- CPU_TO_LE16(match_tun_mask);
- }
-
recps++;
rm->root_rid = (u8)rid;
}
recp->n_grp_count = rm->n_grp_count;
recp->tun_type = rm->tun_type;
recp->recp_created = true;
- recp->adv_rule = 1;
}
rm->root_buf = buf;
ice_free(hw, tmp);
case ICE_SW_TUN_IPV4_AH:
ice_set_bit(ICE_PROFID_IPV4_AH, bm);
return;
+ case ICE_SW_IPV4_TCP:
+ ice_set_bit(ICE_PROFID_IPV4_TCP, bm);
+ return;
+ case ICE_SW_IPV4_UDP:
+ ice_set_bit(ICE_PROFID_IPV4_UDP, bm);
+ return;
+ case ICE_SW_IPV6_TCP:
+ ice_set_bit(ICE_PROFID_IPV6_TCP, bm);
+ return;
+ case ICE_SW_IPV6_UDP:
+ ice_set_bit(ICE_PROFID_IPV6_UDP, bm);
+ return;
case ICE_SW_TUN_AND_NON_TUN:
default:
prof_type = ICE_PROF_ALL;
struct ice_sw_fv_list_entry *tmp;
enum ice_status status = ICE_SUCCESS;
struct ice_sw_recipe *rm;
- u16 match_tun_mask = 0;
- u16 mask;
u8 i;
if (!ice_is_prof_rule(rinfo->tun_type) && !lkups_cnt)
if (status)
goto err_unroll;
+ /* Create any special protocol/offset pairs, such as looking at tunnel
+ * bits by extracting metadata
+ */
+ status = ice_add_special_words(rinfo, lkup_exts);
+ if (status)
+ goto err_free_lkup_exts;
+
/* Group match words into recipes using preferred recipe grouping
* criteria.
*/
if (status)
goto err_unroll;
- /* For certain tunnel types it is necessary to use a metadata ID flag to
- * differentiate different tunnel types. A separate recipe needs to be
- * used for the metadata.
- */
- if (ice_tun_type_match_word(rinfo->tun_type, &mask) &&
- rm->n_grp_count > 1)
- match_tun_mask = mask;
-
/* set the recipe priority if specified */
rm->priority = (u8)rinfo->priority;
ice_set_bit((u16)fvit->profile_id, profiles);
}
- /* Create any special protocol/offset pairs, such as looking at tunnel
- * bits by extracting metadata
- */
- status = ice_add_special_words(rinfo, lkup_exts);
- if (status)
- goto err_free_lkup_exts;
-
/* Look for a recipe which matches our requested fv / mask list */
*rid = ice_find_recp(hw, lkup_exts, rinfo->tun_type);
if (*rid < ICE_MAX_NUM_RECIPES)
rm->tun_type = rinfo->tun_type;
/* Recipe we need does not exist, add a recipe */
- status = ice_add_sw_recipe(hw, rm, match_tun_mask, profiles);
+ status = ice_add_sw_recipe(hw, rm, profiles);
if (status)
goto err_unroll;
lkups[i].m_u.ethertype.ethtype_id ==
0xFFFF)
ipv6 = true;
+ else if (lkups[i].type == ICE_IPV4_IL &&
+ lkups[i].h_u.ipv4_hdr.protocol ==
+ ICE_TCP_PROTO_ID &&
+ lkups[i].m_u.ipv4_hdr.protocol ==
+ 0xFF)
+ tcp = true;
}
if (tun_type == ICE_SW_TUN_IPV4_ESP) {
return;
}
+ if (tun_type == ICE_SW_IPV4_TCP) {
+ *pkt = dummy_tcp_packet;
+ *pkt_len = sizeof(dummy_tcp_packet);
+ *offsets = dummy_tcp_packet_offsets;
+ return;
+ }
+
+ if (tun_type == ICE_SW_IPV4_UDP) {
+ *pkt = dummy_udp_packet;
+ *pkt_len = sizeof(dummy_udp_packet);
+ *offsets = dummy_udp_packet_offsets;
+ return;
+ }
+
+ if (tun_type == ICE_SW_IPV6_TCP) {
+ *pkt = dummy_tcp_ipv6_packet;
+ *pkt_len = sizeof(dummy_tcp_ipv6_packet);
+ *offsets = dummy_tcp_ipv6_packet_offsets;
+ return;
+ }
+
+ if (tun_type == ICE_SW_IPV6_UDP) {
+ *pkt = dummy_udp_ipv6_packet;
+ *pkt_len = sizeof(dummy_udp_ipv6_packet);
+ *offsets = dummy_udp_ipv6_packet_offsets;
+ return;
+ }
+
if (tun_type == ICE_ALL_TUNNELS) {
*pkt = dummy_gre_udp_packet;
*pkt_len = sizeof(dummy_gre_udp_packet);
ice_get_hw_vsi_num(hw, rem_vsi_handle);
fm_list->rule_info.sw_act.fwd_id.hw_vsi_id =
ice_get_hw_vsi_num(hw, rem_vsi_handle);
+ fm_list->rule_info.sw_act.vsi_handle = rem_vsi_handle;
/* Update the previous switch rule of "MAC forward to VSI" to
* "MAC fwd to VSI list"
tmp_fltr.fwd_id.hw_vsi_id, status);
return status;
}
+ fm_list->vsi_list_info->ref_cnt--;
/* Remove the VSI list since it is no longer used */
status = ice_remove_vsi_list_rule(hw, vsi_list_id, lkup_type);
if (list_elem->rule_info.sw_act.fltr_act != ICE_FWD_TO_VSI_LIST) {
remove_rule = true;
} else if (list_elem->vsi_count > 1) {
- list_elem->vsi_list_info->ref_cnt--;
remove_rule = false;
vsi_handle = rinfo->sw_act.vsi_handle;
status = ice_adv_rem_update_vsi_list(hw, vsi_handle, list_elem);
rule_buf_sz, 1,
ice_aqc_opc_remove_sw_rules, NULL);
if (status == ICE_SUCCESS || status == ICE_ERR_DOES_NOT_EXIST) {
+ struct ice_switch_info *sw = hw->switch_info;
+
ice_acquire_lock(rule_lock);
LIST_DEL(&list_elem->list_entry);
ice_free(hw, list_elem->lkups);
ice_free(hw, list_elem);
ice_release_lock(rule_lock);
+ if (LIST_EMPTY(&sw->recp_list[rid].filt_rules))
+ sw->recp_list[rid].adv_rule = false;
}
ice_free(hw, s_rule);
}
list_itr->lkups_cnt, &rinfo);
}
}
- return ICE_ERR_PARAM;
+ /* either list is empty or unable to find rule */
+ return ICE_ERR_DOES_NOT_EXIST;
}
/**
git.droids-corp.org / dpdk.git / blobdiff