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 /** 38 * DIV_ROUND_UP_POW2 - divide and round up 39 * @n: numerator 40 * @d: denominator (must be a power of 2) 41 * 42 * Divides @n by @d and rounds up to next multiple of @d (which must be a power 43 * of 2). Avoids integer overflows that may occur with __KERNEL_DIV_ROUND_UP(). 44 * Performance is roughly equivalent to __KERNEL_DIV_ROUND_UP(). 45 */ 46 #define DIV_ROUND_UP_POW2(n, d) \ 47 ((n) / (d) + !!((n) & ((d) - 1))) 48 49 #define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP 50 51 #define DIV_ROUND_DOWN_ULL(ll, d) \ 52 ({ unsigned long long _tmp = (ll); do_div(_tmp, d); _tmp; }) 53 54 #define DIV_ROUND_UP_ULL(ll, d) \ 55 DIV_ROUND_DOWN_ULL((unsigned long long)(ll) + (d) - 1, (d)) 56 57 #if BITS_PER_LONG == 32 58 # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d) 59 #else 60 # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d) 61 #endif 62 63 /** 64 * roundup - round up to the next specified multiple 65 * @x: the value to up 66 * @y: multiple to round up to 67 * 68 * Rounds @x up to next multiple of @y. If @y will always be a power 69 * of 2, consider using the faster round_up(). 70 */ 71 #define roundup(x, y) ( \ 72 { \ 73 typeof(y) __y = y; \ 74 (((x) + (__y - 1)) / __y) * __y; \ 75 } \ 76 ) 77 /** 78 * rounddown - round down to next specified multiple 79 * @x: the value to round 80 * @y: multiple to round down to 81 * 82 * Rounds @x down to next multiple of @y. If @y will always be a power 83 * of 2, consider using the faster round_down(). 84 */ 85 #define rounddown(x, y) ( \ 86 { \ 87 typeof(x) __x = (x); \ 88 __x - (__x % (y)); \ 89 } \ 90 ) 91 92 #define DIV_ROUND_CLOSEST __KERNEL_DIV_ROUND_CLOSEST 93 /* 94 * Same as above but for u64 dividends. divisor must be a 32-bit 95 * number. 96 */ 97 #define DIV_ROUND_CLOSEST_ULL(x, divisor)( \ 98 { \ 99 typeof(divisor) __d = divisor; \ 100 unsigned long long _tmp = (x) + (__d) / 2; \ 101 do_div(_tmp, __d); \ 102 _tmp; \ 103 } \ 104 ) 105 106 #define __STRUCT_FRACT(type) \ 107 struct type##_fract { \ 108 __##type numerator; \ 109 __##type denominator; \ 110 }; 111 __STRUCT_FRACT(s8) 112 __STRUCT_FRACT(u8) 113 __STRUCT_FRACT(s16) 114 __STRUCT_FRACT(u16) 115 __STRUCT_FRACT(s32) 116 __STRUCT_FRACT(u32) 117 #undef __STRUCT_FRACT 118 119 /* Calculate "x * n / d" without unnecessary overflow or loss of precision. */ 120 #define mult_frac(x, n, d) \ 121 ({ \ 122 typeof(x) x_ = (x); \ 123 typeof(n) n_ = (n); \ 124 typeof(d) d_ = (d); \ 125 \ 126 typeof(x_) q = x_ / d_; \ 127 typeof(x_) r = x_ % d_; \ 128 q * n_ + r * n_ / d_; \ 129 }) 130 131 #define sector_div(a, b) do_div(a, b) 132 133 /** 134 * abs - return absolute value of an argument 135 * @x: the value. 136 * 137 * If it is unsigned type, @x 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 * NOTE, for signed type if @x is the minimum, the returned result is undefined 142 * as there is not enough bits to represent it as a positive number. 143 * 144 * Return: an absolute value of @x. 145 */ 146 #define abs(x) __abs_choose_expr(x, long long, \ 147 __abs_choose_expr(x, long, \ 148 __abs_choose_expr(x, int, \ 149 __abs_choose_expr(x, short, \ 150 __abs_choose_expr(x, char, \ 151 __builtin_choose_expr( \ 152 __builtin_types_compatible_p(typeof(x), char), \ 153 (char)({ signed char __x = (x); __x<0?-__x:__x; }), \ 154 ((void)0))))))) 155 156 #define __abs_choose_expr(x, type, other) __builtin_choose_expr( \ 157 __builtin_types_compatible_p(typeof(x), signed type) || \ 158 __builtin_types_compatible_p(typeof(x), unsigned type), \ 159 ({ signed type __x = (x); __x < 0 ? -__x : __x; }), other) 160 161 /** 162 * abs_diff - return absolute value of the difference between the arguments 163 * @a: the first argument 164 * @b: the second argument 165 * 166 * @a and @b have to be of the same type. With this restriction we compare 167 * signed to signed and unsigned to unsigned. The result is the subtraction 168 * the smaller of the two from the bigger, hence result is always a positive 169 * value. 170 * 171 * Return: an absolute value of the difference between the @a and @b. 172 */ 173 #define abs_diff(a, b) ({ \ 174 typeof(a) __a = (a); \ 175 typeof(b) __b = (b); \ 176 (void)(&__a == &__b); \ 177 __a > __b ? (__a - __b) : (__b - __a); \ 178 }) 179 180 /** 181 * reciprocal_scale - "scale" a value into range [0, ep_ro) 182 * @val: value 183 * @ep_ro: right open interval endpoint 184 * 185 * Perform a "reciprocal multiplication" in order to "scale" a value into 186 * range [0, @ep_ro), where the upper interval endpoint is right-open. 187 * This is useful, e.g. for accessing a index of an array containing 188 * @ep_ro elements, for example. Think of it as sort of modulus, only that 189 * the result isn't that of modulo. ;) Note that if initial input is a 190 * small value, then result will return 0. 191 * 192 * Return: a result based on @val in interval [0, @ep_ro). 193 */ 194 static inline u32 reciprocal_scale(u32 val, u32 ep_ro) 195 { 196 return (u32)(((u64) val * ep_ro) >> 32); 197 } 198 199 u64 int_pow(u64 base, unsigned int exp); 200 unsigned long int_sqrt(unsigned long); 201 202 #if BITS_PER_LONG < 64 203 u32 int_sqrt64(u64 x); 204 #else 205 static inline u32 int_sqrt64(u64 x) 206 { 207 return (u32)int_sqrt(x); 208 } 209 #endif 210 211 #endif /* _LINUX_MATH_H */ 212