Quelle  dcss-scaler.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright 2019 NXP.
 *
 * Scaling algorithms were contributed by Dzung Hoang <dzung.hoang@nxp.com>
 */

#include <linux/device.h>
#include <linux/slab.h>

#include "dcss-dev.h"

#define DCSS_SCALER_CTRL   0x00
#define   SCALER_EN    BIT(0)
#define   REPEAT_EN    BIT(4)
#define   SCALE2MEM_EN    BIT(8)
#define   MEM2OFIFO_EN    BIT(12)
#define DCSS_SCALER_OFIFO_CTRL   0x04
#define   OFIFO_LOW_THRES_POS   0
#define   OFIFO_LOW_THRES_MASK   GENMASK(9, 0)
#define   OFIFO_HIGH_THRES_POS   16
#define   OFIFO_HIGH_THRES_MASK   GENMASK(25, 16)
#define   UNDERRUN_DETECT_CLR   BIT(26)
#define   LOW_THRES_DETECT_CLR   BIT(27)
#define   HIGH_THRES_DETECT_CLR   BIT(28)
#define   UNDERRUN_DETECT_EN   BIT(29)
#define   LOW_THRES_DETECT_EN   BIT(30)
#define   HIGH_THRES_DETECT_EN   BIT(31)
#define DCSS_SCALER_SDATA_CTRL   0x08
#define   YUV_EN    BIT(0)
#define   RTRAM_8LINES    BIT(1)
#define   Y_UV_BYTE_SWAP   BIT(4)
#define   A2R10G10B10_FORMAT_POS  8
#define   A2R10G10B10_FORMAT_MASK  GENMASK(11, 8)
#define DCSS_SCALER_BIT_DEPTH   0x0C
#define   LUM_BIT_DEPTH_POS   0
#define   LUM_BIT_DEPTH_MASK   GENMASK(1, 0)
#define   CHR_BIT_DEPTH_POS   4
#define   CHR_BIT_DEPTH_MASK   GENMASK(5, 4)
#define DCSS_SCALER_SRC_FORMAT   0x10
#define DCSS_SCALER_DST_FORMAT   0x14
#define   FORMAT_MASK    GENMASK(1, 0)
#define DCSS_SCALER_SRC_LUM_RES   0x18
#define DCSS_SCALER_SRC_CHR_RES   0x1C
#define DCSS_SCALER_DST_LUM_RES   0x20
#define DCSS_SCALER_DST_CHR_RES   0x24
#define   WIDTH_POS    0
#define   WIDTH_MASK    GENMASK(11, 0)
#define   HEIGHT_POS    16
#define   HEIGHT_MASK    GENMASK(27, 16)
#define DCSS_SCALER_V_LUM_START   0x48
#define   V_START_MASK    GENMASK(15, 0)
#define DCSS_SCALER_V_LUM_INC   0x4C
#define   V_INC_MASK    GENMASK(15, 0)
#define DCSS_SCALER_H_LUM_START   0x50
#define   H_START_MASK    GENMASK(18, 0)
#define DCSS_SCALER_H_LUM_INC   0x54
#define   H_INC_MASK    GENMASK(15, 0)
#define DCSS_SCALER_V_CHR_START   0x58
#define DCSS_SCALER_V_CHR_INC   0x5C
#define DCSS_SCALER_H_CHR_START   0x60
#define DCSS_SCALER_H_CHR_INC   0x64
#define DCSS_SCALER_COEF_VLUM   0x80
#define DCSS_SCALER_COEF_HLUM   0x140
#define DCSS_SCALER_COEF_VCHR   0x200
#define DCSS_SCALER_COEF_HCHR   0x300

struct dcss_scaler_ch {
 void __iomem *base_reg;
 u32 base_ofs;
 struct dcss_scaler *scl;

 u32 sdata_ctrl;
 u32 scaler_ctrl;

 bool scaler_ctrl_chgd;

 u32 c_vstart;
 u32 c_hstart;

 bool use_nn_interpolation;
};

struct dcss_scaler {
 struct device *dev;

 struct dcss_ctxld *ctxld;
 u32 ctx_id;

 struct dcss_scaler_ch ch[3];
};

