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>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

1 files changed, 223 insertions, 223 deletions

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 15e5b72e6e00..29d2ec82b924 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, &regamma->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;