net/ice/base: remove unnecessary dummy packet finding

[dpdk.git] / drivers / net / ice / base / ice_switch.c

diff --git a/drivers/net/ice/base/ice_switch.c b/drivers/net/ice/base/ice_switch.c
index ef12df5..063a26e 100644 (file)
--- a/drivers/net/ice/base/ice_switch.c
+++ b/drivers/net/ice/base/ice_switch.c
@@ -5825,6 +5825,55 @@ ice_fill_adv_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt,
        return ICE_SUCCESS;
 }
 
+/**
+ * ice_fill_adv_packet_tun - fill dummy packet with udp tunnel port
+ * @hw: pointer to the hardware structure
+ * @tun_type: tunnel type
+ * @pkt: dummy packet to fill in
+ * @offsets: offset info for the dummy packet
+ */
+static enum ice_status
+ice_fill_adv_packet_tun(struct ice_hw *hw, enum ice_sw_tunnel_type tun_type,
+                       u8 *pkt, const struct ice_dummy_pkt_offsets *offsets)
+{
+       u16 open_port, i;
+
+       switch (tun_type) {
+       case ICE_SW_TUN_AND_NON_TUN:
+       case ICE_SW_TUN_VXLAN_GPE:
+       case ICE_SW_TUN_VXLAN:
+       case ICE_SW_TUN_UDP:
+               if (!ice_get_open_tunnel_port(hw, TNL_VXLAN, &open_port))
+                       return ICE_ERR_CFG;
+               break;
+
+       case ICE_SW_TUN_GENEVE:
+               if (!ice_get_open_tunnel_port(hw, TNL_GENEVE, &open_port))
+                       return ICE_ERR_CFG;
+               break;
+
+       default:
+               /* Nothing needs to be done for this tunnel type */
+               return ICE_SUCCESS;
+       }
+
+       /* Find the outer UDP protocol header and insert the port number */
+       for (i = 0; offsets[i].type != ICE_PROTOCOL_LAST; i++) {
+               if (offsets[i].type == ICE_UDP_OF) {
+                       struct ice_l4_hdr *hdr;
+                       u16 offset;
+
+                       offset = offsets[i].offset;
+                       hdr = (struct ice_l4_hdr *)&pkt[offset];
+                       hdr->dst_port = open_port << 8 | open_port >> 8;
+
+                       return ICE_SUCCESS;
+               }
+       }
+
+       return ICE_ERR_CFG;
+}
+
 /**
  * ice_find_adv_rule_entry - Search a rule entry
  * @hw: pointer to the hardware structure
@@ -6129,6 +6178,14 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups,
        ice_fill_adv_dummy_packet(lkups, lkups_cnt, s_rule, pkt, pkt_len,
                                  pkt_offsets);
 
+       if (rinfo->tun_type != ICE_NON_TUN) {
+               status = ice_fill_adv_packet_tun(hw, rinfo->tun_type,
+                                                s_rule->pdata.lkup_tx_rx.hdr,
+                                                pkt_offsets);
+               if (status)
+                       goto err_ice_add_adv_rule;
+       }
+
        status = ice_aq_sw_rules(hw, (struct ice_aqc_sw_rules *)s_rule,
                                 rule_buf_sz, 1, ice_aqc_opc_add_sw_rules,
                                 NULL);
@@ -6303,14 +6360,11 @@ ice_rem_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups,
                 u16 lkups_cnt, struct ice_adv_rule_info *rinfo)
 {
        struct ice_adv_fltr_mgmt_list_entry *list_elem;
-       const struct ice_dummy_pkt_offsets *offsets;
        struct ice_prot_lkup_ext lkup_exts;
-       u16 rule_buf_sz, pkt_len, i, rid;
        struct ice_lock *rule_lock; /* Lock to protect filter rule list */
        enum ice_status status = ICE_SUCCESS;
        bool remove_rule = false;
-       const u8 *pkt = NULL;
-       u16 vsi_handle;
+       u16 i, rid, vsi_handle;
 
        ice_memset(&lkup_exts, 0, sizeof(lkup_exts), ICE_NONDMA_MEM);
        for (i = 0; i < lkups_cnt; i++) {
@@ -6362,10 +6416,9 @@ ice_rem_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups,
        ice_release_lock(rule_lock);
        if (remove_rule) {
                struct ice_aqc_sw_rules_elem *s_rule;
+               u16 rule_buf_sz;
 
-               ice_find_dummy_packet(lkups, lkups_cnt, rinfo->tun_type, &pkt,
-                                     &pkt_len, &offsets);
-               rule_buf_sz = ICE_SW_RULE_RX_TX_NO_HDR_SIZE + pkt_len;
+               rule_buf_sz = ICE_SW_RULE_RX_TX_NO_HDR_SIZE;
                s_rule =
                        (struct ice_aqc_sw_rules_elem *)ice_malloc(hw,
                                                                   rule_buf_sz);