BPI/BPI-CM9-Linux
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
BPI-CM9-Linux/aml-comp/uboot/bl33/v2015/drivers/display/osd/dolby_vision.c
T

1393 lines
38 KiB
C
Raw Permalink Blame History

/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
/*
* drivers/display/osd/dolby_vision.c
*
* Copyright (C) 2020 Amlogic, Inc. All rights reserved.
*
*/
#include <common.h>
#include <asm/arch/io.h>
#include <asm/arch/secure_apb.h>
#include <amlogic/vmode.h>
#include <amlogic/storage_if.h>
#include <amlogic/vout.h>
#include <amlogic/hdmi.h>
#include <amlogic/dolby_vision.h>
#include <malloc.h>
#include <config.h>
#include <mmc.h>
#include <asm/byteorder.h>
#include <asm/unaligned.h>
#include <amlogic/dolby_vision_func.h>
#include <asm/cpu_id.h>
#include "vpp.h"
#include "hdr2.h"
#include <asm/arch/io.h>
#include <asm/arch/secure_apb.h>
static struct dovi_setting_s dovi_setting;
static struct dovi_mode_s dovi_mode;
static unsigned int dolby_vision_mode = DOLBY_VISION_OUTPUT_MODE_BYPASS;
static unsigned int dolby_vision_ll_policy = DOLBY_VISION_LL_DISABLE;
static unsigned int dv_ll_output_mode = DOLBY_VISION_OUTPUT_MODE_HDR10;
static unsigned int dolby_vision_target_min = 50; /* 0.0001 */
static unsigned int dolby_vision_target_max[3][3] = {
{ 4000, 1000, 100 }, /* DOVI => DOVI/HDR/SDR */
{ 1000, 1000, 100 }, /* HDR => DOVI/HDR/SDR */
{ 600, 1000, 100 }, /* SDR => DOVI/HDR/SDR */
};
static unsigned int dolby_vision_target_graphics_max[3] = {
300, 375, 100
}; /* DOVI/HDR/SDR */
/* 0: video priority 1: graphic priority */
static unsigned int dv_graphics_priority = 1;
static unsigned int vinfo_width = 1920;
static unsigned int vinfo_height = 1080;
static unsigned int vinfo_duration_num = 60;
static unsigned int vinfo_field_height = 1080;
static bool dolby_vision_on;
static char *dolby_status;
static bool dv_fw_valid = true;
#define COEFF_NORM(a) ((int)((((a) * 2048.0) + 1) / 2))
#define MATRIX_5x3_COEF_SIZE 24
static int RGB709_to_YUV709l_coeff[MATRIX_5x3_COEF_SIZE] = {
0, 0, 0, /* pre offset */
COEFF_NORM(0.181873), COEFF_NORM(0.611831), COEFF_NORM(0.061765),
COEFF_NORM(-0.100251), COEFF_NORM(-0.337249), COEFF_NORM(0.437500),
COEFF_NORM(0.437500), COEFF_NORM(-0.397384), COEFF_NORM(-0.040116),
0, 0, 0, /* 10'/11'/12' */
0, 0, 0, /* 20'/21'/22' */
64, 512, 512, /* offset */
0, 0, 0 /* mode, right_shift, clip_en */
};
static int bypass_coeff[MATRIX_5x3_COEF_SIZE] = {
0, 0, 0, /* pre offset */
COEFF_NORM(1.0), COEFF_NORM(0.0), COEFF_NORM(0.0),
COEFF_NORM(0.0), COEFF_NORM(1.0), COEFF_NORM(0.0),
COEFF_NORM(0.0), COEFF_NORM(0.0), COEFF_NORM(1.0),
0, 0, 0, /* 10'/11'/12' */
0, 0, 0, /* 20'/21'/22' */
0, 0, 0, /* offset */
0, 0, 0 /* mode, right_shift, clip_en */
};
static int dvll_RGB_to_YUV709l_coeff[MATRIX_5x3_COEF_SIZE] = {
0, 0, 0, /* pre offset */
COEFF_NORM(0.181873), COEFF_NORM(0.611831), COEFF_NORM(0.061765),
COEFF_NORM(-0.100251), COEFF_NORM(-0.337249), COEFF_NORM(0.437500),
COEFF_NORM(0.437500), COEFF_NORM(-0.397384), COEFF_NORM(-0.040116),
0, 0, 0, /* 10'/11'/12' */
0, 0, 0, /* 20'/21'/22' */
64, 512, 512, /* offset */
0, 0, 0 /* mode, right_shift, clip_en */
};
static int *cur_osd_mtx = RGB709_to_YUV709l_coeff;
static int *cur_vd1_mtx = bypass_coeff;
static unsigned int debug_enable = 0;
static bool tv_mode;
#define MAX_PARAM 8
#define REG_OFFSET_VCBUS(reg) ((reg << 2))
#define REG_ADDR_VCBUS(reg) (REG_BASE_VCBUS + REG_OFFSET_VCBUS(reg))
static inline u32 READ_VPP_REG(u32 reg)
{
return (*(volatile unsigned int *)REG_ADDR_VCBUS(reg));
}
static inline void WRITE_VPP_REG(u32 reg,
const u32 val)
{
*(volatile unsigned int *)REG_ADDR_VCBUS(reg) = (val);
}
static inline void WRITE_VPP_REG_BITS(uint32_t reg,
const uint32_t value, const uint32_t start, const uint32_t len)
{
WRITE_VPP_REG(reg, ((READ_VPP_REG(reg) &
~(((1L << (len)) - 1) << (start))) |
(((value) & ((1L << (len)) - 1)) << (start))));
}
static bool is_meson_gxm(void)
{
if (get_cpu_id().family_id == MESON_CPU_MAJOR_ID_GXM)
return true;
else
return false;
}
static bool is_meson_g12(void)
{
if (get_cpu_id().family_id == MESON_CPU_MAJOR_ID_G12A ||
get_cpu_id().family_id == MESON_CPU_MAJOR_ID_G12B ||
get_cpu_id().family_id == MESON_CPU_MAJOR_ID_SM1)
return true;
else
return false;
}
static bool is_meson_box(void)
{
if (is_meson_gxm() || is_meson_g12())
return true;
else
return false;
}
static bool is_meson_txlx(void)
{
if (get_cpu_id().family_id == MESON_CPU_MAJOR_ID_TXLX)
return true;
else
return false;
}
static bool is_meson_txlx_tvmode(void)
{
if ((is_meson_txlx()) && (tv_mode == 1))
return true;
else
return false;
}
static bool is_meson_txlx_stbmode(void)
{
if ((is_meson_txlx()) && (tv_mode == 0))
return true;
else
return false;
}
static bool is_meson_tm2(void)
{
if (get_cpu_id().family_id == MESON_CPU_MAJOR_ID_TM2)
return true;
else
return false;
}
static bool is_meson_tm2_tvmode(void)
{
if ((is_meson_tm2()) && (tv_mode == 1))
return true;
else
return false;
}
static bool is_meson_tm2_stbmode(void)
{
if ((is_meson_tm2()) && (tv_mode == 0))
return true;
else
return false;
}
static bool is_meson_tvmode(void)
{
if (is_meson_tm2_tvmode() ||
is_meson_txlx_tvmode())
return true;
else
return false;
}
#ifdef CONFIG_AML_DOLBY
/*check dolby enable status,if status is disabled, not enable dolby
*/
int is_dolby_enable(void)
{
if (!dolby_status)
dolby_status = getenv("dolby_status");
printf("dolby_status %s %d\n", dolby_status, dv_fw_valid);
if (!dv_fw_valid || !dolby_status)
return 0;
if (!strcmp(dolby_status, DOLBY_VISION_SET_STD) ||
!strcmp(dolby_status, DOLBY_VISION_SET_LL_YUV) ||
!strcmp(dolby_status, DOLBY_VISION_SET_LL_RGB))
return 1;
else
return 0;
}
bool request_ll_mode(void)
{
if (!dolby_status)
dolby_status = getenv("dolby_status");
if (!dolby_status)
return false;
if (!strcmp(dolby_status, DOLBY_VISION_SET_LL_RGB) ||
!strcmp(dolby_status, DOLBY_VISION_SET_LL_YUV)) {
printf("request LL mode\n");
return true;
} else
return false;
}
bool check_dolby_vision_on(void)
{
if ((get_cpu_id().family_id == MESON_CPU_MAJOR_ID_G12A) ||
(get_cpu_id().family_id == MESON_CPU_MAJOR_ID_G12B) ||
(get_cpu_id().family_id == MESON_CPU_MAJOR_ID_SM1) ||
(get_cpu_id().family_id == MESON_CPU_MAJOR_ID_TM2)) {
if (READ_VPP_REG(DOLBY_CORE3_SWAP_CTRL0) & 0x1)
return true;
}
return false;
}
#endif
unsigned int dv_read_reg(unsigned int addr)
{
return READ_VPP_REG(addr);
}
void dv_write_reg(unsigned int addr, unsigned int value)
{
WRITE_VPP_REG(addr, value);
}
/*
static int check_tv_has_changed(struct hdmitx_dev* hdmitx_device)
{
return hdmitx_device->RXCap.edid_changed;
}*/
static int check_tv_hpd_status(struct hdmitx_dev* hdmitx_device)
{
return hdmitx_get_hpd_state_ext();
}
static int check_tv_support_dv(struct hdmitx_dev *hdmitx_device)
{
struct dv_info* dv_info = NULL;
int maxTMDSRate = 0;
//int preferredMode = hdmitx_device->RXCap.preferred_mode;
//1.tv not changed, use outputmode from env
//2.tv changed,hdmi will choose best mode and update outputmode to env
char *outputmode = getenv("outputmode");
printf("check_tv_support_dv, outputmode %s\n", outputmode);
if (!hdmitx_device)
return 0;
if (hdmitx_device->RXCap.dv_info.ieeeoui != 0x00d046)
return 0;
if (hdmitx_device->RXCap.dv_info.block_flag != CORRECT)
return 0;
dv_info = &hdmitx_device->RXCap.dv_info;
if (dv_info->ver == 0) {
dovi_mode.dv_rgb_444_8bit = 1;
if (dv_info->sup_2160p60hz)
dovi_mode.sup_2160p60hz = 1;
} else if ((dv_info->ver == 1) && (dv_info->length == 0xB)) {
dovi_mode.dv_rgb_444_8bit = 1;
if (dv_info->low_latency == 0x01)
dovi_mode.ll_ycbcr_422_12bit = 1;
if (dv_info->sup_2160p60hz)
dovi_mode.sup_2160p60hz = 1;
} else if ((dv_info->ver == 1) && (dv_info->length == 0xE)) {
dovi_mode.dv_rgb_444_8bit = 1;
if (dv_info->sup_2160p60hz)
dovi_mode.sup_2160p60hz = 1;
} else if (dv_info->ver == 2) {
dovi_mode.ll_ycbcr_422_12bit = 1;
if ((dv_info->Interface != 0x00) && (dv_info->Interface != 0x01))
dovi_mode.dv_rgb_444_8bit = 1;
if ((dv_info->Interface == 0x01) || (dv_info->Interface == 0x03)) {
if (dv_info->sup_10b_12b_444 == 0x1)
dovi_mode.ll_rgb_444_10bit = 1;
if (dv_info->sup_10b_12b_444 == 0x2)
dovi_mode.ll_rgb_444_12bit = 1;
}
dovi_mode.sup_2160p60hz = 1;
}
//if preferred mode is 4k, make sure it can be truly supported in DV format
if (hdmitx_device->RXCap.Max_TMDS_Clock2 != 0) {
maxTMDSRate = hdmitx_device->RXCap.Max_TMDS_Clock2 * 5;
printf("check_tv_support_dv: maxTMDSRate1 = %d\n", maxTMDSRate);
} else {
if (hdmitx_device->RXCap.Max_TMDS_Clock1 < 0xf)
hdmitx_device->RXCap.Max_TMDS_Clock1 = 0x1e;
maxTMDSRate = hdmitx_device->RXCap.Max_TMDS_Clock1 * 5;
printf("check_tv_support_dv: maxTMDSRate2 = %d\n", maxTMDSRate);
}
//return true only if DV can truly be supported for a given mode
if (strstr(outputmode, "2160p60hz") || strstr(outputmode, "2160p50hz")) {
if ((dovi_mode.sup_2160p60hz) && (maxTMDSRate >= 594)) {
//safety check for yuv420 - shudn't be the case
if (!strcmp(outputmode, "2160p60hz420"))
setenv("outputmode", "2160p60hz");
if (!strcmp(outputmode, "2160p50hz420"))
setenv("outputmode", "2160p50hz");
printf("check_tv_support_dv: 4k60 dovi supported\n");
return 1;
} else {
printf("check_tv_support_dv: 4k60 dovi NOT supported\n");
return 0;
}
}
return 1;
}
static int check_tv_support_hdr(struct hdmitx_dev *hdmitx_device)
{
if (!hdmitx_device)
return 0;
if (hdmitx_device->RXCap.hdr_info.hdr_sup_eotf_smpte_st_2084)
return 1;
return 0;
}
#if 0
/* not needed anymore */
/*if tv has changed, choose the preferred mode and check if dv support this preferred mode*/
static int check_tv_dv_mode(struct hdmitx_dev *hdmitx_device)
{
if (dovi_mode.dv_rgb_444_8bit) {
setenv("colorattribute", "444,8bit");
if ((hdmitx_device->RXCap.preferred_mode
== HDMI_3840x2160p50_16x9) ||
(hdmitx_device->RXCap.preferred_mode
== HDMI_3840x2160p60_16x9)) {
if ((dovi_mode.sup_2160p60hz) &&
(hdmitx_device->RXCap.Max_TMDS_Clock2 * 5 == 600))
setenv("outputmode", "2160p60hz");
else
setenv("outputmode", "1080p60hz");
} else if (hdmitx_device->RXCap.preferred_mode
== HDMI_1920x1080p60_16x9)
setenv("outputmode", "1080p60hz");
else if (hdmitx_device->RXCap.preferred_mode
== HDMI_1920x1080p50_16x9)
setenv("outputmode", "1080p50hz");
else if (hdmitx_device->RXCap.preferred_mode
== HDMI_1280x720p60_16x9)
setenv("outputmode", "720p60hz");
else if (hdmitx_device->RXCap.preferred_mode
== HDMI_1280x720p50_16x9)
setenv("outputmode", "720p50hz");
else
setenv("outputmode", "1080p60hz");
printf("output dv standard mode : mode is : %s attr: %s\n",
getenv("outputmode"), getenv("colorattribute"));
} else if (dovi_mode.ll_ycbcr_422_12bit) {
setenv("colorattribute", "422,12bit");
if ((hdmitx_device->RXCap.preferred_mode
== HDMI_3840x2160p50_16x9) ||
(hdmitx_device->RXCap.preferred_mode
== HDMI_3840x2160p60_16x9)) {
if ((dovi_mode.sup_2160p60hz) &&
(hdmitx_device->RXCap.Max_TMDS_Clock2 * 5 == 600))
setenv("outputmode", "2160p60hz");
else
setenv("outputmode", "1080p60hz");
} else if (hdmitx_device->RXCap.preferred_mode
== HDMI_1920x1080p60_16x9)
setenv("outputmode", "1080p60hz");
else if (hdmitx_device->RXCap.preferred_mode
== HDMI_1920x1080p50_16x9)
setenv("outputmode", "1080p50hz");
else if (hdmitx_device->RXCap.preferred_mode
== HDMI_1280x720p60_16x9)
setenv("outputmode", "720p60hz");
else if (hdmitx_device->RXCap.preferred_mode
== HDMI_1280x720p50_16x9)
setenv("outputmode", "720p50hz");
else
setenv("outputmode", "1080p60hz");
printf("output dv LL 422 mode : mode is : %s attr: %s\n",
getenv("outputmode"), getenv("colorattribute"));
} else if (dovi_mode.ll_rgb_444_10bit) {
setenv("colorattribute", "444,10bit");
setenv("outputmode", "1080p60hz");
printf("output dv LL 444 mode : mode is : %s attr: %s\n",
getenv("outputmode"), getenv("colorattribute"));
} else if (dovi_mode.ll_rgb_444_12bit) {
setenv("colorattribute", "444,12bit");
setenv("outputmode", "1080p60hz");
printf("output dv LL 444 mode : mode is : %s attr: %s\n",
getenv("outputmode"), getenv("colorattribute"));
} else {
setenv("colorattribute", "444,8bit");
setenv("outputmode", "1080p60hz");
}
return 0;
}
#endif
/*true: attr match with dv_moder*/
/*false: attr not match with dv_mode*/
static bool is_attr_match(void)
{
char *attr = getenv("colorattribute");
/*two case use std mode: */
/*1.user not requeset LL mode*/
/*2.user request LL mode but sink not support LL mode*/
if (dovi_mode.dv_rgb_444_8bit &&
(!request_ll_mode() || dovi_mode.ll_ycbcr_422_12bit == 0)) { /*STD*/
if (strncmp(attr, "444,8bit", strlen("444,8bit"))) {
printf("expect output DV, but attr is %s\n", attr);
return false;
}
} else if (dovi_mode.ll_ycbcr_422_12bit) { /*LL YUV*/
if (strncmp(attr, "422,12bit", strlen("422,12bit"))) {
printf("expect output LL YUV, but attr is %s\n", attr);
dovi_setting.dst_format = FORMAT_SDR;
return false;
}
} else if (dovi_mode.ll_rgb_444_10bit) { /*LL RGB*/
if (strncmp(attr, "444,10bit", strlen("444,10bit"))) {
printf("expect output LL RGB, but attr is %s\n", attr);
dovi_setting.dst_format = FORMAT_SDR;
return false;
}
}
return true;
}
static int check_tv_support(struct hdmitx_dev *hdmitx_device)
{
if (check_tv_support_dv(hdmitx_device)) {
if (is_attr_match()) {
dovi_setting.dst_format = FORMAT_DOVI;
printf("output dovi mode: mode is : %s attr: %s\n",
getenv("outputmode"), getenv("colorattribute"));
} else {
dovi_setting.dst_format = FORMAT_SDR;
printf("attr is not match, change to output SDR\n");
}
} else if (check_tv_support_hdr(hdmitx_device)) {
dovi_setting.dst_format = FORMAT_HDR10;
printf("output hdr mode: mode is : %s attr: %s\n",
getenv("outputmode"), getenv("colorattribute"));
} else {
dovi_setting.dst_format = FORMAT_SDR;
printf("output sdr mode: mode is : %s attr: %s\n",
getenv("outputmode"), getenv("colorattribute"));
}
return 0;
}
static void dolby_vision_get_vinfo(struct hdmitx_dev *hdmitx_device)
{
uint32_t width;
uint32_t height;
uint32_t sync_duration_num;
uint32_t field_height;
char *mode_name;
mode_name = getenv("outputmode");
if (strstr(mode_name, "1080")) {
width = 1920;
height = 1080;
} else if (strstr(mode_name, "2160")) {
width = 3840;
height = 2160;
} else if (strstr(mode_name, "720")) {
width = 1280;
height = 720;
} else if (strstr(mode_name, "576")) {
width = 720;
height = 576;
} else if (strstr(mode_name, "480")) {
width = 720;
height = 480;
} else if (strstr(mode_name, "smpte")) {
width = 4096;
height = 2160;
} else {
printf("unkown mode, use default 1080p\n");
width = 1920;
height = 1080;
}
if (strstr(mode_name, "60hz"))
sync_duration_num = 60;
else if (strstr(mode_name, "50hz"))
sync_duration_num = 50;
else if (strstr(mode_name, "30hz"))
sync_duration_num = 30;
else if (strstr(mode_name, "25hz"))
sync_duration_num = 25;
else if (strstr(mode_name, "24hz"))
sync_duration_num = 24;
else
sync_duration_num = 60;
if (strstr(mode_name, "i"))
field_height = height/2;
else
field_height = height;
vinfo_width = width;
vinfo_height = height;
vinfo_duration_num = sync_duration_num;
vinfo_field_height = field_height;
}
static int dolby_vision_parse(struct hdmitx_dev *hdmitx_device)
{
enum signal_format_enum src_format = FORMAT_SDR;
enum signal_format_enum dst_format = dovi_setting.dst_format;
unsigned int graphic_min = 50;
unsigned int graphic_max = 100;
unsigned int target_max = 100;
unsigned int w = 3840;
unsigned int h = 2160;
int ret = 0;
dolby_vision_get_vinfo(hdmitx_device);
dovi_setting.vout_width = vinfo_width;
dovi_setting.vout_height= vinfo_height;
dovi_setting.g_bitdepth = 8;
dovi_setting.g_format = G_SDR_RGB;
dovi_setting.video_width = w << 16;
dovi_setting.video_height = h << 16;
if(dst_format >= 0
&& dst_format <= 2)
graphic_max = dolby_vision_target_graphics_max[dst_format];
if (dovi_setting.dst_format == FORMAT_DOVI) {
memset(&dovi_setting.vsvdb_tbl[0],
0, sizeof(dovi_setting.vsvdb_tbl));
memcpy(&dovi_setting.vsvdb_tbl[0],
&hdmitx_device->RXCap.dv_info.rawdata[0],
hdmitx_device->RXCap.dv_info.length + 1);
//two case use std mode:
//1.user not requeset LL mode
//2.user request LL mode but sink not support LL mode
if (dovi_mode.dv_rgb_444_8bit &&
(!request_ll_mode() || dovi_mode.ll_ycbcr_422_12bit == 0))
;
else if (dovi_mode.ll_ycbcr_422_12bit) {
dovi_setting.use_ll_flag = 1;
dovi_setting.dovi_ll_enable = 1;
} else if (dovi_mode.ll_rgb_444_10bit) {
dovi_setting.use_ll_flag = 1;
dovi_setting.dovi_ll_enable = 1;
dovi_setting.ll_rgb_desired= 1;
dovi_setting.diagnostic_enable = 1;
}
} else if (dovi_setting.dst_format == FORMAT_HDR10) {
if (hdmitx_device->RXCap.hdr_info.hdr_lum_max) {
graphic_max = 50 * (2 ^ (hdmitx_device->RXCap.hdr_info.hdr_lum_max >> 5));
graphic_max = graphic_max * 10000
* hdmitx_device->RXCap.hdr_info.hdr_lum_min
* hdmitx_device->RXCap.hdr_info.hdr_lum_min
/ (255 * 255 * 100);
}
} else
;
if ((src_format >= 0 && src_format <= 2) &&
(dst_format >= 0 && dst_format <= 2))
target_max = dolby_vision_target_max[src_format][dst_format];
ret = control_path(
src_format, dst_format,
NULL, 0,
NULL, 0,
dv_graphics_priority,
12, 0, 0,
graphic_min,
graphic_max * 10000,
dolby_vision_target_min,
target_max * 10000, 1,
NULL,
&dovi_setting);
return ret;
}
static bool need_skip_cvm(unsigned int is_graphic) {
return false;
}
static unsigned int mtx_en_mux;
static void video_effect_bypass(int bypass)
{
WRITE_VPP_REG(VPP_EOTF_CTL, 0);
WRITE_VPP_REG(XVYCC_LUT_CTL, 0);
WRITE_VPP_REG(XVYCC_INV_LUT_CTL, 0);
WRITE_VPP_REG(VPP_VADJ_CTRL, 0);
WRITE_VPP_REG(VPP_GAINOFF_CTRL0, 0);
WRITE_VPP_REG(VPP_VE_ENABLE_CTRL, 0);
WRITE_VPP_REG(XVYCC_VD1_RGB_CTRST, 0);
}
static void vpp_set_mtx_en_write(void)
{
int reg_val;
reg_val = READ_VPP_REG(VPP_MATRIX_CTRL);
WRITE_VPP_REG(VPP_MATRIX_CTRL, (reg_val &
(~(POST_MTX_EN_MASK |
VD2_MTX_EN_MASK |
VD1_MTX_EN_MASK |
XVY_MTX_EN_MASK |
OSD1_MTX_EN_MASK))) |
mtx_en_mux);
}
static void vpp_set_mtx_en_read(void)
{
int reg_value;
reg_value = READ_VPP_REG(VPP_MATRIX_CTRL);
mtx_en_mux = reg_value &
(POST_MTX_EN_MASK |
VD2_MTX_EN_MASK |
VD1_MTX_EN_MASK |
XVY_MTX_EN_MASK |
OSD1_MTX_EN_MASK);
}
static int enable_rgb_to_yuv_matrix_for_dvll(
int32_t on, uint32_t *coeff_orig, uint32_t bits)
{
int32_t i;
uint32_t coeff01, coeff23, coeff45, coeff67, coeff89;
uint32_t scale, shift, offset[3];
int32_t *coeff = dvll_RGB_to_YUV709l_coeff;
if ((bits < 10) || (bits > 12))
return -1;
if (on && !coeff_orig)
return -2;
if (on) {
coeff01 = coeff_orig[0];
coeff23 = coeff_orig[1];
coeff45 = coeff_orig[2];
coeff67 = coeff_orig[3];
coeff89 = coeff_orig[4] & 0xffff;
scale = (coeff_orig[4] >> 16) & 0x0f;
offset[0] = coeff_orig[5];
offset[1] = 0; /* coeff_orig[6]; */
offset[2] = 0; /* coeff_orig[7]; */
coeff[0] = coeff[1] = coeff[2] = 0; /* pre offset */
coeff[5] = (int32_t)((coeff01 & 0xffff) << 16) >> 16;
coeff[3] = (int32_t)coeff01 >> 16;
coeff[4] = (int32_t)((coeff23 & 0xffff) << 16) >> 16;
coeff[8] = (int32_t)coeff23 >> 16;
coeff[6] = (int32_t)((coeff45 & 0xffff) << 16) >> 16;
coeff[7] = (int32_t)coeff45 >> 16;
coeff[11] = (int32_t)((coeff67 & 0xffff) << 16) >> 16;
coeff[9] = (int32_t)coeff67 >> 16;
coeff[10] = (int32_t)((coeff89 & 0xffff) << 16) >> 16;
if (scale > 12) {
shift = scale - 12;
for (i = 3; i < 12; i++)
coeff[i] = (coeff[i] + (1 << (shift - 1))) >> shift;
} else if (scale < 12) {
shift = 12 - scale;
for (i = 3; i < 12; i++)
coeff[i] <<= shift;
}
/* post offset */
coeff[18] = offset[0];
coeff[19] = offset[1];
coeff[20] = offset[2];
coeff[5] = ((coeff[3] + coeff[4] + coeff[5]) & 0xfffe)
- coeff[3] - coeff[4];
coeff[8] = 0 - coeff[6] - coeff[7];
coeff[11] = 0 - coeff[9] - coeff[10];
coeff[18] -= (0x1000 - coeff[3] - coeff[4] - coeff[5]) >> 1;
coeff[22] = 2;
vpp_set_mtx_en_read();
WRITE_VPP_REG(VPP_MATRIX_CTRL, 0);
set_vpp_matrix(VPP_MATRIX_OSD,
cur_osd_mtx, CSC_OFF);
set_vpp_matrix(VPP_MATRIX_VD1,
cur_vd1_mtx, CSC_OFF);
set_vpp_matrix(VPP_MATRIX_POST,
coeff, CSC_ON);
vpp_set_mtx_en_write();
}
return 0;
}
static int dolby_core2_set(
const uint32_t dm_count,
const uint32_t lut_count,
uint32_t *p_core2_dm_regs,
uint32_t *p_core2_lut,
int hsize,
int vsize,
int dolby_enable,
int lut_endian)
{
uint32_t count;
int i;
uint32_t bypass_flag = 0;
uint32_t g_htotal_add = 0x40;
uint32_t g_vtotal_add = 0x80;
uint32_t g_vsize_add = 0;
uint32_t g_vwidth = 0x18;
uint32_t g_hwidth = 0x10;
uint32_t g_vpotch;
uint32_t g_hpotch = 0x10;
/* adjust core2 setting to work around*/
/* fixing with 1080p24hz and 480p60hz */
if ((vinfo_width < 1280) && ((vinfo_height < 720)
&& (vinfo_field_height < 720)))
g_vpotch = 0x60;
else if ((vinfo_width == 1280) &&
(vinfo_height == 720) &&
(vinfo_field_height < 720))
g_vpotch = 0x60;
else if ((vinfo_width == 1920) &&
(vinfo_height == 1080) &&
(vinfo_duration_num == 24))
g_vpotch = 0x60;
else if ((vinfo_width == 1920) &&
(vinfo_height == 1080) &&
(vinfo_field_height < 1080))
g_vpotch = 0x60;
else if ((vinfo_width == 1280) && (vinfo_height == 720))
g_vpotch = 0x38;
else
g_vpotch = 0x20;
WRITE_VPP_REG(DOLBY_CORE2A_CLKGATE_CTRL, 0);
WRITE_VPP_REG(DOLBY_CORE2A_SWAP_CTRL0, 0);
WRITE_VPP_REG(DOLBY_CORE2A_SWAP_CTRL1,
((hsize + g_htotal_add) << 16)
| (vsize + g_vtotal_add + g_vsize_add));
WRITE_VPP_REG(DOLBY_CORE2A_SWAP_CTRL2,
(hsize << 16) | (vsize + g_vsize_add));
WRITE_VPP_REG(DOLBY_CORE2A_SWAP_CTRL3,
(g_hwidth << 16) | g_vwidth);
WRITE_VPP_REG(DOLBY_CORE2A_SWAP_CTRL4,
(g_hpotch << 16) | g_vpotch);
if (is_meson_txlx_stbmode())
WRITE_VPP_REG(DOLBY_CORE2A_SWAP_CTRL5, 0xf8000000);
else if (is_meson_g12() || is_meson_tm2_stbmode())
WRITE_VPP_REG(DOLBY_CORE2A_SWAP_CTRL5, 0xa8000000);
else
WRITE_VPP_REG(DOLBY_CORE2A_SWAP_CTRL5, 0x0);
WRITE_VPP_REG(DOLBY_CORE2A_DMA_CTRL, 0x0);
WRITE_VPP_REG(DOLBY_CORE2A_REG_START + 2, 1);
if (need_skip_cvm(1))
bypass_flag |= 1 << 0;
WRITE_VPP_REG(DOLBY_CORE2A_REG_START + 2, 1);
WRITE_VPP_REG(DOLBY_CORE2A_REG_START + 1,
2 | bypass_flag);
WRITE_VPP_REG(DOLBY_CORE2A_REG_START + 1,
2 | bypass_flag);
WRITE_VPP_REG(DOLBY_CORE2A_CTRL, 0);
WRITE_VPP_REG(DOLBY_CORE2A_CTRL, 0);
if (dm_count == 0)
count = 24;
else
count = dm_count;
for (i = 0; i < count; i++)
WRITE_VPP_REG(
DOLBY_CORE2A_REG_START + 6 + i,
p_core2_dm_regs[i]);
/* core2 metadata program done */
WRITE_VPP_REG(DOLBY_CORE2A_REG_START + 3, 1);
if (lut_count == 0)
count = 256 * 5;
else
count = lut_count;
WRITE_VPP_REG(DOLBY_CORE2A_DMA_CTRL, 0x1401);
if (lut_endian)
for (i = 0; i < count; i += 4) {
WRITE_VPP_REG(DOLBY_CORE2A_DMA_PORT,
p_core2_lut[i+3]);
WRITE_VPP_REG(DOLBY_CORE2A_DMA_PORT,
p_core2_lut[i+2]);
WRITE_VPP_REG(DOLBY_CORE2A_DMA_PORT,
p_core2_lut[i+1]);
WRITE_VPP_REG(DOLBY_CORE2A_DMA_PORT,
p_core2_lut[i]);
}
else
for (i = 0; i < count; i++)
WRITE_VPP_REG(DOLBY_CORE2A_DMA_PORT,
p_core2_lut[i]);
/* enable core2 */
WRITE_VPP_REG(DOLBY_CORE2A_SWAP_CTRL0, dolby_enable << 0);
if (debug_enable) {
printf("core2\n");
for (i = 0; i < 24; i++)
printf("%08x\n", p_core2_dm_regs[i]);
printf("core2 swap\n");
for (i = DOLBY_CORE2A_CLKGATE_CTRL;
i <= DOLBY_CORE2A_DMA_PORT; i++)
printf("[0x%4x] = 0x%x\n",
i, READ_VPP_REG(i));
printf("core2 real reg\n");
for (i = DOLBY_CORE2A_REG_START;
i <= DOLBY_CORE2A_REG_START + 5; i++)
printf("[0x%4x] = 0x%x\n",
i, READ_VPP_REG(i));
}
return 0;
}
static int dolby_core3_set(
uint32_t dm_count,
uint32_t md_count,
uint32_t *p_core3_dm_regs,
uint32_t *p_core3_md_regs,
int hsize,
int vsize,
int dolby_enable,
int scramble_en,
u8 pps_state)
{
uint32_t count;
int i;
int vsize_hold = 0x10;
uint32_t diag_mode = 0;
uint32_t cur_dv_mode = dolby_vision_mode;
uint32_t diag_enable = 0;
uint32_t htotal_add = 0x140;
uint32_t vtotal_add = 0x40;
uint32_t vsize_add = 0;
if (dovi_setting.diagnostic_enable
|| dovi_setting.dovi_ll_enable)
diag_enable = 1;
if (((cur_dv_mode == DOLBY_VISION_OUTPUT_MODE_IPT_TUNNEL)
|| (cur_dv_mode == DOLBY_VISION_OUTPUT_MODE_IPT))
&& diag_enable) {
cur_dv_mode = dv_ll_output_mode & 0xff;
if (is_meson_g12() || is_meson_tm2_stbmode()) {
if (dolby_vision_ll_policy == DOLBY_VISION_LL_YUV422)
diag_mode = 0x20;
else
diag_mode = 3;
} else
diag_mode = 3;
}
if (is_meson_box() || is_meson_tm2_stbmode()) {
if (dovi_setting.dovi_ll_enable &&
dovi_setting.diagnostic_enable == 0) {
WRITE_VPP_REG_BITS(
VPP_DOLBY_CTRL,
3, 6, 2); /* post matrix */
WRITE_VPP_REG_BITS(
VPP_MATRIX_CTRL,
1, 0, 1); /* post matrix */
} else {
WRITE_VPP_REG_BITS(
VPP_DOLBY_CTRL,
0, 6, 2); /* post matrix */
WRITE_VPP_REG_BITS(
VPP_MATRIX_CTRL,
0, 0, 1); /* post matrix */
}
} else if (is_meson_txlx_stbmode()) {
WRITE_VPP_REG_BITS(
VPP_DOLBY_CTRL,
1, 0, 1); /* skip pps/dither/cm */
WRITE_VPP_REG(
VPP_DAT_CONV_PARA0, 0x08000800);
if (dovi_setting.dovi_ll_enable &&
dovi_setting.diagnostic_enable == 0) {
/*bypass gainoff to vks */
/*enable wn tp vks*/
WRITE_VPP_REG_BITS(
VPP_DOLBY_CTRL, 0, 2, 1);
WRITE_VPP_REG_BITS(
VPP_DOLBY_CTRL, 1, 1, 1);
WRITE_VPP_REG(
VPP_DAT_CONV_PARA1, 0x8000800);
WRITE_VPP_REG_BITS(
VPP_MATRIX_CTRL,
1, 0, 1); /* post matrix */
} else {
/* bypass wm tp vks*/
WRITE_VPP_REG_BITS(
VPP_DOLBY_CTRL, 1, 2, 1);
WRITE_VPP_REG_BITS(
VPP_DOLBY_CTRL, 0, 1, 1);
WRITE_VPP_REG(
VPP_DAT_CONV_PARA1, 0x20002000);
if (is_meson_tvmode())
enable_rgb_to_yuv_matrix_for_dvll(
0, NULL, 12);
else
WRITE_VPP_REG_BITS(
VPP_MATRIX_CTRL,
0, 0, 1);
}
}
/* flush post matrix table when ll mode on and setting changed */
if (dovi_setting.dovi_ll_enable &&
(dovi_setting.diagnostic_enable == 0))
enable_rgb_to_yuv_matrix_for_dvll(
1, &p_core3_dm_regs[18], 12);
WRITE_VPP_REG(DOLBY_CORE3_CLKGATE_CTRL, 0);
WRITE_VPP_REG(DOLBY_CORE3_SWAP_CTRL1,
((hsize + htotal_add) << 16)
| (vsize + vtotal_add + vsize_add + vsize_hold * 2));
WRITE_VPP_REG(DOLBY_CORE3_SWAP_CTRL2,
(hsize << 16) | (vsize + vsize_add));
WRITE_VPP_REG(DOLBY_CORE3_SWAP_CTRL3,
(0x80 << 16) | vsize_hold);
WRITE_VPP_REG(DOLBY_CORE3_SWAP_CTRL4,
(0x04 << 16) | vsize_hold);
WRITE_VPP_REG(DOLBY_CORE3_SWAP_CTRL5, 0x0000);
if (cur_dv_mode != DOLBY_VISION_OUTPUT_MODE_IPT_TUNNEL)
WRITE_VPP_REG(DOLBY_CORE3_SWAP_CTRL6, 0);
else
WRITE_VPP_REG(DOLBY_CORE3_SWAP_CTRL6,
0x10000000); /* swap UV */
WRITE_VPP_REG(DOLBY_CORE3_REG_START + 5, 7);
WRITE_VPP_REG(DOLBY_CORE3_REG_START + 4, 4);
WRITE_VPP_REG(DOLBY_CORE3_REG_START + 4, 2);
WRITE_VPP_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*/
/* 01- IPT 12 bit tunnelled over RGB 8 bit 444, 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*/
WRITE_VPP_REG(DOLBY_CORE3_REG_START + 1, cur_dv_mode);
WRITE_VPP_REG(DOLBY_CORE3_REG_START + 1, cur_dv_mode);
/* for delay */
if (dm_count == 0)
count = 26;
else
count = dm_count;
for (i = 0; i < count; i++)
WRITE_VPP_REG(DOLBY_CORE3_REG_START + 0x6 + i,
p_core3_dm_regs[i]);
/* from addr 0x18 */
count = md_count;
for (i = 0; i < count; i++)
WRITE_VPP_REG(DOLBY_CORE3_REG_START + 0x24 + i,
p_core3_md_regs[i]);
for (; i < (128+1); i++)
WRITE_VPP_REG(DOLBY_CORE3_REG_START + 0x24 + i, 0);
/* from addr 0x90 */
/* core3 metadata program done */
WRITE_VPP_REG(DOLBY_CORE3_REG_START + 3, 1);
WRITE_VPP_REG(DOLBY_CORE3_DIAG_CTRL, diag_mode);
/* enable core3 */
WRITE_VPP_REG(DOLBY_CORE3_SWAP_CTRL0, (dolby_enable << 0));
if (debug_enable) {
printf("core3\n");
for (i = 0; i < 26; i++)
printf("%08x\n", p_core3_dm_regs[i]);
printf("core3 swap\n");
for (i = DOLBY_CORE3_CLKGATE_CTRL;
i <= 0x36fd; i++)
printf("[0x%4x] = 0x%x\n",
i, READ_VPP_REG(i));
printf("core3 real reg\n");
for (i = DOLBY_CORE3_REG_START;
i <= DOLBY_CORE3_REG_START + 67; i++)
printf("[0x%4x] = 0x%x\n",
i, READ_VPP_REG(i));
printf("core3 metadata, count %d\n",md_count);
for (i = 0; i < md_count; i++)
printf("%08x\n", p_core3_md_regs[i]);
}
return 0;
}
int apply_stb_core_settings(void)
{
uint32_t graphics_w = 1920;
uint32_t graphics_h = 1080;
if (!is_dolby_enable())
return 0;
if (dovi_setting.dst_format == FORMAT_INVALID)
return 0;
printf("%s\n", __func__);
if (dovi_setting.dst_format == FORMAT_DOVI) {
if (dovi_setting.dovi_ll_enable) {
if (dovi_setting.diagnostic_enable) {
dolby_vision_mode = DOLBY_VISION_OUTPUT_MODE_IPT;
dolby_vision_ll_policy = DOLBY_VISION_LL_RGB444;
} else {
dolby_vision_mode = DOLBY_VISION_OUTPUT_MODE_IPT;
dolby_vision_ll_policy = DOLBY_VISION_LL_YUV422;
}
} else
dolby_vision_mode = DOLBY_VISION_OUTPUT_MODE_IPT_TUNNEL;
} else if (dovi_setting.dst_format == FORMAT_HDR10)
dolby_vision_mode = DOLBY_VISION_OUTPUT_MODE_HDR10;
else
dolby_vision_mode = DOLBY_VISION_OUTPUT_MODE_SDR8;
dolby_core2_set(24, 256 * 5,
(uint32_t *)&dovi_setting.dm_reg2,
(uint32_t *)&dovi_setting.dm_lut2,
graphics_w, graphics_h, 1, 1);
dolby_core3_set(26, dovi_setting.md_reg3.size,
(uint32_t *)&dovi_setting.dm_reg3,
dovi_setting.md_reg3.raw_metadata,
vinfo_width, vinfo_height, 1, 1, 0);
return 0;
}
static int enable_dolby_vision(void)
{
printf("%s\n", __func__);
if (is_meson_g12() || is_meson_tm2_stbmode()) {
hdr_func(OSD1_HDR, HDR_BYPASS);
/*enable core3*/
WRITE_VPP_REG_BITS(VPP_DOLBY_CTRL, 1, 3, 1);
WRITE_VPP_REG(VPP_WRAP_OSD1_MATRIX_EN_CTRL,
0x0);
WRITE_VPP_REG(VPP_WRAP_OSD2_MATRIX_EN_CTRL,
0x0);
WRITE_VPP_REG(VPP_WRAP_OSD3_MATRIX_EN_CTRL,
0x0);
/*enable core2*/
WRITE_VPP_REG_BITS(DOLBY_PATH_CTRL, 0, 2, 1);
/* bypass all video effect */
video_effect_bypass(1);
/* 12->10 before vadj1*/
/* 10->12 before post blend */
WRITE_VPP_REG(VPP_DAT_CONV_PARA0,
0x20002000);
/* 12->10 before vadj2*/
/* 10->12 after gainoff */
WRITE_VPP_REG(VPP_DAT_CONV_PARA1,
0x20002000);
WRITE_VPP_REG(VPP_MATRIX_CTRL, 0);
WRITE_VPP_REG(VPP_DUMMY_DATA1,0x80200);
if (((dolby_vision_mode ==
DOLBY_VISION_OUTPUT_MODE_IPT_TUNNEL)
|| (dolby_vision_mode ==
DOLBY_VISION_OUTPUT_MODE_IPT)) &&
(dovi_setting.diagnostic_enable == 0) &&
dovi_setting.dovi_ll_enable) {
uint32_t *reg = (uint32_t *)&dovi_setting.dm_reg3;
/* input u12 -0x800 to s12 */
WRITE_VPP_REG(VPP_DAT_CONV_PARA1,
0x8000800);
/* bypass vadj */
WRITE_VPP_REG(VPP_VADJ_CTRL, 0);
/* bypass gainoff */
WRITE_VPP_REG(VPP_GAINOFF_CTRL0, 0);
/* enable wm tp vks*/
/* bypass gainoff to vks */
WRITE_VPP_REG_BITS(VPP_DOLBY_CTRL, 1, 1, 2);
enable_rgb_to_yuv_matrix_for_dvll(1, &reg[18],
(dv_ll_output_mode >> 8)& 0xff);
} else
enable_rgb_to_yuv_matrix_for_dvll(0, NULL, 12);
dolby_vision_on = true;
setenv("dolby_vision_on", "1");
run_command("saveenv", 0);
printk("Dolby Vision turn on\n");
}
return 0;
}
static int prepare_drm_pkt(struct master_display_info_s *data,
struct dovi_setting_s *setting, const struct hdmitx_dev *hdmitx_device)
{
struct hdr10_infoframe *p_hdr;
p_hdr = &setting->hdr_info;
if (!data || !hdmitx_device || !setting)
return -1;
data->features = (1 << 29) | (5 << 26) | (0 << 25) | (1 << 24)
| (9 << 16) | (0x10 << 8) | (10 << 0);
/* ko return primaries in RGB order, uboot send pkt in RGB order, */
/* to keep same with kernel*/
data->primaries[0][0] = (p_hdr->primaries_x_0_msb << 8)
| p_hdr->primaries_x_0_lsb;
data->primaries[0][1] = (p_hdr->primaries_y_0_msb << 8)
| p_hdr->primaries_y_0_lsb;
data->primaries[1][0] = (p_hdr->primaries_x_1_msb << 8)
| p_hdr->primaries_x_1_lsb;
data->primaries[1][1] = (p_hdr->primaries_y_1_msb << 8)
| p_hdr->primaries_y_1_lsb;
data->primaries[2][0] = (p_hdr->primaries_x_2_msb << 8)
| p_hdr->primaries_x_2_lsb;
data->primaries[2][1] = (p_hdr->primaries_y_2_msb << 8)
| p_hdr->primaries_y_2_lsb;
data->white_point[0] = (p_hdr->white_point_x_msb << 8)
| p_hdr->white_point_x_lsb;
data->white_point[1] = (p_hdr->white_point_y_msb << 8)
| p_hdr->white_point_y_lsb;
data->luminance[0] =
(p_hdr->max_display_mastering_lum_msb << 8)
| p_hdr->max_display_mastering_lum_lsb;
data->luminance[1] =
(p_hdr->min_display_mastering_lum_msb << 8)
| p_hdr->min_display_mastering_lum_lsb;
data->max_content =
(p_hdr->max_content_light_level_msb << 8)
| p_hdr->max_content_light_level_lsb;
data->max_frame_average =
(p_hdr->max_frame_avg_light_level_msb << 8)
| p_hdr->max_frame_avg_light_level_lsb;
return 0;
}
static int prepare_vsif_pkt(struct dv_vsif_para *vsif,
struct dovi_setting_s *setting, const struct hdmitx_dev *hdmitx_device)
{
if (!vsif || !hdmitx_device || !setting)
return -1;
vsif->vers.ver2.low_latency = setting->dovi_ll_enable;
vsif->vers.ver2.dobly_vision_signal = 1;
if (hdmitx_device->RXCap.dv_info.sup_backlight_control &&
(setting->ext_md.avail_level_mask &
EXT_MD_LEVEL_2)) {
vsif->vers.ver2.backlt_ctrl_MD_present = 1;
vsif->vers.ver2.eff_tmax_PQ_hi =
setting->ext_md.level_2.target_max_pq_h & 0xf;
vsif->vers.ver2.eff_tmax_PQ_low =
setting->ext_md.level_2.target_max_pq_l;
} else {
vsif->vers.ver2.backlt_ctrl_MD_present = 0;
vsif->vers.ver2.eff_tmax_PQ_hi = 0;
vsif->vers.ver2.eff_tmax_PQ_low = 0;
}
if (setting->dovi_ll_enable &&
(setting->ext_md.avail_level_mask &
EXT_MD_LEVEL_255)) {
vsif->vers.ver2.auxiliary_MD_present = 1;
vsif->vers.ver2.auxiliary_runmode =
setting->ext_md.level_255.run_mode;
vsif->vers.ver2.auxiliary_runversion =
setting->ext_md.level_255.run_version;
vsif->vers.ver2.auxiliary_debug0 =
setting->ext_md.level_255.dm_debug_0;
} else {
vsif->vers.ver2.auxiliary_MD_present = 0;
vsif->vers.ver2.auxiliary_runmode = 0;
vsif->vers.ver2.auxiliary_runversion = 0;
vsif->vers.ver2.auxiliary_debug0 = 0;
}
return 0;
}
static const char *output_str[4] = {
"DOVI",
"HDR10",
"SDR",
"DOVI_LL"
};
void send_hdmi_pkt(void)
{
struct dv_vsif_para vsif;
struct master_display_info_s drmif;
if (!is_dolby_enable())
return;
printf("send hdmi pkt %d [%s] dovi_setting.dst_format = %d\n",
dovi_setting.dst_format,
(dovi_setting.dst_format >= 0 && dovi_setting.dst_format < 4) ?
output_str[dovi_setting.dst_format] : "NULL",
dovi_setting.dst_format);
if (dovi_setting.dst_format == FORMAT_DOVI) {
memset(&vsif, 0, sizeof(vsif));
prepare_vsif_pkt(&vsif, &dovi_setting, &hdmitx_device);
if (dovi_setting.dovi_ll_enable)
hdmitx_set_vsif_pkt( EOTF_T_LL_MODE,
dovi_setting.diagnostic_enable
? RGB_10_12BIT : YUV422_BIT12,
&vsif);
else
hdmitx_set_vsif_pkt(EOTF_T_DOLBYVISION, RGB_8BIT,
&vsif);
} else if (dovi_setting.dst_format == FORMAT_HDR10) {
memset(&drmif, 0, sizeof(drmif));
prepare_drm_pkt(&drmif, &dovi_setting, &hdmitx_device);
hdmitx_set_drm_pkt(&drmif);
} else
return;
}
/*check hpd status:
*1. hdmi connected: set hdr/dv mode based on capability of TV if dv enabled.
*2. no hdmi: output sdr if dv enabled.
*/
void dolby_vision_process(void)
{
if (!check_tv_hpd_status(&hdmitx_device)) {
if (is_dolby_enable()) {
dovi_setting.dst_format = FORMAT_SDR;
printf("dolby_vision_process: no hpd, dst_format = SDR\n");
} else {
printf("dolby_vision_process: no tv and dv disabled\n");
setenv("dolby_vision_on", "0");
run_command("saveenv", 0);
return;
}
} else {
if (is_dolby_enable()) {
check_tv_support(&hdmitx_device);
printf("dolby_vision_process: hpd: dst_format=%d\n",
dovi_setting.dst_format);
} else {
printf("dolby_vision_process: hpd: dv disabled\n");
setenv("dolby_vision_on", "0");
run_command("saveenv", 0);
return;
}
}
if (dovi_setting.dst_format == FORMAT_INVALID) {
printf("dolby_vision_process: dst_format = FORMAT_INVALID\n");
setenv("dolby_vision_on", "0");
run_command("saveenv", 0);
return;
}
if (dolby_vision_parse(&hdmitx_device) == 0) {
apply_stb_core_settings();
enable_dolby_vision();
} else {
printf("dolby_vision_process: control path failed\n");
dovi_setting.dst_format = FORMAT_INVALID;
dv_fw_valid = false;
setenv("dolby_vision_on", "0");
run_command("saveenv", 0);
return;
}
/*dv send hdmi vsif after hdmi set mode*/
/* so we add another cmd to send this hdmi package solely*/
}
void dolbyvision_dump_setting() {
int i;
uint32_t *p;
if (!is_dolby_enable()) {
printf("dv is disabled\n");
return;
}
printf("core2\n");
p = (uint32_t *)&dovi_setting.dm_reg2;
for (i = 0; i < 24; i++)
printf("%08x\n", p[i]);
printf("core2 swap\n");
for (i = DOLBY_CORE2A_CLKGATE_CTRL;
i <= DOLBY_CORE2A_DMA_PORT; i++)
printf("[0x%4x] = 0x%x\n",
i, READ_VPP_REG(i));
printf("core2 real reg\n");
for (i = DOLBY_CORE2A_REG_START;
i <= DOLBY_CORE2A_REG_START + 5; i++)
printf("[0x%4x] = 0x%x\n",
i, READ_VPP_REG(i));
printf("\ncore2lut\n");
p = (uint32_t *)&dovi_setting.dm_lut2.tm_lut_i;
for (i = 0; i < 64; i++)
printf("%08x, %08x, %08x, %08x\n",
p[i*4+3], p[i*4+2], p[i*4+1], p[i*4]);
printf("\n");
p = (uint32_t *)&dovi_setting.dm_lut2.tm_lut_s;
for (i = 0; i < 64; i++)
printf("%08x, %08x, %08x, %08x\n",
p[i*4+3], p[i*4+2], p[i*4+1], p[i*4]);
printf("\n");
p = (uint32_t *)&dovi_setting.dm_lut2.sm_lut_i;
for (i = 0; i < 64; i++)
printf("%08x, %08x, %08x, %08x\n",
p[i*4+3], p[i*4+2], p[i*4+1], p[i*4]);
printf("\n");
p = (uint32_t *)&dovi_setting.dm_lut2.sm_lut_s;
for (i = 0; i < 64; i++)
printf("%08x, %08x, %08x, %08x\n",
p[i*4+3], p[i*4+2], p[i*4+1], p[i*4]);
printf("\n");
p = (uint32_t *)&dovi_setting.dm_lut2.g_2_l;
for (i = 0; i < 64; i++)
printf("%08x, %08x, %08x, %08x\n",
p[i*4+3], p[i*4+2], p[i*4+1], p[i*4]);
printf("\n");
printf("core3\n");
p = (uint32_t *)&dovi_setting.dm_reg3;
for (i = 0; i < 26; i++)
printf("%08x\n", p[i]);
printf("core3 swap\n");
for (i = DOLBY_CORE3_CLKGATE_CTRL;
i <= DOLBY_CORE3_CLKGATE_CTRL + 13; i++)
printf("[0x%4x] = 0x%x\n",
i, READ_VPP_REG(i));
printf("core3 real reg\n");
for (i = DOLBY_CORE3_REG_START;
i <= DOLBY_CORE3_REG_START + 67; i++)
printf("[0x%4x] = 0x%x\n",
i, READ_VPP_REG(i));
if (dolby_vision_mode <= DOLBY_VISION_OUTPUT_MODE_IPT_TUNNEL) {
printf("\ncore3_meta %d\n", dovi_setting.md_reg3.size);
p = dovi_setting.md_reg3.raw_metadata;
for (i = 0; i < dovi_setting.md_reg3.size; i++)
printf("%08x\n", p[i]);
printf("\n");
}
}
void dolbyvision_debug(int enable_debug) {
debug_enable = enable_debug;
}
Reference in New Issue View Git Blame Copy Permalink