11 files changed, 23 insertions, 95 deletions

diff --git a/Documentation/networking/packet_mmap.txt b/Documentation/networking/packet_mmap.txt
index 38112d512f47..a6d7cb91069e 100644
--- a/Documentation/networking/packet_mmap.txt
+++ b/Documentation/networking/packet_mmap.txt
@@ -1008,14 +1008,9 @@ hardware timestamps to be used. Note: you may need to enable the generation
 of hardware timestamps with SIOCSHWTSTAMP (see related information from
 Documentation/networking/timestamping.txt).
 
-PACKET_TIMESTAMP accepts the same integer bit field as
-SO_TIMESTAMPING.  However, only the SOF_TIMESTAMPING_SYS_HARDWARE
-and SOF_TIMESTAMPING_RAW_HARDWARE values are recognized by
-PACKET_TIMESTAMP.  SOF_TIMESTAMPING_SYS_HARDWARE takes precedence over
-SOF_TIMESTAMPING_RAW_HARDWARE if both bits are set.
-
-    int req = 0;
-    req |= SOF_TIMESTAMPING_SYS_HARDWARE;
+PACKET_TIMESTAMP accepts the same integer bit field as SO_TIMESTAMPING:
+
+    int req = SOF_TIMESTAMPING_RAW_HARDWARE;
     setsockopt(fd, SOL_PACKET, PACKET_TIMESTAMP, (void *) &req, sizeof(req))
 
 For the mmap(2)ed ring buffers, such timestamps are stored in the
@@ -1023,14 +1018,13 @@ tpacket{,2,3}_hdr structure's tp_sec and tp_{n,u}sec members. To determine
 what kind of timestamp has been reported, the tp_status field is binary |'ed
 with the following possible bits ...
 
-    TP_STATUS_TS_SYS_HARDWARE
     TP_STATUS_TS_RAW_HARDWARE
     TP_STATUS_TS_SOFTWARE
 
 ... that are equivalent to its SOF_TIMESTAMPING_* counterparts. For the
-RX_RING, if none of those 3 are set (i.e. PACKET_TIMESTAMP is not set),
-then this means that a software fallback was invoked *within* PF_PACKET's
-processing code (less precise).
+RX_RING, if neither is set (i.e. PACKET_TIMESTAMP is not set), then a
+software fallback was invoked *within* PF_PACKET's processing code (less
+precise).
 
 Getting timestamps for the TX_RING works as follows: i) fill the ring frames,
 ii) call sendto() e.g. in blocking mode, iii) wait for status of relevant
diff --git a/Documentation/networking/timestamping.txt b/Documentation/networking/timestamping.txt
index 8b4ad809df27..897f942b976b 100644
--- a/Documentation/networking/timestamping.txt
+++ b/Documentation/networking/timestamping.txt
@@ -88,15 +88,8 @@ hwtimeraw is the original hardware time stamp. Filled in if
 SOF_TIMESTAMPING_RAW_HARDWARE is set. No assumptions about its
 relation to system time should be made.
 
-hwtimetrans is the hardware time stamp transformed so that it
-corresponds as good as possible to system time. This correlation is
-not perfect; as a consequence, sorting packets received via different
-NICs by their hwtimetrans may differ from the order in which they were
-received. hwtimetrans may be non-monotonic even for the same NIC.
-Filled in if SOF_TIMESTAMPING_SYS_HARDWARE is set. Requires support
-by the network device and will be empty without that support. This
-field is DEPRECATED. Only one driver computes this value. New device
-drivers must leave this zero. Instead, they can expose the hardware
+hwtimetrans is always zero. This field is deprecated. It used to hold
+hw timestamps converted to system time. Instead, expose the hardware
 clock device on the NIC directly as a HW PTP clock source, to allow
 time conversion in userspace and optionally synchronize system time
 with a userspace PTP stack such as linuxptp. For the PTP clock API,
@@ -191,7 +184,6 @@ struct skb_shared_hwtstamps {
          * since arbitrary point in time
          */
         ktime_t hwtstamp;
-        ktime_t syststamp; /* hwtstamp transformed to system time base */
 };
 
 Time stamps for outgoing packets are to be generated as follows:
diff --git a/Documentation/networking/timestamping/timestamping.c b/Documentation/networking/timestamping/timestamping.c
index 8ba82bfe6a33..5cdfd743447b 100644
--- a/Documentation/networking/timestamping/timestamping.c
+++ b/Documentation/networking/timestamping/timestamping.c
@@ -76,7 +76,6 @@ static void usage(const char *error)
                "  SOF_TIMESTAMPING_RX_HARDWARE - hardware time stamping of incoming packets\n"
                "  SOF_TIMESTAMPING_RX_SOFTWARE - software fallback for incoming packets\n"
                "  SOF_TIMESTAMPING_SOFTWARE - request reporting of software time stamps\n"
-               "  SOF_TIMESTAMPING_SYS_HARDWARE - request reporting of transformed HW time stamps\n"
                "  SOF_TIMESTAMPING_RAW_HARDWARE - request reporting of raw HW time stamps\n"
                "  SIOCGSTAMP - check last socket time stamp\n"
                "  SIOCGSTAMPNS - more accurate socket time stamp\n");
@@ -202,9 +201,7 @@ static void printpacket(struct msghdr *msg, int res,
                                        (long)stamp->tv_sec,
                                        (long)stamp->tv_nsec);
                                 stamp++;
-                                printf("HW transformed %ld.%09ld ",
-                                       (long)stamp->tv_sec,
-                                       (long)stamp->tv_nsec);
+                                /* skip deprecated HW transformed */
                                 stamp++;
                                 printf("HW raw %ld.%09ld",
                                        (long)stamp->tv_sec,
@@ -361,8 +358,6 @@ int main(int argc, char **argv)
                         so_timestamping_flags |= SOF_TIMESTAMPING_RX_SOFTWARE;
                 else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_SOFTWARE"))
                         so_timestamping_flags |= SOF_TIMESTAMPING_SOFTWARE;
-                else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_SYS_HARDWARE"))
-                        so_timestamping_flags |= SOF_TIMESTAMPING_SYS_HARDWARE;
                 else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_RAW_HARDWARE"))
                         so_timestamping_flags |= SOF_TIMESTAMPING_RAW_HARDWARE;
                 else
diff --git a/drivers/net/ethernet/neterion/vxge/vxge-main.c b/drivers/net/ethernet/neterion/vxge/vxge-main.c
index 7a0deadd53bf..2eda153cb1e0 100644
--- a/drivers/net/ethernet/neterion/vxge/vxge-main.c
+++ b/drivers/net/ethernet/neterion/vxge/vxge-main.c
@@ -503,7 +503,6 @@ vxge_rx_1b_compl(struct __vxge_hw_ring *ringh, void *dtr,
 
                         skb_hwts = skb_hwtstamps(skb);
                         skb_hwts->hwtstamp = ns_to_ktime(ns);
-                        skb_hwts->syststamp.tv64 = 0;
                 }
 
                 /* rth_hash_type and rth_it_hit are non-zero regardless of
diff --git a/drivers/net/ethernet/octeon/octeon_mgmt.c b/drivers/net/ethernet/octeon/octeon_mgmt.c
index 7dc3e9b06d75..979c6980639f 100644
--- a/drivers/net/ethernet/octeon/octeon_mgmt.c
+++ b/drivers/net/ethernet/octeon/octeon_mgmt.c
@@ -247,28 +247,6 @@ static void octeon_mgmt_rx_fill_ring(struct net_device *netdev)
         }
 }
 
-static ktime_t ptp_to_ktime(u64 ptptime)
-{
-        ktime_t ktimebase;
-        u64 ptpbase;
-        unsigned long flags;
-
-        local_irq_save(flags);
-        /* Fill the icache with the code */
-        ktime_get_real();
-        /* Flush all pending operations */
-        mb();
-        /* Read the time and PTP clock as close together as
-         * possible. It is important that this sequence take the same
-         * amount of time to reduce jitter
-         */
-        ktimebase = ktime_get_real();
-        ptpbase = cvmx_read_csr(CVMX_MIO_PTP_CLOCK_HI);
-        local_irq_restore(flags);
-
-        return ktime_sub_ns(ktimebase, ptpbase - ptptime);
-}
-
 static void octeon_mgmt_clean_tx_buffers(struct octeon_mgmt *p)
 {
         union cvmx_mixx_orcnt mix_orcnt;
@@ -312,12 +290,12 @@ static void octeon_mgmt_clean_tx_buffers(struct octeon_mgmt *p)
                 /* Read the hardware TX timestamp if one was recorded */
                 if (unlikely(re.s.tstamp)) {
                         struct skb_shared_hwtstamps ts;
+                        memset(&ts, 0, sizeof(ts));
                         /* Read the timestamp */
                         u64 ns = cvmx_read_csr(CVMX_MIXX_TSTAMP(p->port));
                         /* Remove the timestamp from the FIFO */
                         cvmx_write_csr(CVMX_MIXX_TSCTL(p->port), 0);
                         /* Tell the kernel about the timestamp */
-                        ts.syststamp = ptp_to_ktime(ns);
                         ts.hwtstamp = ns_to_ktime(ns);
                         skb_tstamp_tx(skb, &ts);
                 }
@@ -429,7 +407,6 @@ good:
                         struct skb_shared_hwtstamps *ts;
                         ts = skb_hwtstamps(skb);
                         ts->hwtstamp = ns_to_ktime(ns);
-                        ts->syststamp = ptp_to_ktime(ns);
                         __skb_pull(skb, 8);
                 }
                 skb->protocol = eth_type_trans(skb, netdev);
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index b613557132b9..281deced7469 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -210,20 +210,9 @@ static inline void skb_frag_size_sub(skb_frag_t *frag, int delta)
  * struct skb_shared_hwtstamps - hardware time stamps
  * @hwtstamp:   hardware time stamp transformed into duration
  *              since arbitrary point in time
