3 files changed, 367 insertions, 68 deletions

diff --git a/drivers/net/ethernet/intel/igb/igb.h b/drivers/net/ethernet/intel/igb/igb.h
index 82d891e183b1..c2bd4f98a837 100644
--- a/drivers/net/ethernet/intel/igb/igb.h
+++ b/drivers/net/ethernet/intel/igb/igb.h
@@ -29,7 +29,7 @@
 #include "e1000_mac.h"
 #include "e1000_82575.h"
 
-#include <linux/clocksource.h>
+#include <linux/timecounter.h>
 #include <linux/net_tstamp.h>
 #include <linux/ptp_clock_kernel.h>
 #include <linux/bitops.h>
@@ -343,6 +343,9 @@ struct hwmon_buff {
         };
 #endif
 
+#define IGB_N_EXTTS     2
+#define IGB_N_PEROUT    2
+#define IGB_N_SDP       4
 #define IGB_RETA_SIZE   128
 
 /* board specific private data structure */
@@ -439,6 +442,12 @@ struct igb_adapter {
         u32 tx_hwtstamp_timeouts;
         u32 rx_hwtstamp_cleared;
 
+        struct ptp_pin_desc sdp_config[IGB_N_SDP];
+        struct {
+                struct timespec start;
+                struct timespec period;
+        } perout[IGB_N_PEROUT];
+
         char fw_version[32];
 #ifdef CONFIG_IGB_HWMON
         struct hwmon_buff *igb_hwmon_buff;
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index ff59897a9463..f366b3b96d03 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -5035,9 +5035,9 @@ netdev_tx_t igb_xmit_frame_ring(struct sk_buff *skb,
 
         skb_tx_timestamp(skb);
 
-        if (vlan_tx_tag_present(skb)) {
+        if (skb_vlan_tag_present(skb)) {
                 tx_flags |= IGB_TX_FLAGS_VLAN;
-                tx_flags |= (vlan_tx_tag_get(skb) << IGB_TX_FLAGS_VLAN_SHIFT);
+                tx_flags |= (skb_vlan_tag_get(skb) << IGB_TX_FLAGS_VLAN_SHIFT);
         }
 
         /* record initial flags and protocol */
@@ -5384,6 +5384,80 @@ void igb_update_stats(struct igb_adapter *adapter,
         }
 }
 
+static void igb_tsync_interrupt(struct igb_adapter *adapter)
+{
+        struct e1000_hw *hw = &adapter->hw;
+        struct ptp_clock_event event;
+        struct timespec ts;
+        u32 ack = 0, tsauxc, sec, nsec, tsicr = rd32(E1000_TSICR);
+
+        if (tsicr & TSINTR_SYS_WRAP) {
+                event.type = PTP_CLOCK_PPS;
+                if (adapter->ptp_caps.pps)
+                        ptp_clock_event(adapter->ptp_clock, &event);
+                else
+                        dev_err(&adapter->pdev->dev, "unexpected SYS WRAP");
+                ack |= TSINTR_SYS_WRAP;
+        }
+
+        if (tsicr & E1000_TSICR_TXTS) {
+                /* retrieve hardware timestamp */
+                schedule_work(&adapter->ptp_tx_work);
+                ack |= E1000_TSICR_TXTS;
+        }
+
+        if (tsicr & TSINTR_TT0) {
+                spin_lock(&adapter->tmreg_lock);
+                ts = timespec_add(adapter->perout[0].start,
+                                  adapter->perout[0].period);
+                wr32(E1000_TRGTTIML0, ts.tv_nsec);
+                wr32(E1000_TRGTTIMH0, ts.tv_sec);
+                tsauxc = rd32(E1000_TSAUXC);
+                tsauxc |= TSAUXC_EN_TT0;
+                wr32(E1000_TSAUXC, tsauxc);
+                adapter->perout[0].start = ts;
+                spin_unlock(&adapter->tmreg_lock);
+                ack |= TSINTR_TT0;
+        }
+
+        if (tsicr & TSINTR_TT1) {
+                spin_lock(&adapter->tmreg_lock);
+                ts = timespec_add(adapter->perout[1].start,
+                                  adapter->perout[1].period);
+                wr32(E1000_TRGTTIML1, ts.tv_nsec);
+                wr32(E1000_TRGTTIMH1, ts.tv_sec);
+                tsauxc = rd32(E1000_TSAUXC);
+                tsauxc |= TSAUXC_EN_TT1;
+                wr32(E1000_TSAUXC, tsauxc);
+                adapter->perout[1].start = ts;
+                spin_unlock(&adapter->tmreg_lock);
+                ack |= TSINTR_TT1;
+        }
+
+        if (tsicr & TSINTR_AUTT0) {
+                nsec = rd32(E1000_AUXSTMPL0);
+                sec  = rd32(E1000_AUXSTMPH0);
+                event.type = PTP_CLOCK_EXTTS;
+                event.index = 0;
+                event.timestamp = sec * 1000000000ULL + nsec;
+                ptp_clock_event(adapter->ptp_clock, &event);
+                ack |= TSINTR_AUTT0;
+        }
+
+        if (tsicr & TSINTR_AUTT1) {
+                nsec = rd32(E1000_AUXSTMPL1);
+                sec  = rd32(E1000_AUXSTMPH1);
+                event.type = PTP_CLOCK_EXTTS;
+                event.index = 1;
+                event.timestamp = sec * 1000000000ULL + nsec;
+                ptp_clock_event(adapter->ptp_clock, &event);
+                ack |= TSINTR_AUTT1;
+        }
+
+        /* acknowledge the interrupts */
+        wr32(E1000_TSICR, ack);
+}
+
 static irqreturn_t igb_msix_other(int irq, void *data)
 {
         struct igb_adapter *adapter = data;
@@ -5415,16 +5489,8 @@ static irqreturn_t igb_msix_other(int irq, void *data)
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-        if (icr & E1000_ICR_TS) {
-                u32 tsicr = rd32(E1000_TSICR);
-
-                if (tsicr & E1000_TSICR_TXTS) {
-                        /* acknowledge the interrupt */
-                        wr32(E1000_TSICR, E1000_TSICR_TXTS);
-                        /* retrieve hardware timestamp */
-                        schedule_work(&adapter->ptp_tx_work);
-                }
-        }
+        if (icr & E1000_ICR_TS)
+                igb_tsync_interrupt(adapter);
 
         wr32(E1000_EIMS, adapter->eims_other);
 
@@ -6011,8 +6077,12 @@ static void igb_vf_reset_msg(struct igb_adapter *adapter, u32 vf)
         adapter->vf_data[vf].flags |= IGB_VF_FLAG_CTS;
 
         /* reply to reset with ack and vf mac address */
-        msgbuf[0] = E1000_VF_RESET | E1000_VT_MSGTYPE_ACK;
-        memcpy(addr, vf_mac, ETH_ALEN);
+        if (!is_zero_ether_addr(vf_mac)) {
+                msgbuf[0] = E1000_VF_RESET | E1000_VT_MSGTYPE_ACK;
+                memcpy(addr, vf_mac, ETH_ALEN);
+        } else {
+                msgbuf[0] = E1000_VF_RESET | E1000_VT_MSGTYPE_NACK;
+        }
         igb_write_mbx(hw, msgbuf, 3, vf);
 }
 
@@ -6203,16 +6273,8 @@ static irqreturn_t igb_intr_msi(int irq, void *data)
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-        if (icr & E1000_ICR_TS) {
-                u32 tsicr = rd32(E1000_TSICR);
-
-                if (tsicr & E1000_TSICR_TXTS) {
-                        /* acknowledge the interrupt */
-                        wr32(E1000_TSICR, E1000_TSICR_TXTS);
-                        /* retrieve hardware timestamp */
-                        schedule_work(&adapter->ptp_tx_work);
-                }
-        }
+        if (icr & E1000_ICR_TS)
+                igb_tsync_interrupt(adapter);
 
         napi_schedule(&q_vector->napi);
 
@@ -6257,16 +6319,8 @@ static irqreturn_t igb_intr(int irq, void *data)
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-        if (icr & E1000_ICR_TS) {
-                u32 tsicr = rd32(E1000_TSICR);
-
-                if (tsicr & E1000_TSICR_TXTS) {
-                        /* acknowledge the interrupt */
-                        wr32(E1000_TSICR, E1000_TSICR_TXTS);
-                        /* retrieve hardware timestamp */
-                        schedule_work(&adapter->ptp_tx_work);
-                }
-        }
+        if (icr & E1000_ICR_TS)
+                igb_tsync_interrupt(adapter);
 
         napi_schedule(&q_vector->napi);
 
@@ -6527,15 +6581,17 @@ static void igb_reuse_rx_page(struct igb_ring *rx_ring,
                                          DMA_FROM_DEVICE);
 }
 
+static inline bool igb_page_is_reserved(struct page *page)
+{
+        return (page_to_nid(page) != numa_mem_id()) || page->pfmemalloc;
+}
+
 static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer,
                                   struct page *page,
                                   unsigned int truesize)
 {
         /* avoid re-using remote pages */
-        if (unlikely(page_to_nid(page) != numa_node_id()))
-                return false;
-
-        if (unlikely(page->pfmemalloc))
+        if (unlikely(igb_page_is_reserved(page)))
                 return false;
 
 #if (PAGE_SIZE < 8192)
@@ -6545,22 +6601,19 @@ static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer,
 
         /* flip page offset to other buffer */
         rx_buffer->page_offset ^= IGB_RX_BUFSZ;
-
-        /* Even if we own the page, we are not allowed to use atomic_set()
-         * This would break get_page_unless_zero() users.
-         */
-        atomic_inc(&page->_count);
 #else
         /* move offset up to the next cache line */
         rx_buffer->page_offset += truesize;
 
         if (rx_buffer->page_offset > (PAGE_SIZE - IGB_RX_BUFSZ))
                 return false;
-
-        /* bump ref count on page before it is given to the stack */
-        get_page(page);
 #endif
 
+        /* Even if we own the page, we are not allowed to use atomic_set()
+         * This would break get_page_unless_zero() users.
+         */
+        atomic_inc(&page->_count);
+
         return true;
 }
 