/* scaler coefficients generator */
#define PSC_FRAC_BITS 30
#define PSC_FRAC_SCALE BIT(PSC_FRAC_BITS)
#define PSC_BITS_FOR_PHASE 4
#define PSC_NUM_PHASES 16
#define PSC_STORED_PHASES (PSC_NUM_PHASES / 2 + 1)
#define PSC_NUM_TAPS 7
#define PSC_NUM_TAPS_RGBA 5
#define PSC_COEFF_PRECISION 10
#define PSC_PHASE_FRACTION_BITS 13
#define PSC_PHASE_MASK (PSC_NUM_PHASES - 1)
#define PSC_Q_FRACTION 19
#define PSC_Q_ROUND_OFFSET (1 << (PSC_Q_FRACTION - 1))

/**
 * mult_q() - Performs fixed-point multiplication.
 * @A: multiplier
 * @B: multiplicand
 */
static int mult_q(int A, int B)
{
 int result;
 s64 temp;

 temp = (int64_t)A * (int64_t)B;
 temp += PSC_Q_ROUND_OFFSET;
 result = (int)(temp >> PSC_Q_FRACTION);
 return result;
}

/**
 * div_q() - Performs fixed-point division.
 * @A: dividend
 * @B: divisor
 */
static int div_q(int A, int B)
{
 int result;
 s64 temp;

 temp = (int64_t)A << PSC_Q_FRACTION;
 if ((temp >= 0 && B >= 0) || (temp < 0 && B < 0))
  temp += B / 2;
 else
  temp -= B / 2;

 result = div_s64(temp, B);
 return result;
}

/**
 * exp_approx_q() - Compute approximation to exp(x) function using Taylor
 *     series.
 * @x: fixed-point argument of exp function
 */
static int exp_approx_q(int x)
{
 int sum = 1 << PSC_Q_FRACTION;
 int term = 1 << PSC_Q_FRACTION;

 term = mult_q(term, div_q(x, 1 << PSC_Q_FRACTION));
 sum += term;
 term = mult_q(term, div_q(x, 2 << PSC_Q_FRACTION));
 sum += term;
 term = mult_q(term, div_q(x, 3 << PSC_Q_FRACTION));
 sum += term;
 term = mult_q(term, div_q(x, 4 << PSC_Q_FRACTION));
 sum += term;

 return sum;
}

/**
 * dcss_scaler_gaussian_filter() - Generate gaussian prototype filter.
 * @fc_q: fixed-point cutoff frequency normalized to range [0, 1]
 * @use_5_taps: indicates whether to use 5 taps or 7 taps
 * @coef: output filter coefficients
 */
static void dcss_scaler_gaussian_filter(int fc_q, bool use_5_taps,
     bool phase0_identity,
     int coef[][PSC_NUM_TAPS])
{
 int sigma_q, g0_q, g1_q, g2_q;
 int tap_cnt1, tap_cnt2, tap_idx, phase_cnt;
 int mid;
 int phase;
 int i;
 int taps;

 if (use_5_taps)
  for (phase = 0; phase < PSC_STORED_PHASES; phase++) {
   coef[phase][0] = 0;
   coef[phase][PSC_NUM_TAPS - 1] = 0;
  }

 /* seed coefficient scanner */
 taps = use_5_taps ? PSC_NUM_TAPS_RGBA : PSC_NUM_TAPS;
 mid = (PSC_NUM_PHASES * taps) / 2 - 1;
 phase_cnt = (PSC_NUM_PHASES * (PSC_NUM_TAPS + 1)) / 2;
 tap_cnt1 = (PSC_NUM_PHASES * PSC_NUM_TAPS) / 2;
 tap_cnt2 = (PSC_NUM_PHASES * PSC_NUM_TAPS) / 2;

 /* seed gaussian filter generator */
 sigma_q = div_q(PSC_Q_ROUND_OFFSET, fc_q);
 g0_q = 1 << PSC_Q_FRACTION;
 g1_q = exp_approx_q(div_q(-PSC_Q_ROUND_OFFSET,
      mult_q(sigma_q, sigma_q)));
 g2_q = mult_q(g1_q, g1_q);
 coef[phase_cnt & PSC_PHASE_MASK][tap_cnt1 >> PSC_BITS_FOR_PHASE] = g0_q;

 for (i = 0; i < mid; i++) {
  phase_cnt++;
  tap_cnt1--;
  tap_cnt2++;

  g0_q = mult_q(g0_q, g1_q);
  g1_q = mult_q(g1_q, g2_q);

  if ((phase_cnt & PSC_PHASE_MASK) <= 8) {
   tap_idx = tap_cnt1 >> PSC_BITS_FOR_PHASE;
   coef[phase_cnt & PSC_PHASE_MASK][tap_idx] = g0_q;
  }
  if (((-phase_cnt) & PSC_PHASE_MASK) <= 8) {
   tap_idx = tap_cnt2 >> PSC_BITS_FOR_PHASE;
   coef[(-phase_cnt) & PSC_PHASE_MASK][tap_idx] = g0_q;
  }
 }

 phase_cnt++;
 tap_cnt1--;
 coef[phase_cnt & PSC_PHASE_MASK][tap_cnt1 >> PSC_BITS_FOR_PHASE] = 0;

 /* override phase 0 with identity filter if specified */
 if (phase0_identity)
  for (i = 0; i < PSC_NUM_TAPS; i++)
   coef[0][i] = i == (PSC_NUM_TAPS >> 1) ?
      (1 << PSC_COEFF_PRECISION) : 0;

 /* normalize coef */
 for (phase = 0; phase < PSC_STORED_PHASES; phase++) {
  int sum = 0;
  s64 ll_temp;

  for (i = 0; i < PSC_NUM_TAPS; i++)
   sum += coef[phase][i];
  for (i = 0; i < PSC_NUM_TAPS; i++) {
   ll_temp = coef[phase][i];
   ll_temp <<= PSC_COEFF_PRECISION;
   ll_temp += sum >> 1;
   ll_temp = div_s64(ll_temp, sum);
   coef[phase][i] = (int)ll_temp;
  }
 }
}

