net/ice: revert fake TSO fixes

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

diff --git a/drivers/net/ice/base/ice_flow.c b/drivers/net/ice/base/ice_flow.c
index 1e944bf..6035bdf 100644 (file)
--- a/drivers/net/ice/base/ice_flow.c
+++ b/drivers/net/ice/base/ice_flow.c
@@ -469,6 +469,29 @@ static const u32 ice_ptypes_gtpc_tid[] = {
 };
 
 /* Packet types for GTPU */
+static const struct ice_ptype_attributes ice_attr_gtpu_session[] = {
+       { ICE_MAC_IPV4_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV4_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV4_GTPU_IPV4_UDP_PAY, ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV4_GTPU_IPV4_TCP,     ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV4_GTPU_IPV4_ICMP,    ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV6_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV6_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV6_GTPU_IPV4_UDP_PAY, ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV6_GTPU_IPV4_TCP,     ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV6_GTPU_IPV4_ICMP,    ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV4_GTPU_IPV6_FRAG,    ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV4_GTPU_IPV6_PAY,     ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV4_GTPU_IPV6_UDP_PAY, ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV4_GTPU_IPV6_TCP,     ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV4_GTPU_IPV6_ICMPV6,  ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV6_GTPU_IPV6_FRAG,    ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV6_GTPU_IPV6_PAY,     ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV6_GTPU_IPV6_UDP_PAY, ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV6_GTPU_IPV6_TCP,     ICE_PTYPE_ATTR_GTP_SESSION },
+       { ICE_MAC_IPV6_GTPU_IPV6_ICMPV6,  ICE_PTYPE_ATTR_GTP_SESSION },
+};
+
 static const struct ice_ptype_attributes ice_attr_gtpu_eh[] = {
        { ICE_MAC_IPV4_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_PDU_EH },
        { ICE_MAC_IPV4_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_PDU_EH },
@@ -805,16 +828,16 @@ ice_flow_proc_seg_hdrs(struct ice_flow_prof_params *params)
                }
                if ((hdrs & ICE_FLOW_SEG_HDR_IPV4) &&
                    (hdrs & ICE_FLOW_SEG_HDR_IPV_OTHER)) {
-                       src = !i ?
-                               (const ice_bitmap_t *)ice_ptypes_ipv4_ofos_all :
-                               (const ice_bitmap_t *)ice_ptypes_ipv4_il;
+                       src = i ?
+                               (const ice_bitmap_t *)ice_ptypes_ipv4_il :
+                               (const ice_bitmap_t *)ice_ptypes_ipv4_ofos_all;
                        ice_and_bitmap(params->ptypes, params->ptypes, src,
                                       ICE_FLOW_PTYPE_MAX);
                } else if ((hdrs & ICE_FLOW_SEG_HDR_IPV6) &&
                           (hdrs & ICE_FLOW_SEG_HDR_IPV_OTHER)) {
-                       src = !i ?
-                               (const ice_bitmap_t *)ice_ptypes_ipv6_ofos_all :
-                               (const ice_bitmap_t *)ice_ptypes_ipv6_il;
+                       src = i ?
+                               (const ice_bitmap_t *)ice_ptypes_ipv6_il :
+                               (const ice_bitmap_t *)ice_ptypes_ipv6_ofos_all;
                        ice_and_bitmap(params->ptypes, params->ptypes, src,
                                       ICE_FLOW_PTYPE_MAX);
                } else if ((hdrs & ICE_FLOW_SEG_HDR_IPV4) &&
@@ -916,6 +939,10 @@ ice_flow_proc_seg_hdrs(struct ice_flow_prof_params *params)
                        src = (const ice_bitmap_t *)ice_ptypes_gtpu;
                        ice_and_bitmap(params->ptypes, params->ptypes,
                                       src, ICE_FLOW_PTYPE_MAX);
+
+                       /* Attributes for GTP packet without Extension Header */
+                       params->attr = ice_attr_gtpu_session;
+                       params->attr_cnt = ARRAY_SIZE(ice_attr_gtpu_session);
                } else if (hdrs & ICE_FLOW_SEG_HDR_L2TPV3) {
                        src = (const ice_bitmap_t *)ice_ptypes_l2tpv3;
                        ice_and_bitmap(params->ptypes, params->ptypes,
@@ -2215,15 +2242,17 @@ enum ice_status
 ice_flow_get_hw_prof(struct ice_hw *hw, enum ice_block blk, u64 prof_id,
                     u8 *hw_prof_id)
 {
+       enum ice_status status = ICE_ERR_DOES_NOT_EXIST;
        struct ice_prof_map *map;
 
+       ice_acquire_lock(&hw->blk[blk].es.prof_map_lock);
        map = ice_search_prof_id(hw, blk, prof_id);
        if (map) {
                *hw_prof_id = map->prof_id;
-               return ICE_SUCCESS;
+               status = ICE_SUCCESS;
        }
-
-       return ICE_ERR_DOES_NOT_EXIST;
+       ice_release_lock(&hw->blk[blk].es.prof_map_lock);
+       return status;
 }
 
 /**
@@ -3312,7 +3341,7 @@ enum ice_status ice_rem_vsi_rss_cfg(struct ice_hw *hw, u16 vsi_handle)
        if (LIST_EMPTY(&hw->fl_profs[blk]))
                return ICE_SUCCESS;
 
-       ice_acquire_lock(&hw->fl_profs_locks[blk]);
+       ice_acquire_lock(&hw->rss_locks);
        LIST_FOR_EACH_ENTRY_SAFE(p, t, &hw->fl_profs[blk], ice_flow_prof,
                                 l_entry)
                if (ice_is_bit_set(p->vsis, vsi_handle)) {
@@ -3321,12 +3350,12 @@ enum ice_status ice_rem_vsi_rss_cfg(struct ice_hw *hw, u16 vsi_handle)
                                break;
 
                        if (!ice_is_any_bit_set(p->vsis, ICE_MAX_VSI)) {
-                               status = ice_flow_rem_prof_sync(hw, blk, p);
+                               status = ice_flow_rem_prof(hw, blk, p->id);
                                if (status)
                                        break;
                        }
                }
-       ice_release_lock(&hw->fl_profs_locks[blk]);
+       ice_release_lock(&hw->rss_locks);
 
        return status;
 }
@@ -3456,9 +3485,13 @@ ice_rss_update_symm(struct ice_hw *hw,
        struct ice_prof_map *map;
        u8 prof_id, m;
 
+       ice_acquire_lock(&hw->blk[ICE_BLK_RSS].es.prof_map_lock);
        map = ice_search_prof_id(hw, ICE_BLK_RSS, prof->id);
-       prof_id = map->prof_id;
-
+       if (map)
+               prof_id = map->prof_id;
+       ice_release_lock(&hw->blk[ICE_BLK_RSS].es.prof_map_lock);
+       if (!map)
+               return;
        /* clear to default */
        for (m = 0; m < 6; m++)
                wr32(hw, GLQF_HSYMM(prof_id, m), 0);
@@ -3551,6 +3584,13 @@ ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
        if (status)
                goto exit;
 
+       /* don't do RSS for GTPU outer */
+       if (segs_cnt == ICE_RSS_OUTER_HEADERS &&
+           segs[segs_cnt - 1].hdrs & ICE_FLOW_SEG_HDR_GTPU) {
+               status = ICE_SUCCESS;
+               goto exit;
+       }
+
        /* Search for a flow profile that has matching headers, hash fields
         * and has the input VSI associated to it. If found, no further
         * operations required and exit.
@@ -3667,6 +3707,7 @@ ice_add_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
        ice_acquire_lock(&hw->rss_locks);
        status = ice_add_rss_cfg_sync(hw, vsi_handle, hashed_flds, addl_hdrs,
                                      ICE_RSS_OUTER_HEADERS, symm);
+
        if (!status)
                status = ice_add_rss_cfg_sync(hw, vsi_handle, hashed_flds,
                                              addl_hdrs, ICE_RSS_INNER_HEADERS,
@@ -3706,6 +3747,12 @@ ice_rem_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
        if (status)
                goto out;
 
+       if (segs_cnt == ICE_RSS_OUTER_HEADERS &&
+           segs[segs_cnt - 1].hdrs & ICE_FLOW_SEG_HDR_GTPU) {
+               status = ICE_SUCCESS;
+               goto out;
+       }
+
        prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, segs_cnt,
                                        vsi_handle,
                                        ICE_FLOW_FIND_PROF_CHK_FLDS);
@@ -3814,7 +3861,8 @@ enum ice_status ice_replay_rss_cfg(struct ice_hw *hw, u16 vsi_handle)
  */
 u64 ice_get_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u32 hdrs)
 {
-       struct ice_rss_cfg *r, *rss_cfg = NULL;
+       u64 rss_hash = ICE_HASH_INVALID;
+       struct ice_rss_cfg *r;
 
        /* verify if the protocol header is non zero and VSI is valid */
        if (hdrs == ICE_FLOW_SEG_HDR_NONE || !ice_is_vsi_valid(hw, vsi_handle))
@@ -3825,10 +3873,10 @@ u64 ice_get_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u32 hdrs)
                            ice_rss_cfg, l_entry)
                if (ice_is_bit_set(r->vsis, vsi_handle) &&
                    r->packet_hdr == hdrs) {
-                       rss_cfg = r;
+                       rss_hash = r->hashed_flds;
                        break;
                }
        ice_release_lock(&hw->rss_locks);
 
-       return rss_cfg ? rss_cfg->hashed_flds : ICE_HASH_INVALID;
+       return rss_hash;
 }