mirror of
https://github.com/zephyrproject-rtos/zephyr
synced 2025-08-17 01:16:00 +00:00
83b9f69755
Both operands of an operator in the arithmetic conversions performed shall have the same essential type category. Changes are related to converting the integer constants to the unsigned integer constants Signed-off-by: Aastha Grover <aastha.grover@intel.com>
1393 lines
41 KiB
C
1393 lines
41 KiB
C
/*
|
|
* Copyright (c) 2019 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#ifndef ZEPHYR_INCLUDE_TIME_UNITS_H_
|
|
#define ZEPHYR_INCLUDE_TIME_UNITS_H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/** @brief System-wide macro to denote "forever" in milliseconds
|
|
*
|
|
* Usage of this macro is limited to APIs that want to expose a timeout value
|
|
* that can optionally be unlimited, or "forever".
|
|
* This macro can not be fed into kernel functions or macros directly. Use
|
|
* @ref SYS_TIMEOUT_MS instead.
|
|
*/
|
|
#define SYS_FOREVER_MS (-1)
|
|
|
|
/** @brief System-wide macro to convert milliseconds to kernel timeouts
|
|
*/
|
|
#define SYS_TIMEOUT_MS(ms) ((ms) == SYS_FOREVER_MS ? K_FOREVER : K_MSEC(ms))
|
|
|
|
/* Exhaustively enumerated, highly optimized time unit conversion API */
|
|
|
|
#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
|
|
__syscall int z_clock_hw_cycles_per_sec_runtime_get(void);
|
|
|
|
static inline int z_impl_z_clock_hw_cycles_per_sec_runtime_get(void)
|
|
{
|
|
extern int z_clock_hw_cycles_per_sec;
|
|
|
|
return z_clock_hw_cycles_per_sec;
|
|
}
|
|
#endif /* CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME */
|
|
|
|
#if defined(__cplusplus) && __cplusplus >= 201402L
|
|
#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
|
|
#define TIME_CONSTEXPR
|
|
#else
|
|
#define TIME_CONSTEXPR constexpr
|
|
#endif
|
|
#else
|
|
#define TIME_CONSTEXPR
|
|
#endif
|
|
|
|
static TIME_CONSTEXPR inline int sys_clock_hw_cycles_per_sec(void)
|
|
{
|
|
#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
|
|
return z_clock_hw_cycles_per_sec_runtime_get();
|
|
#else
|
|
return CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC;
|
|
#endif
|
|
}
|
|
|
|
/* Time converter generator gadget. Selects from one of three
|
|
* conversion algorithms: ones that take advantage when the
|
|
* frequencies are an integer ratio (in either direction), or a full
|
|
* precision conversion. Clever use of extra arguments causes all the
|
|
* selection logic to be optimized out, and the generated code even
|
|
* reduces to 32 bit only if a ratio conversion is available and the
|
|
* result is 32 bits.
|
|
*
|
|
* This isn't intended to be used directly, instead being wrapped
|
|
* appropriately in a user-facing API. The boolean arguments are:
|
|
*
|
|
* const_hz - The hz arguments are known to be compile-time
|
|
* constants (because otherwise the modulus test would
|
|
* have to be done at runtime)
|
|
* result32 - The result will be truncated to 32 bits on use
|
|
* round_up - Return the ceiling of the resulting fraction
|
|
* round_off - Return the nearest value to the resulting fraction
|
|
* (pass both round_up/off as false to get "round_down")
|
|
*/
|
|
static TIME_CONSTEXPR ALWAYS_INLINE uint64_t z_tmcvt(uint64_t t, uint32_t from_hz,
|
|
uint32_t to_hz, bool const_hz,
|
|
bool result32, bool round_up,
|
|
bool round_off)
|
|
{
|
|
bool mul_ratio = const_hz &&
|
|
(to_hz > from_hz) && ((to_hz % from_hz) == 0U);
|
|
bool div_ratio = const_hz &&
|
|
(from_hz > to_hz) && ((from_hz % to_hz) == 0U);
|
|
|
|
if (from_hz == to_hz) {
|
|
return result32 ? ((uint32_t)t) : t;
|
|
}
|
|
|
|
uint64_t off = 0;
|
|
|
|
if (!mul_ratio) {
|
|
uint32_t rdivisor = div_ratio ? (from_hz / to_hz) : from_hz;
|
|
|
|
if (round_up) {
|
|
off = rdivisor - 1U;
|
|
} else if (round_off) {
|
|
off = rdivisor / 2U;
|
|
}
|
|
}
|
|
|
|
/* Select (at build time!) between three different expressions for
|
|
* the same mathematical relationship, each expressed with and
|
|
* without truncation to 32 bits (I couldn't find a way to make
|
|
* the compiler correctly guess at the 32 bit result otherwise).
|
|
*/
|
|
if (div_ratio) {
|
|
t += off;
|
|
if (result32 && (t < BIT64(32))) {
|
|
return ((uint32_t)t) / (from_hz / to_hz);
|
|
} else {
|
|
return t / (from_hz / to_hz);
|
|
}
|
|
} else if (mul_ratio) {
|
|
if (result32) {
|
|
return ((uint32_t)t) * (to_hz / from_hz);
|
|
} else {
|
|
return t * (to_hz / from_hz);
|
|
}
|
|
} else {
|
|
if (result32) {
|
|
return (uint32_t)((t * to_hz + off) / from_hz);
|
|
} else {
|
|
return (t * to_hz + off) / from_hz;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* The following code is programmatically generated using this perl
|
|
* code, which enumerates all possible combinations of units, rounding
|
|
* modes and precision. Do not edit directly.
|
|
*
|
|
* Note that nano/microsecond conversions are only defined with 64 bit
|
|
* precision. These units conversions were not available in 32 bit
|
|
* variants historically, and doing 32 bit math with units that small
|
|
* has precision traps that we probably don't want to support in an
|
|
* official API.
|
|
*
|
|
* #!/usr/bin/perl -w
|
|
* use strict;
|
|
*
|
|
* my %human = ("ms" => "milliseconds",
|
|
* "us" => "microseconds",
|
|
* "ns" => "nanoseconds",
|
|
* "cyc" => "hardware cycles",
|
|
* "ticks" => "ticks");
|
|
*
|
|
* sub big { return $_[0] eq "us" || $_[0] eq "ns"; }
|
|
* sub prefix { return $_[0] eq "ms" || $_[0] eq "us" || $_[0] eq "ns"; }
|
|
*
|
|
* for my $from_unit ("ms", "us", "ns", "cyc", "ticks") {
|
|
* for my $to_unit ("ms", "us", "ns", "cyc", "ticks") {
|
|
* next if $from_unit eq $to_unit;
|
|
* next if prefix($from_unit) && prefix($to_unit);
|
|
* for my $round ("floor", "near", "ceil") {
|
|
* for(my $big=0; $big <= 1; $big++) {
|
|
* my $sz = $big ? 64 : 32;
|
|
* my $sym = "k_${from_unit}_to_${to_unit}_$round$sz";
|
|
* my $type = "u${sz}_t";
|
|
* my $const_hz = ($from_unit eq "cyc" || $to_unit eq "cyc")
|
|
* ? "Z_CCYC" : "true";
|
|
* my $ret32 = $big ? "false" : "true";
|
|
* my $rup = $round eq "ceil" ? "true" : "false";
|
|
* my $roff = $round eq "near" ? "true" : "false";
|
|
*
|
|
* my $hfrom = $human{$from_unit};
|
|
* my $hto = $human{$to_unit};
|
|
* print "/", "** \@brief Convert $hfrom to $hto\n";
|
|
* print " *\n";
|
|
* print " * Converts time values in $hfrom to $hto.\n";
|
|
* print " * Computes result in $sz bit precision.\n";
|
|
* if ($round eq "ceil") {
|
|
* print " * Rounds up to the next highest output unit.\n";
|
|
* } elsif ($round eq "near") {
|
|
* print " * Rounds to the nearest output unit.\n";
|
|
* } else {
|
|
* print " * Truncates to the next lowest output unit.\n";
|
|
* }
|
|
* print " *\n";
|
|
* print " * \@return The converted time value\n";
|
|
* print " *", "/\n";
|
|
*
|
|
* print "static TIME_CONSTEXPR inline $type $sym($type t)\n{\n\t";
|
|
* print "/", "* Generated. Do not edit. See above. *", "/\n\t";
|
|
* print "return z_tmcvt(t, Z_HZ_$from_unit, Z_HZ_$to_unit,";
|
|
* print " $const_hz, $ret32, $rup, $roff);\n";
|
|
* print "}\n\n";
|
|
* }
|
|
* }
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
/* Some more concise declarations to simplify the generator script and
|
|
* save bytes below
|
|
*/
|
|
#define Z_HZ_ms 1000
|
|
#define Z_HZ_us 1000000
|
|
#define Z_HZ_ns 1000000000
|
|
#define Z_HZ_cyc sys_clock_hw_cycles_per_sec()
|
|
#define Z_HZ_ticks CONFIG_SYS_CLOCK_TICKS_PER_SEC
|
|
#define Z_CCYC (!IS_ENABLED(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME))
|
|
|
|
/** @brief Convert milliseconds to hardware cycles
|
|
*
|
|
* Converts time values in milliseconds to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ms_to_cyc_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to hardware cycles
|
|
*
|
|
* Converts time values in milliseconds to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ms_to_cyc_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to hardware cycles
|
|
*
|
|
* Converts time values in milliseconds to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ms_to_cyc_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to hardware cycles
|
|
*
|
|
* Converts time values in milliseconds to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ms_to_cyc_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to hardware cycles
|
|
*
|
|
* Converts time values in milliseconds to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ms_to_cyc_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to hardware cycles
|
|
*
|
|
* Converts time values in milliseconds to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ms_to_cyc_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_cyc, Z_CCYC, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to ticks
|
|
*
|
|
* Converts time values in milliseconds to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ms_to_ticks_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_ticks, true, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to ticks
|
|
*
|
|
* Converts time values in milliseconds to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ms_to_ticks_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_ticks, true, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to ticks
|
|
*
|
|
* Converts time values in milliseconds to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ms_to_ticks_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_ticks, true, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to ticks
|
|
*
|
|
* Converts time values in milliseconds to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ms_to_ticks_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_ticks, true, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to ticks
|
|
*
|
|
* Converts time values in milliseconds to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ms_to_ticks_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_ticks, true, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert milliseconds to ticks
|
|
*
|
|
* Converts time values in milliseconds to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ms_to_ticks_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ms, Z_HZ_ticks, true, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert microseconds to hardware cycles
|
|
*
|
|
* Converts time values in microseconds to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_us_to_cyc_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert microseconds to hardware cycles
|
|
*
|
|
* Converts time values in microseconds to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_us_to_cyc_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert microseconds to hardware cycles
|
|
*
|
|
* Converts time values in microseconds to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_us_to_cyc_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert microseconds to hardware cycles
|
|
*
|
|
* Converts time values in microseconds to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_us_to_cyc_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert microseconds to hardware cycles
|
|
*
|
|
* Converts time values in microseconds to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_us_to_cyc_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert microseconds to hardware cycles
|
|
*
|
|
* Converts time values in microseconds to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_us_to_cyc_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_cyc, Z_CCYC, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert microseconds to ticks
|
|
*
|
|
* Converts time values in microseconds to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_us_to_ticks_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_ticks, true, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert microseconds to ticks
|
|
*
|
|
* Converts time values in microseconds to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_us_to_ticks_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_ticks, true, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert microseconds to ticks
|
|
*
|
|
* Converts time values in microseconds to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_us_to_ticks_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_ticks, true, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert microseconds to ticks
|
|
*
|
|
* Converts time values in microseconds to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_us_to_ticks_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_ticks, true, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert microseconds to ticks
|
|
*
|
|
* Converts time values in microseconds to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_us_to_ticks_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_ticks, true, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert microseconds to ticks
|
|
*
|
|
* Converts time values in microseconds to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_us_to_ticks_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_us, Z_HZ_ticks, true, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to hardware cycles
|
|
*
|
|
* Converts time values in nanoseconds to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ns_to_cyc_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to hardware cycles
|
|
*
|
|
* Converts time values in nanoseconds to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ns_to_cyc_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to hardware cycles
|
|
*
|
|
* Converts time values in nanoseconds to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ns_to_cyc_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to hardware cycles
|
|
*
|
|
* Converts time values in nanoseconds to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ns_to_cyc_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to hardware cycles
|
|
*
|
|
* Converts time values in nanoseconds to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ns_to_cyc_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to hardware cycles
|
|
*
|
|
* Converts time values in nanoseconds to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ns_to_cyc_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_cyc, Z_CCYC, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to ticks
|
|
*
|
|
* Converts time values in nanoseconds to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ns_to_ticks_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_ticks, true, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to ticks
|
|
*
|
|
* Converts time values in nanoseconds to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ns_to_ticks_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_ticks, true, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to ticks
|
|
*
|
|
* Converts time values in nanoseconds to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ns_to_ticks_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_ticks, true, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to ticks
|
|
*
|
|
* Converts time values in nanoseconds to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ns_to_ticks_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_ticks, true, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to ticks
|
|
*
|
|
* Converts time values in nanoseconds to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ns_to_ticks_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_ticks, true, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert nanoseconds to ticks
|
|
*
|
|
* Converts time values in nanoseconds to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ns_to_ticks_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ns, Z_HZ_ticks, true, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to milliseconds
|
|
*
|
|
* Converts time values in hardware cycles to milliseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_ms_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to milliseconds
|
|
*
|
|
* Converts time values in hardware cycles to milliseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_ms_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to milliseconds
|
|
*
|
|
* Converts time values in hardware cycles to milliseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_ms_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to milliseconds
|
|
*
|
|
* Converts time values in hardware cycles to milliseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_ms_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to milliseconds
|
|
*
|
|
* Converts time values in hardware cycles to milliseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_ms_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to milliseconds
|
|
*
|
|
* Converts time values in hardware cycles to milliseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_ms_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ms, Z_CCYC, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to microseconds
|
|
*
|
|
* Converts time values in hardware cycles to microseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_us_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to microseconds
|
|
*
|
|
* Converts time values in hardware cycles to microseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_us_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to microseconds
|
|
*
|
|
* Converts time values in hardware cycles to microseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_us_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to microseconds
|
|
*
|
|
* Converts time values in hardware cycles to microseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_us_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to microseconds
|
|
*
|
|
* Converts time values in hardware cycles to microseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_us_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to microseconds
|
|
*
|
|
* Converts time values in hardware cycles to microseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_us_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_us, Z_CCYC, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to nanoseconds
|
|
*
|
|
* Converts time values in hardware cycles to nanoseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_ns_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to nanoseconds
|
|
*
|
|
* Converts time values in hardware cycles to nanoseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_ns_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to nanoseconds
|
|
*
|
|
* Converts time values in hardware cycles to nanoseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_ns_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to nanoseconds
|
|
*
|
|
* Converts time values in hardware cycles to nanoseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_ns_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to nanoseconds
|
|
*
|
|
* Converts time values in hardware cycles to nanoseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_ns_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to nanoseconds
|
|
*
|
|
* Converts time values in hardware cycles to nanoseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_ns_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ns, Z_CCYC, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to ticks
|
|
*
|
|
* Converts time values in hardware cycles to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_ticks_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to ticks
|
|
*
|
|
* Converts time values in hardware cycles to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_ticks_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to ticks
|
|
*
|
|
* Converts time values in hardware cycles to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_ticks_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to ticks
|
|
*
|
|
* Converts time values in hardware cycles to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_ticks_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to ticks
|
|
*
|
|
* Converts time values in hardware cycles to ticks.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_cyc_to_ticks_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert hardware cycles to ticks
|
|
*
|
|
* Converts time values in hardware cycles to ticks.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_cyc_to_ticks_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_cyc, Z_HZ_ticks, Z_CCYC, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to milliseconds
|
|
*
|
|
* Converts time values in ticks to milliseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_ms_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ms, true, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to milliseconds
|
|
*
|
|
* Converts time values in ticks to milliseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_ms_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ms, true, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to milliseconds
|
|
*
|
|
* Converts time values in ticks to milliseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_ms_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ms, true, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert ticks to milliseconds
|
|
*
|
|
* Converts time values in ticks to milliseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_ms_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ms, true, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert ticks to milliseconds
|
|
*
|
|
* Converts time values in ticks to milliseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_ms_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ms, true, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to milliseconds
|
|
*
|
|
* Converts time values in ticks to milliseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_ms_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ms, true, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to microseconds
|
|
*
|
|
* Converts time values in ticks to microseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_us_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_us, true, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to microseconds
|
|
*
|
|
* Converts time values in ticks to microseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_us_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_us, true, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to microseconds
|
|
*
|
|
* Converts time values in ticks to microseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_us_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_us, true, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert ticks to microseconds
|
|
*
|
|
* Converts time values in ticks to microseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_us_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_us, true, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert ticks to microseconds
|
|
*
|
|
* Converts time values in ticks to microseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_us_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_us, true, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to microseconds
|
|
*
|
|
* Converts time values in ticks to microseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_us_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_us, true, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to nanoseconds
|
|
*
|
|
* Converts time values in ticks to nanoseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_ns_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ns, true, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to nanoseconds
|
|
*
|
|
* Converts time values in ticks to nanoseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_ns_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ns, true, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to nanoseconds
|
|
*
|
|
* Converts time values in ticks to nanoseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_ns_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ns, true, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert ticks to nanoseconds
|
|
*
|
|
* Converts time values in ticks to nanoseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_ns_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ns, true, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert ticks to nanoseconds
|
|
*
|
|
* Converts time values in ticks to nanoseconds.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_ns_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ns, true, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to nanoseconds
|
|
*
|
|
* Converts time values in ticks to nanoseconds.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_ns_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_ns, true, false, true, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to hardware cycles
|
|
*
|
|
* Converts time values in ticks to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_cyc_floor32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, true, false, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to hardware cycles
|
|
*
|
|
* Converts time values in ticks to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Truncates to the next lowest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_cyc_floor64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, false, false, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to hardware cycles
|
|
*
|
|
* Converts time values in ticks to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_cyc_near32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, true, false, true);
|
|
}
|
|
|
|
/** @brief Convert ticks to hardware cycles
|
|
*
|
|
* Converts time values in ticks to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds to the nearest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_cyc_near64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, false, false, true);
|
|
}
|
|
|
|
/** @brief Convert ticks to hardware cycles
|
|
*
|
|
* Converts time values in ticks to hardware cycles.
|
|
* Computes result in 32 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint32_t k_ticks_to_cyc_ceil32(uint32_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, true, true, false);
|
|
}
|
|
|
|
/** @brief Convert ticks to hardware cycles
|
|
*
|
|
* Converts time values in ticks to hardware cycles.
|
|
* Computes result in 64 bit precision.
|
|
* Rounds up to the next highest output unit.
|
|
*
|
|
* @return The converted time value
|
|
*/
|
|
static TIME_CONSTEXPR inline uint64_t k_ticks_to_cyc_ceil64(uint64_t t)
|
|
{
|
|
/* Generated. Do not edit. See above. */
|
|
return z_tmcvt(t, Z_HZ_ticks, Z_HZ_cyc, Z_CCYC, false, true, false);
|
|
}
|
|
|
|
#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
|
|
#include <syscalls/time_units.h>
|
|
#endif
|
|
|
|
#undef TIME_CONSTEXPR
|
|
|
|
#ifdef __cplusplus
|
|
} /* extern "C" */
|
|
#endif
|
|
|
|
#endif /* ZEPHYR_INCLUDE_TIME_UNITS_H_ */
|