/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_MATH_H
#define _LINUX_MATH_H

#include <linux/types.h>
#include <asm/div64.h>
#include <uapi/linux/kernel.h>

/*
 * This looks more complex than it should be. But we need to
 * get the type for the ~ right in round_down (it needs to be
 * as wide as the result!), and we want to evaluate the macro
 * arguments just once each.
 */
#define __round_mask(x, y) ((__typeof__(x))((y)-1))

/**
 * round_up - round up to next specified power of 2
 * @x: the value to round
 * @y: multiple to round up to (must be a power of 2)
 *
 * Rounds @x up to next multiple of @y (which must be a power of 2).
 * To perform arbitrary rounding up, use roundup() below.
 */
#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)

/**
 * round_down - round down to next specified power of 2
 * @x: the value to round
 * @y: multiple to round down to (must be a power of 2)
 *
 * Rounds @x down to next multiple of @y (which must be a power of 2).
 * To perform arbitrary rounding down, use rounddown() below.
 */
#define round_down(x, y) ((x) & ~__round_mask(x, y))

/**
 * DIV_ROUND_UP_POW2 - divide and round up
 * @n: numerator
 * @d: denominator (must be a power of 2)
 *
 * Divides @n by @d and rounds up to next multiple of @d (which must be a power
 * of 2). Avoids integer overflows that may occur with __KERNEL_DIV_ROUND_UP().
 * Performance is roughly equivalent to __KERNEL_DIV_ROUND_UP().
 */
#define DIV_ROUND_UP_POW2(n, d) \
 ((n) / (d) + !!((n) & ((d) - 1)))

#define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP

#define DIV_ROUND_DOWN_ULL(ll, d) \
 ({ unsigned long long _tmp = (ll); do_div(_tmp, d); _tmp; })

#define DIV_ROUND_UP_ULL(ll, d) \
 DIV_ROUND_DOWN_ULL((unsigned long long)(ll) + (d) - 1, (d))

#if BITS_PER_LONG == 32
# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d)
#else
# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)
#endif

/**
 * roundup - round up to the next specified multiple
 * @x: the value to up
 * @y: multiple to round up to
 *
 * Rounds @x up to next multiple of @y. If @y will always be a power
 * of 2, consider using the faster round_up().
 */
#define roundup(x, y) (     \
{       \
 typeof(y) __y = y;    \
 (((x) + (__y - 1)) / __y) * __y;  \
}       \
)
/**
 * rounddown - round down to next specified multiple
 * @x: the value to round
 * @y: multiple to round down to
 *
 * Rounds @x down to next multiple of @y. If @y will always be a power
 * of 2, consider using the faster round_down().
 */
#define rounddown(x, y) (    \
{       \
 typeof(x) __x = (x);    \
 __x - (__x % (y));    \
}       \
)

/*
 * Divide positive or negative dividend by positive or negative divisor
 * and round to closest integer. Result is undefined for negative
 * divisors if the dividend variable type is unsigned and for negative
 * dividends if the divisor variable type is unsigned.
 */
#define DIV_ROUND_CLOSEST(x, divisor)(   \
{       \
 typeof(x) __x = x;    \
 typeof(divisor) __d = divisor;   \
 (((typeof(x))-1) > 0 ||    \
  ((typeof(divisor))-1) > 0 ||   \
  (((__x) > 0) == ((__d) > 0))) ?  \
  (((__x) + ((__d) / 2)) / (__d)) : \
  (((__x) - ((__d) / 2)) / (__d)); \
}       \
)
/*
 * Same as above but for u64 dividends. divisor must be a 32-bit
 * number.
 */
#define DIV_ROUND_CLOSEST_ULL(x, divisor)(  \
{       \
 typeof(divisor) __d = divisor;   \
 unsigned long long _tmp = (x) + (__d) / 2; \
 do_div(_tmp, __d);    \
 _tmp;      \
}       \
)

#define __STRUCT_FRACT(type)    \
struct type##_fract {     \
 __##type numerator;    \
 __##type denominator;    \
};
__STRUCT_FRACT(s8)
__STRUCT_FRACT(u8)
__STRUCT_FRACT(s16)
__STRUCT_FRACT(u16)
__STRUCT_FRACT(s32)
__STRUCT_FRACT(u32)
#undef __STRUCT_FRACT

/* Calculate "x * n / d" without unnecessary overflow or loss of precision. */
#define mult_frac(x, n, d) \
({    \
 typeof(x) x_ = (x); \
 typeof(n) n_ = (n); \
 typeof(d) d_ = (d); \
    \
 typeof(x_) q = x_ / d_; \
 typeof(x_) r = x_ % d_; \
 q * n_ + r * n_ / d_; \
})

#define sector_div(a, b) do_div(a, b)

/**
 * abs - return absolute value of an argument
 * @x: the value.  If it is unsigned type, it is converted to signed type first.
 *     char is treated as if it was signed (regardless of whether it really is)
 *     but the macro's return type is preserved as char.
 *
 * Return: an absolute value of x.
 */
#define abs(x) __abs_choose_expr(x, long long,    \
  __abs_choose_expr(x, long,    \
  __abs_choose_expr(x, int,    \
  __abs_choose_expr(x, short,    \
  __abs_choose_expr(x, char,    \
  __builtin_choose_expr(     \
   __builtin_types_compatible_p(typeof(x), char), \
   (char)({ signed char __x = (x); __x<0?-__x:__x; }), \
   ((void)0)))))))

#define __abs_choose_expr(x, type, other) __builtin_choose_expr( \
 __builtin_types_compatible_p(typeof(x),   signed type) || \
 __builtin_types_compatible_p(typeof(x), unsigned type),  \
 ({ signed type __x = (x); __x < 0 ? -__x : __x; }), other)

/**
 * abs_diff - return absolute value of the difference between the arguments
 * @a: the first argument
 * @b: the second argument
 *
 * @a and @b have to be of the same type. With this restriction we compare
 * signed to signed and unsigned to unsigned. The result is the subtraction
 * the smaller of the two from the bigger, hence result is always a positive
 * value.
 *
 * Return: an absolute value of the difference between the @a and @b.
 */
#define abs_diff(a, b) ({   \
 typeof(a) __a = (a);   \
 typeof(b) __b = (b);   \
 (void)(&__a == &__b);   \
 __a > __b ? (__a - __b) : (__b - __a); \
})

/**
 * reciprocal_scale - "scale" a value into range [0, ep_ro)
 * @val: value
 * @ep_ro: right open interval endpoint
 *
 * Perform a "reciprocal multiplication" in order to "scale" a value into
 * range [0, @ep_ro), where the upper interval endpoint is right-open.
 * This is useful, e.g. for accessing a index of an array containing
 * @ep_ro elements, for example. Think of it as sort of modulus, only that
 * the result isn't that of modulo. ;) Note that if initial input is a
 * small value, then result will return 0.
 *
 * Return: a result based on @val in interval [0, @ep_ro).
 */
static inline u32 reciprocal_scale(u32 val, u32 ep_ro)
{
 return (u32)(((u64) val * ep_ro) >> 32);
}

u64 int_pow(u64 base, unsigned int exp);
unsigned long int_sqrt(unsigned long);

#if BITS_PER_LONG < 64
u32 int_sqrt64(u64 x);
#else
static inline u32 int_sqrt64(u64 x)
{
 return (u32)int_sqrt(x);
}
#endif

#endif /* _LINUX_MATH_H */