Merge LinuxKPI changes from DragonflyBSD:

- Reimplement math64 header file to distinguish more from Linux.

Sponsored by:	Mellanox Technologies

1 files changed, 17 insertions, 96 deletions

diff --git a/sys/ofed/include/linux/math64.h b/sys/ofed/include/linux/math64.h
index cc3d946..a898f37 100644
--- a/sys/ofed/include/linux/math64.h
+++ b/sys/ofed/include/linux/math64.h
@@ -1,6 +1,6 @@
 /*-
  * Copyright (c) 2007 Cisco Systems, Inc.  All rights reserved.
- * Copyright (c) 2014 Mellanox Technologies, Ltd. All rights reserved.
+ * Copyright (c) 2014-2015 Mellanox Technologies, Ltd. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -26,108 +26,29 @@
  */
 
 #ifndef _LINUX_MATH64_H
-#define _LINUX_MATH64_H
+#define	_LINUX_MATH64_H
 
-#include <linux/types.h>
-#include <linux/bitops.h>
+#include <sys/stdint.h>
 
-#if BITS_PER_LONG == 64
- 
-# define do_div(n, base) ({                                    \
-	uint32_t __base = (base);                               \
-	uint32_t __rem;                                         \
-	__rem = ((uint64_t)(n)) % __base;                       \
-	(n) = ((uint64_t)(n)) / __base;                         \
-	__rem;                                                  \
+#define	do_div(n, base) ({			\
+	uint32_t __base = (base);		\
+	uint32_t __rem;				\
+	__rem = ((uint64_t)(n)) % __base;	\
+	(n) = ((uint64_t)(n)) / __base;		\
+	__rem;					\
 })
 
-/**
-* div_u64_rem - unsigned 64bit divide with 32bit divisor with remainder
-*
-* This is commonly provided by 32bit archs to provide an optimized 64bit
-* divide.
-*/
-static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
+static inline uint64_t
+div_u64_rem(uint64_t dividend, uint32_t divisor, uint32_t *remainder)
 {
-        *remainder = dividend % divisor;
-        return dividend / divisor;
+	*remainder = dividend % divisor;
+	return (dividend / divisor);
 }
 
-
-#elif BITS_PER_LONG == 32
-
-static uint32_t __div64_32(uint64_t *n, uint32_t base)
-{
-	uint64_t rem = *n;
-	uint64_t b = base;
-	uint64_t res, d = 1;
-	uint32_t high = rem >> 32;
-
-	/* Reduce the thing a bit first */
-	res = 0;
-	if (high >= base) {
-		high /= base;
-		res = (uint64_t) high << 32;
-		rem -= (uint64_t) (high*base) << 32;
-	}
-
-	while ((int64_t)b > 0 && b < rem) {
-		b = b+b;
-		d = d+d;
-	}
-
-	do {
-		if (rem >= b) {
-			rem -= b;
-			res += d;
-		}
-		b >>= 1;
-		d >>= 1;
-	} while (d);
-
-	*n = res;
-	return rem;
-}
- 
-# define do_div(n, base) ({                            \
-	uint32_t __base = (base);                       \
-	uint32_t __rem;                                 \
-	(void)(((typeof((n)) *)0) == ((uint64_t *)0));  \
-	if (likely(((n) >> 32) == 0)) {                 \
-		__rem = (uint32_t)(n) % __base;         \
-		(n) = (uint32_t)(n) / __base;           \
-	} else                                          \
-		__rem = __div64_32(&(n), __base);       \
-	__rem;                                          \
-})
-
-#ifndef div_u64_rem
-static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
-{
-        *remainder = do_div(dividend, divisor);
-        return dividend;
-}
-#endif
- 
-
-#endif /* BITS_PER_LONG */
-
-
-
-/**
- ** div_u64 - unsigned 64bit divide with 32bit divisor
- **
- ** This is the most common 64bit divide and should be used if possible,
- ** as many 32bit archs can optimize this variant better than a full 64bit
- ** divide.
- *  */
-#ifndef div_u64
-
-static inline u64 div_u64(u64 dividend, u32 divisor)
+static inline uint64_t
+div_u64(uint64_t dividend, uint32_t divisor)
 {
-        u32 remainder;
-        return div_u64_rem(dividend, divisor, &remainder);
+	return (dividend / divisor);
 }
-#endif
 
-#endif	/* _LINUX_MATH64_H */
+#endif					/* _LINUX_MATH64_H */