@@ -6603,13 +6656,12 @@ static bool igb_add_rx_frag(struct igb_ring *rx_ring,
 
                 memcpy(__skb_put(skb, size), va, ALIGN(size, sizeof(long)));
 
-                /* we can reuse buffer as-is, just make sure it is local */
-                if (likely((page_to_nid(page) == numa_node_id()) &&
-                           !page->pfmemalloc))
+                /* page is not reserved, we can reuse buffer as-is */
+                if (likely(!igb_page_is_reserved(page)))
                         return true;
 
                 /* this page cannot be reused so discard it */
-                put_page(page);
+                __free_page(page);
                 return false;
         }
 
@@ -6627,7 +6679,6 @@ static struct sk_buff *igb_fetch_rx_buffer(struct igb_ring *rx_ring,
         struct page *page;
 
         rx_buffer = &rx_ring->rx_buffer_info[rx_ring->next_to_clean];
-
         page = rx_buffer->page;
         prefetchw(page);
 
@@ -7042,8 +7093,8 @@ void igb_alloc_rx_buffers(struct igb_ring *rx_ring, u16 cleaned_count)
                         i -= rx_ring->count;
                 }
 
-                /* clear the hdr_addr for the next_to_use descriptor */
-                rx_desc->read.hdr_addr = 0;
+                /* clear the status bits for the next_to_use descriptor */
+                rx_desc->wb.upper.status_error = 0;
 
                 cleaned_count--;
         } while (cleaned_count);
