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) |

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 |

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 |