#define Wr_reg_bits(adr, val, start, len) \
WRITE_VCBUS_REG_BITS(adr, val, start, len)
-static int vsync_rdma_handle;
-static int irq_count;
-static int enable;
-static int cur_enable;
-static int pre_enable_;
-static int debug_flag;
-static int vsync_cfg_count;
-static u32 force_rdma_config;
-static bool first_config;
-static bool rdma_done;
+#define RDMA_NUM 2
+static int second_rdma_feature;
+static int rdma_num = RDMA_NUM;
+static int vsync_rdma_handle[RDMA_NUM];
+static int irq_count[RDMA_NUM];
+static int enable[RDMA_NUM];
+static int cur_enable[RDMA_NUM];
+static int pre_enable_[RDMA_NUM];
+static int debug_flag[RDMA_NUM];
+static int vsync_cfg_count[RDMA_NUM];
+static u32 force_rdma_config[RDMA_NUM];
+static bool first_config[RDMA_NUM];
+static bool rdma_done[RDMA_NUM];
static void vsync_rdma_irq(void *arg);
+static void line_n_int_rdma_irq(void *arg);
struct rdma_op_s vsync_rdma_op = {
vsync_rdma_irq,
NULL
};
+struct rdma_op_s line_n_int_rdma_op = {
+ line_n_int_rdma_irq,
+ NULL
+};
-void vsync_rdma_config(void)
+static void set_rdma_trigger_line(void)
+{
+ int trigger_line;
+
+ switch (aml_read_vcbus(VPU_VIU_VENC_MUX_CTRL) & 0x3) {
+ case 0:
+ trigger_line = aml_read_vcbus(ENCL_VIDEO_VAVON_ELINE)
+ - aml_read_vcbus(ENCL_VIDEO_VSO_BLINE);
+ break;
+ case 1:
+ if ((aml_read_vcbus(ENCI_VIDEO_MODE) & 1) == 0)
+ trigger_line = 260; /* 480i */
+ else
+ trigger_line = 310; /* 576i */
+ break;
+ case 2:
+ if (aml_read_vcbus(ENCP_VIDEO_MODE) & (1 << 12))
+ trigger_line = aml_read_vcbus(ENCP_DE_V_END_EVEN);
+ else
+ trigger_line = aml_read_vcbus(ENCP_VIDEO_VAVON_ELINE)
+ - aml_read_vcbus(ENCP_VIDEO_VSO_BLINE);
+ break;
+ case 3:
+ trigger_line = aml_read_vcbus(ENCT_VIDEO_VAVON_ELINE)
+ - aml_read_vcbus(ENCT_VIDEO_VSO_BLINE);
+ break;
+ }
+ aml_write_vcbus(VPP_INT_LINE_NUM, trigger_line);
+}
+
+void _vsync_rdma_config(int rdma_type)
{
int iret = 0;
- int enable_ = cur_enable & 0xf;
+ int enable_ = cur_enable[rdma_type] & 0xf;
- if (vsync_rdma_handle <= 0)
+ if (vsync_rdma_handle[rdma_type] <= 0)
return;
/* first frame not use rdma */
- if (!first_config) {
- cur_enable = enable;
- pre_enable_ = enable_;
- first_config = true;
- rdma_done = false;
+ if (!first_config[rdma_type]) {
+ cur_enable[rdma_type] = enable[rdma_type];
+ pre_enable_[rdma_type] = enable_;
+ first_config[rdma_type] = true;
+ rdma_done[rdma_type] = false;
return;
}
/* if rdma mode changed, reset rdma */
- if (pre_enable_ != enable_) {
- rdma_clear(vsync_rdma_handle);
- force_rdma_config = 1;
+ if (pre_enable_[rdma_type] != enable_) {
+ rdma_clear(vsync_rdma_handle[rdma_type]);
+ force_rdma_config[rdma_type] = 1;
}
- if (force_rdma_config)
- rdma_done = true;
+ if (force_rdma_config[rdma_type])
+ rdma_done[rdma_type] = true;
if (enable_ == 1) {
- if (rdma_done)
+ if (rdma_done[rdma_type])
iret = rdma_watchdog_setting(0);
else
iret = rdma_watchdog_setting(1);
} else {
/* not vsync mode */
iret = rdma_watchdog_setting(0);
- force_rdma_config = 1;
+ force_rdma_config[rdma_type] = 1;
}
- rdma_done = false;
+ rdma_done[rdma_type] = false;
if (iret)
- force_rdma_config = 1;
+ force_rdma_config[rdma_type] = 1;
iret = 0;
- if (force_rdma_config) {
+ if (force_rdma_config[rdma_type]) {
if (enable_ == 1) {
- iret = rdma_config(vsync_rdma_handle,
- RDMA_TRIGGER_VSYNC_INPUT);
+ if (rdma_type == VSYNC_RDMA)
+ iret = rdma_config(vsync_rdma_handle[rdma_type],
+ RDMA_TRIGGER_VSYNC_INPUT);
+ else if (rdma_type == LINE_N_INT_RDMA) {
+ set_rdma_trigger_line();
+ iret = rdma_config(vsync_rdma_handle[rdma_type],
+ RDMA_TRIGGER_LINE_INPUT);
+ }
if (iret)
- vsync_cfg_count++;
+ vsync_cfg_count[rdma_type]++;
} else if (enable_ == 2)
/*manually in cur vsync*/
- rdma_config(vsync_rdma_handle,
+ rdma_config(vsync_rdma_handle[rdma_type],
RDMA_TRIGGER_MANUAL);
else if (enable_ == 3)
;
else if (enable_ == 4)
- rdma_config(vsync_rdma_handle,
+ rdma_config(vsync_rdma_handle[rdma_type],
RDMA_TRIGGER_DEBUG1); /*for debug*/
else if (enable_ == 5)
- rdma_config(vsync_rdma_handle,
+ rdma_config(vsync_rdma_handle[rdma_type],
RDMA_TRIGGER_DEBUG2); /*for debug*/
else if (enable_ == 6)
;
if (!iret)
- force_rdma_config = 1;
+ force_rdma_config[rdma_type] = 1;
else
- force_rdma_config = 0;
+ force_rdma_config[rdma_type] = 0;
}
- pre_enable_ = enable_;
- cur_enable = enable;
+ pre_enable_[rdma_type] = enable_;
+ cur_enable[rdma_type] = enable[rdma_type];
+}
+
+void vsync_rdma_config(void)
+{
+ _vsync_rdma_config(VSYNC_RDMA);
+ if (second_rdma_feature &&
+ is_meson_g12b_revb())
+ _vsync_rdma_config(LINE_N_INT_RDMA);
}
+
EXPORT_SYMBOL(vsync_rdma_config);
-void vsync_rdma_config_pre(void)
+void _vsync_rdma_config_pre(int rdma_type)
{
- int enable_ = cur_enable & 0xf;
+ int enable_ = cur_enable[rdma_type] & 0xf;
- if (vsync_rdma_handle == 0)
+ if (vsync_rdma_handle[rdma_type] == 0)
return;
if (enable_ == 3)/*manually in next vsync*/
- rdma_config(vsync_rdma_handle, 0);
+ rdma_config(vsync_rdma_handle[rdma_type], 0);
else if (enable_ == 6)
- rdma_config(vsync_rdma_handle, 0x101); /*for debug*/
+ rdma_config(vsync_rdma_handle[rdma_type], 0x101); /*for debug*/
+}
+
+void vsync_rdma_config_pre(void)
+{
+ _vsync_rdma_config_pre(VSYNC_RDMA);
+ if (second_rdma_feature &&
+ is_meson_g12b_revb())
+ _vsync_rdma_config_pre(LINE_N_INT_RDMA);
}
EXPORT_SYMBOL(vsync_rdma_config_pre);
static void vsync_rdma_irq(void *arg)
{
int iret;
- int enable_ = cur_enable & 0xf;
+ int enable_ = cur_enable[VSYNC_RDMA] & 0xf;
if (enable_ == 1) {
/*triggered by next vsync*/
- iret = rdma_config(vsync_rdma_handle,
+ iret = rdma_config(vsync_rdma_handle[VSYNC_RDMA],
RDMA_TRIGGER_VSYNC_INPUT);
if (iret)
- vsync_cfg_count++;
+ vsync_cfg_count[VSYNC_RDMA]++;
} else
- iret = rdma_config(vsync_rdma_handle, 0);
- pre_enable_ = enable_;
+ iret = rdma_config(vsync_rdma_handle[VSYNC_RDMA], 0);
+ pre_enable_[VSYNC_RDMA] = enable_;
if ((!iret) || (enable_ != 1))
- force_rdma_config = 1;
+ force_rdma_config[VSYNC_RDMA] = 1;
else
- force_rdma_config = 0;
- rdma_done = true;
- irq_count++;
+ force_rdma_config[VSYNC_RDMA] = 0;
+ rdma_done[VSYNC_RDMA] = true;
+ irq_count[VSYNC_RDMA]++;
return;
}
+static void line_n_int_rdma_irq(void *arg)
+{
+ int iret;
+ int enable_ = cur_enable[LINE_N_INT_RDMA] & 0xf;
+
+ if (enable_ == 1) {
+ /*triggered by next vsync*/
+ //set_rdma_trigger_line();
+ iret = rdma_config(vsync_rdma_handle[LINE_N_INT_RDMA],
+ RDMA_TRIGGER_LINE_INPUT);
+ if (iret)
+ vsync_cfg_count[LINE_N_INT_RDMA]++;
+ } else
+ iret = rdma_config(vsync_rdma_handle[LINE_N_INT_RDMA], 0);
+ pre_enable_[LINE_N_INT_RDMA] = enable_;
+
+ if ((!iret) || (enable_ != 1))
+ force_rdma_config[LINE_N_INT_RDMA] = 1;
+ else
+ force_rdma_config[LINE_N_INT_RDMA] = 0;
+ rdma_done[VSYNC_RDMA] = true;
+ irq_count[VSYNC_RDMA]++;
+}
+
u32 VSYNC_RD_MPEG_REG(u32 adr)
{
- int enable_ = cur_enable & 0xf;
+ int enable_ = cur_enable[VSYNC_RDMA] & 0xf;
u32 read_val = Rd(adr);
- if ((enable_ != 0) && (vsync_rdma_handle > 0))
- read_val = rdma_read_reg(vsync_rdma_handle, adr);
+ if ((enable_ != 0) && (vsync_rdma_handle[VSYNC_RDMA] > 0))
+ read_val = rdma_read_reg(vsync_rdma_handle[VSYNC_RDMA], adr);
return read_val;
}
int VSYNC_WR_MPEG_REG(u32 adr, u32 val)
{
- int enable_ = cur_enable & 0xf;
+ int enable_ = cur_enable[VSYNC_RDMA] & 0xf;
- if ((enable_ != 0) && (vsync_rdma_handle > 0)) {
- rdma_write_reg(vsync_rdma_handle, adr, val);
+ if ((enable_ != 0) && (vsync_rdma_handle[VSYNC_RDMA] > 0)) {
+ rdma_write_reg(vsync_rdma_handle[VSYNC_RDMA], adr, val);
} else {
Wr(adr, val);
- if (debug_flag & 1)
+ if (debug_flag[VSYNC_RDMA] & 1)
pr_info("VSYNC_WR(%x)<=%x\n", adr, val);
}
return 0;
int VSYNC_WR_MPEG_REG_BITS(u32 adr, u32 val, u32 start, u32 len)
{
- int enable_ = cur_enable & 0xf;
+ int enable_ = cur_enable[VSYNC_RDMA] & 0xf;
- if ((enable_ != 0) && (vsync_rdma_handle > 0)) {
- rdma_write_reg_bits(vsync_rdma_handle, adr, val, start, len);
+ if ((enable_ != 0) && (vsync_rdma_handle[VSYNC_RDMA] > 0)) {
+ rdma_write_reg_bits(vsync_rdma_handle[VSYNC_RDMA],
+ adr, val, start, len);
} else {
u32 read_val = Rd(adr);
u32 write_val = (read_val & ~(((1L<<(len))-1)<<(start)))
|((unsigned int)(val) << (start));
Wr(adr, write_val);
- if (debug_flag & 1)
+ if (debug_flag[VSYNC_RDMA] & 1)
pr_info("VSYNC_WR(%x)<=%x\n", adr, write_val);
}
return 0;
}
EXPORT_SYMBOL(VSYNC_WR_MPEG_REG_BITS);
+u32 _VSYNC_RD_MPEG_REG(u32 adr)
+{
+ u32 read_val = 0;
+
+ if (second_rdma_feature && is_meson_g12b_revb()) {
+ int enable_ = cur_enable[LINE_N_INT_RDMA] & 0xf;
+
+ read_val = Rd(adr);
+
+ if ((enable_ != 0) &&
+ (vsync_rdma_handle[LINE_N_INT_RDMA] > 0))
+ read_val = rdma_read_reg
+ (vsync_rdma_handle[LINE_N_INT_RDMA], adr);
+ } else {
+ read_val = VSYNC_RD_MPEG_REG(adr);
+ }
+ return read_val;
+}
+EXPORT_SYMBOL(_VSYNC_RD_MPEG_REG);
+
+int _VSYNC_WR_MPEG_REG(u32 adr, u32 val)
+{
+ if (second_rdma_feature && is_meson_g12b_revb()) {
+ int enable_ = cur_enable[LINE_N_INT_RDMA] & 0xf;
+
+ if ((enable_ != 0) &&
+ (vsync_rdma_handle[LINE_N_INT_RDMA] > 0)) {
+ rdma_write_reg
+ (vsync_rdma_handle[LINE_N_INT_RDMA], adr, val);
+ } else {
+ Wr(adr, val);
+ if (debug_flag[LINE_N_INT_RDMA] & 1)
+ pr_info("VSYNC_WR(%x)<=%x\n", adr, val);
+ }
+ } else {
+ VSYNC_WR_MPEG_REG(adr, val);
+ }
+ return 0;
+}
+EXPORT_SYMBOL(_VSYNC_WR_MPEG_REG);
+
+int _VSYNC_WR_MPEG_REG_BITS(u32 adr, u32 val, u32 start, u32 len)
+{
+ if (second_rdma_feature && is_meson_g12b_revb()) {
+ int enable_ = cur_enable[LINE_N_INT_RDMA] & 0xf;
+
+ if ((enable_ != 0) &&
+ (vsync_rdma_handle[LINE_N_INT_RDMA] > 0)) {
+ rdma_write_reg_bits
+ (vsync_rdma_handle[LINE_N_INT_RDMA],
+ adr, val, start, len);
+ } else {
+ u32 read_val = Rd(adr);
+ u32 write_val = (read_val & ~(((1L<<(len))-1)<<(start)))
+ |((unsigned int)(val) << (start));
+ Wr(adr, write_val);
+ if (debug_flag[LINE_N_INT_RDMA] & 1)
+ pr_info("VSYNC_WR(%x)<=%x\n", adr, write_val);
+ }
+ } else {
+ VSYNC_WR_MPEG_REG_BITS(adr, val, start, len);
+ }
+ return 0;
+}
+EXPORT_SYMBOL(_VSYNC_WR_MPEG_REG_BITS);
+
bool is_vsync_rdma_enable(void)
{
bool ret;
- int enable_ = cur_enable & 0xf;
+ int enable_ = cur_enable[VSYNC_RDMA] & 0xf;
ret = (enable_ != 0);
return ret;
void enable_rdma_log(int flag)
{
- if (flag)
- debug_flag |= 0x1;
- else
- debug_flag &= (~0x1);
+ if (flag) {
+ debug_flag[VSYNC_RDMA] |= 0x1;
+ debug_flag[LINE_N_INT_RDMA] |= 0x1;
+ } else {
+ debug_flag[VSYNC_RDMA] &= (~0x1);
+ debug_flag[LINE_N_INT_RDMA] &= (~0x1);
+ }
}
EXPORT_SYMBOL(enable_rdma_log);
void enable_rdma(int enable_flag)
{
- enable = enable_flag;
+ enable[VSYNC_RDMA] = enable_flag;
+ enable[LINE_N_INT_RDMA] = enable_flag;
}
EXPORT_SYMBOL(enable_rdma);
-struct rdma_op_s *get_rdma_ops(void)
+struct rdma_op_s *get_rdma_ops(int rdma_type)
{
- return &vsync_rdma_op;
+ if (rdma_type == VSYNC_RDMA)
+ return &vsync_rdma_op;
+ else if (rdma_type == LINE_N_INT_RDMA)
+ return &line_n_int_rdma_op;
+ else
+ return NULL;
}
-void set_rdma_handle(int handle)
+void set_rdma_handle(int rdma_type, int handle)
{
- vsync_rdma_handle = handle;
+ vsync_rdma_handle[rdma_type] = handle;
pr_info("%s video rdma handle = %d.\n", __func__,
- vsync_rdma_handle);
+ vsync_rdma_handle[rdma_type]);
+
+}
+
+u32 is_line_n_rdma_enable(void)
+{
+ return second_rdma_feature;
}
static int __init rdma_init(void)
{
- cur_enable = 0;
- enable = 1;
- force_rdma_config = 1;
+ second_rdma_feature = 0;
+ if (is_meson_g12b_revb())
+ second_rdma_feature = 1;
+
+ cur_enable[VSYNC_RDMA] = 0;
+ enable[VSYNC_RDMA] = 1;
+ force_rdma_config[VSYNC_RDMA] = 1;
+
+ if (second_rdma_feature) {
+ cur_enable[LINE_N_INT_RDMA] = 0;
+ enable[LINE_N_INT_RDMA] = 1;
+ force_rdma_config[LINE_N_INT_RDMA] = 1;
+ }
+
return 0;
}
module_init(rdma_init);
-MODULE_PARM_DESC(enable, "\n enable\n");
-module_param(enable, uint, 0664);
+MODULE_PARM_DESC(second_rdma_feature,
+ "\n second_rdma_feature enable\n");
+module_param(second_rdma_feature, uint, 0664);
+
+MODULE_PARM_DESC(enable,
+ "\n vsync rdma enable\n");
+module_param_array(enable, uint, &rdma_num, 0664);
-MODULE_PARM_DESC(irq_count, "\n irq_count\n");
-module_param(irq_count, uint, 0664);
+MODULE_PARM_DESC(irq_count,
+ "\n vsync rdma irq_count\n");
+module_param_array(irq_count, uint, &rdma_num, 0664);
-MODULE_PARM_DESC(debug_flag, "\n debug_flag\n");
-module_param(debug_flag, uint, 0664);
+MODULE_PARM_DESC(debug_flag,
+ "\n vsync rdma debug_flag\n");
+module_param_array(debug_flag, uint, &rdma_num, 0664);
-MODULE_PARM_DESC(vsync_cfg_count, "\n vsync_cfg_count\n");
-module_param(vsync_cfg_count, uint, 0664);
+MODULE_PARM_DESC(vsync_cfg_count,
+ "\n vsync rdma vsync_cfg_count\n");
+module_param_array(vsync_cfg_count, uint, &rdma_num, 0664);
-MODULE_PARM_DESC(force_rdma_config, "\n force_rdma_config\n");
-module_param(force_rdma_config, uint, 0664);
+MODULE_PARM_DESC(force_rdma_config,
+ "\n vsync rdma force_rdma_config\n");
+module_param_array(force_rdma_config, uint, &rdma_num, 0664);
DOLBY_TV_CLKGATE_CTRL, 0x2800);
if (reset) {
if (!dolby_vision_core1_on) {
- VSYNC_WR_MPEG_REG(VIU_SW_RESET, 1 << 9);
- VSYNC_WR_MPEG_REG(VIU_SW_RESET, 0);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(VIU_SW_RESET, 1 << 9);
+ _VSYNC_WR_MPEG_REG(VIU_SW_RESET, 0);
+ _VSYNC_WR_MPEG_REG(
DOLBY_TV_CLKGATE_CTRL, 0x2800);
} else
reset = 0;
}
if (!bl_enable)
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL5, 0x446);
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL0, 0);
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL1,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL5, 0x446);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL0, 0);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL1,
((hsize + 0x80) << 16) | (vsize + 0x40));
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL3,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL3,
(hwidth << 16) | vwidth);
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL4,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL4,
(hpotch << 16) | vpotch);
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL2,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL2,
(hsize << 16) | vsize);
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL6, 0xba000000);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL6, 0xba000000);
if (dolby_vision_flags & FLAG_DISABLE_COMPOSER)
composer_enable = 0;
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL0,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL0,
/* el dly 3, bl dly 1 after de*/
(el_41_mode ? (0x3 << 4) : (0x1 << 8)) |
bl_enable << 0 | composer_enable << 1 | el_41_mode << 2);
if (el_enable && (dolby_vision_mask & 1))
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* vd2 to core1 */
0, 17, 1);
else
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* vd2 to vpp */
1, 17, 1);
if (dolby_vision_core1_on
&& !bypass_core1)
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* enable core 1 */
0, 16, 1);
else if (dolby_vision_core1_on
&& bypass_core1)
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* bypass core 1 */
1, 16, 1);
bypass_flag;
if (dolby_vision_on_count < dolby_vision_run_mode_delay) {
run_mode |= 1;
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
(0x200 << 10) | 0x200);
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
(0x200 << 10) | 0x200);
} else if (dolby_vision_on_count ==
dolby_vision_run_mode_delay) {
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
(0x200 << 10) | 0x200);
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
(0x200 << 10) | 0x200);
} else {
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
(0x3ff << 20) | (0x3ff << 10) | 0x3ff);
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
0);
}
}
if (reset)
- VSYNC_WR_MPEG_REG(DOLBY_TV_REG_START + 1, run_mode);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_REG_START + 1, run_mode);
/* 962e work around to fix the uv swap issue when bl:el = 1:1 */
if (el_41_mode)
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL5, 0x6);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL5, 0x6);
else
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL5, 0xa);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL5, 0xa);
/* axi dma for reg table */
reg_size = prepare_stb_dolby_core1_reg(
}
if (reset) {
/* dma1:11-0 tv_oo+g2l size, dma2:23-12 3d lut size */
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL1,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL1,
0x00000080 | (reg_size << 23));
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL2, (u32)dma_paddr);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL2, (u32)dma_paddr);
/* dma3:23-12 cvm size */
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL3,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL3,
0x80100000 | dma_start_line);
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL0, 0x01000062);
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL0, 0x80400042);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL0, 0x01000062);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL0, 0x80400042);
}
tv_dovi_setting_update_flag = true;
DOLBY_TV_CLKGATE_CTRL, 0x2800);
if (reset) {
- VSYNC_WR_MPEG_REG(VIU_SW_RESET, 1 << 9);
- VSYNC_WR_MPEG_REG(VIU_SW_RESET, 0);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(VIU_SW_RESET, 1 << 9);
+ _VSYNC_WR_MPEG_REG(VIU_SW_RESET, 0);
+ _VSYNC_WR_MPEG_REG(
DOLBY_TV_CLKGATE_CTRL, 0x2800);
}
if (dolby_vision_flags & FLAG_DISABLE_COMPOSER)
composer_enable = 0;
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL0,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL0,
/* el dly 3, bl dly 1 after de*/
(el_41_mode ? (0x3 << 4) : (0x1 << 8)) |
bl_enable << 0 | composer_enable << 1 | el_41_mode << 2);
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL1,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL1,
((hsize + 0x80) << 16 | (vsize + 0x40)));
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL3, (hwidth << 16) | vwidth);
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL4, (hpotch << 16) | vpotch);
- VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL2, (hsize << 16) | vsize);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL3, (hwidth << 16) | vwidth);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL4, (hpotch << 16) | vpotch);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_SWAP_CTRL2, (hsize << 16) | vsize);
/*0x2c2d0:5-4-1-3-2-0*/
- VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL5, 0x2c2d0, 14, 18);
- VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL5, 0xa, 0, 4);
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL5, 0x2c2d0, 14, 18);
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL5, 0xa, 0, 4);
if ((hdmi) && (!hdr10))
- VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL5, 1, 4, 1);
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL5, 1, 4, 1);
else
- VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL5, 0, 4, 1);
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL5, 0, 4, 1);
- VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL6, 1, 20, 1);
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL6, 1, 20, 1);
/* bypass dither */
- VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL6, 1, 25, 1);
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL6, 1, 25, 1);
if (src_chroma_format == 2)
- VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL6, 1, 29, 1);
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL6, 1, 29, 1);
else if (src_chroma_format == 1)
- VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL6, 0, 29, 1);
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL6, 0, 29, 1);
/* input 12 or 10 bit */
- VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL7, 12, 0, 8);
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_TV_SWAP_CTRL7, 12, 0, 8);
if (el_enable && (dolby_vision_mask & 1))
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* vd2 to core1 */
0, 17, 1);
else
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* vd2 to vpp */
1, 17, 1);
if (dolby_vision_core1_on
&& !bypass_core1)
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* enable core 1 */
0, 16, 1);
else if (dolby_vision_core1_on
&& bypass_core1)
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* bypass core 1 */
1, 16, 1);
run_mode = tv_run_mode(vsize, hdmi, hdr10, el_41_mode);
if (dolby_vision_on_count < dolby_vision_run_mode_delay) {
run_mode = (run_mode & 0xfffffffc) | 1;
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
(0x200 << 10) | 0x200);
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
(0x200 << 10) | 0x200);
} else if (dolby_vision_on_count ==
dolby_vision_run_mode_delay) {
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
(0x200 << 10) | 0x200);
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
(0x200 << 10) | 0x200);
} else {
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC0,
(0x3ff << 20) | (0x3ff << 10) | 0x3ff);
- VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
+ _VSYNC_WR_MPEG_REG(VPP_VD1_CLIP_MISC1,
0);
}
}
((struct tv_dovi_setting_s *)tv_dovi_setting)->core1_reg_lut[1] =
0x0000000100000000 | run_mode;
if (reset)
- VSYNC_WR_MPEG_REG(DOLBY_TV_REG_START + 1, run_mode);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_REG_START + 1, run_mode);
if (!dolby_vision_on) {
WRITE_VPP_REG(DOLBY_TV_AXI2DMA_CTRL1, 0x6f666080);
WRITE_VPP_REG(DOLBY_TV_AXI2DMA_CTRL0, 0x80400042);
}
if (reset) {
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL1, 0x6f666080);
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL2, (u32)dma_paddr);
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL3,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL1, 0x6f666080);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL2, (u32)dma_paddr);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL3,
0x80000000 | dma_start_line);
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL0, 0x01000042);
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL0, 0x80400042);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL0, 0x01000042);
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL0, 0x80400042);
}
tv_dovi_setting_update_flag = true;
if (is_meson_g12() && frame_count == 1
&& dolby_vision_core1_on == 0) {
pr_dolby_dbg("((%s %d, register DOLBY_PATH_CTRL: %x))\n",
- __func__, __LINE__, VSYNC_RD_MPEG_REG(DOLBY_PATH_CTRL));
- if ((VSYNC_RD_MPEG_REG(DOLBY_PATH_CTRL) & 0x1) != 0) {
+ __func__, __LINE__,
+ _VSYNC_RD_MPEG_REG(DOLBY_PATH_CTRL));
+ if ((_VSYNC_RD_MPEG_REG(DOLBY_PATH_CTRL) & 0x1) != 0) {
pr_dolby_dbg("BL is disable for 1st frame.Re-enable BL\n");
- VSYNC_WR_MPEG_REG_BITS(DOLBY_PATH_CTRL, 0, 0, 1);
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_PATH_CTRL, 0, 0, 1);
pr_dolby_dbg("((%s %d, enable_bl, DOLBY_PATH_CTRL: %x))\n",
__func__, __LINE__,
- VSYNC_RD_MPEG_REG(DOLBY_PATH_CTRL));
+ _VSYNC_RD_MPEG_REG(DOLBY_PATH_CTRL));
}
if (el_enable) {
- if ((VSYNC_RD_MPEG_REG(DOLBY_PATH_CTRL) & 0x10) != 0) {
+ if ((_VSYNC_RD_MPEG_REG(DOLBY_PATH_CTRL) & 0x10) != 0) {
pr_dolby_dbg("((%s %d enable el))\n",
__func__, __LINE__);
- VSYNC_WR_MPEG_REG_BITS(DOLBY_PATH_CTRL,
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_PATH_CTRL,
0, 1, 1);
pr_dolby_dbg("((%s %d, enable_el, DOLBY_PATH_CTRL: %x))\n",
__func__, __LINE__,
- VSYNC_RD_MPEG_REG(DOLBY_PATH_CTRL));
+ _VSYNC_RD_MPEG_REG(DOLBY_PATH_CTRL));
}
}
}
reset = true;
if ((!dolby_vision_on || reset) && bl_enable) {
- VSYNC_WR_MPEG_REG(VIU_SW_RESET, 1 << 9);
- VSYNC_WR_MPEG_REG(VIU_SW_RESET, 0);
+ _VSYNC_WR_MPEG_REG(VIU_SW_RESET, 1 << 9);
+ _VSYNC_WR_MPEG_REG(VIU_SW_RESET, 0);
reset = true;
}
if (bl_enable && el_enable && (dolby_vision_mask & 1)) {
if (is_meson_g12())
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_PATH_CTRL,
/* vd2 to core1 */
0, 1, 1);
else
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* vd2 to core1 */
0, 17, 1);
} else {
if (is_meson_g12())
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_PATH_CTRL,
/* vd2 to core1 */
1, 1, 1);
else
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* vd2 to vpp */
1, 17, 1);
}
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_CLKGATE_CTRL, 0);
- /* VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL0, 0); */
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL1,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_CLKGATE_CTRL, 0);
+ /* _VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL0, 0); */
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL1,
((hsize + 0x80) << 16) | (vsize + 0x40));
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL3, (hwidth << 16) | vwidth);
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL4, (hpotch << 16) | vpotch);
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL2, (hsize << 16) | vsize);
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL5, 0xa);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL3, (hwidth << 16) | vwidth);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL4, (hpotch << 16) | vpotch);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL2, (hsize << 16) | vsize);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL5, 0xa);
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_CTRL, 0x0);
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_REG_START + 4, 4);
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_REG_START + 2, 1);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_CTRL, 0x0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_REG_START + 4, 4);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_REG_START + 2, 1);
/* bypass composer to get 12bit when SDR and HDR source */
#ifndef V2_4
if (el_41_mode)
bypass_flag |= 1 << 3;
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_REG_START + 1,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_REG_START + 1,
0x70 | bypass_flag); /* bypass CVM and/or CSC */
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_REG_START + 1,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_REG_START + 1,
0x70 | bypass_flag); /* for delay */
if (dm_count == 0)
count = 24;
if (reset ||
(p_core1_dm_regs[i] !=
last_dm[i]))
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_CORE1_REG_START + 6 + i,
p_core1_dm_regs[i]);
if (reset ||
(p_core1_comp_regs[i] !=
last_comp[i]))
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_CORE1_REG_START + 6 + 44 + i,
p_core1_comp_regs[i]);
/* metadata program done */
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_REG_START + 3, 1);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_REG_START + 3, 1);
if (lut_count == 0)
count = 256 * 5;
count = lut_count;
if (count && (set_lut || reset)) {
if (dolby_vision_flags & FLAG_CLKGATE_WHEN_LOAD_LUT)
- VSYNC_WR_MPEG_REG_BITS(DOLBY_CORE1_CLKGATE_CTRL,
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_CORE1_CLKGATE_CTRL,
2, 2, 2);
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_CTRL, 0x1401);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_CTRL, 0x1401);
if (lut_endian)
for (i = 0; i < count; i += 4) {
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_PORT,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_PORT,
p_core1_lut[i+3]);
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_PORT,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_PORT,
p_core1_lut[i+2]);
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_PORT,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_PORT,
p_core1_lut[i+1]);
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_PORT,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_PORT,
p_core1_lut[i]);
}
else
for (i = 0; i < count; i++)
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_PORT,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_DMA_PORT,
p_core1_lut[i]);
if (dolby_vision_flags & FLAG_CLKGATE_WHEN_LOAD_LUT)
- VSYNC_WR_MPEG_REG_BITS(DOLBY_CORE1_CLKGATE_CTRL,
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_CORE1_CLKGATE_CTRL,
0, 2, 2);
}
if (dolby_vision_on_count
<= dolby_vision_run_mode_delay) {
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_VD1_CLIP_MISC0,
(0x200 << 10) | 0x200);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_VD1_CLIP_MISC1,
(0x200 << 10) | 0x200);
if (is_meson_g12())
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_PATH_CTRL,
1,
0, 1);
else
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
1, 16, 1);
} else {
if (dolby_vision_on_count >
dolby_vision_run_mode_delay) {
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_VD1_CLIP_MISC0,
(0x3ff << 20) |
(0x3ff << 10) |
0x3ff);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_VD1_CLIP_MISC1,
0);
}
if (dolby_vision_core1_on
&& !bypass_core1) {
if (is_meson_g12())
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_PATH_CTRL,
0,
0, 1);
else
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* enable core 1 */
0, 16, 1);
} else if (dolby_vision_core1_on
&& bypass_core1) {
if (is_meson_g12())
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_PATH_CTRL,
1,
0, 1);
else
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* bypass core 1 */
1, 16, 1);
}
if (is_meson_g12())
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL0,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL0,
(el_41_mode ? (0x3 << 4) : (0x0 << 4)) |
bl_enable | composer_enable << 1 | el_41_mode << 2);
else
/* enable core1 */
- VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL0,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE1_SWAP_CTRL0,
bl_enable << 0 |
composer_enable << 1 |
el_41_mode << 2);
return 0;
if (!dolby_vision_on || force_reset_core2) {
- VSYNC_WR_MPEG_REG(VIU_SW_RESET, (1 << 10));
- VSYNC_WR_MPEG_REG(VIU_SW_RESET, 0);
+ _VSYNC_WR_MPEG_REG(VIU_SW_RESET, (1 << 10));
+ _VSYNC_WR_MPEG_REG(VIU_SW_RESET, 0);
force_reset_core2 = false;
reset = true;
}
if (stb_core_setting_update_flag & FLAG_CHANGE_TC2)
set_lut = true;
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_CLKGATE_CTRL, 0);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL0, 0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_CLKGATE_CTRL, 0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL0, 0);
if (is_meson_gxm() || is_meson_g12() || reset) {
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL1,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL1,
((hsize + g_htotal_add) << 16)
| (vsize + g_vtotal_add + g_vsize_add));
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL2,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL2,
(hsize << 16) | (vsize + g_vsize_add));
}
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL3,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL3,
(g_hwidth << 16) | g_vwidth);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL4,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL4,
(g_hpotch << 16) | g_vpotch);
if (is_meson_txlx_stbmode() || force_stb_mode)
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL5, 0xf8000000);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL5, 0xf8000000);
else if (is_meson_g12())
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL5, 0xa8000000);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL5, 0xa8000000);
else
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL5, 0x0);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_CTRL, 0x0);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_REG_START + 2, 1);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL5, 0x0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_CTRL, 0x0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_REG_START + 2, 1);
if (need_skip_cvm(1))
bypass_flag |= 1 << 0;
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_REG_START + 2, 1);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_REG_START + 1,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_REG_START + 2, 1);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_REG_START + 1,
2 | bypass_flag);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_REG_START + 1,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_REG_START + 1,
2 | bypass_flag);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_CTRL, 0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_CTRL, 0);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_CTRL, 0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_CTRL, 0);
if (dm_count == 0)
count = 24;
if (reset ||
(p_core2_dm_regs[i] !=
last_dm[i])) {
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_CORE2A_REG_START + 6 + i,
p_core2_dm_regs[i]);
set_lut = true;
set_lut = false;
/* core2 metadata program done */
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_REG_START + 3, 1);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_REG_START + 3, 1);
if (lut_count == 0)
count = 256 * 5;
count = lut_count;
if (count && (set_lut || reset)) {
if (dolby_vision_flags & FLAG_CLKGATE_WHEN_LOAD_LUT)
- VSYNC_WR_MPEG_REG_BITS(DOLBY_CORE2A_CLKGATE_CTRL,
+ _VSYNC_WR_MPEG_REG_BITS(DOLBY_CORE2A_CLKGATE_CTRL,
2, 2, 2);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_CTRL, 0x1401);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_CTRL, 0x1401);
if (lut_endian)
for (i = 0; i < count; i += 4) {
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_PORT,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_PORT,
p_core2_lut[i+3]);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_PORT,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_PORT,
p_core2_lut[i+2]);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_PORT,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_PORT,
p_core2_lut[i+1]);
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_PORT,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_PORT,
p_core2_lut[i]);
}
else
for (i = 0; i < count; i++)
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_PORT,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_DMA_PORT,
p_core2_lut[i]);
/* core2 lookup table program done */
if (dolby_vision_flags & FLAG_CLKGATE_WHEN_LOAD_LUT)
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_CORE2A_CLKGATE_CTRL, 0, 2, 2);
}
/* enable core2 */
- VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL0, dolby_enable << 0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE2A_SWAP_CTRL0, dolby_enable << 0);
return 0;
}
is_meson_g12()) {
if (new_dovi_setting.dovi_ll_enable &&
new_dovi_setting.diagnostic_enable == 0) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL,
3, 6, 2); /* post matrix */
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_MATRIX_CTRL,
1, 0, 1); /* post matrix */
} else {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL,
0, 6, 2); /* post matrix */
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_MATRIX_CTRL,
0, 0, 1); /* post matrix */
}
} else if (is_meson_txlx_stbmode()
|| force_stb_mode) {
if (pps_state == 2) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL,
1, 0, 1); /* skip pps/dither/cm */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA0, 0x08000800);
} else if (pps_state == 1) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL,
0, 0, 1); /* enable pps/dither/cm */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA0, 0x20002000);
}
if (new_dovi_setting.dovi_ll_enable &&
new_dovi_setting.diagnostic_enable == 0) {
/*bypass gainoff to vks */
/*enable wn tp vks*/
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 0, 2, 1);
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 1, 1, 1);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA1, 0x8000800);
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_MATRIX_CTRL,
1, 0, 1); /* post matrix */
} else {
/* bypass wm tp vks*/
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 1, 2, 1);
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 0, 1, 1);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA1, 0x20002000);
if (is_meson_txlx_tvmode())
enable_rgb_to_yuv_matrix_for_dvll(
0, NULL, 12);
else
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_MATRIX_CTRL,
0, 0, 1);
}
1, &p_core3_dm_regs[18], 12);
#endif
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_CLKGATE_CTRL, 0);
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL1,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_CLKGATE_CTRL, 0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL1,
((hsize + htotal_add) << 16)
| (vsize + vtotal_add + vsize_add + vsize_hold * 2));
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL2,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL2,
(hsize << 16) | (vsize + vsize_add));
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL3,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL3,
(0x80 << 16) | vsize_hold);
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL4,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL4,
(0x04 << 16) | vsize_hold);
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL5, 0x0000);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL5, 0x0000);
if (cur_dv_mode !=
DOLBY_VISION_OUTPUT_MODE_IPT_TUNNEL)
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL6, 0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL6, 0);
else
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL6,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL6,
0x10000000); /* swap UV */
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 5, 7);
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 4, 4);
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 4, 2);
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 2, 1);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 5, 7);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 4, 4);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 4, 2);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 2, 1);
/* Control Register, address 0x04 2:0 RW */
/* Output_operating mode*/
/* 00- IPT 12 bit 444 bypass Dolby Vision output*/
/* 02- HDR10 output, RGB 10 bit 444 PQ*/
/* 03- Deep color SDR, RGB 10 bit 444 Gamma*/
/* 04- SDR, RGB 8 bit 444 Gamma*/
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 1, cur_dv_mode);
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 1, cur_dv_mode);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 1, cur_dv_mode);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 1, cur_dv_mode);
/* for delay */
if (dm_count == 0)
for (i = 0; i < count; i++)
if (reset || (p_core3_dm_regs[i] !=
last_dm[i]))
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_CORE3_REG_START + 0x6 + i,
p_core3_dm_regs[i]);
/* from addr 0x18 */
for (i = 0; i < count; i++) {
#ifdef FORCE_HDMI_META
if ((i == 20) && (p_core3_md_regs[i] == 0x5140a3e))
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 0x24 + i,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 0x24 + i,
(p_core3_md_regs[i] & 0xffffff00) | 0x80);
else
#endif
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 0x24 + i,
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 0x24 + i,
p_core3_md_regs[i]);
}
for (; i < 30; i++)
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 0x24 + i, 0);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 0x24 + i, 0);
/* from addr 0x90 */
/* core3 metadata program done */
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 3, 1);
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_REG_START + 3, 1);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_CORE3_DIAG_CTRL,
diag_mode);
if ((dolby_vision_flags & FLAG_CERTIFICAION)
&& !(dolby_vision_flags & FLAG_DISABLE_CRC))
- VSYNC_WR_MPEG_REG(0x36fb, 1);
+ _VSYNC_WR_MPEG_REG(0x36fb, 1);
/* enable core3 */
- VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL0, (dolby_enable << 0));
+ _VSYNC_WR_MPEG_REG(DOLBY_CORE3_SWAP_CTRL0, (dolby_enable << 0));
return 0;
}
static uint32_t osd_backup_mtx;
if (bypass) {
- osd_backup_ctrl = VSYNC_RD_MPEG_REG(VIU_OSD1_CTRL_STAT);
- osd_backup_eotf = VSYNC_RD_MPEG_REG(VIU_OSD1_EOTF_CTL);
- osd_backup_mtx = VSYNC_RD_MPEG_REG(VPP_MATRIX_CTRL);
- VSYNC_WR_MPEG_REG_BITS(VIU_OSD1_EOTF_CTL, 0, 31, 1);
- VSYNC_WR_MPEG_REG_BITS(VIU_OSD1_CTRL_STAT, 0, 3, 1);
- VSYNC_WR_MPEG_REG_BITS(VPP_MATRIX_CTRL, 0, 7, 1);
+ osd_backup_ctrl = _VSYNC_RD_MPEG_REG(VIU_OSD1_CTRL_STAT);
+ osd_backup_eotf = _VSYNC_RD_MPEG_REG(VIU_OSD1_EOTF_CTL);
+ osd_backup_mtx = _VSYNC_RD_MPEG_REG(VPP_MATRIX_CTRL);
+ _VSYNC_WR_MPEG_REG_BITS(VIU_OSD1_EOTF_CTL, 0, 31, 1);
+ _VSYNC_WR_MPEG_REG_BITS(VIU_OSD1_CTRL_STAT, 0, 3, 1);
+ _VSYNC_WR_MPEG_REG_BITS(VPP_MATRIX_CTRL, 0, 7, 1);
} else {
- VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, osd_backup_mtx);
- VSYNC_WR_MPEG_REG(VIU_OSD1_CTRL_STAT, osd_backup_ctrl);
- VSYNC_WR_MPEG_REG(VIU_OSD1_EOTF_CTL, osd_backup_eotf);
+ _VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, osd_backup_mtx);
+ _VSYNC_WR_MPEG_REG(VIU_OSD1_CTRL_STAT, osd_backup_ctrl);
+ _VSYNC_WR_MPEG_REG(VIU_OSD1_EOTF_CTL, osd_backup_eotf);
}
}
if (bypass) {
if (!is_video_effect_bypass) {
viu_eotf_ctrl_backup =
- VSYNC_RD_MPEG_REG(VIU_EOTF_CTL);
+ _VSYNC_RD_MPEG_REG(VIU_EOTF_CTL);
xvycc_lut_ctrl_backup =
- VSYNC_RD_MPEG_REG(XVYCC_LUT_CTL);
+ _VSYNC_RD_MPEG_REG(XVYCC_LUT_CTL);
inv_lut_ctrl_backup =
- VSYNC_RD_MPEG_REG(XVYCC_INV_LUT_CTL);
+ _VSYNC_RD_MPEG_REG(XVYCC_INV_LUT_CTL);
vpp_vadj_backup =
- VSYNC_RD_MPEG_REG(VPP_VADJ_CTRL);
+ _VSYNC_RD_MPEG_REG(VPP_VADJ_CTRL);
vpp_gainoff_backup =
- VSYNC_RD_MPEG_REG(VPP_GAINOFF_CTRL0);
+ _VSYNC_RD_MPEG_REG(VPP_GAINOFF_CTRL0);
vpp_ve_enable_ctrl_backup =
- VSYNC_RD_MPEG_REG(VPP_VE_ENABLE_CTRL);
+ _VSYNC_RD_MPEG_REG(VPP_VE_ENABLE_CTRL);
xvycc_vd1_rgb_ctrst_backup =
- VSYNC_RD_MPEG_REG(XVYCC_VD1_RGB_CTRST);
+ _VSYNC_RD_MPEG_REG(XVYCC_VD1_RGB_CTRST);
is_video_effect_bypass = true;
}
- VSYNC_WR_MPEG_REG(VIU_EOTF_CTL, 0);
- VSYNC_WR_MPEG_REG(XVYCC_LUT_CTL, 0);
- VSYNC_WR_MPEG_REG(XVYCC_INV_LUT_CTL, 0);
- VSYNC_WR_MPEG_REG(VPP_VADJ_CTRL, 0);
- VSYNC_WR_MPEG_REG(VPP_GAINOFF_CTRL0, 0);
- VSYNC_WR_MPEG_REG(VPP_VE_ENABLE_CTRL, 0);
- VSYNC_WR_MPEG_REG(XVYCC_VD1_RGB_CTRST, 0);
+ _VSYNC_WR_MPEG_REG(VIU_EOTF_CTL, 0);
+ _VSYNC_WR_MPEG_REG(XVYCC_LUT_CTL, 0);
+ _VSYNC_WR_MPEG_REG(XVYCC_INV_LUT_CTL, 0);
+ _VSYNC_WR_MPEG_REG(VPP_VADJ_CTRL, 0);
+ _VSYNC_WR_MPEG_REG(VPP_GAINOFF_CTRL0, 0);
+ _VSYNC_WR_MPEG_REG(VPP_VE_ENABLE_CTRL, 0);
+ _VSYNC_WR_MPEG_REG(XVYCC_VD1_RGB_CTRST, 0);
} else if (is_video_effect_bypass) {
- VSYNC_WR_MPEG_REG(VIU_EOTF_CTL,
+ _VSYNC_WR_MPEG_REG(VIU_EOTF_CTL,
viu_eotf_ctrl_backup);
- VSYNC_WR_MPEG_REG(XVYCC_LUT_CTL,
+ _VSYNC_WR_MPEG_REG(XVYCC_LUT_CTL,
xvycc_lut_ctrl_backup);
- VSYNC_WR_MPEG_REG(XVYCC_INV_LUT_CTL,
+ _VSYNC_WR_MPEG_REG(XVYCC_INV_LUT_CTL,
inv_lut_ctrl_backup);
- VSYNC_WR_MPEG_REG(VPP_VADJ_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_VADJ_CTRL,
vpp_vadj_backup);
- VSYNC_WR_MPEG_REG(VPP_GAINOFF_CTRL0,
+ _VSYNC_WR_MPEG_REG(VPP_GAINOFF_CTRL0,
vpp_gainoff_backup);
- VSYNC_WR_MPEG_REG(VPP_VE_ENABLE_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_VE_ENABLE_CTRL,
vpp_ve_enable_ctrl_backup);
- VSYNC_WR_MPEG_REG(XVYCC_VD1_RGB_CTRST,
+ _VSYNC_WR_MPEG_REG(XVYCC_VD1_RGB_CTRST,
xvycc_vd1_rgb_ctrst_backup);
}
}
if (!on) {
enable_osd_path(0, 0);
- VSYNC_WR_MPEG_REG(VIU_OSD1_EOTF_CTL, 0);
- VSYNC_WR_MPEG_REG(VIU_OSD1_OETF_CTL, 0);
+ _VSYNC_WR_MPEG_REG(VIU_OSD1_EOTF_CTL, 0);
+ _VSYNC_WR_MPEG_REG(VIU_OSD1_OETF_CTL, 0);
} else {
enable_osd_path(1, -1);
if ((hdr_osd_reg.viu_osd1_eotf_ctl & 0x80000000) != 0) {
addr_port = VIU_OSD1_EOTF_LUT_ADDR_PORT;
data_port = VIU_OSD1_EOTF_LUT_DATA_PORT;
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
addr_port, 0);
for (i = 0; i < 16; i++)
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
data_port,
lut->r_map[i * 2]
| (lut->r_map[i * 2 + 1] << 16));
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
data_port,
lut->r_map[EOTF_LUT_SIZE - 1]
| (lut->g_map[0] << 16));
for (i = 0; i < 16; i++)
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
data_port,
lut->g_map[i * 2 + 1]
| (lut->b_map[i * 2 + 2] << 16));
for (i = 0; i < 16; i++)
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
data_port,
lut->b_map[i * 2]
| (lut->b_map[i * 2 + 1] << 16));
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
data_port, lut->b_map[EOTF_LUT_SIZE - 1]);
/* load eotf matrix */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_EOTF_COEF00_01,
hdr_osd_reg.viu_osd1_eotf_coef00_01);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_EOTF_COEF02_10,
hdr_osd_reg.viu_osd1_eotf_coef02_10);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_EOTF_COEF11_12,
hdr_osd_reg.viu_osd1_eotf_coef11_12);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_EOTF_COEF20_21,
hdr_osd_reg.viu_osd1_eotf_coef20_21);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_EOTF_COEF22_RS,
hdr_osd_reg.viu_osd1_eotf_coef22_rs);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_EOTF_CTL,
hdr_osd_reg.viu_osd1_eotf_ctl);
}
addr_port = VIU_OSD1_OETF_LUT_ADDR_PORT;
data_port = VIU_OSD1_OETF_LUT_DATA_PORT;
for (i = 0; i < 20; i++) {
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
addr_port, i);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
data_port,
lut->or_map[i * 2]
| (lut->or_map[i * 2 + 1] << 16));
}
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
addr_port, 20);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
data_port,
lut->or_map[41 - 1]
| (lut->og_map[0] << 16));
for (i = 0; i < 20; i++) {
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
addr_port, 21 + i);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
data_port,
lut->og_map[i * 2 + 1]
| (lut->og_map[i * 2 + 2] << 16));
}
for (i = 0; i < 20; i++) {
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
addr_port, 41 + i);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
data_port,
lut->ob_map[i * 2]
| (lut->ob_map[i * 2 + 1] << 16));
}
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
addr_port, 61);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
data_port,
lut->ob_map[41 - 1]);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_OETF_CTL,
hdr_osd_reg.viu_osd1_oetf_ctl);
}
}
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_PRE_OFFSET0_1,
hdr_osd_reg.viu_osd1_matrix_pre_offset0_1);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_PRE_OFFSET2,
hdr_osd_reg.viu_osd1_matrix_pre_offset2);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_COEF00_01,
hdr_osd_reg.viu_osd1_matrix_coef00_01);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_COEF02_10,
hdr_osd_reg.viu_osd1_matrix_coef02_10);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_COEF11_12,
hdr_osd_reg.viu_osd1_matrix_coef11_12);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_COEF20_21,
hdr_osd_reg.viu_osd1_matrix_coef20_21);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_COEF22_30,
hdr_osd_reg.viu_osd1_matrix_coef22_30);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_COEF31_32,
hdr_osd_reg.viu_osd1_matrix_coef31_32);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_COEF40_41,
hdr_osd_reg.viu_osd1_matrix_coef40_41);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_COLMOD_COEF42,
hdr_osd_reg.viu_osd1_matrix_colmod_coef42);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_OFFSET0_1,
hdr_osd_reg.viu_osd1_matrix_offset0_1);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_OFFSET2,
hdr_osd_reg.viu_osd1_matrix_offset2);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VIU_OSD1_MATRIX_CTRL,
hdr_osd_reg.viu_osd1_matrix_ctrl);
}
if (enable) {
if (!dolby_vision_on) {
dolby_ctrl_backup =
- VSYNC_RD_MPEG_REG(VPP_DOLBY_CTRL);
+ _VSYNC_RD_MPEG_REG(VPP_DOLBY_CTRL);
viu_misc_ctrl_backup =
- VSYNC_RD_MPEG_REG(VIU_MISC_CTRL1);
+ _VSYNC_RD_MPEG_REG(VIU_MISC_CTRL1);
vpp_matrix_backup =
- VSYNC_RD_MPEG_REG(VPP_MATRIX_CTRL);
+ _VSYNC_RD_MPEG_REG(VPP_MATRIX_CTRL);
vpp_dummy1_backup =
- VSYNC_RD_MPEG_REG(VPP_DUMMY_DATA1);
+ _VSYNC_RD_MPEG_REG(VPP_DUMMY_DATA1);
if (is_meson_txlx()) {
vpp_data_conv_para0_backup =
- VSYNC_RD_MPEG_REG(VPP_DAT_CONV_PARA0);
+ _VSYNC_RD_MPEG_REG(VPP_DAT_CONV_PARA0);
vpp_data_conv_para1_backup =
- VSYNC_RD_MPEG_REG(VPP_DAT_CONV_PARA1);
+ _VSYNC_RD_MPEG_REG(VPP_DAT_CONV_PARA1);
setting_update_count = 0;
}
if (is_meson_txlx_tvmode() && !force_stb_mode) {
}
if ((dolby_vision_mask & 1)
&& dovi_setting_video_flag) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
0,
16, 1); /* core1 */
dolby_vision_core1_on = true;
} else {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
1,
16, 1); /* core1 */
}
if (dolby_vision_flags & FLAG_CERTIFICAION) {
/* bypass dither/PPS/SR/CM, EO/OE */
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 3, 0, 2);
/* bypass all video effect */
video_effect_bypass(1);
/* before vadj1 */
/* 12 bit sign to unsign*/
/* before post blend */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA0, 0x08000800);
/* 12->10 before vadj2*/
/* 10->12 after gainoff */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA1, 0x20002000);
WRITE_VPP_REG(0x33e7, 0xb);
} else {
video_effect_bypass(1);
/* 12->10 before vadj1*/
/* 10->12 before post blend */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA0, 0x20002000);
/* 12->10 before vadj2*/
/* 10->12 after gainoff */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA1, 0x20002000);
}
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DUMMY_DATA1,
0x80200);
/* osd rgb to yuv, vpp out yuv to rgb */
- VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, 0x81);
+ _VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, 0x81);
pr_dolby_dbg("Dolby Vision TV core turn on\n");
} else if (is_meson_txlx_stbmode()
|| force_stb_mode) {
memset(dma_vaddr, 0x0, size);
osd_bypass(1);
if (dolby_vision_mask & 4)
- VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
+ _VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
1, 3, 1); /* core3 enable */
if ((dolby_vision_mask & 1)
&& dovi_setting_video_flag) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
0,
16, 1); /* core1 */
dolby_vision_core1_on = true;
} else {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
1,
16, 1); /* core1 */
dolby_vision_core1_on = false;
}
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
(((dolby_vision_mask & 1)
&& dovi_setting_video_flag)
? 0 : 1),
16, 1); /* core1 */
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
((dolby_vision_mask & 2) ? 0 : 1),
18, 1); /* core2 */
/* bypass dither/PPS/SR/CM*/
/* bypass EO/OE*/
/* bypass vadj2/mtx/gainoff */
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 7, 0, 3);
/* bypass all video effect */
video_effect_bypass(1);
/* before vadj1 */
/* 12 bit sign to unsign*/
/* before post blend */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA0, 0x08000800);
/* 12->10 before vadj2*/
/* 10->12 after gainoff */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA1, 0x20002000);
} else {
/* bypass all video effect */
video_effect_bypass(1);
/* 12->10 before vadj1*/
/* 10->12 before post blend */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA0, 0x20002000);
/* 12->10 before vadj2*/
/* 10->12 after gainoff */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA1, 0x20002000);
}
- VSYNC_WR_MPEG_REG(VPP_DUMMY_DATA1,
+ _VSYNC_WR_MPEG_REG(VPP_DUMMY_DATA1,
0x80200);
if (is_meson_txlx_tvmode())
- VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, 1);
+ _VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, 1);
else
- VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, 0);
+ _VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, 0);
#ifdef V2_4
if (((dolby_vision_mode ==
DOLBY_VISION_OUTPUT_MODE_IPT_TUNNEL)
u32 *reg =
(u32 *)&dovi_setting.dm_reg3;
/* input u12 -0x800 to s12 */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA1, 0x8000800);
/* bypass vadj */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_VADJ_CTRL, 0);
/* bypass gainoff */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_GAINOFF_CTRL0, 0);
/* enable wm tp vks*/
/* bypass gainoff to vks */
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 1, 1, 2);
enable_rgb_to_yuv_matrix_for_dvll(
1, ®[18], 12);
pr_dolby_dbg("Dolby Vision STB cores turn on\n");
} else if (is_meson_g12()) {
if (dolby_vision_mask & 4)
- VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
+ _VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
1, 3, 1); /* core3 enable */
else
- VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
+ _VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
0, 3, 1); /* bypass core3 */
- VSYNC_WR_MPEG_REG(VPP_WRAP_OSD1_MATRIX_EN_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_WRAP_OSD1_MATRIX_EN_CTRL,
0x0);
- VSYNC_WR_MPEG_REG(VPP_WRAP_OSD2_MATRIX_EN_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_WRAP_OSD2_MATRIX_EN_CTRL,
0x0);
- VSYNC_WR_MPEG_REG(VPP_WRAP_OSD3_MATRIX_EN_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_WRAP_OSD3_MATRIX_EN_CTRL,
0x0);
if (dolby_vision_mask & 2)
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_PATH_CTRL,
0,
2, 1);/*core2 enable*/
else
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_PATH_CTRL,
1,
2, 1);/*core2 bypass*/
if ((dolby_vision_mask & 1)
&& dovi_setting_video_flag) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_PATH_CTRL,
0,
0, 1); /* core1 */
dolby_vision_core1_on = true;
} else {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_PATH_CTRL,
1,
0, 1); /* core1 */
/* bypass dither/PPS/SR/CM*/
/* bypass EO/OE*/
/* bypass vadj2/mtx/gainoff */
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 7, 0, 3);
/* bypass all video effect */
video_effect_bypass(1);
/* before vadj1 */
/* 12 bit sign to unsign*/
/* before post blend */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA0, 0x08000800);
/* 12->10 before vadj2*/
/* 10->12 after gainoff */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA1, 0x20002000);
} else {
/* bypass all video effect */
video_effect_bypass(1);
/* 12->10 before vadj1*/
/* 10->12 before post blend */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA0, 0x20002000);
/* 12->10 before vadj2*/
/* 10->12 after gainoff */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA1, 0x20002000);
}
- VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, 0);
- VSYNC_WR_MPEG_REG(VPP_DUMMY_DATA1,
+ _VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, 0);
+ _VSYNC_WR_MPEG_REG(VPP_DUMMY_DATA1,
0x80200);
#ifdef V2_4
if (((dolby_vision_mode ==
u32 *reg =
(u32 *)&dovi_setting.dm_reg3;
/* input u12 -0x800 to s12 */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA1, 0x8000800);
/* bypass vadj */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_VADJ_CTRL, 0);
/* bypass gainoff */
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_GAINOFF_CTRL0, 0);
/* enable wm tp vks*/
/* bypass gainoff to vks */
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 1, 1, 2);
enable_rgb_to_yuv_matrix_for_dvll(
1, ®[18],
#endif
pr_dolby_dbg("Dolby Vision G12a turn on\n");
} else {
- VSYNC_WR_MPEG_REG(VPP_DOLBY_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_DOLBY_CTRL,
/* cm_datx4_mode */
(0x0<<21) |
/* reg_front_cti_bit_mode */
(0x3<<8) |
/* vpp_uns2s_mode 7:0 */
0x1f);
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* 23-20 ext mode */
(0 << 2) |
18, 6);
if ((dolby_vision_mask & 1)
&& dovi_setting_video_flag) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
0,
16, 1); /* core1 */
dolby_vision_core1_on = true;
} else {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
1,
16, 1); /* core1 */
if ((dolby_vision_flags & FLAG_BYPASS_VPP)
|| (dolby_vision_flags & FLAG_CERTIFICAION))
video_effect_bypass(1);
- VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, 0);
- VSYNC_WR_MPEG_REG(VPP_DUMMY_DATA1, 0x20000000);
+ _VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL, 0);
+ _VSYNC_WR_MPEG_REG(VPP_DUMMY_DATA1, 0x20000000);
/* disable osd effect and shadow mode */
osd_path_enable(0);
#ifdef V2_4
dovi_setting.dovi_ll_enable) {
u32 *reg =
(u32 *)&dovi_setting.dm_reg3;
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL,
3, 6, 2); /* post matrix */
enable_rgb_to_yuv_matrix_for_dvll(
if (!dolby_vision_core1_on
&& (dolby_vision_mask & 1)
&& dovi_setting_video_flag) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
0,
16, 1); /* core1 */
} else if (dolby_vision_core1_on
&& (!(dolby_vision_mask & 1)
|| !dovi_setting_video_flag)){
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
1,
16, 1); /* core1 */
} else {
if (dolby_vision_on) {
if (is_meson_txlx_tvmode() && !force_stb_mode) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
/* vd2 connect to vpp */
(1 << 1) |
pr_dolby_dbg("Dolby Vision TV core turn off\n");
} else if (is_meson_txlx_stbmode()
|| force_stb_mode) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
(1 << 2) | /* core2 bypass */
(1 << 1) | /* vd2 connect to vpp */
(1 << 0), /* core1 bl bypass */
16, 3);
- VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
+ _VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
0, 3, 1); /* core3 disable */
osd_bypass(0);
#ifdef V2_4
memset(&dovi_setting, 0, sizeof(dovi_setting));
pr_dolby_dbg("Dolby Vision STB cores turn off\n");
} else if (is_meson_g12()) {
- VSYNC_WR_MPEG_REG(VPP_WRAP_OSD1_MATRIX_EN_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_WRAP_OSD1_MATRIX_EN_CTRL,
0x1);
- VSYNC_WR_MPEG_REG(VPP_WRAP_OSD2_MATRIX_EN_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_WRAP_OSD2_MATRIX_EN_CTRL,
0x1);
- VSYNC_WR_MPEG_REG(VPP_WRAP_OSD3_MATRIX_EN_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_WRAP_OSD3_MATRIX_EN_CTRL,
0x1);
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
DOLBY_PATH_CTRL,
(1 << 2) | /* core2 bypass */
(1 << 1) | /* vd2 connect to vpp */
(1 << 0), /* core1 bl bypass */
0, 3);
- VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
+ _VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
0, 3, 1); /* core3 disable */
#ifdef V2_4
if (p_funcs) /* destroy ctx */
memset(&dovi_setting, 0, sizeof(dovi_setting));
pr_dolby_dbg("Dolby Vision G12a turn off\n");
} else {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VIU_MISC_CTRL1,
(1 << 2) | /* core2 bypass */
(1 << 1) | /* vd2 connect to vpp */
(1 << 0), /* core1 bl bypass */
16, 3);
- VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
+ _VSYNC_WR_MPEG_REG_BITS(VPP_DOLBY_CTRL,
0, 16, 1); /* core3 disable */
/* enable osd effect and*/
/* use default shadow mode */
memset(&dovi_setting, 0, sizeof(dovi_setting));
pr_dolby_dbg("Dolby Vision turn off\n");
}
- VSYNC_WR_MPEG_REG(VIU_SW_RESET, 3 << 9);
- VSYNC_WR_MPEG_REG(VIU_SW_RESET, 0);
+ _VSYNC_WR_MPEG_REG(VIU_SW_RESET, 3 << 9);
+ _VSYNC_WR_MPEG_REG(VIU_SW_RESET, 0);
if (is_meson_txlx()) {
- VSYNC_WR_MPEG_REG(VPP_DAT_CONV_PARA0,
+ _VSYNC_WR_MPEG_REG(VPP_DAT_CONV_PARA0,
vpp_data_conv_para0_backup);
- VSYNC_WR_MPEG_REG(VPP_DAT_CONV_PARA1,
+ _VSYNC_WR_MPEG_REG(VPP_DAT_CONV_PARA1,
vpp_data_conv_para1_backup);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_TV_CLKGATE_CTRL,
0x2414);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_CORE2A_CLKGATE_CTRL,
0x4);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_CORE3_CLKGATE_CTRL,
0x414);
- VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL0,
+ _VSYNC_WR_MPEG_REG(DOLBY_TV_AXI2DMA_CTRL0,
0x01000042);
}
if (is_meson_gxm() ||
is_meson_g12()) {
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_CORE1_CLKGATE_CTRL,
0x55555555);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_CORE2A_CLKGATE_CTRL,
0x55555555);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
DOLBY_CORE3_CLKGATE_CTRL,
0x55555555);
}
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_VD1_CLIP_MISC0,
(0x3ff << 20)
| (0x3ff << 10) | 0x3ff);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_VD1_CLIP_MISC1,
0);
video_effect_bypass(0);
- VSYNC_WR_MPEG_REG(VPP_DOLBY_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_DOLBY_CTRL,
dolby_ctrl_backup);
/* always vd2 to vpp and bypass core 1 */
viu_misc_ctrl_backup |=
- (VSYNC_RD_MPEG_REG(VIU_MISC_CTRL1) & 2);
- VSYNC_WR_MPEG_REG(VIU_MISC_CTRL1,
+ (_VSYNC_RD_MPEG_REG(VIU_MISC_CTRL1) & 2);
+ _VSYNC_WR_MPEG_REG(VIU_MISC_CTRL1,
viu_misc_ctrl_backup
| (3 << 16));
- VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL,
+ _VSYNC_WR_MPEG_REG(VPP_MATRIX_CTRL,
vpp_matrix_backup);
- VSYNC_WR_MPEG_REG(VPP_DUMMY_DATA1,
+ _VSYNC_WR_MPEG_REG(VPP_DUMMY_DATA1,
vpp_dummy1_backup);
}
frame_count = 0;
if (is_meson_txlx_package_962E()
|| force_stb_mode) {
if (pps_state == 2) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 1, 0, 1);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA0, 0x08000800);
} else if (pps_state == 1) {
- VSYNC_WR_MPEG_REG_BITS(
+ _VSYNC_WR_MPEG_REG_BITS(
VPP_DOLBY_CTRL, 0, 0, 1);
- VSYNC_WR_MPEG_REG(
+ _VSYNC_WR_MPEG_REG(
VPP_DAT_CONV_PARA0, 0x20002000);
}
}
&& (setting_update_count == 1)
&& (crc_read_delay == 1)) {
/* work around to enable crc for frame 0 */
- VSYNC_WR_MPEG_REG(0x36fb, 1);
+ _VSYNC_WR_MPEG_REG(0x36fb, 1);
crc_read_delay++;
} else {
crc_read_delay++;
projects / platform / kernel / linux-amlogic.git / commitdiff