// SPDX-License-Identifier: GPL-2.0 /* * Copyright 2019 NXP. * * Scaling algorithms were contributed by Dzung Hoang */ #include #include #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; } } }