diff --git a/drivers/net/ethernet/intel/igb/igb_ptp.c b/drivers/net/ethernet/intel/igb/igb_ptp.c
index 794c139f0cc0..d20fc8ed11f1 100644
--- a/drivers/net/ethernet/intel/igb/igb_ptp.c
+++ b/drivers/net/ethernet/intel/igb/igb_ptp.c
@@ -256,14 +256,9 @@ static int igb_ptp_adjtime_82576(struct ptp_clock_info *ptp, s64 delta)
         struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
                                                ptp_caps);
         unsigned long flags;
-        s64 now;
 
         spin_lock_irqsave(&igb->tmreg_lock, flags);
-
-        now = timecounter_read(&igb->tc);
-        now += delta;
-        timecounter_init(&igb->tc, &igb->cc, now);
-
+        timecounter_adjtime(&igb->tc, delta);
         spin_unlock_irqrestore(&igb->tmreg_lock, flags);
 
         return 0;
@@ -360,12 +355,239 @@ static int igb_ptp_settime_i210(struct ptp_clock_info *ptp,
         return 0;
 }
 
+static void igb_pin_direction(int pin, int input, u32 *ctrl, u32 *ctrl_ext)
+{
+        u32 *ptr = pin < 2 ? ctrl : ctrl_ext;
+        u32 mask[IGB_N_SDP] = {
+                E1000_CTRL_SDP0_DIR,
+                E1000_CTRL_SDP1_DIR,
+                E1000_CTRL_EXT_SDP2_DIR,
+                E1000_CTRL_EXT_SDP3_DIR,
+        };
+
+        if (input)
+                *ptr &= ~mask[pin];
+        else
+                *ptr |= mask[pin];
+}
+
+static void igb_pin_extts(struct igb_adapter *igb, int chan, int pin)
+{
+        struct e1000_hw *hw = &igb->hw;
+        u32 aux0_sel_sdp[IGB_N_SDP] = {
+                AUX0_SEL_SDP0, AUX0_SEL_SDP1, AUX0_SEL_SDP2, AUX0_SEL_SDP3,
+        };
+        u32 aux1_sel_sdp[IGB_N_SDP] = {
+                AUX1_SEL_SDP0, AUX1_SEL_SDP1, AUX1_SEL_SDP2, AUX1_SEL_SDP3,
+        };
+        u32 ts_sdp_en[IGB_N_SDP] = {
+                TS_SDP0_EN, TS_SDP1_EN, TS_SDP2_EN, TS_SDP3_EN,
+        };
+        u32 ctrl, ctrl_ext, tssdp = 0;
+
+        ctrl = rd32(E1000_CTRL);
+        ctrl_ext = rd32(E1000_CTRL_EXT);
+        tssdp = rd32(E1000_TSSDP);
+
+        igb_pin_direction(pin, 1, &ctrl, &ctrl_ext);
+
+        /* Make sure this pin is not enabled as an output. */
+        tssdp &= ~ts_sdp_en[pin];
+
+        if (chan == 1) {
+                tssdp &= ~AUX1_SEL_SDP3;
+                tssdp |= aux1_sel_sdp[pin] | AUX1_TS_SDP_EN;
+        } else {
+                tssdp &= ~AUX0_SEL_SDP3;
+                tssdp |= aux0_sel_sdp[pin] | AUX0_TS_SDP_EN;
+        }
+
+        wr32(E1000_TSSDP, tssdp);
+        wr32(E1000_CTRL, ctrl);
+        wr32(E1000_CTRL_EXT, ctrl_ext);
+}
+
+static void igb_pin_perout(struct igb_adapter *igb, int chan, int pin)
+{
+        struct e1000_hw *hw = &igb->hw;
+        u32 aux0_sel_sdp[IGB_N_SDP] = {
+                AUX0_SEL_SDP0, AUX0_SEL_SDP1, AUX0_SEL_SDP2, AUX0_SEL_SDP3,
+        };
+        u32 aux1_sel_sdp[IGB_N_SDP] = {
+                AUX1_SEL_SDP0, AUX1_SEL_SDP1, AUX1_SEL_SDP2, AUX1_SEL_SDP3,
+        };
+        u32 ts_sdp_en[IGB_N_SDP] = {
+                TS_SDP0_EN, TS_SDP1_EN, TS_SDP2_EN, TS_SDP3_EN,
+        };
+        u32 ts_sdp_sel_tt0[IGB_N_SDP] = {
+                TS_SDP0_SEL_TT0, TS_SDP1_SEL_TT0,
+                TS_SDP2_SEL_TT0, TS_SDP3_SEL_TT0,
+        };
+        u32 ts_sdp_sel_tt1[IGB_N_SDP] = {
+                TS_SDP0_SEL_TT1, TS_SDP1_SEL_TT1,
+                TS_SDP2_SEL_TT1, TS_SDP3_SEL_TT1,
+        };
+        u32 ts_sdp_sel_clr[IGB_N_SDP] = {
+                TS_SDP0_SEL_FC1, TS_SDP1_SEL_FC1,
+                TS_SDP2_SEL_FC1, TS_SDP3_SEL_FC1,
+        };
+        u32 ctrl, ctrl_ext, tssdp = 0;
+
+        ctrl = rd32(E1000_CTRL);
+        ctrl_ext = rd32(E1000_CTRL_EXT);
+        tssdp = rd32(E1000_TSSDP);
+
+        igb_pin_direction(pin, 0, &ctrl, &ctrl_ext);
+
+        /* Make sure this pin is not enabled as an input. */
+        if ((tssdp & AUX0_SEL_SDP3) == aux0_sel_sdp[pin])
+                tssdp &= ~AUX0_TS_SDP_EN;
+
+        if ((tssdp & AUX1_SEL_SDP3) == aux1_sel_sdp[pin])
+                tssdp &= ~AUX1_TS_SDP_EN;
+
+        tssdp &= ~ts_sdp_sel_clr[pin];
+        if (chan == 1)
+                tssdp |= ts_sdp_sel_tt1[pin];
+        else
+                tssdp |= ts_sdp_sel_tt0[pin];
+
+        tssdp |= ts_sdp_en[pin];
+
+        wr32(E1000_TSSDP, tssdp);
+        wr32(E1000_CTRL, ctrl);
+        wr32(E1000_CTRL_EXT, ctrl_ext);
+}
+
+static int igb_ptp_feature_enable_i210(struct ptp_clock_info *ptp,
+                                       struct ptp_clock_request *rq, int on)
+{
+        struct igb_adapter *igb =
+                container_of(ptp, struct igb_adapter, ptp_caps);
+        struct e1000_hw *hw = &igb->hw;
+        u32 tsauxc, tsim, tsauxc_mask, tsim_mask, trgttiml, trgttimh;
+        unsigned long flags;
+        struct timespec ts;
+        int pin;
+        s64 ns;
+
+        switch (rq->type) {
+        case PTP_CLK_REQ_EXTTS:
+                if (on) {
+                        pin = ptp_find_pin(igb->ptp_clock, PTP_PF_EXTTS,
+                                           rq->extts.index);
+                        if (pin < 0)
+                                return -EBUSY;
+                }
+                if (rq->extts.index == 1) {
+                        tsauxc_mask = TSAUXC_EN_TS1;
+                        tsim_mask = TSINTR_AUTT1;
+                } else {
+                        tsauxc_mask = TSAUXC_EN_TS0;
+                        tsim_mask = TSINTR_AUTT0;
+                }
+                spin_lock_irqsave(&igb->tmreg_lock, flags);
+                tsauxc = rd32(E1000_TSAUXC);
+                tsim = rd32(E1000_TSIM);
+                if (on) {
+                        igb_pin_extts(igb, rq->extts.index, pin);
+                        tsauxc |= tsauxc_mask;
+                        tsim |= tsim_mask;
+                } else {
+                        tsauxc &= ~tsauxc_mask;
+                        tsim &= ~tsim_mask;
+                }
+                wr32(E1000_TSAUXC, tsauxc);
+                wr32(E1000_TSIM, tsim);
+                spin_unlock_irqrestore(&igb->tmreg_lock, flags);
+                return 0;
+
+        case PTP_CLK_REQ_PEROUT:
+                if (on) {
+                        pin = ptp_find_pin(igb->ptp_clock, PTP_PF_PEROUT,
+                                           rq->perout.index);
+                        if (pin < 0)
+                                return -EBUSY;
+                }
+                ts.tv_sec = rq->perout.period.sec;
+                ts.tv_nsec = rq->perout.period.nsec;
+                ns = timespec_to_ns(&ts);
+                ns = ns >> 1;
+                if (on && ns < 500000LL) {
+                        /* 2k interrupts per second is an awful lot. */
+                        return -EINVAL;
+                }
+                ts = ns_to_timespec(ns);
+                if (rq->perout.index == 1) {
+                        tsauxc_mask = TSAUXC_EN_TT1;
+                        tsim_mask = TSINTR_TT1;
+                        trgttiml = E1000_TRGTTIML1;
+                        trgttimh = E1000_TRGTTIMH1;
+                } else {
+                        tsauxc_mask = TSAUXC_EN_TT0;
+                        tsim_mask = TSINTR_TT0;
+                        trgttiml = E1000_TRGTTIML0;
+                        trgttimh = E1000_TRGTTIMH0;
+                }
+                spin_lock_irqsave(&igb->tmreg_lock, flags);
+                tsauxc = rd32(E1000_TSAUXC);
+                tsim = rd32(E1000_TSIM);
+                if (on) {
+                        int i = rq->perout.index;
+
+                        igb_pin_perout(igb, i, pin);
+                        igb->perout[i].start.tv_sec = rq->perout.start.sec;
+                        igb->perout[i].start.tv_nsec = rq->perout.start.nsec;
+                        igb->perout[i].period.tv_sec = ts.tv_sec;
+                        igb->perout[i].period.tv_nsec = ts.tv_nsec;
+                        wr32(trgttiml, rq->perout.start.sec);
+                        wr32(trgttimh, rq->perout.start.nsec);
+                        tsauxc |= tsauxc_mask;
+                        tsim |= tsim_mask;
+                } else {
+                        tsauxc &= ~tsauxc_mask;
+                        tsim &= ~tsim_mask;
+                }
+                wr32(E1000_TSAUXC, tsauxc);
+                wr32(E1000_TSIM, tsim);
+                spin_unlock_irqrestore(&igb->tmreg_lock, flags);
+                return 0;
+
+        case PTP_CLK_REQ_PPS:
+                spin_lock_irqsave(&igb->tmreg_lock, flags);
+                tsim = rd32(E1000_TSIM);
+                if (on)
+                        tsim |= TSINTR_SYS_WRAP;
+                else
+                        tsim &= ~TSINTR_SYS_WRAP;
+                wr32(E1000_TSIM, tsim);
+                spin_unlock_irqrestore(&igb->tmreg_lock, flags);
+                return 0;
+        }
+
+        return -EOPNOTSUPP;
+}
+
 static int igb_ptp_feature_enable(struct ptp_clock_info *ptp,
                                   struct ptp_clock_request *rq, int on)
 {
         return -EOPNOTSUPP;
 }
 
+static int igb_ptp_verify_pin(struct ptp_clock_info *ptp, unsigned int pin,
+                              enum ptp_pin_function func, unsigned int chan)
+{
+        switch (func) {
+        case PTP_PF_NONE:
+        case PTP_PF_EXTTS:
+        case PTP_PF_PEROUT:
+                break;
+        case PTP_PF_PHYSYNC:
+                return -1;
+        }
+        return 0;
+}
+
 /**
  * igb_ptp_tx_work
  * @work: pointer to work struct
@@ -756,6 +978,7 @@ void igb_ptp_init(struct igb_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
         struct net_device *netdev = adapter->netdev;
+        int i;
 
         switch (hw->mac.type) {
         case e1000_82576:
@@ -770,7 +993,7 @@ void igb_ptp_init(struct igb_adapter *adapter)
                 adapter->ptp_caps.settime = igb_ptp_settime_82576;
                 adapter->ptp_caps.enable = igb_ptp_feature_enable;
                 adapter->cc.read = igb_ptp_read_82576;
-                adapter->cc.mask = CLOCKSOURCE_MASK(64);
+                adapter->cc.mask = CYCLECOUNTER_MASK(64);
                 adapter->cc.mult = 1;
                 adapter->cc.shift = IGB_82576_TSYNC_SHIFT;
                 /* Dial the nominal frequency. */
