drivers/gpu/drm/amd/display/dc/spl/dc_spl.c

   1 // SPDX-License-Identifier: MIT
   2 //
   3 // Copyright 2024 Advanced Micro Devices, Inc.
   4
   5 #include "dc_spl.h"
   6 #include "dc_spl_scl_filters.h"
   7 #include "dc_spl_scl_easf_filters.h"
   8 #include "dc_spl_isharp_filters.h"
   9 #include "spl_debug.h"
  10
  11 #define IDENTITY_RATIO(ratio) (spl_fixpt_u2d19(ratio) == (1 << 19))
  12 #define MIN_VIEWPORT_SIZE 12
  13
  14 static bool spl_is_yuv420(enum spl_pixel_format format)
  15 {
  16         if ((format >= SPL_PIXEL_FORMAT_420BPP8) &&
  17                 (format <= SPL_PIXEL_FORMAT_420BPP10))
  18                 return true;
  19
  20         return false;
  21 }
  22
  23 static bool spl_is_rgb8(enum spl_pixel_format format)
  24 {
  25         if (format == SPL_PIXEL_FORMAT_ARGB8888)
  26                 return true;
  27
  28         return false;
  29 }
  30
  31 static bool spl_is_video_format(enum spl_pixel_format format)
  32 {
  33         if (format >= SPL_PIXEL_FORMAT_VIDEO_BEGIN
  34                 && format <= SPL_PIXEL_FORMAT_VIDEO_END)
  35                 return true;
  36         else
  37                 return false;
  38 }
  39
  40 static bool spl_is_subsampled_format(enum spl_pixel_format format)
  41 {
  42         if (format >= SPL_PIXEL_FORMAT_SUBSAMPLED_BEGIN
  43                 && format <= SPL_PIXEL_FORMAT_SUBSAMPLED_END)
  44                 return true;
  45         else
  46                 return false;
  47 }
  48
  49 static struct spl_rect intersect_rec(const struct spl_rect *r0, const struct spl_rect *r1)
  50 {
  51         struct spl_rect rec;
  52         int r0_x_end = r0->x + r0->width;
  53         int r1_x_end = r1->x + r1->width;
  54         int r0_y_end = r0->y + r0->height;
  55         int r1_y_end = r1->y + r1->height;
  56
  57         rec.x = r0->x > r1->x ? r0->x : r1->x;
  58         rec.width = r0_x_end > r1_x_end ? r1_x_end - rec.x : r0_x_end - rec.x;
  59         rec.y = r0->y > r1->y ? r0->y : r1->y;
  60         rec.height = r0_y_end > r1_y_end ? r1_y_end - rec.y : r0_y_end - rec.y;
  61
  62         /* in case that there is no intersection */
  63         if (rec.width < 0 || rec.height < 0)
  64                 memset(&rec, 0, sizeof(rec));
  65
  66         return rec;
  67 }
  68
  69 static struct spl_rect shift_rec(const struct spl_rect *rec_in, int x, int y)
  70 {
  71         struct spl_rect rec_out = *rec_in;
  72
  73         rec_out.x += x;
  74         rec_out.y += y;
  75
  76         return rec_out;
  77 }
  78
  79 static struct spl_rect calculate_plane_rec_in_timing_active(
  80                 struct spl_in *spl_in,
  81                 const struct spl_rect *rec_in)
  82 {
  83         /*
  84          * The following diagram shows an example where we map a 1920x1200
  85          * desktop to a 2560x1440 timing with a plane rect in the middle
  86          * of the screen. To map a plane rect from Stream Source to Timing
  87          * Active space, we first multiply stream scaling ratios (i.e 2304/1920
  88          * horizontal and 1440/1200 vertical) to the plane's x and y, then
  89          * we add stream destination offsets (i.e 128 horizontal, 0 vertical).
  90          * This will give us a plane rect's position in Timing Active. However
  91          * we have to remove the fractional. The rule is that we find left/right
  92          * and top/bottom positions and round the value to the adjacent integer.
  93          *
  94          * Stream Source Space
  95          * ------------
  96          *        __________________________________________________
  97          *       |Stream Source (1920 x 1200) ^                     |
  98          *       |                            y                     |
  99          *       |         <------- w --------|>                    |
 100          *       |          __________________V                     |
 101          *       |<-- x -->|Plane//////////////| ^                  |
 102          *       |         |(pre scale)////////| |                  |
 103          *       |         |///////////////////| |                  |
 104          *       |         |///////////////////| h                  |
 105          *       |         |///////////////////| |                  |
 106          *       |         |///////////////////| |                  |
 107          *       |         |///////////////////| V                  |
 108          *       |                                                  |
 109          *       |                                                  |
 110          *       |__________________________________________________|
 111          *
 112          *
 113          * Timing Active Space
 114          * ---------------------------------
 115          *
 116          *       Timing Active (2560 x 1440)
 117          *        __________________________________________________
 118          *       |*****|  Stteam Destination (2304 x 1440)    |*****|
 119          *       |*****|                                      |*****|
 120          *       |<128>|                                      |*****|
 121          *       |*****|     __________________               |*****|
 122          *       |*****|    |Plane/////////////|              |*****|
 123          *       |*****|    |(post scale)//////|              |*****|
 124          *       |*****|    |//////////////////|              |*****|
 125          *       |*****|    |//////////////////|              |*****|
 126          *       |*****|    |//////////////////|              |*****|
 127          *       |*****|    |//////////////////|              |*****|
 128          *       |*****|                                      |*****|
 129          *       |*****|                                      |*****|
 130          *       |*****|                                      |*****|
 131          *       |*****|______________________________________|*****|
 132          *
 133          * So the resulting formulas are shown below:
 134          *
 135          * recout_x = 128 + round(plane_x * 2304 / 1920)
 136          * recout_w = 128 + round((plane_x + plane_w) * 2304 / 1920) - recout_x
 137          * recout_y = 0 + round(plane_y * 1440 / 1200)
 138          * recout_h = 0 + round((plane_y + plane_h) * 1440 / 1200) - recout_y
 139          *
 140          * NOTE: fixed point division is not error free. To reduce errors
 141          * introduced by fixed point division, we divide only after
 142          * multiplication is complete.
 143          */
 144         const struct spl_rect *stream_src = &spl_in->basic_out.src_rect;
 145         const struct spl_rect *stream_dst = &spl_in->basic_out.dst_rect;
 146         struct spl_rect rec_out = {0};
 147         struct spl_fixed31_32 temp;
 148
 149
 150         temp = spl_fixpt_from_fraction(rec_in->x * (long long)stream_dst->width,
 151                         stream_src->width);
 152         rec_out.x = stream_dst->x + spl_fixpt_round(temp);
 153
 154         temp = spl_fixpt_from_fraction(
 155                         (rec_in->x + rec_in->width) * (long long)stream_dst->width,
 156                         stream_src->width);
 157         rec_out.width = stream_dst->x + spl_fixpt_round(temp) - rec_out.x;
 158
 159         temp = spl_fixpt_from_fraction(rec_in->y * (long long)stream_dst->height,
 160                         stream_src->height);
 161         rec_out.y = stream_dst->y + spl_fixpt_round(temp);
 162
 163         temp = spl_fixpt_from_fraction(
 164                         (rec_in->y + rec_in->height) * (long long)stream_dst->height,
 165                         stream_src->height);
 166         rec_out.height = stream_dst->y + spl_fixpt_round(temp) - rec_out.y;
 167
 168         return rec_out;
 169 }
 170
 171 static struct spl_rect calculate_mpc_slice_in_timing_active(
 172                 struct spl_in *spl_in,
 173                 struct spl_rect *plane_clip_rec)
 174 {
 175         bool use_recout_width_aligned =
 176                 spl_in->basic_in.num_h_slices_recout_width_align.use_recout_width_aligned;
 177         int mpc_slice_count =
 178                 spl_in->basic_in.num_h_slices_recout_width_align.num_slices_recout_width.mpc_num_h_slices;
 179         int recout_width_align =
 180                 spl_in->basic_in.num_h_slices_recout_width_align.num_slices_recout_width.mpc_recout_width_align;
 181         int mpc_slice_idx = spl_in->basic_in.mpc_h_slice_index;
 182         int epimo = mpc_slice_count - plane_clip_rec->width % mpc_slice_count - 1;
 183         struct spl_rect mpc_rec;
 184
 185         if (use_recout_width_aligned) {
 186                 mpc_rec.width = recout_width_align;
 187                 if ((mpc_rec.width * (mpc_slice_idx + 1)) > plane_clip_rec->width) {
 188                         mpc_rec.width = plane_clip_rec->width % recout_width_align;
 189                         mpc_rec.x = plane_clip_rec->x + recout_width_align * mpc_slice_idx;
 190                 } else
 191                         mpc_rec.x = plane_clip_rec->x + mpc_rec.width * mpc_slice_idx;
 192                 mpc_rec.height = plane_clip_rec->height;
 193                 mpc_rec.y = plane_clip_rec->y;
 194
 195         } else {
 196                 mpc_rec.width = plane_clip_rec->width / mpc_slice_count;
 197                 mpc_rec.x = plane_clip_rec->x + mpc_rec.width * mpc_slice_idx;
 198                 mpc_rec.height = plane_clip_rec->height;
 199                 mpc_rec.y = plane_clip_rec->y;
 200         }
 201         SPL_ASSERT(mpc_slice_count == 1 ||
 202                         spl_in->basic_out.view_format != SPL_VIEW_3D_SIDE_BY_SIDE ||
 203                         mpc_rec.width % 2 == 0);
 204
 205         /* extra pixels in the division remainder need to go to pipes after
 206          * the extra pixel index minus one(epimo) defined here as:
 207          */
 208         if (mpc_slice_idx > epimo) {
 209                 mpc_rec.x += mpc_slice_idx - epimo - 1;
 210                 mpc_rec.width += 1;
 211         }
 212
 213         if (spl_in->basic_out.view_format == SPL_VIEW_3D_TOP_AND_BOTTOM) {
 214                 SPL_ASSERT(mpc_rec.height % 2 == 0);
 215                 mpc_rec.height /= 2;
 216         }
 217         return mpc_rec;
 218 }
 219
 220 static struct spl_rect calculate_odm_slice_in_timing_active(struct spl_in *spl_in)
 221 {
 222         int odm_slice_count = spl_in->basic_out.odm_combine_factor;
 223         int odm_slice_idx = spl_in->odm_slice_index;
 224         bool is_last_odm_slice = (odm_slice_idx + 1) == odm_slice_count;
 225         int h_active = spl_in->basic_out.output_size.width;
 226         int v_active = spl_in->basic_out.output_size.height;
 227         int odm_slice_width;
 228         struct spl_rect odm_rec;
 229
 230         if (spl_in->basic_out.odm_combine_factor > 0) {
 231                 odm_slice_width = h_active / odm_slice_count;
 232                 /*
 233                  * deprecated, caller must pass in odm slice rect i.e OPP input
 234                  * rect in timing active for the new interface.
 235                  */
 236                 if (spl_in->basic_out.use_two_pixels_per_container && (odm_slice_width % 2))
 237                         odm_slice_width++;
 238
 239                 odm_rec.x = odm_slice_width * odm_slice_idx;
 240                 odm_rec.width = is_last_odm_slice ?
 241                                 /* last slice width is the reminder of h_active */
 242                                 h_active - odm_slice_width * (odm_slice_count - 1) :
 243                                 /* odm slice width is the floor of h_active / count */
 244                                 odm_slice_width;
 245                 odm_rec.y = 0;
 246                 odm_rec.height = v_active;
 247
 248                 return odm_rec;
 249         }
 250
 251         return spl_in->basic_out.odm_slice_rect;
 252 }
 253
 254 static void spl_calculate_recout(struct spl_in *spl_in, struct spl_scratch *spl_scratch, struct spl_out *spl_out)
 255 {
 256         /*
 257          * A plane clip represents the desired plane size and position in Stream
 258          * Source Space. Stream Source is the destination where all planes are
 259          * blended (i.e. positioned, scaled and overlaid). It is a canvas where
 260          * all planes associated with the current stream are drawn together.
 261          * After Stream Source is completed, we will further scale and
 262          * reposition the entire canvas of the stream source to Stream
 263          * Destination in Timing Active Space. This could be due to display
 264          * overscan adjustment where we will need to rescale and reposition all
 265          * the planes so they can fit into a TV with overscan or downscale
 266          * upscale features such as GPU scaling or VSR.
 267          *
 268          * This two step blending is a virtual procedure in software. In
 269          * hardware there is no such thing as Stream Source. all planes are
 270          * blended once in Timing Active Space. Software virtualizes a Stream
 271          * Source space to decouple the math complicity so scaling param
 272          * calculation focuses on one step at a time.
 273          *
 274          * In the following two diagrams, user applied 10% overscan adjustment
 275          * so the Stream Source needs to be scaled down a little before mapping
 276          * to Timing Active Space. As a result the Plane Clip is also scaled
 277          * down by the same ratio, Plane Clip position (i.e. x and y) with
 278          * respect to Stream Source is also scaled down. To map it in Timing
 279          * Active Space additional x and y offsets from Stream Destination are
 280          * added to Plane Clip as well.
 281          *
 282          * Stream Source Space
 283          * ------------
 284          *        __________________________________________________
 285          *       |Stream Source (3840 x 2160) ^                     |
 286          *       |                            y                     |
 287          *       |                            |                     |
 288          *       |          __________________V                     |
 289          *       |<-- x -->|Plane Clip/////////|                    |
 290          *       |         |(pre scale)////////|                    |
 291          *       |         |///////////////////|                    |
 292          *       |         |///////////////////|                    |
 293          *       |         |///////////////////|                    |
 294          *       |         |///////////////////|                    |
 295          *       |         |///////////////////|                    |
 296          *       |                                                  |
 297          *       |                                                  |
 298          *       |__________________________________________________|
 299          *
 300          *
 301          * Timing Active Space (3840 x 2160)
 302          * ---------------------------------
 303          *
 304          *       Timing Active
 305          *        __________________________________________________
 306          *       | y_____________________________________________   |
 307          *       |x |Stream Destination (3456 x 1944)            |  |
 308          *       |  |                                            |  |
 309          *       |  |        __________________                  |  |
 310          *       |  |       |Plane Clip////////|                 |  |
 311          *       |  |       |(post scale)//////|                 |  |
 312          *       |  |       |//////////////////|                 |  |
 313          *       |  |       |//////////////////|                 |  |
 314          *       |  |       |//////////////////|                 |  |
 315          *       |  |       |//////////////////|                 |  |
 316          *       |  |                                            |  |
 317          *       |  |                                            |  |
 318          *       |  |____________________________________________|  |
 319          *       |__________________________________________________|
 320          *
 321          *
 322          * In Timing Active Space a plane clip could be further sliced into
 323          * pieces called MPC slices. Each Pipe Context is responsible for
 324          * processing only one MPC slice so the plane processing workload can be
 325          * distributed to multiple DPP Pipes. MPC slices could be blended
 326          * together to a single ODM slice. Each ODM slice is responsible for
 327          * processing a portion of Timing Active divided horizontally so the
 328          * output pixel processing workload can be distributed to multiple OPP
 329          * pipes. All ODM slices are mapped together in ODM block so all MPC
 330          * slices belong to different ODM slices could be pieced together to
 331          * form a single image in Timing Active. MPC slices must belong to
 332          * single ODM slice. If an MPC slice goes across ODM slice boundary, it
 333          * needs to be divided into two MPC slices one for each ODM slice.
 334          *
 335          * In the following diagram the output pixel processing workload is
 336          * divided horizontally into two ODM slices one for each OPP blend tree.
 337          * OPP0 blend tree is responsible for processing left half of Timing
 338          * Active, while OPP2 blend tree is responsible for processing right
 339          * half.
 340          *
 341          * The plane has two MPC slices. However since the right MPC slice goes
 342          * across ODM boundary, two DPP pipes are needed one for each OPP blend
 343          * tree. (i.e. DPP1 for OPP0 blend tree and DPP2 for OPP2 blend tree).
 344          *
 345          * Assuming that we have a Pipe Context associated with OPP0 and DPP1
 346          * working on processing the plane in the diagram. We want to know the
 347          * width and height of the shaded rectangle and its relative position
 348          * with respect to the ODM slice0. This is called the recout of the pipe
 349          * context.
 350          *
 351          * Planes can be at arbitrary size and position and there could be an
 352          * arbitrary number of MPC and ODM slices. The algorithm needs to take
 353          * all scenarios into account.
 354          *
 355          * Timing Active Space (3840 x 2160)
 356          * ---------------------------------
 357          *
 358          *       Timing Active
 359          *        __________________________________________________
 360          *       |OPP0(ODM slice0)^        |OPP2(ODM slice1)        |
 361          *       |                y        |                        |
 362          *       |                |  <- w ->                        |
 363          *       |           _____V________|____                    |
 364          *       |          |DPP0 ^  |DPP1 |DPP2|                   |
 365          *       |<------ x |-----|->|/////|    |                   |
 366          *       |          |     |  |/////|    |                   |
 367          *       |          |     h  |/////|    |                   |
 368          *       |          |     |  |/////|    |                   |
 369          *       |          |_____V__|/////|____|                   |
 370          *       |                         |                        |
 371          *       |                         |                        |
 372          *       |                         |                        |
 373          *       |_________________________|________________________|
 374          *
 375          *
 376          */
 377         struct spl_rect plane_clip;
 378         struct spl_rect mpc_slice_of_plane_clip;
 379         struct spl_rect odm_slice;
 380         struct spl_rect overlapping_area;
 381
 382         plane_clip = calculate_plane_rec_in_timing_active(spl_in,
 383                         &spl_in->basic_in.clip_rect);
 384         /* guard plane clip from drawing beyond stream dst here */
 385         plane_clip = intersect_rec(&plane_clip,
 386                                 &spl_in->basic_out.dst_rect);
 387         mpc_slice_of_plane_clip = calculate_mpc_slice_in_timing_active(
 388                         spl_in, &plane_clip);
 389         odm_slice = calculate_odm_slice_in_timing_active(spl_in);
 390         overlapping_area = intersect_rec(&mpc_slice_of_plane_clip, &odm_slice);
 391
 392         if (overlapping_area.height > 0 &&
 393                         overlapping_area.width > 0) {
 394                 /* shift the overlapping area so it is with respect to current
 395                  * ODM slice's position
 396                  */
 397                 spl_scratch->scl_data.recout = shift_rec(
 398                                 &overlapping_area,
 399                                 -odm_slice.x, -odm_slice.y);
 400                 spl_scratch->scl_data.recout.height -=
 401                         spl_in->debug.visual_confirm_base_offset;
 402                 spl_scratch->scl_data.recout.height -=
 403                         spl_in->debug.visual_confirm_dpp_offset;
 404         } else
 405                 /* if there is no overlap, zero recout */
 406                 memset(&spl_scratch->scl_data.recout, 0,
 407                                 sizeof(struct spl_rect));
 408 }
 409
 410 /* Calculate scaling ratios */
 411 static void spl_calculate_scaling_ratios(struct spl_in *spl_in,
 412                 struct spl_scratch *spl_scratch,
 413                 struct spl_out *spl_out)
 414 {
 415         const int in_w = spl_in->basic_out.src_rect.width;
 416         const int in_h = spl_in->basic_out.src_rect.height;
 417         const int out_w = spl_in->basic_out.dst_rect.width;
 418         const int out_h = spl_in->basic_out.dst_rect.height;
 419         struct spl_rect surf_src = spl_in->basic_in.src_rect;
 420
 421         /*Swap surf_src height and width since scaling ratios are in recout rotation*/
 422         if (spl_in->basic_in.rotation == SPL_ROTATION_ANGLE_90 ||
 423                 spl_in->basic_in.rotation == SPL_ROTATION_ANGLE_270)
 424                 spl_swap(surf_src.height, surf_src.width);
 425
 426         spl_scratch->scl_data.ratios.horz = spl_fixpt_from_fraction(
 427                                         surf_src.width,
 428                                         spl_in->basic_in.dst_rect.width);
 429         spl_scratch->scl_data.ratios.vert = spl_fixpt_from_fraction(
 430                                         surf_src.height,
 431                                         spl_in->basic_in.dst_rect.height);
 432
 433         if (spl_in->basic_out.view_format == SPL_VIEW_3D_SIDE_BY_SIDE)
 434                 spl_scratch->scl_data.ratios.horz.value *= 2;
 435         else if (spl_in->basic_out.view_format == SPL_VIEW_3D_TOP_AND_BOTTOM)
 436                 spl_scratch->scl_data.ratios.vert.value *= 2;
 437
 438         spl_scratch->scl_data.ratios.vert.value = spl_div64_s64(
 439                 spl_scratch->scl_data.ratios.vert.value * in_h, out_h);
 440         spl_scratch->scl_data.ratios.horz.value = spl_div64_s64(
 441                 spl_scratch->scl_data.ratios.horz.value * in_w, out_w);
 442
 443         spl_scratch->scl_data.ratios.horz_c = spl_scratch->scl_data.ratios.horz;
 444         spl_scratch->scl_data.ratios.vert_c = spl_scratch->scl_data.ratios.vert;
 445
 446         if (spl_is_yuv420(spl_in->basic_in.format)) {
 447                 spl_scratch->scl_data.ratios.horz_c.value /= 2;
 448                 spl_scratch->scl_data.ratios.vert_c.value /= 2;
 449         }
 450         spl_scratch->scl_data.ratios.horz = spl_fixpt_truncate(
 451                         spl_scratch->scl_data.ratios.horz, 19);
 452         spl_scratch->scl_data.ratios.vert = spl_fixpt_truncate(
 453                         spl_scratch->scl_data.ratios.vert, 19);
 454         spl_scratch->scl_data.ratios.horz_c = spl_fixpt_truncate(
 455                         spl_scratch->scl_data.ratios.horz_c, 19);
 456         spl_scratch->scl_data.ratios.vert_c = spl_fixpt_truncate(
 457                         spl_scratch->scl_data.ratios.vert_c, 19);
 458
 459         /*
 460          * Coefficient table and some registers are different based on ratio
 461          * that is output/input.  Currently we calculate input/output
 462          * Store 1/ratio in recip_ratio for those lookups
 463          */
 464         spl_scratch->scl_data.recip_ratios.horz = spl_fixpt_recip(
 465                         spl_scratch->scl_data.ratios.horz);
 466         spl_scratch->scl_data.recip_ratios.vert = spl_fixpt_recip(
 467                         spl_scratch->scl_data.ratios.vert);
 468         spl_scratch->scl_data.recip_ratios.horz_c = spl_fixpt_recip(
 469                         spl_scratch->scl_data.ratios.horz_c);
 470         spl_scratch->scl_data.recip_ratios.vert_c = spl_fixpt_recip(
 471                         spl_scratch->scl_data.ratios.vert_c);
 472 }
 473
 474 /* Calculate Viewport size */
 475 static void spl_calculate_viewport_size(struct spl_in *spl_in, struct spl_scratch *spl_scratch)
 476 {
 477         spl_scratch->scl_data.viewport.width = spl_fixpt_ceil(spl_fixpt_mul_int(spl_scratch->scl_data.ratios.horz,
 478                                                         spl_scratch->scl_data.recout.width));
 479         spl_scratch->scl_data.viewport.height = spl_fixpt_ceil(spl_fixpt_mul_int(spl_scratch->scl_data.ratios.vert,
 480                                                         spl_scratch->scl_data.recout.height));
 481         spl_scratch->scl_data.viewport_c.width = spl_fixpt_ceil(spl_fixpt_mul_int(spl_scratch->scl_data.ratios.horz_c,
 482                                                 spl_scratch->scl_data.recout.width));
 483         spl_scratch->scl_data.viewport_c.height = spl_fixpt_ceil(spl_fixpt_mul_int(spl_scratch->scl_data.ratios.vert_c,
 484                                                 spl_scratch->scl_data.recout.height));
 485         if (spl_in->basic_in.rotation == SPL_ROTATION_ANGLE_90 ||
 486                         spl_in->basic_in.rotation == SPL_ROTATION_ANGLE_270) {
 487                 spl_swap(spl_scratch->scl_data.viewport.width, spl_scratch->scl_data.viewport.height);
 488                 spl_swap(spl_scratch->scl_data.viewport_c.width, spl_scratch->scl_data.viewport_c.height);
 489         }
 490 }
 491
 492 static void spl_get_vp_scan_direction(enum spl_rotation_angle rotation,
 493                            bool horizontal_mirror,
 494                            bool *orthogonal_rotation,
 495                            bool *flip_vert_scan_dir,
 496                            bool *flip_horz_scan_dir)
 497 {
 498         *orthogonal_rotation = false;
 499         *flip_vert_scan_dir = false;
 500         *flip_horz_scan_dir = false;
 501         if (rotation == SPL_ROTATION_ANGLE_180) {
 502                 *flip_vert_scan_dir = true;
 503                 *flip_horz_scan_dir = true;
 504         } else if (rotation == SPL_ROTATION_ANGLE_90) {
 505                 *orthogonal_rotation = true;
 506                 *flip_horz_scan_dir = true;
 507         } else if (rotation == SPL_ROTATION_ANGLE_270) {
 508                 *orthogonal_rotation = true;
 509                 *flip_vert_scan_dir = true;
 510         }
 511
 512         if (horizontal_mirror)
 513                 *flip_horz_scan_dir = !*flip_horz_scan_dir;
 514 }
 515
 516 /*
 517  * We completely calculate vp offset, size and inits here based entirely on scaling
 518  * ratios and recout for pixel perfect pipe combine.
 519  */
 520 static void spl_calculate_init_and_vp(bool flip_scan_dir,
 521                                 int recout_offset_within_recout_full,
 522                                 int recout_size,
 523                                 int src_size,
 524                                 int taps,
 525                                 struct spl_fixed31_32 ratio,
 526                                 struct spl_fixed31_32 init_adj,
 527                                 struct spl_fixed31_32 *init,
 528                                 int *vp_offset,
 529                                 int *vp_size)
 530 {
 531         struct spl_fixed31_32 temp;
 532         int int_part;
 533
 534         /*
 535          * First of the taps starts sampling pixel number <init_int_part> corresponding to recout
 536          * pixel 1. Next recout pixel samples int part of <init + scaling ratio> and so on.
 537          * All following calculations are based on this logic.
 538          *
 539          * Init calculated according to formula:
 540          * init = (scaling_ratio + number_of_taps + 1) / 2
 541          * init_bot = init + scaling_ratio
 542          * to get pixel perfect combine add the fraction from calculating vp offset
 543          */
 544         temp = spl_fixpt_mul_int(ratio, recout_offset_within_recout_full);
 545         *vp_offset = spl_fixpt_floor(temp);
 546         temp.value &= 0xffffffff;
 547         *init = spl_fixpt_add(spl_fixpt_div_int(spl_fixpt_add_int(ratio, taps + 1), 2), temp);
 548         *init = spl_fixpt_add(*init, init_adj);
 549         *init = spl_fixpt_truncate(*init, 19);
 550
 551         /*
 552          * If viewport has non 0 offset and there are more taps than covered by init then
 553          * we should decrease the offset and increase init so we are never sampling
 554          * outside of viewport.
 555          */
 556         int_part = spl_fixpt_floor(*init);
 557         if (int_part < taps) {
 558                 int_part = taps - int_part;
 559                 if (int_part > *vp_offset)
 560                         int_part = *vp_offset;
 561                 *vp_offset -= int_part;
 562                 *init = spl_fixpt_add_int(*init, int_part);
 563         }
 564         /*
 565          * If taps are sampling outside of viewport at end of recout and there are more pixels
 566          * available in the surface we should increase the viewport size, regardless set vp to
 567          * only what is used.
 568          */
 569         temp = spl_fixpt_add(*init, spl_fixpt_mul_int(ratio, recout_size - 1));
 570         *vp_size = spl_fixpt_floor(temp);
 571         if (*vp_size + *vp_offset > src_size)
 572                 *vp_size = src_size - *vp_offset;
 573
 574         /* We did all the math assuming we are scanning same direction as display does,
 575          * however mirror/rotation changes how vp scans vs how it is offset. If scan direction
 576          * is flipped we simply need to calculate offset from the other side of plane.
 577          * Note that outside of viewport all scaling hardware works in recout space.
 578          */
 579         if (flip_scan_dir)
 580                 *vp_offset = src_size - *vp_offset - *vp_size;
 581 }
 582
 583 /*Calculate inits and viewport */
 584 static void spl_calculate_inits_and_viewports(struct spl_in *spl_in,
 585                 struct spl_scratch *spl_scratch)
 586 {
 587         struct spl_rect src = spl_in->basic_in.src_rect;
 588         struct spl_rect recout_dst_in_active_timing;
 589         struct spl_rect recout_clip_in_active_timing;
 590         struct spl_rect recout_clip_in_recout_dst;
 591         struct spl_rect overlap_in_active_timing;
 592         struct spl_rect odm_slice = calculate_odm_slice_in_timing_active(spl_in);
 593         int vpc_div = spl_is_subsampled_format(spl_in->basic_in.format) ? 2 : 1;
 594         bool orthogonal_rotation, flip_vert_scan_dir, flip_horz_scan_dir;
 595         struct spl_fixed31_32 init_adj_h = spl_fixpt_zero;
 596         struct spl_fixed31_32 init_adj_v = spl_fixpt_zero;
 597
 598         recout_clip_in_active_timing = shift_rec(
 599                         &spl_scratch->scl_data.recout, odm_slice.x, odm_slice.y);
 600         recout_dst_in_active_timing = calculate_plane_rec_in_timing_active(
 601                         spl_in, &spl_in->basic_in.dst_rect);
 602         overlap_in_active_timing = intersect_rec(&recout_clip_in_active_timing,
 603                         &recout_dst_in_active_timing);
 604         if (overlap_in_active_timing.width > 0 &&
 605                         overlap_in_active_timing.height > 0)
 606                 recout_clip_in_recout_dst = shift_rec(&overlap_in_active_timing,
 607                                 -recout_dst_in_active_timing.x,
 608                                 -recout_dst_in_active_timing.y);
 609         else
 610                 memset(&recout_clip_in_recout_dst, 0, sizeof(struct spl_rect));
 611         /*
 612          * Work in recout rotation since that requires less transformations
 613          */
 614         spl_get_vp_scan_direction(
 615                         spl_in->basic_in.rotation,
 616                         spl_in->basic_in.horizontal_mirror,
 617                         &orthogonal_rotation,
 618                         &flip_vert_scan_dir,
 619                         &flip_horz_scan_dir);
 620
 621         if (spl_is_subsampled_format(spl_in->basic_in.format)) {
 622                 /* this gives the direction of the cositing (negative will move
 623                  * left, right otherwise)
 624                  */
 625                 int sign = 1;
 626
 627                 switch (spl_in->basic_in.cositing) {
 628
 629                 case CHROMA_COSITING_TOPLEFT:
 630                         init_adj_h = spl_fixpt_from_fraction(sign, 4);
 631                         init_adj_v = spl_fixpt_from_fraction(sign, 4);
 632                         break;
 633                 case CHROMA_COSITING_LEFT:
 634                         init_adj_h = spl_fixpt_from_fraction(sign, 4);
 635                         init_adj_v = spl_fixpt_zero;
 636                         break;
 637                 case CHROMA_COSITING_NONE:
 638                 default:
 639                         init_adj_h = spl_fixpt_zero;
 640                         init_adj_v = spl_fixpt_zero;
 641                         break;
 642                 }
 643         }
 644
 645         if (orthogonal_rotation) {
 646                 spl_swap(src.width, src.height);
 647                 spl_swap(flip_vert_scan_dir, flip_horz_scan_dir);
 648                 spl_swap(init_adj_h, init_adj_v);
 649         }
 650
 651         spl_calculate_init_and_vp(
 652                         flip_horz_scan_dir,
 653                         recout_clip_in_recout_dst.x,
 654                         spl_scratch->scl_data.recout.width,
 655                         src.width,
 656                         spl_scratch->scl_data.taps.h_taps,
 657                         spl_scratch->scl_data.ratios.horz,
 658                         spl_fixpt_zero,
 659                         &spl_scratch->scl_data.inits.h,
 660                         &spl_scratch->scl_data.viewport.x,
 661                         &spl_scratch->scl_data.viewport.width);
 662         spl_calculate_init_and_vp(
 663                         flip_horz_scan_dir,
 664                         recout_clip_in_recout_dst.x,
 665                         spl_scratch->scl_data.recout.width,
 666                         src.width / vpc_div,
 667                         spl_scratch->scl_data.taps.h_taps_c,
 668                         spl_scratch->scl_data.ratios.horz_c,
 669                         init_adj_h,
 670                         &spl_scratch->scl_data.inits.h_c,
 671                         &spl_scratch->scl_data.viewport_c.x,
 672                         &spl_scratch->scl_data.viewport_c.width);
 673         spl_calculate_init_and_vp(
 674                         flip_vert_scan_dir,
 675                         recout_clip_in_recout_dst.y,
 676                         spl_scratch->scl_data.recout.height,
 677                         src.height,
 678                         spl_scratch->scl_data.taps.v_taps,
 679                         spl_scratch->scl_data.ratios.vert,
 680                         spl_fixpt_zero,
 681                         &spl_scratch->scl_data.inits.v,
 682                         &spl_scratch->scl_data.viewport.y,
 683                         &spl_scratch->scl_data.viewport.height);
 684         spl_calculate_init_and_vp(
 685                         flip_vert_scan_dir,
 686                         recout_clip_in_recout_dst.y,
 687                         spl_scratch->scl_data.recout.height,
 688                         src.height / vpc_div,
 689                         spl_scratch->scl_data.taps.v_taps_c,
 690                         spl_scratch->scl_data.ratios.vert_c,
 691                         init_adj_v,
 692                         &spl_scratch->scl_data.inits.v_c,
 693                         &spl_scratch->scl_data.viewport_c.y,
 694                         &spl_scratch->scl_data.viewport_c.height);
 695         if (orthogonal_rotation) {
 696                 spl_swap(spl_scratch->scl_data.viewport.x, spl_scratch->scl_data.viewport.y);
 697                 spl_swap(spl_scratch->scl_data.viewport.width, spl_scratch->scl_data.viewport.height);
 698                 spl_swap(spl_scratch->scl_data.viewport_c.x, spl_scratch->scl_data.viewport_c.y);
 699                 spl_swap(spl_scratch->scl_data.viewport_c.width, spl_scratch->scl_data.viewport_c.height);
 700         }
 701         spl_scratch->scl_data.viewport.x += src.x;
 702         spl_scratch->scl_data.viewport.y += src.y;
 703         SPL_ASSERT(src.x % vpc_div == 0 && src.y % vpc_div == 0);
 704         spl_scratch->scl_data.viewport_c.x += src.x / vpc_div;
 705         spl_scratch->scl_data.viewport_c.y += src.y / vpc_div;
 706 }
 707
 708 static void spl_handle_3d_recout(struct spl_in *spl_in, struct spl_rect *recout)
 709 {
 710         /*
 711          * Handle side by side and top bottom 3d recout offsets after vp calculation
 712          * since 3d is special and needs to calculate vp as if there is no recout offset
 713          * This may break with rotation, good thing we aren't mixing hw rotation and 3d
 714          */
 715         if (spl_in->basic_in.mpc_h_slice_index) {
 716                 SPL_ASSERT(spl_in->basic_in.rotation == SPL_ROTATION_ANGLE_0 ||
 717                         (spl_in->basic_out.view_format != SPL_VIEW_3D_TOP_AND_BOTTOM &&
 718                                         spl_in->basic_out.view_format != SPL_VIEW_3D_SIDE_BY_SIDE));
 719                 if (spl_in->basic_out.view_format == SPL_VIEW_3D_TOP_AND_BOTTOM)
 720                         recout->y += recout->height;
 721                 else if (spl_in->basic_out.view_format == SPL_VIEW_3D_SIDE_BY_SIDE)
 722                         recout->x += recout->width;
 723         }
 724 }
 725
 726 static void spl_clamp_viewport(struct spl_rect *viewport)
 727 {
 728         /* Clamp minimum viewport size */
 729         if (viewport->height < MIN_VIEWPORT_SIZE)
 730                 viewport->height = MIN_VIEWPORT_SIZE;
 731         if (viewport->width < MIN_VIEWPORT_SIZE)
 732                 viewport->width = MIN_VIEWPORT_SIZE;
 733 }
 734
 735 static enum scl_mode spl_get_dscl_mode(const struct spl_in *spl_in,
 736                                 const struct spl_scaler_data *data,
 737                                 bool enable_isharp, bool enable_easf)
 738 {
 739         const long long one = spl_fixpt_one.value;
 740         enum spl_pixel_format pixel_format = spl_in->basic_in.format;
 741
 742         /* Bypass if ratio is 1:1 with no ISHARP or force scale on */
 743         if (data->ratios.horz.value == one
 744                         && data->ratios.vert.value == one
 745                         && data->ratios.horz_c.value == one
 746                         && data->ratios.vert_c.value == one
 747                         && !spl_in->basic_out.always_scale
 748                         && !enable_isharp)
 749                 return SCL_MODE_SCALING_444_BYPASS;
 750
 751         if (!spl_is_subsampled_format(pixel_format)) {
 752                 if (spl_is_video_format(pixel_format))
 753                         return SCL_MODE_SCALING_444_YCBCR_ENABLE;
 754                 else
 755                         return SCL_MODE_SCALING_444_RGB_ENABLE;
 756         }
 757
 758         /*
 759          * Bypass YUV if Y is 1:1 with no ISHARP
 760          * Do not bypass UV at 1:1 for cositing to be applied
 761          */
 762         if (!enable_isharp) {
 763                 if (data->ratios.horz.value == one && data->ratios.vert.value == one)
 764                         return SCL_MODE_SCALING_420_LUMA_BYPASS;
 765         }
 766
 767         return SCL_MODE_SCALING_420_YCBCR_ENABLE;
 768 }
 769
 770 static bool spl_choose_lls_policy(enum spl_pixel_format format,
 771         enum spl_transfer_func_type tf_type,
 772         enum spl_transfer_func_predefined tf_predefined_type,
 773         enum linear_light_scaling *lls_pref)
 774 {
 775         if (spl_is_video_format(format)) {
 776                 *lls_pref = LLS_PREF_NO;
 777                 if ((tf_type == SPL_TF_TYPE_PREDEFINED) ||
 778                         (tf_type == SPL_TF_TYPE_DISTRIBUTED_POINTS))
 779                         return true;
 780         } else { /* RGB or YUV444 */
 781                 if ((tf_type == SPL_TF_TYPE_PREDEFINED) ||
 782                         (tf_type == SPL_TF_TYPE_BYPASS)) {
 783                         *lls_pref = LLS_PREF_YES;
 784                         return true;
 785                 }
 786         }
 787         *lls_pref = LLS_PREF_NO;
 788         return false;
 789 }
 790
 791 /* Enable EASF ?*/
 792 static bool enable_easf(struct spl_in *spl_in, struct spl_scratch *spl_scratch)
 793 {
 794         int vratio = 0;
 795         int hratio = 0;
 796         bool skip_easf = false;
 797         bool lls_enable_easf = true;
 798
 799         if (spl_in->disable_easf)
 800                 skip_easf = true;
 801
 802         vratio = spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert);
 803         hratio = spl_fixpt_ceil(spl_scratch->scl_data.ratios.horz);
 804
 805         /*
 806          * No EASF support for downscaling > 2:1
 807          * EASF support for upscaling or downscaling up to 2:1
 808          */
 809         if ((vratio > 2) || (hratio > 2))
 810                 skip_easf = true;
 811
 812         /*
 813          * If lls_pref is LLS_PREF_DONT_CARE, then use pixel format and transfer
 814          *  function to determine whether to use LINEAR or NONLINEAR scaling
 815          */
 816         if (spl_in->lls_pref == LLS_PREF_DONT_CARE)
 817                 lls_enable_easf = spl_choose_lls_policy(spl_in->basic_in.format,
 818                         spl_in->basic_in.tf_type, spl_in->basic_in.tf_predefined_type,
 819                         &spl_in->lls_pref);
 820
 821         if (!lls_enable_easf)
 822                 skip_easf = true;
 823
 824         /* Check for linear scaling or EASF preferred */
 825         if (spl_in->lls_pref != LLS_PREF_YES && !spl_in->prefer_easf)
 826                 skip_easf = true;
 827
 828         return skip_easf;
 829 }
 830
 831 /* Check if video is in fullscreen mode */
 832 static bool spl_is_video_fullscreen(struct spl_in *spl_in)
 833 {
 834         if (spl_is_video_format(spl_in->basic_in.format) && spl_in->is_fullscreen)
 835                 return true;
 836         return false;
 837 }
 838
 839 static bool spl_get_isharp_en(struct spl_in *spl_in,
 840         struct spl_scratch *spl_scratch)
 841 {
 842         bool enable_isharp = false;
 843         int vratio = 0;
 844         int hratio = 0;
 845         struct spl_taps taps = spl_scratch->scl_data.taps;
 846         bool fullscreen = spl_is_video_fullscreen(spl_in);
 847
 848         /* Return if adaptive sharpness is disabled */
 849         if (spl_in->adaptive_sharpness.enable == false)
 850                 return enable_isharp;
 851
 852         vratio = spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert);
 853         hratio = spl_fixpt_ceil(spl_scratch->scl_data.ratios.horz);
 854
 855         /* No iSHARP support for downscaling */
 856         if (vratio > 1 || hratio > 1)
 857                 return enable_isharp;
 858
 859         // Scaling is up to 1:1 (no scaling) or upscaling
 860
 861         /*
 862          * Apply sharpness to RGB and YUV (NV12/P010)
 863          *  surfaces based on policy setting
 864          */
 865         if (!spl_is_video_format(spl_in->basic_in.format) &&
 866                 (spl_in->sharpen_policy == SHARPEN_YUV))
 867                 return enable_isharp;
 868         else if ((spl_is_video_format(spl_in->basic_in.format) && !fullscreen) &&
 869                 (spl_in->sharpen_policy == SHARPEN_RGB_FULLSCREEN_YUV))
 870                 return enable_isharp;
 871         else if (!spl_in->is_fullscreen &&
 872                         spl_in->sharpen_policy == SHARPEN_FULLSCREEN_ALL)
 873                 return enable_isharp;
 874
 875         /*
 876          * Apply sharpness if supports horizontal taps 4,6 AND
 877          *  vertical taps 3, 4, 6
 878          */
 879         if ((taps.h_taps == 4 || taps.h_taps == 6) &&
 880                 (taps.v_taps == 3 || taps.v_taps == 4 || taps.v_taps == 6))
 881                 enable_isharp = true;
 882
 883         return enable_isharp;
 884 }
 885
 886 /* Calculate number of tap with adaptive scaling off */
 887 static void spl_get_taps_non_adaptive_scaler(
 888           struct spl_scratch *spl_scratch, const struct spl_taps *in_taps)
 889 {
 890         if (in_taps->h_taps == 0) {
 891                 if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.horz) > 1)
 892                         spl_scratch->scl_data.taps.h_taps = spl_min(2 * spl_fixpt_ceil(
 893                                 spl_scratch->scl_data.ratios.horz), 8);
 894                 else
 895                         spl_scratch->scl_data.taps.h_taps = 4;
 896         } else
 897                 spl_scratch->scl_data.taps.h_taps = in_taps->h_taps;
 898
 899         if (in_taps->v_taps == 0) {
 900                 if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert) > 1)
 901                         spl_scratch->scl_data.taps.v_taps = spl_min(2 * spl_fixpt_ceil(
 902                                 spl_scratch->scl_data.ratios.vert), 8);
 903                 else
 904                         spl_scratch->scl_data.taps.v_taps = 4;
 905         } else
 906                 spl_scratch->scl_data.taps.v_taps = in_taps->v_taps;
 907
 908         if (in_taps->v_taps_c == 0) {
 909                 if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert_c) > 1)
 910                         spl_scratch->scl_data.taps.v_taps_c = spl_min(2 * spl_fixpt_ceil(
 911                                 spl_scratch->scl_data.ratios.vert_c), 8);
 912                 else
 913                         spl_scratch->scl_data.taps.v_taps_c = 4;
 914         } else
 915                 spl_scratch->scl_data.taps.v_taps_c = in_taps->v_taps_c;
 916
 917         if (in_taps->h_taps_c == 0) {
 918                 if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.horz_c) > 1)
 919                         spl_scratch->scl_data.taps.h_taps_c = spl_min(2 * spl_fixpt_ceil(
 920                                 spl_scratch->scl_data.ratios.horz_c), 8);
 921                 else
 922                         spl_scratch->scl_data.taps.h_taps_c = 4;
 923         } else if ((in_taps->h_taps_c % 2) != 0 && in_taps->h_taps_c != 1)
 924                 /* Only 1 and even h_taps_c are supported by hw */
 925                 spl_scratch->scl_data.taps.h_taps_c = in_taps->h_taps_c - 1;
 926         else
 927                 spl_scratch->scl_data.taps.h_taps_c = in_taps->h_taps_c;
 928
 929         if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz))
 930                 spl_scratch->scl_data.taps.h_taps = 1;
 931         if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert))
 932                 spl_scratch->scl_data.taps.v_taps = 1;
 933         if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz_c))
 934                 spl_scratch->scl_data.taps.h_taps_c = 1;
 935         if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert_c))
 936                 spl_scratch->scl_data.taps.v_taps_c = 1;
 937
 938 }
 939
 940 /* Calculate optimal number of taps */
 941 static bool spl_get_optimal_number_of_taps(
 942           int max_downscale_src_width, struct spl_in *spl_in, struct spl_scratch *spl_scratch,
 943           const struct spl_taps *in_taps, bool *enable_easf_v, bool *enable_easf_h,
 944           bool *enable_isharp)
 945 {
 946         int num_part_y, num_part_c;
 947         int max_taps_y, max_taps_c;
 948         int min_taps_y, min_taps_c;
 949         enum lb_memory_config lb_config;
 950         bool skip_easf = false;
 951         bool is_subsampled = spl_is_subsampled_format(spl_in->basic_in.format);
 952
 953         if (spl_scratch->scl_data.viewport.width > spl_scratch->scl_data.h_active &&
 954                 max_downscale_src_width != 0 &&
 955                 spl_scratch->scl_data.viewport.width > max_downscale_src_width) {
 956                 spl_get_taps_non_adaptive_scaler(spl_scratch, in_taps);
 957                 *enable_easf_v = false;
 958                 *enable_easf_h = false;
 959                 *enable_isharp = false;
 960                 return false;
 961         }
 962
 963         /* Disable adaptive scaler and sharpener when integer scaling is enabled */
 964         if (spl_in->scaling_quality.integer_scaling) {
 965                 spl_get_taps_non_adaptive_scaler(spl_scratch, in_taps);
 966                 *enable_easf_v = false;
 967                 *enable_easf_h = false;
 968                 *enable_isharp = false;
 969                 return true;
 970         }
 971
 972         /* Check if we are using EASF or not */
 973         skip_easf = enable_easf(spl_in, spl_scratch);
 974
 975         /*
 976          * Set default taps if none are provided
 977          * From programming guide: taps = min{ ceil(2*H_RATIO,1), 8} for downscaling
 978          * taps = 4 for upscaling
 979          */
 980         if (skip_easf)
 981                 spl_get_taps_non_adaptive_scaler(spl_scratch, in_taps);
 982         else {
 983                 if (spl_is_video_format(spl_in->basic_in.format)) {
 984                         spl_scratch->scl_data.taps.h_taps = 6;
 985                         spl_scratch->scl_data.taps.v_taps = 6;
 986                         spl_scratch->scl_data.taps.h_taps_c = 4;
 987                         spl_scratch->scl_data.taps.v_taps_c = 4;
 988                 } else { /* RGB */
 989                         spl_scratch->scl_data.taps.h_taps = 6;
 990                         spl_scratch->scl_data.taps.v_taps = 6;
 991                         spl_scratch->scl_data.taps.h_taps_c = 6;
 992                         spl_scratch->scl_data.taps.v_taps_c = 6;
 993                 }
 994         }
 995
 996         /*Ensure we can support the requested number of vtaps*/
 997         min_taps_y = spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert);
 998         min_taps_c = spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert_c);
 999
