/** * i40e_ptp_rx_hang - Detect error case when Rx timestamp registers are hung * @pf: The PF private data structure * @vsi: The VSI with the rings relevant to 1588 * * This watchdog task is scheduled to detect error case where hardware has * dropped an Rx packet that was timestamped when the ring is full. The * particular error is rare but leaves the device in a state unable to timestamp * any future packets. **/ void i40e_ptp_rx_hang(struct i40e_pf *pf) { struct i40e_hw *hw = &pf->hw; unsigned int i, cleared = 0; /* Since we cannot turn off the Rx timestamp logic if the device is * configured for Tx timestamping, we check if Rx timestamping is * configured. We don't want to spuriously warn about Rx timestamp * hangs if we don't care about the timestamps. */ if (!(pf->flags & I40E_FLAG_PTP) || !pf->ptp_rx) return; spin_lock_bh(&pf->ptp_rx_lock); /* Update current latch times for Rx events */ i40e_ptp_get_rx_events(pf); /* Check all the currently latched Rx events and see whether they have * been latched for over a second. It is assumed that any timestamp * should have been cleared within this time, or else it was captured * for a dropped frame that the driver never received. Thus, we will * clear any timestamp that has been latched for over 1 second. */ for (i = 0; i < 4; i++) { if ((pf->latch_event_flags & BIT(i)) && time_is_before_jiffies(pf->latch_events[i] + HZ)) { rd32(hw, I40E_PRTTSYN_RXTIME_H(i)); pf->latch_event_flags &= ~BIT(i); cleared++; } } spin_unlock_bh(&pf->ptp_rx_lock); /* Log a warning if more than 2 timestamps got dropped in the same * check. We don't want to warn about all drops because it can occur * in normal scenarios such as PTP frames on multicast addresses we * aren't listening to. However, administrator should know if this is * the reason packets aren't receiving timestamps. */ if (cleared > 2) dev_dbg(&pf->pdev->dev, "Dropped %d missed RXTIME timestamp events\n", cleared); /* Finally, update the rx_hwtstamp_cleared counter */ pf->rx_hwtstamp_cleared += cleared; }
/** * i40e_ptp_rx_hang - Detect error case when Rx timestamp registers are hung * @vsi: The VSI with the rings relevant to 1588 * * This watchdog task is scheduled to detect error case where hardware has * dropped an Rx packet that was timestamped when the ring is full. The * particular error is rare but leaves the device in a state unable to timestamp * any future packets. **/ void i40e_ptp_rx_hang(struct i40e_vsi *vsi) { struct i40e_pf *pf = vsi->back; struct i40e_hw *hw = &pf->hw; int i; /* Since we cannot turn off the Rx timestamp logic if the device is * configured for Tx timestamping, we check if Rx timestamping is * configured. We don't want to spuriously warn about Rx timestamp * hangs if we don't care about the timestamps. */ if (!(pf->flags & I40E_FLAG_PTP) || !pf->ptp_rx) return; spin_lock_bh(&pf->ptp_rx_lock); /* Update current latch times for Rx events */ i40e_ptp_get_rx_events(pf); /* Check all the currently latched Rx events and see whether they have * been latched for over a second. It is assumed that any timestamp * should have been cleared within this time, or else it was captured * for a dropped frame that the driver never received. Thus, we will * clear any timestamp that has been latched for over 1 second. */ for (i = 0; i < 4; i++) { if ((pf->latch_event_flags & BIT(i)) && time_is_before_jiffies(pf->latch_events[i] + HZ)) { rd32(hw, I40E_PRTTSYN_RXTIME_H(i)); pf->latch_event_flags &= ~BIT(i); pf->rx_hwtstamp_cleared++; dev_warn(&pf->pdev->dev, "Clearing a missed Rx timestamp event for RXTIME[%d]\n", i); } } spin_unlock_bh(&pf->ptp_rx_lock); }
/** * i40e_ptp_rx_hwtstamp - Utility function which checks for an Rx timestamp * @pf: Board private structure * @skb: Particular skb to send timestamp with * @index: Index into the receive timestamp registers for the timestamp * * The XL710 receives a notification in the receive descriptor with an offset * into the set of RXTIME registers where the timestamp is for that skb. This * function goes and fetches the receive timestamp from that offset, if a valid * one exists. The RXTIME registers are in ns, so we must convert the result * first. **/ void i40e_ptp_rx_hwtstamp(struct i40e_pf *pf, struct sk_buff *skb, u8 index) { u32 prttsyn_stat, hi, lo; struct i40e_hw *hw; u64 ns; /* Since we cannot turn off the Rx timestamp logic if the device is * doing Tx timestamping, check if Rx timestamping is configured. */ if (!(pf->flags & I40E_FLAG_PTP) || !pf->ptp_rx) return; hw = &pf->hw; spin_lock_bh(&pf->ptp_rx_lock); /* Get current Rx events and update latch times */ prttsyn_stat = i40e_ptp_get_rx_events(pf); /* TODO: Should we warn about missing Rx timestamp event? */ if (!(prttsyn_stat & BIT(index))) { spin_unlock_bh(&pf->ptp_rx_lock); return; } /* Clear the latched event since we're about to read its register */ pf->latch_event_flags &= ~BIT(index); lo = rd32(hw, I40E_PRTTSYN_RXTIME_L(index)); hi = rd32(hw, I40E_PRTTSYN_RXTIME_H(index)); spin_unlock_bh(&pf->ptp_rx_lock); ns = (((u64)hi) << 32) | lo; i40e_ptp_convert_to_hwtstamp(skb_hwtstamps(skb), ns); }