Merge branch 'fortglx/4.4/time' of https://git.linaro.org/people/john.stultz/linux...

Time updates from John Stultz:

     - More 2038 work from Arnd Bergmann around ntp and pps

diff --git a/drivers/net/ethernet/sfc/ptp.c b/drivers/net/ethernet/sfc/ptp.c
index ad62615a93dcfe238fd23cf0487e5c6ea60330b7..c771e0af4e06d76028e7e8b85f36c09b9e19c149 100644 (file)
--- a/drivers/net/ethernet/sfc/ptp.c
+++ b/drivers/net/ethernet/sfc/ptp.c
@@ -401,8 +401,8 @@ size_t efx_ptp_update_stats(struct efx_nic *efx, u64 *stats)
 /* For Siena platforms NIC time is s and ns */
 static void efx_ptp_ns_to_s_ns(s64 ns, u32 *nic_major, u32 *nic_minor)
 {
-       struct timespec ts = ns_to_timespec(ns);
-       *nic_major = ts.tv_sec;
+       struct timespec64 ts = ns_to_timespec64(ns);
+       *nic_major = (u32)ts.tv_sec;
        *nic_minor = ts.tv_nsec;
 }
 
@@ -431,8 +431,8 @@ static ktime_t efx_ptp_s_ns_to_ktime_correction(u32 nic_major, u32 nic_minor,
  */
 static void efx_ptp_ns_to_s27(s64 ns, u32 *nic_major, u32 *nic_minor)
 {
-       struct timespec ts = ns_to_timespec(ns);
-       u32 maj = ts.tv_sec;
+       struct timespec64 ts = ns_to_timespec64(ns);
+       u32 maj = (u32)ts.tv_sec;
        u32 min = (u32)(((u64)ts.tv_nsec * NS_TO_S27_MULT +
                         (1ULL << (NS_TO_S27_SHIFT - 1))) >> NS_TO_S27_SHIFT);
 
@@ -646,28 +646,28 @@ static void efx_ptp_send_times(struct efx_nic *efx,
                               struct pps_event_time *last_time)
 {
        struct pps_event_time now;
-       struct timespec limit;
+       struct timespec64 limit;
        struct efx_ptp_data *ptp = efx->ptp_data;
-       struct timespec start;
+       struct timespec64 start;
        int *mc_running = ptp->start.addr;
 
        pps_get_ts(&now);
        start = now.ts_real;
        limit = now.ts_real;
-       timespec_add_ns(&limit, SYNCHRONISE_PERIOD_NS);
+       timespec64_add_ns(&limit, SYNCHRONISE_PERIOD_NS);
 
        /* Write host time for specified period or until MC is done */
-       while ((timespec_compare(&now.ts_real, &limit) < 0) &&
+       while ((timespec64_compare(&now.ts_real, &limit) < 0) &&
               ACCESS_ONCE(*mc_running)) {
-               struct timespec update_time;
+               struct timespec64 update_time;
                unsigned int host_time;
 
                /* Don't update continuously to avoid saturating the PCIe bus */
                update_time = now.ts_real;
-               timespec_add_ns(&update_time, SYNCHRONISATION_GRANULARITY_NS);
+               timespec64_add_ns(&update_time, SYNCHRONISATION_GRANULARITY_NS);
                do {
                        pps_get_ts(&now);
-               } while ((timespec_compare(&now.ts_real, &update_time) < 0) &&
+               } while ((timespec64_compare(&now.ts_real, &update_time) < 0) &&
                         ACCESS_ONCE(*mc_running));
 
                /* Synchronise NIC with single word of time only */
@@ -723,7 +723,7 @@ efx_ptp_process_times(struct efx_nic *efx, MCDI_DECLARE_STRUCT_PTR(synch_buf),
        struct efx_ptp_data *ptp = efx->ptp_data;
        u32 last_sec;
        u32 start_sec;
-       struct timespec delta;
+       struct timespec64 delta;
        ktime_t mc_time;
 
        if (number_readings == 0)
@@ -737,14 +737,14 @@ efx_ptp_process_times(struct efx_nic *efx, MCDI_DECLARE_STRUCT_PTR(synch_buf),
         */
        for (i = 0; i < number_readings; i++) {
                s32 window, corrected;
-               struct timespec wait;
+               struct timespec64 wait;
 
                efx_ptp_read_timeset(
                        MCDI_ARRAY_STRUCT_PTR(synch_buf,
                                              PTP_OUT_SYNCHRONIZE_TIMESET, i),
                        &ptp->timeset[i]);
 
-               wait = ktime_to_timespec(
+               wait = ktime_to_timespec64(
                        ptp->nic_to_kernel_time(0, ptp->timeset[i].wait, 0));
                window = ptp->timeset[i].window;
                corrected = window - wait.tv_nsec;
@@ -803,7 +803,7 @@ efx_ptp_process_times(struct efx_nic *efx, MCDI_DECLARE_STRUCT_PTR(synch_buf),
                                          ptp->timeset[last_good].minor, 0);
 
        /* Calculate delay from NIC top of second to last_time */
-       delta.tv_nsec += ktime_to_timespec(mc_time).tv_nsec;
+       delta.tv_nsec += ktime_to_timespec64(mc_time).tv_nsec;
 
        /* Set PPS timestamp to match NIC top of second */
        ptp->host_time_pps = *last_time;

diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
index cdad4d95b20eed060e6bc961da9bb27ab23865fb..805c749ac1ad035975a36c00231a83395e55e102 100644 (file)
--- a/drivers/pps/kapi.c
+++ b/drivers/pps/kapi.c
@@ -179,8 +179,8 @@ void pps_event(struct pps_device *pps, struct pps_event_time *ts, int event,
        /* check event type */
        BUG_ON((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0);
 
-       dev_dbg(pps->dev, "PPS event at %ld.%09ld\n",
-                       ts->ts_real.tv_sec, ts->ts_real.tv_nsec);
+       dev_dbg(pps->dev, "PPS event at %lld.%09ld\n",
+                       (s64)ts->ts_real.tv_sec, ts->ts_real.tv_nsec);
 
        timespec_to_pps_ktime(&ts_real, ts->ts_real);
 

diff --git a/include/linux/pps_kernel.h b/include/linux/pps_kernel.h
index 1d2cd21242e8a75c1ac6aeb191d9964d2f3388ea..54bf1484d41f0333cc860c84307d23eda76477e5 100644 (file)
--- a/include/linux/pps_kernel.h
+++ b/include/linux/pps_kernel.h
@@ -48,9 +48,9 @@ struct pps_source_info {
 
 struct pps_event_time {
 #ifdef CONFIG_NTP_PPS
-       struct timespec ts_raw;
+       struct timespec64 ts_raw;
 #endif /* CONFIG_NTP_PPS */
-       struct timespec ts_real;
+       struct timespec64 ts_real;
 };
 
 /* The main struct */
@@ -105,7 +105,7 @@ extern void pps_event(struct pps_device *pps,
 struct pps_device *pps_lookup_dev(void const *cookie);
 
 static inline void timespec_to_pps_ktime(struct pps_ktime *kt,
-               struct timespec ts)
+               struct timespec64 ts)
 {
        kt->sec = ts.tv_sec;
        kt->nsec = ts.tv_nsec;
@@ -115,24 +115,24 @@ static inline void timespec_to_pps_ktime(struct pps_ktime *kt,
 
 static inline void pps_get_ts(struct pps_event_time *ts)
 {
-       getnstime_raw_and_real(&ts->ts_raw, &ts->ts_real);
+       ktime_get_raw_and_real_ts64(&ts->ts_raw, &ts->ts_real);
 }
 
 #else /* CONFIG_NTP_PPS */
 
 static inline void pps_get_ts(struct pps_event_time *ts)
 {
-       getnstimeofday(&ts->ts_real);
+       ktime_get_real_ts64(&ts->ts_real);
 }
 
 #endif /* CONFIG_NTP_PPS */
 
 /* Subtract known time delay from PPS event time(s) */
-static inline void pps_sub_ts(struct pps_event_time *ts, struct timespec delta)
+static inline void pps_sub_ts(struct pps_event_time *ts, struct timespec64 delta)
 {
-       ts->ts_real = timespec_sub(ts->ts_real, delta);
+       ts->ts_real = timespec64_sub(ts->ts_real, delta);
 #ifdef CONFIG_NTP_PPS
-       ts->ts_raw = timespec_sub(ts->ts_raw, delta);
+       ts->ts_raw = timespec64_sub(ts->ts_raw, delta);
 #endif
 }
 

diff --git a/include/linux/timekeeping.h b/include/linux/timekeeping.h
index ba0ae09cbb21f2038c71104a435f6782f70c1668..ec89d846324cac714807f7c002339636c497e4d8 100644 (file)
--- a/include/linux/timekeeping.h
+++ b/include/linux/timekeeping.h
@@ -263,8 +263,8 @@ extern void timekeeping_inject_sleeptime64(struct timespec64 *delta);
 /*
  * PPS accessor
  */
-extern void getnstime_raw_and_real(struct timespec *ts_raw,
-                                  struct timespec *ts_real);
+extern void ktime_get_raw_and_real_ts64(struct timespec64 *ts_raw,
+                                       struct timespec64 *ts_real);
 
 /*
  * Persistent clock related interfaces

diff --git a/include/linux/timex.h b/include/linux/timex.h
index 9d3f1a5b6178a9dd1aa3914b35051b96f5ceb279..39c25dbebfe8043b71892840918a384b14bf6e70 100644 (file)
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -152,7 +152,7 @@ extern unsigned long tick_nsec;             /* SHIFTED_HZ period (nsec) */
 #define NTP_INTERVAL_LENGTH (NSEC_PER_SEC/NTP_INTERVAL_FREQ)
 
 extern int do_adjtimex(struct timex *);
-extern void hardpps(const struct timespec *, const struct timespec *);
+extern void hardpps(const struct timespec64 *, const struct timespec64 *);
 
 int read_current_timer(unsigned long *timer_val);
 void ntp_notify_cmos_timer(void);

diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index df68cb87524885dd561b615300137a68d7ecfbdb..149cc8086aea16bbd811d3af37e187fd08bb366f 100644 (file)
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -99,7 +99,7 @@ static time64_t                       ntp_next_leap_sec = TIME64_MAX;
 static int pps_valid;          /* signal watchdog counter */
 static long pps_tf[3];         /* phase median filter */
 static long pps_jitter;                /* current jitter (ns) */
-static struct timespec pps_fbase; /* beginning of the last freq interval */
+static struct timespec64 pps_fbase; /* beginning of the last freq interval */
 static int pps_shift;          /* current interval duration (s) (shift) */
 static int pps_intcnt;         /* interval counter */
 static s64 pps_freq;           /* frequency offset (scaled ns/s) */
@@ -509,7 +509,7 @@ static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
 static void sync_cmos_clock(struct work_struct *work)
 {
        struct timespec64 now;
-       struct timespec next;
+       struct timespec64 next;
        int fail = 1;
 
        /*
@@ -559,7 +559,7 @@ static void sync_cmos_clock(struct work_struct *work)
                next.tv_nsec -= NSEC_PER_SEC;
        }
        queue_delayed_work(system_power_efficient_wq,
-                          &sync_cmos_work, timespec_to_jiffies(&next));
+                          &sync_cmos_work, timespec64_to_jiffies(&next));
 }
 
 void ntp_notify_cmos_timer(void)
@@ -773,13 +773,13 @@ int __do_adjtimex(struct timex *txc, struct timespec64 *ts, s32 *time_tai)
  * pps_normtime.nsec has a range of ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ]
  * while timespec.tv_nsec has a range of [0, NSEC_PER_SEC) */
 struct pps_normtime {
-       __kernel_time_t sec;    /* seconds */
+       s64             sec;    /* seconds */
        long            nsec;   /* nanoseconds */
 };
 
 /* normalize the timestamp so that nsec is in the
    ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] interval */
-static inline struct pps_normtime pps_normalize_ts(struct timespec ts)
+static inline struct pps_normtime pps_normalize_ts(struct timespec64 ts)
 {
        struct pps_normtime norm = {
                .sec = ts.tv_sec,
@@ -861,7 +861,7 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
                pps_errcnt++;
                pps_dec_freq_interval();
                printk_deferred(KERN_ERR
-                       "hardpps: PPSERROR: interval too long - %ld s\n",
+                       "hardpps: PPSERROR: interval too long - %lld s\n",
                        freq_norm.sec);
                return 0;
        }
@@ -948,7 +948,7 @@ static void hardpps_update_phase(long error)
  * This code is based on David Mills's reference nanokernel
  * implementation. It was mostly rewritten but keeps the same idea.
  */
-void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
+void __hardpps(const struct timespec64 *phase_ts, const struct timespec64 *raw_ts)
 {
        struct pps_normtime pts_norm, freq_norm;
 
@@ -969,7 +969,7 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
        }
 
        /* ok, now we have a base for frequency calculation */
-       freq_norm = pps_normalize_ts(timespec_sub(*raw_ts, pps_fbase));
+       freq_norm = pps_normalize_ts(timespec64_sub(*raw_ts, pps_fbase));
 
        /* check that the signal is in the range
         * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */

diff --git a/kernel/time/ntp_internal.h b/kernel/time/ntp_internal.h
index 65430504ca2630c31d185429e6a2573c817b43ae..af924470eac04c046e3481750a32833cef9acc13 100644 (file)
--- a/kernel/time/ntp_internal.h
+++ b/kernel/time/ntp_internal.h
@@ -9,5 +9,5 @@ extern ktime_t ntp_get_next_leap(void);
 extern int second_overflow(unsigned long secs);
 extern int ntp_validate_timex(struct timex *);
 extern int __do_adjtimex(struct timex *, struct timespec64 *, s32 *);
-extern void __hardpps(const struct timespec *, const struct timespec *);
+extern void __hardpps(const struct timespec64 *, const struct timespec64 *);
 #endif /* _LINUX_NTP_INTERNAL_H */

diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 125f16a29cf6b54e7d7ec8e28580c65968a5466e..d50543101247103f9de5dc7ee8b477b1e056e36f 100644 (file)
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -849,7 +849,7 @@ EXPORT_SYMBOL_GPL(ktime_get_real_seconds);
 #ifdef CONFIG_NTP_PPS
 
 /**
- * getnstime_raw_and_real - get day and raw monotonic time in timespec format
+ * ktime_get_raw_and_real_ts64 - get day and raw monotonic time in timespec format
  * @ts_raw:    pointer to the timespec to be set to raw monotonic time
  * @ts_real:   pointer to the timespec to be set to the time of day
  *
@@ -857,7 +857,7 @@ EXPORT_SYMBOL_GPL(ktime_get_real_seconds);
  * same time atomically and stores the resulting timestamps in timespec
  * format.
  */
-void getnstime_raw_and_real(struct timespec *ts_raw, struct timespec *ts_real)
+void ktime_get_raw_and_real_ts64(struct timespec64 *ts_raw, struct timespec64 *ts_real)
 {
        struct timekeeper *tk = &tk_core.timekeeper;
        unsigned long seq;
@@ -868,7 +868,7 @@ void getnstime_raw_and_real(struct timespec *ts_raw, struct timespec *ts_real)
        do {
                seq = read_seqcount_begin(&tk_core.seq);
 
-               *ts_raw = timespec64_to_timespec(tk->raw_time);
+               *ts_raw = tk->raw_time;
                ts_real->tv_sec = tk->xtime_sec;
                ts_real->tv_nsec = 0;
 
@@ -877,10 +877,10 @@ void getnstime_raw_and_real(struct timespec *ts_raw, struct timespec *ts_real)
 
        } while (read_seqcount_retry(&tk_core.seq, seq));
 
-       timespec_add_ns(ts_raw, nsecs_raw);
-       timespec_add_ns(ts_real, nsecs_real);
+       timespec64_add_ns(ts_raw, nsecs_raw);
+       timespec64_add_ns(ts_real, nsecs_real);
 }
-EXPORT_SYMBOL(getnstime_raw_and_real);
+EXPORT_SYMBOL(ktime_get_raw_and_real_ts64);
 
 #endif /* CONFIG_NTP_PPS */
 
@@ -2025,7 +2025,7 @@ int do_adjtimex(struct timex *txc)
 /**
  * hardpps() - Accessor function to NTP __hardpps function
  */
-void hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
+void hardpps(const struct timespec64 *phase_ts, const struct timespec64 *raw_ts)
 {
        unsigned long flags;