344 lines
9.8 KiB
C
344 lines
9.8 KiB
C
/*
|
||
* 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 |