[Xen-devel] [PATCH v2 2/9] x86/intel_pstate: add some calculation related support

[Wei Wang <wei.w.wang@xxxxxxxxx>]

The added calculation related functions will be used in the intel_pstate.c.

Signed-off-by: Wei Wang <wei.w.wang@xxxxxxxxx>
---
 xen/include/asm-x86/div64.h | 68 +++++++++++++++++++++++++++++++++++++++++++++
 xen/include/xen/kernel.h    | 30 ++++++++++++++++++++
 2 files changed, 98 insertions(+)

diff --git a/xen/include/asm-x86/div64.h b/xen/include/asm-x86/div64.h
index dd49f64..10f1009 100644
--- a/xen/include/asm-x86/div64.h
+++ b/xen/include/asm-x86/div64.h
@@ -11,4 +11,72 @@
     __rem;                                      \
 })
 
+static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
+{
+    *remainder = do_div(dividend, divisor);
+    return dividend;
+}
+
+static inline u64 div_u64(u64 dividend, u32 divisor)
+{
+    u32 remainder;
+    return div_u64_rem(dividend, divisor, &remainder);
+}
+
+/*
+ * div64_u64 - unsigned 64bit divide with 64bit divisor
+ * @dividend:    64bit dividend
+ * @divisor:    64bit divisor
+ *
+ * This implementation is a modified version of the algorithm proposed
+ * by the book 'Hacker's Delight'.  The original source and full proof
+ * can be found here and is available for use without restriction.
+ *
+ * 'http://www.hackersdelight.org/HDcode/newCode/divDouble.c.txt'
+ */
+static inline u64 div64_u64(u64 dividend, u64 divisor) {
+    u32 high = divisor >> 32;
+    u64 quot;
+
+    if (high == 0) {
+        quot = div_u64(dividend, divisor);
+    } else {
+        int n = 1 + fls(high);
+        quot = div_u64(dividend >> n, divisor >> n);
+
+        if (quot != 0)
+            quot--;
+        if ((dividend - quot * divisor) >= divisor)
+            quot++;
+    }
+    return quot;
+}
+
+static inline s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder) {
+    u64 quotient;
+
+    if (dividend < 0) {
+        quotient = div_u64_rem(-dividend, abs(divisor),
+                        (u32 *)remainder);
+        *remainder = -*remainder;
+        if (divisor > 0)
+            quotient = -quotient;
+    } else {
+        quotient = div_u64_rem(dividend, abs(divisor),
+                        (u32 *)remainder);
+        if (divisor < 0)
+            quotient = -quotient;
+    }
+    return quotient;
+}
+
+/*
+ * div_s64 - signed 64bit divide with 32bit divisor
+ */
+static inline s64 div_s64(s64 dividend, s32 divisor)
+{
+    s32 remainder;
+    return div_s64_rem(dividend, divisor, &remainder);
+}
+
 #endif
diff --git a/xen/include/xen/kernel.h b/xen/include/xen/kernel.h
index 548b64d..cb0ce03 100644
--- a/xen/include/xen/kernel.h
+++ b/xen/include/xen/kernel.h
@@ -42,6 +42,36 @@
 #define MIN(x,y) ((x) < (y) ? (x) : (y))
 #define MAX(x,y) ((x) > (y) ? (x) : (y))
 
+/*
+ * clamp_t - return a value clamped to a given range using a given type
+ * @type: the type of variable to use
+ * @val: current value
+ * @lo: minimum allowable value
+ * @hi: maximum allowable value
+ *
+ * This macro does no typechecking and uses temporary variables of type
+ * 'type' to make all the comparisons.
+ */
+#define clamp_t(type, val, lo, hi) min_t(type, max_t(type, val, lo), hi)
+
+/*
+ * abs() handles unsigned and signed longs, ints, shorts and chars. For all
+ * input types abs() returns a signed long.
+ * abs() should not be used for 64-bit types (s64, u64, long long) - use 
abs64()
+ * for those.
+ */
+#define abs(x) ({                      \
+    long ret;                          \
+    if (sizeof(x) == sizeof(long)) {   \
+        long __x = (x);                \
+        ret = (__x < 0) ? -__x : __x;  \
+    } else {                           \
+        int __x = (x);                 \
+        ret = (__x < 0) ? -__x : __x;  \
+    }                                  \
+    ret;                               \
+})
+
 /**
  * container_of - cast a member of a structure out to the containing structure
  *
-- 
1.9.1


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
http://lists.xen.org/xen-devel