mirror of
https://github.com/ARM-software/arm-trusted-firmware.git
synced 2025-04-19 11:04:20 +00:00
57bf605772
This patch adds a new include/export/ directory meant for inclusion in third-party code. This is useful for cases where third-party code needs to interact with TF-A interfaces and data structures (such as a custom BL2-implementation like coreboot handing off to BL31). Directly including headers from the TF-A repository avoids having to duplicate all these definitions (and risk them going stale), but with the current header structure this is not possible because handoff API definitions are too deeply intertwined with other TF code/headers and chain-include other headers that will not be available in the other environment. The new approach aims to solve this by separating only the parts that are really needed into these special headers that are self-contained and will not chain-include other (non-export) headers. TF-A code should never include them directly but should instead always include the respective wrapper header, which will include the required prerequisites (like <stdint.h>) before including the export header. Third-party code can include the export headers via its own wrappers that make sure the necessary definitions are available in whatever way that environment can provide them. Change-Id: Ifd769320ba51371439a8e5dd5b79c2516c3b43ab Signed-off-by: Julius Werner <jwerner@chromium.org>
151 lines
4 KiB
C
151 lines
4 KiB
C
/*
|
|
* Copyright (c) 2016-2019, ARM Limited and Contributors. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*/
|
|
|
|
#ifndef UTILS_DEF_H
|
|
#define UTILS_DEF_H
|
|
|
|
#include <export/lib/utils_def_exp.h>
|
|
|
|
/* Compute the number of elements in the given array */
|
|
#define ARRAY_SIZE(a) \
|
|
(sizeof(a) / sizeof((a)[0]))
|
|
|
|
#define IS_POWER_OF_TWO(x) \
|
|
(((x) & ((x) - 1)) == 0)
|
|
|
|
#define SIZE_FROM_LOG2_WORDS(n) (4 << (n))
|
|
|
|
#define BIT_32(nr) (U(1) << (nr))
|
|
#define BIT_64(nr) (ULL(1) << (nr))
|
|
|
|
#ifdef AARCH32
|
|
#define BIT BIT_32
|
|
#else
|
|
#define BIT BIT_64
|
|
#endif
|
|
|
|
/*
|
|
* Create a contiguous bitmask starting at bit position @l and ending at
|
|
* position @h. For example
|
|
* GENMASK_64(39, 21) gives us the 64bit vector 0x000000ffffe00000.
|
|
*/
|
|
#if defined(__LINKER__) || defined(__ASSEMBLY__)
|
|
#define GENMASK_32(h, l) \
|
|
(((0xFFFFFFFF) << (l)) & (0xFFFFFFFF >> (32 - 1 - (h))))
|
|
|
|
#define GENMASK_64(h, l) \
|
|
((~0 << (l)) & (~0 >> (64 - 1 - (h))))
|
|
#else
|
|
#define GENMASK_32(h, l) \
|
|
(((~UINT32_C(0)) << (l)) & (~UINT32_C(0) >> (32 - 1 - (h))))
|
|
|
|
#define GENMASK_64(h, l) \
|
|
(((~UINT64_C(0)) << (l)) & (~UINT64_C(0) >> (64 - 1 - (h))))
|
|
#endif
|
|
|
|
#ifdef AARCH32
|
|
#define GENMASK GENMASK_32
|
|
#else
|
|
#define GENMASK GENMASK_64
|
|
#endif
|
|
|
|
/*
|
|
* This variant of div_round_up can be used in macro definition but should not
|
|
* be used in C code as the `div` parameter is evaluated twice.
|
|
*/
|
|
#define DIV_ROUND_UP_2EVAL(n, d) (((n) + (d) - 1) / (d))
|
|
|
|
#define div_round_up(val, div) __extension__ ({ \
|
|
__typeof__(div) _div = (div); \
|
|
((val) + _div - (__typeof__(div)) 1) / _div; \
|
|
})
|
|
|
|
#define MIN(x, y) __extension__ ({ \
|
|
__typeof__(x) _x = (x); \
|
|
__typeof__(y) _y = (y); \
|
|
(void)(&_x == &_y); \
|
|
_x < _y ? _x : _y; \
|
|
})
|
|
|
|
#define MAX(x, y) __extension__ ({ \
|
|
__typeof__(x) _x = (x); \
|
|
__typeof__(y) _y = (y); \
|
|
(void)(&_x == &_y); \
|
|
_x > _y ? _x : _y; \
|
|
})
|
|
|
|
/*
|
|
* The round_up() macro rounds up a value to the given boundary in a
|
|
* type-agnostic yet type-safe manner. The boundary must be a power of two.
|
|
* In other words, it computes the smallest multiple of boundary which is
|
|
* greater than or equal to value.
|
|
*
|
|
* round_down() is similar but rounds the value down instead.
|
|
*/
|
|
#define round_boundary(value, boundary) \
|
|
((__typeof__(value))((boundary) - 1))
|
|
|
|
#define round_up(value, boundary) \
|
|
((((value) - 1) | round_boundary(value, boundary)) + 1)
|
|
|
|
#define round_down(value, boundary) \
|
|
((value) & ~round_boundary(value, boundary))
|
|
|
|
/*
|
|
* Evaluates to 1 if (ptr + inc) overflows, 0 otherwise.
|
|
* Both arguments must be unsigned pointer values (i.e. uintptr_t).
|
|
*/
|
|
#define check_uptr_overflow(_ptr, _inc) \
|
|
((_ptr) > (UINTPTR_MAX - (_inc)))
|
|
|
|
/*
|
|
* Evaluates to 1 if (u32 + inc) overflows, 0 otherwise.
|
|
* Both arguments must be 32-bit unsigned integers (i.e. effectively uint32_t).
|
|
*/
|
|
#define check_u32_overflow(_u32, _inc) \
|
|
((_u32) > (UINT32_MAX - (_inc)))
|
|
|
|
/* Register size of the current architecture. */
|
|
#ifdef AARCH32
|
|
#define REGSZ U(4)
|
|
#else
|
|
#define REGSZ U(8)
|
|
#endif
|
|
|
|
/*
|
|
* Test for the current architecture version to be at least the version
|
|
* expected.
|
|
*/
|
|
#define ARM_ARCH_AT_LEAST(_maj, _min) \
|
|
((ARM_ARCH_MAJOR > (_maj)) || \
|
|
((ARM_ARCH_MAJOR == (_maj)) && (ARM_ARCH_MINOR >= (_min))))
|
|
|
|
/*
|
|
* Import an assembly or linker symbol as a C expression with the specified
|
|
* type
|
|
*/
|
|
#define IMPORT_SYM(type, sym, name) \
|
|
extern char sym[];\
|
|
static const __attribute__((unused)) type name = (type) sym;
|
|
|
|
/*
|
|
* When the symbol is used to hold a pointer, its alignment can be asserted
|
|
* with this macro. For example, if there is a linker symbol that is going to
|
|
* be used as a 64-bit pointer, the value of the linker symbol must also be
|
|
* aligned to 64 bit. This macro makes sure this is the case.
|
|
*/
|
|
#define ASSERT_SYM_PTR_ALIGN(sym) assert(((size_t)(sym) % __alignof__(*(sym))) == 0)
|
|
|
|
#define COMPILER_BARRIER() __asm__ volatile ("" ::: "memory")
|
|
|
|
/* Compiler builtin of GCC >= 9 and planned in llvm */
|
|
#ifdef __HAVE_SPECULATION_SAFE_VALUE
|
|
# define SPECULATION_SAFE_VALUE(var) __builtin_speculation_safe_value(var)
|
|
#else
|
|
# define SPECULATION_SAFE_VALUE(var) var
|
|
#endif
|
|
|
|
#endif /* UTILS_DEF_H */
|