U-Boot has imported various utility macros from Linux scattering them to various places without consistency. In include/common.h are min, max, min3, max3, ARRAY_SIZE, ALIGN, container_of, DIV_ROUND_UP, etc. In include/linux/compat.h are min_t, max_t, round_up, round_down, etc. We also have duplicated defines of min_t in some *.c files. Moreover, we are suffering from too cluttered include/common.h. This commit moves various macros that originate in include/linux/kernel.h of Linux to their original position. Note: This commit simply moves the macros; the macros roundup, min, max, min2, max3, ARRAY_SIZE are different from those of Linux at this point. Signed-off-by: Masahiro Yamada <yamada.m@jp.panasonic.com>master
Masahiro Yamada
11 years ago
committed by
Tom Rini
parent
9e57a1c3ad
commit
cba1da495d
@ -0,0 +1,157 @@ |
||||
#ifndef _LINUX_KERNEL_H |
||||
#define _LINUX_KERNEL_H |
||||
|
||||
|
||||
#include <linux/types.h> |
||||
|
||||
#define INT_MAX ((int)(~0U>>1)) |
||||
#define INT_MIN (-INT_MAX - 1) |
||||
#define LLONG_MAX ((long long)(~0ULL>>1)) |
||||
|
||||
#define U8_MAX ((u8)~0U) |
||||
#define U32_MAX ((u32)~0U) |
||||
#define U64_MAX ((u64)~0ULL) |
||||
|
||||
#define ALIGN(x,a) __ALIGN_MASK((x),(typeof(x))(a)-1) |
||||
#define __ALIGN_MASK(x,mask) (((x)+(mask))&~(mask)) |
||||
|
||||
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) |
||||
|
||||
/*
|
||||
* This looks more complex than it should be. But we need to |
||||
* get the type for the ~ right in round_down (it needs to be |
||||
* as wide as the result!), and we want to evaluate the macro |
||||
* arguments just once each. |
||||
*/ |
||||
#define __round_mask(x, y) ((__typeof__(x))((y)-1)) |
||||
#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1) |
||||
#define round_down(x, y) ((x) & ~__round_mask(x, y)) |
||||
|
||||
#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d)) |
||||
|
||||
#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y)) |
||||
|
||||
/*
|
||||
* Divide positive or negative dividend by positive divisor and round |
||||
* to closest integer. Result is undefined for negative divisors and |
||||
* for negative dividends if the divisor variable type is unsigned. |
||||
*/ |
||||
#define DIV_ROUND_CLOSEST(x, divisor)( \ |
||||
{ \
|
||||
typeof(x) __x = x; \
|
||||
typeof(divisor) __d = divisor; \
|
||||
(((typeof(x))-1) > 0 || \
|
||||
((typeof(divisor))-1) > 0 || (__x) > 0) ? \
|
||||
(((__x) + ((__d) / 2)) / (__d)) : \
|
||||
(((__x) - ((__d) / 2)) / (__d)); \
|
||||
} \
|
||||
) |
||||
|
||||
/*
|
||||
* Multiplies an integer by a fraction, while avoiding unnecessary |
||||
* overflow or loss of precision. |
||||
*/ |
||||
#define mult_frac(x, numer, denom)( \ |
||||
{ \
|
||||
typeof(x) quot = (x) / (denom); \
|
||||
typeof(x) rem = (x) % (denom); \
|
||||
(quot * (numer)) + ((rem * (numer)) / (denom)); \
|
||||
} \
|
||||
) |
||||
|
||||
/**
|
||||
* 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. |
||||
*/ |
||||
#define upper_32_bits(n) ((u32)(((n) >> 16) >> 16)) |
||||
|
||||
/**
|
||||
* lower_32_bits - return bits 0-31 of a number |
||||
* @n: the number we're accessing |
||||
*/ |
||||
#define lower_32_bits(n) ((u32)(n)) |
||||
|
||||
/*
|
||||
* abs() handles unsigned and signed longs, ints, shorts and chars. For all |
||||
* input types abs() returns a signed long. |
||||
* abs() should not be used for 64-bit types (s64, u64, long long) - use abs64() |
||||
* for those. |
||||
*/ |
||||
#define abs(x) ({ \ |
||||
long ret; \
|
||||
if (sizeof(x) == sizeof(long)) { \
|
||||
long __x = (x); \
|
||||
ret = (__x < 0) ? -__x : __x; \
|
||||
} else { \
|
||||
int __x = (x); \
|
||||
ret = (__x < 0) ? -__x : __x; \
|
||||
} \
|
||||
ret; \
|
||||
}) |
||||
|
||||
#define abs64(x) ({ \ |
||||
s64 __x = (x); \
|
||||
(__x < 0) ? -__x : __x; \
|
||||
}) |
||||
|
||||
/*
|
||||
* min()/max()/clamp() macros that also do |
||||
* strict type-checking.. See the |
||||
* "unnecessary" pointer comparison. |
||||
*/ |
||||
#define min(x, y) ({ \ |
||||
typeof(x) _min1 = (x); \
|
||||
typeof(y) _min2 = (y); \
|
||||
_min1 < _min2 ? _min1 : _min2; }) |
||||
|
||||
#define max(x, y) ({ \ |
||||
typeof(x) _max1 = (x); \
|
||||
typeof(y) _max2 = (y); \
|
||||
_max1 > _max2 ? _max1 : _max2; }) |
||||
|
||||
#define min3(x, y, z) ({ \ |
||||
typeof(x) _min1 = (x); \
|
||||
typeof(y) _min2 = (y); \
|
||||
typeof(z) _min3 = (z); \
|
||||
_min1 < _min2 ? (_min1 < _min3 ? _min1 : _min3) : \
|
||||
(_min2 < _min3 ? _min2 : _min3); }) |
||||
|
||||
#define max3(x, y, z) ({ \ |
||||
typeof(x) _max1 = (x); \
|
||||
typeof(y) _max2 = (y); \
|
||||
typeof(z) _max3 = (z); \
|
||||
_max1 > _max2 ? (_max1 > _max3 ? _max1 : _max3) : \
|
||||
(_max2 > _max3 ? _max2 : _max3); }) |
||||
|
||||
/*
|
||||
* ..and if you can't take the strict |
||||
* types, you can specify one yourself. |
||||
* |
||||
* Or not use min/max/clamp at all, of course. |
||||
*/ |
||||
#define min_t(type, x, y) ({ \ |
||||
type __min1 = (x); \
|
||||
type __min2 = (y); \
|
||||
__min1 < __min2 ? __min1: __min2; }) |
||||
|
||||
#define max_t(type, x, y) ({ \ |
||||
type __max1 = (x); \
|
||||
type __max2 = (y); \
|
||||
__max1 > __max2 ? __max1: __max2; }) |
||||
|
||||
/**
|
||||
* container_of - cast a member of a structure out to the containing structure |
||||
* @ptr: the pointer to the member. |
||||
* @type: the type of the container struct this is embedded in. |
||||
* @member: the name of the member within the struct. |
||||
* |
||||
*/ |
||||
#define container_of(ptr, type, member) ({ \ |
||||
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
|
||||
(type *)( (char *)__mptr - offsetof(type,member) );}) |
||||
|
||||
#endif |
||||
Loading…
Reference in new issue