static void dcss_scaler_nearest_neighbor_filter(bool use_5_taps,
      int coef[][PSC_NUM_TAPS])
{
 int i, j;

 for (i = 0; i < PSC_STORED_PHASES; i++)
  for (j = 0; j < PSC_NUM_TAPS; j++)
   coef[i][j] = j == PSC_NUM_TAPS >> 1 ?
      (1 << PSC_COEFF_PRECISION) : 0;
}

/**
 * dcss_scaler_filter_design() - Compute filter coefficients using
 *  Gaussian filter.
 * @src_length: length of input
 * @dst_length: length of output
 * @use_5_taps: 0 for 7 taps per phase, 1 for 5 taps
 * @coef: output coefficients
 */
static void dcss_scaler_filter_design(int src_length, int dst_length,
          bool use_5_taps, bool phase0_identity,
          int coef[][PSC_NUM_TAPS],
          bool nn_interpolation)
{
 int fc_q;

 /* compute cutoff frequency */
 if (dst_length >= src_length)
  fc_q = div_q(1, PSC_NUM_PHASES);
 else
  fc_q = div_q(dst_length, src_length * PSC_NUM_PHASES);

 if (nn_interpolation)
  dcss_scaler_nearest_neighbor_filter(use_5_taps, coef);
 else
  /* compute gaussian filter coefficients */
  dcss_scaler_gaussian_filter(fc_q, use_5_taps, phase0_identity, coef);
}

static void dcss_scaler_write(struct dcss_scaler_ch *ch, u32 val, u32 ofs)
{
 struct dcss_scaler *scl = ch->scl;

 dcss_ctxld_write(scl->ctxld, scl->ctx_id, val, ch->base_ofs + ofs);
}

static int dcss_scaler_ch_init_all(struct dcss_scaler *scl,
       unsigned long scaler_base)
{
 struct dcss_scaler_ch *ch;
 int i;

 for (i = 0; i < 3; i++) {
  ch = &scl->ch[i];

  ch->base_ofs = scaler_base + i * 0x400;

  ch->base_reg = devm_ioremap(scl->dev, ch->base_ofs, SZ_4K);
  if (!ch->base_reg) {
   dev_err(scl->dev, "scaler: unable to remap ch base\n");
   return -ENOMEM;
  }

  ch->scl = scl;
 }

 return 0;
}