@@ -790,7 +1013,7 @@ void igb_ptp_init(struct igb_adapter *adapter)
                 adapter->ptp_caps.settime = igb_ptp_settime_82576;
                 adapter->ptp_caps.enable = igb_ptp_feature_enable;
                 adapter->cc.read = igb_ptp_read_82580;
-                adapter->cc.mask = CLOCKSOURCE_MASK(IGB_NBITS_82580);
+                adapter->cc.mask = CYCLECOUNTER_MASK(IGB_NBITS_82580);
                 adapter->cc.mult = 1;
                 adapter->cc.shift = 0;
                 /* Enable the timer functions by clearing bit 31. */
@@ -798,16 +1021,27 @@ void igb_ptp_init(struct igb_adapter *adapter)
                 break;
         case e1000_i210:
         case e1000_i211:
+                for (i = 0; i < IGB_N_SDP; i++) {
+                        struct ptp_pin_desc *ppd = &adapter->sdp_config[i];
+
+                        snprintf(ppd->name, sizeof(ppd->name), "SDP%d", i);
+                        ppd->index = i;
+                        ppd->func = PTP_PF_NONE;
+                }
                 snprintf(adapter->ptp_caps.name, 16, "%pm", netdev->dev_addr);
                 adapter->ptp_caps.owner = THIS_MODULE;
                 adapter->ptp_caps.max_adj = 62499999;
