1 /* 2 * Copyright (c) 2016-2025, Arm Limited and Contributors. All rights reserved. 3 * Copyright (c) 2020, NVIDIA Corporation. All rights reserved. 4 * 5 * SPDX-License-Identifier: BSD-3-Clause 6 */ 7 8 #ifndef UTILS_DEF_H 9 #define UTILS_DEF_H 10 11 #include <export/lib/utils_def_exp.h> 12 13 /* Compute the number of elements in the given array */ 14 #define ARRAY_SIZE(a) \ 15 (sizeof(a) / sizeof((a)[0])) 16 17 #define IS_POWER_OF_TWO(x) \ 18 (((x) & ((x) - 1)) == 0) 19 20 #define SIZE_FROM_LOG2_WORDS(n) (U(4) << (n)) 21 22 #if defined(__LINKER__) || defined(__ASSEMBLER__) 23 #define BIT_32(nr) (U(1) << (nr)) 24 #define BIT_64(nr) (ULL(1) << (nr)) 25 #else 26 #define BIT_32(nr) (((uint32_t)(1U)) << (nr)) 27 #define BIT_64(nr) (((uint64_t)(1ULL)) << (nr)) 28 #endif 29 30 #ifdef __aarch64__ 31 #define BIT BIT_64 32 #else 33 #define BIT BIT_32 34 #endif 35 36 /* 37 * Create a contiguous bitmask starting at bit position @low and ending at 38 * position @high. For example 39 * GENMASK_64(39, 21) gives us the 64bit vector 0x000000ffffe00000. 40 */ 41 #if defined(__LINKER__) || defined(__ASSEMBLER__) 42 #define GENMASK_32(high, low) \ 43 (((0xFFFFFFFF) << (low)) & (0xFFFFFFFF >> (32 - 1 - (high)))) 44 45 #define GENMASK_64(high, low) \ 46 ((~0 << (low)) & (~0 >> (64 - 1 - (high)))) 47 #else 48 #define GENMASK_32(high, low) \ 49 ((~UINT32_C(0) >> (32U - 1U - (high))) ^ ((BIT_32(low) - 1U))) 50 51 #define GENMASK_64(high, low) \ 52 ((~UINT64_C(0) >> (64U - 1U - (high))) ^ ((BIT_64(low) - 1U))) 53 #endif 54 55 #ifdef __aarch64__ 56 #define GENMASK GENMASK_64 57 #else 58 #define GENMASK GENMASK_32 59 #endif 60 61 /* 62 * Similar to GENMASK_64 but uses a named register field to compute the mask. 63 * For a register field REG_FIELD, the macros REG_FIELD_WIDTH and 64 * REG_FIELD_SHIFT must be defined. 65 */ 66 #define MASK(regfield) \ 67 ((~0ULL >> (64ULL - (regfield##_WIDTH))) << (regfield##_SHIFT)) 68 69 #define HI(addr) (addr >> 32) 70 #define LO(addr) (addr & 0xffffffff) 71 72 #define HI_64(addr) (addr >> 64) 73 #define LO_64(addr) (addr & 0xffffffffffffffff) 74 75 /** 76 * EXTRACT_FIELD - Extracts a specific bit field from a value. 77 * 78 * @reg: The input value containing the field. 79 80 * @regfield: A bitmask representing the field. For a register field REG_FIELD, 81 * the macros REG_FIELD_WIDTH and REG_FIELD_SHIFT must be defined. 82 83 * The result of this macro is the contents of the field right shifted to the 84 * least significant bit positions, with the rest being zero. 85 */ 86 #define EXTRACT(regfield, reg) \ 87 (((reg) & MASK(regfield)) >> (regfield##_SHIFT)) 88 89 #define UPDATE_REG_FIELD(regfield, reg, val) \ 90 do { \ 91 (reg) &= ~(MASK(regfield)); \ 92 (reg) |= ((uint64_t)(val) << (regfield##_SHIFT)); \ 93 } while (0) 94 95 /* 96 * This variant of div_round_up can be used in macro definition but should not 97 * be used in C code as the `div` parameter is evaluated twice. 98 */ 99 #define DIV_ROUND_UP_2EVAL(n, d) (((n) + (d) - 1) / (d)) 100 101 /* round `n` up to a multiple of `r` */ 102 #define ROUND_UP_2EVAL(n, r) ((((n) + (r) - 1) / (r)) * (r)) 103 104 #define div_round_up(val, div) __extension__ ({ \ 105 __typeof__(div) _div = (div); \ 106 ((val) + _div - (__typeof__(div)) 1) / _div; \ 107 }) 108 109 #define MIN(x, y) __extension__ ({ \ 110 __typeof__(x) _x = (x); \ 111 __typeof__(y) _y = (y); \ 112 (void)(&_x == &_y); \ 113 (_x < _y) ? _x : _y; \ 114 }) 115 116 #define MAX(x, y) __extension__ ({ \ 117 __typeof__(x) _x = (x); \ 118 __typeof__(y) _y = (y); \ 119 (void)(&_x == &_y); \ 120 (_x > _y) ? _x : _y; \ 121 }) 122 123 #define CLAMP(x, min, max) __extension__ ({ \ 124 __typeof__(x) _x = (x); \ 125 __typeof__(min) _min = (min); \ 126 __typeof__(max) _max = (max); \ 127 (void)(&_x == &_min); \ 128 (void)(&_x == &_max); \ 129 ((_x > _max) ? _max : ((_x < _min) ? _min : _x)); \ 130 }) 131 132 /* 133 * The round_up() macro rounds up a value to the given boundary in a 134 * type-agnostic yet type-safe manner. The boundary must be a power of two. 135 * In other words, it computes the smallest multiple of boundary which is 136 * greater than or equal to value. 137 * 138 * round_down() is similar but rounds the value down instead. 139 */ 140 #define round_boundary(value, boundary) \ 141 ((__typeof__(value))((boundary) - ((__typeof__(value))1U))) 142 143 #define round_up(value, boundary) \ 144 ((((value) - ((__typeof__(value))1U)) | round_boundary(value, boundary)) + ((__typeof__(value))1U)) 145 146 #define round_down(value, boundary) \ 147 ((value) & ~round_boundary(value, boundary)) 148 149 /* add operation together with checking whether the operation overflowed 150 * The result is '*res', 151 * return 0 on success and 1 on overflow 152 */ 153 #define add_overflow(a, b, res) __builtin_add_overflow((a), (b), (res)) 154 155 /* 156 * Round up a value to align with a given size and 157 * check whether overflow happens. 158 * The rounduped value is '*res', 159 * return 0 on success and 1 on overflow 160 */ 161 #define round_up_overflow(v, size, res) (__extension__({ \ 162 typeof(res) __res = res; \ 163 typeof(*(__res)) __roundup_tmp = 0; \ 164 typeof(v) __roundup_mask = (typeof(v))(size) - 1; \ 165 \ 166 add_overflow((v), __roundup_mask, &__roundup_tmp) ? 1 : \ 167 (void)(*(__res) = __roundup_tmp & ~__roundup_mask), 0; \ 168 })) 169 170 /* 171 * Add a with b, then round up the result to align with a given size and 172 * check whether overflow happens. 173 * The rounduped value is '*res', 174 * return 0 on success and 1 on overflow 175 */ 176 #define add_with_round_up_overflow(a, b, size, res) (__extension__({ \ 177 typeof(a) __a = (a); \ 178 typeof(__a) __add_res = 0; \ 179 \ 180 add_overflow((__a), (b), &__add_res) ? 1 : \ 181 round_up_overflow(__add_res, (size), (res)) ? 1 : 0; \ 182 })) 183 184 /** 185 * Helper macro to ensure a value lies on a given boundary. 186 */ 187 #define is_aligned(value, boundary) \ 188 (round_up((uintptr_t) value, boundary) == \ 189 round_down((uintptr_t) value, boundary)) 190 191 /* 192 * Evaluates to 1 if (ptr + inc) overflows, 0 otherwise. 193 * Both arguments must be unsigned pointer values (i.e. uintptr_t). 194 */ 195 #define check_uptr_overflow(_ptr, _inc) \ 196 ((_ptr) > (UINTPTR_MAX - (_inc))) 197 198 /* 199 * Evaluates to 1 if (u32 + inc) overflows, 0 otherwise. 200 * Both arguments must be 32-bit unsigned integers (i.e. effectively uint32_t). 201 */ 202 #define check_u32_overflow(_u32, _inc) \ 203 ((_u32) > (UINT32_MAX - (_inc))) 204 205 /* Register size of the current architecture. */ 206 #ifdef __aarch64__ 207 #define REGSZ U(8) 208 #else 209 #define REGSZ U(4) 210 #endif 211 212 /* 213 * Test for the current architecture version to be at least the version 214 * expected. 215 */ 216 #define ARM_ARCH_AT_LEAST(_maj, _min) \ 217 ((ARM_ARCH_MAJOR > (_maj)) || \ 218 ((ARM_ARCH_MAJOR == (_maj)) && (ARM_ARCH_MINOR >= (_min)))) 219 220 /* 221 * Import an assembly or linker symbol as a C expression with the specified 222 * type 223 */ 224 #define IMPORT_SYM(type, sym, name) \ 225 extern char sym[];\ 226 static const __attribute__((unused)) type name = (type) sym; 227 228 /* 229 * When the symbol is used to hold a pointer, its alignment can be asserted 230 * with this macro. For example, if there is a linker symbol that is going to 231 * be used as a 64-bit pointer, the value of the linker symbol must also be 232 * aligned to 64 bit. This macro makes sure this is the case. 233 */ 234 #define ASSERT_SYM_PTR_ALIGN(sym) assert(((size_t)(sym) % __alignof__(*(sym))) == 0) 235 236 #define COMPILER_BARRIER() __asm__ volatile ("" ::: "memory") 237 238 /* Compiler builtin of GCC >= 9 and planned in llvm */ 239 #ifdef __HAVE_SPECULATION_SAFE_VALUE 240 # define SPECULATION_SAFE_VALUE(var) __builtin_speculation_safe_value(var) 241 #else 242 # define SPECULATION_SAFE_VALUE(var) var 243 #endif 244 245 /* 246 * Ticks elapsed in one second with a signal of 1 MHz 247 */ 248 #define MHZ_TICKS_PER_SEC U(1000000) 249 250 /* 251 * Ticks elapsed in one second with a signal of 1 KHz 252 */ 253 #define KHZ_TICKS_PER_SEC U(1000) 254 255 #endif /* UTILS_DEF_H */ 256