Zephyr API Documentation 4.3.99
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
time_units.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2019 Intel Corporation
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7#ifndef ZEPHYR_INCLUDE_TIME_UNITS_H_
8#define ZEPHYR_INCLUDE_TIME_UNITS_H_
9
10#include <zephyr/toolchain.h>
11#include <zephyr/sys/util.h>
12
13#ifdef __cplusplus
14extern "C" {
15#endif
16
25
33#define SYS_FOREVER_MS (-1)
34
39#define SYS_FOREVER_US (-1)
40
44#define SYS_TIMEOUT_MS_INIT(ms) \
45 Z_TIMEOUT_TICKS_INIT((ms) == SYS_FOREVER_MS ? \
46 K_TICKS_FOREVER : Z_TIMEOUT_MS_TICKS(ms))
47
50#define SYS_TIMEOUT_MS(ms) ((k_timeout_t) SYS_TIMEOUT_MS_INIT(ms))
51
52/* Exhaustively enumerated, highly optimized time unit conversion API */
53
54#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME) || \
55 defined(CONFIG_SYSTEM_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_UPDATE)
63__syscall unsigned int sys_clock_hw_cycles_per_sec_runtime_get(void);
64
65static inline unsigned int z_impl_sys_clock_hw_cycles_per_sec_runtime_get(void)
66{
67 extern unsigned int z_clock_hw_cycles_per_sec;
68
69 return z_clock_hw_cycles_per_sec;
70}
71#endif /* CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME */
72
73#if defined(__cplusplus) && (__cplusplus >= 201402L)
74 #if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME) || \
75 defined(CONFIG_SYSTEM_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_UPDATE)
76 #define TIME_CONSTEXPR
77 #else
78 #define TIME_CONSTEXPR constexpr
79 #endif
80#else
81 #define TIME_CONSTEXPR
82#endif
83
88#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME) || \
89 defined(CONFIG_SYSTEM_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_UPDATE)
90#define sys_clock_hw_cycles_per_sec() sys_clock_hw_cycles_per_sec_runtime_get()
91#else
92#define sys_clock_hw_cycles_per_sec() (uint32_t)CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC
93#endif
94
106#define z_tmcvt_use_fast_algo(from_hz, to_hz) \
107 ((DIV_ROUND_UP(CONFIG_SYS_CLOCK_MAX_TIMEOUT_DAYS * 24ULL * 3600ULL * from_hz, \
108 UINT32_MAX) * to_hz) <= UINT32_MAX)
109
110/* Time converter generator gadget. Selects from one of three
111 * conversion algorithms: ones that take advantage when the
112 * frequencies are an integer ratio (in either direction), or a full
113 * precision conversion. Clever use of extra arguments causes all the
114 * selection logic to be optimized out, and the generated code even
115 * reduces to 32 bit only if a ratio conversion is available and the
116 * result is 32 bits.
117 *
118 * This isn't intended to be used directly, instead being wrapped
119 * appropriately in a user-facing API. The boolean arguments are:
120 *
121 * const_hz - The hz arguments are known to be compile-time
122 * constants (because otherwise the modulus test would
123 * have to be done at runtime)
124 * result32 - The result will be truncated to 32 bits on use
125 * round_up - Return the ceiling of the resulting fraction
126 * round_off - Return the nearest value to the resulting fraction
127 * (pass both round_up/off as false to get "round_down")
128 *
129 * All of this must be implemented as expressions so that, when constant,
130 * the results may be used to initialize global variables.
131 */
132
133/* true if the conversion is the identity */
134#define z_tmcvt_is_identity(__from_hz, __to_hz) \
135 ((__to_hz) == (__from_hz))
136
137/* true if the conversion requires a simple integer multiply */
138#define z_tmcvt_is_int_mul(__from_hz, __to_hz) \
139 ((__to_hz) > (__from_hz) && (__to_hz) % (__from_hz) == 0U)
140
141/* true if the conversion requires a simple integer division */
142#define z_tmcvt_is_int_div(__from_hz, __to_hz) \
143 ((__from_hz) > (__to_hz) && (__from_hz) % (__to_hz) == 0U)
144
145/*
146 * Compute the offset needed to round the result correctly when
147 * the conversion requires a simple integer division
148 */
149#define z_tmcvt_off_div(__from_hz, __to_hz, __round_up, __round_off) \
150 ((__round_off) ? ((__from_hz) / (__to_hz)) / 2 : \
151 (__round_up) ? ((__from_hz) / (__to_hz)) - 1 : \
152 0)
153
154/*
155 * All users of this macro MUST ensure its output is never used when a/b
156 * is zero because it incorrectly but by design never returns zero.
157 *
158 * Some compiler versions emit a divide-by-zero warning for this code:
159 * "false ? 42/0 : 43". Dealing with (generated) dead code is hard:
160 * https://github.com/zephyrproject-rtos/zephyr/issues/63564
161 * https://blog.llvm.org/2011/05/what-every-c-programmer-should-know_21.html
162 *
163 * To silence such divide-by-zero warnings, "cheat" and never return
164 * zero. Return 1 instead. Use octal "01u" as a breadcrumb to ease a
165 * little bit the huge pain of "reverse-engineering" pre-processor
166 * output.
167 *
168 * The "Elvis" operator "a/b ?: 1" is tempting because it avoids
169 * evaluating the same expression twice. However: 1. it's a non-standard
170 * GNU extension; 2. everything in this file is designed to be computed
171 * at compile time anyway.
172 */
173#define z_tmcvt_divisor(a, b) ((a)/(b) ? (a)/(b) : 01u)
174
175/*
176 * Compute the offset needed to round the result correctly when
177 * the conversion requires a full mul/div
178 */
179#define z_tmcvt_off_gen(__from_hz, __to_hz, __round_up, __round_off) \
180 ((__round_off) ? (__from_hz) / 2 : \
181 (__round_up) ? (__from_hz) - 1 : \
182 0)
183
184/* Integer division 32-bit conversion */
185#define z_tmcvt_int_div_32(__t, __from_hz, __to_hz, __round_up, __round_off) \
186 ((uint64_t) (__t) <= 0xffffffffU - \
187 z_tmcvt_off_div(__from_hz, __to_hz, __round_up, __round_off) ? \
188 ((uint32_t)(((__t) + \
189 z_tmcvt_off_div(__from_hz, __to_hz, \
190 __round_up, __round_off)) / \
191 z_tmcvt_divisor(__from_hz, __to_hz))) \
192 : \
193 (uint32_t) (((uint64_t) (__t) + \
194 z_tmcvt_off_div(__from_hz, __to_hz, \
195 __round_up, __round_off)) / \
196 z_tmcvt_divisor(__from_hz, __to_hz)) \
197 )
198
199/* Integer multiplication 32-bit conversion */
200#define z_tmcvt_int_mul_32(__t, __from_hz, __to_hz) \
201 ((uint32_t) ((__t)*((__to_hz) / (__from_hz))))
202
203/* General 32-bit conversion */
204#define z_tmcvt_gen_32(__t, __from_hz, __to_hz, __round_up, __round_off) \
205 ((uint32_t) (((uint64_t) (__t)*(__to_hz) + \
206 z_tmcvt_off_gen(__from_hz, __to_hz, __round_up, __round_off)) / (__from_hz)))
207
208/* Integer division 64-bit conversion */
209#define z_tmcvt_int_div_64(__t, __from_hz, __to_hz, __round_up, __round_off) \
210 (((uint64_t) (__t) + z_tmcvt_off_div(__from_hz, __to_hz, \
211 __round_up, __round_off)) / \
212 z_tmcvt_divisor(__from_hz, __to_hz))
213
214/* Integer multiplication 64-bit conversion */
215#define z_tmcvt_int_mul_64(__t, __from_hz, __to_hz) \
216 (uint64_t) (__t)*((__to_hz) / (__from_hz))
217
218/* Fast 64-bit conversion. This relies on the multiply not overflowing */
219#define z_tmcvt_gen_64_fast(__t, __from_hz, __to_hz, __round_up, __round_off) \
220 (((uint64_t) (__t)*(__to_hz) + \
221 z_tmcvt_off_gen(__from_hz, __to_hz, __round_up, __round_off)) / (__from_hz))
222
223/* Slow 64-bit conversion. This avoids overflowing the multiply */
224#define z_tmcvt_gen_64_slow(__t, __from_hz, __to_hz, __round_up, __round_off) \
225 ((((uint64_t) (__t) / (__from_hz))*(__to_hz)) + \
226 (((((uint64_t) (__t) % (__from_hz))*(__to_hz)) + \
227 z_tmcvt_off_gen(__from_hz, __to_hz, __round_up, __round_off)) / (__from_hz)))
228
229/* General 64-bit conversion. Uses one of the two above macros */
230#define z_tmcvt_gen_64(__t, __from_hz, __to_hz, __round_up, __round_off) \
231 (z_tmcvt_use_fast_algo(__from_hz, __to_hz) ? \
232 z_tmcvt_gen_64_fast(__t, __from_hz, __to_hz, __round_up, __round_off) : \
233 z_tmcvt_gen_64_slow(__t, __from_hz, __to_hz, __round_up, __round_off))
234
235/* Convert, generating a 32-bit result */
236#define z_tmcvt_32(__t, __from_hz, __to_hz, __const_hz, __round_up, __round_off) \
237 ((__const_hz) ? \
238 ( \
239 z_tmcvt_is_identity(__from_hz, __to_hz) ? \
240 (uint32_t) (__t) \
241 : \
242 z_tmcvt_is_int_div(__from_hz, __to_hz) ? \
243 z_tmcvt_int_div_32(__t, __from_hz, __to_hz, __round_up, __round_off) \
244 : \
245 z_tmcvt_is_int_mul(__from_hz, __to_hz) ? \
246 z_tmcvt_int_mul_32(__t, __from_hz, __to_hz) \
247 : \
248 z_tmcvt_gen_32(__t, __from_hz, __to_hz, __round_up, __round_off) \
249 ) \
250 : \
251 z_tmcvt_gen_32(__t, __from_hz, __to_hz, __round_up, __round_off) \
252 )
253
254/* Convert, generating a 64-bit result */
255#define z_tmcvt_64(__t, __from_hz, __to_hz, __const_hz, __round_up, __round_off) \
256 ((__const_hz) ? \
257 ( \
258 z_tmcvt_is_identity(__from_hz, __to_hz) ? \
259 (uint64_t) (__t) \
260 : \
261 z_tmcvt_is_int_div(__from_hz, __to_hz) ? \
262 z_tmcvt_int_div_64(__t, __from_hz, __to_hz, __round_up, __round_off) \
263 : \
264 z_tmcvt_is_int_mul(__from_hz, __to_hz) ? \
265 z_tmcvt_int_mul_64(__t, __from_hz, __to_hz) \
266 : \
267 z_tmcvt_gen_64(__t, __from_hz, __to_hz, __round_up, __round_off) \
268 ) \
269 : \
270 z_tmcvt_gen_64_slow(__t, __from_hz, __to_hz, __round_up, __round_off) \
271 )
272
273#define z_tmcvt(__t, __from_hz, __to_hz, __const_hz, __result32, __round_up, __round_off) \
274 ((__result32) ? \
275 z_tmcvt_32(__t, __from_hz, __to_hz, __const_hz, __round_up, __round_off) : \
276 z_tmcvt_64(__t, __from_hz, __to_hz, __const_hz, __round_up, __round_off))
277
278/* The following code is programmatically generated using this perl
279 * code, which enumerates all possible combinations of units, rounding
280 * modes and precision. Do not edit directly.
281 *
282 * Note that nano/microsecond conversions are only defined with 64 bit
283 * precision. These units conversions were not available in 32 bit
284 * variants historically, and doing 32 bit math with units that small
285 * has precision traps that we probably don't want to support in an
286 * official API.
287 *
288 * #!/usr/bin/perl -w
289 * use strict;
290 *
291 * my %human = ("sec" => "seconds",
292 * "ms" => "milliseconds",
293 * "us" => "microseconds",
294 * "ns" => "nanoseconds",
295 * "cyc" => "hardware cycles",
296 * "ticks" => "ticks");
297 * my %human_round = ("ceil" => "Rounds up",
298 * "near" => "Round nearest",
299 * "floor" => "Truncates");
300 *
301 * sub big { return $_[0] eq "us" || $_[0] eq "ns"; }
302 * sub prefix { return $_[0] eq "sec" || $_[0] eq "ms" || $_[0] eq "us" || $_[0] eq "ns"; }
303 *
304 * for my $from_unit ("sec", "ms", "us", "ns", "cyc", "ticks") {
305 * for my $to_unit ("sec", "ms", "us", "ns", "cyc", "ticks") {
306 * next if $from_unit eq $to_unit;
307 * next if prefix($from_unit) && prefix($to_unit);
308 * for my $round ("floor", "near", "ceil") {
309 * for(my $big=0; $big <= 1; $big++) {
310 * my $sz = $big ? 64 : 32;
311 * my $sym = "k_${from_unit}_to_${to_unit}_$round$sz";
312 * my $type = "uint${sz}_t";
313 * my $const_hz = ($from_unit eq "cyc" || $to_unit eq "cyc")
314 * ? "Z_CCYC" : "true";
315 * my $ret32 = $big ? "64" : "32";
316 * my $rup = $round eq "ceil" ? "true" : "false";
317 * my $roff = $round eq "near" ? "true" : "false";
318 *
319 * my $hfrom = $human{$from_unit};
320 * my $hto = $human{$to_unit};
321 * my $hround = $human_round{$round};
322 * print "/", "** \@brief Convert $hfrom to $hto. $ret32 bits. $hround.\n";
323 * print " *\n";
324 * print " * Converts time values in $hfrom to $hto.\n";
325 * print " * Computes result in $sz bit precision.\n";
326 * if ($round eq "ceil") {
327 * print " * Rounds up to the next highest output unit.\n";
328 * } elsif ($round eq "near") {
329 * print " * Rounds to the nearest output unit.\n";
330 * } else {
331 * print " * Truncates to the next lowest output unit.\n";
332 * }
333 * print " *\n";
334 * print " * \@warning Generated. Do not edit. See above.\n";
335 * print " *\n";
336 * print " * \@param t Source time in $hfrom. uint64_t\n";
337 * print " *\n";
338 * print " * \@return The converted time value in $hto. $type\n";
339 * print " *", "/\n";
340 * print "#define $sym(t) \\\n";
341 * print "\tz_tmcvt_$ret32(t, Z_HZ_$from_unit, Z_HZ_$to_unit,";
342 * print " $const_hz, $rup, $roff)\n";
343 * print "\n\n";
344 * }
345 * }
346 * }
347 * }
348 */
349
350/* Some more concise declarations to simplify the generator script and
351 * save bytes below
352 */
353#define Z_HZ_sec 1
354#define Z_HZ_ms 1000
355#define Z_HZ_us 1000000
356#define Z_HZ_ns 1000000000
357#define Z_HZ_cyc sys_clock_hw_cycles_per_sec()
358#define Z_HZ_ticks CONFIG_SYS_CLOCK_TICKS_PER_SEC
359#define Z_CCYC (!IS_ENABLED(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME) && \
360 !IS_ENABLED(CONFIG_SYSTEM_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_UPDATE))
361
374#define k_sec_to_cyc_floor32(t) \
375 z_tmcvt_32(t, Z_HZ_sec, Z_HZ_cyc, Z_CCYC, false, false)
376
377
390#define k_sec_to_cyc_floor64(t) \
391 z_tmcvt_64(t, Z_HZ_sec, Z_HZ_cyc, Z_CCYC, false, false)
392
393
406#define k_sec_to_cyc_near32(t) \
407 z_tmcvt_32(t, Z_HZ_sec, Z_HZ_cyc, Z_CCYC, false, true)
408
409
422#define k_sec_to_cyc_near64(t) \
423 z_tmcvt_64(t, Z_HZ_sec, Z_HZ_cyc, Z_CCYC, false, true)
424
425
438#define k_sec_to_cyc_ceil32(t) \
439 z_tmcvt_32(t, Z_HZ_sec, Z_HZ_cyc, Z_CCYC, true, false)
440
441
454#define k_sec_to_cyc_ceil64(t) \
455 z_tmcvt_64(t, Z_HZ_sec, Z_HZ_cyc, Z_CCYC, true, false)
456
457
470#define k_sec_to_ticks_floor32(t) \
471 z_tmcvt_32(t, Z_HZ_sec, Z_HZ_ticks, true, false, false)
472
473
486#define k_sec_to_ticks_floor64(t) \
487 z_tmcvt_64(t, Z_HZ_sec, Z_HZ_ticks, true, false, false)
488
489
502#define k_sec_to_ticks_near32(t) \
503 z_tmcvt_32(t, Z_HZ_sec, Z_HZ_ticks, true, false, true)
504
505
518#define k_sec_to_ticks_near64(t) \
519 z_tmcvt_64(t, Z_HZ_sec, Z_HZ_ticks, true, false, true)
520
521
534#define k_sec_to_ticks_ceil32(t) \
535 z_tmcvt_32(t, Z_HZ_sec, Z_HZ_ticks, true, true, false)
536
537
550#define k_sec_to_ticks_ceil64(t) \
551 z_tmcvt_64(t, Z_HZ_sec, Z_HZ_ticks, true, true, false)
552
553
566#define k_ms_to_cyc_floor32(t) \
567 z_tmcvt_32(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, false, false)
568
569
582#define k_ms_to_cyc_floor64(t) \
583 z_tmcvt_64(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, false, false)
584
585
598#define k_ms_to_cyc_near32(t) \
599 z_tmcvt_32(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, false, true)
600
601
614#define k_ms_to_cyc_near64(t) \
615 z_tmcvt_64(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, false, true)
616
617
630#define k_ms_to_cyc_ceil32(t) \
631 z_tmcvt_32(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, true, false)
632
633
646#define k_ms_to_cyc_ceil64(t) \
647 z_tmcvt_64(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, true, false)
648
649
662#define k_ms_to_ticks_floor32(t) \
663 z_tmcvt_32(t, Z_HZ_ms, Z_HZ_ticks, true, false, false)
664
665
678#define k_ms_to_ticks_floor64(t) \
679 z_tmcvt_64(t, Z_HZ_ms, Z_HZ_ticks, true, false, false)
680
681
694#define k_ms_to_ticks_near32(t) \
695 z_tmcvt_32(t, Z_HZ_ms, Z_HZ_ticks, true, false, true)
696
697
710#define k_ms_to_ticks_near64(t) \
711 z_tmcvt_64(t, Z_HZ_ms, Z_HZ_ticks, true, false, true)
712
713
726#define k_ms_to_ticks_ceil32(t) \
727 z_tmcvt_32(t, Z_HZ_ms, Z_HZ_ticks, true, true, false)
728
729
742#define k_ms_to_ticks_ceil64(t) \
743 z_tmcvt_64(t, Z_HZ_ms, Z_HZ_ticks, true, true, false)
744
745
758#define k_us_to_cyc_floor32(t) \
759 z_tmcvt_32(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, false, false)
760
761
774#define k_us_to_cyc_floor64(t) \
775 z_tmcvt_64(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, false, false)
776
777
790#define k_us_to_cyc_near32(t) \
791 z_tmcvt_32(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, false, true)
792
793
806#define k_us_to_cyc_near64(t) \
807 z_tmcvt_64(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, false, true)
808
809
822#define k_us_to_cyc_ceil32(t) \
823 z_tmcvt_32(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, true, false)
824
825
838#define k_us_to_cyc_ceil64(t) \
839 z_tmcvt_64(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, true, false)
840
841
854#define k_us_to_ticks_floor32(t) \
855 z_tmcvt_32(t, Z_HZ_us, Z_HZ_ticks, true, false, false)
856
857
870#define k_us_to_ticks_floor64(t) \
871 z_tmcvt_64(t, Z_HZ_us, Z_HZ_ticks, true, false, false)
872
873
886#define k_us_to_ticks_near32(t) \
887 z_tmcvt_32(t, Z_HZ_us, Z_HZ_ticks, true, false, true)
888
889
902#define k_us_to_ticks_near64(t) \
903 z_tmcvt_64(t, Z_HZ_us, Z_HZ_ticks, true, false, true)
904
905
918#define k_us_to_ticks_ceil32(t) \
919 z_tmcvt_32(t, Z_HZ_us, Z_HZ_ticks, true, true, false)
920
921
934#define k_us_to_ticks_ceil64(t) \
935 z_tmcvt_64(t, Z_HZ_us, Z_HZ_ticks, true, true, false)
936
937
950#define k_ns_to_cyc_floor32(t) \
951 z_tmcvt_32(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, false, false)
952
953
966#define k_ns_to_cyc_floor64(t) \
967 z_tmcvt_64(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, false, false)
968
969
982#define k_ns_to_cyc_near32(t) \
983 z_tmcvt_32(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, false, true)
984
985
998#define k_ns_to_cyc_near64(t) \
999 z_tmcvt_64(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, false, true)
1000
1001
1014#define k_ns_to_cyc_ceil32(t) \
1015 z_tmcvt_32(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, true, false)
1016
1017
1030#define k_ns_to_cyc_ceil64(t) \
1031 z_tmcvt_64(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, true, false)
1032
1033
1046#define k_ns_to_ticks_floor32(t) \
1047 z_tmcvt_32(t, Z_HZ_ns, Z_HZ_ticks, true, false, false)
1048
1049
1062#define k_ns_to_ticks_floor64(t) \
1063 z_tmcvt_64(t, Z_HZ_ns, Z_HZ_ticks, true, false, false)
1064
1065
1078#define k_ns_to_ticks_near32(t) \
1079 z_tmcvt_32(t, Z_HZ_ns, Z_HZ_ticks, true, false, true)
1080
1081
1094#define k_ns_to_ticks_near64(t) \
1095 z_tmcvt_64(t, Z_HZ_ns, Z_HZ_ticks, true, false, true)
1096
1097
1110#define k_ns_to_ticks_ceil32(t) \
1111 z_tmcvt_32(t, Z_HZ_ns, Z_HZ_ticks, true, true, false)
1112
1113
1126#define k_ns_to_ticks_ceil64(t) \
1127 z_tmcvt_64(t, Z_HZ_ns, Z_HZ_ticks, true, true, false)
1128
1129
1142#define k_cyc_to_sec_floor32(t) \
1143 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_sec, Z_CCYC, false, false)
1144
1145
1158#define k_cyc_to_sec_floor64(t) \
1159 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_sec, Z_CCYC, false, false)
1160
1161
1174#define k_cyc_to_sec_near32(t) \
1175 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_sec, Z_CCYC, false, true)
1176
1177
1190#define k_cyc_to_sec_near64(t) \
1191 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_sec, Z_CCYC, false, true)
1192
1193
1206#define k_cyc_to_sec_ceil32(t) \
1207 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_sec, Z_CCYC, true, false)
1208
1209
1222#define k_cyc_to_sec_ceil64(t) \
1223 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_sec, Z_CCYC, true, false)
1224
1225
1238#define k_cyc_to_ms_floor32(t) \
1239 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, false, false)
1240
1241
1254#define k_cyc_to_ms_floor64(t) \
1255 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, false, false)
1256
1257
1270#define k_cyc_to_ms_near32(t) \
1271 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, false, true)
1272
1273
1286#define k_cyc_to_ms_near64(t) \
1287 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, false, true)
1288
1289
1302#define k_cyc_to_ms_ceil32(t) \
1303 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, true, false)
1304
1305
1318#define k_cyc_to_ms_ceil64(t) \
1319 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, true, false)
1320
1321
1334#define k_cyc_to_us_floor32(t) \
1335 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, false, false)
1336
1337
1350#define k_cyc_to_us_floor64(t) \
1351 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, false, false)
1352
1353
1366#define k_cyc_to_us_near32(t) \
1367 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, false, true)
1368
1369
1382#define k_cyc_to_us_near64(t) \
1383 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, false, true)
1384
1385
1398#define k_cyc_to_us_ceil32(t) \
1399 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, true, false)
1400
1401
1414#define k_cyc_to_us_ceil64(t) \
1415 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, true, false)
1416
1417
1430#define k_cyc_to_ns_floor32(t) \
1431 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, false, false)
1432
1433
1446#define k_cyc_to_ns_floor64(t) \
1447 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, false, false)
1448
1449
1462#define k_cyc_to_ns_near32(t) \
1463 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, false, true)
1464
1465
1478#define k_cyc_to_ns_near64(t) \
1479 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, false, true)
1480
1481
1494#define k_cyc_to_ns_ceil32(t) \
1495 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, true, false)
1496
1497
1510#define k_cyc_to_ns_ceil64(t) \
1511 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, true, false)
1512
1513
1526#define k_cyc_to_ticks_floor32(t) \
1527 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, false, false)
1528
1529
1542#define k_cyc_to_ticks_floor64(t) \
1543 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, false, false)
1544
1545
1558#define k_cyc_to_ticks_near32(t) \
1559 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, false, true)
1560
1561
1574#define k_cyc_to_ticks_near64(t) \
1575 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, false, true)
1576
1577
1590#define k_cyc_to_ticks_ceil32(t) \
1591 z_tmcvt_32(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, true, false)
1592
1593
1606#define k_cyc_to_ticks_ceil64(t) \
1607 z_tmcvt_64(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, true, false)
1608
1609
1622#define k_ticks_to_sec_floor32(t) \
1623 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_sec, true, false, false)
1624
1625
1638#define k_ticks_to_sec_floor64(t) \
1639 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_sec, true, false, false)
1640
1641
1654#define k_ticks_to_sec_near32(t) \
1655 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_sec, true, false, true)
1656
1657
1670#define k_ticks_to_sec_near64(t) \
1671 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_sec, true, false, true)
1672
1673
1686#define k_ticks_to_sec_ceil32(t) \
1687 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_sec, true, true, false)
1688
1689
1702#define k_ticks_to_sec_ceil64(t) \
1703 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_sec, true, true, false)
1704
1705
1718#define k_ticks_to_ms_floor32(t) \
1719 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_ms, true, false, false)
1720
1721
1734#define k_ticks_to_ms_floor64(t) \
1735 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_ms, true, false, false)
1736
1737
1750#define k_ticks_to_ms_near32(t) \
1751 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_ms, true, false, true)
1752
1753
1766#define k_ticks_to_ms_near64(t) \
1767 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_ms, true, false, true)
1768
1769
1782#define k_ticks_to_ms_ceil32(t) \
1783 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_ms, true, true, false)
1784
1785
1798#define k_ticks_to_ms_ceil64(t) \
1799 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_ms, true, true, false)
1800
1801
1814#define k_ticks_to_us_floor32(t) \
1815 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_us, true, false, false)
1816
1817
1830#define k_ticks_to_us_floor64(t) \
1831 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_us, true, false, false)
1832
1833
1846#define k_ticks_to_us_near32(t) \
1847 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_us, true, false, true)
1848
1849
1862#define k_ticks_to_us_near64(t) \
1863 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_us, true, false, true)
1864
1865
1878#define k_ticks_to_us_ceil32(t) \
1879 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_us, true, true, false)
1880
1881
1894#define k_ticks_to_us_ceil64(t) \
1895 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_us, true, true, false)
1896
1897
1910#define k_ticks_to_ns_floor32(t) \
1911 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_ns, true, false, false)
1912
1913
1926#define k_ticks_to_ns_floor64(t) \
1927 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_ns, true, false, false)
1928
1929
1942#define k_ticks_to_ns_near32(t) \
1943 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_ns, true, false, true)
1944
1945
1958#define k_ticks_to_ns_near64(t) \
1959 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_ns, true, false, true)
1960
1961
1974#define k_ticks_to_ns_ceil32(t) \
1975 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_ns, true, true, false)
1976
1977
1990#define k_ticks_to_ns_ceil64(t) \
1991 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_ns, true, true, false)
1992
1993
2006#define k_ticks_to_cyc_floor32(t) \
2007 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, false, false)
2008
2009
2022#define k_ticks_to_cyc_floor64(t) \
2023 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, false, false)
2024
2025
2038#define k_ticks_to_cyc_near32(t) \
2039 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, false, true)
2040
2041
2054#define k_ticks_to_cyc_near64(t) \
2055 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, false, true)
2056
2057
2070#define k_ticks_to_cyc_ceil32(t) \
2071 z_tmcvt_32(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, true, false)
2072
2073
2086#define k_ticks_to_cyc_ceil64(t) \
2087 z_tmcvt_64(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, true, false)
2088
2089#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME) || \
2090 defined(CONFIG_SYSTEM_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_UPDATE)
2091#include <zephyr/syscalls/time_units.h>
2092#endif
2093
2094#undef TIME_CONSTEXPR
2095
2099
2100#ifdef __cplusplus
2101} /* extern "C" */
2102#endif
2103
2104#endif /* ZEPHYR_INCLUDE_TIME_UNITS_H_ */
util.h
Misc utilities.
toolchain.h
Macros to abstract toolchain specific capabilities.