include: move various macros to include/linux/kernel.h
authorMasahiro Yamada <yamada.m@jp.panasonic.com>
Thu, 6 Nov 2014 18:03:28 +0000 (03:03 +0900)
committerTom Rini <trini@ti.com>
Thu, 20 Nov 2014 16:28:25 +0000 (11:28 -0500)
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>
15 files changed:
arch/arm/cpu/armv7/bcm281xx/clk-core.h
arch/mips/cpu/mips32/au1x00/au1x00_usb_ohci.c
arch/powerpc/cpu/mpc5xxx/usb_ohci.c
arch/powerpc/cpu/ppc4xx/usb_ohci.c
drivers/usb/host/isp116x-hcd.c
drivers/usb/host/ohci-hcd.c
drivers/usb/host/ohci-s3c24xx.c
drivers/usb/host/r8a66597-hcd.c
drivers/usb/musb/musb_hcd.h
drivers/video/ati_radeon_fb.c
fs/ubifs/ubifs.h
include/common.h
include/linux/compat.h
include/linux/kernel.h [new file with mode: 0644]
lib/vsprintf.c

index 882a2977979c7fd87c09fe1866731a38da0a663f..4a694d7fe782267b0cd0b32df4004636827a7b0c 100644 (file)
@@ -73,10 +73,6 @@ struct clk {
 
 struct refclk *refclk_str_to_clk(const char *name);
 
-#define U8_MAX ((u8)~0U)
-#define U32_MAX        ((u32)~0U)
-#define U64_MAX        ((u64)~0U)
-
 /* The common clock framework uses u8 to represent a parent index */
 #define PARENT_COUNT_MAX       ((u32)U8_MAX)
 
index a3dac70798d999de87da3d7851fabea03750a449..74bdb773032f10bac9a19d8d649f628436a919b7 100644 (file)
@@ -54,8 +54,6 @@
 #define readl(a)     au_readl((long)(a))
 #define writel(v,a)  au_writel((v),(int)(a))
 
-#define min_t(type,x,y) ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
-
 #define DEBUG
 #ifdef DEBUG
 #define dbg(format, arg...) printf("DEBUG: " format "\n", ## arg)
index 3c8b2d904fef6942874551516b385808c8de83f1..b7c1b5594a003a4c7b28f98ec3db67d48d199061 100644 (file)
@@ -42,8 +42,6 @@
 #define readl(a) (*((volatile u32 *)(a)))
 #define writel(a, b) (*((volatile u32 *)(b)) = ((volatile u32)a))
 
-#define min_t(type,x,y) ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
-
 #ifdef DEBUG
 #define dbg(format, arg...) printf("DEBUG: " format "\n", ## arg)
 #else
index d1e78f6b0c3c78901d45fe43faef782c604f1d91..65a0675446e5bf41030d80e8dea1c1c2e18f76c5 100644 (file)
@@ -40,8 +40,6 @@
 #define readl(a) (*((volatile u32 *)(a)))
 #define writel(a, b) (*((volatile u32 *)(b)) = ((volatile u32)a))
 
-#define min_t(type,x,y) ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
-
 #ifdef DEBUG
 #define dbg(format, arg...) printf("DEBUG: " format "\n", ## arg)
 #else
index 46e4cee1d04c9dd3af28bdaa09b121f11e056719..0556f328e459b7d23b95b20a260b56c0a74ad33a 100644 (file)
@@ -103,12 +103,6 @@ static int rh_devnum;              /* address of Root Hub endpoint */
 
 /* ------------------------------------------------------------------------- */
 
-#define ALIGN(x,a)     (((x)+(a)-1UL)&~((a)-1UL))
-#define min_t(type,x,y)        \
-       ({ type __x = (x); type __y = (y); __x < __y ? __x : __y; })
-
-/* ------------------------------------------------------------------------- */
-
 static int isp116x_reset(struct isp116x *isp116x);
 
 /* --- Debugging functions ------------------------------------------------- */
index 2ab28a4bdb097049f2d97a7e241cca394055d474..97a7edeb53998713985a626faac565779d89b985 100644 (file)
@@ -65,9 +65,6 @@
 #define OHCI_CONTROL_INIT \
        (OHCI_CTRL_CBSR & 0x3) | OHCI_CTRL_IE | OHCI_CTRL_PLE
 
-#define min_t(type, x, y) \
-                   ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
-
 #ifdef CONFIG_PCI_OHCI
 static struct pci_device_id ohci_pci_ids[] = {
        {0x10b9, 0x5237},       /* ULI1575 PCI OHCI module ids */
index 3c659c60c97a5893309c3861ff75a06d1aefa2a8..8bb2275c09473a6e9a8e15486ea44e9849d05633 100644 (file)
@@ -35,9 +35,6 @@
 #define        OHCI_CONTROL_INIT \
        (OHCI_CTRL_CBSR & 0x3) | OHCI_CTRL_IE | OHCI_CTRL_PLE
 
-#define min_t(type, x, y) \
-       ({ type __x = (x); type __y = (y); __x < __y ? __x : __y; })
-
 #undef DEBUG
 #ifdef DEBUG
 #define dbg(format, arg...) printf("DEBUG: " format "\n", ## arg)
index 511454479b109d3f303116e910b6d6722582d0bf..6f33456c90d0130fe6be40e2265bf21954a6e050 100644 (file)
@@ -550,9 +550,6 @@ static int check_usb_device_connecting(struct r8a66597 *r8a66597)
        return -1;      /* fail */
 }
 
-/* based on usb_ohci.c */
-#define min_t(type, x, y) \
-               ({ type __x = (x); type __y = (y); __x < __y ? __x : __y; })
 /*-------------------------------------------------------------------------*
  * Virtual Root Hub
  *-------------------------------------------------------------------------*/
index 02b9adcbe4efb8d813654741de318b4bc7c31e0d..0c8e75d46c1e0b1a493eefe2807ac9173b874dcc 100644 (file)
@@ -37,9 +37,6 @@ extern unsigned char new[];
        ((readb(&musbr->power) & MUSB_POWER_HSMODE) \
                >> MUSB_POWER_HSMODE_SHIFT)
 
-#define min_t(type, x, y)      \
-       ({ type __x = (x); type __y = (y); __x < __y ? __x : __y; })
-
 /* USB HUB CONSTANTS (not OHCI-specific; see hub.h) */
 
 /* destination of request */
index 38d2eb107ecd15c2d245968da5b920e551842492..618f5d93b6d1df89d090579a02973f317e34f8cf 100644 (file)
 #define DPRINT(x...) do{}while(0)
 #endif
 
-#ifndef min_t
-#define min_t(type,x,y) \
-       ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
-#endif
-
 #define MAX_MAPPED_VRAM        (2048*2048*4)
 #define MIN_MAPPED_VRAM        (1024*768*1)
 
index 0ce2475e0b8e9a9c95650837d20fef9adbc5415b..c12026147fc5635512482a8814abc43e17448d78 100644 (file)
@@ -476,10 +476,6 @@ struct file {
 #define MAX_LFS_FILESIZE       0x7fffffffffffffffUL
 #endif
 
-#define INT_MAX                ((int)(~0U>>1))
-#define INT_MIN                (-INT_MAX - 1)
-#define LLONG_MAX      ((long long)(~0ULL>>1))
-
 /*
  * These are the fs-independent mount-flags: up to 32 flags are supported
  */
index c9fe38656edcd61981e406c1aaad8999fded1bd9..c1bdaeccaa48800fcff919fe9a4cc599dcceb2de 100644 (file)
@@ -23,6 +23,7 @@ typedef volatile unsigned char        vu_char;
 #include <linux/stringify.h>
 #include <asm/ptrace.h>
 #include <stdarg.h>
+#include <linux/kernel.h>
 #if defined(CONFIG_PCI) && defined(CONFIG_4xx)
 #include <pci.h>
 #endif
@@ -168,58 +169,6 @@ typedef void (interrupt_handler_t)(void *);
 # endif
 #endif
 
-/*
- * General Purpose Utilities
- */
-#define min(X, Y)                              \
-       ({ typeof(X) __x = (X);                 \
-               typeof(Y) __y = (Y);            \
-               (__x < __y) ? __x : __y; })
-
-#define max(X, Y)                              \
-       ({ typeof(X) __x = (X);                 \
-               typeof(Y) __y = (Y);            \
-               (__x > __y) ? __x : __y; })
-
-#define min3(X, Y, Z)                          \
-       ({ typeof(X) __x = (X);                 \
-               typeof(Y) __y = (Y);            \
-               typeof(Z) __z = (Z);            \
-               __x < __y ? (__x < __z ? __x : __z) :   \
-               (__y < __z ? __y : __z); })
-
-#define max3(X, Y, Z)                          \
-       ({ typeof(X) __x = (X);                 \
-               typeof(Y) __y = (Y);            \
-               typeof(Z) __z = (Z);            \
-               __x > __y ? (__x > __z ? __x : __z) :   \
-               (__y > __z ? __y : __z); })
-
-/*
- * Return the absolute value of a number.
- *
- * This handles unsigned and signed longs, ints, shorts and chars.  For all
- * input types abs() returns a signed long.
- *
- * For 64-bit types, use abs64()
- */
-#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;         \
-       })
-
 #if defined(CONFIG_ENV_IS_EMBEDDED)
 #define TOTAL_MALLOC_LEN       CONFIG_SYS_MALLOC_LEN
 #elif ( ((CONFIG_ENV_ADDR+CONFIG_ENV_SIZE) < CONFIG_SYS_MONITOR_BASE) || \