- * @syststamp:  hwtstamp transformed to system time base (deprecated)
  *
  * Software time stamps generated by ktime_get_real() are stored in
- * skb->tstamp. The relation between the different kinds of time
- * stamps is as follows:
- *
- * syststamp and tstamp can be compared against each other in
- * arbitrary combinations.  The accuracy of a
- * syststamp/tstamp/"syststamp from other device" comparison is
- * limited by the accuracy of the transformation into system time
- * base. This depends on the device driver and its underlying
- * hardware. The syststamp implementation is deprecated in favor
- * of hwtstamps and hw PTP clock sources exposed directly to
- * userspace.
+ * skb->tstamp.
  *
  * hwtstamps can only be compared against other hwtstamps from
  * the same device.
@@ -233,7 +222,6 @@ static inline void skb_frag_size_sub(skb_frag_t *frag, int delta)
  */
 struct skb_shared_hwtstamps {
         ktime_t hwtstamp;
-        ktime_t syststamp;
 };
 
 /* Definitions for tx_flags in struct skb_shared_info */
diff --git a/include/net/sock.h b/include/net/sock.h
index 720773304a85..b91c8868ab8d 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -707,7 +707,6 @@ enum sock_flags {
         SOCK_TIMESTAMPING_RX_SOFTWARE,  /* %SOF_TIMESTAMPING_RX_SOFTWARE */
         SOCK_TIMESTAMPING_SOFTWARE,     /* %SOF_TIMESTAMPING_SOFTWARE */
         SOCK_TIMESTAMPING_RAW_HARDWARE, /* %SOF_TIMESTAMPING_RAW_HARDWARE */
-        SOCK_TIMESTAMPING_SYS_HARDWARE, /* %SOF_TIMESTAMPING_SYS_HARDWARE */
         SOCK_FASYNC, /* fasync() active */
         SOCK_RXQ_OVFL,
         SOCK_ZEROCOPY, /* buffers from userspace */
@@ -2166,16 +2165,13 @@ sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
          * - software time stamp available and wanted
          *   (SOCK_TIMESTAMPING_SOFTWARE)
          * - hardware time stamps available and wanted
-         *   (SOCK_TIMESTAMPING_SYS_HARDWARE or
-         *   SOCK_TIMESTAMPING_RAW_HARDWARE)
+         *   SOCK_TIMESTAMPING_RAW_HARDWARE
          */
         if (sock_flag(sk, SOCK_RCVTSTAMP) ||
             sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE) ||
             (kt.tv64 && sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) ||
             (hwtstamps->hwtstamp.tv64 &&
-             sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE)) ||
-            (hwtstamps->syststamp.tv64 &&
-             sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE)))
+             sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE)))
                 __sock_recv_timestamp(msg, sk, skb);
         else
                 sk->sk_stamp = kt;