-                adapter->ptp_caps.n_ext_ts = 0;
-                adapter->ptp_caps.pps = 0;
+                adapter->ptp_caps.n_ext_ts = IGB_N_EXTTS;
+                adapter->ptp_caps.n_per_out = IGB_N_PEROUT;
+                adapter->ptp_caps.n_pins = IGB_N_SDP;
+                adapter->ptp_caps.pps = 1;
+                adapter->ptp_caps.pin_config = adapter->sdp_config;
                 adapter->ptp_caps.adjfreq = igb_ptp_adjfreq_82580;
                 adapter->ptp_caps.adjtime = igb_ptp_adjtime_i210;
                 adapter->ptp_caps.gettime = igb_ptp_gettime_i210;
                 adapter->ptp_caps.settime = igb_ptp_settime_i210;
-                adapter->ptp_caps.enable = igb_ptp_feature_enable;
+                adapter->ptp_caps.enable = igb_ptp_feature_enable_i210;
+                adapter->ptp_caps.verify = igb_ptp_verify_pin;
                 /* Enable the timer functions by clearing bit 31. */
                 wr32(E1000_TSAUXC, 0x0);
                 break;
@@ -905,6 +1139,7 @@ void igb_ptp_stop(struct igb_adapter *adapter)
 void igb_ptp_reset(struct igb_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
+        unsigned long flags;
 
         if (!(adapter->flags & IGB_FLAG_PTP))
                 return;
@@ -912,6 +1147,8 @@ void igb_ptp_reset(struct igb_adapter *adapter)
         /* reset the tstamp_config */
         igb_ptp_set_timestamp_mode(adapter, &adapter->tstamp_config);
 
+        spin_lock_irqsave(&adapter->tmreg_lock, flags);
+
         switch (adapter->hw.mac.type) {
         case e1000_82576:
                 /* Dial the nominal frequency. */
@@ -922,23 +1159,25 @@ void igb_ptp_reset(struct igb_adapter *adapter)
         case e1000_i350:
         case e1000_i210:
         case e1000_i211:
-                /* Enable the timer functions and interrupts. */
                 wr32(E1000_TSAUXC, 0x0);
+                wr32(E1000_TSSDP, 0x0);
                 wr32(E1000_TSIM, TSYNC_INTERRUPTS);
                 wr32(E1000_IMS, E1000_IMS_TS);
                 break;
         default:
                 /* No work to do. */
-                return;
+                goto out;
         }
 
         /* Re-initialize the timer. */
         if ((hw->mac.type == e1000_i210) || (hw->mac.type == e1000_i211)) {
                 struct timespec ts = ktime_to_timespec(ktime_get_real());
 
-                igb_ptp_settime_i210(&adapter->ptp_caps, &ts);
+                igb_ptp_write_i210(adapter, &ts);
         } else {
                 timecounter_init(&adapter->tc, &adapter->cc,
                                  ktime_to_ns(ktime_get_real()));
         }
+out:
+        spin_unlock_irqrestore(&adapter->tmreg_lock, flags);
 }