269 lines
8.3 KiB
C
269 lines
8.3 KiB
C
// SPDX-License-Identifier: BSD-3-Clause
|
|
/*
|
|
* Copyright (c) 2021 Rockchip Electronics Co. Ltd.
|
|
*
|
|
* Author: Wyon Bi <bivvy.bi@rock-chips.com>
|
|
*/
|
|
#include "rk628.h"
|
|
#include "rk628_config.h"
|
|
#include "rk628_cru.h"
|
|
|
|
static void calc_dsp_frm_hst_vst(const struct rk628_display_mode *src,
|
|
const struct rk628_display_mode *dst,
|
|
u32 *dsp_frame_hst,
|
|
u32 *dsp_frame_vst)
|
|
{
|
|
u32 bp_in, bp_out;
|
|
u32 v_scale_ratio;
|
|
u64 t_frm_st;
|
|
u64 t_bp_in, t_bp_out, t_delta, tin;
|
|
u32 src_pixclock, dst_pixclock;
|
|
u32 dst_htotal, dst_hsync_len, dst_hback_porch;
|
|
u32 dst_vsync_len, dst_vback_porch, dst_vactive;
|
|
u32 src_htotal, src_hsync_len, src_hback_porch;
|
|
u32 src_vtotal, src_vsync_len, src_vback_porch, src_vactive;
|
|
u32 rem;
|
|
u32 x;
|
|
|
|
src_pixclock = div_u64(1000000000llu, src->clock);
|
|
dst_pixclock = div_u64(1000000000llu, dst->clock);
|
|
|
|
src_hsync_len = src->hsync_end - src->hsync_start;
|
|
src_hback_porch = src->htotal - src->hsync_end;
|
|
src_htotal = src->htotal;
|
|
src_vsync_len = src->vsync_end - src->vsync_start;
|
|
src_vback_porch = src->vtotal - src->vsync_end;
|
|
src_vactive = src->vdisplay;
|
|
src_vtotal = src->vtotal;
|
|
|
|
dst_hsync_len = dst->hsync_end - dst->hsync_start;
|
|
dst_hback_porch = dst->htotal - dst->hsync_end;
|
|
dst_htotal = dst->htotal;
|
|
dst_vsync_len = dst->vsync_end - dst->vsync_start;
|
|
dst_vback_porch = dst->vtotal - dst->vsync_end;
|
|
dst_vactive = dst->vdisplay;
|
|
|
|
bp_in = (src_vback_porch + src_vsync_len) * src_htotal +
|
|
src_hsync_len + src_hback_porch;
|
|
bp_out = (dst_vback_porch + dst_vsync_len) * dst_htotal +
|
|
dst_hsync_len + dst_hback_porch;
|
|
|
|
t_bp_in = bp_in * src_pixclock;
|
|
t_bp_out = bp_out * dst_pixclock;
|
|
tin = src_vtotal * src_htotal * src_pixclock;
|
|
|
|
v_scale_ratio = src_vactive / dst_vactive;
|
|
x = 5;
|
|
__retry:
|
|
if (v_scale_ratio <= 2)
|
|
t_delta = x * src_htotal * src_pixclock;
|
|
else
|
|
t_delta = 12 * src_htotal * src_pixclock;
|
|
|
|
if (t_bp_in + t_delta > t_bp_out)
|
|
t_frm_st = (t_bp_in + t_delta - t_bp_out);
|
|
else
|
|
t_frm_st = tin - (t_bp_out - (t_bp_in + t_delta));
|
|
|
|
do_div(t_frm_st, src_pixclock);
|
|
rem = do_div(t_frm_st, src_htotal);
|
|
if ((t_frm_st < 2 || t_frm_st > 14) && x < 12) {
|
|
x++;
|
|
goto __retry;
|
|
}
|
|
if (t_frm_st < 2 || t_frm_st > 14)
|
|
t_frm_st = 4;
|
|
|
|
*dsp_frame_hst = rem;
|
|
*dsp_frame_vst = t_frm_st;
|
|
}
|
|
|
|
static void rk628_post_process_scaler_init(struct rk628 *rk628,
|
|
struct rk628_display_mode *src,
|
|
const struct rk628_display_mode *dst)
|
|
{
|
|
u32 dsp_frame_hst, dsp_frame_vst;
|
|
u32 scl_hor_mode, scl_ver_mode;
|
|
u32 scl_v_factor, scl_h_factor;
|
|
u32 dsp_htotal, dsp_hs_end, dsp_hact_st, dsp_hact_end;
|
|
u32 dsp_vtotal, dsp_vs_end, dsp_vact_st, dsp_vact_end;
|
|
u32 dsp_hbor_end, dsp_hbor_st, dsp_vbor_end, dsp_vbor_st;
|
|
u16 bor_right = 0, bor_left = 0, bor_up = 0, bor_down = 0;
|
|
u8 hor_down_mode = 0, ver_down_mode = 0;
|
|
u32 dst_hsync_len, dst_hback_porch, dst_hfront_porch, dst_hactive;
|
|
u32 dst_vsync_len, dst_vback_porch, dst_vfront_porch, dst_vactive;
|
|
u32 src_hactive;
|
|
u32 src_vactive;
|
|
|
|
src_hactive = src->hdisplay;
|
|
src_vactive = src->vdisplay;
|
|
|
|
dst_hactive = dst->hdisplay;
|
|
dst_hsync_len = dst->hsync_end - dst->hsync_start;
|
|
dst_hback_porch = dst->htotal - dst->hsync_end;
|
|
dst_hfront_porch = dst->hsync_start - dst->hdisplay;
|
|
dst_vsync_len = dst->vsync_end - dst->vsync_start;
|
|
dst_vback_porch = dst->vtotal - dst->vsync_end;
|
|
dst_vfront_porch = dst->vsync_start - dst->vdisplay;
|
|
dst_vactive = dst->vdisplay;
|
|
|
|
dsp_htotal = dst_hsync_len + dst_hback_porch +
|
|
dst_hactive + dst_hfront_porch;
|
|
dsp_vtotal = dst_vsync_len + dst_vback_porch +
|
|
dst_vactive + dst_vfront_porch;
|
|
dsp_hs_end = dst_hsync_len;
|
|
dsp_vs_end = dst_vsync_len;
|
|
dsp_hbor_end = dst_hsync_len + dst_hback_porch + dst_hactive;
|
|
dsp_hbor_st = dst_hsync_len + dst_hback_porch;
|
|
dsp_vbor_end = dst_vsync_len + dst_vback_porch + dst_vactive;
|
|
dsp_vbor_st = dst_vsync_len + dst_vback_porch;
|
|
dsp_hact_st = dsp_hbor_st + bor_left;
|
|
dsp_hact_end = dsp_hbor_end - bor_right;
|
|
dsp_vact_st = dsp_vbor_st + bor_up;
|
|
dsp_vact_end = dsp_vbor_end - bor_down;
|
|
|
|
calc_dsp_frm_hst_vst(src, dst, &dsp_frame_hst, &dsp_frame_vst);
|
|
dev_info(rk628->dev, "dsp_frame_vst:%d dsp_frame_hst:%d\n",
|
|
dsp_frame_vst, dsp_frame_hst);
|
|
|
|
if (src_hactive > dst_hactive) {
|
|
scl_hor_mode = 2;
|
|
|
|
if (hor_down_mode == 0) {
|
|
if ((src_hactive - 1) / (dst_hactive - 1) > 2)
|
|
scl_h_factor = ((src_hactive - 1) << 14) /
|
|
(dst_hactive - 1);
|
|
else
|
|
scl_h_factor = ((src_hactive - 2) << 14) /
|
|
(dst_hactive - 1);
|
|
} else {
|
|
scl_h_factor = (dst_hactive << 16) / (src_hactive - 1);
|
|
}
|
|
|
|
} else if (src_hactive == dst_hactive) {
|
|
scl_hor_mode = 0;
|
|
scl_h_factor = 0;
|
|
} else {
|
|
scl_hor_mode = 1;
|
|
scl_h_factor = ((src_hactive - 1) << 16) / (dst_hactive - 1);
|
|
}
|
|
|
|
if (src_vactive > dst_vactive) {
|
|
scl_ver_mode = 2;
|
|
|
|
if (ver_down_mode == 0) {
|
|
if ((src_vactive - 1) / (dst_vactive - 1) > 2)
|
|
scl_v_factor = ((src_vactive - 1) << 14) /
|
|
(dst_vactive - 1);
|
|
else
|
|
scl_v_factor = ((src_vactive - 2) << 14) /
|
|
(dst_vactive - 1);
|
|
} else {
|
|
scl_v_factor = (dst_vactive << 16) / (src_vactive - 1);
|
|
}
|
|
|
|
} else if (src_vactive == dst_vactive) {
|
|
scl_ver_mode = 0;
|
|
scl_v_factor = 0;
|
|
} else {
|
|
scl_ver_mode = 1;
|
|
scl_v_factor = ((src_vactive - 1) << 16) / (dst_vactive - 1);
|
|
}
|
|
|
|
rk628_i2c_update_bits(rk628, GRF_RGB_DEC_CON0, SW_HRES_MASK,
|
|
SW_HRES(src_hactive));
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON0, SCL_VER_DOWN_MODE(ver_down_mode) |
|
|
SCL_HOR_DOWN_MODE(hor_down_mode) |
|
|
SCL_VER_MODE(scl_ver_mode) |
|
|
SCL_HOR_MODE(scl_hor_mode));
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON1, SCL_V_FACTOR(scl_v_factor) |
|
|
SCL_H_FACTOR(scl_h_factor));
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON2, DSP_FRAME_VST(dsp_frame_vst) |
|
|
DSP_FRAME_HST(dsp_frame_hst));
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON3, DSP_HS_END(dsp_hs_end) |
|
|
DSP_HTOTAL(dsp_htotal));
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON4, DSP_HACT_END(dsp_hact_end) |
|
|
DSP_HACT_ST(dsp_hact_st));
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON5, DSP_VS_END(dsp_vs_end) |
|
|
DSP_VTOTAL(dsp_vtotal));
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON6, DSP_VACT_END(dsp_vact_end) |
|
|
DSP_VACT_ST(dsp_vact_st));
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON7, DSP_HBOR_END(dsp_hbor_end) |
|
|
DSP_HBOR_ST(dsp_hbor_st));
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON8, DSP_VBOR_END(dsp_vbor_end) |
|
|
DSP_VBOR_ST(dsp_vbor_st));
|
|
}
|
|
|
|
void rk628_post_process_init(struct rk628 *rk628)
|
|
{
|
|
struct rk628_display_mode *src = &rk628->src_mode;
|
|
const struct rk628_display_mode *dst = &rk628->dst_mode;
|
|
u64 dst_rate, src_rate;
|
|
|
|
src_rate = src->clock * 1000;
|
|
dst_rate = src_rate * dst->vdisplay * dst->htotal;
|
|
do_div(dst_rate, (src->vdisplay * src->htotal));
|
|
do_div(dst_rate, 1000);
|
|
dev_info(rk628->dev, "src %dx%d clock:%d\n",
|
|
src->hdisplay, src->vdisplay, src->clock);
|
|
|
|
dev_info(rk628->dev, "dst %dx%d clock:%llu\n",
|
|
dst->hdisplay, dst->vdisplay, dst_rate);
|
|
|
|
rk628_cru_clk_set_rate(rk628, CGU_CLK_RX_READ, src->clock * 1000);
|
|
rk628_cru_clk_set_rate(rk628, CGU_SCLK_VOP, dst_rate * 1000);
|
|
|
|
if (rk628->output_mode == OUTPUT_MODE_HDMI) {
|
|
rk628_i2c_update_bits(rk628, GRF_SYSTEM_CON0, SW_VSYNC_POL_MASK,
|
|
SW_VSYNC_POL(rk628->sync_pol));
|
|
rk628_i2c_update_bits(rk628, GRF_SYSTEM_CON0, SW_HSYNC_POL_MASK,
|
|
SW_HSYNC_POL(rk628->sync_pol));
|
|
} else {
|
|
if (src->flags & DRM_MODE_FLAG_PVSYNC)
|
|
rk628_i2c_update_bits(rk628, GRF_SYSTEM_CON0,
|
|
SW_VSYNC_POL_MASK, SW_VSYNC_POL(1));
|
|
if (src->flags & DRM_MODE_FLAG_PHSYNC)
|
|
rk628_i2c_update_bits(rk628, GRF_SYSTEM_CON0,
|
|
SW_HSYNC_POL_MASK,
|
|
SW_HSYNC_POL(1));
|
|
}
|
|
|
|
rk628_post_process_scaler_init(rk628, src, dst);
|
|
}
|
|
|
|
static void rk628_post_process_csc(struct rk628 *rk628)
|
|
{
|
|
enum bus_format in_fmt, out_fmt;
|
|
|
|
in_fmt = rk628_get_input_bus_format(rk628);
|
|
out_fmt = rk628_get_output_bus_format(rk628);
|
|
|
|
if (in_fmt == out_fmt) {
|
|
if (out_fmt == BUS_FMT_YUV422) {
|
|
rk628_i2c_write(rk628, GRF_CSC_CTRL_CON,
|
|
SW_YUV2VYU_SWP(1) |
|
|
SW_R2Y_EN(0));
|
|
return;
|
|
}
|
|
rk628_i2c_write(rk628, GRF_CSC_CTRL_CON, SW_R2Y_EN(0));
|
|
rk628_i2c_write(rk628, GRF_CSC_CTRL_CON, SW_Y2R_EN(0));
|
|
return;
|
|
}
|
|
|
|
if (in_fmt == BUS_FMT_RGB)
|
|
rk628_i2c_write(rk628, GRF_CSC_CTRL_CON, SW_R2Y_EN(1));
|
|
else if (out_fmt == BUS_FMT_RGB)
|
|
rk628_i2c_write(rk628, GRF_CSC_CTRL_CON, SW_Y2R_EN(1));
|
|
}
|
|
|
|
void rk628_post_process_enable(struct rk628 *rk628)
|
|
{
|
|
rk628_post_process_csc(rk628);
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON0, SCL_EN(1));
|
|
}
|
|
|
|
void rk628_post_process_disable(struct rk628 *rk628)
|
|
{
|
|
rk628_i2c_write(rk628, GRF_SCALER_CON0, SCL_EN(0));
|
|
}
|