Merge branch 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull timer updates from Thomas Gleixner:
 "The timer department delivers this time:

   - Support for cross clock domain timestamps in the core code plus a
     first user.  That allows more precise timestamping for PTP and
     later for audio and other peripherals.

     The ptp/e1000e patches have been acked by the relevant maintainers
     and are carried in the timer tree to avoid merge ordering issues.

   - Support for unregistering the current clocksource watchdog.  That
     lifts a limitation for switching clocksources which has been there
     from day 1

   - The usual pile of fixes and updates to the core and the drivers.
     Nothing outstanding and exciting"

* 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (26 commits)
  time/timekeeping: Work around false positive GCC warning
  e1000e: Adds hardware supported cross timestamp on e1000e nic
  ptp: Add PTP_SYS_OFFSET_PRECISE for driver crosstimestamping
  x86/tsc: Always Running Timer (ART) correlated clocksource
  hrtimer: Revert CLOCK_MONOTONIC_RAW support
  time: Add history to cross timestamp interface supporting slower devices
  time: Add driver cross timestamp interface for higher precision time synchronization
  time: Remove duplicated code in ktime_get_raw_and_real()
  time: Add timekeeping snapshot code capturing system time and counter
  time: Add cycles to nanoseconds translation
  jiffies: Use CLOCKSOURCE_MASK instead of constant
  clocksource: Introduce clocksource_freq2mult()
  clockevents/drivers/exynos_mct: Implement ->set_state_oneshot_stopped()
  clockevents/drivers/arm_global_timer: Implement ->set_state_oneshot_stopped()
  clockevents/drivers/arm_arch_timer: Implement ->set_state_oneshot_stopped()
  clocksource/drivers/arm_global_timer: Register delay timer
  clocksource/drivers/lpc32xx: Support timer-based ARM delay
  clocksource/drivers/lpc32xx: Support periodic mode
  clocksource/drivers/lpc32xx: Don't use the prescaler counter for clockevents
  clocksource/drivers/rockchip: Add err handle for rk_timer_init
  ...

1 files changed, 27 insertions, 0 deletions

diff --git a/drivers/ptp/ptp_chardev.c b/drivers/ptp/ptp_chardev.c
index da7bae991552..579fd65299a0 100644
--- a/drivers/ptp/ptp_chardev.c
+++ b/drivers/ptp/ptp_chardev.c
@@ -22,6 +22,7 @@
 #include <linux/poll.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/timekeeping.h>
 
 #include "ptp_private.h"
 
@@ -120,11 +121,13 @@ long ptp_ioctl(struct posix_clock *pc, unsigned int cmd, unsigned long arg)
         struct ptp_clock_caps caps;
         struct ptp_clock_request req;
         struct ptp_sys_offset *sysoff = NULL;
+        struct ptp_sys_offset_precise precise_offset;
         struct ptp_pin_desc pd;
         struct ptp_clock *ptp = container_of(pc, struct ptp_clock, clock);
         struct ptp_clock_info *ops = ptp->info;
         struct ptp_clock_time *pct;
         struct timespec64 ts;
+        struct system_device_crosststamp xtstamp;
         int enable, err = 0;
         unsigned int i, pin_index;
 
@@ -138,6 +141,7 @@ long ptp_ioctl(struct posix_clock *pc, unsigned int cmd, unsigned long arg)
                 caps.n_per_out = ptp->info->n_per_out;
                 caps.pps = ptp->info->pps;
                 caps.n_pins = ptp->info->n_pins;
+                caps.cross_timestamping = ptp->info->getcrosststamp != NULL;
                 if (copy_to_user((void __user *)arg, &caps, sizeof(caps)))
                         err = -EFAULT;
                 break;
@@ -180,6 +184,29 @@ long ptp_ioctl(struct posix_clock *pc, unsigned int cmd, unsigned long arg)
                 err = ops->enable(ops, &req, enable);
                 break;
 
+        case PTP_SYS_OFFSET_PRECISE:
+                if (!ptp->info->getcrosststamp) {
+                        err = -EOPNOTSUPP;
+                        break;
+                }
+                err = ptp->info->getcrosststamp(ptp->info, &xtstamp);
+                if (err)
+                        break;
+
+                ts = ktime_to_timespec64(xtstamp.device);
+                precise_offset.device.sec = ts.tv_sec;
+                precise_offset.device.nsec = ts.tv_nsec;
+                ts = ktime_to_timespec64(xtstamp.sys_realtime);
+                precise_offset.sys_realtime.sec = ts.tv_sec;
+                precise_offset.sys_realtime.nsec = ts.tv_nsec;
+                ts = ktime_to_timespec64(xtstamp.sys_monoraw);
+                precise_offset.sys_monoraw.sec = ts.tv_sec;
+                precise_offset.sys_monoraw.nsec = ts.tv_nsec;
+                if (copy_to_user((void __user *)arg, &precise_offset,
+                                 sizeof(precise_offset)))
+                        err = -EFAULT;
+                break;
+
         case PTP_SYS_OFFSET:
                 sysoff = kmalloc(sizeof(*sysoff), GFP_KERNEL);
                 if (!sysoff) {