Home | History | Annotate | Line # | Download | only in drm 
      1 /*	$NetBSD: drm_fixed.h,v 1.4 2021/12/18 23:45:46 riastradh Exp $	*/
      2 
      3 /*
      4  * Copyright 2009 Red Hat Inc.
      5  *
      6  * Permission is hereby granted, free of charge, to any person obtaining a
      7  * copy of this software and associated documentation files (the "Software"),
      8  * to deal in the Software without restriction, including without limitation
      9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
     10  * and/or sell copies of the Software, and to permit persons to whom the
     11  * Software is furnished to do so, subject to the following conditions:
     12  *
     13  * The above copyright notice and this permission notice shall be included in
     14  * all copies or substantial portions of the Software.
     15  *
     16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
     19  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
     20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
     21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
     22  * OTHER DEALINGS IN THE SOFTWARE.
     23  *
     24  * Authors: Dave Airlie
     25  *          Christian Knig
     26  */
     27 #ifndef DRM_FIXED_H
     28 #define DRM_FIXED_H
     29 
     30 #include <linux/math64.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 static inline s64 drm_int2fixp(int a)
     82 {
     83 	return ((s64)a) << DRM_FIXED_POINT;
     84 }
     85 
     86 static inline int drm_fixp2int(s64 a)
     87 {
     88 	return ((s64)a) >> DRM_FIXED_POINT;
     89 }
     90 
     91 static inline int drm_fixp2int_ceil(s64 a)
     92 {
     93 	if (a > 0)
     94 		return drm_fixp2int(a + DRM_FIXED_ALMOST_ONE);
     95 	else
     96 		return drm_fixp2int(a - DRM_FIXED_ALMOST_ONE);
     97 }
     98 
     99 static inline unsigned drm_fixp_msbset(s64 a)
    100 {
    101 	unsigned shift, sign = (a >> 63) & 1;
    102 
    103 	for (shift = 62; shift > 0; --shift)
    104 		if (((a >> shift) & 1) != sign)
    105 			return shift;
    106 
    107 	return 0;
    108 }
    109 
    110 static inline s64 drm_fixp_mul(s64 a, s64 b)
    111 {
    112 	unsigned shift = drm_fixp_msbset(a) + drm_fixp_msbset(b);
    113 	s64 result;
    114 
    115 	if (shift > 61) {
    116 		shift = shift - 61;
    117 		a >>= (shift >> 1) + (shift & 1);
    118 		b >>= shift >> 1;
    119 	} else
    120 		shift = 0;
    121 
    122 	result = a * b;
    123 
    124 	if (shift > DRM_FIXED_POINT)
    125 		return result << (shift - DRM_FIXED_POINT);
    126 
    127 	if (shift < DRM_FIXED_POINT)
    128 		return result >> (DRM_FIXED_POINT - shift);
    129 
    130 	return result;
    131 }
    132 
    133 static inline s64 drm_fixp_div(s64 a, s64 b)
    134 {
    135 	unsigned shift = 62 - drm_fixp_msbset(a);
    136 	s64 result;
    137 
    138 	a <<= shift;
    139 
    140 	if (shift < DRM_FIXED_POINT)
    141 		b >>= (DRM_FIXED_POINT - shift);
    142 
    143 	result = div64_s64(a, b);
    144 
    145 	if (shift > DRM_FIXED_POINT)
    146 		return result >> (shift - DRM_FIXED_POINT);
    147 
    148 	return result;
    149 }
    150 
    151 static inline s64 drm_fixp_from_fraction(s64 a, s64 b)
    152 {
    153 	s64 res;
    154 	bool a_neg = a < 0;
    155 	bool b_neg = b < 0;
    156 	u64 a_abs = a_neg ? -a : a;
    157 	u64 b_abs = b_neg ? -b : b;
    158 	u64 rem;
    159 
    160 	/* determine integer part */
    161 	u64 res_abs  = div64_u64_rem(a_abs, b_abs, &rem);
    162 
    163 	/* determine fractional part */
    164 	{
    165 		u32 i = DRM_FIXED_POINT;
    166 
    167 		do {
    168 			rem <<= 1;
    169 			res_abs <<= 1;
    170 			if (rem >= b_abs) {
    171 				res_abs |= 1;
    172 				rem -= b_abs;
    173 			}
    174 		} while (--i != 0);
    175 	}
    176 
    177 	/* round up LSB */
    178 	{
    179 		u64 summand = (rem << 1) >= b_abs;
    180 
    181 		res_abs += summand;
    182 	}
    183 
    184 	res = (s64) res_abs;
    185 	if (a_neg ^ b_neg)
    186 		res = -res;
    187 	return res;
    188 }
    189 
    190 static inline s64 drm_fixp_exp(s64 x)
    191 {
    192 	s64 tolerance = div64_s64(DRM_FIXED_ONE, 1000000);
    193 	s64 sum = DRM_FIXED_ONE, term, y = x;
    194 	u64 count = 1;
    195 
    196 	if (x < 0)
    197 		y = -1 * x;
    198 
    199 	term = y;
    200 
    201 	while (term >= tolerance) {
    202 		sum = sum + term;
    203 		count = count + 1;
    204 		term = drm_fixp_mul(term, div64_s64(y, count));
    205 	}
    206 
    207 	if (x < 0)
    208 		sum = drm_fixp_div(DRM_FIXED_ONE, sum);
    209 
    210 	return sum;
    211 }
    212 
    213 #endif
    214