mirror of
https://github.com/zephyrproject-rtos/zephyr
synced 2025-08-20 10:55:22 +00:00
cc334c7273
Convert code to use u{8,16,32,64}_t and s{8,16,32,64}_t instead of C99
integer types. This handles the remaining includes and kernel, plus
touching up various points that we skipped because of include
dependancies. We also convert the PRI printf formatters in the arch
code over to normal formatters.
Jira: ZEP-2051
Change-Id: Iecbb12601a3ee4ea936fd7ddea37788a645b08b0
Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
180 lines
4.9 KiB
C
180 lines
4.9 KiB
C
/*
|
|
* Copyright (c) 2011-2014, Wind River Systems, Inc.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* @brief Misc utilities
|
|
*
|
|
* Misc utilities usable by the kernel and application code.
|
|
*/
|
|
|
|
#ifndef _UTIL__H_
|
|
#define _UTIL__H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#ifndef _ASMLANGUAGE
|
|
|
|
#include <zephyr/types.h>
|
|
|
|
/* Helper to pass a int as a pointer or vice-versa.
|
|
* Those are available for 32 bits architectures:
|
|
*/
|
|
#define POINTER_TO_UINT(x) ((u32_t) (x))
|
|
#define UINT_TO_POINTER(x) ((void *) (x))
|
|
#define POINTER_TO_INT(x) ((s32_t) (x))
|
|
#define INT_TO_POINTER(x) ((void *) (x))
|
|
|
|
/* Evaluates to 0 if cond is true-ish; compile error otherwise */
|
|
#define ZERO_OR_COMPILE_ERROR(cond) ((int) sizeof(char[1 - 2 * !(cond)]) - 1)
|
|
|
|
/* Evaluates to 0 if array is an array; compile error if not array (e.g.
|
|
* pointer)
|
|
*/
|
|
#define IS_ARRAY(array) \
|
|
ZERO_OR_COMPILE_ERROR( \
|
|
!__builtin_types_compatible_p(__typeof__(array), \
|
|
__typeof__(&(array)[0])))
|
|
|
|
/* Evaluates to number of elements in an array; compile error if not
|
|
* an array (e.g. pointer)
|
|
*/
|
|
#define ARRAY_SIZE(array) \
|
|
((unsigned long) (IS_ARRAY(array) + \
|
|
(sizeof(array) / sizeof((array)[0]))))
|
|
|
|
/* Evaluates to 1 if ptr is part of array, 0 otherwise; compile error if
|
|
* "array" argument is not an array (e.g. "ptr" and "array" mixed up)
|
|
*/
|
|
#define PART_OF_ARRAY(array, ptr) \
|
|
((ptr) && ((ptr) >= &array[0] && (ptr) < &array[ARRAY_SIZE(array)]))
|
|
|
|
#define CONTAINER_OF(ptr, type, field) \
|
|
((type *)(((char *)(ptr)) - offsetof(type, field)))
|
|
|
|
/* round "x" up/down to next multiple of "align" (which must be a power of 2) */
|
|
#define ROUND_UP(x, align) \
|
|
(((unsigned long)(x) + ((unsigned long)align - 1)) & \
|
|
~((unsigned long)align - 1))
|
|
#define ROUND_DOWN(x, align) ((unsigned long)(x) & ~((unsigned long)align - 1))
|
|
|
|
#define ceiling_fraction(numerator, divider) \
|
|
(((numerator) + ((divider) - 1)) / (divider))
|
|
|
|
#ifdef INLINED
|
|
#define INLINE inline
|
|
#else
|
|
#define INLINE
|
|
#endif
|
|
|
|
#ifndef max
|
|
#define max(a, b) (((a) > (b)) ? (a) : (b))
|
|
#endif
|
|
|
|
#ifndef min
|
|
#define min(a, b) (((a) < (b)) ? (a) : (b))
|
|
#endif
|
|
|
|
static inline int is_power_of_two(unsigned int x)
|
|
{
|
|
return (x != 0) && !(x & (x - 1));
|
|
}
|
|
|
|
static inline s64_t arithmetic_shift_right(s64_t value, u8_t shift)
|
|
{
|
|
s64_t sign_ext;
|
|
|
|
if (shift == 0) {
|
|
return value;
|
|
}
|
|
|
|
/* extract sign bit */
|
|
sign_ext = (value >> 63) & 1;
|
|
|
|
/* make all bits of sign_ext be the same as the value's sign bit */
|
|
sign_ext = -sign_ext;
|
|
|
|
/* shift value and fill opened bit positions with sign bit */
|
|
return (value >> shift) | (sign_ext << (64 - shift));
|
|
}
|
|
|
|
#endif /* !_ASMLANGUAGE */
|
|
|
|
/* KB, MB, GB */
|
|
#define KB(x) ((x) << 10)
|
|
#define MB(x) (KB(x) << 10)
|
|
#define GB(x) (MB(x) << 10)
|
|
|
|
/* KHZ, MHZ */
|
|
#define KHZ(x) ((x) * 1000)
|
|
#define MHZ(x) (KHZ(x) * 1000)
|
|
|
|
#ifndef BIT
|
|
#define BIT(n) (1UL << (n))
|
|
#endif
|
|
|
|
#define BIT_MASK(n) (BIT(n) - 1)
|
|
|
|
/**
|
|
* @brief Check for macro definition in compiler-visible expressions
|
|
*
|
|
* This trick was pioneered in Linux as the config_enabled() macro.
|
|
* The madness has the effect of taking a macro value that may be
|
|
* defined to "1" (e.g. CONFIG_MYFEATURE), or may not be defined at
|
|
* all and turning it into a literal expression that can be used at
|
|
* "runtime". That is, it works similarly to
|
|
* "defined(CONFIG_MYFEATURE)" does except that it is an expansion
|
|
* that can exist in a standard expression and be seen by the compiler
|
|
* and optimizer. Thus much ifdef usage can be replaced with cleaner
|
|
* expressions like:
|
|
*
|
|
* if (IS_ENABLED(CONFIG_MYFEATURE))
|
|
* myfeature_enable();
|
|
*
|
|
* INTERNAL
|
|
* First pass just to expand any existing macros, we need the macro
|
|
* value to be e.g. a literal "1" at expansion time in the next macro,
|
|
* not "(1)", etc... Standard recursive expansion does not work.
|
|
*/
|
|
#define IS_ENABLED(config_macro) _IS_ENABLED1(config_macro)
|
|
|
|
/* Now stick on a "_XXXX" prefix, it will now be "_XXXX1" if config_macro
|
|
* is "1", or just "_XXXX" if it's undefined.
|
|
* ENABLED: _IS_ENABLED2(_XXXX1)
|
|
* DISABLED _IS_ENABLED2(_XXXX)
|
|
*/
|
|
#define _IS_ENABLED1(config_macro) _IS_ENABLED2(_XXXX##config_macro)
|
|
|
|
/* Here's the core trick, we map "_XXXX1" to "_YYYY," (i.e. a string
|
|
* with a trailing comma), so it has the effect of making this a
|
|
* two-argument tuple to the preprocessor only in the case where the
|
|
* value is defined to "1"
|
|
* ENABLED: _YYYY, <--- note comma!
|
|
* DISABLED: _XXXX
|
|
*/
|
|
#define _XXXX1 _YYYY,
|
|
|
|
/* Then we append an extra argument to fool the gcc preprocessor into
|
|
* accepting it as a varargs macro.
|
|
* arg1 arg2 arg3
|
|
* ENABLED: _IS_ENABLED3(_YYYY, 1, 0)
|
|
* DISABLED _IS_ENABLED3(_XXXX 1, 0)
|
|
*/
|
|
#define _IS_ENABLED2(one_or_two_args) _IS_ENABLED3(one_or_two_args 1, 0)
|
|
|
|
/* And our second argument is thus now cooked to be 1 in the case
|
|
* where the value is defined to 1, and 0 if not:
|
|
*/
|
|
#define _IS_ENABLED3(ignore_this, val, ...) val
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _UTIL__H_ */
|