| 1 |
/* |
| 2 |
* Copyright 2009 Red Hat Inc. |
| 3 |
* |
| 4 |
* Permission is hereby granted, free of charge, to any person obtaining a |
| 5 |
* copy of this software and associated documentation files (the "Software"), |
| 6 |
* to deal in the Software without restriction, including without limitation |
| 7 |
* the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 8 |
* and/or sell copies of the Software, and to permit persons to whom the |
| 9 |
* Software is furnished to do so, subject to the following conditions: |
| 10 |
* |
| 11 |
* The above copyright notice and this permission notice shall be included in |
| 12 |
* all copies or substantial portions of the Software. |
| 13 |
* |
| 14 |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 15 |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 16 |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 17 |
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| 18 |
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| 19 |
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| 20 |
* OTHER DEALINGS IN THE SOFTWARE. |
| 21 |
* |
| 22 |
* Authors: Dave Airlie |
| 23 |
* Christian König |
| 24 |
*/ |
| 25 |
#ifndef DRM_FIXED_H |
| 26 |
#define DRM_FIXED_H |
| 27 |
|
| 28 |
#include <linux/math64.h> |
| 29 |
#include <linux/types.h> |
| 30 |
#include <linux/wordpart.h> |
| 31 |
|
| 32 |
typedef union dfixed { |
| 33 |
u32 full; |
| 34 |
} fixed20_12; |
| 35 |
|
| 36 |
|
| 37 |
#define dfixed_const(A) (u32)(((A) << 12))/* + ((B + 0.000122)*4096)) */ |
| 38 |
#define dfixed_const_half(A) (u32)(((A) << 12) + 2048) |
| 39 |
#define dfixed_const_666(A) (u32)(((A) << 12) + 2731) |
| 40 |
#define dfixed_const_8(A) (u32)(((A) << 12) + 3277) |
| 41 |
#define dfixed_mul(A, B) ((u64)((u64)(A).full * (B).full + 2048) >> 12) |
| 42 |
#define dfixed_init(A) { .full = dfixed_const((A)) } |
| 43 |
#define dfixed_init_half(A) { .full = dfixed_const_half((A)) } |
| 44 |
#define dfixed_trunc(A) ((A).full >> 12) |
| 45 |
#define dfixed_frac(A) ((A).full & ((1 << 12) - 1)) |
| 46 |
|
| 47 |
static inline u32 dfixed_floor(fixed20_12 A) |
| 48 |
{ |
| 49 |
u32 non_frac = dfixed_trunc(A); |
| 50 |
|
| 51 |
return dfixed_const(non_frac); |
| 52 |
} |
| 53 |
|
| 54 |
static inline u32 dfixed_ceil(fixed20_12 A) |
| 55 |
{ |
| 56 |
u32 non_frac = dfixed_trunc(A); |
| 57 |
|
| 58 |
if (A.full > dfixed_const(non_frac)) |
| 59 |
return dfixed_const(non_frac + 1); |
| 60 |
else |
| 61 |
return dfixed_const(non_frac); |
| 62 |
} |
| 63 |
|
| 64 |
static inline u32 dfixed_div(fixed20_12 A, fixed20_12 B) |
| 65 |
{ |
| 66 |
u64 tmp = ((u64)A.full << 13); |
| 67 |
|
| 68 |
do_div(tmp, B.full); |
| 69 |
tmp += 1; |
| 70 |
tmp /= 2; |
| 71 |
return lower_32_bits(tmp); |
| 72 |
} |
| 73 |
|
| 74 |
#define DRM_FIXED_POINT 32 |
| 75 |
#define DRM_FIXED_ONE (1ULL << DRM_FIXED_POINT) |
| 76 |
#define DRM_FIXED_DECIMAL_MASK (DRM_FIXED_ONE - 1) |
| 77 |
#define DRM_FIXED_DIGITS_MASK (~DRM_FIXED_DECIMAL_MASK) |
| 78 |
#define DRM_FIXED_EPSILON 1LL |
| 79 |
#define DRM_FIXED_ALMOST_ONE (DRM_FIXED_ONE - DRM_FIXED_EPSILON) |
| 80 |
|
| 81 |
/** |
| 82 |
* @drm_sm2fixp |
| 83 |
* |
| 84 |
* Convert a 1.31.32 signed-magnitude fixed point to 32.32 |
| 85 |
* 2s-complement fixed point |
| 86 |
* |
| 87 |
* @return s64 2s-complement fixed point |
| 88 |
*/ |
| 89 |
static inline s64 drm_sm2fixp(__u64 a) |
| 90 |
{ |
| 91 |
if ((a & (1LL << 63))) { |
| 92 |
return -(a & 0x7fffffffffffffffll); |
| 93 |
} else { |
| 94 |
return a; |
| 95 |
} |
| 96 |
} |
| 97 |
|
| 98 |
static inline s64 drm_int2fixp(int a) |
| 99 |
{ |
| 100 |
return ((s64)a) << DRM_FIXED_POINT; |
| 101 |
} |
| 102 |
|
| 103 |
static inline int drm_fixp2int(s64 a) |
| 104 |
{ |
| 105 |
return ((s64)a) >> DRM_FIXED_POINT; |
| 106 |
} |
| 107 |
|
| 108 |
static inline int drm_fixp2int_round(s64 a) |
| 109 |
{ |
| 110 |
return drm_fixp2int(a + DRM_FIXED_ONE / 2); |
| 111 |
} |
| 112 |
|
| 113 |
static inline int drm_fixp2int_ceil(s64 a) |
| 114 |
{ |
| 115 |
if (a >= 0) |
| 116 |
return drm_fixp2int(a + DRM_FIXED_ALMOST_ONE); |
| 117 |
else |
| 118 |
return drm_fixp2int(a - DRM_FIXED_ALMOST_ONE); |
| 119 |
} |
| 120 |
|
| 121 |
static inline unsigned drm_fixp_msbset(s64 a) |
| 122 |
{ |
| 123 |
unsigned shift, sign = (a >> 63) & 1; |
| 124 |
|
| 125 |
for (shift = 62; shift > 0; --shift) |
| 126 |
if (((a >> shift) & 1) != sign) |
| 127 |
return shift; |
| 128 |
|
| 129 |
return 0; |
| 130 |
} |
| 131 |
|
| 132 |
static inline s64 drm_fixp_mul(s64 a, s64 b) |
| 133 |
{ |
| 134 |
unsigned shift = drm_fixp_msbset(a) + drm_fixp_msbset(b); |
| 135 |
s64 result; |
| 136 |
|
| 137 |
if (shift > 61) { |
| 138 |
shift = shift - 61; |
| 139 |
a >>= (shift >> 1) + (shift & 1); |
| 140 |
b >>= shift >> 1; |
| 141 |
} else |
| 142 |
shift = 0; |
| 143 |
|
| 144 |
result = a * b; |
| 145 |
|
| 146 |
if (shift > DRM_FIXED_POINT) |
| 147 |
return result << (shift - DRM_FIXED_POINT); |
| 148 |
|
| 149 |
if (shift < DRM_FIXED_POINT) |
| 150 |
return result >> (DRM_FIXED_POINT - shift); |
| 151 |
|
| 152 |
return result; |
| 153 |
} |
| 154 |
|
| 155 |
static inline s64 drm_fixp_div(s64 a, s64 b) |
| 156 |
{ |
| 157 |
unsigned shift = 62 - drm_fixp_msbset(a); |
| 158 |
s64 result; |
| 159 |
|
| 160 |
a <<= shift; |
| 161 |
|
| 162 |
if (shift < DRM_FIXED_POINT) |
| 163 |
b >>= (DRM_FIXED_POINT - shift); |
| 164 |
|
| 165 |
result = div64_s64(a, b); |
| 166 |
|
| 167 |
if (shift > DRM_FIXED_POINT) |
| 168 |
return result >> (shift - DRM_FIXED_POINT); |
| 169 |
|
| 170 |
return result; |
| 171 |
} |
| 172 |
|
| 173 |
static inline s64 drm_fixp_from_fraction(s64 a, s64 b) |
| 174 |
{ |
| 175 |
s64 res; |
| 176 |
bool a_neg = a < 0; |
| 177 |
bool b_neg = b < 0; |
| 178 |
u64 a_abs = a_neg ? -a : a; |
| 179 |
u64 b_abs = b_neg ? -b : b; |
| 180 |
u64 rem; |
| 181 |
|
| 182 |
/* determine integer part */ |
| 183 |
u64 res_abs = div64_u64_rem(a_abs, b_abs, &rem); |
| 184 |
|
| 185 |
/* determine fractional part */ |
| 186 |
{ |
| 187 |
u32 i = DRM_FIXED_POINT; |
| 188 |
|
| 189 |
do { |
| 190 |
rem <<= 1; |
| 191 |
res_abs <<= 1; |
| 192 |
if (rem >= b_abs) { |
| 193 |
res_abs |= 1; |
| 194 |
rem -= b_abs; |
| 195 |
} |
| 196 |
} while (--i != 0); |
| 197 |
} |
| 198 |
|
| 199 |
/* round up LSB */ |
| 200 |
{ |
| 201 |
u64 summand = (rem << 1) >= b_abs; |
| 202 |
|
| 203 |
res_abs += summand; |
| 204 |
} |
| 205 |
|
| 206 |
res = (s64) res_abs; |
| 207 |
if (a_neg ^ b_neg) |
| 208 |
res = -res; |
| 209 |
return res; |
| 210 |
} |
| 211 |
|
| 212 |
static inline s64 drm_fixp_exp(s64 x) |
| 213 |
{ |
| 214 |
s64 tolerance = div64_s64(DRM_FIXED_ONE, 1000000); |
| 215 |
s64 sum = DRM_FIXED_ONE, term, y = x; |
| 216 |
u64 count = 1; |
| 217 |
|
| 218 |
if (x < 0) |
| 219 |
y = -1 * x; |
| 220 |
|
| 221 |
term = y; |
| 222 |
|
| 223 |
while (term >= tolerance) { |
| 224 |
sum = sum + term; |
| 225 |
count = count + 1; |
| 226 |
term = drm_fixp_mul(term, div64_s64(y, count)); |
| 227 |
} |
| 228 |
|
| 229 |
if (x < 0) |
| 230 |
sum = drm_fixp_div(DRM_FIXED_ONE, sum); |
| 231 |
|
| 232 |
return sum; |
| 233 |
} |
| 234 |
|
| 235 |
static inline int fxp_q4_from_int(int val_int) |
| 236 |
{ |
| 237 |
return val_int << 4; |
| 238 |
} |
| 239 |
|
| 240 |
static inline int fxp_q4_to_int(int val_q4) |
| 241 |
{ |
| 242 |
return val_q4 >> 4; |
| 243 |
} |
| 244 |
|
| 245 |
static inline int fxp_q4_to_int_roundup(int val_q4) |
| 246 |
{ |
| 247 |
return (val_q4 + 0xf) >> 4; |
| 248 |
} |
| 249 |
|
| 250 |
static inline int fxp_q4_to_frac(int val_q4) |
| 251 |
{ |
| 252 |
return val_q4 & 0xf; |
| 253 |
} |
| 254 |
|
| 255 |
#define FXP_Q4_FMT "%d.%04d" |
| 256 |
#define FXP_Q4_ARGS(val_q4) fxp_q4_to_int(val_q4), (fxp_q4_to_frac(val_q4) * 625) |
| 257 |
|
| 258 |
#endif |