// SPDX-License-Identifier: GPL-2.0+/* * Based on clocksource code. See commit 74d23cc704d1 */#include <linux/export.h>#include <linux/timecounter.h> void timecounter_init(struct timecounter *tc,		      const struct cyclecounter *cc,		      u64 start_tstamp){	tc->cc = cc;	tc->cycle_last = cc->read(cc);	tc->nsec = start_tstamp;	tc->mask = (1ULL << cc->shift) - 1;	tc->frac = 0;}EXPORT_SYMBOL_GPL(timecounter_init); /** * timecounter_read_delta - get nanoseconds since last call of this function * @tc:         Pointer to time counter * * When the underlying cycle counter runs over, this will be handled * correctly as long as it does not run over more than once between * calls. * * The first call to this function for a new time counter initializes * the time tracking and returns an undefined result. */static u64 timecounter_read_delta(struct timecounter *tc){	u64 cycle_now, cycle_delta;	u64 ns_offset; 	/* read cycle counter: */	cycle_now = tc->cc->read(tc->cc); 	/* calculate the delta since the last timecounter_read_delta(): */	cycle_delta = (cycle_now - tc->cycle_last) & tc->cc->mask; 	/* convert to nanoseconds: */	ns_offset = cyclecounter_cyc2ns(tc->cc, cycle_delta,					tc->mask, &tc->frac); 	/* update time stamp of timecounter_read_delta() call: */	tc->cycle_last = cycle_now; 	return ns_offset;} u64 timecounter_read(struct timecounter *tc){	u64 nsec; 	/* increment time by nanoseconds since last call */	nsec = timecounter_read_delta(tc);	nsec += tc->nsec;	tc->nsec = nsec; 	return nsec;}EXPORT_SYMBOL_GPL(timecounter_read); /* * This is like cyclecounter_cyc2ns(), but it is used for computing a * time previous to the time stored in the cycle counter. */static u64 cc_cyc2ns_backwards(const struct cyclecounter *cc,			       u64 cycles, u64 mask, u64 frac){	u64 ns = (u64) cycles; 	ns = ((ns * cc->mult) - frac) >> cc->shift; 	return ns;} u64 timecounter_cyc2time(const struct timecounter *tc,			 u64 cycle_tstamp){	u64 delta = (cycle_tstamp - tc->cycle_last) & tc->cc->mask;	u64 nsec = tc->nsec, frac = tc->frac; 	/*	 * Instead of always treating cycle_tstamp as more recent	 * than tc->cycle_last, detect when it is too far in the	 * future and treat it as old time stamp instead.	 */	if (delta > tc->cc->mask / 2) {		delta = (tc->cycle_last - cycle_tstamp) & tc->cc->mask;		nsec -= cc_cyc2ns_backwards(tc->cc, delta, tc->mask, frac);	} else {		nsec += cyclecounter_cyc2ns(tc->cc, delta, tc->mask, &frac);	} 	return nsec;}EXPORT_SYMBOL_GPL(timecounter_cyc2time);