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)				\
111struct 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 */
191static inline u32 reciprocal_scale(u32 val, u32 ep_ro)
192{
193	return (u32)(((u64) val * ep_ro) >> 32);
194}
195
196u64 int_pow(u64 base, unsigned int exp);
197unsigned long int_sqrt(unsigned long);
198
199#if BITS_PER_LONG < 64
200u32 int_sqrt64(u64 x);
201#else
202static inline u32 int_sqrt64(u64 x)
203{
204	return (u32)int_sqrt(x);
205}
206#endif
207
208#endif	/* _LINUX_MATH_H */
209