xref: /openbmc/linux/include/linux/math.h (revision 46f12960)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_MATH_H
3 #define _LINUX_MATH_H
4 
5 #include <linux/types.h>
6 #include <asm/div64.h>
7 #include <uapi/linux/kernel.h>
8 
9 /*
10  * This looks more complex than it should be. But we need to
11  * get the type for the ~ right in round_down (it needs to be
12  * as wide as the result!), and we want to evaluate the macro
13  * arguments just once each.
14  */
15 #define __round_mask(x, y) ((__typeof__(x))((y)-1))
16 
17 /**
18  * round_up - round up to next specified power of 2
19  * @x: the value to round
20  * @y: multiple to round up to (must be a power of 2)
21  *
22  * Rounds @x up to next multiple of @y (which must be a power of 2).
23  * To perform arbitrary rounding up, use roundup() below.
24  */
25 #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
26 
27 /**
28  * round_down - round down to next specified power of 2
29  * @x: the value to round
30  * @y: multiple to round down to (must be a power of 2)
31  *
32  * Rounds @x down to next multiple of @y (which must be a power of 2).
33  * To perform arbitrary rounding down, use rounddown() below.
34  */
35 #define round_down(x, y) ((x) & ~__round_mask(x, y))
36 
37 #define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP
38 
39 #define DIV_ROUND_DOWN_ULL(ll, d) \
40 	({ unsigned long long _tmp = (ll); do_div(_tmp, d); _tmp; })
41 
42 #define DIV_ROUND_UP_ULL(ll, d) \
43 	DIV_ROUND_DOWN_ULL((unsigned long long)(ll) + (d) - 1, (d))
44 
45 #if BITS_PER_LONG == 32
46 # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d)
47 #else
48 # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)
49 #endif
50 
51 /**
52  * roundup - round up to the next specified multiple
53  * @x: the value to up
54  * @y: multiple to round up to
55  *
56  * Rounds @x up to next multiple of @y. If @y will always be a power
57  * of 2, consider using the faster round_up().
58  */
59 #define roundup(x, y) (					\
60 {							\
61 	typeof(y) __y = y;				\
62 	(((x) + (__y - 1)) / __y) * __y;		\
63 }							\
64 )
65 /**
66  * rounddown - round down to next specified multiple
67  * @x: the value to round
68  * @y: multiple to round down to
69  *
70  * Rounds @x down to next multiple of @y. If @y will always be a power
71  * of 2, consider using the faster round_down().
72  */
73 #define rounddown(x, y) (				\
74 {							\
75 	typeof(x) __x = (x);				\
76 	__x - (__x % (y));				\
77 }							\
78 )
79 
80 /*
81  * Divide positive or negative dividend by positive or negative divisor
82  * and round to closest integer. Result is undefined for negative
83  * divisors if the dividend variable type is unsigned and for negative
84  * dividends if the divisor variable type is unsigned.
85  */
86 #define DIV_ROUND_CLOSEST(x, divisor)(			\
87 {							\
88 	typeof(x) __x = x;				\
89 	typeof(divisor) __d = divisor;			\
90 	(((typeof(x))-1) > 0 ||				\
91 	 ((typeof(divisor))-1) > 0 ||			\
92 	 (((__x) > 0) == ((__d) > 0))) ?		\
93 		(((__x) + ((__d) / 2)) / (__d)) :	\
94 		(((__x) - ((__d) / 2)) / (__d));	\
95 }							\
96 )
97 /*
98  * Same as above but for u64 dividends. divisor must be a 32-bit
99  * number.
100  */
101 #define DIV_ROUND_CLOSEST_ULL(x, divisor)(		\
102 {							\
103 	typeof(divisor) __d = divisor;			\
104 	unsigned long long _tmp = (x) + (__d) / 2;	\
105 	do_div(_tmp, __d);				\
106 	_tmp;						\
107 }							\
108 )
109 
110 #define __STRUCT_FRACT(type)				\
111 struct type##_fract {					\
112 	__##type numerator;				\
113 	__##type denominator;				\
114 };
115 __STRUCT_FRACT(s16)
__STRUCT_FRACT(u16)116 __STRUCT_FRACT(u16)
117 __STRUCT_FRACT(s32)
118 __STRUCT_FRACT(u32)
119 #undef __STRUCT_FRACT
120 
121 /* Calculate "x * n / d" without unnecessary overflow or loss of precision. */
122 #define mult_frac(x, n, d)	\
123 ({				\
124 	typeof(x) x_ = (x);	\
125 	typeof(n) n_ = (n);	\
126 	typeof(d) d_ = (d);	\
127 				\
128 	typeof(x_) q = x_ / d_;	\
129 	typeof(x_) r = x_ % d_;	\
130 	q * n_ + r * n_ / d_;	\
131 })
132 
133 #define sector_div(a, b) do_div(a, b)
134 
135 /**
136  * abs - return absolute value of an argument
137  * @x: the value.  If it is unsigned type, it is converted to signed type first.
138  *     char is treated as if it was signed (regardless of whether it really is)
139  *     but the macro's return type is preserved as char.
140  *
141  * Return: an absolute value of x.
142  */
143 #define abs(x)	__abs_choose_expr(x, long long,				\
144 		__abs_choose_expr(x, long,				\
145 		__abs_choose_expr(x, int,				\
146 		__abs_choose_expr(x, short,				\
147 		__abs_choose_expr(x, char,				\
148 		__builtin_choose_expr(					\
149 			__builtin_types_compatible_p(typeof(x), char),	\
150 			(char)({ signed char __x = (x); __x<0?-__x:__x; }), \
151 			((void)0)))))))
152 
153 #define __abs_choose_expr(x, type, other) __builtin_choose_expr(	\
154 	__builtin_types_compatible_p(typeof(x),   signed type) ||	\
155 	__builtin_types_compatible_p(typeof(x), unsigned type),		\
156 	({ signed type __x = (x); __x < 0 ? -__x : __x; }), other)
157 
158 /**
159  * abs_diff - return absolute value of the difference between the arguments
160  * @a: the first argument
161  * @b: the second argument
162  *
163  * @a and @b have to be of the same type. With this restriction we compare
164  * signed to signed and unsigned to unsigned. The result is the subtraction
165  * the smaller of the two from the bigger, hence result is always a positive
166  * value.
167  *
168  * Return: an absolute value of the difference between the @a and @b.
169  */
170 #define abs_diff(a, b) ({			\
171 	typeof(a) __a = (a);			\
172 	typeof(b) __b = (b);			\
173 	(void)(&__a == &__b);			\
174 	__a > __b ? (__a - __b) : (__b - __a);	\
175 })
176 
177 /**
178  * reciprocal_scale - "scale" a value into range [0, ep_ro)
179  * @val: value
180  * @ep_ro: right open interval endpoint
181  *
182  * Perform a "reciprocal multiplication" in order to "scale" a value into
183  * range [0, @ep_ro), where the upper interval endpoint is right-open.
184  * This is useful, e.g. for accessing a index of an array containing
185  * @ep_ro elements, for example. Think of it as sort of modulus, only that
186  * the result isn't that of modulo. ;) Note that if initial input is a
187  * small value, then result will return 0.
188  *
189  * Return: a result based on @val in interval [0, @ep_ro).
190  */
191 static inline u32 reciprocal_scale(u32 val, u32 ep_ro)
192 {
193 	return (u32)(((u64) val * ep_ro) >> 32);
194 }
195 
196 u64 int_pow(u64 base, unsigned int exp);
197 unsigned long int_sqrt(unsigned long);
198 
199 #if BITS_PER_LONG < 64
200 u32 int_sqrt64(u64 x);
201 #else
int_sqrt64(u64 x)202 static inline u32 int_sqrt64(u64 x)
203 {
204 	return (u32)int_sqrt(x);
205 }
206 #endif
207 
208 #endif	/* _LINUX_MATH_H */
209