drivers/gpu/drm/imx/dcss/dcss-scaler.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2019 NXP.
   4  *
   5  * Scaling algorithms were contributed by Dzung Hoang <[email protected]>
   6  */
   7
   8 #include <linux/device.h>
   9 #include <linux/slab.h>
  10
  11 #include "dcss-dev.h"
  12
  13 #define DCSS_SCALER_CTRL                        0x00
  14 #define   SCALER_EN                             BIT(0)
  15 #define   REPEAT_EN                             BIT(4)
  16 #define   SCALE2MEM_EN                          BIT(8)
  17 #define   MEM2OFIFO_EN                          BIT(12)
  18 #define DCSS_SCALER_OFIFO_CTRL                  0x04
  19 #define   OFIFO_LOW_THRES_POS                   0
  20 #define   OFIFO_LOW_THRES_MASK                  GENMASK(9, 0)
  21 #define   OFIFO_HIGH_THRES_POS                  16
  22 #define   OFIFO_HIGH_THRES_MASK                 GENMASK(25, 16)
  23 #define   UNDERRUN_DETECT_CLR                   BIT(26)
  24 #define   LOW_THRES_DETECT_CLR                  BIT(27)
  25 #define   HIGH_THRES_DETECT_CLR                 BIT(28)
  26 #define   UNDERRUN_DETECT_EN                    BIT(29)
  27 #define   LOW_THRES_DETECT_EN                   BIT(30)
  28 #define   HIGH_THRES_DETECT_EN                  BIT(31)
  29 #define DCSS_SCALER_SDATA_CTRL                  0x08
  30 #define   YUV_EN                                BIT(0)
  31 #define   RTRAM_8LINES                          BIT(1)
  32 #define   Y_UV_BYTE_SWAP                        BIT(4)
  33 #define   A2R10G10B10_FORMAT_POS                8
  34 #define   A2R10G10B10_FORMAT_MASK               GENMASK(11, 8)
  35 #define DCSS_SCALER_BIT_DEPTH                   0x0C
  36 #define   LUM_BIT_DEPTH_POS                     0
  37 #define   LUM_BIT_DEPTH_MASK                    GENMASK(1, 0)
  38 #define   CHR_BIT_DEPTH_POS                     4
  39 #define   CHR_BIT_DEPTH_MASK                    GENMASK(5, 4)
  40 #define DCSS_SCALER_SRC_FORMAT                  0x10
  41 #define DCSS_SCALER_DST_FORMAT                  0x14
  42 #define   FORMAT_MASK                           GENMASK(1, 0)
  43 #define DCSS_SCALER_SRC_LUM_RES                 0x18
  44 #define DCSS_SCALER_SRC_CHR_RES                 0x1C
  45 #define DCSS_SCALER_DST_LUM_RES                 0x20
  46 #define DCSS_SCALER_DST_CHR_RES                 0x24
  47 #define   WIDTH_POS                             0
  48 #define   WIDTH_MASK                            GENMASK(11, 0)
  49 #define   HEIGHT_POS                            16
  50 #define   HEIGHT_MASK                           GENMASK(27, 16)
  51 #define DCSS_SCALER_V_LUM_START                 0x48
  52 #define   V_START_MASK                          GENMASK(15, 0)
  53 #define DCSS_SCALER_V_LUM_INC                   0x4C
  54 #define   V_INC_MASK                            GENMASK(15, 0)
  55 #define DCSS_SCALER_H_LUM_START                 0x50
  56 #define   H_START_MASK                          GENMASK(18, 0)
  57 #define DCSS_SCALER_H_LUM_INC                   0x54
  58 #define   H_INC_MASK                            GENMASK(15, 0)
  59 #define DCSS_SCALER_V_CHR_START                 0x58
  60 #define DCSS_SCALER_V_CHR_INC                   0x5C
  61 #define DCSS_SCALER_H_CHR_START                 0x60
  62 #define DCSS_SCALER_H_CHR_INC                   0x64
  63 #define DCSS_SCALER_COEF_VLUM                   0x80
  64 #define DCSS_SCALER_COEF_HLUM                   0x140
  65 #define DCSS_SCALER_COEF_VCHR                   0x200
  66 #define DCSS_SCALER_COEF_HCHR                   0x300
  67
  68 struct dcss_scaler_ch {
  69         void __iomem *base_reg;
  70         u32 base_ofs;
  71         struct dcss_scaler *scl;
  72
  73         u32 sdata_ctrl;
  74         u32 scaler_ctrl;
  75
  76         bool scaler_ctrl_chgd;
  77
  78         u32 c_vstart;
  79         u32 c_hstart;
  80
  81         bool use_nn_interpolation;
  82 };
  83
  84 struct dcss_scaler {
  85         struct device *dev;
  86
  87         struct dcss_ctxld *ctxld;
  88         u32 ctx_id;
  89
  90         struct dcss_scaler_ch ch[3];
  91 };
  92
  93 /* scaler coefficients generator */
  94 #define PSC_FRAC_BITS 30
  95 #define PSC_FRAC_SCALE BIT(PSC_FRAC_BITS)
  96 #define PSC_BITS_FOR_PHASE 4
  97 #define PSC_NUM_PHASES 16
  98 #define PSC_STORED_PHASES (PSC_NUM_PHASES / 2 + 1)
  99 #define PSC_NUM_TAPS 7
 100 #define PSC_NUM_TAPS_RGBA 5
 101 #define PSC_COEFF_PRECISION 10
 102 #define PSC_PHASE_FRACTION_BITS 13
 103 #define PSC_PHASE_MASK (PSC_NUM_PHASES - 1)
 104 #define PSC_Q_FRACTION 19
 105 #define PSC_Q_ROUND_OFFSET (1 << (PSC_Q_FRACTION - 1))
 106
 107 /**
 108  * mult_q() - Performs fixed-point multiplication.
 109  * @A: multiplier
 110  * @B: multiplicand
 111  */
 112 static int mult_q(int A, int B)
 113 {
 114         int result;
 115         s64 temp;
 116
 117         temp = (int64_t)A * (int64_t)B;
 118         temp += PSC_Q_ROUND_OFFSET;
 119         result = (int)(temp >> PSC_Q_FRACTION);
 120         return result;
 121 }
 122
 123 /**
 124  * div_q() - Performs fixed-point division.
 125  * @A: dividend
 126  * @B: divisor
 127  */
 128 static int div_q(int A, int B)
 129 {
 130         int result;
 131         s64 temp;
 132
 133         temp = (int64_t)A << PSC_Q_FRACTION;
 134         if ((temp >= 0 && B >= 0) || (temp < 0 && B < 0))
 135                 temp += B / 2;
 136         else
 137                 temp -= B / 2;
 138
 139         result = (int)(temp / B);
 140         return result;
 141 }
 142
 143 /**
 144  * exp_approx_q() - Compute approximation to exp(x) function using Taylor
 145  *                  series.
 146  * @x: fixed-point argument of exp function
 147  */
 148 static int exp_approx_q(int x)
 149 {
 150         int sum = 1 << PSC_Q_FRACTION;
 151         int term = 1 << PSC_Q_FRACTION;
 152
 153         term = mult_q(term, div_q(x, 1 << PSC_Q_FRACTION));
 154         sum += term;
 155         term = mult_q(term, div_q(x, 2 << PSC_Q_FRACTION));
 156         sum += term;
 157         term = mult_q(term, div_q(x, 3 << PSC_Q_FRACTION));
 158         sum += term;
 159         term = mult_q(term, div_q(x, 4 << PSC_Q_FRACTION));
 160         sum += term;
 161
 162         return sum;
 163 }
 164
 165 /**
 166  * dcss_scaler_gaussian_filter() - Generate gaussian prototype filter.
 167  * @fc_q: fixed-point cutoff frequency normalized to range [0, 1]
 168  * @use_5_taps: indicates whether to use 5 taps or 7 taps
 169  * @coef: output filter coefficients
 170  */
 171 static void dcss_scaler_gaussian_filter(int fc_q, bool use_5_taps,
 172                                         bool phase0_identity,
 173                                         int coef[][PSC_NUM_TAPS])
 174 {
 175         int sigma_q, g0_q, g1_q, g2_q;
 176         int tap_cnt1, tap_cnt2, tap_idx, phase_cnt;
 177         int mid;
 178         int phase;
 179         int i;
 180         int taps;
 181
 182         if (use_5_taps)
 183                 for (phase = 0; phase < PSC_STORED_PHASES; phase++) {
 184                         coef[phase][0] = 0;
 185                         coef[phase][PSC_NUM_TAPS - 1] = 0;
 186                 }
 187
 188         /* seed coefficient scanner */
 189         taps = use_5_taps ? PSC_NUM_TAPS_RGBA : PSC_NUM_TAPS;
 190         mid = (PSC_NUM_PHASES * taps) / 2 - 1;
 191         phase_cnt = (PSC_NUM_PHASES * (PSC_NUM_TAPS + 1)) / 2;
 192         tap_cnt1 = (PSC_NUM_PHASES * PSC_NUM_TAPS) / 2;
 193         tap_cnt2 = (PSC_NUM_PHASES * PSC_NUM_TAPS) / 2;
 194
 195         /* seed gaussian filter generator */
 196         sigma_q = div_q(PSC_Q_ROUND_OFFSET, fc_q);
 197         g0_q = 1 << PSC_Q_FRACTION;
 198         g1_q = exp_approx_q(div_q(-PSC_Q_ROUND_OFFSET,
 199                                   mult_q(sigma_q, sigma_q)));
 200         g2_q = mult_q(g1_q, g1_q);
 201         coef[phase_cnt & PSC_PHASE_MASK][tap_cnt1 >> PSC_BITS_FOR_PHASE] = g0_q;
 202
 203         for (i = 0; i < mid; i++) {
 204                 phase_cnt++;
 205                 tap_cnt1--;
 206                 tap_cnt2++;
 207
 208                 g0_q = mult_q(g0_q, g1_q);
 209                 g1_q = mult_q(g1_q, g2_q);
 210
 211                 if ((phase_cnt & PSC_PHASE_MASK) <= 8) {
 212                         tap_idx = tap_cnt1 >> PSC_BITS_FOR_PHASE;
 213                         coef[phase_cnt & PSC_PHASE_MASK][tap_idx] = g0_q;
 214                 }
 215                 if (((-phase_cnt) & PSC_PHASE_MASK) <= 8) {
 216                         tap_idx = tap_cnt2 >> PSC_BITS_FOR_PHASE;
 217                         coef[(-phase_cnt) & PSC_PHASE_MASK][tap_idx] = g0_q;
 218                 }
 219         }
 220
 221         phase_cnt++;
 222         tap_cnt1--;
 223         coef[phase_cnt & PSC_PHASE_MASK][tap_cnt1 >> PSC_BITS_FOR_PHASE] = 0;
 224
 225         /* override phase 0 with identity filter if specified */
 226         if (phase0_identity)
 227                 for (i = 0; i < PSC_NUM_TAPS; i++)
 228                         coef[0][i] = i == (PSC_NUM_TAPS >> 1) ?
 229                                                 (1 << PSC_COEFF_PRECISION) : 0;
 230
 231         /* normalize coef */
 232         for (phase = 0; phase < PSC_STORED_PHASES; phase++) {
 233                 int sum = 0;
 234                 s64 ll_temp;
 235
 236                 for (i = 0; i < PSC_NUM_TAPS; i++)
 237                         sum += coef[phase][i];
 238                 for (i = 0; i < PSC_NUM_TAPS; i++) {
 239                         ll_temp = coef[phase][i];
 240                         ll_temp <<= PSC_COEFF_PRECISION;
 241                         ll_temp += sum >> 1;
 242                         ll_temp /= sum;
 243                         coef[phase][i] = (int)ll_temp;
 244                 }
 245         }
 246 }
 247
 248 static void dcss_scaler_nearest_neighbor_filter(bool use_5_taps,
 249                                                 int coef[][PSC_NUM_TAPS])
 250 {
 251         int i, j;
 252
 253         for (i = 0; i < PSC_STORED_PHASES; i++)
 254                 for (j = 0; j < PSC_NUM_TAPS; j++)
 255                         coef[i][j] = j == PSC_NUM_TAPS >> 1 ?
 256                                                 (1 << PSC_COEFF_PRECISION) : 0;
 257 }
 258
 259 /**
 260  * dcss_scaler_filter_design() - Compute filter coefficients using
 261  *                               Gaussian filter.
 262  * @src_length: length of input
 263  * @dst_length: length of output
 264  * @use_5_taps: 0 for 7 taps per phase, 1 for 5 taps
 265  * @coef: output coefficients
 266  */
 267 static void dcss_scaler_filter_design(int src_length, int dst_length,
 268                                       bool use_5_taps, bool phase0_identity,
 269                                       int coef[][PSC_NUM_TAPS],
 270                                       bool nn_interpolation)
 271 {
 272         int fc_q;
 273
 274         /* compute cutoff frequency */
 275         if (dst_length >= src_length)
 276                 fc_q = div_q(1, PSC_NUM_PHASES);
 277         else
 278                 fc_q = div_q(dst_length, src_length * PSC_NUM_PHASES);
 279
 280         if (nn_interpolation)
 281                 dcss_scaler_nearest_neighbor_filter(use_5_taps, coef);
 282         else
 283                 /* compute gaussian filter coefficients */
 284                 dcss_scaler_gaussian_filter(fc_q, use_5_taps, phase0_identity, coef);
 285 }
 286
 287 static void dcss_scaler_write(struct dcss_scaler_ch *ch, u32 val, u32 ofs)
 288 {
 289         struct dcss_scaler *scl = ch->scl;
 290
 291         dcss_ctxld_write(scl->ctxld, scl->ctx_id, val, ch->base_ofs + ofs);
 292 }
 293
 294 static int dcss_scaler_ch_init_all(struct dcss_scaler *scl,
 295                                    unsigned long scaler_base)
 296 {
 297         struct dcss_scaler_ch *ch;
 298         int i;
 299
 300         for (i = 0; i < 3; i++) {
 301                 ch = &scl->ch[i];
 302
 303                 ch->base_ofs = scaler_base + i * 0x400;
 304
 305                 ch->base_reg = ioremap(ch->base_ofs, SZ_4K);
 306                 if (!ch->base_reg) {
 307                         dev_err(scl->dev, "scaler: unable to remap ch base\n");
 308                         return -ENOMEM;
 309                 }
 310
 311                 ch->scl = scl;
 312         }
 313
 314         return 0;
 315 }
 316
 317 int dcss_scaler_init(struct dcss_dev *dcss, unsigned long scaler_base)
 318 {
 319         struct dcss_scaler *scaler;
 320
 321         scaler = kzalloc(sizeof(*scaler), GFP_KERNEL);
 322         if (!scaler)
 323                 return -ENOMEM;
 324
 325         dcss->scaler = scaler;
 326         scaler->dev = dcss->dev;
 327         scaler->ctxld = dcss->ctxld;
 328         scaler->ctx_id = CTX_SB_HP;
 329
 330         if (dcss_scaler_ch_init_all(scaler, scaler_base)) {
 331                 int i;
 332
 333                 for (i = 0; i < 3; i++) {
 334                         if (scaler->ch[i].base_reg)
 335                                 iounmap(scaler->ch[i].base_reg);
 336                 }
 337
 338                 kfree(scaler);
 339
 340                 return -ENOMEM;
 341         }
 342
 343         return 0;
 344 }
 345
 346 void dcss_scaler_exit(struct dcss_scaler *scl)
 347 {
 348         int ch_no;
 349
 350         for (ch_no = 0; ch_no < 3; ch_no++) {
 351                 struct dcss_scaler_ch *ch = &scl->ch[ch_no];
 352
 353                 dcss_writel(0, ch->base_reg + DCSS_SCALER_CTRL);
 354
 355                 if (ch->base_reg)
 356                         iounmap(ch->base_reg);
 357         }
 358
 359         kfree(scl);
 360 }
 361
 362 void dcss_scaler_ch_enable(struct dcss_scaler *scl, int ch_num, bool en)
 363 {
 364         struct dcss_scaler_ch *ch = &scl->ch[ch_num];
 365         u32 scaler_ctrl;
 366
 367         scaler_ctrl = en ? SCALER_EN | REPEAT_EN : 0;
 368
 369         if (en)
 370                 dcss_scaler_write(ch, ch->sdata_ctrl, DCSS_SCALER_SDATA_CTRL);
 371
 372         if (ch->scaler_ctrl != scaler_ctrl)
 373                 ch->scaler_ctrl_chgd = true;
 374
 375         ch->scaler_ctrl = scaler_ctrl;
 376 }
 377
 378 static void dcss_scaler_yuv_enable(struct dcss_scaler_ch *ch, bool en)
 379 {
 380         ch->sdata_ctrl &= ~YUV_EN;
 381         ch->sdata_ctrl |= en ? YUV_EN : 0;
 382 }
 383
 384 static void dcss_scaler_rtr_8lines_enable(struct dcss_scaler_ch *ch, bool en)
 385 {
 386         ch->sdata_ctrl &= ~RTRAM_8LINES;
 387         ch->sdata_ctrl |= en ? RTRAM_8LINES : 0;
 388 }
 389
 390 static void dcss_scaler_bit_depth_set(struct dcss_scaler_ch *ch, int depth)
 391 {
 392         u32 val;
 393
 394         val = depth == 30 ? 2 : 0;
 395
 396         dcss_scaler_write(ch,
 397                           ((val << CHR_BIT_DEPTH_POS) & CHR_BIT_DEPTH_MASK) |
 398                           ((val << LUM_BIT_DEPTH_POS) & LUM_BIT_DEPTH_MASK),
 399                           DCSS_SCALER_BIT_DEPTH);
 400 }
 401
 402 enum buffer_format {
 403         BUF_FMT_YUV420,
 404         BUF_FMT_YUV422,
 405         BUF_FMT_ARGB8888_YUV444,
 406 };
 407
 408 enum chroma_location {
 409         PSC_LOC_HORZ_0_VERT_1_OVER_4 = 0,
 410         PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_4 = 1,
 411         PSC_LOC_HORZ_0_VERT_0 = 2,
 412         PSC_LOC_HORZ_1_OVER_4_VERT_0 = 3,
 413         PSC_LOC_HORZ_0_VERT_1_OVER_2 = 4,
 414         PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_2 = 5
 415 };
 416
 417 static void dcss_scaler_format_set(struct dcss_scaler_ch *ch,
 418                                    enum buffer_format src_fmt,
 419                                    enum buffer_format dst_fmt)
 420 {
 421         dcss_scaler_write(ch, src_fmt, DCSS_SCALER_SRC_FORMAT);
 422         dcss_scaler_write(ch, dst_fmt, DCSS_SCALER_DST_FORMAT);
 423 }
 424
 425 static void dcss_scaler_res_set(struct dcss_scaler_ch *ch,
 426                                 int src_xres, int src_yres,
 427                                 int dst_xres, int dst_yres,
 428                                 u32 pix_format, enum buffer_format dst_format)
 429 {
 430         u32 lsrc_xres, lsrc_yres, csrc_xres, csrc_yres;
 431         u32 ldst_xres, ldst_yres, cdst_xres, cdst_yres;
 432         bool src_is_444 = true;
 433
 434         lsrc_xres = src_xres;
 435         csrc_xres = src_xres;
 436         lsrc_yres = src_yres;
 437         csrc_yres = src_yres;
 438         ldst_xres = dst_xres;
 439         cdst_xres = dst_xres;
 440         ldst_yres = dst_yres;
 441         cdst_yres = dst_yres;
 442
 443         if (pix_format == DRM_FORMAT_UYVY || pix_format == DRM_FORMAT_VYUY ||
 444             pix_format == DRM_FORMAT_YUYV || pix_format == DRM_FORMAT_YVYU) {
 445                 csrc_xres >>= 1;
 446                 src_is_444 = false;
 447         } else if (pix_format == DRM_FORMAT_NV12 ||
 448                    pix_format == DRM_FORMAT_NV21) {
 449                 csrc_xres >>= 1;
 450                 csrc_yres >>= 1;
 451                 src_is_444 = false;
 452         }
 453
 454         if (dst_format == BUF_FMT_YUV422)
 455                 cdst_xres >>= 1;
 456
 457         /* for 4:4:4 to 4:2:2 conversion, source height should be 1 less */
 458         if (src_is_444 && dst_format == BUF_FMT_YUV422) {
 459                 lsrc_yres--;
 460                 csrc_yres--;
 461         }
 462
 463         dcss_scaler_write(ch, (((lsrc_yres - 1) << HEIGHT_POS) & HEIGHT_MASK) |
 464                                (((lsrc_xres - 1) << WIDTH_POS) & WIDTH_MASK),
 465                           DCSS_SCALER_SRC_LUM_RES);
 466         dcss_scaler_write(ch, (((csrc_yres - 1) << HEIGHT_POS) & HEIGHT_MASK) |
 467                                (((csrc_xres - 1) << WIDTH_POS) & WIDTH_MASK),
 468                           DCSS_SCALER_SRC_CHR_RES);
 469         dcss_scaler_write(ch, (((ldst_yres - 1) << HEIGHT_POS) & HEIGHT_MASK) |
 470                                (((ldst_xres - 1) << WIDTH_POS) & WIDTH_MASK),
 471                           DCSS_SCALER_DST_LUM_RES);
 472         dcss_scaler_write(ch, (((cdst_yres - 1) << HEIGHT_POS) & HEIGHT_MASK) |
 473                                (((cdst_xres - 1) << WIDTH_POS) & WIDTH_MASK),
 474                           DCSS_SCALER_DST_CHR_RES);
 475 }
 476
 477 #define downscale_fp(factor, fp_pos)            ((factor) << (fp_pos))
 478 #define upscale_fp(factor, fp_pos)              ((1 << (fp_pos)) / (factor))
 479
 480 struct dcss_scaler_factors {
 481         int downscale;
 482         int upscale;
 483 };
 484
 485 static const struct dcss_scaler_factors dcss_scaler_factors[] = {
 486         {3, 8}, {5, 8}, {5, 8},
 487 };
 488
 489 static void dcss_scaler_fractions_set(struct dcss_scaler_ch *ch,
 490                                       int src_xres, int src_yres,
 491                                       int dst_xres, int dst_yres,
 492                                       u32 src_format, u32 dst_format,
 493                                       enum chroma_location src_chroma_loc)
 494 {
 495         int src_c_xres, src_c_yres, dst_c_xres, dst_c_yres;
 496         u32 l_vinc, l_hinc, c_vinc, c_hinc;
 497         u32 c_vstart, c_hstart;
 498
 499         src_c_xres = src_xres;
 500         src_c_yres = src_yres;
 501         dst_c_xres = dst_xres;
 502         dst_c_yres = dst_yres;
 503
 504         c_vstart = 0;
 505         c_hstart = 0;
 506
 507         /* adjustments for source chroma location */
 508         if (src_format == BUF_FMT_YUV420) {
 509                 /* vertical input chroma position adjustment */
 510                 switch (src_chroma_loc) {
 511                 case PSC_LOC_HORZ_0_VERT_1_OVER_4:
 512                 case PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_4:
 513                         /*
 514                          * move chroma up to first luma line
 515                          * (1/4 chroma input line spacing)
 516                          */
 517                         c_vstart -= (1 << (PSC_PHASE_FRACTION_BITS - 2));
 518                         break;
 519                 case PSC_LOC_HORZ_0_VERT_1_OVER_2:
 520                 case PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_2:
 521                         /*
 522                          * move chroma up to first luma line
 523                          * (1/2 chroma input line spacing)
 524                          */
 525                         c_vstart -= (1 << (PSC_PHASE_FRACTION_BITS - 1));
 526                         break;
 527                 default:
 528                         break;
 529                 }
 530                 /* horizontal input chroma position adjustment */
 531                 switch (src_chroma_loc) {
 532                 case PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_4:
 533                 case PSC_LOC_HORZ_1_OVER_4_VERT_0:
 534                 case PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_2:
 535                         /* move chroma left 1/4 chroma input sample spacing */
 536                         c_hstart -= (1 << (PSC_PHASE_FRACTION_BITS - 2));
 537                         break;
 538                 default:
 539                         break;
 540                 }
 541         }
 542
 543         /* adjustments to chroma resolution */
 544         if (src_format == BUF_FMT_YUV420) {
 545                 src_c_xres >>= 1;
 546                 src_c_yres >>= 1;
 547         } else if (src_format == BUF_FMT_YUV422) {
 548                 src_c_xres >>= 1;
 549         }
 550
 551         if (dst_format == BUF_FMT_YUV422)
 552                 dst_c_xres >>= 1;
 553
 554         l_vinc = ((src_yres << 13) + (dst_yres >> 1)) / dst_yres;
 555         c_vinc = ((src_c_yres << 13) + (dst_c_yres >> 1)) / dst_c_yres;
 556         l_hinc = ((src_xres << 13) + (dst_xres >> 1)) / dst_xres;
 557         c_hinc = ((src_c_xres << 13) + (dst_c_xres >> 1)) / dst_c_xres;
 558
 559         /* save chroma start phase */
 560         ch->c_vstart = c_vstart;
 561         ch->c_hstart = c_hstart;
 562
 563         dcss_scaler_write(ch, 0, DCSS_SCALER_V_LUM_START);
 564         dcss_scaler_write(ch, l_vinc, DCSS_SCALER_V_LUM_INC);
 565
 566         dcss_scaler_write(ch, 0, DCSS_SCALER_H_LUM_START);
 567         dcss_scaler_write(ch, l_hinc, DCSS_SCALER_H_LUM_INC);
 568
 569         dcss_scaler_write(ch, c_vstart, DCSS_SCALER_V_CHR_START);
 570         dcss_scaler_write(ch, c_vinc, DCSS_SCALER_V_CHR_INC);
 571
 572         dcss_scaler_write(ch, c_hstart, DCSS_SCALER_H_CHR_START);
 573         dcss_scaler_write(ch, c_hinc, DCSS_SCALER_H_CHR_INC);
 574 }
 575
 576 int dcss_scaler_get_min_max_ratios(struct dcss_scaler *scl, int ch_num,
 577                                    int *min, int *max)
 578 {
 579         *min = upscale_fp(dcss_scaler_factors[ch_num].upscale, 16);
 580         *max = downscale_fp(dcss_scaler_factors[ch_num].downscale, 16);
 581
 582         return 0;
 583 }
 584
 585 static void dcss_scaler_program_5_coef_set(struct dcss_scaler_ch *ch,
 586                                            int base_addr,
 587                                            int coef[][PSC_NUM_TAPS])
 588 {
 589         int i, phase;
 590
 591         for (i = 0; i < PSC_STORED_PHASES; i++) {
 592                 dcss_scaler_write(ch, ((coef[i][1] & 0xfff) << 16 |
 593                                        (coef[i][2] & 0xfff) << 4  |
 594                                        (coef[i][3] & 0xf00) >> 8),
 595                                   base_addr + i * sizeof(u32));
 596                 dcss_scaler_write(ch, ((coef[i][3] & 0x0ff) << 20 |
 597                                        (coef[i][4] & 0xfff) << 8  |
 598                                        (coef[i][5] & 0xff0) >> 4),
 599                                   base_addr + 0x40 + i * sizeof(u32));
 600                 dcss_scaler_write(ch, ((coef[i][5] & 0x00f) << 24),
 601                                   base_addr + 0x80 + i * sizeof(u32));
 602         }
 603
 604         /* reverse both phase and tap orderings */
 605         for (phase = (PSC_NUM_PHASES >> 1) - 1;
 606                         i < PSC_NUM_PHASES; i++, phase--) {
 607                 dcss_scaler_write(ch, ((coef[phase][5] & 0xfff) << 16 |
 608                                        (coef[phase][4] & 0xfff) << 4  |
 609                                        (coef[phase][3] & 0xf00) >> 8),
 610                                   base_addr + i * sizeof(u32));
 611                 dcss_scaler_write(ch, ((coef[phase][3] & 0x0ff) << 20 |
 612                                        (coef[phase][2] & 0xfff) << 8  |
 613                                        (coef[phase][1] & 0xff0) >> 4),
 614                                   base_addr + 0x40 + i * sizeof(u32));
 615                 dcss_scaler_write(ch, ((coef[phase][1] & 0x00f) << 24),
 616                                   base_addr + 0x80 + i * sizeof(u32));
 617         }
 618 }
 619
 620 static void dcss_scaler_program_7_coef_set(struct dcss_scaler_ch *ch,
 621                                            int base_addr,
 622                                            int coef[][PSC_NUM_TAPS])
 623 {
 624         int i, phase;
 625
 626         for (i = 0; i < PSC_STORED_PHASES; i++) {
 627                 dcss_scaler_write(ch, ((coef[i][0] & 0xfff) << 16 |
 628                                        (coef[i][1] & 0xfff) << 4  |
 629                                        (coef[i][2] & 0xf00) >> 8),
 630                                   base_addr + i * sizeof(u32));
 631                 dcss_scaler_write(ch, ((coef[i][2] & 0x0ff) << 20 |
 632                                        (coef[i][3] & 0xfff) << 8  |
 633                                        (coef[i][4] & 0xff0) >> 4),
 634                                   base_addr + 0x40 + i * sizeof(u32));
 635                 dcss_scaler_write(ch, ((coef[i][4] & 0x00f) << 24 |
 636                                        (coef[i][5] & 0xfff) << 12 |
 637                                        (coef[i][6] & 0xfff)),
 638                                   base_addr + 0x80 + i * sizeof(u32));
 639         }
 640
 641         /* reverse both phase and tap orderings */
 642         for (phase = (PSC_NUM_PHASES >> 1) - 1;
 643                         i < PSC_NUM_PHASES; i++, phase--) {
 644                 dcss_scaler_write(ch, ((coef[phase][6] & 0xfff) << 16 |
 645                                        (coef[phase][5] & 0xfff) << 4  |
 646                                        (coef[phase][4] & 0xf00) >> 8),
 647                                   base_addr + i * sizeof(u32));
 648                 dcss_scaler_write(ch, ((coef[phase][4] & 0x0ff) << 20 |
 649                                        (coef[phase][3] & 0xfff) << 8  |
 650                                        (coef[phase][2] & 0xff0) >> 4),
 651                                   base_addr + 0x40 + i * sizeof(u32));
 652                 dcss_scaler_write(ch, ((coef[phase][2] & 0x00f) << 24 |
 653                                        (coef[phase][1] & 0xfff) << 12 |
 654                                        (coef[phase][0] & 0xfff)),
 655                                   base_addr + 0x80 + i * sizeof(u32));
 656         }
 657 }
 658
 659 static void dcss_scaler_yuv_coef_set(struct dcss_scaler_ch *ch,
 660                                      enum buffer_format src_format,
 661                                      enum buffer_format dst_format,
 662                                      bool use_5_taps,
 663                                      int src_xres, int src_yres, int dst_xres,
 664                                      int dst_yres)
 665 {
 666         int coef[PSC_STORED_PHASES][PSC_NUM_TAPS];
 667         bool program_5_taps = use_5_taps ||
 668                               (dst_format == BUF_FMT_YUV422 &&
 669                                src_format == BUF_FMT_ARGB8888_YUV444);
 670
 671         /* horizontal luma */
 672         dcss_scaler_filter_design(src_xres, dst_xres, false,
 673                                   src_xres == dst_xres, coef,
 674                                   ch->use_nn_interpolation);
 675         dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_HLUM, coef);
 676
 677         /* vertical luma */
 678         dcss_scaler_filter_design(src_yres, dst_yres, program_5_taps,
 679                                   src_yres == dst_yres, coef,
 680                                   ch->use_nn_interpolation);
 681
 682         if (program_5_taps)
 683                 dcss_scaler_program_5_coef_set(ch, DCSS_SCALER_COEF_VLUM, coef);
 684         else
 685                 dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_VLUM, coef);
 686
 687         /* adjust chroma resolution */
 688         if (src_format != BUF_FMT_ARGB8888_YUV444)
 689                 src_xres >>= 1;
 690         if (src_format == BUF_FMT_YUV420)
 691                 src_yres >>= 1;
 692         if (dst_format != BUF_FMT_ARGB8888_YUV444)
 693                 dst_xres >>= 1;
 694         if (dst_format == BUF_FMT_YUV420) /* should not happen */
 695                 dst_yres >>= 1;
 696
 697         /* horizontal chroma */
 698         dcss_scaler_filter_design(src_xres, dst_xres, false,
 699                                   (src_xres == dst_xres) && (ch->c_hstart == 0),
 700                                   coef, ch->use_nn_interpolation);
 701
 702         dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_HCHR, coef);
 703
 704         /* vertical chroma */
 705         dcss_scaler_filter_design(src_yres, dst_yres, program_5_taps,
 706                                   (src_yres == dst_yres) && (ch->c_vstart == 0),
 707                                   coef, ch->use_nn_interpolation);
 708         if (program_5_taps)
 709                 dcss_scaler_program_5_coef_set(ch, DCSS_SCALER_COEF_VCHR, coef);
 710         else
 711                 dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_VCHR, coef);
 712 }
 713
 714 static void dcss_scaler_rgb_coef_set(struct dcss_scaler_ch *ch,
 715                                      int src_xres, int src_yres, int dst_xres,
 716                                      int dst_yres)
 717 {
 718         int coef[PSC_STORED_PHASES][PSC_NUM_TAPS];
 719
 720         /* horizontal RGB */
 721         dcss_scaler_filter_design(src_xres, dst_xres, false,
 722                                   src_xres == dst_xres, coef,
 723                                   ch->use_nn_interpolation);
 724         dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_HLUM, coef);
 725
 726         /* vertical RGB */
 727         dcss_scaler_filter_design(src_yres, dst_yres, false,
 728                                   src_yres == dst_yres, coef,
 729                                   ch->use_nn_interpolation);
 730         dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_VLUM, coef);
 731 }
 732
 733 static void dcss_scaler_set_rgb10_order(struct dcss_scaler_ch *ch,
 734                                         const struct drm_format_info *format)
 735 {
 736         u32 a2r10g10b10_format;
 737
 738         if (format->is_yuv)
 739                 return;
 740
 741         ch->sdata_ctrl &= ~A2R10G10B10_FORMAT_MASK;
 742
 743         if (format->depth != 30)
 744                 return;
 745
 746         switch (format->format) {
 747         case DRM_FORMAT_ARGB2101010:
 748         case DRM_FORMAT_XRGB2101010:
 749                 a2r10g10b10_format = 0;
 750                 break;
 751
 752         case DRM_FORMAT_ABGR2101010:
 753         case DRM_FORMAT_XBGR2101010:
 754                 a2r10g10b10_format = 5;
 755                 break;
 756
 757         case DRM_FORMAT_RGBA1010102:
 758         case DRM_FORMAT_RGBX1010102:
 759                 a2r10g10b10_format = 6;
 760                 break;
 761
 762         case DRM_FORMAT_BGRA1010102:
 763         case DRM_FORMAT_BGRX1010102:
 764                 a2r10g10b10_format = 11;
 765                 break;
 766
 767         default:
 768                 a2r10g10b10_format = 0;
 769                 break;
 770         }
 771
 772         ch->sdata_ctrl |= a2r10g10b10_format << A2R10G10B10_FORMAT_POS;
 773 }
 774
 775 void dcss_scaler_set_filter(struct dcss_scaler *scl, int ch_num,
 776                             enum drm_scaling_filter scaling_filter)
 777 {
 778         struct dcss_scaler_ch *ch = &scl->ch[ch_num];
 779
 780         ch->use_nn_interpolation = scaling_filter == DRM_SCALING_FILTER_NEAREST_NEIGHBOR;
 781 }
 782
 783 void dcss_scaler_setup(struct dcss_scaler *scl, int ch_num,
 784                        const struct drm_format_info *format,
 785                        int src_xres, int src_yres, int dst_xres, int dst_yres,
 786                        u32 vrefresh_hz)
 787 {
 788         struct dcss_scaler_ch *ch = &scl->ch[ch_num];
 789         unsigned int pixel_depth = 0;
 790         bool rtr_8line_en = false;
 791         bool use_5_taps = false;
 792         enum buffer_format src_format = BUF_FMT_ARGB8888_YUV444;
 793         enum buffer_format dst_format = BUF_FMT_ARGB8888_YUV444;
 794         u32 pix_format = format->format;
 795
 796         if (format->is_yuv) {
 797                 dcss_scaler_yuv_enable(ch, true);
 798
 799                 if (pix_format == DRM_FORMAT_NV12 ||
 800                     pix_format == DRM_FORMAT_NV21) {
 801                         rtr_8line_en = true;
 802                         src_format = BUF_FMT_YUV420;
 803                 } else if (pix_format == DRM_FORMAT_UYVY ||
 804                            pix_format == DRM_FORMAT_VYUY ||
 805                            pix_format == DRM_FORMAT_YUYV ||
 806                            pix_format == DRM_FORMAT_YVYU) {
 807                         src_format = BUF_FMT_YUV422;
 808                 }
 809
 810                 use_5_taps = !rtr_8line_en;
 811         } else {
 812                 dcss_scaler_yuv_enable(ch, false);
 813
 814                 pixel_depth = format->depth;
 815         }
 816
 817         dcss_scaler_fractions_set(ch, src_xres, src_yres, dst_xres,
 818                                   dst_yres, src_format, dst_format,
 819                                   PSC_LOC_HORZ_0_VERT_1_OVER_4);
 820
 821         if (format->is_yuv)
 822                 dcss_scaler_yuv_coef_set(ch, src_format, dst_format,
 823                                          use_5_taps, src_xres, src_yres,
 824                                          dst_xres, dst_yres);
 825         else
 826                 dcss_scaler_rgb_coef_set(ch, src_xres, src_yres,
 827                                          dst_xres, dst_yres);
 828
 829         dcss_scaler_rtr_8lines_enable(ch, rtr_8line_en);
 830         dcss_scaler_bit_depth_set(ch, pixel_depth);
 831         dcss_scaler_set_rgb10_order(ch, format);
 832         dcss_scaler_format_set(ch, src_format, dst_format);
 833         dcss_scaler_res_set(ch, src_xres, src_yres, dst_xres, dst_yres,
 834                             pix_format, dst_format);
 835 }
 836
 837 /* This function will be called from interrupt context. */
 838 void dcss_scaler_write_sclctrl(struct dcss_scaler *scl)
 839 {
 840         int chnum;
 841
 842         dcss_ctxld_assert_locked(scl->ctxld);
 843
 844         for (chnum = 0; chnum < 3; chnum++) {
 845                 struct dcss_scaler_ch *ch = &scl->ch[chnum];
 846
 847                 if (ch->scaler_ctrl_chgd) {
 848                         dcss_ctxld_write_irqsafe(scl->ctxld, scl->ctx_id,
 849                                                  ch->scaler_ctrl,
 850                                                  ch->base_ofs +
 851                                                  DCSS_SCALER_CTRL);
 852                         ch->scaler_ctrl_chgd = false;
 853                 }
 854         }
 855 }