int dcss_scaler_init(struct dcss_dev *dcss, unsigned long scaler_base)
{
 struct dcss_scaler *scaler;

 scaler = devm_kzalloc(dcss->dev, sizeof(*scaler), GFP_KERNEL);
 if (!scaler)
  return -ENOMEM;

 dcss->scaler = scaler;
 scaler->dev = dcss->dev;
 scaler->ctxld = dcss->ctxld;
 scaler->ctx_id = CTX_SB_HP;

 if (dcss_scaler_ch_init_all(scaler, scaler_base))
  return -ENOMEM;

 return 0;
}

void dcss_scaler_exit(struct dcss_scaler *scl)
{
 int ch_no;

 for (ch_no = 0; ch_no < 3; ch_no++) {
  struct dcss_scaler_ch *ch = &scl->ch[ch_no];

  dcss_writel(0, ch->base_reg + DCSS_SCALER_CTRL);
 }
}

void dcss_scaler_ch_enable(struct dcss_scaler *scl, int ch_num, bool en)
{
 struct dcss_scaler_ch *ch = &scl->ch[ch_num];
 u32 scaler_ctrl;

 scaler_ctrl = en ? SCALER_EN | REPEAT_EN : 0;

 if (en)
  dcss_scaler_write(ch, ch->sdata_ctrl, DCSS_SCALER_SDATA_CTRL);

 if (ch->scaler_ctrl != scaler_ctrl)
  ch->scaler_ctrl_chgd = true;

 ch->scaler_ctrl = scaler_ctrl;
}

static void dcss_scaler_yuv_enable(struct dcss_scaler_ch *ch, bool en)
{
 ch->sdata_ctrl &= ~YUV_EN;
 ch->sdata_ctrl |= en ? YUV_EN : 0;
}

static void dcss_scaler_rtr_8lines_enable(struct dcss_scaler_ch *ch, bool en)
{
 ch->sdata_ctrl &= ~RTRAM_8LINES;
 ch->sdata_ctrl |= en ? RTRAM_8LINES : 0;
}

static void dcss_scaler_bit_depth_set(struct dcss_scaler_ch *ch, int depth)
{
 u32 val;

 val = depth == 30 ? 2 : 0;

 dcss_scaler_write(ch,
     ((val << CHR_BIT_DEPTH_POS) & CHR_BIT_DEPTH_MASK) |
     ((val << LUM_BIT_DEPTH_POS) & LUM_BIT_DEPTH_MASK),
     DCSS_SCALER_BIT_DEPTH);
}

enum buffer_format {
 BUF_FMT_YUV420,
 BUF_FMT_YUV422,
 BUF_FMT_ARGB8888_YUV444,
};

enum chroma_location {
 PSC_LOC_HORZ_0_VERT_1_OVER_4 = 0,
 PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_4 = 1,
 PSC_LOC_HORZ_0_VERT_0 = 2,
 PSC_LOC_HORZ_1_OVER_4_VERT_0 = 3,
 PSC_LOC_HORZ_0_VERT_1_OVER_2 = 4,
 PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_2 = 5
};

static void dcss_scaler_format_set(struct dcss_scaler_ch *ch,
       enum buffer_format src_fmt,
       enum buffer_format dst_fmt)
{
 dcss_scaler_write(ch, src_fmt, DCSS_SCALER_SRC_FORMAT);
 dcss_scaler_write(ch, dst_fmt, DCSS_SCALER_DST_FORMAT);
}

static void dcss_scaler_res_set(struct dcss_scaler_ch *ch,
    int src_xres, int src_yres,
    int dst_xres, int dst_yres,
    u32 pix_format, enum buffer_format dst_format)
{
 u32 lsrc_xres, lsrc_yres, csrc_xres, csrc_yres;
 u32 ldst_xres, ldst_yres, cdst_xres, cdst_yres;
 bool src_is_444 = true;

 lsrc_xres = src_xres;
 csrc_xres = src_xres;
 lsrc_yres = src_yres;
 csrc_yres = src_yres;
 ldst_xres = dst_xres;
 cdst_xres = dst_xres;
 ldst_yres = dst_yres;
 cdst_yres = dst_yres;

 if (pix_format == DRM_FORMAT_UYVY || pix_format == DRM_FORMAT_VYUY ||
     pix_format == DRM_FORMAT_YUYV || pix_format == DRM_FORMAT_YVYU) {
  csrc_xres >>= 1;
  src_is_444 = false;
 } else if (pix_format == DRM_FORMAT_NV12 ||
     pix_format == DRM_FORMAT_NV21) {
  csrc_xres >>= 1;
  csrc_yres >>= 1;
  src_is_444 = false;
 }

 if (dst_format == BUF_FMT_YUV422)
  cdst_xres >>= 1;

 /* for 4:4:4 to 4:2:2 conversion, source height should be 1 less */
 if (src_is_444 && dst_format == BUF_FMT_YUV422) {
  lsrc_yres--;
  csrc_yres--;
 }

 dcss_scaler_write(ch, (((lsrc_yres - 1) << HEIGHT_POS) & HEIGHT_MASK) |
          (((lsrc_xres - 1) << WIDTH_POS) & WIDTH_MASK),
     DCSS_SCALER_SRC_LUM_RES);
 dcss_scaler_write(ch, (((csrc_yres - 1) << HEIGHT_POS) & HEIGHT_MASK) |
          (((csrc_xres - 1) << WIDTH_POS) & WIDTH_MASK),
     DCSS_SCALER_SRC_CHR_RES);
 dcss_scaler_write(ch, (((ldst_yres - 1) << HEIGHT_POS) & HEIGHT_MASK) |
          (((ldst_xres - 1) << WIDTH_POS) & WIDTH_MASK),
     DCSS_SCALER_DST_LUM_RES);
 dcss_scaler_write(ch, (((cdst_yres - 1) << HEIGHT_POS) & HEIGHT_MASK) |
          (((cdst_xres - 1) << WIDTH_POS) & WIDTH_MASK),
     DCSS_SCALER_DST_CHR_RES);
}

#define downscale_fp(factor, fp_pos)  ((factor) << (fp_pos))
#define upscale_fp(factor, fp_pos)  ((1 << (fp_pos)) / (factor))

struct dcss_scaler_factors {
 int downscale;
 int upscale;
};

static const struct dcss_scaler_factors dcss_scaler_factors[] = {
 {3, 8}, {5, 8}, {5, 8},
};

static void dcss_scaler_fractions_set(struct dcss_scaler_ch *ch,
          int src_xres, int src_yres,
          int dst_xres, int dst_yres,
          u32 src_format, u32 dst_format,
          enum chroma_location src_chroma_loc)
{
 int src_c_xres, src_c_yres, dst_c_xres, dst_c_yres;
 u32 l_vinc, l_hinc, c_vinc, c_hinc;
 u32 c_vstart, c_hstart;

 src_c_xres = src_xres;
 src_c_yres = src_yres;
 dst_c_xres = dst_xres;
 dst_c_yres = dst_yres;

 c_vstart = 0;
 c_hstart = 0;

 /* adjustments for source chroma location */
 if (src_format == BUF_FMT_YUV420) {
  /* vertical input chroma position adjustment */
  switch (src_chroma_loc) {
  case PSC_LOC_HORZ_0_VERT_1_OVER_4:
  case PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_4:
   /*
 * move chroma up to first luma line
 * (1/4 chroma input line spacing)
 */
   c_vstart -= (1 << (PSC_PHASE_FRACTION_BITS - 2));
   break;
  case PSC_LOC_HORZ_0_VERT_1_OVER_2:
  case PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_2:
   /*
 * move chroma up to first luma line
 * (1/2 chroma input line spacing)
 */
   c_vstart -= (1 << (PSC_PHASE_FRACTION_BITS - 1));
   break;
  default:
   break;
  }
  /* horizontal input chroma position adjustment */
  switch (src_chroma_loc) {
  case PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_4:
  case PSC_LOC_HORZ_1_OVER_4_VERT_0:
  case PSC_LOC_HORZ_1_OVER_4_VERT_1_OVER_2:
   /* move chroma left 1/4 chroma input sample spacing */
   c_hstart -= (1 << (PSC_PHASE_FRACTION_BITS - 2));
   break;
  default:
   break;
  }
 }

 /* adjustments to chroma resolution */
 if (src_format == BUF_FMT_YUV420) {
  src_c_xres >>= 1;
  src_c_yres >>= 1;
 } else if (src_format == BUF_FMT_YUV422) {
  src_c_xres >>= 1;
 }

 if (dst_format == BUF_FMT_YUV422)
  dst_c_xres >>= 1;

 l_vinc = ((src_yres << 13) + (dst_yres >> 1)) / dst_yres;
 c_vinc = ((src_c_yres << 13) + (dst_c_yres >> 1)) / dst_c_yres;
 l_hinc = ((src_xres << 13) + (dst_xres >> 1)) / dst_xres;
 c_hinc = ((src_c_xres << 13) + (dst_c_xres >> 1)) / dst_c_xres;

 /* save chroma start phase */
 ch->c_vstart = c_vstart;
 ch->c_hstart = c_hstart;

 dcss_scaler_write(ch, 0, DCSS_SCALER_V_LUM_START);
 dcss_scaler_write(ch, l_vinc, DCSS_SCALER_V_LUM_INC);

 dcss_scaler_write(ch, 0, DCSS_SCALER_H_LUM_START);
 dcss_scaler_write(ch, l_hinc, DCSS_SCALER_H_LUM_INC);

 dcss_scaler_write(ch, c_vstart, DCSS_SCALER_V_CHR_START);
 dcss_scaler_write(ch, c_vinc, DCSS_SCALER_V_CHR_INC);

 dcss_scaler_write(ch, c_hstart, DCSS_SCALER_H_CHR_START);
 dcss_scaler_write(ch, c_hinc, DCSS_SCALER_H_CHR_INC);
}

int dcss_scaler_get_min_max_ratios(struct dcss_scaler *scl, int ch_num,
       int *min, int *max)
{
 *min = upscale_fp(dcss_scaler_factors[ch_num].upscale, 16);
 *max = downscale_fp(dcss_scaler_factors[ch_num].downscale, 16);

 return 0;
}

static void dcss_scaler_program_5_coef_set(struct dcss_scaler_ch *ch,
        int base_addr,
        int coef[][PSC_NUM_TAPS])
{
 int i, phase;

 for (i = 0; i < PSC_STORED_PHASES; i++) {
  dcss_scaler_write(ch, ((coef[i][1] & 0xfff) << 16 |
           (coef[i][2] & 0xfff) << 4  |
           (coef[i][3] & 0xf00) >> 8),
      base_addr + i * sizeof(u32));
  dcss_scaler_write(ch, ((coef[i][3] & 0x0ff) << 20 |
           (coef[i][4] & 0xfff) << 8  |
           (coef[i][5] & 0xff0) >> 4),
      base_addr + 0x40 + i * sizeof(u32));
  dcss_scaler_write(ch, ((coef[i][5] & 0x00f) << 24),
      base_addr + 0x80 + i * sizeof(u32));
 }

 /* reverse both phase and tap orderings */
 for (phase = (PSC_NUM_PHASES >> 1) - 1;
   i < PSC_NUM_PHASES; i++, phase--) {
  dcss_scaler_write(ch, ((coef[phase][5] & 0xfff) << 16 |
           (coef[phase][4] & 0xfff) << 4  |
           (coef[phase][3] & 0xf00) >> 8),
      base_addr + i * sizeof(u32));
  dcss_scaler_write(ch, ((coef[phase][3] & 0x0ff) << 20 |
           (coef[phase][2] & 0xfff) << 8  |
           (coef[phase][1] & 0xff0) >> 4),
      base_addr + 0x40 + i * sizeof(u32));
  dcss_scaler_write(ch, ((coef[phase][1] & 0x00f) << 24),
      base_addr + 0x80 + i * sizeof(u32));
 }
}

