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