~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/clocksource.h

Version: ~ [ linux-5.18 ] ~ [ linux-5.17.9 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.41 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.117 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.195 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.244 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.280 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.315 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0 */
  2 /*  linux/include/linux/clocksource.h
  3  *
  4  *  This file contains the structure definitions for clocksources.
  5  *
  6  *  If you are not a clocksource, or timekeeping code, you should
  7  *  not be including this file!
  8  */
  9 #ifndef _LINUX_CLOCKSOURCE_H
 10 #define _LINUX_CLOCKSOURCE_H
 11 
 12 #include <linux/types.h>
 13 #include <linux/timex.h>
 14 #include <linux/time.h>
 15 #include <linux/list.h>
 16 #include <linux/cache.h>
 17 #include <linux/timer.h>
 18 #include <linux/init.h>
 19 #include <linux/of.h>
 20 #include <asm/div64.h>
 21 #include <asm/io.h>
 22 
 23 struct clocksource;
 24 struct module;
 25 
 26 #if defined(CONFIG_ARCH_CLOCKSOURCE_DATA) || \
 27     defined(CONFIG_GENERIC_GETTIMEOFDAY)
 28 #include <asm/clocksource.h>
 29 #endif
 30 
 31 #include <vdso/clocksource.h>
 32 
 33 /**
 34  * struct clocksource - hardware abstraction for a free running counter
 35  *      Provides mostly state-free accessors to the underlying hardware.
 36  *      This is the structure used for system time.
 37  *
 38  * @read:               Returns a cycle value, passes clocksource as argument
 39  * @mask:               Bitmask for two's complement
 40  *                      subtraction of non 64 bit counters
 41  * @mult:               Cycle to nanosecond multiplier
 42  * @shift:              Cycle to nanosecond divisor (power of two)
 43  * @max_idle_ns:        Maximum idle time permitted by the clocksource (nsecs)
 44  * @maxadj:             Maximum adjustment value to mult (~11%)
 45  * @archdata:           Optional arch-specific data
 46  * @max_cycles:         Maximum safe cycle value which won't overflow on
 47  *                      multiplication
 48  * @name:               Pointer to clocksource name
 49  * @list:               List head for registration (internal)
 50  * @rating:             Rating value for selection (higher is better)
 51  *                      To avoid rating inflation the following
 52  *                      list should give you a guide as to how
 53  *                      to assign your clocksource a rating
 54  *                      1-99: Unfit for real use
 55  *                              Only available for bootup and testing purposes.
 56  *                      100-199: Base level usability.
 57  *                              Functional for real use, but not desired.
 58  *                      200-299: Good.
 59  *                              A correct and usable clocksource.
 60  *                      300-399: Desired.
 61  *                              A reasonably fast and accurate clocksource.
 62  *                      400-499: Perfect
 63  *                              The ideal clocksource. A must-use where
 64  *                              available.
 65  * @flags:              Flags describing special properties
 66  * @enable:             Optional function to enable the clocksource
 67  * @disable:            Optional function to disable the clocksource
 68  * @suspend:            Optional suspend function for the clocksource
 69  * @resume:             Optional resume function for the clocksource
 70  * @mark_unstable:      Optional function to inform the clocksource driver that
 71  *                      the watchdog marked the clocksource unstable
 72  * @tick_stable:        Optional function called periodically from the watchdog
 73  *                      code to provide stable syncrhonization points
 74  * @wd_list:            List head to enqueue into the watchdog list (internal)
 75  * @cs_last:            Last clocksource value for clocksource watchdog
 76  * @wd_last:            Last watchdog value corresponding to @cs_last
 77  * @owner:              Module reference, must be set by clocksource in modules
 78  *
 79  * Note: This struct is not used in hotpathes of the timekeeping code
 80  * because the timekeeper caches the hot path fields in its own data
 81  * structure, so no cache line alignment is required,
 82  *
 83  * The pointer to the clocksource itself is handed to the read
 84  * callback. If you need extra information there you can wrap struct
 85  * clocksource into your own struct. Depending on the amount of
 86  * information you need you should consider to cache line align that
 87  * structure.
 88  */
 89 struct clocksource {
 90         u64                     (*read)(struct clocksource *cs);
 91         u64                     mask;
 92         u32                     mult;
 93         u32                     shift;
 94         u64                     max_idle_ns;
 95         u32                     maxadj;
 96 #ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
 97         struct arch_clocksource_data archdata;
 98 #endif
 99         u64                     max_cycles;
100         const char              *name;
101         struct list_head        list;
102         int                     rating;
103         enum vdso_clock_mode    vdso_clock_mode;
104         unsigned long           flags;
105 
106         int                     (*enable)(struct clocksource *cs);
107         void                    (*disable)(struct clocksource *cs);
108         void                    (*suspend)(struct clocksource *cs);
109         void                    (*resume)(struct clocksource *cs);
110         void                    (*mark_unstable)(struct clocksource *cs);
111         void                    (*tick_stable)(struct clocksource *cs);
112 
113         /* private: */
114 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
115         /* Watchdog related data, used by the framework */
116         struct list_head        wd_list;
117         u64                     cs_last;
118         u64                     wd_last;
119 #endif
120         struct module           *owner;
121 };
122 
123 /*
124  * Clock source flags bits::
125  */
126 #define CLOCK_SOURCE_IS_CONTINUOUS              0x01
127 #define CLOCK_SOURCE_MUST_VERIFY                0x02
128 
129 #define CLOCK_SOURCE_WATCHDOG                   0x10
130 #define CLOCK_SOURCE_VALID_FOR_HRES             0x20
131 #define CLOCK_SOURCE_UNSTABLE                   0x40
132 #define CLOCK_SOURCE_SUSPEND_NONSTOP            0x80
133 #define CLOCK_SOURCE_RESELECT                   0x100
134 
135 /* simplify initialization of mask field */
136 #define CLOCKSOURCE_MASK(bits) GENMASK_ULL((bits) - 1, 0)
137 
138 static inline u32 clocksource_freq2mult(u32 freq, u32 shift_constant, u64 from)
139 {
140         /*  freq = cyc/from
141          *  mult/2^shift  = ns/cyc
142          *  mult = ns/cyc * 2^shift
143          *  mult = from/freq * 2^shift
144          *  mult = from * 2^shift / freq
145          *  mult = (from<<shift) / freq
146          */
147         u64 tmp = ((u64)from) << shift_constant;
148 
149         tmp += freq/2; /* round for do_div */
150         do_div(tmp, freq);
151 
152         return (u32)tmp;
153 }
154 
155 /**
156  * clocksource_khz2mult - calculates mult from khz and shift
157  * @khz:                Clocksource frequency in KHz
158  * @shift_constant:     Clocksource shift factor
159  *
160  * Helper functions that converts a khz counter frequency to a timsource
161  * multiplier, given the clocksource shift value
162  */
163 static inline u32 clocksource_khz2mult(u32 khz, u32 shift_constant)
164 {
165         return clocksource_freq2mult(khz, shift_constant, NSEC_PER_MSEC);
166 }
167 
168 /**
169  * clocksource_hz2mult - calculates mult from hz and shift
170  * @hz:                 Clocksource frequency in Hz
171  * @shift_constant:     Clocksource shift factor
172  *
173  * Helper functions that converts a hz counter
174  * frequency to a timsource multiplier, given the
175  * clocksource shift value
176  */
177 static inline u32 clocksource_hz2mult(u32 hz, u32 shift_constant)
178 {
179         return clocksource_freq2mult(hz, shift_constant, NSEC_PER_SEC);
180 }
181 
182 /**
183  * clocksource_cyc2ns - converts clocksource cycles to nanoseconds
184  * @cycles:     cycles
185  * @mult:       cycle to nanosecond multiplier
186  * @shift:      cycle to nanosecond divisor (power of two)
187  *
188  * Converts clocksource cycles to nanoseconds, using the given @mult and @shift.
189  * The code is optimized for performance and is not intended to work
190  * with absolute clocksource cycles (as those will easily overflow),
191  * but is only intended to be used with relative (delta) clocksource cycles.
192  *
193  * XXX - This could use some mult_lxl_ll() asm optimization
194  */
195 static inline s64 clocksource_cyc2ns(u64 cycles, u32 mult, u32 shift)
196 {
197         return ((u64) cycles * mult) >> shift;
198 }
199 
200 
201 extern int clocksource_unregister(struct clocksource*);
202 extern void clocksource_touch_watchdog(void);
203 extern void clocksource_change_rating(struct clocksource *cs, int rating);
204 extern void clocksource_suspend(void);
205 extern void clocksource_resume(void);
206 extern struct clocksource * __init clocksource_default_clock(void);
207 extern void clocksource_mark_unstable(struct clocksource *cs);
208 extern void
209 clocksource_start_suspend_timing(struct clocksource *cs, u64 start_cycles);
210 extern u64 clocksource_stop_suspend_timing(struct clocksource *cs, u64 now);
211 
212 extern u64
213 clocks_calc_max_nsecs(u32 mult, u32 shift, u32 maxadj, u64 mask, u64 *max_cycles);
214 extern void
215 clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 minsec);
216 
217 /*
218  * Don't call __clocksource_register_scale directly, use
219  * clocksource_register_hz/khz
220  */
221 extern int
222 __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq);
223 extern void
224 __clocksource_update_freq_scale(struct clocksource *cs, u32 scale, u32 freq);
225 
226 /*
227  * Don't call this unless you are a default clocksource
228  * (AKA: jiffies) and absolutely have to.
229  */
230 static inline int __clocksource_register(struct clocksource *cs)
231 {
232         return __clocksource_register_scale(cs, 1, 0);
233 }
234 
235 static inline int clocksource_register_hz(struct clocksource *cs, u32 hz)
236 {
237         return __clocksource_register_scale(cs, 1, hz);
238 }
239 
240 static inline int clocksource_register_khz(struct clocksource *cs, u32 khz)
241 {
242         return __clocksource_register_scale(cs, 1000, khz);
243 }
244 
245 static inline void __clocksource_update_freq_hz(struct clocksource *cs, u32 hz)
246 {
247         __clocksource_update_freq_scale(cs, 1, hz);
248 }
249 
250 static inline void __clocksource_update_freq_khz(struct clocksource *cs, u32 khz)
251 {
252         __clocksource_update_freq_scale(cs, 1000, khz);
253 }
254 
255 #ifdef CONFIG_ARCH_CLOCKSOURCE_INIT
256 extern void clocksource_arch_init(struct clocksource *cs);
257 #else
258 static inline void clocksource_arch_init(struct clocksource *cs) { }
259 #endif
260 
261 extern int timekeeping_notify(struct clocksource *clock);
262 
263 extern u64 clocksource_mmio_readl_up(struct clocksource *);
264 extern u64 clocksource_mmio_readl_down(struct clocksource *);
265 extern u64 clocksource_mmio_readw_up(struct clocksource *);
266 extern u64 clocksource_mmio_readw_down(struct clocksource *);
267 
268 extern int clocksource_mmio_init(void __iomem *, const char *,
269         unsigned long, int, unsigned, u64 (*)(struct clocksource *));
270 
271 extern int clocksource_i8253_init(void);
272 
273 #define TIMER_OF_DECLARE(name, compat, fn) \
274         OF_DECLARE_1_RET(timer, name, compat, fn)
275 
276 #ifdef CONFIG_TIMER_PROBE
277 extern void timer_probe(void);
278 #else
279 static inline void timer_probe(void) {}
280 #endif
281 
282 #define TIMER_ACPI_DECLARE(name, table_id, fn)          \
283         ACPI_DECLARE_PROBE_ENTRY(timer, name, table_id, 0, NULL, 0, fn)
284 
285 #endif /* _LINUX_CLOCKSOURCE_H */
286 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp