Merge branch 'fortglx/4.15/time' of... (fb56d689) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/rtc/class.c

+3 −0

Original line number	Diff line number	Diff line
		@@ -161,6 +161,9 @@ static struct rtc_device *rtc_allocate_device(void)

		device_initialize(&rtc->dev);

		/* Drivers can revise this default after allocating the device. */
		rtc->set_offset_nsec = NSEC_PER_SEC / 2;

		rtc->irq_freq = 1;
		rtc->max_user_freq = 64;
		rtc->dev.class = rtc_class;

drivers/rtc/systohc.c

+38 −15

Original line number	Diff line number	Diff line
		@@ -10,6 +10,7 @@
		/**
		* rtc_set_ntp_time - Save NTP synchronized time to the RTC
		* @now: Current time of day
		* @target_nsec: pointer for desired now->tv_nsec value
		*
		* Replacement for the NTP platform function update_persistent_clock64
		* that stores time for later retrieval by rtc_hctosys.
		@@ -18,30 +19,52 @@
		* possible at all, and various other -errno for specific temporary failure
		* cases.
		*
		* -EPROTO is returned if now.tv_nsec is not close enough to *target_nsec.
		(
		* If temporary failure is indicated the caller should try again 'soon'
		*/
		int rtc_set_ntp_time(struct timespec64 now)
		int rtc_set_ntp_time(struct timespec64 now, unsigned long *target_nsec)
		{
		struct rtc_device *rtc;
		struct rtc_time tm;
		struct timespec64 to_set;
		int err = -ENODEV;

		if (now.tv_nsec < (NSEC_PER_SEC >> 1))
		rtc_time64_to_tm(now.tv_sec, &tm);
		else
		rtc_time64_to_tm(now.tv_sec + 1, &tm);
		bool ok;

		rtc = rtc_class_open(CONFIG_RTC_SYSTOHC_DEVICE);
		if (rtc) {
		/* rtc_hctosys exclusively uses UTC, so we call set_time here,
		* not set_mmss. */
		if (rtc->ops &&
		(rtc->ops->set_time \|\|
		rtc->ops->set_mmss64 \|\|
		rtc->ops->set_mmss))
		err = rtc_set_time(rtc, &tm);
		rtc_class_close(rtc);
		if (!rtc)
		goto out_err;

		if (!rtc->ops \|\| (!rtc->ops->set_time && !rtc->ops->set_mmss64 &&
		!rtc->ops->set_mmss))
		goto out_close;

		/* Compute the value of tv_nsec we require the caller to supply in
		* now.tv_nsec. This is the value such that (now +
		* set_offset_nsec).tv_nsec == 0.
		*/
		set_normalized_timespec64(&to_set, 0, -rtc->set_offset_nsec);
		*target_nsec = to_set.tv_nsec;

		/* The ntp code must call this with the correct value in tv_nsec, if
		* it does not we update target_nsec and return EPROTO to make the ntp
		* code try again later.
		*/
		ok = rtc_tv_nsec_ok(rtc->set_offset_nsec, &to_set, &now);
		if (!ok) {
		err = -EPROTO;
		goto out_close;
		}

		rtc_time64_to_tm(to_set.tv_sec, &tm);

		/* rtc_hctosys exclusively uses UTC, so we call set_time here, not
		* set_mmss.
		*/
		err = rtc_set_time(rtc, &tm);

		out_close:
		rtc_class_close(rtc);
		out_err:
		return err;
		}

include/linux/ktime.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -270,5 +270,6 @@ static inline ktime_t ms_to_ktime(u64 ms)
		}

		# include <linux/timekeeping.h>
		# include <linux/timekeeping32.h>

		#endif

include/linux/rtc.h

+42 −1

