]>
Commit | Line | Data |
---|---|---|
35728b82 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
74d23cc7 | 2 | /* |
58c5fc2b | 3 | * Based on clocksource code. See commit 74d23cc704d1 |
74d23cc7 | 4 | */ |
74d23cc7 RC |
5 | #include <linux/export.h> |
6 | #include <linux/timecounter.h> | |
7 | ||
8 | void timecounter_init(struct timecounter *tc, | |
9 | const struct cyclecounter *cc, | |
10 | u64 start_tstamp) | |
11 | { | |
12 | tc->cc = cc; | |
13 | tc->cycle_last = cc->read(cc); | |
14 | tc->nsec = start_tstamp; | |
2eebdde6 RC |
15 | tc->mask = (1ULL << cc->shift) - 1; |
16 | tc->frac = 0; | |
74d23cc7 RC |
17 | } |
18 | EXPORT_SYMBOL_GPL(timecounter_init); | |
19 | ||
20 | /** | |
21 | * timecounter_read_delta - get nanoseconds since last call of this function | |
22 | * @tc: Pointer to time counter | |
23 | * | |
24 | * When the underlying cycle counter runs over, this will be handled | |
25 | * correctly as long as it does not run over more than once between | |
26 | * calls. | |
27 | * | |
28 | * The first call to this function for a new time counter initializes | |
29 | * the time tracking and returns an undefined result. | |
30 | */ | |
31 | static u64 timecounter_read_delta(struct timecounter *tc) | |
32 | { | |
a5a1d1c2 | 33 | u64 cycle_now, cycle_delta; |
74d23cc7 RC |
34 | u64 ns_offset; |
35 | ||
36 | /* read cycle counter: */ | |
37 | cycle_now = tc->cc->read(tc->cc); | |
38 | ||
39 | /* calculate the delta since the last timecounter_read_delta(): */ | |
40 | cycle_delta = (cycle_now - tc->cycle_last) & tc->cc->mask; | |
41 | ||
42 | /* convert to nanoseconds: */ | |
2eebdde6 RC |
43 | ns_offset = cyclecounter_cyc2ns(tc->cc, cycle_delta, |
44 | tc->mask, &tc->frac); | |
74d23cc7 RC |
45 | |
46 | /* update time stamp of timecounter_read_delta() call: */ | |
47 | tc->cycle_last = cycle_now; | |
48 | ||
49 | return ns_offset; | |
50 | } | |
51 | ||
52 | u64 timecounter_read(struct timecounter *tc) | |
53 | { | |
54 | u64 nsec; | |
55 | ||
56 | /* increment time by nanoseconds since last call */ | |
57 | nsec = timecounter_read_delta(tc); | |
58 | nsec += tc->nsec; | |
59 | tc->nsec = nsec; | |
60 | ||
61 | return nsec; | |
62 | } | |
63 | EXPORT_SYMBOL_GPL(timecounter_read); | |
64 | ||
2eebdde6 RC |
65 | /* |
66 | * This is like cyclecounter_cyc2ns(), but it is used for computing a | |
67 | * time previous to the time stored in the cycle counter. | |
68 | */ | |
69 | static u64 cc_cyc2ns_backwards(const struct cyclecounter *cc, | |
a5a1d1c2 | 70 | u64 cycles, u64 mask, u64 frac) |
2eebdde6 RC |
71 | { |
72 | u64 ns = (u64) cycles; | |
73 | ||
74 | ns = ((ns * cc->mult) - frac) >> cc->shift; | |
75 | ||
76 | return ns; | |
77 | } | |
78 | ||
07ff4aed | 79 | u64 timecounter_cyc2time(const struct timecounter *tc, |
a5a1d1c2 | 80 | u64 cycle_tstamp) |
74d23cc7 | 81 | { |
2eebdde6 RC |
82 | u64 delta = (cycle_tstamp - tc->cycle_last) & tc->cc->mask; |
83 | u64 nsec = tc->nsec, frac = tc->frac; | |
74d23cc7 RC |
84 | |
85 | /* | |
86 | * Instead of always treating cycle_tstamp as more recent | |
87 | * than tc->cycle_last, detect when it is too far in the | |
88 | * future and treat it as old time stamp instead. | |
89 | */ | |
2eebdde6 RC |
90 | if (delta > tc->cc->mask / 2) { |
91 | delta = (tc->cycle_last - cycle_tstamp) & tc->cc->mask; | |
92 | nsec -= cc_cyc2ns_backwards(tc->cc, delta, tc->mask, frac); | |
74d23cc7 | 93 | } else { |
2eebdde6 | 94 | nsec += cyclecounter_cyc2ns(tc->cc, delta, tc->mask, &frac); |
74d23cc7 RC |
95 | } |
96 | ||
97 | return nsec; | |
98 | } | |
99 | EXPORT_SYMBOL_GPL(timecounter_cyc2time); |