/* * Copyright : (C) 2022 Phytium Information Technology, Inc. * All Rights Reserved. * * This program is OPEN SOURCE software: you can redistribute it and/or modify it * under the terms of the Phytium Public License as published by the Phytium Technology Co.,Ltd, * either version 1.0 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the Phytium Public License for more details. * * * FilePath: fkernel.h * Date: 2022-02-10 14:53:41 * LastEditTime: 2022-02-17 17:35:07 * Description:  This file is for kernel definition functions * * Modify History: * Ver   Who        Date         Changes * ----- ------     --------    -------------------------------------- * 1.0 huanghe 2021/10/20 first release * 1.1 zhugengyu 2022/2/17 add extra functionality */ #ifndef FKERNEL_H #define FKERNEL_H #ifdef __cplusplus extern "C" { #endif #ifdef __ASSEMBLY__ #define _AC(X, Y) X #define _AT(T, X) X #else #define __AC(X, Y) (X##Y) #define _AC(X, Y) __AC(X, Y) #define _AT(T, X) ((T)(X)) #endif #define _UL(x) (_AC(x, UL)) #define _ULL(x) (_AC(x, ULL)) #define _BITUL(x) (_UL(1) << (x)) #define _BITULL(x) (_ULL(1) << (x)) #define UL(x) (_UL(x)) #define ULL(x) (_ULL(x)) #define min(x, y) ( \ { \ typeof(x) _min1 = (x); \ typeof(y) _min2 = (y); \ (void)(&_min1 == &_min2); \ _min1 < _min2 ? _min1 : _min2; \ }) #define max(x, y) ( \ { \ typeof(x) _max1 = (x); \ typeof(y) _max2 = (y); \ (void)(&_max1 == &_max2); \ _max1 > _max2 ? _max1 : _max2; \ }) #define min3(x, y, z) min((typeof(x))min(x, y), z) #define max3(x, y, z) max((typeof(x))max(x, y), z) #define min_t(type, a, b) min(((type) a), ((type) b)) #define max_t(type, a, b) max(((type) a), ((type) b)) /** * clamp - return a value clamped to a given range with strict typechecking * @val: current value * @lo: lowest allowable value * @hi: highest allowable value * * This macro does strict typechecking of @lo/@hi to make sure they are of the * same type as @val. See the unnecessary pointer comparisons. */ #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) /** * do_div - returns 2 values: calculate remainder and update new dividend * @n: uint64_t dividend (will be updated) * @base: uint32_t divisor * * Summary: * ``uint32_t remainder = n % base;`` * ``n = n / base;`` * * Return: (uint32_t)remainder * * NOTE: macro parameter @n is evaluated multiple times, * beware of side effects! */ #define do_div(n, base) ( \ { \ uint32_t __base = (base); \ uint32_t __rem; \ __rem = ((uint64_t)(n)) % __base; \ (n) = ((uint64_t)(n)) / __base; \ __rem; \ }) /* The `const' in roundup() prevents gcc-3.3 from calling __divdi3 */ #define roundup(x, y) ( \ { \ const typeof(y) __y = y; \ ((x + (__y - 1)) / __y) * __y; \ }) #define rounddown(x, y) ( \ { \ typeof(x) __x = (x); \ __x - (__x % (y)); \ }) #define DIV_ROUND_UP(n, d) (((n) + (d)-1) / (d)) #if defined(__aarch64__) #define BITS_PER_LONG 64 #else #define BITS_PER_LONG 32 #endif #ifndef BITS_PER_LONG_LONG #define BITS_PER_LONG_LONG 64 #endif #define BIT(nr) (1ULL << (nr)) #define BIT_ULL(nr) (1ULL << (nr)) #define BIT_MASK(nr) (BIT(nr) - 1UL) #define BIT_WORD(nr) ((nr) / BITS_PER_LONG) #define BIT_ULL_MASK(nr) (1ULL << ((nr) % BITS_PER_LONG_LONG)) #define BIT_ULL_WORD(nr) ((nr) / BITS_PER_LONG_LONG) #define BITS_PER_BYTE 8 #define DIV_ROUND_DOWN_ULL(ll, d) \ ({ unsigned long long _tmp = (ll); do_div(_tmp, d); _tmp; }) #define DIV_ROUND_UP_ULL(ll, d) DIV_ROUND_DOWN_ULL((ll) + (d) - 1, (d)) #if BITS_PER_LONG == 32 #define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d) #else #define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d) #endif /* * Create a contiguous bitmask starting at bit position @l and ending at * position @h. For example * GENMASK_ULL(39, 21) gives us the 64bit vector 0x000000ffffe00000. */ #define GENMASK(h, l) \ (((~0UL) - (1UL << (l)) + 1) & (~0UL >> (BITS_PER_LONG - 1 - (h)))) #define GENMASK_ULL(h, l) \ (((~0ULL) - (1ULL << (l)) + 1) & \ (~0ULL >> (BITS_PER_LONG_LONG - 1 - (h)))) #define SZ_1 0x00000001 #define SZ_2 0x00000002 #define SZ_4 0x00000004 #define SZ_8 0x00000008 #define SZ_16 0x00000010 #define SZ_32 0x00000020 #define SZ_64 0x00000040 #define SZ_128 0x00000080 #define SZ_256 0x00000100 #define SZ_512 0x00000200 #define SZ_1K 0x00000400 #define SZ_2K 0x00000800 #define SZ_4K 0x00001000 #define SZ_8K 0x00002000 #define SZ_16K 0x00004000 #define SZ_32K 0x00008000 #define SZ_64K 0x00010000 #define SZ_128K 0x00020000 #define SZ_256K 0x00040000 #define SZ_512K 0x00080000 #define SZ_1M 0x00100000 #define SZ_2M 0x00200000 #define SZ_4M 0x00400000 #define SZ_8M 0x00800000 #define SZ_16M 0x01000000 #define SZ_32M 0x02000000 #define SZ_64M 0x04000000 #define SZ_128M 0x08000000 #define SZ_256M 0x10000000 #define SZ_512M 0x20000000 #define SZ_1G 0x40000000 #define SZ_2G 0x80000000 #define SZ_3G 0xC0000000 #define SZ_4G 0x100000000ULL #define SZ_8G 0x200000000ULL #define NANO_TO_MICRO 1000 #define NANO_TO_KILO 1000000 /** * UPPER_32_BITS - return bits 32-63 of a number * @n: the number we're accessing * * A basic shift-right of a 64- or 32-bit quantity. Use this to suppress * the "right shift count >= width of type" warning when that quantity is * 32-bits. * Note that do not input signed int 'n' */ #define UPPER_32_BITS(n) ((uint32_t)(((n) >> 16) >> 16)) /** * LOWER_32_BITS - return bits 0-31 of a number * @n: the number we're accessing * Note that do not input signed int 'n' */ #define LOWER_32_BITS(n) ((uint32_t)((n)&0xffffffff)) #define IS_ALIGNED(x, a) (((x) & ((typeof(x))(a)-1)) == 0) #ifndef __aligned #define __aligned(x) __attribute__((__aligned__(x))) #endif /** * CONTAINER_OF - return the member address of ptr, if the type of ptr is the * struct type. */ #define CONTAINER_OF(ptr, type, member) \ ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member))) #ifndef ARRAY_SIZE #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) #endif /* set 32-bit register [a:b] as x, where a is high bit, b is low bit, x is setting/getting value */ #define GET_REG32_BITS(x, a, b) (u32)((((u32)(x)) & GENMASK(a, b)) >> b) #define SET_REG32_BITS(x, a, b) (u32)((((u32)(x)) << b) & GENMASK(a, b)) /* Integer alignment down */ #define PALIGN_DOWN(x,align) (x & ~(align-1)) /* Integer alignment up */ #define PALIGN_UP(x,align) ((x + (align-1)) & ~(align-1)) #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) #define __BUILD_BUG_ON_NOT_POWER_OF_2(n) \ BUILD_BUG_ON(((n) & ((n) - 1)) != 0) #define BUILD_BUG_ON_NOT_POWER_OF_2(n) \ BUILD_BUG_ON((n) == 0 || (((n) & ((n) - 1)) != 0)) /** * COMILETIME_ASSERT - break build and emit msg if condition is false * @condition: a compile-time constant condition to check * @msg: a message to emit if condition is false * * In tradition of POSIX assert, this macro will break the build if the * supplied condition is *false*, emitting the supplied error message if the * compiler has support to do so. */ # define COMILETIME_ASSERT(condition, msg, prefix, suffix) \ do { \ extern void prefix ## suffix(void) __attribute__((error(msg))); \ if (!(condition)) \ prefix ## suffix(); \ } while (0) /** * BUILD_BUG_ON_MSG - break compile if a condition is true & emit supplied * error message. * @condition: the condition which the compiler should know is false. * * See BUILD_BUG_ON for description. */ #define BUILD_BUG_ON_MSG(cond, msg) COMILETIME_ASSERT(!(cond), msg, __compiletime_assert_, __COUNTER__) /* * Bitfield access macros * * FIELD_{GET,PREP} macros take as first parameter shifted mask * from which they extract the base mask and shift amount. * Mask must be a compilation time constant. * * Example: * * #define REG_FIELD_A GENMASK(6, 0) * #define REG_FIELD_B BIT(7) * #define REG_FIELD_C GENMASK(15, 8) * #define REG_FIELD_D GENMASK(31, 16) * * Get: * a = FIELD_GET(REG_FIELD_A, reg); * b = FIELD_GET(REG_FIELD_B, reg); * * Set: * reg = FIELD_PREP(REG_FIELD_A, 1) | * FIELD_PREP(REG_FIELD_B, 0) | * FIELD_PREP(REG_FIELD_C, c) | * FIELD_PREP(REG_FIELD_D, 0x40); * * Modify: * reg &= ~REG_FIELD_C; * reg |= FIELD_PREP(REG_FIELD_C, c); */ #define BF_SHF(x) (__builtin_ffsll(x) - 1) #define BF_FIELD_CHECK(mask, reg, val, pfx) \ ({ \ BUILD_BUG_ON_MSG(!__builtin_constant_p(mask), \ pfx "mask is not constant"); \ BUILD_BUG_ON_MSG((mask) == 0, pfx "mask is zero"); \ BUILD_BUG_ON_MSG(__builtin_constant_p(val) ? \ ~((mask) >> BF_SHF(mask)) & (val) : 0, \ pfx "value too large for the field"); \ BUILD_BUG_ON_MSG((mask) > (typeof(reg))~0ull, \ pfx "type of reg too small for mask"); \ __BUILD_BUG_ON_NOT_POWER_OF_2((mask) + \ (1ULL << BF_SHF(mask))); \ }) /** * FIELD_PREP() - prepare a bitfield element * @mask: shifted mask defining the field's length and position * @val: value to put in the field * * FIELD_PREP() masks and shifts up the value. The result should * be combined with other fields of the bitfield using logical OR. */ #define FIELD_PREP(mask, val) \ ({ \ BF_FIELD_CHECK(mask, 0ULL, val, "FIELD_PREP: "); \ ((typeof(mask))(val) << BF_SHF(mask)) & (mask); \ }) #ifdef __cplusplus } #endif #endif