Original line number	Diff line number	Diff line
		@@ -135,6 +135,14 @@ struct rtc_device {
		/* Some hardware can't support UIE mode */
		int uie_unsupported;

		/* Number of nsec it takes to set the RTC clock. This influences when
		* the set ops are called. An offset:
		* - of 0.5 s will call RTC set for wall clock time 10.0 s at 9.5 s
		* - of 1.5 s will call RTC set for wall clock time 10.0 s at 8.5 s
		* - of -0.5 s will call RTC set for wall clock time 10.0 s at 10.5 s
		*/
		long set_offset_nsec;

		bool registered;

		struct nvmem_config *nvmem_config;
		@@ -172,7 +180,7 @@ extern void devm_rtc_device_unregister(struct device *dev,

		extern int rtc_read_time(struct rtc_device rtc, struct rtc_time tm);
		extern int rtc_set_time(struct rtc_device rtc, struct rtc_time tm);
		extern int rtc_set_ntp_time(struct timespec64 now);
		extern int rtc_set_ntp_time(struct timespec64 now, unsigned long *target_nsec);
		int __rtc_read_alarm(struct rtc_device rtc, struct rtc_wkalrm alarm);
		extern int rtc_read_alarm(struct rtc_device *rtc,
		struct rtc_wkalrm *alrm);
		@@ -221,6 +229,39 @@ static inline bool is_leap_year(unsigned int year)
		return (!(year % 4) && (year % 100)) \|\| !(year % 400);
		}

		/* Determine if we can call to driver to set the time. Drivers can only be
		* called to set a second aligned time value, and the field set_offset_nsec
		* specifies how far away from the second aligned time to call the driver.
		*
		* This also computes 'to_set' which is the time we are trying to set, and has
		* a zero in tv_nsecs, such that:
		* to_set - set_delay_nsec == now +/- FUZZ
		*
		*/
		static inline bool rtc_tv_nsec_ok(s64 set_offset_nsec,
		struct timespec64 *to_set,
		const struct timespec64 *now)
		{
		/* Allowed error in tv_nsec, arbitarily set to 5 jiffies in ns. */
		const unsigned long TIME_SET_NSEC_FUZZ = TICK_NSEC * 5;
		struct timespec64 delay = {.tv_sec = 0,
		.tv_nsec = set_offset_nsec};

		to_set = timespec64_add(now, delay);

		if (to_set->tv_nsec < TIME_SET_NSEC_FUZZ) {
		to_set->tv_nsec = 0;
		return true;
		}

		if (to_set->tv_nsec > NSEC_PER_SEC - TIME_SET_NSEC_FUZZ) {
		to_set->tv_sec++;
		to_set->tv_nsec = 0;
		return true;
		}
		return false;
		}

		#define rtc_register_device(device) \
		__rtc_register_device(THIS_MODULE, device)

include/linux/time.h

+1 −206

Original line number	Diff line number	Diff line
		@@ -17,149 +17,10 @@ int get_itimerspec64(struct itimerspec64 *it,
		int put_itimerspec64(const struct itimerspec64 *it,
		struct itimerspec __user *uit);

		#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)

		static inline int timespec_equal(const struct timespec *a,
		const struct timespec *b)
		{
		return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
		}

		/*
		* lhs < rhs: return <0
		* lhs == rhs: return 0
		* lhs > rhs: return >0
		*/
		static inline int timespec_compare(const struct timespec lhs, const struct timespec rhs)
		{
		if (lhs->tv_sec < rhs->tv_sec)
		return -1;
		if (lhs->tv_sec > rhs->tv_sec)
		return 1;
		return lhs->tv_nsec - rhs->tv_nsec;
		}

		static inline int timeval_compare(const struct timeval lhs, const struct timeval rhs)
		{
		if (lhs->tv_sec < rhs->tv_sec)
		return -1;
		if (lhs->tv_sec > rhs->tv_sec)
		return 1;
		return lhs->tv_usec - rhs->tv_usec;
		}

		extern time64_t mktime64(const unsigned int year, const unsigned int mon,
		const unsigned int day, const unsigned int hour,
		const unsigned int min, const unsigned int sec);

		/**
		* Deprecated. Use mktime64().
		*/
		static inline unsigned long mktime(const unsigned int year,
		const unsigned int mon, const unsigned int day,
		const unsigned int hour, const unsigned int min,
		const unsigned int sec)
		{
		return mktime64(year, mon, day, hour, min, sec);
		}

		extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);

		/*
		* timespec_add_safe assumes both values are positive and checks
		* for overflow. It will return TIME_T_MAX if the reutrn would be
		* smaller then either of the arguments.
		*/
		extern struct timespec timespec_add_safe(const struct timespec lhs,
		const struct timespec rhs);


		static inline struct timespec timespec_add(struct timespec lhs,
		struct timespec rhs)
		{
		struct timespec ts_delta;
		set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,
		lhs.tv_nsec + rhs.tv_nsec);
		return ts_delta;
		}

		/*
		* sub = lhs - rhs, in normalized form
		*/
		static inline struct timespec timespec_sub(struct timespec lhs,
		struct timespec rhs)
		{
		struct timespec ts_delta;
		set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
		lhs.tv_nsec - rhs.tv_nsec);
		return ts_delta;
		}

		/*
		* Returns true if the timespec is norm, false if denorm:
		*/
		static inline bool timespec_valid(const struct timespec *ts)
		{
		/* Dates before 1970 are bogus */
		if (ts->tv_sec < 0)
		return false;
		/* Can't have more nanoseconds then a second */
		if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
		return false;
		return true;
		}

		static inline bool timespec_valid_strict(const struct timespec *ts)
		{
		if (!timespec_valid(ts))
		return false;
		/* Disallow values that could overflow ktime_t */
		if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
		return false;
		return true;
		}

		static inline bool timeval_valid(const struct timeval *tv)
		{
		/* Dates before 1970 are bogus */
		if (tv->tv_sec < 0)
		return false;

		/* Can't have more microseconds then a second */
		if (tv->tv_usec < 0 \|\| tv->tv_usec >= USEC_PER_SEC)
		return false;

		return true;
		}

		extern struct timespec timespec_trunc(struct timespec t, unsigned gran);

		/*
		* Validates if a timespec/timeval used to inject a time offset is valid.
		* Offsets can be postive or negative. The value of the timeval/timespec
		* is the sum of its fields, but NOTE: the field tv_usec/tv_nsec must
		* always be non-negative.
		*/
		static inline bool timeval_inject_offset_valid(const struct timeval *tv)
		{
		/* We don't check the tv_sec as it can be positive or negative */

		/* Can't have more microseconds then a second */
		if (tv->tv_usec < 0 \|\| tv->tv_usec >= USEC_PER_SEC)
		return false;
		return true;
		}

		static inline bool timespec_inject_offset_valid(const struct timespec *ts)
		{
		/* We don't check the tv_sec as it can be positive or negative */

		/* Can't have more nanoseconds then a second */
		if (ts->tv_nsec < 0 \|\| ts->tv_nsec >= NSEC_PER_SEC)
		return false;
		return true;
		}

		/* Some architectures do not supply their own clocksource.
		* This is mainly the case in architectures that get their
		* inter-tick times by reading the counter on their interval
		@@ -208,73 +69,7 @@ struct tm {

		void time64_to_tm(time64_t totalsecs, int offset, struct tm *result);

		/**
		* time_to_tm - converts the calendar time to local broken-down time
		*
		* @totalsecs the number of seconds elapsed since 00:00:00 on January 1, 1970,
		* Coordinated Universal Time (UTC).
		* @offset offset seconds adding to totalsecs.
		* @result pointer to struct tm variable to receive broken-down time
		*/
		static inline void time_to_tm(time_t totalsecs, int offset, struct tm *result)
		{
		time64_to_tm(totalsecs, offset, result);
		}

		/**
		* timespec_to_ns - Convert timespec to nanoseconds
		* @ts: pointer to the timespec variable to be converted
		*
		* Returns the scalar nanosecond representation of the timespec
		* parameter.
		*/
		static inline s64 timespec_to_ns(const struct timespec *ts)
		{
		return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
		}

		/**
		* timeval_to_ns - Convert timeval to nanoseconds
		* @ts: pointer to the timeval variable to be converted
		*
		* Returns the scalar nanosecond representation of the timeval
		* parameter.
		*/
		static inline s64 timeval_to_ns(const struct timeval *tv)
		{
		return ((s64) tv->tv_sec * NSEC_PER_SEC) +
		tv->tv_usec * NSEC_PER_USEC;
		}

		/**
		* ns_to_timespec - Convert nanoseconds to timespec
		* @nsec: the nanoseconds value to be converted
		*
		* Returns the timespec representation of the nsec parameter.
		*/
		extern struct timespec ns_to_timespec(const s64 nsec);

		/**
		* ns_to_timeval - Convert nanoseconds to timeval
		* @nsec: the nanoseconds value to be converted
		*
		* Returns the timeval representation of the nsec parameter.
		*/
		extern struct timeval ns_to_timeval(const s64 nsec);

		/**
		* timespec_add_ns - Adds nanoseconds to a timespec
		* @a: pointer to timespec to be incremented
		* @ns: unsigned nanoseconds value to be added
		*
		* This must always be inlined because its used from the x86-64 vdso,
		* which cannot call other kernel functions.
		*/
		static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
		{
		a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
		a->tv_nsec = ns;
		}
		# include <linux/time32.h>

		static inline bool itimerspec64_valid(const struct itimerspec64 *its)
		{