@@ -230,17 +179,6 @@ typedef void (interrupt_handler_t)(void *);
 #define        TOTAL_MALLOC_LEN        CONFIG_SYS_MALLOC_LEN
 #endif
 
-/**
- * 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) );})
-
 /*
  * Function Prototypes
  */
@@ -947,30 +885,7 @@ static inline phys_addr_t map_to_sysmem(const void *ptr)
 #error Read section CONFIG_SKIP_LOWLEVEL_INIT in README.
 #endif
 
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
-
 #define ROUND(a,b)             (((a) + (b) - 1) & ~((b) - 1))
-#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));        \
-}                                                      \
-)
-
-#define ALIGN(x,a)             __ALIGN_MASK((x),(typeof(x))(a)-1)
-#define __ALIGN_MASK(x,mask)   (((x)+(mask))&~(mask))
 
 /*
  * ARCH_DMA_MINALIGN is defined in asm/cache.h for each architecture.  It
index 7ff6064b187b7b914f27ac8f5e7004a014037130..47b088973944404ba9e432308f1bcdb14d7a82b9 100644 (file)
@@ -57,17 +57,6 @@ void *kmem_cache_alloc(struct kmem_cache *obj, int flag);
 
 #define KERNEL_VERSION(a,b,c)  (((a) << 16) + ((b) << 8) + (c))
 
-/*
- * ..and if you can't take the strict
- * types, you can specify one yourself.
- *
- * Or not use min/max at all, of course.
- */
-#define min_t(type,x,y) \
-       ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
-#define max_t(type,x,y) \
-       ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
-
 #ifndef BUG
 #define BUG() do { \
        printf("U-Boot BUG at %s:%d!\n", __FILE__, __LINE__); \
