Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0+
       2                 :            : /*
       3                 :            :  * Based on clocksource code. See commit 74d23cc704d1
       4                 :            :  */
       5                 :            : #include <linux/export.h>
       6                 :            : #include <linux/timecounter.h>
       7                 :            : 
       8                 :          3 : void timecounter_init(struct timecounter *tc,
       9                 :            :                       const struct cyclecounter *cc,
      10                 :            :                       u64 start_tstamp)
      11                 :            : {
      12                 :          3 :         tc->cc = cc;
      13                 :          3 :         tc->cycle_last = cc->read(cc);
      14                 :          3 :         tc->nsec = start_tstamp;
      15                 :          3 :         tc->mask = (1ULL << cc->shift) - 1;
      16                 :          3 :         tc->frac = 0;
      17                 :          3 : }
      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                 :          0 : static u64 timecounter_read_delta(struct timecounter *tc)
      32                 :            : {
      33                 :            :         u64 cycle_now, cycle_delta;
      34                 :            :         u64 ns_offset;
      35                 :            : 
      36                 :            :         /* read cycle counter: */
      37                 :          0 :         cycle_now = tc->cc->read(tc->cc);
      38                 :            : 
      39                 :            :         /* calculate the delta since the last timecounter_read_delta(): */
      40                 :          0 :         cycle_delta = (cycle_now - tc->cycle_last) & tc->cc->mask;
      41                 :            : 
      42                 :            :         /* convert to nanoseconds: */
      43                 :          0 :         ns_offset = cyclecounter_cyc2ns(tc->cc, cycle_delta,
      44                 :            :                                         tc->mask, &tc->frac);
      45                 :            : 
      46                 :            :         /* update time stamp of timecounter_read_delta() call: */
      47                 :          0 :         tc->cycle_last = cycle_now;
      48                 :            : 
      49                 :          0 :         return ns_offset;
      50                 :            : }
      51                 :            : 
      52                 :          0 : u64 timecounter_read(struct timecounter *tc)
      53                 :            : {
      54                 :            :         u64 nsec;
      55                 :            : 
      56                 :            :         /* increment time by nanoseconds since last call */
      57                 :          0 :         nsec = timecounter_read_delta(tc);
      58                 :          0 :         nsec += tc->nsec;
      59                 :          0 :         tc->nsec = nsec;
      60                 :            : 
      61                 :          0 :         return nsec;
      62                 :            : }
      63                 :            : EXPORT_SYMBOL_GPL(timecounter_read);
      64                 :            : 
      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,
      70                 :            :                                u64 cycles, u64 mask, u64 frac)
      71                 :            : {
      72                 :            :         u64 ns = (u64) cycles;
      73                 :            : 
      74                 :          0 :         ns = ((ns * cc->mult) - frac) >> cc->shift;
      75                 :            : 
      76                 :            :         return ns;
      77                 :            : }
      78                 :            : 
      79                 :          0 : u64 timecounter_cyc2time(struct timecounter *tc,
      80                 :            :                          u64 cycle_tstamp)
      81                 :            : {
      82                 :          0 :         u64 delta = (cycle_tstamp - tc->cycle_last) & tc->cc->mask;
      83                 :          0 :         u64 nsec = tc->nsec, frac = tc->frac;
      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                 :            :          */
      90                 :          0 :         if (delta > tc->cc->mask / 2) {
      91                 :          0 :                 delta = (tc->cycle_last - cycle_tstamp) & tc->cc->mask;
      92                 :          0 :                 nsec -= cc_cyc2ns_backwards(tc->cc, delta, tc->mask, frac);
      93                 :            :         } else {
      94                 :          0 :                 nsec += cyclecounter_cyc2ns(tc->cc, delta, tc->mask, &frac);
      95                 :            :         }
      96                 :            : 
      97                 :          0 :         return nsec;
      98                 :            : }
      99                 :            : EXPORT_SYMBOL_GPL(timecounter_cyc2time);