1000         /* Use LB_MEMORY_CONFIG_3 for 4:2:0 */
1001         if (spl_is_yuv420(spl_in->basic_in.format))
1002                 lb_config = LB_MEMORY_CONFIG_3;
1003         else
1004                 lb_config = LB_MEMORY_CONFIG_0;
1005         // Determine max vtap support by calculating how much line buffer can fit
1006         spl_in->callbacks.spl_calc_lb_num_partitions(spl_in->basic_out.alpha_en, &spl_scratch->scl_data,
1007                         lb_config, &num_part_y, &num_part_c);
1008         /* MAX_V_TAPS = MIN (NUM_LINES - MAX(CEILING(V_RATIO,1)-2, 0), 8) */
1009         if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert) > 2)
1010                 max_taps_y = num_part_y - (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert) - 2);
1011         else
1012                 max_taps_y = num_part_y;
1013
1014         if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert_c) > 2)
1015                 max_taps_c = num_part_c - (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert_c) - 2);
1016         else
1017                 max_taps_c = num_part_c;
1018
1019         if (max_taps_y < min_taps_y)
1020                 return false;
1021         else if (max_taps_c < min_taps_c)
1022                 return false;
1023
1024         if (spl_scratch->scl_data.taps.v_taps > max_taps_y)
1025                 spl_scratch->scl_data.taps.v_taps = max_taps_y;
1026
1027         if (spl_scratch->scl_data.taps.v_taps_c > max_taps_c)
1028                 spl_scratch->scl_data.taps.v_taps_c = max_taps_c;
1029
1030         if (!skip_easf) {
1031                 /*
1032                  * RGB ( L + NL ) and Linear HDR support 6x6, 6x4, 6x3, 4x4, 4x3
1033                  * NL YUV420 only supports 6x6, 6x4 for Y and 4x4 for UV
1034                  *
1035                  * If LB does not support 3, 4, or 6 taps, then disable EASF_V
1036                  *  and only enable EASF_H.  So for RGB, support 6x2, 4x2
1037                  *  and for NL YUV420, support 6x2 for Y and 4x2 for UV
1038                  *
1039                  * All other cases, have to disable EASF_V and EASF_H
1040                  *
1041                  * If optimal no of taps is 5, then set it to 4
1042                  * If optimal no of taps is 7 or 8, then fine since max tap is 6
1043                  *
1044                  */
1045                 if (spl_scratch->scl_data.taps.v_taps == 5)
1046                         spl_scratch->scl_data.taps.v_taps = 4;
1047
1048                 if (spl_scratch->scl_data.taps.v_taps_c == 5)
1049                         spl_scratch->scl_data.taps.v_taps_c = 4;
1050
1051                 if (spl_scratch->scl_data.taps.h_taps == 5)
1052                         spl_scratch->scl_data.taps.h_taps = 4;
1053
1054                 if (spl_scratch->scl_data.taps.h_taps_c == 5)
1055                         spl_scratch->scl_data.taps.h_taps_c = 4;
1056
1057                 if (spl_is_video_format(spl_in->basic_in.format)) {
1058                         if (spl_scratch->scl_data.taps.h_taps <= 4) {
1059                                 *enable_easf_v = false;
1060                                 *enable_easf_h = false;
1061                         } else if (spl_scratch->scl_data.taps.v_taps <= 3) {
1062                                 *enable_easf_v = false;
1063                                 *enable_easf_h = true;
1064                         } else {
1065                                 *enable_easf_v = true;
1066                                 *enable_easf_h = true;
1067                         }
1068                         SPL_ASSERT((spl_scratch->scl_data.taps.v_taps > 1) &&
1069                                 (spl_scratch->scl_data.taps.v_taps_c > 1));
1070                 } else { /* RGB */
1071                         if (spl_scratch->scl_data.taps.h_taps <= 3) {
1072                                 *enable_easf_v = false;
1073                                 *enable_easf_h = false;
1074                         } else if (spl_scratch->scl_data.taps.v_taps < 3) {
1075                                 *enable_easf_v = false;
1076                                 *enable_easf_h = true;
1077                         } else {
1078                                 *enable_easf_v = true;
1079                                 *enable_easf_h = true;
1080                         }
1081                         SPL_ASSERT(spl_scratch->scl_data.taps.v_taps > 1);
1082                 }
1083         } else {
1084                 *enable_easf_v = false;
1085                 *enable_easf_h = false;
1086         } // end of if prefer_easf
1087
1088         /* Sharpener requires scaler to be enabled, including for 1:1
1089          * Check if ISHARP can be enabled
1090          * If ISHARP is not enabled, set taps to 1 if ratio is 1:1
1091          *  except for chroma taps.  Keep previous taps so it can
1092          *  handle cositing
1093          */
1094
1095         *enable_isharp = spl_get_isharp_en(spl_in, spl_scratch);
1096         if (!*enable_isharp && !spl_in->basic_out.always_scale) {
1097                 if ((IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz)) &&
1098                         (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert))) {
1099                         spl_scratch->scl_data.taps.h_taps = 1;
1100                         spl_scratch->scl_data.taps.v_taps = 1;
1101
1102                         if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz_c) && !is_subsampled)
1103                                 spl_scratch->scl_data.taps.h_taps_c = 1;
1104
1105                         if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert_c) && !is_subsampled)
1106                                 spl_scratch->scl_data.taps.v_taps_c = 1;
1107
1108                         *enable_easf_v = false;
1109                         *enable_easf_h = false;
1110                 } else {
1111                         if ((!*enable_easf_h) &&
1112                                 (IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz)))
1113                                 spl_scratch->scl_data.taps.h_taps = 1;
1114
1115                         if ((!*enable_easf_v) &&
1116                                 (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert)))
1117                                 spl_scratch->scl_data.taps.v_taps = 1;
1118
1119                         if ((!*enable_easf_h) && !is_subsampled &&
1120                                 (IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz_c)))
1121                                 spl_scratch->scl_data.taps.h_taps_c = 1;
1122
1123                         if ((!*enable_easf_v) && !is_subsampled &&
1124                                 (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert_c)))
1125                                 spl_scratch->scl_data.taps.v_taps_c = 1;
1126                 }
1127         }
1128         return true;
1129 }
1130
1131 static void spl_set_black_color_data(enum spl_pixel_format format,
1132                         struct scl_black_color *scl_black_color)
1133 {
1134         bool ycbcr = spl_is_video_format(format);
1135         if (ycbcr)      {
1136                 scl_black_color->offset_rgb_y = BLACK_OFFSET_RGB_Y;
1137                 scl_black_color->offset_rgb_cbcr = BLACK_OFFSET_CBCR;
1138         }       else {
1139                 scl_black_color->offset_rgb_y = 0x0;
1140                 scl_black_color->offset_rgb_cbcr = 0x0;
1141         }
1142 }
1143
1144 static void spl_set_manual_ratio_init_data(struct dscl_prog_data *dscl_prog_data,
1145                 const struct spl_scaler_data *scl_data)
1146 {
1147         struct spl_fixed31_32 bot;
1148
1149         dscl_prog_data->ratios.h_scale_ratio = spl_fixpt_u3d19(scl_data->ratios.horz) << 5;
1150         dscl_prog_data->ratios.v_scale_ratio = spl_fixpt_u3d19(scl_data->ratios.vert) << 5;
1151         dscl_prog_data->ratios.h_scale_ratio_c = spl_fixpt_u3d19(scl_data->ratios.horz_c) << 5;
1152         dscl_prog_data->ratios.v_scale_ratio_c = spl_fixpt_u3d19(scl_data->ratios.vert_c) << 5;
1153         /*
1154          * 0.24 format for fraction, first five bits zeroed
1155          */
1156         dscl_prog_data->init.h_filter_init_frac =
1157                         spl_fixpt_u0d19(scl_data->inits.h) << 5;
1158         dscl_prog_data->init.h_filter_init_int =
1159                         spl_fixpt_floor(scl_data->inits.h);
1160         dscl_prog_data->init.h_filter_init_frac_c =
1161                         spl_fixpt_u0d19(scl_data->inits.h_c) << 5;
1162         dscl_prog_data->init.h_filter_init_int_c =
1163                         spl_fixpt_floor(scl_data->inits.h_c);
1164         dscl_prog_data->init.v_filter_init_frac =
1165                         spl_fixpt_u0d19(scl_data->inits.v) << 5;
1166         dscl_prog_data->init.v_filter_init_int =
1167                         spl_fixpt_floor(scl_data->inits.v);
1168         dscl_prog_data->init.v_filter_init_frac_c =
1169                         spl_fixpt_u0d19(scl_data->inits.v_c) << 5;
1170         dscl_prog_data->init.v_filter_init_int_c =
1171                         spl_fixpt_floor(scl_data->inits.v_c);
1172
1173         bot = spl_fixpt_add(scl_data->inits.v, scl_data->ratios.vert);
1174         dscl_prog_data->init.v_filter_init_bot_frac = spl_fixpt_u0d19(bot) << 5;
1175         dscl_prog_data->init.v_filter_init_bot_int = spl_fixpt_floor(bot);
1176         bot = spl_fixpt_add(scl_data->inits.v_c, scl_data->ratios.vert_c);
1177         dscl_prog_data->init.v_filter_init_bot_frac_c = spl_fixpt_u0d19(bot) << 5;
1178         dscl_prog_data->init.v_filter_init_bot_int_c = spl_fixpt_floor(bot);
1179 }
1180
1181 static void spl_set_taps_data(struct dscl_prog_data *dscl_prog_data,
1182                 const struct spl_scaler_data *scl_data)
1183 {
1184         dscl_prog_data->taps.v_taps = scl_data->taps.v_taps - 1;
1185         dscl_prog_data->taps.h_taps = scl_data->taps.h_taps - 1;
1186         dscl_prog_data->taps.v_taps_c = scl_data->taps.v_taps_c - 1;
1187         dscl_prog_data->taps.h_taps_c = scl_data->taps.h_taps_c - 1;
1188 }
1189
1190 /* Populate dscl prog data structure from scaler data calculated by SPL */
1191 static void spl_set_dscl_prog_data(struct spl_in *spl_in, struct spl_scratch *spl_scratch,
1192         struct spl_out *spl_out, bool enable_easf_v, bool enable_easf_h, bool enable_isharp)
1193 {
1194         struct dscl_prog_data *dscl_prog_data = spl_out->dscl_prog_data;
1195
1196         const struct spl_scaler_data *data = &spl_scratch->scl_data;
1197
1198         struct scl_black_color *scl_black_color = &dscl_prog_data->scl_black_color;
1199
1200         bool enable_easf = enable_easf_v || enable_easf_h;
1201
1202         // Set values for recout
1203         dscl_prog_data->recout = spl_scratch->scl_data.recout;
1204         // Set values for MPC Size
1205         dscl_prog_data->mpc_size.width = spl_scratch->scl_data.h_active;
1206         dscl_prog_data->mpc_size.height = spl_scratch->scl_data.v_active;
1207
1208         // SCL_MODE - Set SCL_MODE data
1209         dscl_prog_data->dscl_mode = spl_get_dscl_mode(spl_in, data, enable_isharp,
1210                 enable_easf);
1211
1212         // SCL_BLACK_COLOR
1213         spl_set_black_color_data(spl_in->basic_in.format, scl_black_color);
1214
1215         /* Manually calculate scale ratio and init values */
1216         spl_set_manual_ratio_init_data(dscl_prog_data, data);
1217
1218         // Set HTaps/VTaps
1219         spl_set_taps_data(dscl_prog_data, data);
1220         // Set viewport
1221         dscl_prog_data->viewport = spl_scratch->scl_data.viewport;
1222         // Set viewport_c
1223         dscl_prog_data->viewport_c = spl_scratch->scl_data.viewport_c;
1224         // Set filters data
1225         spl_set_filters_data(dscl_prog_data, data, enable_easf_v, enable_easf_h);
1226 }
1227
1228 /* Calculate C0-C3 coefficients based on HDR_mult */
1229 static void spl_calculate_c0_c3_hdr(struct dscl_prog_data *dscl_prog_data, uint32_t sdr_white_level_nits)
1230 {
1231         struct spl_fixed31_32 hdr_mult, c0_mult, c1_mult, c2_mult;
1232         struct spl_fixed31_32 c0_calc, c1_calc, c2_calc;
1233         struct spl_custom_float_format fmt;
1234         uint32_t hdr_multx100_int;
1235
1236         if ((sdr_white_level_nits >= 80) && (sdr_white_level_nits <= 480))
1237                 hdr_multx100_int = sdr_white_level_nits * 100 / 80;
1238         else
1239                 hdr_multx100_int = 100; /* default for 80 nits otherwise */
1240
1241         hdr_mult = spl_fixpt_from_fraction((long long)hdr_multx100_int, 100LL);
1242         c0_mult = spl_fixpt_from_fraction(2126LL, 10000LL);
1243         c1_mult = spl_fixpt_from_fraction(7152LL, 10000LL);
1244         c2_mult = spl_fixpt_from_fraction(722LL, 10000LL);
1245
1246         c0_calc = spl_fixpt_mul(hdr_mult, spl_fixpt_mul(c0_mult, spl_fixpt_from_fraction(
1247                 16384LL, 125LL)));
1248         c1_calc = spl_fixpt_mul(hdr_mult, spl_fixpt_mul(c1_mult, spl_fixpt_from_fraction(
1249                 16384LL, 125LL)));
1250         c2_calc = spl_fixpt_mul(hdr_mult, spl_fixpt_mul(c2_mult, spl_fixpt_from_fraction(
1251                 16384LL, 125LL)));
1252
1253         fmt.exponenta_bits = 5;
1254         fmt.mantissa_bits = 10;
1255         fmt.sign = true;
1256
1257         // fp1.5.10, C0 coefficient (LN_rec709:  HDR_MULT * 0.212600 * 2^14/125)
1258         spl_convert_to_custom_float_format(c0_calc, &fmt, &dscl_prog_data->easf_matrix_c0);
1259         // fp1.5.10, C1 coefficient (LN_rec709:  HDR_MULT * 0.715200 * 2^14/125)
1260         spl_convert_to_custom_float_format(c1_calc, &fmt, &dscl_prog_data->easf_matrix_c1);
1261         // fp1.5.10, C2 coefficient (LN_rec709:  HDR_MULT * 0.072200 * 2^14/125)
1262         spl_convert_to_custom_float_format(c2_calc, &fmt, &dscl_prog_data->easf_matrix_c2);
1263         dscl_prog_data->easf_matrix_c3 = 0x0; // fp1.5.10, C3 coefficient
1264 }
1265
1266 /* Set EASF data */
1267 static void spl_set_easf_data(struct spl_scratch *spl_scratch, struct spl_out *spl_out, bool enable_easf_v,
1268         bool enable_easf_h, enum linear_light_scaling lls_pref,
1269         enum spl_pixel_format format, enum system_setup setup,
1270         uint32_t sdr_white_level_nits)
1271 {
1272         struct dscl_prog_data *dscl_prog_data = spl_out->dscl_prog_data;
1273         if (enable_easf_v) {
1274                 dscl_prog_data->easf_v_en = true;
1275                 dscl_prog_data->easf_v_ring = 0;
1276                 dscl_prog_data->easf_v_sharp_factor = 0;
1277                 dscl_prog_data->easf_v_bf1_en = 1;      // 1-bit, BF1 calculation enable, 0=disable, 1=enable
1278                 dscl_prog_data->easf_v_bf2_mode = 0xF;  // 4-bit, BF2 calculation mode
1279                 /* 2-bit, BF3 chroma mode correction calculation mode */
1280                 dscl_prog_data->easf_v_bf3_mode = spl_get_v_bf3_mode(
1281                         spl_scratch->scl_data.recip_ratios.vert);
1282                 /* FP1.5.10 [ minCoef ]*/
1283                 dscl_prog_data->easf_v_ringest_3tap_dntilt_uptilt =
1284                         spl_get_3tap_dntilt_uptilt_offset(spl_scratch->scl_data.taps.v_taps,
1285                                 spl_scratch->scl_data.recip_ratios.vert);
1286                 /* FP1.5.10 [ upTiltMaxVal ]*/
1287                 dscl_prog_data->easf_v_ringest_3tap_uptilt_max =
1288                         spl_get_3tap_uptilt_maxval(spl_scratch->scl_data.taps.v_taps,
1289                                 spl_scratch->scl_data.recip_ratios.vert);
1290                 /* FP1.5.10 [ dnTiltSlope ]*/
1291                 dscl_prog_data->easf_v_ringest_3tap_dntilt_slope =
1292                         spl_get_3tap_dntilt_slope(spl_scratch->scl_data.taps.v_taps,
1293                                 spl_scratch->scl_data.recip_ratios.vert);
1294                 /* FP1.5.10 [ upTilt1Slope ]*/
1295                 dscl_prog_data->easf_v_ringest_3tap_uptilt1_slope =
1296                         spl_get_3tap_uptilt1_slope(spl_scratch->scl_data.taps.v_taps,
1297                                 spl_scratch->scl_data.recip_ratios.vert);
1298                 /* FP1.5.10 [ upTilt2Slope ]*/
1299                 dscl_prog_data->easf_v_ringest_3tap_uptilt2_slope =
1300                         spl_get_3tap_uptilt2_slope(spl_scratch->scl_data.taps.v_taps,
1301                                 spl_scratch->scl_data.recip_ratios.vert);
1302                 /* FP1.5.10 [ upTilt2Offset ]*/
1303                 dscl_prog_data->easf_v_ringest_3tap_uptilt2_offset =
1304                         spl_get_3tap_uptilt2_offset(spl_scratch->scl_data.taps.v_taps,
1305                                 spl_scratch->scl_data.recip_ratios.vert);
1306                 /* FP1.5.10; (2.0) Ring reducer gain for 4 or 6-tap mode [H_REDUCER_GAIN4] */
1307                 dscl_prog_data->easf_v_ringest_eventap_reduceg1 =
1308                         spl_get_reducer_gain4(spl_scratch->scl_data.taps.v_taps,
1309                                 spl_scratch->scl_data.recip_ratios.vert);
1310                 /* FP1.5.10; (2.5) Ring reducer gain for 6-tap mode [V_REDUCER_GAIN6] */
1311                 dscl_prog_data->easf_v_ringest_eventap_reduceg2 =
1312                         spl_get_reducer_gain6(spl_scratch->scl_data.taps.v_taps,
1313                                 spl_scratch->scl_data.recip_ratios.vert);
1314                 /* FP1.5.10; (-0.135742) Ring gain for 6-tap set to -139/1024 */
1315                 dscl_prog_data->easf_v_ringest_eventap_gain1 =
1316                         spl_get_gainRing4(spl_scratch->scl_data.taps.v_taps,
1317                                 spl_scratch->scl_data.recip_ratios.vert);
1318                 /* FP1.5.10; (-0.024414) Ring gain for 6-tap set to -25/1024 */
1319                 dscl_prog_data->easf_v_ringest_eventap_gain2 =
1320                         spl_get_gainRing6(spl_scratch->scl_data.taps.v_taps,
1321                                 spl_scratch->scl_data.recip_ratios.vert);
1322                 dscl_prog_data->easf_v_bf_maxa = 63; //Vertical Max BF value A in U0.6 format.Selected if V_FCNTL == 0
1323                 dscl_prog_data->easf_v_bf_maxb = 63; //Vertical Max BF value A in U0.6 format.Selected if V_FCNTL == 1
1324                 dscl_prog_data->easf_v_bf_mina = 0;     //Vertical Min BF value A in U0.6 format.Selected if V_FCNTL == 0
1325                 dscl_prog_data->easf_v_bf_minb = 0;     //Vertical Min BF value A in U0.6 format.Selected if V_FCNTL == 1
1326                 if (lls_pref == LLS_PREF_YES)   {
1327                         dscl_prog_data->easf_v_bf2_flat1_gain = 4;      // U1.3, BF2 Flat1 Gain control
1328                         dscl_prog_data->easf_v_bf2_flat2_gain = 8;      // U4.0, BF2 Flat2 Gain control
1329                         dscl_prog_data->easf_v_bf2_roc_gain = 4;        // U2.2, Rate Of Change control
1330
1331                         dscl_prog_data->easf_v_bf1_pwl_in_seg0 = 0x600; // S0.10, BF1 PWL Segment 0 = -512
1332                         dscl_prog_data->easf_v_bf1_pwl_base_seg0 = 0;   // U0.6, BF1 Base PWL Segment 0
1333                         dscl_prog_data->easf_v_bf1_pwl_slope_seg0 = 3;  // S7.3, BF1 Slope PWL Segment 0
1334                         dscl_prog_data->easf_v_bf1_pwl_in_seg1 = 0x7EC; // S0.10, BF1 PWL Segment 1 = -20
1335                         dscl_prog_data->easf_v_bf1_pwl_base_seg1 = 12;  // U0.6, BF1 Base PWL Segment 1
1336                         dscl_prog_data->easf_v_bf1_pwl_slope_seg1 = 326;        // S7.3, BF1 Slope PWL Segment 1
1337                         dscl_prog_data->easf_v_bf1_pwl_in_seg2 = 0;     // S0.10, BF1 PWL Segment 2
1338                         dscl_prog_data->easf_v_bf1_pwl_base_seg2 = 63;  // U0.6, BF1 Base PWL Segment 2
1339                         dscl_prog_data->easf_v_bf1_pwl_slope_seg2 = 0;  // S7.3, BF1 Slope PWL Segment 2
1340                         dscl_prog_data->easf_v_bf1_pwl_in_seg3 = 16;    // S0.10, BF1 PWL Segment 3
1341                         dscl_prog_data->easf_v_bf1_pwl_base_seg3 = 63;  // U0.6, BF1 Base PWL Segment 3
1342                         dscl_prog_data->easf_v_bf1_pwl_slope_seg3 = 0x7C8;      // S7.3, BF1 Slope PWL Segment 3 = -56
1343                         dscl_prog_data->easf_v_bf1_pwl_in_seg4 = 32;    // S0.10, BF1 PWL Segment 4
1344                         dscl_prog_data->easf_v_bf1_pwl_base_seg4 = 56;  // U0.6, BF1 Base PWL Segment 4
1345                         dscl_prog_data->easf_v_bf1_pwl_slope_seg4 = 0x7D0;      // S7.3, BF1 Slope PWL Segment 4 = -48
1346                         dscl_prog_data->easf_v_bf1_pwl_in_seg5 = 48;    // S0.10, BF1 PWL Segment 5
1347                         dscl_prog_data->easf_v_bf1_pwl_base_seg5 = 50;  // U0.6, BF1 Base PWL Segment 5
1348                         dscl_prog_data->easf_v_bf1_pwl_slope_seg5 = 0x710;      // S7.3, BF1 Slope PWL Segment 5 = -240
1349                         dscl_prog_data->easf_v_bf1_pwl_in_seg6 = 64;    // S0.10, BF1 PWL Segment 6
1350                         dscl_prog_data->easf_v_bf1_pwl_base_seg6 = 20;  // U0.6, BF1 Base PWL Segment 6
1351                         dscl_prog_data->easf_v_bf1_pwl_slope_seg6 = 0x760;      // S7.3, BF1 Slope PWL Segment 6 = -160
1352                         dscl_prog_data->easf_v_bf1_pwl_in_seg7 = 80;    // S0.10, BF1 PWL Segment 7
1353                         dscl_prog_data->easf_v_bf1_pwl_base_seg7 = 0;   // U0.6, BF1 Base PWL Segment 7
1354
1355                         dscl_prog_data->easf_v_bf3_pwl_in_set0 = 0x000; // FP0.6.6, BF3 Input value PWL Segment 0
1356                         dscl_prog_data->easf_v_bf3_pwl_base_set0 = 63;  // S0.6, BF3 Base PWL Segment 0
1357                         dscl_prog_data->easf_v_bf3_pwl_slope_set0 = 0x12C5;     // FP1.6.6, BF3 Slope PWL Segment 0
1358                         dscl_prog_data->easf_v_bf3_pwl_in_set1 =
1359                                 0x0B37; // FP0.6.6, BF3 Input value PWL Segment 1 (0.0078125 * 125^3)
1360                         dscl_prog_data->easf_v_bf3_pwl_base_set1 = 62;  // S0.6, BF3 Base PWL Segment 1
1361                         dscl_prog_data->easf_v_bf3_pwl_slope_set1 =
1362                                 0x13B8; // FP1.6.6, BF3 Slope PWL Segment 1
1363                         dscl_prog_data->easf_v_bf3_pwl_in_set2 =
1364                                 0x0BB7; // FP0.6.6, BF3 Input value PWL Segment 2 (0.03125 * 125^3)
1365                         dscl_prog_data->easf_v_bf3_pwl_base_set2 = 20;  // S0.6, BF3 Base PWL Segment 2
1366                         dscl_prog_data->easf_v_bf3_pwl_slope_set2 =
1367                                 0x1356; // FP1.6.6, BF3 Slope PWL Segment 2
1368                         dscl_prog_data->easf_v_bf3_pwl_in_set3 =
1369                                 0x0BF7; // FP0.6.6, BF3 Input value PWL Segment 3 (0.0625 * 125^3)
1370                         dscl_prog_data->easf_v_bf3_pwl_base_set3 = 0;   // S0.6, BF3 Base PWL Segment 3
1371                         dscl_prog_data->easf_v_bf3_pwl_slope_set3 =
1372                                 0x136B; // FP1.6.6, BF3 Slope PWL Segment 3
1373                         dscl_prog_data->easf_v_bf3_pwl_in_set4 =
1374                                 0x0C37; // FP0.6.6, BF3 Input value PWL Segment 4 (0.125 * 125^3)
1375                         dscl_prog_data->easf_v_bf3_pwl_base_set4 = 0x4E;        // S0.6, BF3 Base PWL Segment 4 = -50
1376                         dscl_prog_data->easf_v_bf3_pwl_slope_set4 =
1377                                 0x1200; // FP1.6.6, BF3 Slope PWL Segment 4
1378                         dscl_prog_data->easf_v_bf3_pwl_in_set5 =
1379                                 0x0CF7; // FP0.6.6, BF3 Input value PWL Segment 5 (1.0 * 125^3)
1380                         dscl_prog_data->easf_v_bf3_pwl_base_set5 = 0x41;        // S0.6, BF3 Base PWL Segment 5 = -63
1381                 }       else    {
1382                         dscl_prog_data->easf_v_bf2_flat1_gain = 13;     // U1.3, BF2 Flat1 Gain control
1383                         dscl_prog_data->easf_v_bf2_flat2_gain = 15;     // U4.0, BF2 Flat2 Gain control
1384                         dscl_prog_data->easf_v_bf2_roc_gain = 14;       // U2.2, Rate Of Change control
1385
1386                         dscl_prog_data->easf_v_bf1_pwl_in_seg0 = 0x440; // S0.10, BF1 PWL Segment 0 = -960
1387                         dscl_prog_data->easf_v_bf1_pwl_base_seg0 = 0;   // U0.6, BF1 Base PWL Segment 0
1388                         dscl_prog_data->easf_v_bf1_pwl_slope_seg0 = 2;  // S7.3, BF1 Slope PWL Segment 0
1389                         dscl_prog_data->easf_v_bf1_pwl_in_seg1 = 0x7C4; // S0.10, BF1 PWL Segment 1 = -60
1390                         dscl_prog_data->easf_v_bf1_pwl_base_seg1 = 12;  // U0.6, BF1 Base PWL Segment 1
1391                         dscl_prog_data->easf_v_bf1_pwl_slope_seg1 = 109;        // S7.3, BF1 Slope PWL Segment 1
1392                         dscl_prog_data->easf_v_bf1_pwl_in_seg2 = 0;     // S0.10, BF1 PWL Segment 2
1393                         dscl_prog_data->easf_v_bf1_pwl_base_seg2 = 63;  // U0.6, BF1 Base PWL Segment 2
1394                         dscl_prog_data->easf_v_bf1_pwl_slope_seg2 = 0;  // S7.3, BF1 Slope PWL Segment 2
1395                         dscl_prog_data->easf_v_bf1_pwl_in_seg3 = 48;    // S0.10, BF1 PWL Segment 3
1396                         dscl_prog_data->easf_v_bf1_pwl_base_seg3 = 63;  // U0.6, BF1 Base PWL Segment 3
1397                         dscl_prog_data->easf_v_bf1_pwl_slope_seg3 = 0x7ED;      // S7.3, BF1 Slope PWL Segment 3 = -19
1398                         dscl_prog_data->easf_v_bf1_pwl_in_seg4 = 96;    // S0.10, BF1 PWL Segment 4
1399                         dscl_prog_data->easf_v_bf1_pwl_base_seg4 = 56;  // U0.6, BF1 Base PWL Segment 4
1400                         dscl_prog_data->easf_v_bf1_pwl_slope_seg4 = 0x7F0;      // S7.3, BF1 Slope PWL Segment 4 = -16
1401                         dscl_prog_data->easf_v_bf1_pwl_in_seg5 = 144;   // S0.10, BF1 PWL Segment 5
1402                         dscl_prog_data->easf_v_bf1_pwl_base_seg5 = 50;  // U0.6, BF1 Base PWL Segment 5
1403                         dscl_prog_data->easf_v_bf1_pwl_slope_seg5 = 0x7B0;      // S7.3, BF1 Slope PWL Segment 5 = -80
1404                         dscl_prog_data->easf_v_bf1_pwl_in_seg6 = 192;   // S0.10, BF1 PWL Segment 6
1405                         dscl_prog_data->easf_v_bf1_pwl_base_seg6 = 20;  // U0.6, BF1 Base PWL Segment 6
1406                         dscl_prog_data->easf_v_bf1_pwl_slope_seg6 = 0x7CB;      // S7.3, BF1 Slope PWL Segment 6 = -53
1407                         dscl_prog_data->easf_v_bf1_pwl_in_seg7 = 240;   // S0.10, BF1 PWL Segment 7
1408                         dscl_prog_data->easf_v_bf1_pwl_base_seg7 = 0;   // U0.6, BF1 Base PWL Segment 7
1409
1410                         dscl_prog_data->easf_v_bf3_pwl_in_set0 = 0x000; // FP0.6.6, BF3 Input value PWL Segment 0
1411                         dscl_prog_data->easf_v_bf3_pwl_base_set0 = 63;  // S0.6, BF3 Base PWL Segment 0
1412                         dscl_prog_data->easf_v_bf3_pwl_slope_set0 = 0x0000;     // FP1.6.6, BF3 Slope PWL Segment 0
1413                         dscl_prog_data->easf_v_bf3_pwl_in_set1 =
1414                                 0x06C0; // FP0.6.6, BF3 Input value PWL Segment 1 (0.0625)
1415                         dscl_prog_data->easf_v_bf3_pwl_base_set1 = 63;  // S0.6, BF3 Base PWL Segment 1
1416                         dscl_prog_data->easf_v_bf3_pwl_slope_set1 = 0x1896;     // FP1.6.6, BF3 Slope PWL Segment 1
1417                         dscl_prog_data->easf_v_bf3_pwl_in_set2 =
1418                                 0x0700; // FP0.6.6, BF3 Input value PWL Segment 2 (0.125)
1419                         dscl_prog_data->easf_v_bf3_pwl_base_set2 = 20;  // S0.6, BF3 Base PWL Segment 2
1420                         dscl_prog_data->easf_v_bf3_pwl_slope_set2 = 0x1810;     // FP1.6.6, BF3 Slope PWL Segment 2
1421                         dscl_prog_data->easf_v_bf3_pwl_in_set3 =
1422                                 0x0740; // FP0.6.6, BF3 Input value PWL Segment 3 (0.25)
1423                         dscl_prog_data->easf_v_bf3_pwl_base_set3 = 0;   // S0.6, BF3 Base PWL Segment 3
1424                         dscl_prog_data->easf_v_bf3_pwl_slope_set3 =
1425                                 0x1878; // FP1.6.6, BF3 Slope PWL Segment 3
1426                         dscl_prog_data->easf_v_bf3_pwl_in_set4 =
1427                                 0x0761; // FP0.6.6, BF3 Input value PWL Segment 4 (0.375)
1428                         dscl_prog_data->easf_v_bf3_pwl_base_set4 = 0x44;        // S0.6, BF3 Base PWL Segment 4 = -60
1429                         dscl_prog_data->easf_v_bf3_pwl_slope_set4 = 0x1760;     // FP1.6.6, BF3 Slope PWL Segment 4
1430                         dscl_prog_data->easf_v_bf3_pwl_in_set5 =
1431                                 0x0780; // FP0.6.6, BF3 Input value PWL Segment 5 (0.5)
1432                         dscl_prog_data->easf_v_bf3_pwl_base_set5 = 0x41;        // S0.6, BF3 Base PWL Segment 5 = -63
1433                 }
1434         } else
1435                 dscl_prog_data->easf_v_en = false;
1436
1437         if (enable_easf_h) {
1438                 dscl_prog_data->easf_h_en = true;
1439                 dscl_prog_data->easf_h_ring = 0;
1440                 dscl_prog_data->easf_h_sharp_factor = 0;
1441                 dscl_prog_data->easf_h_bf1_en =
1442                         1;      // 1-bit, BF1 calculation enable, 0=disable, 1=enable
1443                 dscl_prog_data->easf_h_bf2_mode =
1444                         0xF;    // 4-bit, BF2 calculation mode
1445                 /* 2-bit, BF3 chroma mode correction calculation mode */
1446                 dscl_prog_data->easf_h_bf3_mode = spl_get_h_bf3_mode(
1447                         spl_scratch->scl_data.recip_ratios.horz);
1448                 /* FP1.5.10; (2.0) Ring reducer gain for 4 or 6-tap mode [H_REDUCER_GAIN4] */
1449                 dscl_prog_data->easf_h_ringest_eventap_reduceg1 =
1450                         spl_get_reducer_gain4(spl_scratch->scl_data.taps.h_taps,
1451                                 spl_scratch->scl_data.recip_ratios.horz);
1452                 /* FP1.5.10; (2.5) Ring reducer gain for 6-tap mode [V_REDUCER_GAIN6] */
1453                 dscl_prog_data->easf_h_ringest_eventap_reduceg2 =
1454                         spl_get_reducer_gain6(spl_scratch->scl_data.taps.h_taps,
1455                                 spl_scratch->scl_data.recip_ratios.horz);
1456                 /* FP1.5.10; (-0.135742) Ring gain for 6-tap set to -139/1024 */
1457                 dscl_prog_data->easf_h_ringest_eventap_gain1 =
1458                         spl_get_gainRing4(spl_scratch->scl_data.taps.h_taps,
1459                                 spl_scratch->scl_data.recip_ratios.horz);
1460                 /* FP1.5.10; (-0.024414) Ring gain for 6-tap set to -25/1024 */
1461                 dscl_prog_data->easf_h_ringest_eventap_gain2 =
1462                         spl_get_gainRing6(spl_scratch->scl_data.taps.h_taps,
1463                                 spl_scratch->scl_data.recip_ratios.horz);
1464                 dscl_prog_data->easf_h_bf_maxa = 63; //Horz Max BF value A in U0.6 format.Selected if H_FCNTL==0
1465                 dscl_prog_data->easf_h_bf_maxb = 63; //Horz Max BF value B in U0.6 format.Selected if H_FCNTL==1
1466                 dscl_prog_data->easf_h_bf_mina = 0;     //Horz Min BF value B in U0.6 format.Selected if H_FCNTL==0
1467                 dscl_prog_data->easf_h_bf_minb = 0;     //Horz Min BF value B in U0.6 format.Selected if H_FCNTL==1
1468                 if (lls_pref == LLS_PREF_YES)   {
1469                         dscl_prog_data->easf_h_bf2_flat1_gain = 4;      // U1.3, BF2 Flat1 Gain control
1470                         dscl_prog_data->easf_h_bf2_flat2_gain = 8;      // U4.0, BF2 Flat2 Gain control
1471                         dscl_prog_data->easf_h_bf2_roc_gain = 4;        // U2.2, Rate Of Change control
1472
1473                         dscl_prog_data->easf_h_bf1_pwl_in_seg0 = 0x600; // S0.10, BF1 PWL Segment 0 = -512
1474                         dscl_prog_data->easf_h_bf1_pwl_base_seg0 = 0;   // U0.6, BF1 Base PWL Segment 0
1475                         dscl_prog_data->easf_h_bf1_pwl_slope_seg0 = 3;  // S7.3, BF1 Slope PWL Segment 0
1476                         dscl_prog_data->easf_h_bf1_pwl_in_seg1 = 0x7EC; // S0.10, BF1 PWL Segment 1 = -20
1477                         dscl_prog_data->easf_h_bf1_pwl_base_seg1 = 12;  // U0.6, BF1 Base PWL Segment 1
1478                         dscl_prog_data->easf_h_bf1_pwl_slope_seg1 = 326;        // S7.3, BF1 Slope PWL Segment 1
1479                         dscl_prog_data->easf_h_bf1_pwl_in_seg2 = 0;     // S0.10, BF1 PWL Segment 2
1480                         dscl_prog_data->easf_h_bf1_pwl_base_seg2 = 63;  // U0.6, BF1 Base PWL Segment 2
1481                         dscl_prog_data->easf_h_bf1_pwl_slope_seg2 = 0;  // S7.3, BF1 Slope PWL Segment 2
1482                         dscl_prog_data->easf_h_bf1_pwl_in_seg3 = 16;    // S0.10, BF1 PWL Segment 3
1483                         dscl_prog_data->easf_h_bf1_pwl_base_seg3 = 63;  // U0.6, BF1 Base PWL Segment 3
1484                         dscl_prog_data->easf_h_bf1_pwl_slope_seg3 = 0x7C8;      // S7.3, BF1 Slope PWL Segment 3 = -56
1485                         dscl_prog_data->easf_h_bf1_pwl_in_seg4 = 32;    // S0.10, BF1 PWL Segment 4
1486                         dscl_prog_data->easf_h_bf1_pwl_base_seg4 = 56;  // U0.6, BF1 Base PWL Segment 4
1487                         dscl_prog_data->easf_h_bf1_pwl_slope_seg4 = 0x7D0;      // S7.3, BF1 Slope PWL Segment 4 = -48
1488                         dscl_prog_data->easf_h_bf1_pwl_in_seg5 = 48;    // S0.10, BF1 PWL Segment 5
1489                         dscl_prog_data->easf_h_bf1_pwl_base_seg5 = 50;  // U0.6, BF1 Base PWL Segment 5
1490                         dscl_prog_data->easf_h_bf1_pwl_slope_seg5 = 0x710;      // S7.3, BF1 Slope PWL Segment 5 = -240
1491                         dscl_prog_data->easf_h_bf1_pwl_in_seg6 = 64;    // S0.10, BF1 PWL Segment 6
1492                         dscl_prog_data->easf_h_bf1_pwl_base_seg6 = 20;  // U0.6, BF1 Base PWL Segment 6
1493                         dscl_prog_data->easf_h_bf1_pwl_slope_seg6 = 0x760;      // S7.3, BF1 Slope PWL Segment 6 = -160
1494                         dscl_prog_data->easf_h_bf1_pwl_in_seg7 = 80;    // S0.10, BF1 PWL Segment 7
1495                         dscl_prog_data->easf_h_bf1_pwl_base_seg7 = 0;   // U0.6, BF1 Base PWL Segment 7
1496
1497                         dscl_prog_data->easf_h_bf3_pwl_in_set0 = 0x000; // FP0.6.6, BF3 Input value PWL Segment 0
1498                         dscl_prog_data->easf_h_bf3_pwl_base_set0 = 63;  // S0.6, BF3 Base PWL Segment 0
1499                         dscl_prog_data->easf_h_bf3_pwl_slope_set0 = 0x12C5;     // FP1.6.6, BF3 Slope PWL Segment 0
1500                         dscl_prog_data->easf_h_bf3_pwl_in_set1 =
1501                                 0x0B37; // FP0.6.6, BF3 Input value PWL Segment 1 (0.0078125 * 125^3)
1502                         dscl_prog_data->easf_h_bf3_pwl_base_set1 = 62;  // S0.6, BF3 Base PWL Segment 1
1503                         dscl_prog_data->easf_h_bf3_pwl_slope_set1 =     0x13B8; // FP1.6.6, BF3 Slope PWL Segment 1
1504                         dscl_prog_data->easf_h_bf3_pwl_in_set2 =
1505                                 0x0BB7; // FP0.6.6, BF3 Input value PWL Segment 2 (0.03125 * 125^3)
1506                         dscl_prog_data->easf_h_bf3_pwl_base_set2 = 20;  // S0.6, BF3 Base PWL Segment 2
1507                         dscl_prog_data->easf_h_bf3_pwl_slope_set2 =     0x1356; // FP1.6.6, BF3 Slope PWL Segment 2
1508                         dscl_prog_data->easf_h_bf3_pwl_in_set3 =
1509                                 0x0BF7; // FP0.6.6, BF3 Input value PWL Segment 3 (0.0625 * 125^3)
1510                         dscl_prog_data->easf_h_bf3_pwl_base_set3 = 0;   // S0.6, BF3 Base PWL Segment 3
1511                         dscl_prog_data->easf_h_bf3_pwl_slope_set3 =     0x136B; // FP1.6.6, BF3 Slope PWL Segment 3
1512                         dscl_prog_data->easf_h_bf3_pwl_in_set4 =
1513                                 0x0C37; // FP0.6.6, BF3 Input value PWL Segment 4 (0.125 * 125^3)
1514                         dscl_prog_data->easf_h_bf3_pwl_base_set4 = 0x4E;        // S0.6, BF3 Base PWL Segment 4 = -50
1515                         dscl_prog_data->easf_h_bf3_pwl_slope_set4 = 0x1200;     // FP1.6.6, BF3 Slope PWL Segment 4
1516                         dscl_prog_data->easf_h_bf3_pwl_in_set5 =
1517                                 0x0CF7; // FP0.6.6, BF3 Input value PWL Segment 5 (1.0 * 125^3)
1518                         dscl_prog_data->easf_h_bf3_pwl_base_set5 = 0x41;        // S0.6, BF3 Base PWL Segment 5 = -63
1519                 } else {
1520                         dscl_prog_data->easf_h_bf2_flat1_gain = 13;     // U1.3, BF2 Flat1 Gain control
1521                         dscl_prog_data->easf_h_bf2_flat2_gain = 15;     // U4.0, BF2 Flat2 Gain control
1522                         dscl_prog_data->easf_h_bf2_roc_gain = 14;       // U2.2, Rate Of Change control
1523
1524                         dscl_prog_data->easf_h_bf1_pwl_in_seg0 = 0x440; // S0.10, BF1 PWL Segment 0 = -960
1525                         dscl_prog_data->easf_h_bf1_pwl_base_seg0 = 0;   // U0.6, BF1 Base PWL Segment 0
1526                         dscl_prog_data->easf_h_bf1_pwl_slope_seg0 = 2;  // S7.3, BF1 Slope PWL Segment 0
1527                         dscl_prog_data->easf_h_bf1_pwl_in_seg1 = 0x7C4; // S0.10, BF1 PWL Segment 1 = -60
1528                         dscl_prog_data->easf_h_bf1_pwl_base_seg1 = 12;  // U0.6, BF1 Base PWL Segment 1
1529                         dscl_prog_data->easf_h_bf1_pwl_slope_seg1 = 109;        // S7.3, BF1 Slope PWL Segment 1
1530                         dscl_prog_data->easf_h_bf1_pwl_in_seg2 = 0;     // S0.10, BF1 PWL Segment 2
1531                         dscl_prog_data->easf_h_bf1_pwl_base_seg2 = 63;  // U0.6, BF1 Base PWL Segment 2
1532                         dscl_prog_data->easf_h_bf1_pwl_slope_seg2 = 0;  // S7.3, BF1 Slope PWL Segment 2
1533                         dscl_prog_data->easf_h_bf1_pwl_in_seg3 = 48;    // S0.10, BF1 PWL Segment 3
1534                         dscl_prog_data->easf_h_bf1_pwl_base_seg3 = 63;  // U0.6, BF1 Base PWL Segment 3
1535                         dscl_prog_data->easf_h_bf1_pwl_slope_seg3 = 0x7ED;      // S7.3, BF1 Slope PWL Segment 3 = -19
1536                         dscl_prog_data->easf_h_bf1_pwl_in_seg4 = 96;    // S0.10, BF1 PWL Segment 4
1537                         dscl_prog_data->easf_h_bf1_pwl_base_seg4 = 56;  // U0.6, BF1 Base PWL Segment 4
1538                         dscl_prog_data->easf_h_bf1_pwl_slope_seg4 = 0x7F0;      // S7.3, BF1 Slope PWL Segment 4 = -16
1539                         dscl_prog_data->easf_h_bf1_pwl_in_seg5 = 144;   // S0.10, BF1 PWL Segment 5
1540                         dscl_prog_data->easf_h_bf1_pwl_base_seg5 = 50;  // U0.6, BF1 Base PWL Segment 5
1541                         dscl_prog_data->easf_h_bf1_pwl_slope_seg5 = 0x7B0;      // S7.3, BF1 Slope PWL Segment 5 = -80
1542                         dscl_prog_data->easf_h_bf1_pwl_in_seg6 = 192;   // S0.10, BF1 PWL Segment 6
1543                         dscl_prog_data->easf_h_bf1_pwl_base_seg6 = 20;  // U0.6, BF1 Base PWL Segment 6
1544                         dscl_prog_data->easf_h_bf1_pwl_slope_seg6 = 0x7CB;      // S7.3, BF1 Slope PWL Segment 6 = -53
1545                         dscl_prog_data->easf_h_bf1_pwl_in_seg7 = 240;   // S0.10, BF1 PWL Segment 7
1546                         dscl_prog_data->easf_h_bf1_pwl_base_seg7 = 0;   // U0.6, BF1 Base PWL Segment 7
1547
1548                         dscl_prog_data->easf_h_bf3_pwl_in_set0 = 0x000; // FP0.6.6, BF3 Input value PWL Segment 0
1549                         dscl_prog_data->easf_h_bf3_pwl_base_set0 = 63;  // S0.6, BF3 Base PWL Segment 0
1550                         dscl_prog_data->easf_h_bf3_pwl_slope_set0 = 0x0000;     // FP1.6.6, BF3 Slope PWL Segment 0
1551                         dscl_prog_data->easf_h_bf3_pwl_in_set1 =
1552                                 0x06C0; // FP0.6.6, BF3 Input value PWL Segment 1 (0.0625)
1553                         dscl_prog_data->easf_h_bf3_pwl_base_set1 = 63;  // S0.6, BF3 Base PWL Segment 1
1554                         dscl_prog_data->easf_h_bf3_pwl_slope_set1 = 0x1896;     // FP1.6.6, BF3 Slope PWL Segment 1
1555                         dscl_prog_data->easf_h_bf3_pwl_in_set2 =
1556                                 0x0700; // FP0.6.6, BF3 Input value PWL Segment 2 (0.125)
1557                         dscl_prog_data->easf_h_bf3_pwl_base_set2 = 20;  // S0.6, BF3 Base PWL Segment 2
1558                         dscl_prog_data->easf_h_bf3_pwl_slope_set2 = 0x1810;     // FP1.6.6, BF3 Slope PWL Segment 2
1559                         dscl_prog_data->easf_h_bf3_pwl_in_set3 =
1560                                 0x0740; // FP0.6.6, BF3 Input value PWL Segment 3 (0.25)
1561                         dscl_prog_data->easf_h_bf3_pwl_base_set3 = 0;   // S0.6, BF3 Base PWL Segment 3
1562                         dscl_prog_data->easf_h_bf3_pwl_slope_set3 = 0x1878;     // FP1.6.6, BF3 Slope PWL Segment 3
1563                         dscl_prog_data->easf_h_bf3_pwl_in_set4 =
1564                                 0x0761; // FP0.6.6, BF3 Input value PWL Segment 4 (0.375)
1565                         dscl_prog_data->easf_h_bf3_pwl_base_set4 = 0x44;        // S0.6, BF3 Base PWL Segment 4 = -60
1566                         dscl_prog_data->easf_h_bf3_pwl_slope_set4 = 0x1760;     // FP1.6.6, BF3 Slope PWL Segment 4
1567                         dscl_prog_data->easf_h_bf3_pwl_in_set5 =
1568                                 0x0780; // FP0.6.6, BF3 Input value PWL Segment 5 (0.5)
1569                         dscl_prog_data->easf_h_bf3_pwl_base_set5 = 0x41;        // S0.6, BF3 Base PWL Segment 5 = -63
1570                 } // if (lls_pref == LLS_PREF_YES)
1571         } else
1572                 dscl_prog_data->easf_h_en = false;
1573
1574         if (lls_pref == LLS_PREF_YES)   {
1575                 dscl_prog_data->easf_ltonl_en = 1;      // Linear input
1576                 if ((setup == HDR_L) && (spl_is_rgb8(format))) {
1577                         /* Calculate C0-C3 coefficients based on HDR multiplier */
1578                         spl_calculate_c0_c3_hdr(dscl_prog_data, sdr_white_level_nits);
1579                 } else { // HDR_L ( DWM ) and SDR_L
1580                         dscl_prog_data->easf_matrix_c0 =
1581                                 0x4EF7; // fp1.5.10, C0 coefficient (LN_rec709:  0.2126 * (2^14)/125 = 27.86590720)
1582                         dscl_prog_data->easf_matrix_c1 =
1583                                 0x55DC; // fp1.5.10, C1 coefficient (LN_rec709:  0.7152 * (2^14)/125 = 93.74269440)
1584                         dscl_prog_data->easf_matrix_c2 =
1585                                 0x48BB; // fp1.5.10, C2 coefficient (LN_rec709:  0.0722 * (2^14)/125 = 9.46339840)
1586                         dscl_prog_data->easf_matrix_c3 =
1587                                 0x0;    // fp1.5.10, C3 coefficient
1588                 }
1589         }       else    {
1590                 dscl_prog_data->easf_ltonl_en = 0;      // Non-Linear input
1591                 dscl_prog_data->easf_matrix_c0 =
1592                         0x3434; // fp1.5.10, C0 coefficient (LN_BT2020:  0.262695312500000)
1593                 dscl_prog_data->easf_matrix_c1 =
1594                         0x396D; // fp1.5.10, C1 coefficient (LN_BT2020:  0.678222656250000)
1595                 dscl_prog_data->easf_matrix_c2 =
1596                         0x2B97; // fp1.5.10, C2 coefficient (LN_BT2020:  0.059295654296875)
1597                 dscl_prog_data->easf_matrix_c3 =
1598                         0x0;    // fp1.5.10, C3 coefficient
1599         }
1600
1601         if (spl_is_subsampled_format(format)) { /* TODO: 0 = RGB, 1 = YUV */
1602                 dscl_prog_data->easf_matrix_mode = 1;
1603                 /*
1604                  * 2-bit, BF3 chroma mode correction calculation mode
1605                  * Needs to be disabled for YUV420 mode
1606                  * Override lookup value
1607                  */
1608                 dscl_prog_data->easf_v_bf3_mode = 0;
1609                 dscl_prog_data->easf_h_bf3_mode = 0;
1610         } else
1611                 dscl_prog_data->easf_matrix_mode = 0;
1612
1613 }
1614
1615 /*Set isharp noise detection */
1616 static void spl_set_isharp_noise_det_mode(struct dscl_prog_data *dscl_prog_data,
1617         const struct spl_scaler_data *data)
1618 {
1619         // ISHARP_NOISEDET_MODE
1620         // 0: 3x5 as VxH
1621         // 1: 4x5 as VxH
1622         // 2:
1623         // 3: 5x5 as VxH
1624         if (data->taps.v_taps == 6)
1625                 dscl_prog_data->isharp_noise_det.mode = 3;
1626         else if (data->taps.v_taps == 4)
1627                 dscl_prog_data->isharp_noise_det.mode = 1;
1628         else if (data->taps.v_taps == 3)
1629                 dscl_prog_data->isharp_noise_det.mode = 0;
1630 };
1631 /* Set Sharpener data */
1632 static void spl_set_isharp_data(struct dscl_prog_data *dscl_prog_data,
1633                 struct adaptive_sharpness adp_sharpness, bool enable_isharp,
1634                 enum linear_light_scaling lls_pref, enum spl_pixel_format format,
1635                 const struct spl_scaler_data *data, struct spl_fixed31_32 ratio,
1636                 enum system_setup setup, enum scale_to_sharpness_policy scale_to_sharpness_policy)
1637 {
1638         /* Turn off sharpener if not required */
1639         if (!enable_isharp) {
1640                 dscl_prog_data->isharp_en = 0;
1641                 return;
1642         }
1643
1644         spl_build_isharp_1dlut_from_reference_curve(ratio, setup, adp_sharpness,
1645                 scale_to_sharpness_policy);
1646         memcpy(dscl_prog_data->isharp_delta, spl_get_pregen_filter_isharp_1D_lut(setup),
1647                 sizeof(uint32_t) * ISHARP_LUT_TABLE_SIZE);
1648         dscl_prog_data->sharpness_level = adp_sharpness.sharpness_level;
1649
1650         dscl_prog_data->isharp_en = 1;  // ISHARP_EN
1651         // Set ISHARP_NOISEDET_MODE if htaps = 6-tap
1652         if (data->taps.h_taps == 6) {
1653                 dscl_prog_data->isharp_noise_det.enable = 1;    /* ISHARP_NOISEDET_EN */
1654                 spl_set_isharp_noise_det_mode(dscl_prog_data, data);    /* ISHARP_NOISEDET_MODE */
1655         } else
1656                 dscl_prog_data->isharp_noise_det.enable = 0;    // ISHARP_NOISEDET_EN
1657         // Program noise detection threshold
1658         dscl_prog_data->isharp_noise_det.uthreshold = 24;       // ISHARP_NOISEDET_UTHRE
1659         dscl_prog_data->isharp_noise_det.dthreshold = 4;        // ISHARP_NOISEDET_DTHRE
1660         // Program noise detection gain
1661         dscl_prog_data->isharp_noise_det.pwl_start_in = 3;      // ISHARP_NOISEDET_PWL_START_IN
1662         dscl_prog_data->isharp_noise_det.pwl_end_in = 13;       // ISHARP_NOISEDET_PWL_END_IN
1663         dscl_prog_data->isharp_noise_det.pwl_slope = 1623;      // ISHARP_NOISEDET_PWL_SLOPE
1664
1665         if (lls_pref == LLS_PREF_NO) /* ISHARP_FMT_MODE */
1666                 dscl_prog_data->isharp_fmt.mode = 1;
1667         else
1668                 dscl_prog_data->isharp_fmt.mode = 0;
1669
1670         dscl_prog_data->isharp_fmt.norm = 0x3C00;       // ISHARP_FMT_NORM
1671         dscl_prog_data->isharp_lba.mode = 0;    // ISHARP_LBA_MODE
1672
1673         if (setup == SDR_L) {
1674                 // ISHARP_LBA_PWL_SEG0: ISHARP Local Brightness Adjustment PWL Segment 0
1675                 dscl_prog_data->isharp_lba.in_seg[0] = 0;       // ISHARP LBA PWL for Seg 0. INPUT value in U0.10 format
1676                 dscl_prog_data->isharp_lba.base_seg[0] = 0;     // ISHARP LBA PWL for Seg 0. BASE value in U0.6 format
1677                 dscl_prog_data->isharp_lba.slope_seg[0] = 62;   // ISHARP LBA for Seg 0. SLOPE value in S5.3 format
1678                 // ISHARP_LBA_PWL_SEG1: ISHARP LBA PWL Segment 1
1679                 dscl_prog_data->isharp_lba.in_seg[1] = 130;     // ISHARP LBA PWL for Seg 1. INPUT value in U0.10 format
1680                 dscl_prog_data->isharp_lba.base_seg[1] = 63; // ISHARP LBA PWL for Seg 1. BASE value in U0.6 format
1681                 dscl_prog_data->isharp_lba.slope_seg[1] = 0; // ISHARP LBA for Seg 1. SLOPE value in S5.3 format
1682                 // ISHARP_LBA_PWL_SEG2: ISHARP LBA PWL Segment 2
1683                 dscl_prog_data->isharp_lba.in_seg[2] = 450; // ISHARP LBA PWL for Seg 2. INPUT value in U0.10 format
1684                 dscl_prog_data->isharp_lba.base_seg[2] = 63; // ISHARP LBA PWL for Seg 2. BASE value in U0.6 format
1685                 dscl_prog_data->isharp_lba.slope_seg[2] = 0x18D; // ISHARP LBA for Seg 2. SLOPE value in S5.3 format = -115
1686                 // ISHARP_LBA_PWL_SEG3: ISHARP LBA PWL Segment 3
1687                 dscl_prog_data->isharp_lba.in_seg[3] = 520; // ISHARP LBA PWL for Seg 3.INPUT value in U0.10 format
1688                 dscl_prog_data->isharp_lba.base_seg[3] = 0; // ISHARP LBA PWL for Seg 3. BASE value in U0.6 format
1689                 dscl_prog_data->isharp_lba.slope_seg[3] = 0; // ISHARP LBA for Seg 3. SLOPE value in S5.3 format
1690                 // ISHARP_LBA_PWL_SEG4: ISHARP LBA PWL Segment 4
1691                 dscl_prog_data->isharp_lba.in_seg[4] = 520; // ISHARP LBA PWL for Seg 4.INPUT value in U0.10 format
1692                 dscl_prog_data->isharp_lba.base_seg[4] = 0; // ISHARP LBA PWL for Seg 4. BASE value in U0.6 format
1693                 dscl_prog_data->isharp_lba.slope_seg[4] = 0; // ISHARP LBA for Seg 4. SLOPE value in S5.3 format
1694                 // ISHARP_LBA_PWL_SEG5: ISHARP LBA PWL Segment 5
1695                 dscl_prog_data->isharp_lba.in_seg[5] = 520; // ISHARP LBA PWL for Seg 5.INPUT value in U0.10 format
1696                 dscl_prog_data->isharp_lba.base_seg[5] = 0;     // ISHARP LBA PWL for Seg 5. BASE value in U0.6 format
1697         } else if (setup == HDR_L) {
1698                 // ISHARP_LBA_PWL_SEG0: ISHARP Local Brightness Adjustment PWL Segment 0
1699                 dscl_prog_data->isharp_lba.in_seg[0] = 0;       // ISHARP LBA PWL for Seg 0. INPUT value in U0.10 format
1700                 dscl_prog_data->isharp_lba.base_seg[0] = 0;     // ISHARP LBA PWL for Seg 0. BASE value in U0.6 format
1701                 dscl_prog_data->isharp_lba.slope_seg[0] = 32;   // ISHARP LBA for Seg 0. SLOPE value in S5.3 format
1702                 // ISHARP_LBA_PWL_SEG1: ISHARP LBA PWL Segment 1
1703                 dscl_prog_data->isharp_lba.in_seg[1] = 254;     // ISHARP LBA PWL for Seg 1. INPUT value in U0.10 format
1704                 dscl_prog_data->isharp_lba.base_seg[1] = 63; // ISHARP LBA PWL for Seg 1. BASE value in U0.6 format
1705                 dscl_prog_data->isharp_lba.slope_seg[1] = 0; // ISHARP LBA for Seg 1. SLOPE value in S5.3 format
1706                 // ISHARP_LBA_PWL_SEG2: ISHARP LBA PWL Segment 2
1707                 dscl_prog_data->isharp_lba.in_seg[2] = 559; // ISHARP LBA PWL for Seg 2. INPUT value in U0.10 format
1708                 dscl_prog_data->isharp_lba.base_seg[2] = 63; // ISHARP LBA PWL for Seg 2. BASE value in U0.6 format
1709                 dscl_prog_data->isharp_lba.slope_seg[2] = 0x10C; // ISHARP LBA for Seg 2. SLOPE value in S5.3 format = -244
1710                 // ISHARP_LBA_PWL_SEG3: ISHARP LBA PWL Segment 3
1711                 dscl_prog_data->isharp_lba.in_seg[3] = 592; // ISHARP LBA PWL for Seg 3.INPUT value in U0.10 format
1712                 dscl_prog_data->isharp_lba.base_seg[3] = 0; // ISHARP LBA PWL for Seg 3. BASE value in U0.6 format
1713                 dscl_prog_data->isharp_lba.slope_seg[3] = 0; // ISHARP LBA for Seg 3. SLOPE value in S5.3 format
1714                 // ISHARP_LBA_PWL_SEG4: ISHARP LBA PWL Segment 4
1715                 dscl_prog_data->isharp_lba.in_seg[4] = 1023; // ISHARP LBA PWL for Seg 4.INPUT value in U0.10 format
1716                 dscl_prog_data->isharp_lba.base_seg[4] = 0; // ISHARP LBA PWL for Seg 4. BASE value in U0.6 format
1717                 dscl_prog_data->isharp_lba.slope_seg[4] = 0; // ISHARP LBA for Seg 4. SLOPE value in S5.3 format
1718                 // ISHARP_LBA_PWL_SEG5: ISHARP LBA PWL Segment 5
1719                 dscl_prog_data->isharp_lba.in_seg[5] = 1023; // ISHARP LBA PWL for Seg 5.INPUT value in U0.10 format
1720                 dscl_prog_data->isharp_lba.base_seg[5] = 0;     // ISHARP LBA PWL for Seg 5. BASE value in U0.6 format
1721         } else {
1722                 // ISHARP_LBA_PWL_SEG0: ISHARP Local Brightness Adjustment PWL Segment 0
1723                 dscl_prog_data->isharp_lba.in_seg[0] = 0;       // ISHARP LBA PWL for Seg 0. INPUT value in U0.10 format
1724                 dscl_prog_data->isharp_lba.base_seg[0] = 0;     // ISHARP LBA PWL for Seg 0. BASE value in U0.6 format
1725                 dscl_prog_data->isharp_lba.slope_seg[0] = 40;   // ISHARP LBA for Seg 0. SLOPE value in S5.3 format
1726                 // ISHARP_LBA_PWL_SEG1: ISHARP LBA PWL Segment 1
1727                 dscl_prog_data->isharp_lba.in_seg[1] = 204;     // ISHARP LBA PWL for Seg 1. INPUT value in U0.10 format
1728                 dscl_prog_data->isharp_lba.base_seg[1] = 63; // ISHARP LBA PWL for Seg 1. BASE value in U0.6 format
1729                 dscl_prog_data->isharp_lba.slope_seg[1] = 0; // ISHARP LBA for Seg 1. SLOPE value in S5.3 format
1730                 // ISHARP_LBA_PWL_SEG2: ISHARP LBA PWL Segment 2
1731                 dscl_prog_data->isharp_lba.in_seg[2] = 818; // ISHARP LBA PWL for Seg 2. INPUT value in U0.10 format
1732                 dscl_prog_data->isharp_lba.base_seg[2] = 63; // ISHARP LBA PWL for Seg 2. BASE value in U0.6 format
1733                 dscl_prog_data->isharp_lba.slope_seg[2] = 0x1D9; // ISHARP LBA for Seg 2. SLOPE value in S5.3 format = -39
1734                 // ISHARP_LBA_PWL_SEG3: ISHARP LBA PWL Segment 3
1735                 dscl_prog_data->isharp_lba.in_seg[3] = 1023; // ISHARP LBA PWL for Seg 3.INPUT value in U0.10 format
1736                 dscl_prog_data->isharp_lba.base_seg[3] = 0; // ISHARP LBA PWL for Seg 3. BASE value in U0.6 format
1737                 dscl_prog_data->isharp_lba.slope_seg[3] = 0; // ISHARP LBA for Seg 3. SLOPE value in S5.3 format
1738                 // ISHARP_LBA_PWL_SEG4: ISHARP LBA PWL Segment 4
1739                 dscl_prog_data->isharp_lba.in_seg[4] = 1023; // ISHARP LBA PWL for Seg 4.INPUT value in U0.10 format
1740                 dscl_prog_data->isharp_lba.base_seg[4] = 0; // ISHARP LBA PWL for Seg 4. BASE value in U0.6 format
1741                 dscl_prog_data->isharp_lba.slope_seg[4] = 0; // ISHARP LBA for Seg 4. SLOPE value in S5.3 format
1742                 // ISHARP_LBA_PWL_SEG5: ISHARP LBA PWL Segment 5
1743                 dscl_prog_data->isharp_lba.in_seg[5] = 1023; // ISHARP LBA PWL for Seg 5.INPUT value in U0.10 format
1744                 dscl_prog_data->isharp_lba.base_seg[5] = 0;     // ISHARP LBA PWL for Seg 5. BASE value in U0.6 format
1745         }
1746
1747         // Program the nldelta soft clip values
1748         if (lls_pref == LLS_PREF_YES) {
1749                 dscl_prog_data->isharp_nldelta_sclip.enable_p = 0;      /* ISHARP_NLDELTA_SCLIP_EN_P */
1750                 dscl_prog_data->isharp_nldelta_sclip.pivot_p = 0;       /* ISHARP_NLDELTA_SCLIP_PIVOT_P */
1751                 dscl_prog_data->isharp_nldelta_sclip.slope_p = 0;       /* ISHARP_NLDELTA_SCLIP_SLOPE_P */
1752                 dscl_prog_data->isharp_nldelta_sclip.enable_n = 1;      /* ISHARP_NLDELTA_SCLIP_EN_N */
1753                 dscl_prog_data->isharp_nldelta_sclip.pivot_n = 71;      /* ISHARP_NLDELTA_SCLIP_PIVOT_N */
1754                 dscl_prog_data->isharp_nldelta_sclip.slope_n = 16;      /* ISHARP_NLDELTA_SCLIP_SLOPE_N */
1755         } else {
1756                 dscl_prog_data->isharp_nldelta_sclip.enable_p = 1;      /* ISHARP_NLDELTA_SCLIP_EN_P */
1757                 dscl_prog_data->isharp_nldelta_sclip.pivot_p = 70;      /* ISHARP_NLDELTA_SCLIP_PIVOT_P */
1758                 dscl_prog_data->isharp_nldelta_sclip.slope_p = 24;      /* ISHARP_NLDELTA_SCLIP_SLOPE_P */
1759                 dscl_prog_data->isharp_nldelta_sclip.enable_n = 1;      /* ISHARP_NLDELTA_SCLIP_EN_N */
1760                 dscl_prog_data->isharp_nldelta_sclip.pivot_n = 70;      /* ISHARP_NLDELTA_SCLIP_PIVOT_N */
1761                 dscl_prog_data->isharp_nldelta_sclip.slope_n = 24;      /* ISHARP_NLDELTA_SCLIP_SLOPE_N */
1762         }
1763
1764         // Set the values as per lookup table
1765         spl_set_blur_scale_data(dscl_prog_data, data);
1766 }
1767
1768 /* Calculate recout, scaling ratio, and viewport, then get optimal number of taps */
1769 static bool spl_calculate_number_of_taps(struct spl_in *spl_in, struct spl_scratch *spl_scratch, struct spl_out *spl_out,
1770         bool *enable_easf_v, bool *enable_easf_h, bool *enable_isharp)
1771 {
1772         bool res = false;
1773
1774         memset(spl_scratch, 0, sizeof(struct spl_scratch));
1775         spl_scratch->scl_data.h_active = spl_in->h_active;
1776         spl_scratch->scl_data.v_active = spl_in->v_active;
1777
1778         // All SPL calls
1779         /* recout calculation */
1780         /* depends on h_active */
1781         spl_calculate_recout(spl_in, spl_scratch, spl_out);
1782         /* depends on pixel format */
1783         spl_calculate_scaling_ratios(spl_in, spl_scratch, spl_out);
1784         /* depends on scaling ratios and recout, does not calculate offset yet */
1785         spl_calculate_viewport_size(spl_in, spl_scratch);
1786
1787         res = spl_get_optimal_number_of_taps(
1788                           spl_in->basic_out.max_downscale_src_width, spl_in,
1789                           spl_scratch, &spl_in->scaling_quality, enable_easf_v,
1790                           enable_easf_h, enable_isharp);
1791         return res;
1792 }
1793
1794 /* Calculate scaler parameters */
1795 bool spl_calculate_scaler_params(struct spl_in *spl_in, struct spl_out *spl_out)
1796 {
1797         bool res = false;
1798         bool enable_easf_v = false;
1799         bool enable_easf_h = false;
1800         int vratio = 0;
1801         int hratio = 0;
1802         struct spl_scratch spl_scratch;
1803         struct spl_fixed31_32 isharp_scale_ratio;
1804         enum system_setup setup;
1805         bool enable_isharp = false;
1806         const struct spl_scaler_data *data = &spl_scratch.scl_data;
1807
1808         res = spl_calculate_number_of_taps(spl_in, &spl_scratch, spl_out,
1809                 &enable_easf_v, &enable_easf_h, &enable_isharp);
1810
1811         /*
1812          * Depends on recout, scaling ratios, h_active and taps
1813          * May need to re-check lb size after this in some obscure scenario
1814          */
1815         if (res)
1816                 spl_calculate_inits_and_viewports(spl_in, &spl_scratch);
1817         // Handle 3d recout
1818         spl_handle_3d_recout(spl_in, &spl_scratch.scl_data.recout);
1819         // Clamp
1820         spl_clamp_viewport(&spl_scratch.scl_data.viewport);
1821
1822         // Save all calculated parameters in dscl_prog_data structure to program hw registers
1823         spl_set_dscl_prog_data(spl_in, &spl_scratch, spl_out, enable_easf_v, enable_easf_h, enable_isharp);
1824
1825         if (!res)
1826                 return res;
1827
1828         if (spl_in->lls_pref == LLS_PREF_YES) {
1829                 if (spl_in->is_hdr_on)
1830                         setup = HDR_L;
1831                 else
1832                         setup = SDR_L;
1833         } else {
1834                 if (spl_in->is_hdr_on)
1835                         setup = HDR_NL;
1836                 else
1837                         setup = SDR_NL;
1838         }
1839
1840         // Set EASF
1841         spl_set_easf_data(&spl_scratch, spl_out, enable_easf_v, enable_easf_h, spl_in->lls_pref,
1842                 spl_in->basic_in.format, setup, spl_in->sdr_white_level_nits);
1843
1844         // Set iSHARP
1845         vratio = spl_fixpt_ceil(spl_scratch.scl_data.ratios.vert);
1846         hratio = spl_fixpt_ceil(spl_scratch.scl_data.ratios.horz);
1847         if (vratio <= hratio)
1848                 isharp_scale_ratio = spl_scratch.scl_data.recip_ratios.vert;
1849         else
1850                 isharp_scale_ratio = spl_scratch.scl_data.recip_ratios.horz;
1851
1852         spl_set_isharp_data(spl_out->dscl_prog_data, spl_in->adaptive_sharpness, enable_isharp,
1853                 spl_in->lls_pref, spl_in->basic_in.format, data, isharp_scale_ratio, setup,
1854                 spl_in->debug.scale_to_sharpness_policy);
1855
1856         return res;
1857 }
1858
1859 /* External interface to get number of taps only */
1860 bool spl_get_number_of_taps(struct spl_in *spl_in, struct spl_out *spl_out)
1861 {
1862         bool res = false;
1863         bool enable_easf_v = false;
1864         bool enable_easf_h = false;
1865         bool enable_isharp = false;
1866         struct spl_scratch spl_scratch;
1867         struct dscl_prog_data *dscl_prog_data = spl_out->dscl_prog_data;
1868         const struct spl_scaler_data *data = &spl_scratch.scl_data;
1869
1870         res = spl_calculate_number_of_taps(spl_in, &spl_scratch, spl_out,
1871                 &enable_easf_v, &enable_easf_h, &enable_isharp);
1872         spl_set_taps_data(dscl_prog_data, data);
1873         return res;
1874 }