static void dcss_scaler_program_7_coef_set(struct dcss_scaler_ch *ch,
        int base_addr,
        int coef[][PSC_NUM_TAPS])
{
 int i, phase;

 for (i = 0; i < PSC_STORED_PHASES; i++) {
  dcss_scaler_write(ch, ((coef[i][0] & 0xfff) << 16 |
           (coef[i][1] & 0xfff) << 4  |
           (coef[i][2] & 0xf00) >> 8),
      base_addr + i * sizeof(u32));
  dcss_scaler_write(ch, ((coef[i][2] & 0x0ff) << 20 |
           (coef[i][3] & 0xfff) << 8  |
           (coef[i][4] & 0xff0) >> 4),
      base_addr + 0x40 + i * sizeof(u32));
  dcss_scaler_write(ch, ((coef[i][4] & 0x00f) << 24 |
           (coef[i][5] & 0xfff) << 12 |
           (coef[i][6] & 0xfff)),
      base_addr + 0x80 + i * sizeof(u32));
 }

 /* reverse both phase and tap orderings */
 for (phase = (PSC_NUM_PHASES >> 1) - 1;
   i < PSC_NUM_PHASES; i++, phase--) {
  dcss_scaler_write(ch, ((coef[phase][6] & 0xfff) << 16 |
           (coef[phase][5] & 0xfff) << 4  |
           (coef[phase][4] & 0xf00) >> 8),
      base_addr + i * sizeof(u32));
  dcss_scaler_write(ch, ((coef[phase][4] & 0x0ff) << 20 |
           (coef[phase][3] & 0xfff) << 8  |
           (coef[phase][2] & 0xff0) >> 4),
      base_addr + 0x40 + i * sizeof(u32));
  dcss_scaler_write(ch, ((coef[phase][2] & 0x00f) << 24 |
           (coef[phase][1] & 0xfff) << 12 |
           (coef[phase][0] & 0xfff)),
      base_addr + 0x80 + i * sizeof(u32));
 }
}

static void dcss_scaler_yuv_coef_set(struct dcss_scaler_ch *ch,
         enum buffer_format src_format,
         enum buffer_format dst_format,
         bool use_5_taps,
         int src_xres, int src_yres, int dst_xres,
         int dst_yres)
{
 int coef[PSC_STORED_PHASES][PSC_NUM_TAPS];
 bool program_5_taps = use_5_taps ||
         (dst_format == BUF_FMT_YUV422 &&
          src_format == BUF_FMT_ARGB8888_YUV444);

 /* horizontal luma */
 dcss_scaler_filter_design(src_xres, dst_xres, false,
      src_xres == dst_xres, coef,
      ch->use_nn_interpolation);
 dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_HLUM, coef);

 /* vertical luma */
 dcss_scaler_filter_design(src_yres, dst_yres, program_5_taps,
      src_yres == dst_yres, coef,
      ch->use_nn_interpolation);

 if (program_5_taps)
  dcss_scaler_program_5_coef_set(ch, DCSS_SCALER_COEF_VLUM, coef);
 else
  dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_VLUM, coef);

 /* adjust chroma resolution */
 if (src_format != BUF_FMT_ARGB8888_YUV444)
  src_xres >>= 1;
 if (src_format == BUF_FMT_YUV420)
  src_yres >>= 1;
 if (dst_format != BUF_FMT_ARGB8888_YUV444)
  dst_xres >>= 1;
 if (dst_format == BUF_FMT_YUV420) /* should not happen */
  dst_yres >>= 1;

 /* horizontal chroma */
 dcss_scaler_filter_design(src_xres, dst_xres, false,
      (src_xres == dst_xres) && (ch->c_hstart == 0),
      coef, ch->use_nn_interpolation);

 dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_HCHR, coef);

 /* vertical chroma */
 dcss_scaler_filter_design(src_yres, dst_yres, program_5_taps,
      (src_yres == dst_yres) && (ch->c_vstart == 0),
      coef, ch->use_nn_interpolation);
 if (program_5_taps)
  dcss_scaler_program_5_coef_set(ch, DCSS_SCALER_COEF_VCHR, coef);
 else
  dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_VCHR, coef);
}

static void dcss_scaler_rgb_coef_set(struct dcss_scaler_ch *ch,
         int src_xres, int src_yres, int dst_xres,
         int dst_yres)
{
 int coef[PSC_STORED_PHASES][PSC_NUM_TAPS];

 /* horizontal RGB */
 dcss_scaler_filter_design(src_xres, dst_xres, false,
      src_xres == dst_xres, coef,
      ch->use_nn_interpolation);
 dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_HLUM, coef);

 /* vertical RGB */
 dcss_scaler_filter_design(src_yres, dst_yres, false,
      src_yres == dst_yres, coef,
      ch->use_nn_interpolation);
 dcss_scaler_program_7_coef_set(ch, DCSS_SCALER_COEF_VLUM, coef);
}

