ice: only check set bits in ice_ptp_flush_tx_tracker

The ice_ptp_flush_tx_tracker function is called to clear all outstanding Tx
timestamp requests when the port is being brought down. This function
iterates over the entire list, but this is unnecessary. We only need to
check the bits which are actually set in the ready bitmap.

Replace this logic with for_each_set_bit, and follow a similar flow as in
ice_ptp_tx_tstamp_cleanup. Note that it is safe to call dev_kfree_skb_any
on a NULL pointer as it will perform a no-op so we do not need to verify
that the skb is actually NULL.

The new implementation also avoids clearing (and thus reading!) the PHY
timestamp unless the index is marked as having a valid timestamp in the
timestamp status bitmap. This ensures that we properly clear the status
registers as appropriate.

Signed-off-by: Jacob Keller <jacob.e.keller@intel.com>
Tested-by: Gurucharan G <gurucharanx.g@intel.com> (A Contingent worker at Intel)
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>

diff --git a/drivers/net/ethernet/intel/ice/ice_ptp.c b/drivers/net/ethernet/intel/ice/ice_ptp.c
index f9cf9df334e8258f176b4b722aa50a3637431b74..c5de14abe7f43db64ff7e1be081b293c0d0c8b01 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_ptp.c
+++ b/drivers/net/ethernet/intel/ice/ice_ptp.c
@@ -828,28 +828,48 @@ ice_ptp_alloc_tx_tracker(struct ice_ptp_tx *tx)
  * ice_ptp_flush_tx_tracker - Flush any remaining timestamps from the tracker
  * @pf: Board private structure
  * @tx: the tracker to flush
+ *
+ * Called during teardown when a Tx tracker is being removed.
  */
 static void
 ice_ptp_flush_tx_tracker(struct ice_pf *pf, struct ice_ptp_tx *tx)
 {
+       struct ice_hw *hw = &pf->hw;
+       u64 tstamp_ready;
+       int err;
        u8 idx;
 
-       for (idx = 0; idx < tx->len; idx++) {
+       err = ice_get_phy_tx_tstamp_ready(hw, tx->block, &tstamp_ready);
+       if (err) {
+               dev_dbg(ice_pf_to_dev(pf), "Failed to get the Tx tstamp ready bitmap for block %u, err %d\n",
+                       tx->block, err);
+
+               /* If we fail to read the Tx timestamp ready bitmap just
+                * skip clearing the PHY timestamps.
+                */
+               tstamp_ready = 0;
+       }
+
+       for_each_set_bit(idx, tx->in_use, tx->len) {
                u8 phy_idx = idx + tx->offset;
+               struct sk_buff *skb;
+
+               /* In case this timestamp is ready, we need to clear it. */
+               if (!hw->reset_ongoing && (tstamp_ready & BIT_ULL(phy_idx)))
+                       ice_clear_phy_tstamp(hw, tx->block, phy_idx);
 
                spin_lock(&tx->lock);
-               if (tx->tstamps[idx].skb) {
-                       dev_kfree_skb_any(tx->tstamps[idx].skb);
-                       tx->tstamps[idx].skb = NULL;
-                       pf->ptp.tx_hwtstamp_flushed++;
-               }
+               skb = tx->tstamps[idx].skb;
+               tx->tstamps[idx].skb = NULL;
                clear_bit(idx, tx->in_use);
                clear_bit(idx, tx->stale);
                spin_unlock(&tx->lock);
 
-               /* Clear any potential residual timestamp in the PHY block */
-               if (!pf->hw.reset_ongoing)
-                       ice_clear_phy_tstamp(&pf->hw, tx->block, phy_idx);
+               /* Count the number of Tx timestamps flushed */
+               pf->ptp.tx_hwtstamp_flushed++;
+
+               /* Free the SKB after we've cleared the bit */
+               dev_kfree_skb_any(skb);
        }
 }