[PATCH v4 02/11] x86/intel_pstate: add some calculation related support

[Wei Wang <wei.w.wang@intel.com>]

The added calculation related functions will be used in the intel_pstate.c.
They are copied from the Linux kernel(commit 2418f4f2, f3002134, eb18cba7).

v4 changes:
1) in commit message, "kernel" changed to "Linux kernel"
2) if-else coding style change.

Signed-off-by: Wei Wang <wei.w.wang@intel.com>
---
 xen/include/asm-x86/div64.h | 78 +++++++++++++++++++++++++++++++++++++++++++++
 xen/include/xen/kernel.h    | 12 +++++++
 2 files changed, 90 insertions(+)

diff --git a/xen/include/asm-x86/div64.h b/xen/include/asm-x86/div64.h
index dd49f64..1f171ba 100644
--- a/xen/include/asm-x86/div64.h
+++ b/xen/include/asm-x86/div64.h
@@ -11,4 +11,82 @@
     __rem;                                      \
 })
 
+static inline uint64_t div_u64_rem(uint64_t dividend, uint32_t divisor,
+                                      uint32_t *remainder)
+{
+    *remainder = do_div(dividend, divisor);
+    return dividend;
+}
+
+static inline uint64_t div_u64(uint64_t dividend, uint32_t  divisor)
+{
+    uint32_t 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 uint64_t div64_u64(uint64_t dividend, uint64_t divisor)
+{
+    uint32_t high = divisor >> 32;
+    uint64_t 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 int64_t div_s64_rem(int64_t dividend, int32_t divisor,
+                                     int32_t *remainder)
+{
+    int64_t quotient;
+
+    if (dividend < 0)
+    {
+        quotient = div_u64_rem(-dividend, ABS(divisor),
+                        (uint32_t *)remainder);
+        *remainder = -*remainder;
+        if (divisor > 0)
+            quotient = -quotient;
+    }
+    else
+    {
+        quotient = div_u64_rem(dividend, ABS(divisor),
+                        (uint32_t *)remainder);
+        if (divisor < 0)
+            quotient = -quotient;
+    }
+    return quotient;
+}
+
+/*
+ * div_s64 - signed 64bit divide with 32bit divisor
+ */
+static inline int64_t div_s64(int64_t dividend, int32_t divisor)
+{
+    int32_t 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..bfdcdb6 100644
--- a/xen/include/xen/kernel.h
+++ b/xen/include/xen/kernel.h
@@ -42,6 +42,18 @@
 #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)
+
 /**
  * container_of - cast a member of a structure out to the containing structure
  *
-- 
1.9.1