p_common->brb_discards = stats.common.brb_discards;
        p_common->tx_mac_ctrl_frames = stats.common.tx_mac_ctrl_frames;
        p_common->link_change_count = stats.common.link_change_count;
+       p_common->ptp_skip_txts = edev->ptp_skip_txts;
 
        if (QEDE_IS_BB(edev)) {
                struct qede_stats_bb *p_bb = &edev->stats.bb;
        if (mode != QEDE_UNLOAD_RECOVERY)
                DP_NOTICE(edev, "Link is down\n");
 
+       edev->ptp_skip_txts = 0;
+
        DP_INFO(edev, "Ending qede unload\n");
 }
 
 
  * SOFTWARE.
  */
 #include "qede_ptp.h"
+#define QEDE_PTP_TX_TIMEOUT (2 * HZ)
 
 struct qede_ptp {
        const struct qed_eth_ptp_ops    *ops;
        struct timecounter              tc;
        struct ptp_clock                *clock;
        struct work_struct              work;
+       unsigned long                   ptp_tx_start;
        struct qede_dev                 *edev;
        struct sk_buff                  *tx_skb;
 
        struct qede_dev *edev;
        struct qede_ptp *ptp;
        u64 timestamp, ns;
+       bool timedout;
        int rc;
 
        ptp = container_of(work, struct qede_ptp, work);
        edev = ptp->edev;
+       timedout = time_is_before_jiffies(ptp->ptp_tx_start +
+                                         QEDE_PTP_TX_TIMEOUT);
 
        /* Read Tx timestamp registers */
        spin_lock_bh(&ptp->lock);
        rc = ptp->ops->read_tx_ts(edev->cdev, ×tamp);
        spin_unlock_bh(&ptp->lock);
        if (rc) {
-               /* Reschedule to keep checking for a valid timestamp value */
-               schedule_work(&ptp->work);
+               if (unlikely(timedout)) {
+                       DP_INFO(edev, "Tx timestamp is not recorded\n");
+                       dev_kfree_skb_any(ptp->tx_skb);
+                       ptp->tx_skb = NULL;
+                       clear_bit_unlock(QEDE_FLAGS_PTP_TX_IN_PRORGESS,
+                                        &edev->flags);
+                       edev->ptp_skip_txts++;
+               } else {
+                       /* Reschedule to keep checking for a valid TS value */
+                       schedule_work(&ptp->work);
+               }
                return;
        }
 
        if (!ptp)
                return;
 
-       if (test_and_set_bit_lock(QEDE_FLAGS_PTP_TX_IN_PRORGESS, &edev->flags))
+       if (test_and_set_bit_lock(QEDE_FLAGS_PTP_TX_IN_PRORGESS,
+                                 &edev->flags)) {
+               DP_ERR(edev, "Timestamping in progress\n");
+               edev->ptp_skip_txts++;
                return;
+       }
 
        if (unlikely(!test_bit(QEDE_FLAGS_TX_TIMESTAMPING_EN, &edev->flags))) {
-               DP_NOTICE(edev,
-                         "Tx timestamping was not enabled, this packet will not be timestamped\n");
+               DP_ERR(edev,
+                      "Tx timestamping was not enabled, this packet will not be timestamped\n");
+               clear_bit_unlock(QEDE_FLAGS_PTP_TX_IN_PRORGESS, &edev->flags);
+               edev->ptp_skip_txts++;
        } else if (unlikely(ptp->tx_skb)) {
-               DP_NOTICE(edev,
-                         "The device supports only a single outstanding packet to timestamp, this packet will not be timestamped\n");
+               DP_ERR(edev,
+                      "The device supports only a single outstanding packet to timestamp, this packet will not be timestamped\n");
+               clear_bit_unlock(QEDE_FLAGS_PTP_TX_IN_PRORGESS, &edev->flags);
+               edev->ptp_skip_txts++;
        } else {
                skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
                /* schedule check for Tx timestamp */
                ptp->tx_skb = skb_get(skb);
+               ptp->ptp_tx_start = jiffies;
                schedule_work(&ptp->work);
        }
 }