@@ -2193,8 +2189,7 @@ static inline void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
 #define FLAGS_TS_OR_DROPS ((1UL << SOCK_RXQ_OVFL)                       | \
                            (1UL << SOCK_RCVTSTAMP)                      | \
                            (1UL << SOCK_TIMESTAMPING_SOFTWARE)          | \
-                           (1UL << SOCK_TIMESTAMPING_RAW_HARDWARE)      | \
-                           (1UL << SOCK_TIMESTAMPING_SYS_HARDWARE))
+                           (1UL << SOCK_TIMESTAMPING_RAW_HARDWARE))
 
         if (sk->sk_flags & FLAGS_TS_OR_DROPS)
                 __sock_recv_ts_and_drops(msg, sk, skb);
diff --git a/include/uapi/linux/if_packet.h b/include/uapi/linux/if_packet.h
index bac27fa05f5b..da2d668b8cf1 100644
--- a/include/uapi/linux/if_packet.h
+++ b/include/uapi/linux/if_packet.h
@@ -108,7 +108,7 @@ struct tpacket_auxdata {
 
 /* Rx and Tx ring - header status */
 #define TP_STATUS_TS_SOFTWARE           (1 << 29)
-#define TP_STATUS_TS_SYS_HARDWARE       (1 << 30)
+#define TP_STATUS_TS_SYS_HARDWARE       (1 << 30) /* deprecated, never set */
 #define TP_STATUS_TS_RAW_HARDWARE       (1 << 31)
 
 /* Rx ring - feature request bits */
diff --git a/net/core/sock.c b/net/core/sock.c
index ca9b65199d28..134291d73fcd 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -862,8 +862,6 @@ set_rcvbuf:
                                                (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE));
                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_SOFTWARE,
                                   val & SOF_TIMESTAMPING_SOFTWARE);
-                sock_valbool_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE,
-                                  val & SOF_TIMESTAMPING_SYS_HARDWARE);
                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE,
                                   val & SOF_TIMESTAMPING_RAW_HARDWARE);
                 break;
@@ -1102,8 +1100,6 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
                         v.val |= SOF_TIMESTAMPING_RX_SOFTWARE;
                 if (sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE))
                         v.val |= SOF_TIMESTAMPING_SOFTWARE;
-                if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE))
-                        v.val |= SOF_TIMESTAMPING_SYS_HARDWARE;
                 if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE))
                         v.val |= SOF_TIMESTAMPING_RAW_HARDWARE;
                 break;
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index 614ca91f785a..8d9f8042705a 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -441,14 +441,10 @@ static __u32 tpacket_get_timestamp(struct sk_buff *skb, struct timespec *ts,
 {
         struct skb_shared_hwtstamps *shhwtstamps = skb_hwtstamps(skb);
 
-        if (shhwtstamps) {
-                if ((flags & SOF_TIMESTAMPING_SYS_HARDWARE) &&
-                    ktime_to_timespec_cond(shhwtstamps->syststamp, ts))
-                        return TP_STATUS_TS_SYS_HARDWARE;
-                if ((flags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
-                    ktime_to_timespec_cond(shhwtstamps->hwtstamp, ts))
-                        return TP_STATUS_TS_RAW_HARDWARE;
-        }
+        if (shhwtstamps &&
+            (flags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
+            ktime_to_timespec_cond(shhwtstamps->hwtstamp, ts))
+                return TP_STATUS_TS_RAW_HARDWARE;
 
         if (ktime_to_timespec_cond(skb->tstamp, ts))
                 return TP_STATUS_TS_SOFTWARE;
diff --git a/net/socket.c b/net/socket.c
index abf56b2a14f9..d8222c025061 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -725,14 +725,10 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
         if (sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE) &&
             ktime_to_timespec_cond(skb->tstamp, ts + 0))
                 empty = 0;
-        if (shhwtstamps) {
-                if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE) &&
-                    ktime_to_timespec_cond(shhwtstamps->syststamp, ts + 1))
-                        empty = 0;
-                if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE) &&
-                    ktime_to_timespec_cond(shhwtstamps->hwtstamp, ts + 2))
-                        empty = 0;
-        }
+        if (shhwtstamps &&
+            sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE) &&
+            ktime_to_timespec_cond(shhwtstamps->hwtstamp, ts + 2))
+                empty = 0;
         if (!empty)
                 put_cmsg(msg, SOL_SOCKET,
                          SCM_TIMESTAMPING, sizeof(ts), &ts);