static void dcss_scaler_set_rgb10_order(struct dcss_scaler_ch *ch,
     const struct drm_format_info *format)
{
 u32 a2r10g10b10_format;

 if (format->is_yuv)
  return;

 ch->sdata_ctrl &= ~A2R10G10B10_FORMAT_MASK;

 if (format->depth != 30)
  return;

 switch (format->format) {
 case DRM_FORMAT_ARGB2101010:
 case DRM_FORMAT_XRGB2101010:
  a2r10g10b10_format = 0;
  break;

 case DRM_FORMAT_ABGR2101010:
 case DRM_FORMAT_XBGR2101010:
  a2r10g10b10_format = 5;
  break;

 case DRM_FORMAT_RGBA1010102:
 case DRM_FORMAT_RGBX1010102:
  a2r10g10b10_format = 6;
  break;

 case DRM_FORMAT_BGRA1010102:
 case DRM_FORMAT_BGRX1010102:
  a2r10g10b10_format = 11;
  break;

 default:
  a2r10g10b10_format = 0;
  break;
 }

 ch->sdata_ctrl |= a2r10g10b10_format << A2R10G10B10_FORMAT_POS;
}

void dcss_scaler_set_filter(struct dcss_scaler *scl, int ch_num,
       enum drm_scaling_filter scaling_filter)
{
 struct dcss_scaler_ch *ch = &scl->ch[ch_num];

 ch->use_nn_interpolation = scaling_filter == DRM_SCALING_FILTER_NEAREST_NEIGHBOR;
}

void dcss_scaler_setup(struct dcss_scaler *scl, int ch_num,
         const struct drm_format_info *format,
         int src_xres, int src_yres, int dst_xres, int dst_yres,
         u32 vrefresh_hz)
{
 struct dcss_scaler_ch *ch = &scl->ch[ch_num];
 unsigned int pixel_depth = 0;
 bool rtr_8line_en = false;
 bool use_5_taps = false;
 enum buffer_format src_format = BUF_FMT_ARGB8888_YUV444;
 enum buffer_format dst_format = BUF_FMT_ARGB8888_YUV444;
 u32 pix_format = format->format;

 if (format->is_yuv) {
  dcss_scaler_yuv_enable(ch, true);

  if (pix_format == DRM_FORMAT_NV12 ||
      pix_format == DRM_FORMAT_NV21) {
   rtr_8line_en = true;
   src_format = BUF_FMT_YUV420;
  } else if (pix_format == DRM_FORMAT_UYVY ||
      pix_format == DRM_FORMAT_VYUY ||
      pix_format == DRM_FORMAT_YUYV ||
      pix_format == DRM_FORMAT_YVYU) {
   src_format = BUF_FMT_YUV422;
  }

  use_5_taps = !rtr_8line_en;
 } else {
  dcss_scaler_yuv_enable(ch, false);

  pixel_depth = format->depth;
 }

 dcss_scaler_fractions_set(ch, src_xres, src_yres, dst_xres,
      dst_yres, src_format, dst_format,
      PSC_LOC_HORZ_0_VERT_1_OVER_4);

 if (format->is_yuv)
  dcss_scaler_yuv_coef_set(ch, src_format, dst_format,
      use_5_taps, src_xres, src_yres,
      dst_xres, dst_yres);
 else
  dcss_scaler_rgb_coef_set(ch, src_xres, src_yres,
      dst_xres, dst_yres);

 dcss_scaler_rtr_8lines_enable(ch, rtr_8line_en);
 dcss_scaler_bit_depth_set(ch, pixel_depth);
 dcss_scaler_set_rgb10_order(ch, format);
 dcss_scaler_format_set(ch, src_format, dst_format);
 dcss_scaler_res_set(ch, src_xres, src_yres, dst_xres, dst_yres,
       pix_format, dst_format);
}

/* This function will be called from interrupt context. */
void dcss_scaler_write_sclctrl(struct dcss_scaler *scl)
{
 int chnum;

 dcss_ctxld_assert_locked(scl->ctxld);

 for (chnum = 0; chnum < 3; chnum++) {
  struct dcss_scaler_ch *ch = &scl->ch[chnum];

  if (ch->scaler_ctrl_chgd) {
   dcss_ctxld_write_irqsafe(scl->ctxld, scl->ctx_id,
       ch->scaler_ctrl,
       ch->base_ofs +
       DCSS_SCALER_CTRL);
   ch->scaler_ctrl_chgd = false;
  }
 }
}