diff options
Diffstat (limited to 'common/recipes-kernel/linux/linux-yocto-4.14.71/4455-drm-amd-display-get-rid-of-32.32-unsigned-fixed-poin.patch')
-rw-r--r-- | common/recipes-kernel/linux/linux-yocto-4.14.71/4455-drm-amd-display-get-rid-of-32.32-unsigned-fixed-poin.patch | 3536 |
1 files changed, 3536 insertions, 0 deletions
diff --git a/common/recipes-kernel/linux/linux-yocto-4.14.71/4455-drm-amd-display-get-rid-of-32.32-unsigned-fixed-poin.patch b/common/recipes-kernel/linux/linux-yocto-4.14.71/4455-drm-amd-display-get-rid-of-32.32-unsigned-fixed-poin.patch new file mode 100644 index 00000000..f6efc6db --- /dev/null +++ b/common/recipes-kernel/linux/linux-yocto-4.14.71/4455-drm-amd-display-get-rid-of-32.32-unsigned-fixed-poin.patch @@ -0,0 +1,3536 @@ +From f8dd6c111ee12e09a00ca4ef0de5933421fb0ad2 Mon Sep 17 00:00:00 2001 +From: Dmytro Laktyushkin <Dmytro.Laktyushkin@amd.com> +Date: Wed, 18 Apr 2018 11:37:53 -0400 +Subject: [PATCH 4455/5725] drm/amd/display: get rid of 32.32 unsigned fixed + point + +32.32 is redundant, 31.32 does everything we use 32.32 for + +Signed-off-by: Dmytro Laktyushkin <Dmytro.Laktyushkin@amd.com> +Reviewed-by: Tony Cheng <Tony.Cheng@amd.com> +Acked-by: Harry Wentland <harry.wentland@amd.com> +--- + .../drm/amd/display/amdgpu_dm/amdgpu_dm_color.c | 14 +- + drivers/gpu/drm/amd/display/dc/basics/Makefile | 2 +- + drivers/gpu/drm/amd/display/dc/basics/conversion.c | 28 +- + drivers/gpu/drm/amd/display/dc/basics/fixpt31_32.c | 176 ++++---- + drivers/gpu/drm/amd/display/dc/basics/fixpt32_32.c | 161 -------- + .../gpu/drm/amd/display/dc/calcs/custom_float.c | 46 +-- + drivers/gpu/drm/amd/display/dc/calcs/dcn_calcs.c | 8 +- + drivers/gpu/drm/amd/display/dc/core/dc_link.c | 12 +- + drivers/gpu/drm/amd/display/dc/core/dc_resource.c | 68 ++-- + drivers/gpu/drm/amd/display/dc/dc_dp_types.h | 2 + + drivers/gpu/drm/amd/display/dc/dc_types.h | 2 +- + drivers/gpu/drm/amd/display/dc/dce/dce_abm.c | 2 +- + .../gpu/drm/amd/display/dc/dce/dce_clock_source.c | 60 +-- + drivers/gpu/drm/amd/display/dc/dce/dce_clocks.c | 26 +- + drivers/gpu/drm/amd/display/dc/dce/dce_dmcu.c | 2 +- + drivers/gpu/drm/amd/display/dc/dce/dce_ipp.c | 6 +- + .../gpu/drm/amd/display/dc/dce/dce_scl_filters.c | 48 +-- + .../drm/amd/display/dc/dce/dce_stream_encoder.c | 8 +- + drivers/gpu/drm/amd/display/dc/dce/dce_transform.c | 26 +- + .../amd/display/dc/dce110/dce110_hw_sequencer.c | 36 +- + .../drm/amd/display/dc/dce110/dce110_transform_v.c | 8 +- + .../gpu/drm/amd/display/dc/dcn10/dcn10_cm_common.c | 86 ++-- + drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp.c | 2 +- + .../gpu/drm/amd/display/dc/dcn10/dcn10_dpp_cm.c | 6 +- + .../gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c | 38 +- + drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c | 4 +- + .../drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c | 28 +- + .../amd/display/dc/dcn10/dcn10_stream_encoder.c | 8 +- + drivers/gpu/drm/amd/display/dc/irq_types.h | 2 + + drivers/gpu/drm/amd/display/include/fixed31_32.h | 118 +++--- + drivers/gpu/drm/amd/display/include/fixed32_32.h | 129 ------ + .../drm/amd/display/modules/color/color_gamma.c | 446 ++++++++++----------- + 32 files changed, 661 insertions(+), 947 deletions(-) + delete mode 100644 drivers/gpu/drm/amd/display/dc/basics/fixpt32_32.c + delete mode 100644 drivers/gpu/drm/amd/display/include/fixed32_32.h + +diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_color.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_color.c +index e3d90e9..b329393 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_color.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_color.c +@@ -88,9 +88,9 @@ static void __drm_lut_to_dc_gamma(struct drm_color_lut *lut, + g = drm_color_lut_extract(lut[i].green, 16); + b = drm_color_lut_extract(lut[i].blue, 16); + +- gamma->entries.red[i] = dal_fixed31_32_from_int(r); +- gamma->entries.green[i] = dal_fixed31_32_from_int(g); +- gamma->entries.blue[i] = dal_fixed31_32_from_int(b); ++ gamma->entries.red[i] = dc_fixpt_from_int(r); ++ gamma->entries.green[i] = dc_fixpt_from_int(g); ++ gamma->entries.blue[i] = dc_fixpt_from_int(b); + } + return; + } +@@ -101,9 +101,9 @@ static void __drm_lut_to_dc_gamma(struct drm_color_lut *lut, + g = drm_color_lut_extract(lut[i].green, 16); + b = drm_color_lut_extract(lut[i].blue, 16); + +- gamma->entries.red[i] = dal_fixed31_32_from_fraction(r, MAX_DRM_LUT_VALUE); +- gamma->entries.green[i] = dal_fixed31_32_from_fraction(g, MAX_DRM_LUT_VALUE); +- gamma->entries.blue[i] = dal_fixed31_32_from_fraction(b, MAX_DRM_LUT_VALUE); ++ gamma->entries.red[i] = dc_fixpt_from_fraction(r, MAX_DRM_LUT_VALUE); ++ gamma->entries.green[i] = dc_fixpt_from_fraction(g, MAX_DRM_LUT_VALUE); ++ gamma->entries.blue[i] = dc_fixpt_from_fraction(b, MAX_DRM_LUT_VALUE); + } + } + +@@ -208,7 +208,7 @@ void amdgpu_dm_set_ctm(struct dm_crtc_state *crtc) + for (i = 0; i < 12; i++) { + /* Skip 4th element */ + if (i % 4 == 3) { +- stream->gamut_remap_matrix.matrix[i] = dal_fixed31_32_zero; ++ stream->gamut_remap_matrix.matrix[i] = dc_fixpt_zero; + continue; + } + +diff --git a/drivers/gpu/drm/amd/display/dc/basics/Makefile b/drivers/gpu/drm/amd/display/dc/basics/Makefile +index ddc7fab..fbf4dbf 100644 +--- a/drivers/gpu/drm/amd/display/dc/basics/Makefile ++++ b/drivers/gpu/drm/amd/display/dc/basics/Makefile +@@ -3,7 +3,7 @@ + # It provides the general basic services required by other DAL + # subcomponents. + +-BASICS = conversion.o fixpt31_32.o fixpt32_32.o \ ++BASICS = conversion.o fixpt31_32.o \ + logger.o log_helpers.o vector.o + + AMD_DAL_BASICS = $(addprefix $(AMDDALPATH)/dc/basics/,$(BASICS)) +diff --git a/drivers/gpu/drm/amd/display/dc/basics/conversion.c b/drivers/gpu/drm/amd/display/dc/basics/conversion.c +index 3109649..50b47f1 100644 +--- a/drivers/gpu/drm/amd/display/dc/basics/conversion.c ++++ b/drivers/gpu/drm/amd/display/dc/basics/conversion.c +@@ -41,22 +41,22 @@ uint16_t fixed_point_to_int_frac( + + uint16_t result; + +- uint16_t d = (uint16_t)dal_fixed31_32_floor( +- dal_fixed31_32_abs( ++ uint16_t d = (uint16_t)dc_fixpt_floor( ++ dc_fixpt_abs( + arg)); + + if (d <= (uint16_t)(1 << integer_bits) - (1 / (uint16_t)divisor)) +- numerator = (uint16_t)dal_fixed31_32_round( +- dal_fixed31_32_mul_int( ++ numerator = (uint16_t)dc_fixpt_round( ++ dc_fixpt_mul_int( + arg, + divisor)); + else { +- numerator = dal_fixed31_32_floor( +- dal_fixed31_32_sub( +- dal_fixed31_32_from_int( ++ numerator = dc_fixpt_floor( ++ dc_fixpt_sub( ++ dc_fixpt_from_int( + 1LL << integer_bits), +- dal_fixed31_32_recip( +- dal_fixed31_32_from_int( ++ dc_fixpt_recip( ++ dc_fixpt_from_int( + divisor)))); + } + +@@ -66,8 +66,8 @@ uint16_t fixed_point_to_int_frac( + result = (uint16_t)( + (1 << (integer_bits + fractional_bits + 1)) + numerator); + +- if ((result != 0) && dal_fixed31_32_lt( +- arg, dal_fixed31_32_zero)) ++ if ((result != 0) && dc_fixpt_lt( ++ arg, dc_fixpt_zero)) + result |= 1 << (integer_bits + fractional_bits); + + return result; +@@ -84,15 +84,15 @@ void convert_float_matrix( + uint32_t buffer_size) + { + const struct fixed31_32 min_2_13 = +- dal_fixed31_32_from_fraction(S2D13_MIN, DIVIDER); ++ dc_fixpt_from_fraction(S2D13_MIN, DIVIDER); + const struct fixed31_32 max_2_13 = +- dal_fixed31_32_from_fraction(S2D13_MAX, DIVIDER); ++ dc_fixpt_from_fraction(S2D13_MAX, DIVIDER); + uint32_t i; + + for (i = 0; i < buffer_size; ++i) { + uint32_t reg_value = + fixed_point_to_int_frac( +- dal_fixed31_32_clamp( ++ dc_fixpt_clamp( + flt[i], + min_2_13, + max_2_13), +diff --git a/drivers/gpu/drm/amd/display/dc/basics/fixpt31_32.c b/drivers/gpu/drm/amd/display/dc/basics/fixpt31_32.c +index 7191c32..e398ecd 100644 +--- a/drivers/gpu/drm/amd/display/dc/basics/fixpt31_32.c ++++ b/drivers/gpu/drm/amd/display/dc/basics/fixpt31_32.c +@@ -64,7 +64,7 @@ static inline unsigned long long complete_integer_division_u64( + #define GET_FRACTIONAL_PART(x) \ + (FRACTIONAL_PART_MASK & (x)) + +-struct fixed31_32 dal_fixed31_32_from_fraction( ++struct fixed31_32 dc_fixpt_from_fraction( + long long numerator, + long long denominator) + { +@@ -118,7 +118,7 @@ struct fixed31_32 dal_fixed31_32_from_fraction( + return res; + } + +-struct fixed31_32 dal_fixed31_32_from_int_nonconst( ++struct fixed31_32 dc_fixpt_from_int_nonconst( + long long arg) + { + struct fixed31_32 res; +@@ -130,7 +130,7 @@ struct fixed31_32 dal_fixed31_32_from_int_nonconst( + return res; + } + +-struct fixed31_32 dal_fixed31_32_shl( ++struct fixed31_32 dc_fixpt_shl( + struct fixed31_32 arg, + unsigned char shift) + { +@@ -144,7 +144,7 @@ struct fixed31_32 dal_fixed31_32_shl( + return res; + } + +-struct fixed31_32 dal_fixed31_32_add( ++struct fixed31_32 dc_fixpt_add( + struct fixed31_32 arg1, + struct fixed31_32 arg2) + { +@@ -158,7 +158,7 @@ struct fixed31_32 dal_fixed31_32_add( + return res; + } + +-struct fixed31_32 dal_fixed31_32_sub( ++struct fixed31_32 dc_fixpt_sub( + struct fixed31_32 arg1, + struct fixed31_32 arg2) + { +@@ -172,7 +172,7 @@ struct fixed31_32 dal_fixed31_32_sub( + return res; + } + +-struct fixed31_32 dal_fixed31_32_mul( ++struct fixed31_32 dc_fixpt_mul( + struct fixed31_32 arg1, + struct fixed31_32 arg2) + { +@@ -213,7 +213,7 @@ struct fixed31_32 dal_fixed31_32_mul( + tmp = arg1_fra * arg2_fra; + + tmp = (tmp >> FIXED31_32_BITS_PER_FRACTIONAL_PART) + +- (tmp >= (unsigned long long)dal_fixed31_32_half.value); ++ (tmp >= (unsigned long long)dc_fixpt_half.value); + + ASSERT(tmp <= (unsigned long long)(LLONG_MAX - res.value)); + +@@ -225,7 +225,7 @@ struct fixed31_32 dal_fixed31_32_mul( + return res; + } + +-struct fixed31_32 dal_fixed31_32_sqr( ++struct fixed31_32 dc_fixpt_sqr( + struct fixed31_32 arg) + { + struct fixed31_32 res; +@@ -257,7 +257,7 @@ struct fixed31_32 dal_fixed31_32_sqr( + tmp = arg_fra * arg_fra; + + tmp = (tmp >> FIXED31_32_BITS_PER_FRACTIONAL_PART) + +- (tmp >= (unsigned long long)dal_fixed31_32_half.value); ++ (tmp >= (unsigned long long)dc_fixpt_half.value); + + ASSERT(tmp <= (unsigned long long)(LLONG_MAX - res.value)); + +@@ -266,7 +266,7 @@ struct fixed31_32 dal_fixed31_32_sqr( + return res; + } + +-struct fixed31_32 dal_fixed31_32_recip( ++struct fixed31_32 dc_fixpt_recip( + struct fixed31_32 arg) + { + /* +@@ -276,41 +276,41 @@ struct fixed31_32 dal_fixed31_32_recip( + + ASSERT(arg.value); + +- return dal_fixed31_32_from_fraction( +- dal_fixed31_32_one.value, ++ return dc_fixpt_from_fraction( ++ dc_fixpt_one.value, + arg.value); + } + +-struct fixed31_32 dal_fixed31_32_sinc( ++struct fixed31_32 dc_fixpt_sinc( + struct fixed31_32 arg) + { + struct fixed31_32 square; + +- struct fixed31_32 res = dal_fixed31_32_one; ++ struct fixed31_32 res = dc_fixpt_one; + + int n = 27; + + struct fixed31_32 arg_norm = arg; + +- if (dal_fixed31_32_le( +- dal_fixed31_32_two_pi, +- dal_fixed31_32_abs(arg))) { +- arg_norm = dal_fixed31_32_sub( ++ if (dc_fixpt_le( ++ dc_fixpt_two_pi, ++ dc_fixpt_abs(arg))) { ++ arg_norm = dc_fixpt_sub( + arg_norm, +- dal_fixed31_32_mul_int( +- dal_fixed31_32_two_pi, ++ dc_fixpt_mul_int( ++ dc_fixpt_two_pi, + (int)div64_s64( + arg_norm.value, +- dal_fixed31_32_two_pi.value))); ++ dc_fixpt_two_pi.value))); + } + +- square = dal_fixed31_32_sqr(arg_norm); ++ square = dc_fixpt_sqr(arg_norm); + + do { +- res = dal_fixed31_32_sub( +- dal_fixed31_32_one, +- dal_fixed31_32_div_int( +- dal_fixed31_32_mul( ++ res = dc_fixpt_sub( ++ dc_fixpt_one, ++ dc_fixpt_div_int( ++ dc_fixpt_mul( + square, + res), + n * (n - 1))); +@@ -319,37 +319,37 @@ struct fixed31_32 dal_fixed31_32_sinc( + } while (n > 2); + + if (arg.value != arg_norm.value) +- res = dal_fixed31_32_div( +- dal_fixed31_32_mul(res, arg_norm), ++ res = dc_fixpt_div( ++ dc_fixpt_mul(res, arg_norm), + arg); + + return res; + } + +-struct fixed31_32 dal_fixed31_32_sin( ++struct fixed31_32 dc_fixpt_sin( + struct fixed31_32 arg) + { +- return dal_fixed31_32_mul( ++ return dc_fixpt_mul( + arg, +- dal_fixed31_32_sinc(arg)); ++ dc_fixpt_sinc(arg)); + } + +-struct fixed31_32 dal_fixed31_32_cos( ++struct fixed31_32 dc_fixpt_cos( + struct fixed31_32 arg) + { + /* TODO implement argument normalization */ + +- const struct fixed31_32 square = dal_fixed31_32_sqr(arg); ++ const struct fixed31_32 square = dc_fixpt_sqr(arg); + +- struct fixed31_32 res = dal_fixed31_32_one; ++ struct fixed31_32 res = dc_fixpt_one; + + int n = 26; + + do { +- res = dal_fixed31_32_sub( +- dal_fixed31_32_one, +- dal_fixed31_32_div_int( +- dal_fixed31_32_mul( ++ res = dc_fixpt_sub( ++ dc_fixpt_one, ++ dc_fixpt_div_int( ++ dc_fixpt_mul( + square, + res), + n * (n - 1))); +@@ -372,31 +372,31 @@ static struct fixed31_32 fixed31_32_exp_from_taylor_series( + { + unsigned int n = 9; + +- struct fixed31_32 res = dal_fixed31_32_from_fraction( ++ struct fixed31_32 res = dc_fixpt_from_fraction( + n + 2, + n + 1); + /* TODO find correct res */ + +- ASSERT(dal_fixed31_32_lt(arg, dal_fixed31_32_one)); ++ ASSERT(dc_fixpt_lt(arg, dc_fixpt_one)); + + do +- res = dal_fixed31_32_add( +- dal_fixed31_32_one, +- dal_fixed31_32_div_int( +- dal_fixed31_32_mul( ++ res = dc_fixpt_add( ++ dc_fixpt_one, ++ dc_fixpt_div_int( ++ dc_fixpt_mul( + arg, + res), + n)); + while (--n != 1); + +- return dal_fixed31_32_add( +- dal_fixed31_32_one, +- dal_fixed31_32_mul( ++ return dc_fixpt_add( ++ dc_fixpt_one, ++ dc_fixpt_mul( + arg, + res)); + } + +-struct fixed31_32 dal_fixed31_32_exp( ++struct fixed31_32 dc_fixpt_exp( + struct fixed31_32 arg) + { + /* +@@ -406,44 +406,44 @@ struct fixed31_32 dal_fixed31_32_exp( + * where m = round(x / ln(2)), r = x - m * ln(2) + */ + +- if (dal_fixed31_32_le( +- dal_fixed31_32_ln2_div_2, +- dal_fixed31_32_abs(arg))) { +- int m = dal_fixed31_32_round( +- dal_fixed31_32_div( ++ if (dc_fixpt_le( ++ dc_fixpt_ln2_div_2, ++ dc_fixpt_abs(arg))) { ++ int m = dc_fixpt_round( ++ dc_fixpt_div( + arg, +- dal_fixed31_32_ln2)); ++ dc_fixpt_ln2)); + +- struct fixed31_32 r = dal_fixed31_32_sub( ++ struct fixed31_32 r = dc_fixpt_sub( + arg, +- dal_fixed31_32_mul_int( +- dal_fixed31_32_ln2, ++ dc_fixpt_mul_int( ++ dc_fixpt_ln2, + m)); + + ASSERT(m != 0); + +- ASSERT(dal_fixed31_32_lt( +- dal_fixed31_32_abs(r), +- dal_fixed31_32_one)); ++ ASSERT(dc_fixpt_lt( ++ dc_fixpt_abs(r), ++ dc_fixpt_one)); + + if (m > 0) +- return dal_fixed31_32_shl( ++ return dc_fixpt_shl( + fixed31_32_exp_from_taylor_series(r), + (unsigned char)m); + else +- return dal_fixed31_32_div_int( ++ return dc_fixpt_div_int( + fixed31_32_exp_from_taylor_series(r), + 1LL << -m); + } else if (arg.value != 0) + return fixed31_32_exp_from_taylor_series(arg); + else +- return dal_fixed31_32_one; ++ return dc_fixpt_one; + } + +-struct fixed31_32 dal_fixed31_32_log( ++struct fixed31_32 dc_fixpt_log( + struct fixed31_32 arg) + { +- struct fixed31_32 res = dal_fixed31_32_neg(dal_fixed31_32_one); ++ struct fixed31_32 res = dc_fixpt_neg(dc_fixpt_one); + /* TODO improve 1st estimation */ + + struct fixed31_32 error; +@@ -453,15 +453,15 @@ struct fixed31_32 dal_fixed31_32_log( + /* TODO if arg is zero, return -INF */ + + do { +- struct fixed31_32 res1 = dal_fixed31_32_add( +- dal_fixed31_32_sub( ++ struct fixed31_32 res1 = dc_fixpt_add( ++ dc_fixpt_sub( + res, +- dal_fixed31_32_one), +- dal_fixed31_32_div( ++ dc_fixpt_one), ++ dc_fixpt_div( + arg, +- dal_fixed31_32_exp(res))); ++ dc_fixpt_exp(res))); + +- error = dal_fixed31_32_sub( ++ error = dc_fixpt_sub( + res, + res1); + +@@ -472,17 +472,17 @@ struct fixed31_32 dal_fixed31_32_log( + return res; + } + +-struct fixed31_32 dal_fixed31_32_pow( ++struct fixed31_32 dc_fixpt_pow( + struct fixed31_32 arg1, + struct fixed31_32 arg2) + { +- return dal_fixed31_32_exp( +- dal_fixed31_32_mul( +- dal_fixed31_32_log(arg1), ++ return dc_fixpt_exp( ++ dc_fixpt_mul( ++ dc_fixpt_log(arg1), + arg2)); + } + +-int dal_fixed31_32_floor( ++int dc_fixpt_floor( + struct fixed31_32 arg) + { + unsigned long long arg_value = abs_i64(arg.value); +@@ -493,12 +493,12 @@ int dal_fixed31_32_floor( + return -(int)GET_INTEGER_PART(arg_value); + } + +-int dal_fixed31_32_round( ++int dc_fixpt_round( + struct fixed31_32 arg) + { + unsigned long long arg_value = abs_i64(arg.value); + +- const long long summand = dal_fixed31_32_half.value; ++ const long long summand = dc_fixpt_half.value; + + ASSERT(LLONG_MAX - (long long)arg_value >= summand); + +@@ -510,13 +510,13 @@ int dal_fixed31_32_round( + return -(int)GET_INTEGER_PART(arg_value); + } + +-int dal_fixed31_32_ceil( ++int dc_fixpt_ceil( + struct fixed31_32 arg) + { + unsigned long long arg_value = abs_i64(arg.value); + +- const long long summand = dal_fixed31_32_one.value - +- dal_fixed31_32_epsilon.value; ++ const long long summand = dc_fixpt_one.value - ++ dc_fixpt_epsilon.value; + + ASSERT(LLONG_MAX - (long long)arg_value >= summand); + +@@ -531,7 +531,7 @@ int dal_fixed31_32_ceil( + /* this function is a generic helper to translate fixed point value to + * specified integer format that will consist of integer_bits integer part and + * fractional_bits fractional part. For example it is used in +- * dal_fixed31_32_u2d19 to receive 2 bits integer part and 19 bits fractional ++ * dc_fixpt_u2d19 to receive 2 bits integer part and 19 bits fractional + * part in 32 bits. It is used in hw programming (scaler) + */ + +@@ -570,35 +570,35 @@ static inline unsigned int clamp_ux_dy( + return min_clamp; + } + +-unsigned int dal_fixed31_32_u2d19( ++unsigned int dc_fixpt_u2d19( + struct fixed31_32 arg) + { + return ux_dy(arg.value, 2, 19); + } + +-unsigned int dal_fixed31_32_u0d19( ++unsigned int dc_fixpt_u0d19( + struct fixed31_32 arg) + { + return ux_dy(arg.value, 0, 19); + } + +-unsigned int dal_fixed31_32_clamp_u0d14( ++unsigned int dc_fixpt_clamp_u0d14( + struct fixed31_32 arg) + { + return clamp_ux_dy(arg.value, 0, 14, 1); + } + +-unsigned int dal_fixed31_32_clamp_u0d10( ++unsigned int dc_fixpt_clamp_u0d10( + struct fixed31_32 arg) + { + return clamp_ux_dy(arg.value, 0, 10, 1); + } + +-int dal_fixed31_32_s4d19( ++int dc_fixpt_s4d19( + struct fixed31_32 arg) + { + if (arg.value < 0) +- return -(int)ux_dy(dal_fixed31_32_abs(arg).value, 4, 19); ++ return -(int)ux_dy(dc_fixpt_abs(arg).value, 4, 19); + else + return ux_dy(arg.value, 4, 19); + } +diff --git a/drivers/gpu/drm/amd/display/dc/basics/fixpt32_32.c b/drivers/gpu/drm/amd/display/dc/basics/fixpt32_32.c +deleted file mode 100644 +index 4d3aaa8..0000000 +--- a/drivers/gpu/drm/amd/display/dc/basics/fixpt32_32.c ++++ /dev/null +@@ -1,161 +0,0 @@ +-/* +- * Copyright 2012-15 Advanced Micro Devices, Inc. +- * +- * Permission is hereby granted, free of charge, to any person obtaining a +- * copy of this software and associated documentation files (the "Software"), +- * to deal in the Software without restriction, including without limitation +- * the rights to use, copy, modify, merge, publish, distribute, sublicense, +- * and/or sell copies of the Software, and to permit persons to whom the +- * Software is furnished to do so, subject to the following conditions: +- * +- * The above copyright notice and this permission notice shall be included in +- * all copies or substantial portions of the Software. +- * +- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR +- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +- * OTHER DEALINGS IN THE SOFTWARE. +- * +- * Authors: AMD +- * +- */ +- +-#include "dm_services.h" +-#include "include/fixed32_32.h" +- +-static uint64_t u64_div(uint64_t n, uint64_t d) +-{ +- uint32_t i = 0; +- uint64_t r; +- uint64_t q = div64_u64_rem(n, d, &r); +- +- for (i = 0; i < 32; ++i) { +- uint64_t sbit = q & (1ULL<<63); +- +- r <<= 1; +- r |= sbit ? 1 : 0; +- q <<= 1; +- if (r >= d) { +- r -= d; +- q |= 1; +- } +- } +- +- if (2*r >= d) +- q += 1; +- return q; +-} +- +-struct fixed32_32 dal_fixed32_32_from_fraction(uint32_t n, uint32_t d) +-{ +- struct fixed32_32 fx; +- +- fx.value = u64_div((uint64_t)n << 32, (uint64_t)d << 32); +- return fx; +-} +- +-struct fixed32_32 dal_fixed32_32_add( +- struct fixed32_32 lhs, +- struct fixed32_32 rhs) +-{ +- struct fixed32_32 fx = {lhs.value + rhs.value}; +- +- ASSERT(fx.value >= rhs.value); +- return fx; +-} +- +-struct fixed32_32 dal_fixed32_32_add_int(struct fixed32_32 lhs, uint32_t rhs) +-{ +- struct fixed32_32 fx = {lhs.value + ((uint64_t)rhs << 32)}; +- +- ASSERT(fx.value >= (uint64_t)rhs << 32); +- return fx; +- +-} +-struct fixed32_32 dal_fixed32_32_sub( +- struct fixed32_32 lhs, +- struct fixed32_32 rhs) +-{ +- struct fixed32_32 fx; +- +- ASSERT(lhs.value >= rhs.value); +- fx.value = lhs.value - rhs.value; +- return fx; +-} +- +-struct fixed32_32 dal_fixed32_32_sub_int(struct fixed32_32 lhs, uint32_t rhs) +-{ +- struct fixed32_32 fx; +- +- ASSERT(lhs.value >= ((uint64_t)rhs<<32)); +- fx.value = lhs.value - ((uint64_t)rhs<<32); +- return fx; +-} +- +-struct fixed32_32 dal_fixed32_32_mul( +- struct fixed32_32 lhs, +- struct fixed32_32 rhs) +-{ +- struct fixed32_32 fx; +- uint64_t lhs_int = lhs.value>>32; +- uint64_t lhs_frac = (uint32_t)lhs.value; +- uint64_t rhs_int = rhs.value>>32; +- uint64_t rhs_frac = (uint32_t)rhs.value; +- uint64_t ahbh = lhs_int * rhs_int; +- uint64_t ahbl = lhs_int * rhs_frac; +- uint64_t albh = lhs_frac * rhs_int; +- uint64_t albl = lhs_frac * rhs_frac; +- +- ASSERT((ahbh>>32) == 0); +- +- fx.value = (ahbh<<32) + ahbl + albh + (albl>>32); +- return fx; +- +-} +- +-struct fixed32_32 dal_fixed32_32_mul_int(struct fixed32_32 lhs, uint32_t rhs) +-{ +- struct fixed32_32 fx; +- uint64_t lhsi = (lhs.value>>32) * (uint64_t)rhs; +- uint64_t lhsf; +- +- ASSERT((lhsi>>32) == 0); +- lhsf = ((uint32_t)lhs.value) * (uint64_t)rhs; +- ASSERT((lhsi<<32) + lhsf >= lhsf); +- fx.value = (lhsi<<32) + lhsf; +- return fx; +-} +- +-struct fixed32_32 dal_fixed32_32_div( +- struct fixed32_32 lhs, +- struct fixed32_32 rhs) +-{ +- struct fixed32_32 fx; +- +- fx.value = u64_div(lhs.value, rhs.value); +- return fx; +-} +- +-struct fixed32_32 dal_fixed32_32_div_int(struct fixed32_32 lhs, uint32_t rhs) +-{ +- struct fixed32_32 fx; +- +- fx.value = u64_div(lhs.value, (uint64_t)rhs << 32); +- return fx; +-} +- +-uint32_t dal_fixed32_32_ceil(struct fixed32_32 v) +-{ +- ASSERT((uint32_t)v.value ? (v.value >> 32) + 1 >= 1 : true); +- return (v.value>>32) + ((uint32_t)v.value ? 1 : 0); +-} +- +-uint32_t dal_fixed32_32_round(struct fixed32_32 v) +-{ +- ASSERT(v.value + (1ULL<<31) >= (1ULL<<31)); +- return (v.value + (1ULL<<31))>>32; +-} +- +diff --git a/drivers/gpu/drm/amd/display/dc/calcs/custom_float.c b/drivers/gpu/drm/amd/display/dc/calcs/custom_float.c +index 7243c37..31d167b 100644 +--- a/drivers/gpu/drm/amd/display/dc/calcs/custom_float.c ++++ b/drivers/gpu/drm/amd/display/dc/calcs/custom_float.c +@@ -36,41 +36,41 @@ static bool build_custom_float( + uint32_t exp_offset = (1 << (format->exponenta_bits - 1)) - 1; + + const struct fixed31_32 mantissa_constant_plus_max_fraction = +- dal_fixed31_32_from_fraction( ++ dc_fixpt_from_fraction( + (1LL << (format->mantissa_bits + 1)) - 1, + 1LL << format->mantissa_bits); + + struct fixed31_32 mantiss; + +- if (dal_fixed31_32_eq( ++ if (dc_fixpt_eq( + value, +- dal_fixed31_32_zero)) { ++ dc_fixpt_zero)) { + *negative = false; + *mantissa = 0; + *exponenta = 0; + return true; + } + +- if (dal_fixed31_32_lt( ++ if (dc_fixpt_lt( + value, +- dal_fixed31_32_zero)) { ++ dc_fixpt_zero)) { + *negative = format->sign; +- value = dal_fixed31_32_neg(value); ++ value = dc_fixpt_neg(value); + } else { + *negative = false; + } + +- if (dal_fixed31_32_lt( ++ if (dc_fixpt_lt( + value, +- dal_fixed31_32_one)) { ++ dc_fixpt_one)) { + uint32_t i = 1; + + do { +- value = dal_fixed31_32_shl(value, 1); ++ value = dc_fixpt_shl(value, 1); + ++i; +- } while (dal_fixed31_32_lt( ++ } while (dc_fixpt_lt( + value, +- dal_fixed31_32_one)); ++ dc_fixpt_one)); + + --i; + +@@ -81,15 +81,15 @@ static bool build_custom_float( + } + + *exponenta = exp_offset - i; +- } else if (dal_fixed31_32_le( ++ } else if (dc_fixpt_le( + mantissa_constant_plus_max_fraction, + value)) { + uint32_t i = 1; + + do { +- value = dal_fixed31_32_shr(value, 1); ++ value = dc_fixpt_shr(value, 1); + ++i; +- } while (dal_fixed31_32_lt( ++ } while (dc_fixpt_lt( + mantissa_constant_plus_max_fraction, + value)); + +@@ -98,23 +98,23 @@ static bool build_custom_float( + *exponenta = exp_offset; + } + +- mantiss = dal_fixed31_32_sub( ++ mantiss = dc_fixpt_sub( + value, +- dal_fixed31_32_one); ++ dc_fixpt_one); + +- if (dal_fixed31_32_lt( ++ if (dc_fixpt_lt( + mantiss, +- dal_fixed31_32_zero) || +- dal_fixed31_32_lt( +- dal_fixed31_32_one, ++ dc_fixpt_zero) || ++ dc_fixpt_lt( ++ dc_fixpt_one, + mantiss)) +- mantiss = dal_fixed31_32_zero; ++ mantiss = dc_fixpt_zero; + else +- mantiss = dal_fixed31_32_shl( ++ mantiss = dc_fixpt_shl( + mantiss, + format->mantissa_bits); + +- *mantissa = dal_fixed31_32_floor(mantiss); ++ *mantissa = dc_fixpt_floor(mantiss); + + return true; + } +diff --git a/drivers/gpu/drm/amd/display/dc/calcs/dcn_calcs.c b/drivers/gpu/drm/amd/display/dc/calcs/dcn_calcs.c +index a102c19..49a4ea4 100644 +--- a/drivers/gpu/drm/amd/display/dc/calcs/dcn_calcs.c ++++ b/drivers/gpu/drm/amd/display/dc/calcs/dcn_calcs.c +@@ -873,14 +873,14 @@ bool dcn_validate_bandwidth( + } + + if (pipe->plane_state->rotation % 2 == 0) { +- ASSERT(pipe->plane_res.scl_data.ratios.horz.value != dal_fixed31_32_one.value ++ ASSERT(pipe->plane_res.scl_data.ratios.horz.value != dc_fixpt_one.value + || v->scaler_rec_out_width[input_idx] == v->viewport_width[input_idx]); +- ASSERT(pipe->plane_res.scl_data.ratios.vert.value != dal_fixed31_32_one.value ++ ASSERT(pipe->plane_res.scl_data.ratios.vert.value != dc_fixpt_one.value + || v->scaler_recout_height[input_idx] == v->viewport_height[input_idx]); + } else { +- ASSERT(pipe->plane_res.scl_data.ratios.horz.value != dal_fixed31_32_one.value ++ ASSERT(pipe->plane_res.scl_data.ratios.horz.value != dc_fixpt_one.value + || v->scaler_recout_height[input_idx] == v->viewport_width[input_idx]); +- ASSERT(pipe->plane_res.scl_data.ratios.vert.value != dal_fixed31_32_one.value ++ ASSERT(pipe->plane_res.scl_data.ratios.vert.value != dc_fixpt_one.value + || v->scaler_rec_out_width[input_idx] == v->viewport_height[input_idx]); + } + v->dcc_enable[input_idx] = pipe->plane_state->dcc.enable ? dcn_bw_yes : dcn_bw_no; +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_link.c b/drivers/gpu/drm/amd/display/dc/core/dc_link.c +index b44cf52..ea5d5ff 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc_link.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc_link.c +@@ -631,7 +631,7 @@ bool dc_link_detect(struct dc_link *link, enum dc_detect_reason reason) + /* Need to setup mst link_cap struct here + * otherwise dc_link_detect() will leave mst link_cap + * empty which leads to allocate_mst_payload() has "0" +- * pbn_per_slot value leading to exception on dal_fixed31_32_div() ++ * pbn_per_slot value leading to exception on dc_fixpt_div() + */ + link->verified_link_cap = link->reported_link_cap; + return false; +@@ -2059,10 +2059,10 @@ static struct fixed31_32 get_pbn_per_slot(struct dc_stream_state *stream) + &stream->sink->link->cur_link_settings; + uint32_t link_rate_in_mbps = + link_settings->link_rate * LINK_RATE_REF_FREQ_IN_MHZ; +- struct fixed31_32 mbps = dal_fixed31_32_from_int( ++ struct fixed31_32 mbps = dc_fixpt_from_int( + link_rate_in_mbps * link_settings->lane_count); + +- return dal_fixed31_32_div_int(mbps, 54); ++ return dc_fixpt_div_int(mbps, 54); + } + + static int get_color_depth(enum dc_color_depth color_depth) +@@ -2103,7 +2103,7 @@ static struct fixed31_32 get_pbn_from_timing(struct pipe_ctx *pipe_ctx) + numerator = 64 * PEAK_FACTOR_X1000; + denominator = 54 * 8 * 1000 * 1000; + kbps *= numerator; +- peak_kbps = dal_fixed31_32_from_fraction(kbps, denominator); ++ peak_kbps = dc_fixpt_from_fraction(kbps, denominator); + + return peak_kbps; + } +@@ -2230,7 +2230,7 @@ static enum dc_status allocate_mst_payload(struct pipe_ctx *pipe_ctx) + /* slot X.Y for only current stream */ + pbn_per_slot = get_pbn_per_slot(stream); + pbn = get_pbn_from_timing(pipe_ctx); +- avg_time_slots_per_mtp = dal_fixed31_32_div(pbn, pbn_per_slot); ++ avg_time_slots_per_mtp = dc_fixpt_div(pbn, pbn_per_slot); + + stream_encoder->funcs->set_mst_bandwidth( + stream_encoder, +@@ -2247,7 +2247,7 @@ static enum dc_status deallocate_mst_payload(struct pipe_ctx *pipe_ctx) + struct link_encoder *link_encoder = link->link_enc; + struct stream_encoder *stream_encoder = pipe_ctx->stream_res.stream_enc; + struct dp_mst_stream_allocation_table proposed_table = {0}; +- struct fixed31_32 avg_time_slots_per_mtp = dal_fixed31_32_from_int(0); ++ struct fixed31_32 avg_time_slots_per_mtp = dc_fixpt_from_int(0); + uint8_t i; + bool mst_mode = (link->type == dc_connection_mst_branch); + DC_LOGGER_INIT(link->ctx->logger); +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_resource.c b/drivers/gpu/drm/amd/display/dc/core/dc_resource.c +index db4fdf6..68c1a99 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc_resource.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc_resource.c +@@ -495,9 +495,9 @@ static void calculate_viewport(struct pipe_ctx *pipe_ctx) + data->viewport_c.x = data->viewport.x / vpc_div; + data->viewport_c.y = data->viewport.y / vpc_div; + data->inits.h_c = (data->viewport.x % vpc_div) != 0 ? +- dal_fixed31_32_half : dal_fixed31_32_zero; ++ dc_fixpt_half : dc_fixpt_zero; + data->inits.v_c = (data->viewport.y % vpc_div) != 0 ? +- dal_fixed31_32_half : dal_fixed31_32_zero; ++ dc_fixpt_half : dc_fixpt_zero; + /* Round up, assume original video size always even dimensions */ + data->viewport_c.width = (data->viewport.width + vpc_div - 1) / vpc_div; + data->viewport_c.height = (data->viewport.height + vpc_div - 1) / vpc_div; +@@ -626,10 +626,10 @@ static void calculate_scaling_ratios(struct pipe_ctx *pipe_ctx) + pipe_ctx->plane_state->rotation == ROTATION_ANGLE_270) + rect_swap_helper(&surf_src); + +- pipe_ctx->plane_res.scl_data.ratios.horz = dal_fixed31_32_from_fraction( ++ pipe_ctx->plane_res.scl_data.ratios.horz = dc_fixpt_from_fraction( + surf_src.width, + plane_state->dst_rect.width); +- pipe_ctx->plane_res.scl_data.ratios.vert = dal_fixed31_32_from_fraction( ++ pipe_ctx->plane_res.scl_data.ratios.vert = dc_fixpt_from_fraction( + surf_src.height, + plane_state->dst_rect.height); + +@@ -687,32 +687,32 @@ static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx, struct view *r + * init_bot = init + scaling_ratio + * init_c = init + truncated_vp_c_offset(from calculate viewport) + */ +- data->inits.h = dal_fixed31_32_div_int( +- dal_fixed31_32_add_int(data->ratios.horz, data->taps.h_taps + 1), 2); ++ data->inits.h = dc_fixpt_div_int( ++ dc_fixpt_add_int(data->ratios.horz, data->taps.h_taps + 1), 2); + +- data->inits.h_c = dal_fixed31_32_add(data->inits.h_c, dal_fixed31_32_div_int( +- dal_fixed31_32_add_int(data->ratios.horz_c, data->taps.h_taps_c + 1), 2)); ++ data->inits.h_c = dc_fixpt_add(data->inits.h_c, dc_fixpt_div_int( ++ dc_fixpt_add_int(data->ratios.horz_c, data->taps.h_taps_c + 1), 2)); + +- data->inits.v = dal_fixed31_32_div_int( +- dal_fixed31_32_add_int(data->ratios.vert, data->taps.v_taps + 1), 2); ++ data->inits.v = dc_fixpt_div_int( ++ dc_fixpt_add_int(data->ratios.vert, data->taps.v_taps + 1), 2); + +- data->inits.v_c = dal_fixed31_32_add(data->inits.v_c, dal_fixed31_32_div_int( +- dal_fixed31_32_add_int(data->ratios.vert_c, data->taps.v_taps_c + 1), 2)); ++ data->inits.v_c = dc_fixpt_add(data->inits.v_c, dc_fixpt_div_int( ++ dc_fixpt_add_int(data->ratios.vert_c, data->taps.v_taps_c + 1), 2)); + + + /* Adjust for viewport end clip-off */ + if ((data->viewport.x + data->viewport.width) < (src.x + src.width) && !flip_horz_scan_dir) { + int vp_clip = src.x + src.width - data->viewport.width - data->viewport.x; +- int int_part = dal_fixed31_32_floor( +- dal_fixed31_32_sub(data->inits.h, data->ratios.horz)); ++ int int_part = dc_fixpt_floor( ++ dc_fixpt_sub(data->inits.h, data->ratios.horz)); + + int_part = int_part > 0 ? int_part : 0; + data->viewport.width += int_part < vp_clip ? int_part : vp_clip; + } + if ((data->viewport.y + data->viewport.height) < (src.y + src.height) && !flip_vert_scan_dir) { + int vp_clip = src.y + src.height - data->viewport.height - data->viewport.y; +- int int_part = dal_fixed31_32_floor( +- dal_fixed31_32_sub(data->inits.v, data->ratios.vert)); ++ int int_part = dc_fixpt_floor( ++ dc_fixpt_sub(data->inits.v, data->ratios.vert)); + + int_part = int_part > 0 ? int_part : 0; + data->viewport.height += int_part < vp_clip ? int_part : vp_clip; +@@ -720,8 +720,8 @@ static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx, struct view *r + if ((data->viewport_c.x + data->viewport_c.width) < (src.x + src.width) / vpc_div && !flip_horz_scan_dir) { + int vp_clip = (src.x + src.width) / vpc_div - + data->viewport_c.width - data->viewport_c.x; +- int int_part = dal_fixed31_32_floor( +- dal_fixed31_32_sub(data->inits.h_c, data->ratios.horz_c)); ++ int int_part = dc_fixpt_floor( ++ dc_fixpt_sub(data->inits.h_c, data->ratios.horz_c)); + + int_part = int_part > 0 ? int_part : 0; + data->viewport_c.width += int_part < vp_clip ? int_part : vp_clip; +@@ -729,8 +729,8 @@ static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx, struct view *r + if ((data->viewport_c.y + data->viewport_c.height) < (src.y + src.height) / vpc_div && !flip_vert_scan_dir) { + int vp_clip = (src.y + src.height) / vpc_div - + data->viewport_c.height - data->viewport_c.y; +- int int_part = dal_fixed31_32_floor( +- dal_fixed31_32_sub(data->inits.v_c, data->ratios.vert_c)); ++ int int_part = dc_fixpt_floor( ++ dc_fixpt_sub(data->inits.v_c, data->ratios.vert_c)); + + int_part = int_part > 0 ? int_part : 0; + data->viewport_c.height += int_part < vp_clip ? int_part : vp_clip; +@@ -740,9 +740,9 @@ static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx, struct view *r + if (data->viewport.x && !flip_horz_scan_dir) { + int int_part; + +- data->inits.h = dal_fixed31_32_add(data->inits.h, dal_fixed31_32_mul_int( ++ data->inits.h = dc_fixpt_add(data->inits.h, dc_fixpt_mul_int( + data->ratios.horz, recout_skip->width)); +- int_part = dal_fixed31_32_floor(data->inits.h) - data->viewport.x; ++ int_part = dc_fixpt_floor(data->inits.h) - data->viewport.x; + if (int_part < data->taps.h_taps) { + int int_adj = data->viewport.x >= (data->taps.h_taps - int_part) ? + (data->taps.h_taps - int_part) : data->viewport.x; +@@ -755,15 +755,15 @@ static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx, struct view *r + int_part = data->taps.h_taps; + } + data->inits.h.value &= 0xffffffff; +- data->inits.h = dal_fixed31_32_add_int(data->inits.h, int_part); ++ data->inits.h = dc_fixpt_add_int(data->inits.h, int_part); + } + + if (data->viewport_c.x && !flip_horz_scan_dir) { + int int_part; + +- data->inits.h_c = dal_fixed31_32_add(data->inits.h_c, dal_fixed31_32_mul_int( ++ data->inits.h_c = dc_fixpt_add(data->inits.h_c, dc_fixpt_mul_int( + data->ratios.horz_c, recout_skip->width)); +- int_part = dal_fixed31_32_floor(data->inits.h_c) - data->viewport_c.x; ++ int_part = dc_fixpt_floor(data->inits.h_c) - data->viewport_c.x; + if (int_part < data->taps.h_taps_c) { + int int_adj = data->viewport_c.x >= (data->taps.h_taps_c - int_part) ? + (data->taps.h_taps_c - int_part) : data->viewport_c.x; +@@ -776,15 +776,15 @@ static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx, struct view *r + int_part = data->taps.h_taps_c; + } + data->inits.h_c.value &= 0xffffffff; +- data->inits.h_c = dal_fixed31_32_add_int(data->inits.h_c, int_part); ++ data->inits.h_c = dc_fixpt_add_int(data->inits.h_c, int_part); + } + + if (data->viewport.y && !flip_vert_scan_dir) { + int int_part; + +- data->inits.v = dal_fixed31_32_add(data->inits.v, dal_fixed31_32_mul_int( ++ data->inits.v = dc_fixpt_add(data->inits.v, dc_fixpt_mul_int( + data->ratios.vert, recout_skip->height)); +- int_part = dal_fixed31_32_floor(data->inits.v) - data->viewport.y; ++ int_part = dc_fixpt_floor(data->inits.v) - data->viewport.y; + if (int_part < data->taps.v_taps) { + int int_adj = data->viewport.y >= (data->taps.v_taps - int_part) ? + (data->taps.v_taps - int_part) : data->viewport.y; +@@ -797,15 +797,15 @@ static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx, struct view *r + int_part = data->taps.v_taps; + } + data->inits.v.value &= 0xffffffff; +- data->inits.v = dal_fixed31_32_add_int(data->inits.v, int_part); ++ data->inits.v = dc_fixpt_add_int(data->inits.v, int_part); + } + + if (data->viewport_c.y && !flip_vert_scan_dir) { + int int_part; + +- data->inits.v_c = dal_fixed31_32_add(data->inits.v_c, dal_fixed31_32_mul_int( ++ data->inits.v_c = dc_fixpt_add(data->inits.v_c, dc_fixpt_mul_int( + data->ratios.vert_c, recout_skip->height)); +- int_part = dal_fixed31_32_floor(data->inits.v_c) - data->viewport_c.y; ++ int_part = dc_fixpt_floor(data->inits.v_c) - data->viewport_c.y; + if (int_part < data->taps.v_taps_c) { + int int_adj = data->viewport_c.y >= (data->taps.v_taps_c - int_part) ? + (data->taps.v_taps_c - int_part) : data->viewport_c.y; +@@ -818,12 +818,12 @@ static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx, struct view *r + int_part = data->taps.v_taps_c; + } + data->inits.v_c.value &= 0xffffffff; +- data->inits.v_c = dal_fixed31_32_add_int(data->inits.v_c, int_part); ++ data->inits.v_c = dc_fixpt_add_int(data->inits.v_c, int_part); + } + + /* Interlaced inits based on final vert inits */ +- data->inits.v_bot = dal_fixed31_32_add(data->inits.v, data->ratios.vert); +- data->inits.v_c_bot = dal_fixed31_32_add(data->inits.v_c, data->ratios.vert_c); ++ data->inits.v_bot = dc_fixpt_add(data->inits.v, data->ratios.vert); ++ data->inits.v_c_bot = dc_fixpt_add(data->inits.v_c, data->ratios.vert_c); + + if (pipe_ctx->plane_state->rotation == ROTATION_ANGLE_90 || + pipe_ctx->plane_state->rotation == ROTATION_ANGLE_270) { +diff --git a/drivers/gpu/drm/amd/display/dc/dc_dp_types.h b/drivers/gpu/drm/amd/display/dc/dc_dp_types.h +index 2726b02..90bccd5 100644 +--- a/drivers/gpu/drm/amd/display/dc/dc_dp_types.h ++++ b/drivers/gpu/drm/amd/display/dc/dc_dp_types.h +@@ -26,6 +26,8 @@ + #ifndef DC_DP_TYPES_H + #define DC_DP_TYPES_H + ++#include "os_types.h" ++ + enum dc_lane_count { + LANE_COUNT_UNKNOWN = 0, + LANE_COUNT_ONE = 1, +diff --git a/drivers/gpu/drm/amd/display/dc/dc_types.h b/drivers/gpu/drm/amd/display/dc/dc_types.h +index 5e041b7..f530871 100644 +--- a/drivers/gpu/drm/amd/display/dc/dc_types.h ++++ b/drivers/gpu/drm/amd/display/dc/dc_types.h +@@ -25,7 +25,7 @@ + #ifndef DC_TYPES_H_ + #define DC_TYPES_H_ + +-#include "fixed32_32.h" ++#include "os_types.h" + #include "fixed31_32.h" + #include "irq_types.h" + #include "dc_dp_types.h" +diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_abm.c b/drivers/gpu/drm/amd/display/dc/dce/dce_abm.c +index fe92a12..29294db 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce/dce_abm.c ++++ b/drivers/gpu/drm/amd/display/dc/dce/dce_abm.c +@@ -26,7 +26,7 @@ + #include "dce_abm.h" + #include "dm_services.h" + #include "reg_helper.h" +-#include "fixed32_32.h" ++#include "fixed31_32.h" + #include "dc.h" + + #include "atom.h" +diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_clock_source.c b/drivers/gpu/drm/amd/display/dc/dce/dce_clock_source.c +index 0570e7e..599c7ab 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce/dce_clock_source.c ++++ b/drivers/gpu/drm/amd/display/dc/dce/dce_clock_source.c +@@ -657,12 +657,12 @@ static uint32_t dce110_get_d_to_pixel_rate_in_hz( + return 0; + } + +- pix_rate = dal_fixed31_32_from_int(clk_src->ref_freq_khz); +- pix_rate = dal_fixed31_32_mul_int(pix_rate, 1000); +- pix_rate = dal_fixed31_32_mul_int(pix_rate, phase); +- pix_rate = dal_fixed31_32_div_int(pix_rate, modulo); ++ pix_rate = dc_fixpt_from_int(clk_src->ref_freq_khz); ++ pix_rate = dc_fixpt_mul_int(pix_rate, 1000); ++ pix_rate = dc_fixpt_mul_int(pix_rate, phase); ++ pix_rate = dc_fixpt_div_int(pix_rate, modulo); + +- return dal_fixed31_32_round(pix_rate); ++ return dc_fixpt_round(pix_rate); + } else { + return dce110_get_dp_pixel_rate_from_combo_phy_pll(cs, pix_clk_params, pll_settings); + } +@@ -711,12 +711,12 @@ static bool calculate_ss( + const struct spread_spectrum_data *ss_data, + struct delta_sigma_data *ds_data) + { +- struct fixed32_32 fb_div; +- struct fixed32_32 ss_amount; +- struct fixed32_32 ss_nslip_amount; +- struct fixed32_32 ss_ds_frac_amount; +- struct fixed32_32 ss_step_size; +- struct fixed32_32 modulation_time; ++ struct fixed31_32 fb_div; ++ struct fixed31_32 ss_amount; ++ struct fixed31_32 ss_nslip_amount; ++ struct fixed31_32 ss_ds_frac_amount; ++ struct fixed31_32 ss_step_size; ++ struct fixed31_32 modulation_time; + + if (ds_data == NULL) + return false; +@@ -731,42 +731,42 @@ static bool calculate_ss( + + /* compute SS_AMOUNT_FBDIV & SS_AMOUNT_NFRAC_SLIP & SS_AMOUNT_DSFRAC*/ + /* 6 decimal point support in fractional feedback divider */ +- fb_div = dal_fixed32_32_from_fraction( ++ fb_div = dc_fixpt_from_fraction( + pll_settings->fract_feedback_divider, 1000000); +- fb_div = dal_fixed32_32_add_int(fb_div, pll_settings->feedback_divider); ++ fb_div = dc_fixpt_add_int(fb_div, pll_settings->feedback_divider); + + ds_data->ds_frac_amount = 0; + /*spreadSpectrumPercentage is in the unit of .01%, + * so have to divided by 100 * 100*/ +- ss_amount = dal_fixed32_32_mul( +- fb_div, dal_fixed32_32_from_fraction(ss_data->percentage, ++ ss_amount = dc_fixpt_mul( ++ fb_div, dc_fixpt_from_fraction(ss_data->percentage, + 100 * ss_data->percentage_divider)); +- ds_data->feedback_amount = dal_fixed32_32_floor(ss_amount); ++ ds_data->feedback_amount = dc_fixpt_floor(ss_amount); + +- ss_nslip_amount = dal_fixed32_32_sub(ss_amount, +- dal_fixed32_32_from_int(ds_data->feedback_amount)); +- ss_nslip_amount = dal_fixed32_32_mul_int(ss_nslip_amount, 10); +- ds_data->nfrac_amount = dal_fixed32_32_floor(ss_nslip_amount); ++ ss_nslip_amount = dc_fixpt_sub(ss_amount, ++ dc_fixpt_from_int(ds_data->feedback_amount)); ++ ss_nslip_amount = dc_fixpt_mul_int(ss_nslip_amount, 10); ++ ds_data->nfrac_amount = dc_fixpt_floor(ss_nslip_amount); + +- ss_ds_frac_amount = dal_fixed32_32_sub(ss_nslip_amount, +- dal_fixed32_32_from_int(ds_data->nfrac_amount)); +- ss_ds_frac_amount = dal_fixed32_32_mul_int(ss_ds_frac_amount, 65536); +- ds_data->ds_frac_amount = dal_fixed32_32_floor(ss_ds_frac_amount); ++ ss_ds_frac_amount = dc_fixpt_sub(ss_nslip_amount, ++ dc_fixpt_from_int(ds_data->nfrac_amount)); ++ ss_ds_frac_amount = dc_fixpt_mul_int(ss_ds_frac_amount, 65536); ++ ds_data->ds_frac_amount = dc_fixpt_floor(ss_ds_frac_amount); + + /* compute SS_STEP_SIZE_DSFRAC */ +- modulation_time = dal_fixed32_32_from_fraction( ++ modulation_time = dc_fixpt_from_fraction( + pll_settings->reference_freq * 1000, + pll_settings->reference_divider * ss_data->modulation_freq_hz); + + if (ss_data->flags.CENTER_SPREAD) +- modulation_time = dal_fixed32_32_div_int(modulation_time, 4); ++ modulation_time = dc_fixpt_div_int(modulation_time, 4); + else +- modulation_time = dal_fixed32_32_div_int(modulation_time, 2); ++ modulation_time = dc_fixpt_div_int(modulation_time, 2); + +- ss_step_size = dal_fixed32_32_div(ss_amount, modulation_time); ++ ss_step_size = dc_fixpt_div(ss_amount, modulation_time); + /* SS_STEP_SIZE_DSFRAC_DEC = Int(SS_STEP_SIZE * 2 ^ 16 * 10)*/ +- ss_step_size = dal_fixed32_32_mul_int(ss_step_size, 65536 * 10); +- ds_data->ds_frac_size = dal_fixed32_32_floor(ss_step_size); ++ ss_step_size = dc_fixpt_mul_int(ss_step_size, 65536 * 10); ++ ds_data->ds_frac_size = dc_fixpt_floor(ss_step_size); + + return true; + } +diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_clocks.c b/drivers/gpu/drm/amd/display/dc/dce/dce_clocks.c +index f043e5e..8a581c6 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce/dce_clocks.c ++++ b/drivers/gpu/drm/amd/display/dc/dce/dce_clocks.c +@@ -26,7 +26,7 @@ + #include "dce_clocks.h" + #include "dm_services.h" + #include "reg_helper.h" +-#include "fixed32_32.h" ++#include "fixed31_32.h" + #include "bios_parser_interface.h" + #include "dc.h" + #include "dmcu.h" +@@ -228,19 +228,19 @@ static int dce_clocks_get_dp_ref_freq(struct display_clock *clk) + generated according to average value (case as with previous ASICs) + */ + if (clk_dce->ss_on_dprefclk && clk_dce->dprefclk_ss_divider != 0) { +- struct fixed32_32 ss_percentage = dal_fixed32_32_div_int( +- dal_fixed32_32_from_fraction( ++ struct fixed31_32 ss_percentage = dc_fixpt_div_int( ++ dc_fixpt_from_fraction( + clk_dce->dprefclk_ss_percentage, + clk_dce->dprefclk_ss_divider), 200); +- struct fixed32_32 adj_dp_ref_clk_khz; ++ struct fixed31_32 adj_dp_ref_clk_khz; + +- ss_percentage = dal_fixed32_32_sub(dal_fixed32_32_one, ++ ss_percentage = dc_fixpt_sub(dc_fixpt_one, + ss_percentage); + adj_dp_ref_clk_khz = +- dal_fixed32_32_mul_int( ++ dc_fixpt_mul_int( + ss_percentage, + dp_ref_clk_khz); +- dp_ref_clk_khz = dal_fixed32_32_floor(adj_dp_ref_clk_khz); ++ dp_ref_clk_khz = dc_fixpt_floor(adj_dp_ref_clk_khz); + } + + return dp_ref_clk_khz; +@@ -256,19 +256,19 @@ static int dce_clocks_get_dp_ref_freq_wrkaround(struct display_clock *clk) + int dp_ref_clk_khz = 600000; + + if (clk_dce->ss_on_dprefclk && clk_dce->dprefclk_ss_divider != 0) { +- struct fixed32_32 ss_percentage = dal_fixed32_32_div_int( +- dal_fixed32_32_from_fraction( ++ struct fixed31_32 ss_percentage = dc_fixpt_div_int( ++ dc_fixpt_from_fraction( + clk_dce->dprefclk_ss_percentage, + clk_dce->dprefclk_ss_divider), 200); +- struct fixed32_32 adj_dp_ref_clk_khz; ++ struct fixed31_32 adj_dp_ref_clk_khz; + +- ss_percentage = dal_fixed32_32_sub(dal_fixed32_32_one, ++ ss_percentage = dc_fixpt_sub(dc_fixpt_one, + ss_percentage); + adj_dp_ref_clk_khz = +- dal_fixed32_32_mul_int( ++ dc_fixpt_mul_int( + ss_percentage, + dp_ref_clk_khz); +- dp_ref_clk_khz = dal_fixed32_32_floor(adj_dp_ref_clk_khz); ++ dp_ref_clk_khz = dc_fixpt_floor(adj_dp_ref_clk_khz); + } + + return dp_ref_clk_khz; +diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_dmcu.c b/drivers/gpu/drm/amd/display/dc/dce/dce_dmcu.c +index 2ee3d9b..a576b8b 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce/dce_dmcu.c ++++ b/drivers/gpu/drm/amd/display/dc/dce/dce_dmcu.c +@@ -28,7 +28,7 @@ + #include "dce_dmcu.h" + #include "dm_services.h" + #include "reg_helper.h" +-#include "fixed32_32.h" ++#include "fixed31_32.h" + #include "dc.h" + + #define TO_DCE_DMCU(dmcu)\ +diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_ipp.c b/drivers/gpu/drm/amd/display/dc/dce/dce_ipp.c +index d737e91..5d9506b 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce/dce_ipp.c ++++ b/drivers/gpu/drm/amd/display/dc/dce/dce_ipp.c +@@ -195,13 +195,13 @@ static void dce_ipp_program_input_lut( + + for (i = 0; i < gamma->num_entries; i++) { + REG_SET(DC_LUT_SEQ_COLOR, 0, DC_LUT_SEQ_COLOR, +- dal_fixed31_32_round( ++ dc_fixpt_round( + gamma->entries.red[i])); + REG_SET(DC_LUT_SEQ_COLOR, 0, DC_LUT_SEQ_COLOR, +- dal_fixed31_32_round( ++ dc_fixpt_round( + gamma->entries.green[i])); + REG_SET(DC_LUT_SEQ_COLOR, 0, DC_LUT_SEQ_COLOR, +- dal_fixed31_32_round( ++ dc_fixpt_round( + gamma->entries.blue[i])); + } + +diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_scl_filters.c b/drivers/gpu/drm/amd/display/dc/dce/dce_scl_filters.c +index 6243450..48862be 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce/dce_scl_filters.c ++++ b/drivers/gpu/drm/amd/display/dc/dce/dce_scl_filters.c +@@ -1014,11 +1014,11 @@ static const uint16_t filter_8tap_64p_183[264] = { + + const uint16_t *get_filter_3tap_16p(struct fixed31_32 ratio) + { +- if (ratio.value < dal_fixed31_32_one.value) ++ if (ratio.value < dc_fixpt_one.value) + return filter_3tap_16p_upscale; +- else if (ratio.value < dal_fixed31_32_from_fraction(4, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(4, 3).value) + return filter_3tap_16p_117; +- else if (ratio.value < dal_fixed31_32_from_fraction(5, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(5, 3).value) + return filter_3tap_16p_150; + else + return filter_3tap_16p_183; +@@ -1026,11 +1026,11 @@ const uint16_t *get_filter_3tap_16p(struct fixed31_32 ratio) + + const uint16_t *get_filter_3tap_64p(struct fixed31_32 ratio) + { +- if (ratio.value < dal_fixed31_32_one.value) ++ if (ratio.value < dc_fixpt_one.value) + return filter_3tap_64p_upscale; +- else if (ratio.value < dal_fixed31_32_from_fraction(4, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(4, 3).value) + return filter_3tap_64p_117; +- else if (ratio.value < dal_fixed31_32_from_fraction(5, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(5, 3).value) + return filter_3tap_64p_150; + else + return filter_3tap_64p_183; +@@ -1038,11 +1038,11 @@ const uint16_t *get_filter_3tap_64p(struct fixed31_32 ratio) + + const uint16_t *get_filter_4tap_16p(struct fixed31_32 ratio) + { +- if (ratio.value < dal_fixed31_32_one.value) ++ if (ratio.value < dc_fixpt_one.value) + return filter_4tap_16p_upscale; +- else if (ratio.value < dal_fixed31_32_from_fraction(4, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(4, 3).value) + return filter_4tap_16p_117; +- else if (ratio.value < dal_fixed31_32_from_fraction(5, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(5, 3).value) + return filter_4tap_16p_150; + else + return filter_4tap_16p_183; +@@ -1050,11 +1050,11 @@ const uint16_t *get_filter_4tap_16p(struct fixed31_32 ratio) + + const uint16_t *get_filter_4tap_64p(struct fixed31_32 ratio) + { +- if (ratio.value < dal_fixed31_32_one.value) ++ if (ratio.value < dc_fixpt_one.value) + return filter_4tap_64p_upscale; +- else if (ratio.value < dal_fixed31_32_from_fraction(4, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(4, 3).value) + return filter_4tap_64p_117; +- else if (ratio.value < dal_fixed31_32_from_fraction(5, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(5, 3).value) + return filter_4tap_64p_150; + else + return filter_4tap_64p_183; +@@ -1062,11 +1062,11 @@ const uint16_t *get_filter_4tap_64p(struct fixed31_32 ratio) + + const uint16_t *get_filter_5tap_64p(struct fixed31_32 ratio) + { +- if (ratio.value < dal_fixed31_32_one.value) ++ if (ratio.value < dc_fixpt_one.value) + return filter_5tap_64p_upscale; +- else if (ratio.value < dal_fixed31_32_from_fraction(4, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(4, 3).value) + return filter_5tap_64p_117; +- else if (ratio.value < dal_fixed31_32_from_fraction(5, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(5, 3).value) + return filter_5tap_64p_150; + else + return filter_5tap_64p_183; +@@ -1074,11 +1074,11 @@ const uint16_t *get_filter_5tap_64p(struct fixed31_32 ratio) + + const uint16_t *get_filter_6tap_64p(struct fixed31_32 ratio) + { +- if (ratio.value < dal_fixed31_32_one.value) ++ if (ratio.value < dc_fixpt_one.value) + return filter_6tap_64p_upscale; +- else if (ratio.value < dal_fixed31_32_from_fraction(4, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(4, 3).value) + return filter_6tap_64p_117; +- else if (ratio.value < dal_fixed31_32_from_fraction(5, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(5, 3).value) + return filter_6tap_64p_150; + else + return filter_6tap_64p_183; +@@ -1086,11 +1086,11 @@ const uint16_t *get_filter_6tap_64p(struct fixed31_32 ratio) + + const uint16_t *get_filter_7tap_64p(struct fixed31_32 ratio) + { +- if (ratio.value < dal_fixed31_32_one.value) ++ if (ratio.value < dc_fixpt_one.value) + return filter_7tap_64p_upscale; +- else if (ratio.value < dal_fixed31_32_from_fraction(4, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(4, 3).value) + return filter_7tap_64p_117; +- else if (ratio.value < dal_fixed31_32_from_fraction(5, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(5, 3).value) + return filter_7tap_64p_150; + else + return filter_7tap_64p_183; +@@ -1098,11 +1098,11 @@ const uint16_t *get_filter_7tap_64p(struct fixed31_32 ratio) + + const uint16_t *get_filter_8tap_64p(struct fixed31_32 ratio) + { +- if (ratio.value < dal_fixed31_32_one.value) ++ if (ratio.value < dc_fixpt_one.value) + return filter_8tap_64p_upscale; +- else if (ratio.value < dal_fixed31_32_from_fraction(4, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(4, 3).value) + return filter_8tap_64p_117; +- else if (ratio.value < dal_fixed31_32_from_fraction(5, 3).value) ++ else if (ratio.value < dc_fixpt_from_fraction(5, 3).value) + return filter_8tap_64p_150; + else + return filter_8tap_64p_183; +diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_stream_encoder.c b/drivers/gpu/drm/amd/display/dc/dce/dce_stream_encoder.c +index e265a0a..0a6d483 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce/dce_stream_encoder.c ++++ b/drivers/gpu/drm/amd/display/dc/dce/dce_stream_encoder.c +@@ -683,11 +683,11 @@ static void dce110_stream_encoder_set_mst_bandwidth( + struct fixed31_32 avg_time_slots_per_mtp) + { + struct dce110_stream_encoder *enc110 = DCE110STRENC_FROM_STRENC(enc); +- uint32_t x = dal_fixed31_32_floor( ++ uint32_t x = dc_fixpt_floor( + avg_time_slots_per_mtp); +- uint32_t y = dal_fixed31_32_ceil( +- dal_fixed31_32_shl( +- dal_fixed31_32_sub_int( ++ uint32_t y = dc_fixpt_ceil( ++ dc_fixpt_shl( ++ dc_fixpt_sub_int( + avg_time_slots_per_mtp, + x), + 26)); +diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_transform.c b/drivers/gpu/drm/amd/display/dc/dce/dce_transform.c +index 832c5da..a02e719 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce/dce_transform.c ++++ b/drivers/gpu/drm/amd/display/dc/dce/dce_transform.c +@@ -41,7 +41,7 @@ + #define DC_LOGGER \ + xfm_dce->base.ctx->logger + +-#define IDENTITY_RATIO(ratio) (dal_fixed31_32_u2d19(ratio) == (1 << 19)) ++#define IDENTITY_RATIO(ratio) (dc_fixpt_u2d19(ratio) == (1 << 19)) + #define GAMUT_MATRIX_SIZE 12 + #define SCL_PHASES 16 + +@@ -256,27 +256,27 @@ static void calculate_inits( + struct fixed31_32 v_init; + + inits->h_int_scale_ratio = +- dal_fixed31_32_u2d19(data->ratios.horz) << 5; ++ dc_fixpt_u2d19(data->ratios.horz) << 5; + inits->v_int_scale_ratio = +- dal_fixed31_32_u2d19(data->ratios.vert) << 5; ++ dc_fixpt_u2d19(data->ratios.vert) << 5; + + h_init = +- dal_fixed31_32_div_int( +- dal_fixed31_32_add( ++ dc_fixpt_div_int( ++ dc_fixpt_add( + data->ratios.horz, +- dal_fixed31_32_from_int(data->taps.h_taps + 1)), ++ dc_fixpt_from_int(data->taps.h_taps + 1)), + 2); +- inits->h_init.integer = dal_fixed31_32_floor(h_init); +- inits->h_init.fraction = dal_fixed31_32_u0d19(h_init) << 5; ++ inits->h_init.integer = dc_fixpt_floor(h_init); ++ inits->h_init.fraction = dc_fixpt_u0d19(h_init) << 5; + + v_init = +- dal_fixed31_32_div_int( +- dal_fixed31_32_add( ++ dc_fixpt_div_int( ++ dc_fixpt_add( + data->ratios.vert, +- dal_fixed31_32_from_int(data->taps.v_taps + 1)), ++ dc_fixpt_from_int(data->taps.v_taps + 1)), + 2); +- inits->v_init.integer = dal_fixed31_32_floor(v_init); +- inits->v_init.fraction = dal_fixed31_32_u0d19(v_init) << 5; ++ inits->v_init.integer = dc_fixpt_floor(v_init); ++ inits->v_init.fraction = dc_fixpt_u0d19(v_init) << 5; + } + + static void program_scl_ratios_inits( +diff --git a/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c b/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c +index 8a61b10..5fcb67a 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c ++++ b/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c +@@ -509,19 +509,19 @@ dce110_translate_regamma_to_hw_format(const struct dc_transfer_func *output_tf, + rgb_resulted[hw_points - 1].green = output_tf->tf_pts.green[start_index]; + rgb_resulted[hw_points - 1].blue = output_tf->tf_pts.blue[start_index]; + +- arr_points[0].x = dal_fixed31_32_pow(dal_fixed31_32_from_int(2), +- dal_fixed31_32_from_int(region_start)); +- arr_points[1].x = dal_fixed31_32_pow(dal_fixed31_32_from_int(2), +- dal_fixed31_32_from_int(region_end)); ++ arr_points[0].x = dc_fixpt_pow(dc_fixpt_from_int(2), ++ dc_fixpt_from_int(region_start)); ++ arr_points[1].x = dc_fixpt_pow(dc_fixpt_from_int(2), ++ dc_fixpt_from_int(region_end)); + + y_r = rgb_resulted[0].red; + y_g = rgb_resulted[0].green; + y_b = rgb_resulted[0].blue; + +- y1_min = dal_fixed31_32_min(y_r, dal_fixed31_32_min(y_g, y_b)); ++ y1_min = dc_fixpt_min(y_r, dc_fixpt_min(y_g, y_b)); + + arr_points[0].y = y1_min; +- arr_points[0].slope = dal_fixed31_32_div(arr_points[0].y, ++ arr_points[0].slope = dc_fixpt_div(arr_points[0].y, + arr_points[0].x); + + y_r = rgb_resulted[hw_points - 1].red; +@@ -531,21 +531,21 @@ dce110_translate_regamma_to_hw_format(const struct dc_transfer_func *output_tf, + /* see comment above, m_arrPoints[1].y should be the Y value for the + * region end (m_numOfHwPoints), not last HW point(m_numOfHwPoints - 1) + */ +- y3_max = dal_fixed31_32_max(y_r, dal_fixed31_32_max(y_g, y_b)); ++ y3_max = dc_fixpt_max(y_r, dc_fixpt_max(y_g, y_b)); + + arr_points[1].y = y3_max; + +- arr_points[1].slope = dal_fixed31_32_zero; ++ arr_points[1].slope = dc_fixpt_zero; + + if (output_tf->tf == TRANSFER_FUNCTION_PQ) { + /* for PQ, we want to have a straight line from last HW X point, + * and the slope to be such that we hit 1.0 at 10000 nits. + */ +- const struct fixed31_32 end_value = dal_fixed31_32_from_int(125); ++ const struct fixed31_32 end_value = dc_fixpt_from_int(125); + +- arr_points[1].slope = dal_fixed31_32_div( +- dal_fixed31_32_sub(dal_fixed31_32_one, arr_points[1].y), +- dal_fixed31_32_sub(end_value, arr_points[1].x)); ++ arr_points[1].slope = dc_fixpt_div( ++ dc_fixpt_sub(dc_fixpt_one, arr_points[1].y), ++ dc_fixpt_sub(end_value, arr_points[1].x)); + } + + regamma_params->hw_points_num = hw_points; +@@ -569,16 +569,16 @@ dce110_translate_regamma_to_hw_format(const struct dc_transfer_func *output_tf, + i = 1; + + while (i != hw_points + 1) { +- if (dal_fixed31_32_lt(rgb_plus_1->red, rgb->red)) ++ if (dc_fixpt_lt(rgb_plus_1->red, rgb->red)) + rgb_plus_1->red = rgb->red; +- if (dal_fixed31_32_lt(rgb_plus_1->green, rgb->green)) ++ if (dc_fixpt_lt(rgb_plus_1->green, rgb->green)) + rgb_plus_1->green = rgb->green; +- if (dal_fixed31_32_lt(rgb_plus_1->blue, rgb->blue)) ++ if (dc_fixpt_lt(rgb_plus_1->blue, rgb->blue)) + rgb_plus_1->blue = rgb->blue; + +- rgb->delta_red = dal_fixed31_32_sub(rgb_plus_1->red, rgb->red); +- rgb->delta_green = dal_fixed31_32_sub(rgb_plus_1->green, rgb->green); +- rgb->delta_blue = dal_fixed31_32_sub(rgb_plus_1->blue, rgb->blue); ++ rgb->delta_red = dc_fixpt_sub(rgb_plus_1->red, rgb->red); ++ rgb->delta_green = dc_fixpt_sub(rgb_plus_1->green, rgb->green); ++ rgb->delta_blue = dc_fixpt_sub(rgb_plus_1->blue, rgb->blue); + + ++rgb_plus_1; + ++rgb; +diff --git a/drivers/gpu/drm/amd/display/dc/dce110/dce110_transform_v.c b/drivers/gpu/drm/amd/display/dc/dce110/dce110_transform_v.c +index 8ba3c12..a7dce06 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce110/dce110_transform_v.c ++++ b/drivers/gpu/drm/amd/display/dc/dce110/dce110_transform_v.c +@@ -373,13 +373,13 @@ static void calculate_inits( + struct rect *chroma_viewport) + { + inits->h_int_scale_ratio_luma = +- dal_fixed31_32_u2d19(data->ratios.horz) << 5; ++ dc_fixpt_u2d19(data->ratios.horz) << 5; + inits->v_int_scale_ratio_luma = +- dal_fixed31_32_u2d19(data->ratios.vert) << 5; ++ dc_fixpt_u2d19(data->ratios.vert) << 5; + inits->h_int_scale_ratio_chroma = +- dal_fixed31_32_u2d19(data->ratios.horz_c) << 5; ++ dc_fixpt_u2d19(data->ratios.horz_c) << 5; + inits->v_int_scale_ratio_chroma = +- dal_fixed31_32_u2d19(data->ratios.vert_c) << 5; ++ dc_fixpt_u2d19(data->ratios.vert_c) << 5; + + inits->h_init_luma.integer = 1; + inits->v_init_luma.integer = 1; +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_cm_common.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_cm_common.c +index 96d5878..5d95a99 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_cm_common.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_cm_common.c +@@ -169,7 +169,7 @@ bool cm_helper_convert_to_custom_float( + } + + if (fixpoint == true) +- arr_points[1].custom_float_y = dal_fixed31_32_clamp_u0d14(arr_points[1].y); ++ arr_points[1].custom_float_y = dc_fixpt_clamp_u0d14(arr_points[1].y); + else if (!convert_to_custom_float_format(arr_points[1].y, &fmt, + &arr_points[1].custom_float_y)) { + BREAK_TO_DEBUGGER(); +@@ -327,19 +327,19 @@ bool cm_helper_translate_curve_to_hw_format( + rgb_resulted[hw_points - 1].green = output_tf->tf_pts.green[start_index]; + rgb_resulted[hw_points - 1].blue = output_tf->tf_pts.blue[start_index]; + +- arr_points[0].x = dal_fixed31_32_pow(dal_fixed31_32_from_int(2), +- dal_fixed31_32_from_int(region_start)); +- arr_points[1].x = dal_fixed31_32_pow(dal_fixed31_32_from_int(2), +- dal_fixed31_32_from_int(region_end)); ++ arr_points[0].x = dc_fixpt_pow(dc_fixpt_from_int(2), ++ dc_fixpt_from_int(region_start)); ++ arr_points[1].x = dc_fixpt_pow(dc_fixpt_from_int(2), ++ dc_fixpt_from_int(region_end)); + + y_r = rgb_resulted[0].red; + y_g = rgb_resulted[0].green; + y_b = rgb_resulted[0].blue; + +- y1_min = dal_fixed31_32_min(y_r, dal_fixed31_32_min(y_g, y_b)); ++ y1_min = dc_fixpt_min(y_r, dc_fixpt_min(y_g, y_b)); + + arr_points[0].y = y1_min; +- arr_points[0].slope = dal_fixed31_32_div(arr_points[0].y, arr_points[0].x); ++ arr_points[0].slope = dc_fixpt_div(arr_points[0].y, arr_points[0].x); + y_r = rgb_resulted[hw_points - 1].red; + y_g = rgb_resulted[hw_points - 1].green; + y_b = rgb_resulted[hw_points - 1].blue; +@@ -347,22 +347,22 @@ bool cm_helper_translate_curve_to_hw_format( + /* see comment above, m_arrPoints[1].y should be the Y value for the + * region end (m_numOfHwPoints), not last HW point(m_numOfHwPoints - 1) + */ +- y3_max = dal_fixed31_32_max(y_r, dal_fixed31_32_max(y_g, y_b)); ++ y3_max = dc_fixpt_max(y_r, dc_fixpt_max(y_g, y_b)); + + arr_points[1].y = y3_max; + +- arr_points[1].slope = dal_fixed31_32_zero; ++ arr_points[1].slope = dc_fixpt_zero; + + if (output_tf->tf == TRANSFER_FUNCTION_PQ) { + /* for PQ, we want to have a straight line from last HW X point, + * and the slope to be such that we hit 1.0 at 10000 nits. + */ + const struct fixed31_32 end_value = +- dal_fixed31_32_from_int(125); ++ dc_fixpt_from_int(125); + +- arr_points[1].slope = dal_fixed31_32_div( +- dal_fixed31_32_sub(dal_fixed31_32_one, arr_points[1].y), +- dal_fixed31_32_sub(end_value, arr_points[1].x)); ++ arr_points[1].slope = dc_fixpt_div( ++ dc_fixpt_sub(dc_fixpt_one, arr_points[1].y), ++ dc_fixpt_sub(end_value, arr_points[1].x)); + } + + lut_params->hw_points_num = hw_points; +@@ -386,24 +386,24 @@ bool cm_helper_translate_curve_to_hw_format( + + i = 1; + while (i != hw_points + 1) { +- if (dal_fixed31_32_lt(rgb_plus_1->red, rgb->red)) ++ if (dc_fixpt_lt(rgb_plus_1->red, rgb->red)) + rgb_plus_1->red = rgb->red; +- if (dal_fixed31_32_lt(rgb_plus_1->green, rgb->green)) ++ if (dc_fixpt_lt(rgb_plus_1->green, rgb->green)) + rgb_plus_1->green = rgb->green; +- if (dal_fixed31_32_lt(rgb_plus_1->blue, rgb->blue)) ++ if (dc_fixpt_lt(rgb_plus_1->blue, rgb->blue)) + rgb_plus_1->blue = rgb->blue; + +- rgb->delta_red = dal_fixed31_32_sub(rgb_plus_1->red, rgb->red); +- rgb->delta_green = dal_fixed31_32_sub(rgb_plus_1->green, rgb->green); +- rgb->delta_blue = dal_fixed31_32_sub(rgb_plus_1->blue, rgb->blue); ++ rgb->delta_red = dc_fixpt_sub(rgb_plus_1->red, rgb->red); ++ rgb->delta_green = dc_fixpt_sub(rgb_plus_1->green, rgb->green); ++ rgb->delta_blue = dc_fixpt_sub(rgb_plus_1->blue, rgb->blue); + + if (fixpoint == true) { +- rgb->delta_red_reg = dal_fixed31_32_clamp_u0d10(rgb->delta_red); +- rgb->delta_green_reg = dal_fixed31_32_clamp_u0d10(rgb->delta_green); +- rgb->delta_blue_reg = dal_fixed31_32_clamp_u0d10(rgb->delta_blue); +- rgb->red_reg = dal_fixed31_32_clamp_u0d14(rgb->red); +- rgb->green_reg = dal_fixed31_32_clamp_u0d14(rgb->green); +- rgb->blue_reg = dal_fixed31_32_clamp_u0d14(rgb->blue); ++ rgb->delta_red_reg = dc_fixpt_clamp_u0d10(rgb->delta_red); ++ rgb->delta_green_reg = dc_fixpt_clamp_u0d10(rgb->delta_green); ++ rgb->delta_blue_reg = dc_fixpt_clamp_u0d10(rgb->delta_blue); ++ rgb->red_reg = dc_fixpt_clamp_u0d14(rgb->red); ++ rgb->green_reg = dc_fixpt_clamp_u0d14(rgb->green); ++ rgb->blue_reg = dc_fixpt_clamp_u0d14(rgb->blue); + } + + ++rgb_plus_1; +@@ -489,19 +489,19 @@ bool cm_helper_translate_curve_to_degamma_hw_format( + rgb_resulted[hw_points - 1].green = output_tf->tf_pts.green[start_index]; + rgb_resulted[hw_points - 1].blue = output_tf->tf_pts.blue[start_index]; + +- arr_points[0].x = dal_fixed31_32_pow(dal_fixed31_32_from_int(2), +- dal_fixed31_32_from_int(region_start)); +- arr_points[1].x = dal_fixed31_32_pow(dal_fixed31_32_from_int(2), +- dal_fixed31_32_from_int(region_end)); ++ arr_points[0].x = dc_fixpt_pow(dc_fixpt_from_int(2), ++ dc_fixpt_from_int(region_start)); ++ arr_points[1].x = dc_fixpt_pow(dc_fixpt_from_int(2), ++ dc_fixpt_from_int(region_end)); + + y_r = rgb_resulted[0].red; + y_g = rgb_resulted[0].green; + y_b = rgb_resulted[0].blue; + +- y1_min = dal_fixed31_32_min(y_r, dal_fixed31_32_min(y_g, y_b)); ++ y1_min = dc_fixpt_min(y_r, dc_fixpt_min(y_g, y_b)); + + arr_points[0].y = y1_min; +- arr_points[0].slope = dal_fixed31_32_div(arr_points[0].y, arr_points[0].x); ++ arr_points[0].slope = dc_fixpt_div(arr_points[0].y, arr_points[0].x); + y_r = rgb_resulted[hw_points - 1].red; + y_g = rgb_resulted[hw_points - 1].green; + y_b = rgb_resulted[hw_points - 1].blue; +@@ -509,22 +509,22 @@ bool cm_helper_translate_curve_to_degamma_hw_format( + /* see comment above, m_arrPoints[1].y should be the Y value for the + * region end (m_numOfHwPoints), not last HW point(m_numOfHwPoints - 1) + */ +- y3_max = dal_fixed31_32_max(y_r, dal_fixed31_32_max(y_g, y_b)); ++ y3_max = dc_fixpt_max(y_r, dc_fixpt_max(y_g, y_b)); + + arr_points[1].y = y3_max; + +- arr_points[1].slope = dal_fixed31_32_zero; ++ arr_points[1].slope = dc_fixpt_zero; + + if (output_tf->tf == TRANSFER_FUNCTION_PQ) { + /* for PQ, we want to have a straight line from last HW X point, + * and the slope to be such that we hit 1.0 at 10000 nits. + */ + const struct fixed31_32 end_value = +- dal_fixed31_32_from_int(125); ++ dc_fixpt_from_int(125); + +- arr_points[1].slope = dal_fixed31_32_div( +- dal_fixed31_32_sub(dal_fixed31_32_one, arr_points[1].y), +- dal_fixed31_32_sub(end_value, arr_points[1].x)); ++ arr_points[1].slope = dc_fixpt_div( ++ dc_fixpt_sub(dc_fixpt_one, arr_points[1].y), ++ dc_fixpt_sub(end_value, arr_points[1].x)); + } + + lut_params->hw_points_num = hw_points; +@@ -548,16 +548,16 @@ bool cm_helper_translate_curve_to_degamma_hw_format( + + i = 1; + while (i != hw_points + 1) { +- if (dal_fixed31_32_lt(rgb_plus_1->red, rgb->red)) ++ if (dc_fixpt_lt(rgb_plus_1->red, rgb->red)) + rgb_plus_1->red = rgb->red; +- if (dal_fixed31_32_lt(rgb_plus_1->green, rgb->green)) ++ if (dc_fixpt_lt(rgb_plus_1->green, rgb->green)) + rgb_plus_1->green = rgb->green; +- if (dal_fixed31_32_lt(rgb_plus_1->blue, rgb->blue)) ++ if (dc_fixpt_lt(rgb_plus_1->blue, rgb->blue)) + rgb_plus_1->blue = rgb->blue; + +- rgb->delta_red = dal_fixed31_32_sub(rgb_plus_1->red, rgb->red); +- rgb->delta_green = dal_fixed31_32_sub(rgb_plus_1->green, rgb->green); +- rgb->delta_blue = dal_fixed31_32_sub(rgb_plus_1->blue, rgb->blue); ++ rgb->delta_red = dc_fixpt_sub(rgb_plus_1->red, rgb->red); ++ rgb->delta_green = dc_fixpt_sub(rgb_plus_1->green, rgb->green); ++ rgb->delta_blue = dc_fixpt_sub(rgb_plus_1->blue, rgb->blue); + + ++rgb_plus_1; + ++rgb; +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp.c +index 8c4d9e5..20796da 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp.c +@@ -130,7 +130,7 @@ void dpp_set_gamut_remap_bypass(struct dcn10_dpp *dpp) + /* Gamut remap in bypass */ + } + +-#define IDENTITY_RATIO(ratio) (dal_fixed31_32_u2d19(ratio) == (1 << 19)) ++#define IDENTITY_RATIO(ratio) (dc_fixpt_u2d19(ratio) == (1 << 19)) + + + bool dpp_get_optimal_number_of_taps( +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_cm.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_cm.c +index 4f373c9..116977e 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_cm.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_cm.c +@@ -811,13 +811,13 @@ void dpp1_program_input_lut( + REG_UPDATE(CM_IGAM_LUT_RW_INDEX, CM_IGAM_LUT_RW_INDEX, 0); + for (i = 0; i < gamma->num_entries; i++) { + REG_SET(CM_IGAM_LUT_SEQ_COLOR, 0, CM_IGAM_LUT_SEQ_COLOR, +- dal_fixed31_32_round( ++ dc_fixpt_round( + gamma->entries.red[i])); + REG_SET(CM_IGAM_LUT_SEQ_COLOR, 0, CM_IGAM_LUT_SEQ_COLOR, +- dal_fixed31_32_round( ++ dc_fixpt_round( + gamma->entries.green[i])); + REG_SET(CM_IGAM_LUT_SEQ_COLOR, 0, CM_IGAM_LUT_SEQ_COLOR, +- dal_fixed31_32_round( ++ dc_fixpt_round( + gamma->entries.blue[i])); + } + // Power off LUT memory +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c +index 3eb824d..4ddd627 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c +@@ -169,7 +169,7 @@ static enum dscl_mode_sel dpp1_dscl_get_dscl_mode( + const struct scaler_data *data, + bool dbg_always_scale) + { +- const long long one = dal_fixed31_32_one.value; ++ const long long one = dc_fixpt_one.value; + + if (dpp_base->caps->dscl_data_proc_format == DSCL_DATA_PRCESSING_FIXED_FORMAT) { + /* DSCL is processing data in fixed format */ +@@ -464,8 +464,8 @@ static enum lb_memory_config dpp1_dscl_find_lb_memory_config(struct dcn10_dpp *d + int num_part_y, num_part_c; + int vtaps = scl_data->taps.v_taps; + int vtaps_c = scl_data->taps.v_taps_c; +- int ceil_vratio = dal_fixed31_32_ceil(scl_data->ratios.vert); +- int ceil_vratio_c = dal_fixed31_32_ceil(scl_data->ratios.vert_c); ++ int ceil_vratio = dc_fixpt_ceil(scl_data->ratios.vert); ++ int ceil_vratio_c = dc_fixpt_ceil(scl_data->ratios.vert_c); + enum lb_memory_config mem_cfg = LB_MEMORY_CONFIG_0; + + if (dpp->base.ctx->dc->debug.use_max_lb) +@@ -565,52 +565,52 @@ static void dpp1_dscl_set_manual_ratio_init( + uint32_t init_int = 0; + + REG_SET(SCL_HORZ_FILTER_SCALE_RATIO, 0, +- SCL_H_SCALE_RATIO, dal_fixed31_32_u2d19(data->ratios.horz) << 5); ++ SCL_H_SCALE_RATIO, dc_fixpt_u2d19(data->ratios.horz) << 5); + + REG_SET(SCL_VERT_FILTER_SCALE_RATIO, 0, +- SCL_V_SCALE_RATIO, dal_fixed31_32_u2d19(data->ratios.vert) << 5); ++ SCL_V_SCALE_RATIO, dc_fixpt_u2d19(data->ratios.vert) << 5); + + REG_SET(SCL_HORZ_FILTER_SCALE_RATIO_C, 0, +- SCL_H_SCALE_RATIO_C, dal_fixed31_32_u2d19(data->ratios.horz_c) << 5); ++ SCL_H_SCALE_RATIO_C, dc_fixpt_u2d19(data->ratios.horz_c) << 5); + + REG_SET(SCL_VERT_FILTER_SCALE_RATIO_C, 0, +- SCL_V_SCALE_RATIO_C, dal_fixed31_32_u2d19(data->ratios.vert_c) << 5); ++ SCL_V_SCALE_RATIO_C, dc_fixpt_u2d19(data->ratios.vert_c) << 5); + + /* + * 0.24 format for fraction, first five bits zeroed + */ +- init_frac = dal_fixed31_32_u0d19(data->inits.h) << 5; +- init_int = dal_fixed31_32_floor(data->inits.h); ++ init_frac = dc_fixpt_u0d19(data->inits.h) << 5; ++ init_int = dc_fixpt_floor(data->inits.h); + REG_SET_2(SCL_HORZ_FILTER_INIT, 0, + SCL_H_INIT_FRAC, init_frac, + SCL_H_INIT_INT, init_int); + +- init_frac = dal_fixed31_32_u0d19(data->inits.h_c) << 5; +- init_int = dal_fixed31_32_floor(data->inits.h_c); ++ init_frac = dc_fixpt_u0d19(data->inits.h_c) << 5; ++ init_int = dc_fixpt_floor(data->inits.h_c); + REG_SET_2(SCL_HORZ_FILTER_INIT_C, 0, + SCL_H_INIT_FRAC_C, init_frac, + SCL_H_INIT_INT_C, init_int); + +- init_frac = dal_fixed31_32_u0d19(data->inits.v) << 5; +- init_int = dal_fixed31_32_floor(data->inits.v); ++ init_frac = dc_fixpt_u0d19(data->inits.v) << 5; ++ init_int = dc_fixpt_floor(data->inits.v); + REG_SET_2(SCL_VERT_FILTER_INIT, 0, + SCL_V_INIT_FRAC, init_frac, + SCL_V_INIT_INT, init_int); + +- init_frac = dal_fixed31_32_u0d19(data->inits.v_bot) << 5; +- init_int = dal_fixed31_32_floor(data->inits.v_bot); ++ init_frac = dc_fixpt_u0d19(data->inits.v_bot) << 5; ++ init_int = dc_fixpt_floor(data->inits.v_bot); + REG_SET_2(SCL_VERT_FILTER_INIT_BOT, 0, + SCL_V_INIT_FRAC_BOT, init_frac, + SCL_V_INIT_INT_BOT, init_int); + +- init_frac = dal_fixed31_32_u0d19(data->inits.v_c) << 5; +- init_int = dal_fixed31_32_floor(data->inits.v_c); ++ init_frac = dc_fixpt_u0d19(data->inits.v_c) << 5; ++ init_int = dc_fixpt_floor(data->inits.v_c); + REG_SET_2(SCL_VERT_FILTER_INIT_C, 0, + SCL_V_INIT_FRAC_C, init_frac, + SCL_V_INIT_INT_C, init_int); + +- init_frac = dal_fixed31_32_u0d19(data->inits.v_c_bot) << 5; +- init_int = dal_fixed31_32_floor(data->inits.v_c_bot); ++ init_frac = dc_fixpt_u0d19(data->inits.v_c_bot) << 5; ++ init_int = dc_fixpt_floor(data->inits.v_c_bot); + REG_SET_2(SCL_VERT_FILTER_INIT_BOT_C, 0, + SCL_V_INIT_FRAC_BOT_C, init_frac, + SCL_V_INIT_INT_BOT_C, init_int); +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c +index 0cbc83e..185f93b 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c +@@ -1054,8 +1054,8 @@ void hubp1_cursor_set_position( + ASSERT(param->h_scale_ratio.value); + + if (param->h_scale_ratio.value) +- dst_x_offset = dal_fixed31_32_floor(dal_fixed31_32_div( +- dal_fixed31_32_from_int(dst_x_offset), ++ dst_x_offset = dc_fixpt_floor(dc_fixpt_div( ++ dc_fixpt_from_int(dst_x_offset), + param->h_scale_ratio)); + + if (src_x_offset >= (int)param->viewport_width) +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c +index b88e020..d3fc1a2 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c +@@ -1700,22 +1700,22 @@ static uint16_t fixed_point_to_int_frac( + + uint16_t result; + +- uint16_t d = (uint16_t)dal_fixed31_32_floor( +- dal_fixed31_32_abs( ++ uint16_t d = (uint16_t)dc_fixpt_floor( ++ dc_fixpt_abs( + arg)); + + if (d <= (uint16_t)(1 << integer_bits) - (1 / (uint16_t)divisor)) +- numerator = (uint16_t)dal_fixed31_32_floor( +- dal_fixed31_32_mul_int( ++ numerator = (uint16_t)dc_fixpt_floor( ++ dc_fixpt_mul_int( + arg, + divisor)); + else { +- numerator = dal_fixed31_32_floor( +- dal_fixed31_32_sub( +- dal_fixed31_32_from_int( ++ numerator = dc_fixpt_floor( ++ dc_fixpt_sub( ++ dc_fixpt_from_int( + 1LL << integer_bits), +- dal_fixed31_32_recip( +- dal_fixed31_32_from_int( ++ dc_fixpt_recip( ++ dc_fixpt_from_int( + divisor)))); + } + +@@ -1725,8 +1725,8 @@ static uint16_t fixed_point_to_int_frac( + result = (uint16_t)( + (1 << (integer_bits + fractional_bits + 1)) + numerator); + +- if ((result != 0) && dal_fixed31_32_lt( +- arg, dal_fixed31_32_zero)) ++ if ((result != 0) && dc_fixpt_lt( ++ arg, dc_fixpt_zero)) + result |= 1 << (integer_bits + fractional_bits); + + return result; +@@ -1740,8 +1740,8 @@ void build_prescale_params(struct dc_bias_and_scale *bias_and_scale, + && plane_state->input_csc_color_matrix.enable_adjustment + && plane_state->coeff_reduction_factor.value != 0) { + bias_and_scale->scale_blue = fixed_point_to_int_frac( +- dal_fixed31_32_mul(plane_state->coeff_reduction_factor, +- dal_fixed31_32_from_fraction(256, 255)), ++ dc_fixpt_mul(plane_state->coeff_reduction_factor, ++ dc_fixpt_from_fraction(256, 255)), + 2, + 13); + bias_and_scale->scale_red = bias_and_scale->scale_blue; +@@ -2010,7 +2010,7 @@ static void dcn10_blank_pixel_data( + + static void set_hdr_multiplier(struct pipe_ctx *pipe_ctx) + { +- struct fixed31_32 multiplier = dal_fixed31_32_from_fraction( ++ struct fixed31_32 multiplier = dc_fixpt_from_fraction( + pipe_ctx->plane_state->sdr_white_level, 80); + uint32_t hw_mult = 0x1f000; // 1.0 default multiplier + struct custom_float_format fmt; +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_stream_encoder.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_stream_encoder.c +index befd863..653b7b2 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_stream_encoder.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_stream_encoder.c +@@ -603,11 +603,11 @@ void enc1_stream_encoder_set_mst_bandwidth( + struct fixed31_32 avg_time_slots_per_mtp) + { + struct dcn10_stream_encoder *enc1 = DCN10STRENC_FROM_STRENC(enc); +- uint32_t x = dal_fixed31_32_floor( ++ uint32_t x = dc_fixpt_floor( + avg_time_slots_per_mtp); +- uint32_t y = dal_fixed31_32_ceil( +- dal_fixed31_32_shl( +- dal_fixed31_32_sub_int( ++ uint32_t y = dc_fixpt_ceil( ++ dc_fixpt_shl( ++ dc_fixpt_sub_int( + avg_time_slots_per_mtp, + x), + 26)); +diff --git a/drivers/gpu/drm/amd/display/dc/irq_types.h b/drivers/gpu/drm/amd/display/dc/irq_types.h +index cc3b1bc..0b5f3a2 100644 +--- a/drivers/gpu/drm/amd/display/dc/irq_types.h ++++ b/drivers/gpu/drm/amd/display/dc/irq_types.h +@@ -26,6 +26,8 @@ + #ifndef __DAL_IRQ_TYPES_H__ + #define __DAL_IRQ_TYPES_H__ + ++#include "os_types.h" ++ + struct dc_context; + + typedef void (*interrupt_handler)(void *); +diff --git a/drivers/gpu/drm/amd/display/include/fixed31_32.h b/drivers/gpu/drm/amd/display/include/fixed31_32.h +index 16cbdb4..b5b8d7d 100644 +--- a/drivers/gpu/drm/amd/display/include/fixed31_32.h ++++ b/drivers/gpu/drm/amd/display/include/fixed31_32.h +@@ -50,16 +50,16 @@ struct fixed31_32 { + * Useful constants + */ + +-static const struct fixed31_32 dal_fixed31_32_zero = { 0 }; +-static const struct fixed31_32 dal_fixed31_32_epsilon = { 1LL }; +-static const struct fixed31_32 dal_fixed31_32_half = { 0x80000000LL }; +-static const struct fixed31_32 dal_fixed31_32_one = { 0x100000000LL }; ++static const struct fixed31_32 dc_fixpt_zero = { 0 }; ++static const struct fixed31_32 dc_fixpt_epsilon = { 1LL }; ++static const struct fixed31_32 dc_fixpt_half = { 0x80000000LL }; ++static const struct fixed31_32 dc_fixpt_one = { 0x100000000LL }; + +-static const struct fixed31_32 dal_fixed31_32_pi = { 13493037705LL }; +-static const struct fixed31_32 dal_fixed31_32_two_pi = { 26986075409LL }; +-static const struct fixed31_32 dal_fixed31_32_e = { 11674931555LL }; +-static const struct fixed31_32 dal_fixed31_32_ln2 = { 2977044471LL }; +-static const struct fixed31_32 dal_fixed31_32_ln2_div_2 = { 1488522236LL }; ++static const struct fixed31_32 dc_fixpt_pi = { 13493037705LL }; ++static const struct fixed31_32 dc_fixpt_two_pi = { 26986075409LL }; ++static const struct fixed31_32 dc_fixpt_e = { 11674931555LL }; ++static const struct fixed31_32 dc_fixpt_ln2 = { 2977044471LL }; ++static const struct fixed31_32 dc_fixpt_ln2_div_2 = { 1488522236LL }; + + /* + * @brief +@@ -70,7 +70,7 @@ static const struct fixed31_32 dal_fixed31_32_ln2_div_2 = { 1488522236LL }; + * @brief + * result = numerator / denominator + */ +-struct fixed31_32 dal_fixed31_32_from_fraction( ++struct fixed31_32 dc_fixpt_from_fraction( + long long numerator, + long long denominator); + +@@ -78,8 +78,8 @@ struct fixed31_32 dal_fixed31_32_from_fraction( + * @brief + * result = arg + */ +-struct fixed31_32 dal_fixed31_32_from_int_nonconst(long long arg); +-static inline struct fixed31_32 dal_fixed31_32_from_int(long long arg) ++struct fixed31_32 dc_fixpt_from_int_nonconst(long long arg); ++static inline struct fixed31_32 dc_fixpt_from_int(long long arg) + { + if (__builtin_constant_p(arg)) { + struct fixed31_32 res; +@@ -87,7 +87,7 @@ static inline struct fixed31_32 dal_fixed31_32_from_int(long long arg) + res.value = arg << FIXED31_32_BITS_PER_FRACTIONAL_PART; + return res; + } else +- return dal_fixed31_32_from_int_nonconst(arg); ++ return dc_fixpt_from_int_nonconst(arg); + } + + /* +@@ -99,7 +99,7 @@ static inline struct fixed31_32 dal_fixed31_32_from_int(long long arg) + * @brief + * result = -arg + */ +-static inline struct fixed31_32 dal_fixed31_32_neg(struct fixed31_32 arg) ++static inline struct fixed31_32 dc_fixpt_neg(struct fixed31_32 arg) + { + struct fixed31_32 res; + +@@ -112,10 +112,10 @@ static inline struct fixed31_32 dal_fixed31_32_neg(struct fixed31_32 arg) + * @brief + * result = abs(arg) := (arg >= 0) ? arg : -arg + */ +-static inline struct fixed31_32 dal_fixed31_32_abs(struct fixed31_32 arg) ++static inline struct fixed31_32 dc_fixpt_abs(struct fixed31_32 arg) + { + if (arg.value < 0) +- return dal_fixed31_32_neg(arg); ++ return dc_fixpt_neg(arg); + else + return arg; + } +@@ -129,7 +129,7 @@ static inline struct fixed31_32 dal_fixed31_32_abs(struct fixed31_32 arg) + * @brief + * result = arg1 < arg2 + */ +-static inline bool dal_fixed31_32_lt(struct fixed31_32 arg1, ++static inline bool dc_fixpt_lt(struct fixed31_32 arg1, + struct fixed31_32 arg2) + { + return arg1.value < arg2.value; +@@ -139,7 +139,7 @@ static inline bool dal_fixed31_32_lt(struct fixed31_32 arg1, + * @brief + * result = arg1 <= arg2 + */ +-static inline bool dal_fixed31_32_le(struct fixed31_32 arg1, ++static inline bool dc_fixpt_le(struct fixed31_32 arg1, + struct fixed31_32 arg2) + { + return arg1.value <= arg2.value; +@@ -149,7 +149,7 @@ static inline bool dal_fixed31_32_le(struct fixed31_32 arg1, + * @brief + * result = arg1 == arg2 + */ +-static inline bool dal_fixed31_32_eq(struct fixed31_32 arg1, ++static inline bool dc_fixpt_eq(struct fixed31_32 arg1, + struct fixed31_32 arg2) + { + return arg1.value == arg2.value; +@@ -159,7 +159,7 @@ static inline bool dal_fixed31_32_eq(struct fixed31_32 arg1, + * @brief + * result = min(arg1, arg2) := (arg1 <= arg2) ? arg1 : arg2 + */ +-static inline struct fixed31_32 dal_fixed31_32_min(struct fixed31_32 arg1, ++static inline struct fixed31_32 dc_fixpt_min(struct fixed31_32 arg1, + struct fixed31_32 arg2) + { + if (arg1.value <= arg2.value) +@@ -172,7 +172,7 @@ static inline struct fixed31_32 dal_fixed31_32_min(struct fixed31_32 arg1, + * @brief + * result = max(arg1, arg2) := (arg1 <= arg2) ? arg2 : arg1 + */ +-static inline struct fixed31_32 dal_fixed31_32_max(struct fixed31_32 arg1, ++static inline struct fixed31_32 dc_fixpt_max(struct fixed31_32 arg1, + struct fixed31_32 arg2) + { + if (arg1.value <= arg2.value) +@@ -187,14 +187,14 @@ static inline struct fixed31_32 dal_fixed31_32_max(struct fixed31_32 arg1, + * result = | arg, when min_value < arg < max_value + * | max_value, when arg >= max_value + */ +-static inline struct fixed31_32 dal_fixed31_32_clamp( ++static inline struct fixed31_32 dc_fixpt_clamp( + struct fixed31_32 arg, + struct fixed31_32 min_value, + struct fixed31_32 max_value) + { +- if (dal_fixed31_32_le(arg, min_value)) ++ if (dc_fixpt_le(arg, min_value)) + return min_value; +- else if (dal_fixed31_32_le(max_value, arg)) ++ else if (dc_fixpt_le(max_value, arg)) + return max_value; + else + return arg; +@@ -209,7 +209,7 @@ static inline struct fixed31_32 dal_fixed31_32_clamp( + * @brief + * result = arg << shift + */ +-struct fixed31_32 dal_fixed31_32_shl( ++struct fixed31_32 dc_fixpt_shl( + struct fixed31_32 arg, + unsigned char shift); + +@@ -217,7 +217,7 @@ struct fixed31_32 dal_fixed31_32_shl( + * @brief + * result = arg >> shift + */ +-static inline struct fixed31_32 dal_fixed31_32_shr( ++static inline struct fixed31_32 dc_fixpt_shr( + struct fixed31_32 arg, + unsigned char shift) + { +@@ -235,7 +235,7 @@ static inline struct fixed31_32 dal_fixed31_32_shr( + * @brief + * result = arg1 + arg2 + */ +-struct fixed31_32 dal_fixed31_32_add( ++struct fixed31_32 dc_fixpt_add( + struct fixed31_32 arg1, + struct fixed31_32 arg2); + +@@ -243,18 +243,18 @@ struct fixed31_32 dal_fixed31_32_add( + * @brief + * result = arg1 + arg2 + */ +-static inline struct fixed31_32 dal_fixed31_32_add_int(struct fixed31_32 arg1, ++static inline struct fixed31_32 dc_fixpt_add_int(struct fixed31_32 arg1, + int arg2) + { +- return dal_fixed31_32_add(arg1, +- dal_fixed31_32_from_int(arg2)); ++ return dc_fixpt_add(arg1, ++ dc_fixpt_from_int(arg2)); + } + + /* + * @brief + * result = arg1 - arg2 + */ +-struct fixed31_32 dal_fixed31_32_sub( ++struct fixed31_32 dc_fixpt_sub( + struct fixed31_32 arg1, + struct fixed31_32 arg2); + +@@ -262,11 +262,11 @@ struct fixed31_32 dal_fixed31_32_sub( + * @brief + * result = arg1 - arg2 + */ +-static inline struct fixed31_32 dal_fixed31_32_sub_int(struct fixed31_32 arg1, ++static inline struct fixed31_32 dc_fixpt_sub_int(struct fixed31_32 arg1, + int arg2) + { +- return dal_fixed31_32_sub(arg1, +- dal_fixed31_32_from_int(arg2)); ++ return dc_fixpt_sub(arg1, ++ dc_fixpt_from_int(arg2)); + } + + +@@ -279,7 +279,7 @@ static inline struct fixed31_32 dal_fixed31_32_sub_int(struct fixed31_32 arg1, + * @brief + * result = arg1 * arg2 + */ +-struct fixed31_32 dal_fixed31_32_mul( ++struct fixed31_32 dc_fixpt_mul( + struct fixed31_32 arg1, + struct fixed31_32 arg2); + +@@ -288,39 +288,39 @@ struct fixed31_32 dal_fixed31_32_mul( + * @brief + * result = arg1 * arg2 + */ +-static inline struct fixed31_32 dal_fixed31_32_mul_int(struct fixed31_32 arg1, ++static inline struct fixed31_32 dc_fixpt_mul_int(struct fixed31_32 arg1, + int arg2) + { +- return dal_fixed31_32_mul(arg1, +- dal_fixed31_32_from_int(arg2)); ++ return dc_fixpt_mul(arg1, ++ dc_fixpt_from_int(arg2)); + } + + /* + * @brief + * result = square(arg) := arg * arg + */ +-struct fixed31_32 dal_fixed31_32_sqr( ++struct fixed31_32 dc_fixpt_sqr( + struct fixed31_32 arg); + + /* + * @brief + * result = arg1 / arg2 + */ +-static inline struct fixed31_32 dal_fixed31_32_div_int(struct fixed31_32 arg1, ++static inline struct fixed31_32 dc_fixpt_div_int(struct fixed31_32 arg1, + long long arg2) + { +- return dal_fixed31_32_from_fraction(arg1.value, +- dal_fixed31_32_from_int(arg2).value); ++ return dc_fixpt_from_fraction(arg1.value, ++ dc_fixpt_from_int(arg2).value); + } + + /* + * @brief + * result = arg1 / arg2 + */ +-static inline struct fixed31_32 dal_fixed31_32_div(struct fixed31_32 arg1, ++static inline struct fixed31_32 dc_fixpt_div(struct fixed31_32 arg1, + struct fixed31_32 arg2) + { +- return dal_fixed31_32_from_fraction(arg1.value, ++ return dc_fixpt_from_fraction(arg1.value, + arg2.value); + } + +@@ -336,7 +336,7 @@ static inline struct fixed31_32 dal_fixed31_32_div(struct fixed31_32 arg1, + * @note + * No special actions taken in case argument is zero. + */ +-struct fixed31_32 dal_fixed31_32_recip( ++struct fixed31_32 dc_fixpt_recip( + struct fixed31_32 arg); + + /* +@@ -352,7 +352,7 @@ struct fixed31_32 dal_fixed31_32_recip( + * Argument specified in radians, + * internally it's normalized to [-2pi...2pi] range. + */ +-struct fixed31_32 dal_fixed31_32_sinc( ++struct fixed31_32 dc_fixpt_sinc( + struct fixed31_32 arg); + + /* +@@ -363,7 +363,7 @@ struct fixed31_32 dal_fixed31_32_sinc( + * Argument specified in radians, + * internally it's normalized to [-2pi...2pi] range. + */ +-struct fixed31_32 dal_fixed31_32_sin( ++struct fixed31_32 dc_fixpt_sin( + struct fixed31_32 arg); + + /* +@@ -376,7 +376,7 @@ struct fixed31_32 dal_fixed31_32_sin( + * passing arguments outside that range + * will cause incorrect result! + */ +-struct fixed31_32 dal_fixed31_32_cos( ++struct fixed31_32 dc_fixpt_cos( + struct fixed31_32 arg); + + /* +@@ -391,7 +391,7 @@ struct fixed31_32 dal_fixed31_32_cos( + * @note + * Currently, function is verified for abs(arg) <= 1. + */ +-struct fixed31_32 dal_fixed31_32_exp( ++struct fixed31_32 dc_fixpt_exp( + struct fixed31_32 arg); + + /* +@@ -404,7 +404,7 @@ struct fixed31_32 dal_fixed31_32_exp( + * Currently, no special actions taken + * in case of invalid argument(s). Take care! + */ +-struct fixed31_32 dal_fixed31_32_log( ++struct fixed31_32 dc_fixpt_log( + struct fixed31_32 arg); + + /* +@@ -419,7 +419,7 @@ struct fixed31_32 dal_fixed31_32_log( + * @note + * Currently, abs(arg1) should be less than 1. Take care! + */ +-struct fixed31_32 dal_fixed31_32_pow( ++struct fixed31_32 dc_fixpt_pow( + struct fixed31_32 arg1, + struct fixed31_32 arg2); + +@@ -432,21 +432,21 @@ struct fixed31_32 dal_fixed31_32_pow( + * @brief + * result = floor(arg) := greatest integer lower than or equal to arg + */ +-int dal_fixed31_32_floor( ++int dc_fixpt_floor( + struct fixed31_32 arg); + + /* + * @brief + * result = round(arg) := integer nearest to arg + */ +-int dal_fixed31_32_round( ++int dc_fixpt_round( + struct fixed31_32 arg); + + /* + * @brief + * result = ceil(arg) := lowest integer greater than or equal to arg + */ +-int dal_fixed31_32_ceil( ++int dc_fixpt_ceil( + struct fixed31_32 arg); + + /* the following two function are used in scaler hw programming to convert fixed +@@ -455,20 +455,20 @@ int dal_fixed31_32_ceil( + * fractional + */ + +-unsigned int dal_fixed31_32_u2d19( ++unsigned int dc_fixpt_u2d19( + struct fixed31_32 arg); + +-unsigned int dal_fixed31_32_u0d19( ++unsigned int dc_fixpt_u0d19( + struct fixed31_32 arg); + + +-unsigned int dal_fixed31_32_clamp_u0d14( ++unsigned int dc_fixpt_clamp_u0d14( + struct fixed31_32 arg); + +-unsigned int dal_fixed31_32_clamp_u0d10( ++unsigned int dc_fixpt_clamp_u0d10( + struct fixed31_32 arg); + +-int dal_fixed31_32_s4d19( ++int dc_fixpt_s4d19( + struct fixed31_32 arg); + + #endif +diff --git a/drivers/gpu/drm/amd/display/include/fixed32_32.h b/drivers/gpu/drm/amd/display/include/fixed32_32.h +deleted file mode 100644 +index 9c70341..0000000 +--- a/drivers/gpu/drm/amd/display/include/fixed32_32.h ++++ /dev/null +@@ -1,129 +0,0 @@ +-/* +- * Copyright 2012-15 Advanced Micro Devices, Inc. +- * +- * Permission is hereby granted, free of charge, to any person obtaining a +- * copy of this software and associated documentation files (the "Software"), +- * to deal in the Software without restriction, including without limitation +- * the rights to use, copy, modify, merge, publish, distribute, sublicense, +- * and/or sell copies of the Software, and to permit persons to whom the +- * Software is furnished to do so, subject to the following conditions: +- * +- * The above copyright notice and this permission notice shall be included in +- * all copies or substantial portions of the Software. +- * +- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR +- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +- * OTHER DEALINGS IN THE SOFTWARE. +- * +- * Authors: AMD +- * +- */ +- +- +-#ifndef __DAL_FIXED32_32_H__ +-#define __DAL_FIXED32_32_H__ +- +-#include "os_types.h" +- +-struct fixed32_32 { +- uint64_t value; +-}; +- +-static const struct fixed32_32 dal_fixed32_32_zero = { 0 }; +-static const struct fixed32_32 dal_fixed32_32_one = { 0x100000000LL }; +-static const struct fixed32_32 dal_fixed32_32_half = { 0x80000000LL }; +- +-struct fixed32_32 dal_fixed32_32_from_fraction(uint32_t n, uint32_t d); +-static inline struct fixed32_32 dal_fixed32_32_from_int(uint32_t value) +-{ +- struct fixed32_32 fx; +- +- fx.value = (uint64_t)value<<32; +- return fx; +-} +- +-struct fixed32_32 dal_fixed32_32_add( +- struct fixed32_32 lhs, +- struct fixed32_32 rhs); +-struct fixed32_32 dal_fixed32_32_add_int( +- struct fixed32_32 lhs, +- uint32_t rhs); +-struct fixed32_32 dal_fixed32_32_sub( +- struct fixed32_32 lhs, +- struct fixed32_32 rhs); +-struct fixed32_32 dal_fixed32_32_sub_int( +- struct fixed32_32 lhs, +- uint32_t rhs); +-struct fixed32_32 dal_fixed32_32_mul( +- struct fixed32_32 lhs, +- struct fixed32_32 rhs); +-struct fixed32_32 dal_fixed32_32_mul_int( +- struct fixed32_32 lhs, +- uint32_t rhs); +-struct fixed32_32 dal_fixed32_32_div( +- struct fixed32_32 lhs, +- struct fixed32_32 rhs); +-struct fixed32_32 dal_fixed32_32_div_int( +- struct fixed32_32 lhs, +- uint32_t rhs); +- +-static inline struct fixed32_32 dal_fixed32_32_min(struct fixed32_32 lhs, +- struct fixed32_32 rhs) +-{ +- return (lhs.value < rhs.value) ? lhs : rhs; +-} +- +-static inline struct fixed32_32 dal_fixed32_32_max(struct fixed32_32 lhs, +- struct fixed32_32 rhs) +-{ +- return (lhs.value > rhs.value) ? lhs : rhs; +-} +- +-static inline bool dal_fixed32_32_gt(struct fixed32_32 lhs, struct fixed32_32 rhs) +-{ +- return lhs.value > rhs.value; +-} +- +-static inline bool dal_fixed32_32_gt_int(struct fixed32_32 lhs, uint32_t rhs) +-{ +- return lhs.value > ((uint64_t)rhs<<32); +-} +- +-static inline bool dal_fixed32_32_lt(struct fixed32_32 lhs, struct fixed32_32 rhs) +-{ +- return lhs.value < rhs.value; +-} +- +-static inline bool dal_fixed32_32_lt_int(struct fixed32_32 lhs, uint32_t rhs) +-{ +- return lhs.value < ((uint64_t)rhs<<32); +-} +- +-static inline bool dal_fixed32_32_le(struct fixed32_32 lhs, struct fixed32_32 rhs) +-{ +- return lhs.value <= rhs.value; +-} +- +-static inline bool dal_fixed32_32_le_int(struct fixed32_32 lhs, uint32_t rhs) +-{ +- return lhs.value <= ((uint64_t)rhs<<32); +-} +- +-static inline bool dal_fixed32_32_eq(struct fixed32_32 lhs, struct fixed32_32 rhs) +-{ +- return lhs.value == rhs.value; +-} +- +-uint32_t dal_fixed32_32_ceil(struct fixed32_32 value); +-static inline uint32_t dal_fixed32_32_floor(struct fixed32_32 value) +-{ +- return value.value>>32; +-} +- +-uint32_t dal_fixed32_32_round(struct fixed32_32 value); +- +-#endif +diff --git a/drivers/gpu/drm/amd/display/modules/color/color_gamma.c b/drivers/gpu/drm/amd/display/modules/color/color_gamma.c +index 15e5b72..29d2ec8 100644 +--- a/drivers/gpu/drm/amd/display/modules/color/color_gamma.c ++++ b/drivers/gpu/drm/amd/display/modules/color/color_gamma.c +@@ -43,7 +43,7 @@ static bool de_pq_initialized; /* = false; */ + /* one-time setup of X points */ + void setup_x_points_distribution(void) + { +- struct fixed31_32 region_size = dal_fixed31_32_from_int(128); ++ struct fixed31_32 region_size = dc_fixpt_from_int(128); + int32_t segment; + uint32_t seg_offset; + uint32_t index; +@@ -53,8 +53,8 @@ void setup_x_points_distribution(void) + coordinates_x[MAX_HW_POINTS + 1].x = region_size; + + for (segment = 6; segment > (6 - NUM_REGIONS); segment--) { +- region_size = dal_fixed31_32_div_int(region_size, 2); +- increment = dal_fixed31_32_div_int(region_size, ++ region_size = dc_fixpt_div_int(region_size, 2); ++ increment = dc_fixpt_div_int(region_size, + NUM_PTS_IN_REGION); + seg_offset = (segment + (NUM_REGIONS - 7)) * NUM_PTS_IN_REGION; + coordinates_x[seg_offset].x = region_size; +@@ -62,7 +62,7 @@ void setup_x_points_distribution(void) + for (index = seg_offset + 1; + index < seg_offset + NUM_PTS_IN_REGION; + index++) { +- coordinates_x[index].x = dal_fixed31_32_add ++ coordinates_x[index].x = dc_fixpt_add + (coordinates_x[index-1].x, increment); + } + } +@@ -72,63 +72,63 @@ static void compute_pq(struct fixed31_32 in_x, struct fixed31_32 *out_y) + { + /* consts for PQ gamma formula. */ + const struct fixed31_32 m1 = +- dal_fixed31_32_from_fraction(159301758, 1000000000); ++ dc_fixpt_from_fraction(159301758, 1000000000); + const struct fixed31_32 m2 = +- dal_fixed31_32_from_fraction(7884375, 100000); ++ dc_fixpt_from_fraction(7884375, 100000); + const struct fixed31_32 c1 = +- dal_fixed31_32_from_fraction(8359375, 10000000); ++ dc_fixpt_from_fraction(8359375, 10000000); + const struct fixed31_32 c2 = +- dal_fixed31_32_from_fraction(188515625, 10000000); ++ dc_fixpt_from_fraction(188515625, 10000000); + const struct fixed31_32 c3 = +- dal_fixed31_32_from_fraction(186875, 10000); ++ dc_fixpt_from_fraction(186875, 10000); + + struct fixed31_32 l_pow_m1; + struct fixed31_32 base; + +- if (dal_fixed31_32_lt(in_x, dal_fixed31_32_zero)) +- in_x = dal_fixed31_32_zero; ++ if (dc_fixpt_lt(in_x, dc_fixpt_zero)) ++ in_x = dc_fixpt_zero; + +- l_pow_m1 = dal_fixed31_32_pow(in_x, m1); +- base = dal_fixed31_32_div( +- dal_fixed31_32_add(c1, +- (dal_fixed31_32_mul(c2, l_pow_m1))), +- dal_fixed31_32_add(dal_fixed31_32_one, +- (dal_fixed31_32_mul(c3, l_pow_m1)))); +- *out_y = dal_fixed31_32_pow(base, m2); ++ l_pow_m1 = dc_fixpt_pow(in_x, m1); ++ base = dc_fixpt_div( ++ dc_fixpt_add(c1, ++ (dc_fixpt_mul(c2, l_pow_m1))), ++ dc_fixpt_add(dc_fixpt_one, ++ (dc_fixpt_mul(c3, l_pow_m1)))); ++ *out_y = dc_fixpt_pow(base, m2); + } + + static void compute_de_pq(struct fixed31_32 in_x, struct fixed31_32 *out_y) + { + /* consts for dePQ gamma formula. */ + const struct fixed31_32 m1 = +- dal_fixed31_32_from_fraction(159301758, 1000000000); ++ dc_fixpt_from_fraction(159301758, 1000000000); + const struct fixed31_32 m2 = +- dal_fixed31_32_from_fraction(7884375, 100000); ++ dc_fixpt_from_fraction(7884375, 100000); + const struct fixed31_32 c1 = +- dal_fixed31_32_from_fraction(8359375, 10000000); ++ dc_fixpt_from_fraction(8359375, 10000000); + const struct fixed31_32 c2 = +- dal_fixed31_32_from_fraction(188515625, 10000000); ++ dc_fixpt_from_fraction(188515625, 10000000); + const struct fixed31_32 c3 = +- dal_fixed31_32_from_fraction(186875, 10000); ++ dc_fixpt_from_fraction(186875, 10000); + + struct fixed31_32 l_pow_m1; + struct fixed31_32 base, div; + + +- if (dal_fixed31_32_lt(in_x, dal_fixed31_32_zero)) +- in_x = dal_fixed31_32_zero; ++ if (dc_fixpt_lt(in_x, dc_fixpt_zero)) ++ in_x = dc_fixpt_zero; + +- l_pow_m1 = dal_fixed31_32_pow(in_x, +- dal_fixed31_32_div(dal_fixed31_32_one, m2)); +- base = dal_fixed31_32_sub(l_pow_m1, c1); ++ l_pow_m1 = dc_fixpt_pow(in_x, ++ dc_fixpt_div(dc_fixpt_one, m2)); ++ base = dc_fixpt_sub(l_pow_m1, c1); + +- if (dal_fixed31_32_lt(base, dal_fixed31_32_zero)) +- base = dal_fixed31_32_zero; ++ if (dc_fixpt_lt(base, dc_fixpt_zero)) ++ base = dc_fixpt_zero; + +- div = dal_fixed31_32_sub(c2, dal_fixed31_32_mul(c3, l_pow_m1)); ++ div = dc_fixpt_sub(c2, dc_fixpt_mul(c3, l_pow_m1)); + +- *out_y = dal_fixed31_32_pow(dal_fixed31_32_div(base, div), +- dal_fixed31_32_div(dal_fixed31_32_one, m1)); ++ *out_y = dc_fixpt_pow(dc_fixpt_div(base, div), ++ dc_fixpt_div(dc_fixpt_one, m1)); + + } + /* one-time pre-compute PQ values - only for sdr_white_level 80 */ +@@ -138,14 +138,14 @@ void precompute_pq(void) + struct fixed31_32 x; + const struct hw_x_point *coord_x = coordinates_x + 32; + struct fixed31_32 scaling_factor = +- dal_fixed31_32_from_fraction(80, 10000); ++ dc_fixpt_from_fraction(80, 10000); + + /* pow function has problems with arguments too small */ + for (i = 0; i < 32; i++) +- pq_table[i] = dal_fixed31_32_zero; ++ pq_table[i] = dc_fixpt_zero; + + for (i = 32; i <= MAX_HW_POINTS; i++) { +- x = dal_fixed31_32_mul(coord_x->x, scaling_factor); ++ x = dc_fixpt_mul(coord_x->x, scaling_factor); + compute_pq(x, &pq_table[i]); + ++coord_x; + } +@@ -158,7 +158,7 @@ void precompute_de_pq(void) + struct fixed31_32 y; + uint32_t begin_index, end_index; + +- struct fixed31_32 scaling_factor = dal_fixed31_32_from_int(125); ++ struct fixed31_32 scaling_factor = dc_fixpt_from_int(125); + + /* X points is 2^-25 to 2^7 + * De-gamma X is 2^-12 to 2^0 – we are skipping first -12-(-25) = 13 regions +@@ -167,11 +167,11 @@ void precompute_de_pq(void) + end_index = begin_index + 12 * NUM_PTS_IN_REGION; + + for (i = 0; i <= begin_index; i++) +- de_pq_table[i] = dal_fixed31_32_zero; ++ de_pq_table[i] = dc_fixpt_zero; + + for (; i <= end_index; i++) { + compute_de_pq(coordinates_x[i].x, &y); +- de_pq_table[i] = dal_fixed31_32_mul(y, scaling_factor); ++ de_pq_table[i] = dc_fixpt_mul(y, scaling_factor); + } + + for (; i <= MAX_HW_POINTS; i++) +@@ -195,15 +195,15 @@ static void build_coefficients(struct gamma_coefficients *coefficients, bool is_ + uint32_t index = is_2_4 == true ? 0:1; + + do { +- coefficients->a0[i] = dal_fixed31_32_from_fraction( ++ coefficients->a0[i] = dc_fixpt_from_fraction( + numerator01[index], 10000000); +- coefficients->a1[i] = dal_fixed31_32_from_fraction( ++ coefficients->a1[i] = dc_fixpt_from_fraction( + numerator02[index], 1000); +- coefficients->a2[i] = dal_fixed31_32_from_fraction( ++ coefficients->a2[i] = dc_fixpt_from_fraction( + numerator03[index], 1000); +- coefficients->a3[i] = dal_fixed31_32_from_fraction( ++ coefficients->a3[i] = dc_fixpt_from_fraction( + numerator04[index], 1000); +- coefficients->user_gamma[i] = dal_fixed31_32_from_fraction( ++ coefficients->user_gamma[i] = dc_fixpt_from_fraction( + numerator05[index], 1000); + + ++i; +@@ -218,33 +218,33 @@ static struct fixed31_32 translate_from_linear_space( + struct fixed31_32 a3, + struct fixed31_32 gamma) + { +- const struct fixed31_32 one = dal_fixed31_32_from_int(1); ++ const struct fixed31_32 one = dc_fixpt_from_int(1); + +- if (dal_fixed31_32_lt(one, arg)) ++ if (dc_fixpt_lt(one, arg)) + return one; + +- if (dal_fixed31_32_le(arg, dal_fixed31_32_neg(a0))) +- return dal_fixed31_32_sub( ++ if (dc_fixpt_le(arg, dc_fixpt_neg(a0))) ++ return dc_fixpt_sub( + a2, +- dal_fixed31_32_mul( +- dal_fixed31_32_add( ++ dc_fixpt_mul( ++ dc_fixpt_add( + one, + a3), +- dal_fixed31_32_pow( +- dal_fixed31_32_neg(arg), +- dal_fixed31_32_recip(gamma)))); +- else if (dal_fixed31_32_le(a0, arg)) +- return dal_fixed31_32_sub( +- dal_fixed31_32_mul( +- dal_fixed31_32_add( ++ dc_fixpt_pow( ++ dc_fixpt_neg(arg), ++ dc_fixpt_recip(gamma)))); ++ else if (dc_fixpt_le(a0, arg)) ++ return dc_fixpt_sub( ++ dc_fixpt_mul( ++ dc_fixpt_add( + one, + a3), +- dal_fixed31_32_pow( ++ dc_fixpt_pow( + arg, +- dal_fixed31_32_recip(gamma))), ++ dc_fixpt_recip(gamma))), + a2); + else +- return dal_fixed31_32_mul( ++ return dc_fixpt_mul( + arg, + a1); + } +@@ -259,25 +259,25 @@ static struct fixed31_32 translate_to_linear_space( + { + struct fixed31_32 linear; + +- a0 = dal_fixed31_32_mul(a0, a1); +- if (dal_fixed31_32_le(arg, dal_fixed31_32_neg(a0))) ++ a0 = dc_fixpt_mul(a0, a1); ++ if (dc_fixpt_le(arg, dc_fixpt_neg(a0))) + +- linear = dal_fixed31_32_neg( +- dal_fixed31_32_pow( +- dal_fixed31_32_div( +- dal_fixed31_32_sub(a2, arg), +- dal_fixed31_32_add( +- dal_fixed31_32_one, a3)), gamma)); ++ linear = dc_fixpt_neg( ++ dc_fixpt_pow( ++ dc_fixpt_div( ++ dc_fixpt_sub(a2, arg), ++ dc_fixpt_add( ++ dc_fixpt_one, a3)), gamma)); + +- else if (dal_fixed31_32_le(dal_fixed31_32_neg(a0), arg) && +- dal_fixed31_32_le(arg, a0)) +- linear = dal_fixed31_32_div(arg, a1); ++ else if (dc_fixpt_le(dc_fixpt_neg(a0), arg) && ++ dc_fixpt_le(arg, a0)) ++ linear = dc_fixpt_div(arg, a1); + else +- linear = dal_fixed31_32_pow( +- dal_fixed31_32_div( +- dal_fixed31_32_add(a2, arg), +- dal_fixed31_32_add( +- dal_fixed31_32_one, a3)), gamma); ++ linear = dc_fixpt_pow( ++ dc_fixpt_div( ++ dc_fixpt_add(a2, arg), ++ dc_fixpt_add( ++ dc_fixpt_one, a3)), gamma); + + return linear; + } +@@ -352,8 +352,8 @@ static bool find_software_points( + right = axis_x[max_number - 1].b; + } + +- if (dal_fixed31_32_le(left, hw_point) && +- dal_fixed31_32_le(hw_point, right)) { ++ if (dc_fixpt_le(left, hw_point) && ++ dc_fixpt_le(hw_point, right)) { + *index_to_start = i; + *index_left = i; + +@@ -366,7 +366,7 @@ static bool find_software_points( + + return true; + } else if ((i == *index_to_start) && +- dal_fixed31_32_le(hw_point, left)) { ++ dc_fixpt_le(hw_point, left)) { + *index_to_start = i; + *index_left = i; + *index_right = i; +@@ -375,7 +375,7 @@ static bool find_software_points( + + return true; + } else if ((i == max_number - 1) && +- dal_fixed31_32_le(right, hw_point)) { ++ dc_fixpt_le(right, hw_point)) { + *index_to_start = i; + *index_left = i; + *index_right = i; +@@ -457,17 +457,17 @@ static bool build_custom_gamma_mapping_coefficients_worker( + } + + if (hw_pos == HW_POINT_POSITION_MIDDLE) +- point->coeff = dal_fixed31_32_div( +- dal_fixed31_32_sub( ++ point->coeff = dc_fixpt_div( ++ dc_fixpt_sub( + coord_x, + left_pos), +- dal_fixed31_32_sub( ++ dc_fixpt_sub( + right_pos, + left_pos)); + else if (hw_pos == HW_POINT_POSITION_LEFT) +- point->coeff = dal_fixed31_32_zero; ++ point->coeff = dc_fixpt_zero; + else if (hw_pos == HW_POINT_POSITION_RIGHT) +- point->coeff = dal_fixed31_32_from_int(2); ++ point->coeff = dc_fixpt_from_int(2); + else { + BREAK_TO_DEBUGGER(); + return false; +@@ -502,45 +502,45 @@ static struct fixed31_32 calculate_mapped_value( + + if ((point->left_index < 0) || (point->left_index > max_index)) { + BREAK_TO_DEBUGGER(); +- return dal_fixed31_32_zero; ++ return dc_fixpt_zero; + } + + if ((point->right_index < 0) || (point->right_index > max_index)) { + BREAK_TO_DEBUGGER(); +- return dal_fixed31_32_zero; ++ return dc_fixpt_zero; + } + + if (point->pos == HW_POINT_POSITION_MIDDLE) + if (channel == CHANNEL_NAME_RED) +- result = dal_fixed31_32_add( +- dal_fixed31_32_mul( ++ result = dc_fixpt_add( ++ dc_fixpt_mul( + point->coeff, +- dal_fixed31_32_sub( ++ dc_fixpt_sub( + rgb[point->right_index].r, + rgb[point->left_index].r)), + rgb[point->left_index].r); + else if (channel == CHANNEL_NAME_GREEN) +- result = dal_fixed31_32_add( +- dal_fixed31_32_mul( ++ result = dc_fixpt_add( ++ dc_fixpt_mul( + point->coeff, +- dal_fixed31_32_sub( ++ dc_fixpt_sub( + rgb[point->right_index].g, + rgb[point->left_index].g)), + rgb[point->left_index].g); + else +- result = dal_fixed31_32_add( +- dal_fixed31_32_mul( ++ result = dc_fixpt_add( ++ dc_fixpt_mul( + point->coeff, +- dal_fixed31_32_sub( ++ dc_fixpt_sub( + rgb[point->right_index].b, + rgb[point->left_index].b)), + rgb[point->left_index].b); + else if (point->pos == HW_POINT_POSITION_LEFT) { + BREAK_TO_DEBUGGER(); +- result = dal_fixed31_32_zero; ++ result = dc_fixpt_zero; + } else { + BREAK_TO_DEBUGGER(); +- result = dal_fixed31_32_one; ++ result = dc_fixpt_one; + } + + return result; +@@ -558,7 +558,7 @@ static void build_pq(struct pwl_float_data_ex *rgb_regamma, + struct fixed31_32 x; + struct fixed31_32 output; + struct fixed31_32 scaling_factor = +- dal_fixed31_32_from_fraction(sdr_white_level, 10000); ++ dc_fixpt_from_fraction(sdr_white_level, 10000); + + if (!pq_initialized && sdr_white_level == 80) { + precompute_pq(); +@@ -579,15 +579,15 @@ static void build_pq(struct pwl_float_data_ex *rgb_regamma, + if (sdr_white_level == 80) { + output = pq_table[i]; + } else { +- x = dal_fixed31_32_mul(coord_x->x, scaling_factor); ++ x = dc_fixpt_mul(coord_x->x, scaling_factor); + compute_pq(x, &output); + } + + /* should really not happen? */ +- if (dal_fixed31_32_lt(output, dal_fixed31_32_zero)) +- output = dal_fixed31_32_zero; +- else if (dal_fixed31_32_lt(dal_fixed31_32_one, output)) +- output = dal_fixed31_32_one; ++ if (dc_fixpt_lt(output, dc_fixpt_zero)) ++ output = dc_fixpt_zero; ++ else if (dc_fixpt_lt(dc_fixpt_one, output)) ++ output = dc_fixpt_one; + + rgb->r = output; + rgb->g = output; +@@ -605,7 +605,7 @@ static void build_de_pq(struct pwl_float_data_ex *de_pq, + uint32_t i; + struct fixed31_32 output; + +- struct fixed31_32 scaling_factor = dal_fixed31_32_from_int(125); ++ struct fixed31_32 scaling_factor = dc_fixpt_from_int(125); + + if (!de_pq_initialized) { + precompute_de_pq(); +@@ -616,9 +616,9 @@ static void build_de_pq(struct pwl_float_data_ex *de_pq, + for (i = 0; i <= hw_points_num; i++) { + output = de_pq_table[i]; + /* should really not happen? */ +- if (dal_fixed31_32_lt(output, dal_fixed31_32_zero)) +- output = dal_fixed31_32_zero; +- else if (dal_fixed31_32_lt(scaling_factor, output)) ++ if (dc_fixpt_lt(output, dc_fixpt_zero)) ++ output = dc_fixpt_zero; ++ else if (dc_fixpt_lt(scaling_factor, output)) + output = scaling_factor; + de_pq[i].r = output; + de_pq[i].g = output; +@@ -670,9 +670,9 @@ static void build_degamma(struct pwl_float_data_ex *curve, + end_index = begin_index + 12 * NUM_PTS_IN_REGION; + + while (i != begin_index) { +- curve[i].r = dal_fixed31_32_zero; +- curve[i].g = dal_fixed31_32_zero; +- curve[i].b = dal_fixed31_32_zero; ++ curve[i].r = dc_fixpt_zero; ++ curve[i].g = dc_fixpt_zero; ++ curve[i].b = dc_fixpt_zero; + i++; + } + +@@ -684,9 +684,9 @@ static void build_degamma(struct pwl_float_data_ex *curve, + i++; + } + while (i != hw_points_num + 1) { +- curve[i].r = dal_fixed31_32_one; +- curve[i].g = dal_fixed31_32_one; +- curve[i].b = dal_fixed31_32_one; ++ curve[i].r = dc_fixpt_one; ++ curve[i].g = dc_fixpt_one; ++ curve[i].b = dc_fixpt_one; + i++; + } + } +@@ -695,8 +695,8 @@ static void scale_gamma(struct pwl_float_data *pwl_rgb, + const struct dc_gamma *ramp, + struct dividers dividers) + { +- const struct fixed31_32 max_driver = dal_fixed31_32_from_int(0xFFFF); +- const struct fixed31_32 max_os = dal_fixed31_32_from_int(0xFF00); ++ const struct fixed31_32 max_driver = dc_fixpt_from_int(0xFFFF); ++ const struct fixed31_32 max_os = dc_fixpt_from_int(0xFF00); + struct fixed31_32 scaler = max_os; + uint32_t i; + struct pwl_float_data *rgb = pwl_rgb; +@@ -705,9 +705,9 @@ static void scale_gamma(struct pwl_float_data *pwl_rgb, + i = 0; + + do { +- if (dal_fixed31_32_lt(max_os, ramp->entries.red[i]) || +- dal_fixed31_32_lt(max_os, ramp->entries.green[i]) || +- dal_fixed31_32_lt(max_os, ramp->entries.blue[i])) { ++ if (dc_fixpt_lt(max_os, ramp->entries.red[i]) || ++ dc_fixpt_lt(max_os, ramp->entries.green[i]) || ++ dc_fixpt_lt(max_os, ramp->entries.blue[i])) { + scaler = max_driver; + break; + } +@@ -717,40 +717,40 @@ static void scale_gamma(struct pwl_float_data *pwl_rgb, + i = 0; + + do { +- rgb->r = dal_fixed31_32_div( ++ rgb->r = dc_fixpt_div( + ramp->entries.red[i], scaler); +- rgb->g = dal_fixed31_32_div( ++ rgb->g = dc_fixpt_div( + ramp->entries.green[i], scaler); +- rgb->b = dal_fixed31_32_div( ++ rgb->b = dc_fixpt_div( + ramp->entries.blue[i], scaler); + + ++rgb; + ++i; + } while (i != ramp->num_entries); + +- rgb->r = dal_fixed31_32_mul(rgb_last->r, ++ rgb->r = dc_fixpt_mul(rgb_last->r, + dividers.divider1); +- rgb->g = dal_fixed31_32_mul(rgb_last->g, ++ rgb->g = dc_fixpt_mul(rgb_last->g, + dividers.divider1); +- rgb->b = dal_fixed31_32_mul(rgb_last->b, ++ rgb->b = dc_fixpt_mul(rgb_last->b, + dividers.divider1); + + ++rgb; + +- rgb->r = dal_fixed31_32_mul(rgb_last->r, ++ rgb->r = dc_fixpt_mul(rgb_last->r, + dividers.divider2); +- rgb->g = dal_fixed31_32_mul(rgb_last->g, ++ rgb->g = dc_fixpt_mul(rgb_last->g, + dividers.divider2); +- rgb->b = dal_fixed31_32_mul(rgb_last->b, ++ rgb->b = dc_fixpt_mul(rgb_last->b, + dividers.divider2); + + ++rgb; + +- rgb->r = dal_fixed31_32_mul(rgb_last->r, ++ rgb->r = dc_fixpt_mul(rgb_last->r, + dividers.divider3); +- rgb->g = dal_fixed31_32_mul(rgb_last->g, ++ rgb->g = dc_fixpt_mul(rgb_last->g, + dividers.divider3); +- rgb->b = dal_fixed31_32_mul(rgb_last->b, ++ rgb->b = dc_fixpt_mul(rgb_last->b, + dividers.divider3); + } + +@@ -759,62 +759,62 @@ static void scale_gamma_dx(struct pwl_float_data *pwl_rgb, + struct dividers dividers) + { + uint32_t i; +- struct fixed31_32 min = dal_fixed31_32_zero; +- struct fixed31_32 max = dal_fixed31_32_one; ++ struct fixed31_32 min = dc_fixpt_zero; ++ struct fixed31_32 max = dc_fixpt_one; + +- struct fixed31_32 delta = dal_fixed31_32_zero; +- struct fixed31_32 offset = dal_fixed31_32_zero; ++ struct fixed31_32 delta = dc_fixpt_zero; ++ struct fixed31_32 offset = dc_fixpt_zero; + + for (i = 0 ; i < ramp->num_entries; i++) { +- if (dal_fixed31_32_lt(ramp->entries.red[i], min)) ++ if (dc_fixpt_lt(ramp->entries.red[i], min)) + min = ramp->entries.red[i]; + +- if (dal_fixed31_32_lt(ramp->entries.green[i], min)) ++ if (dc_fixpt_lt(ramp->entries.green[i], min)) + min = ramp->entries.green[i]; + +- if (dal_fixed31_32_lt(ramp->entries.blue[i], min)) ++ if (dc_fixpt_lt(ramp->entries.blue[i], min)) + min = ramp->entries.blue[i]; + +- if (dal_fixed31_32_lt(max, ramp->entries.red[i])) ++ if (dc_fixpt_lt(max, ramp->entries.red[i])) + max = ramp->entries.red[i]; + +- if (dal_fixed31_32_lt(max, ramp->entries.green[i])) ++ if (dc_fixpt_lt(max, ramp->entries.green[i])) + max = ramp->entries.green[i]; + +- if (dal_fixed31_32_lt(max, ramp->entries.blue[i])) ++ if (dc_fixpt_lt(max, ramp->entries.blue[i])) + max = ramp->entries.blue[i]; + } + +- if (dal_fixed31_32_lt(min, dal_fixed31_32_zero)) +- delta = dal_fixed31_32_neg(min); ++ if (dc_fixpt_lt(min, dc_fixpt_zero)) ++ delta = dc_fixpt_neg(min); + +- offset = dal_fixed31_32_add(min, max); ++ offset = dc_fixpt_add(min, max); + + for (i = 0 ; i < ramp->num_entries; i++) { +- pwl_rgb[i].r = dal_fixed31_32_div( +- dal_fixed31_32_add( ++ pwl_rgb[i].r = dc_fixpt_div( ++ dc_fixpt_add( + ramp->entries.red[i], delta), offset); +- pwl_rgb[i].g = dal_fixed31_32_div( +- dal_fixed31_32_add( ++ pwl_rgb[i].g = dc_fixpt_div( ++ dc_fixpt_add( + ramp->entries.green[i], delta), offset); +- pwl_rgb[i].b = dal_fixed31_32_div( +- dal_fixed31_32_add( ++ pwl_rgb[i].b = dc_fixpt_div( ++ dc_fixpt_add( + ramp->entries.blue[i], delta), offset); + + } + +- pwl_rgb[i].r = dal_fixed31_32_sub(dal_fixed31_32_mul_int( ++ pwl_rgb[i].r = dc_fixpt_sub(dc_fixpt_mul_int( + pwl_rgb[i-1].r, 2), pwl_rgb[i-2].r); +- pwl_rgb[i].g = dal_fixed31_32_sub(dal_fixed31_32_mul_int( ++ pwl_rgb[i].g = dc_fixpt_sub(dc_fixpt_mul_int( + pwl_rgb[i-1].g, 2), pwl_rgb[i-2].g); +- pwl_rgb[i].b = dal_fixed31_32_sub(dal_fixed31_32_mul_int( ++ pwl_rgb[i].b = dc_fixpt_sub(dc_fixpt_mul_int( + pwl_rgb[i-1].b, 2), pwl_rgb[i-2].b); + ++i; +- pwl_rgb[i].r = dal_fixed31_32_sub(dal_fixed31_32_mul_int( ++ pwl_rgb[i].r = dc_fixpt_sub(dc_fixpt_mul_int( + pwl_rgb[i-1].r, 2), pwl_rgb[i-2].r); +- pwl_rgb[i].g = dal_fixed31_32_sub(dal_fixed31_32_mul_int( ++ pwl_rgb[i].g = dc_fixpt_sub(dc_fixpt_mul_int( + pwl_rgb[i-1].g, 2), pwl_rgb[i-2].g); +- pwl_rgb[i].b = dal_fixed31_32_sub(dal_fixed31_32_mul_int( ++ pwl_rgb[i].b = dc_fixpt_sub(dc_fixpt_mul_int( + pwl_rgb[i-1].b, 2), pwl_rgb[i-2].b); + } + +@@ -846,40 +846,40 @@ static void scale_user_regamma_ramp(struct pwl_float_data *pwl_rgb, + + i = 0; + do { +- rgb->r = dal_fixed31_32_from_fraction( ++ rgb->r = dc_fixpt_from_fraction( + ramp->gamma[i], scaler); +- rgb->g = dal_fixed31_32_from_fraction( ++ rgb->g = dc_fixpt_from_fraction( + ramp->gamma[i + 256], scaler); +- rgb->b = dal_fixed31_32_from_fraction( ++ rgb->b = dc_fixpt_from_fraction( + ramp->gamma[i + 512], scaler); + + ++rgb; + ++i; + } while (i != GAMMA_RGB_256_ENTRIES); + +- rgb->r = dal_fixed31_32_mul(rgb_last->r, ++ rgb->r = dc_fixpt_mul(rgb_last->r, + dividers.divider1); +- rgb->g = dal_fixed31_32_mul(rgb_last->g, ++ rgb->g = dc_fixpt_mul(rgb_last->g, + dividers.divider1); +- rgb->b = dal_fixed31_32_mul(rgb_last->b, ++ rgb->b = dc_fixpt_mul(rgb_last->b, + dividers.divider1); + + ++rgb; + +- rgb->r = dal_fixed31_32_mul(rgb_last->r, ++ rgb->r = dc_fixpt_mul(rgb_last->r, + dividers.divider2); +- rgb->g = dal_fixed31_32_mul(rgb_last->g, ++ rgb->g = dc_fixpt_mul(rgb_last->g, + dividers.divider2); +- rgb->b = dal_fixed31_32_mul(rgb_last->b, ++ rgb->b = dc_fixpt_mul(rgb_last->b, + dividers.divider2); + + ++rgb; + +- rgb->r = dal_fixed31_32_mul(rgb_last->r, ++ rgb->r = dc_fixpt_mul(rgb_last->r, + dividers.divider3); +- rgb->g = dal_fixed31_32_mul(rgb_last->g, ++ rgb->g = dc_fixpt_mul(rgb_last->g, + dividers.divider3); +- rgb->b = dal_fixed31_32_mul(rgb_last->b, ++ rgb->b = dc_fixpt_mul(rgb_last->b, + dividers.divider3); + } + +@@ -913,7 +913,7 @@ static void apply_lut_1d( + struct fixed31_32 lut2; + const int max_lut_index = 4095; + const struct fixed31_32 max_lut_index_f = +- dal_fixed31_32_from_int_nonconst(max_lut_index); ++ dc_fixpt_from_int_nonconst(max_lut_index); + int32_t index = 0, index_next = 0; + struct fixed31_32 index_f; + struct fixed31_32 delta_lut; +@@ -931,10 +931,10 @@ static void apply_lut_1d( + else + regamma_y = &tf_pts->blue[i]; + +- norm_y = dal_fixed31_32_mul(max_lut_index_f, ++ norm_y = dc_fixpt_mul(max_lut_index_f, + *regamma_y); +- index = dal_fixed31_32_floor(norm_y); +- index_f = dal_fixed31_32_from_int_nonconst(index); ++ index = dc_fixpt_floor(norm_y); ++ index_f = dc_fixpt_from_int_nonconst(index); + + if (index < 0 || index > max_lut_index) + continue; +@@ -953,11 +953,11 @@ static void apply_lut_1d( + } + + // we have everything now, so interpolate +- delta_lut = dal_fixed31_32_sub(lut2, lut1); +- delta_index = dal_fixed31_32_sub(norm_y, index_f); ++ delta_lut = dc_fixpt_sub(lut2, lut1); ++ delta_index = dc_fixpt_sub(norm_y, index_f); + +- *regamma_y = dal_fixed31_32_add(lut1, +- dal_fixed31_32_mul(delta_index, delta_lut)); ++ *regamma_y = dc_fixpt_add(lut1, ++ dc_fixpt_mul(delta_index, delta_lut)); + } + } + } +@@ -973,7 +973,7 @@ static void build_evenly_distributed_points( + uint32_t i = 0; + + do { +- struct fixed31_32 value = dal_fixed31_32_from_fraction(i, ++ struct fixed31_32 value = dc_fixpt_from_fraction(i, + numberof_points - 1); + + p->r = value; +@@ -984,21 +984,21 @@ static void build_evenly_distributed_points( + ++i; + } while (i != numberof_points); + +- p->r = dal_fixed31_32_div(p_last->r, dividers.divider1); +- p->g = dal_fixed31_32_div(p_last->g, dividers.divider1); +- p->b = dal_fixed31_32_div(p_last->b, dividers.divider1); ++ p->r = dc_fixpt_div(p_last->r, dividers.divider1); ++ p->g = dc_fixpt_div(p_last->g, dividers.divider1); ++ p->b = dc_fixpt_div(p_last->b, dividers.divider1); + + ++p; + +- p->r = dal_fixed31_32_div(p_last->r, dividers.divider2); +- p->g = dal_fixed31_32_div(p_last->g, dividers.divider2); +- p->b = dal_fixed31_32_div(p_last->b, dividers.divider2); ++ p->r = dc_fixpt_div(p_last->r, dividers.divider2); ++ p->g = dc_fixpt_div(p_last->g, dividers.divider2); ++ p->b = dc_fixpt_div(p_last->b, dividers.divider2); + + ++p; + +- p->r = dal_fixed31_32_div(p_last->r, dividers.divider3); +- p->g = dal_fixed31_32_div(p_last->g, dividers.divider3); +- p->b = dal_fixed31_32_div(p_last->b, dividers.divider3); ++ p->r = dc_fixpt_div(p_last->r, dividers.divider3); ++ p->g = dc_fixpt_div(p_last->g, dividers.divider3); ++ p->b = dc_fixpt_div(p_last->b, dividers.divider3); + } + + static inline void copy_rgb_regamma_to_coordinates_x( +@@ -1094,7 +1094,7 @@ static void interpolate_user_regamma(uint32_t hw_points_num, + struct fixed31_32 *tf_point; + struct fixed31_32 hw_x; + struct fixed31_32 norm_factor = +- dal_fixed31_32_from_int_nonconst(255); ++ dc_fixpt_from_int_nonconst(255); + struct fixed31_32 norm_x; + struct fixed31_32 index_f; + struct fixed31_32 lut1; +@@ -1105,9 +1105,9 @@ static void interpolate_user_regamma(uint32_t hw_points_num, + i = 0; + /* fixed_pt library has problems handling too small values */ + while (i != 32) { +- tf_pts->red[i] = dal_fixed31_32_zero; +- tf_pts->green[i] = dal_fixed31_32_zero; +- tf_pts->blue[i] = dal_fixed31_32_zero; ++ tf_pts->red[i] = dc_fixpt_zero; ++ tf_pts->green[i] = dc_fixpt_zero; ++ tf_pts->blue[i] = dc_fixpt_zero; + ++i; + } + while (i <= hw_points_num + 1) { +@@ -1129,12 +1129,12 @@ static void interpolate_user_regamma(uint32_t hw_points_num, + } else + hw_x = coordinates_x[i].x; + +- norm_x = dal_fixed31_32_mul(norm_factor, hw_x); +- index = dal_fixed31_32_floor(norm_x); ++ norm_x = dc_fixpt_mul(norm_factor, hw_x); ++ index = dc_fixpt_floor(norm_x); + if (index < 0 || index > 255) + continue; + +- index_f = dal_fixed31_32_from_int_nonconst(index); ++ index_f = dc_fixpt_from_int_nonconst(index); + index_next = (index == 255) ? index : index + 1; + + if (color == 0) { +@@ -1149,11 +1149,11 @@ static void interpolate_user_regamma(uint32_t hw_points_num, + } + + // we have everything now, so interpolate +- delta_lut = dal_fixed31_32_sub(lut2, lut1); +- delta_index = dal_fixed31_32_sub(norm_x, index_f); ++ delta_lut = dc_fixpt_sub(lut2, lut1); ++ delta_index = dc_fixpt_sub(norm_x, index_f); + +- *tf_point = dal_fixed31_32_add(lut1, +- dal_fixed31_32_mul(delta_index, delta_lut)); ++ *tf_point = dc_fixpt_add(lut1, ++ dc_fixpt_mul(delta_index, delta_lut)); + } + ++i; + } +@@ -1168,15 +1168,15 @@ static void build_new_custom_resulted_curve( + i = 0; + + while (i != hw_points_num + 1) { +- tf_pts->red[i] = dal_fixed31_32_clamp( +- tf_pts->red[i], dal_fixed31_32_zero, +- dal_fixed31_32_one); +- tf_pts->green[i] = dal_fixed31_32_clamp( +- tf_pts->green[i], dal_fixed31_32_zero, +- dal_fixed31_32_one); +- tf_pts->blue[i] = dal_fixed31_32_clamp( +- tf_pts->blue[i], dal_fixed31_32_zero, +- dal_fixed31_32_one); ++ tf_pts->red[i] = dc_fixpt_clamp( ++ tf_pts->red[i], dc_fixpt_zero, ++ dc_fixpt_one); ++ tf_pts->green[i] = dc_fixpt_clamp( ++ tf_pts->green[i], dc_fixpt_zero, ++ dc_fixpt_one); ++ tf_pts->blue[i] = dc_fixpt_clamp( ++ tf_pts->blue[i], dc_fixpt_zero, ++ dc_fixpt_one); + + ++i; + } +@@ -1290,9 +1290,9 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf, + if (!coeff) + goto coeff_alloc_fail; + +- dividers.divider1 = dal_fixed31_32_from_fraction(3, 2); +- dividers.divider2 = dal_fixed31_32_from_int(2); +- dividers.divider3 = dal_fixed31_32_from_fraction(5, 2); ++ dividers.divider1 = dc_fixpt_from_fraction(3, 2); ++ dividers.divider2 = dc_fixpt_from_int(2); ++ dividers.divider3 = dc_fixpt_from_fraction(5, 2); + + tf = output_tf->tf; + +@@ -1357,15 +1357,15 @@ bool calculate_user_regamma_coeff(struct dc_transfer_func *output_tf, + uint32_t i = 0; + + do { +- coeff.a0[i] = dal_fixed31_32_from_fraction( ++ coeff.a0[i] = dc_fixpt_from_fraction( + regamma->coeff.A0[i], 10000000); +- coeff.a1[i] = dal_fixed31_32_from_fraction( ++ coeff.a1[i] = dc_fixpt_from_fraction( + regamma->coeff.A1[i], 1000); +- coeff.a2[i] = dal_fixed31_32_from_fraction( ++ coeff.a2[i] = dc_fixpt_from_fraction( + regamma->coeff.A2[i], 1000); +- coeff.a3[i] = dal_fixed31_32_from_fraction( ++ coeff.a3[i] = dc_fixpt_from_fraction( + regamma->coeff.A3[i], 1000); +- coeff.user_gamma[i] = dal_fixed31_32_from_fraction( ++ coeff.user_gamma[i] = dc_fixpt_from_fraction( + regamma->coeff.gamma[i], 1000); + + ++i; +@@ -1374,9 +1374,9 @@ bool calculate_user_regamma_coeff(struct dc_transfer_func *output_tf, + i = 0; + /* fixed_pt library has problems handling too small values */ + while (i != 32) { +- output_tf->tf_pts.red[i] = dal_fixed31_32_zero; +- output_tf->tf_pts.green[i] = dal_fixed31_32_zero; +- output_tf->tf_pts.blue[i] = dal_fixed31_32_zero; ++ output_tf->tf_pts.red[i] = dc_fixpt_zero; ++ output_tf->tf_pts.green[i] = dc_fixpt_zero; ++ output_tf->tf_pts.blue[i] = dc_fixpt_zero; + ++coord_x; + ++i; + } +@@ -1423,9 +1423,9 @@ bool calculate_user_regamma_ramp(struct dc_transfer_func *output_tf, + if (!rgb_regamma) + goto rgb_regamma_alloc_fail; + +- dividers.divider1 = dal_fixed31_32_from_fraction(3, 2); +- dividers.divider2 = dal_fixed31_32_from_int(2); +- dividers.divider3 = dal_fixed31_32_from_fraction(5, 2); ++ dividers.divider1 = dc_fixpt_from_fraction(3, 2); ++ dividers.divider2 = dc_fixpt_from_int(2); ++ dividers.divider3 = dc_fixpt_from_fraction(5, 2); + + scale_user_regamma_ramp(rgb_user, ®amma->ramp, dividers); + +@@ -1496,9 +1496,9 @@ bool mod_color_calculate_degamma_params(struct dc_transfer_func *input_tf, + if (!coeff) + goto coeff_alloc_fail; + +- dividers.divider1 = dal_fixed31_32_from_fraction(3, 2); +- dividers.divider2 = dal_fixed31_32_from_int(2); +- dividers.divider3 = dal_fixed31_32_from_fraction(5, 2); ++ dividers.divider1 = dc_fixpt_from_fraction(3, 2); ++ dividers.divider2 = dc_fixpt_from_int(2); ++ dividers.divider3 = dc_fixpt_from_fraction(5, 2); + + tf = input_tf->tf; + +-- +2.7.4 + |