@@ -81,24 +70,6 @@ void *kmem_cache_alloc(struct kmem_cache *obj, int flag);
 
 #define PAGE_SIZE      4096
 
-/**
- * upper_32_bits - return MSB bits 32-63 of a number if little endian, or
- * return MSB bits 0-31 of a number if big endian.
- * @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 LSB bits 0-31 of a number if little endian, or
- * return LSB bits 32-63 of a number if big endian.
- * @n: the number we're accessing
- */
-#define lower_32_bits(n) ((u32)(n))
-
 /* drivers/char/random.c */
 #define get_random_bytes(...)
 
@@ -152,17 +123,6 @@ typedef unsigned long blkcnt_t;
 
 #define ENOTSUPP       524     /* Operation is not supported */
 
-/* from include/linux/kernel.h */
-/*
- * 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))
-
 /* module */
 #define THIS_MODULE            0
 #define try_module_get(...)    1
@@ -198,18 +158,6 @@ typedef unsigned long blkcnt_t;
 
 #define blocking_notifier_call_chain(...) 0
 
-/*
- * 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)); \
-}                                                      \
-)
-
 #define __initdata
 #define late_initcall(...)
 
@@ -267,8 +215,6 @@ typedef int wait_queue_head_t;
 #define cond_resched()                 do { } while (0)
 #define yield()                                do { } while (0)
 
-#define INT_MAX                                ((int)(~0U>>1))
-
 #define __user
 #define __init
 #define __exit
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
new file mode 100644 (file)
index 0000000..527ed40
--- /dev/null
@@ -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
index b585713b7c55c78a598b165e547352ba7719c182..d84c9f51129309f76be5e8f97aa7c56ff9d0feb3 100644 (file)
@@ -25,9 +25,6 @@
 #include <div64.h>
 #define noinline __attribute__((noinline))
 
-/* some reluctance to put this into a new limits.h, so it is here */
-#define INT_MAX                ((int)(~0U>>1))
-
 unsigned long simple_strtoul(const char *cp, char **endp,
                                unsigned int base)
 {