You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2171 lines
63 KiB
2171 lines
63 KiB
/*
|
|
* Copyright (c) Hisilicon Technologies Co., Ltd. 2019-2020. All rights reserved.
|
|
* Description: disp iapi interface
|
|
* Author: Hisilicon
|
|
* Create: 2019-06-28
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <pthread.h>
|
|
#include <unistd.h>
|
|
#include "mpi_disp_ext.h"
|
|
#include "uapi_disp.h"
|
|
#include "soc_errno.h"
|
|
#include "mpi_disp_tran.h"
|
|
#include "securec.h"
|
|
|
|
#define check_disp_id(enID) \
|
|
do { \
|
|
if ((enID) >= UAPI_DISPLAY2) { \
|
|
soc_err_disp("Disp ID para is invalid.\n"); \
|
|
return SOC_ERR_DISP_INVALID_PARA; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define check_iapi_null_ptr(pointer) \
|
|
do { \
|
|
if ((pointer) == TD_NULL) { \
|
|
soc_err_disp("para is null ptr.\n"); \
|
|
return SOC_ERR_DISP_NULL_PTR; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define disp_check_bool(b_enable) \
|
|
{ \
|
|
do { \
|
|
if (((b_enable) != TD_TRUE) && ((b_enable) != TD_FALSE)) { \
|
|
soc_err_disp("b_enable=%d \n", (b_enable)); \
|
|
return TD_FAILURE; \
|
|
} \
|
|
} while (0); \
|
|
}
|
|
|
|
#define vo_disp_func_enter() soc_info_func_enter()
|
|
#define vo_disp_func_exit() soc_info_func_exit()
|
|
|
|
td_s32 uapi_disp_init(td_void)
|
|
{
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
ret = ext_mpi_disp_init();
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_deinit(td_void)
|
|
{
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
ret = ext_mpi_disp_deinit();
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_attach(uapi_disp dst_disp, uapi_disp src_disp)
|
|
{
|
|
ext_drv_display master = EXT_DRV_DISPLAY_0;
|
|
ext_drv_display slave = EXT_DRV_DISPLAY_0;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(dst_disp);
|
|
check_disp_id(src_disp);
|
|
|
|
transfer_disp_id(&dst_disp, &slave, TD_TRUE);
|
|
transfer_disp_id(&src_disp, &master, TD_TRUE);
|
|
ret = ext_mpi_disp_attach(master, slave);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_detach(uapi_disp dst_disp, uapi_disp src_disp)
|
|
{
|
|
ext_drv_display master = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_display slave = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(dst_disp);
|
|
check_disp_id(src_disp);
|
|
|
|
transfer_disp_id(&dst_disp, &slave, TD_TRUE);
|
|
transfer_disp_id(&src_disp, &master, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_detach(master, slave);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_open(uapi_disp disp_id)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
|
|
if (disp_id >= UAPI_DISPLAY2) {
|
|
soc_err_disp("para disp_id is invalid.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id((uapi_disp *)&disp_id, &disp, TD_TRUE);
|
|
ret = ext_mpi_disp_open(disp);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_close(uapi_disp disp_id)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_close(disp);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_bg_color(uapi_disp disp_id, const uapi_disp_color *bg_color)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_color bgcolor;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(bg_color);
|
|
|
|
if (bg_color->bit_depth >= UAPI_PIXEL_BIT_DEPTH_MAX) {
|
|
soc_err_disp("para bit_depth is invalid(%d).\n", bg_color->bit_depth);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
bgcolor.blue = bg_color->blue;
|
|
bgcolor.red = bg_color->red;
|
|
bgcolor.green = bg_color->green;
|
|
transfer_intf_set_bitwidth(&bg_color->bit_depth, &bgcolor.bit_depth);
|
|
|
|
ret = ext_mpi_disp_set_bgcolor(disp, &bgcolor);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_bg_color(uapi_disp disp_id, uapi_disp_color *bg_color)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_color bgcolor;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(bg_color);
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_bgcolor(disp, &bgcolor);
|
|
if (ret == TD_SUCCESS) {
|
|
bg_color->blue = bgcolor.blue;
|
|
bg_color->red = bgcolor.red;
|
|
bg_color->green = bgcolor.green;
|
|
transfer_intf_get_bitwidth(&bg_color->bit_depth, &bgcolor.bit_depth);
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_aspect_ratio(uapi_disp disp_id, const uapi_video_aspect_info *aspect_ratio)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_u32 h = 0;
|
|
td_u32 v = 0;
|
|
td_s32 ret;
|
|
ext_drv_disp_aspect_mode set_aspect_mode = EXT_DRV_DISP_ASPECT_RATIO_MODE_MAX;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(aspect_ratio);
|
|
|
|
if (aspect_ratio->ratio >= UAPI_VIDEO_ASPECT_RATIO_MAX) {
|
|
soc_err_disp("para aspect ratio is invalid.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
transfer_set_aspect_ratio(aspect_ratio, &set_aspect_mode, &h, &v);
|
|
ret = ext_mpi_disp_set_aspectratio(disp, set_aspect_mode, h, v);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_aspect_ratio(uapi_disp disp_id, uapi_video_aspect_info *aspect_ratio)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_u32 h, v;
|
|
td_s32 ret;
|
|
ext_drv_disp_aspect_mode get_aspect_mode;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(aspect_ratio);
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_aspectratio(disp, &get_aspect_mode, &h, &v);
|
|
if (ret == TD_SUCCESS) {
|
|
transfer_get_aspect_ratio(aspect_ratio, &get_aspect_mode, &h, &v);
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
static td_s32 disp_check_type_hdmi(const uapi_disp_intf *disp_id_intf, td_u32 u)
|
|
{
|
|
if (disp_id_intf[u].intf.hdmitx >= UAPI_DISP_HDMITX_ID_MAX) {
|
|
soc_err_disp("UAPI_DISP_INTF_TYPE_HDMI is invalid.\n");
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 disp_check_type_bt1120(const uapi_disp_intf *disp_id_intf, td_u32 u)
|
|
{
|
|
if (disp_id_intf[u].intf.bt1120 >= UAPI_DISP_BT1120_MAX) {
|
|
soc_err_disp("UAPI_DISP_INTF_TYPE_BT1120 is invalid.\n");
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 disp_check_type_ypbpr(const uapi_disp_intf *disp_id_intf, td_u32 u)
|
|
{
|
|
if ((disp_id_intf[u].intf.y_pb_pr.dac_y >= MAX_DAC_NUM) ||
|
|
(disp_id_intf[u].intf.y_pb_pr.dac_pb >= MAX_DAC_NUM) ||
|
|
(disp_id_intf[u].intf.y_pb_pr.dac_pr >= MAX_DAC_NUM)) {
|
|
soc_err_disp("UAPI_DISP_INTF_TYPE_YPBPR is invalid.\n");
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 disp_check_type_rgb(const uapi_disp_intf *disp_id_intf, td_u32 u)
|
|
{
|
|
if ((disp_id_intf[u].intf.rgb.dac_r >= MAX_DAC_NUM) || (disp_id_intf[u].intf.rgb.dac_g >= MAX_DAC_NUM) ||
|
|
(disp_id_intf[u].intf.rgb.dac_b >= MAX_DAC_NUM)) {
|
|
soc_err_disp("UAPI_DISP_INTF_TYPE_RGB is invalid.\n");
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 disp_check_type_cvbs(const uapi_disp_intf *disp_id_intf, td_u32 u)
|
|
{
|
|
if (disp_id_intf[u].intf.cvbs.dac >= MAX_DAC_NUM) {
|
|
soc_err_disp("UAPI_DISP_INTF_TYPE_CVBS is invalid.\n");
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 disp_check_type_svideo(const uapi_disp_intf *disp_id_intf, td_u32 u)
|
|
{
|
|
if ((disp_id_intf[u].intf.svideo.dac_y >= MAX_DAC_NUM) || (disp_id_intf[u].intf.svideo.dac_c >= MAX_DAC_NUM)) {
|
|
soc_err_disp("UAPI_DISP_INTF_TYPE_SVIDEO is invalid.\n");
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 disp_check_type_vga(const uapi_disp_intf *disp_id_intf, td_u32 u)
|
|
{
|
|
if ((disp_id_intf[u].intf.vga.dac_r >= MAX_DAC_NUM) || (disp_id_intf[u].intf.vga.dac_g >= MAX_DAC_NUM) ||
|
|
(disp_id_intf[u].intf.vga.dac_b >= MAX_DAC_NUM)) {
|
|
soc_err_disp("UAPI_DISP_INTF_TYPE_VGA is invalid.\n");
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 disp_check_type_panel(const uapi_disp_intf *disp_id_intf, td_u32 u)
|
|
{
|
|
if (disp_id_intf[u].intf.panel >= UAPI_DISP_PANEL_ID_MAX) {
|
|
soc_err_disp("UAPI_DISP_INTF_TYPE_PANEL is invalid.\n");
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 disp_check_intf_type(const uapi_disp_intf *disp_id_intf, td_u32 u)
|
|
{
|
|
td_s32 ret = SOC_ERR_VO_INVALID_PARA;
|
|
if (disp_id_intf[u].intf_type >= UAPI_DISP_INTF_TYPE_MAX) {
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
|
|
switch (disp_id_intf[u].intf_type) {
|
|
case UAPI_DISP_INTF_TYPE_HDMITX:
|
|
ret = disp_check_type_hdmi(disp_id_intf, u);
|
|
break;
|
|
case UAPI_DISP_INTF_TYPE_BT1120:
|
|
ret = disp_check_type_bt1120(disp_id_intf, u);
|
|
break;
|
|
case UAPI_DISP_INTF_TYPE_YPBPR:
|
|
ret = disp_check_type_ypbpr(disp_id_intf, u);
|
|
break;
|
|
case UAPI_DISP_INTF_TYPE_RGB:
|
|
ret = disp_check_type_rgb(disp_id_intf, u);
|
|
break;
|
|
case UAPI_DISP_INTF_TYPE_CVBS:
|
|
ret = disp_check_type_cvbs(disp_id_intf, u);
|
|
break;
|
|
case UAPI_DISP_INTF_TYPE_SVIDEO:
|
|
ret = disp_check_type_svideo(disp_id_intf, u);
|
|
break;
|
|
case UAPI_DISP_INTF_TYPE_VGA:
|
|
ret = disp_check_type_vga(disp_id_intf, u);
|
|
break;
|
|
case UAPI_DISP_INTF_TYPE_PANEL:
|
|
ret = disp_check_type_panel(disp_id_intf, u);
|
|
break;
|
|
default:
|
|
soc_err_disp("intf_type is invalid.\n");
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static td_s32 disp_check_intf(const uapi_disp_intf *disp_id_intf, td_u32 intf_num)
|
|
{
|
|
td_u32 u;
|
|
td_s32 ret;
|
|
|
|
if (disp_id_intf == NULL) {
|
|
soc_err_disp("para disp_id_intf is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
if (intf_num > EXT_DISP_SUPPORT_MAX_INTF_NUM) {
|
|
soc_err_disp("Intf num is too large.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
/* check parameters */
|
|
for (u = 0; u < intf_num; u++) {
|
|
ret = disp_check_intf_type(disp_id_intf, u);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("invalid intf type(%d) para", disp_id_intf[u].intf_type);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_disp_attach_intf(uapi_disp disp_id, const uapi_disp_intf *intf, td_u32 intf_num)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_intf drv_intf;
|
|
td_s32 ret;
|
|
td_u32 u;
|
|
|
|
vo_disp_func_enter();
|
|
if (intf == TD_NULL) {
|
|
soc_err_disp("para disp_id_intf is null.\n");
|
|
return SOC_ERR_VO_NULL_PTR;
|
|
}
|
|
|
|
if (intf_num > EXT_DISP_SUPPORT_MAX_INTF_NUM) {
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
check_disp_id(disp_id);
|
|
|
|
/* check parameters */
|
|
ret = disp_check_intf(intf, intf_num);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
for (u = 0; u < intf_num; u++) {
|
|
ret = transfer_intf_u_to_m(&intf[u], &drv_intf);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("transfer_intf interface %d failed!\n", (td_s32)intf[u].intf_type);
|
|
break;
|
|
}
|
|
|
|
ret = ext_mpi_disp_add_intf(disp, &drv_intf);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("attach interface %d failed!\n", (td_s32)intf[u].intf_type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ret != TD_SUCCESS) {
|
|
for (; u > 0; u--) {
|
|
ret = transfer_intf_u_to_m(&intf[u - 1], &drv_intf);
|
|
if (ret != TD_SUCCESS) {
|
|
continue;
|
|
}
|
|
ret = ext_mpi_disp_del_intf(disp, &drv_intf);
|
|
if (ret != TD_SUCCESS) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_detach_intf(uapi_disp disp_id, const uapi_disp_intf *stintf, td_u32 intf_num)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_intf drv_intf;
|
|
td_u32 u;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(stintf);
|
|
|
|
if (intf_num > EXT_DISP_SUPPORT_MAX_INTF_NUM) {
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
/* check parameters */
|
|
ret = disp_check_intf(stintf, intf_num);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
for (u = 0; u < intf_num; u++) {
|
|
ret = transfer_intf_u_to_m(&stintf[u], &drv_intf);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("transfer_intf interface %d failed!\n", (td_s32)stintf[u].intf_type);
|
|
break;
|
|
}
|
|
|
|
ret = ext_mpi_disp_del_intf(disp, &drv_intf);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("Detach interface %d failed!\n", (td_s32)stintf[u].intf_type);
|
|
break;
|
|
}
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_custom_timing(uapi_disp disp_id[], const uapi_disp_timing timing[], td_u32 disp_num)
|
|
{
|
|
td_s32 ret;
|
|
td_u32 chan_num;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_format_param drv_custom_timing;
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(disp_id);
|
|
check_iapi_null_ptr(timing);
|
|
|
|
if (disp_num >= UAPI_DISPLAY_MAX) {
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
ret = memset_s(&drv_custom_timing, sizeof(drv_custom_timing), 0, sizeof(drv_custom_timing));
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
for (chan_num = 0; chan_num < disp_num; chan_num++) {
|
|
check_disp_id(disp_id[chan_num]);
|
|
transfer_disp_id(&disp_id[chan_num], &disp, TD_TRUE);
|
|
|
|
transfer_timing_iapi2mpi(&timing[chan_num], &(drv_custom_timing.custom_timing));
|
|
|
|
ret = ext_mpi_disp_set_custom_timing(disp, &drv_custom_timing);
|
|
if (ret != TD_SUCCESS) {
|
|
break;
|
|
}
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_custom_timing(uapi_disp disp_id, uapi_disp_timing *timing)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
ext_drv_disp_format_param get_custom_timing;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(timing);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_timing(disp, &get_custom_timing);
|
|
if (ret == TD_SUCCESS) {
|
|
transfer_timing_mpi2iapi(timing, &(get_custom_timing.custom_timing));
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_test_pattern(uapi_disp disp_id, td_bool enable, const uapi_disp_color *pattern_attr)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_color color;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(pattern_attr);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
transfer_bgcolor_iapi2mpi(pattern_attr, &color);
|
|
ret = ext_mpi_disp_set_test_pattern(disp, enable, &color);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_test_pattern(uapi_disp disp_id, td_bool *enable, uapi_disp_color *pattern_attr)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_color color = { 0 };
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(enable);
|
|
check_iapi_null_ptr(pattern_attr);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_test_pattern(disp, enable, &color);
|
|
if (ret == TD_SUCCESS) {
|
|
transfer_bgcolor_mpi2iapi(pattern_attr, &color);
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_inkrgb(uapi_disp disp_id, uapi_disp_ink_attr *ink_attr, uapi_disp_color *ink_data)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_ink_attr ink_attr_mpi;
|
|
ext_drv_disp_color ink_rgb_mpi = { 0 };
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(ink_attr);
|
|
check_iapi_null_ptr(ink_data);
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
transfer_ink_attr_iapi2mpi(ink_attr, &ink_attr_mpi);
|
|
|
|
ret = ext_mpi_disp_get_inkrgb(disp, &ink_attr_mpi, &ink_rgb_mpi);
|
|
if (ret == TD_SUCCESS) {
|
|
transfer_bgcolor_mpi2iapi(ink_data, &ink_rgb_mpi);
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_sink_delay(uapi_disp disp_id, td_u32 sink_delay)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_sink_delay(disp, sink_delay);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_sink_delay(uapi_disp disp_id, td_u32 *sink_delay)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(sink_delay);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_sink_delay(disp, sink_delay);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_dolby_vision_info(uapi_disp disp_id, const uapi_disp_dolbyvision_info *dolby_vison_info)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_dolbyvision_info info = {{0}};
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(dolby_vison_info);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
ret = memcpy_s(info.target_bin_path, (sizeof(info.target_bin_path) - 1),
|
|
dolby_vison_info->target_bin_path, (sizeof(dolby_vison_info->target_bin_path) - 1));
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("memcpy_s failed, err = 0x%x\n", ret);
|
|
return ret;
|
|
}
|
|
info.target_bin_path[DRV_MAX_FILEPATH_LEN - 1] = '\0';
|
|
|
|
ret = ext_mpi_disp_set_dolbyvision_info(disp, &info);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_dolby_vision_info(uapi_disp disp_id, uapi_disp_dolbyvision_info *dolby_vison_info)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_dolbyvision_info info = {{0}};
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(dolby_vison_info);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
ret = ext_mpi_disp_get_dolbyvision_info(disp, &info);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("ext_mpi_disp_get_dolbyvision_info failed! ret= 0x%x \n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = memcpy_s(dolby_vison_info->target_bin_path, (sizeof(dolby_vison_info->target_bin_path) - 1),
|
|
info.target_bin_path, (sizeof(info.target_bin_path) - 1));
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("memcpy_s failed, err = 0x%x\n", ret);
|
|
return ret;
|
|
}
|
|
dolby_vison_info->target_bin_path[DRV_MAX_FILEPATH_LEN - 1] = '\0';
|
|
vo_disp_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_disp_create_vbi(uapi_disp disp_id, const uapi_disp_vbi_cfg *cfg, td_handle *vbi_handle)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_vbi_cfg vbi_cfg;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(cfg);
|
|
check_iapi_null_ptr(vbi_handle);
|
|
|
|
if (cfg->vbi_type >= UAPI_DISP_VBI_TYPE_MAX) {
|
|
soc_err_disp("pstCfg->enType para is invalid.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
transfer_vbi_cfg_iapi2mpi(cfg, &vbi_cfg);
|
|
|
|
ret = ext_mpi_disp_vbi_create(disp, &vbi_cfg, vbi_handle);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_destroy_vbi(td_handle vbi_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
ret = ext_mpi_disp_vbi_destroy(vbi_handle);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_send_vbi_data(td_handle vbi_handle, const uapi_disp_vbi_data *vbi_data)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_disp_vbi_data disp_vbi_data = {0};
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(vbi_data);
|
|
|
|
if (vbi_data->vbi_type >= UAPI_DISP_VBI_TYPE_MAX) {
|
|
soc_err_disp("pstVbiData->enType para is invalid.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
ret = transfer_vbi_data_iapi2mpi(vbi_data, &disp_vbi_data);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
ret = ext_mpi_disp_vbi_sendvbidata(vbi_handle, &disp_vbi_data);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_wss(uapi_disp disp_id, const uapi_disp_wss_data *wss_data)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
ext_drv_disp_wss_data disp_wss_cfg;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(wss_data);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
disp_wss_cfg.enable = wss_data->enable;
|
|
disp_wss_cfg.data = wss_data->data;
|
|
|
|
ret = ext_mpi_disp_set_wss(disp, &disp_wss_cfg);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_macrovision(uapi_disp disp_id, uapi_disp_macrovision_mode mode, const td_void *data)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
(td_void)(data);
|
|
check_disp_id(disp_id);
|
|
if (mode >= UAPI_DISP_MACROVISION_MODE_MAX) {
|
|
soc_err_disp("enMode para is invalid.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_macrovision(disp, (ext_drv_disp_macrovision)mode);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_macrovision(uapi_disp disp_id, uapi_disp_macrovision_mode *mode, const td_void *data)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_macrovision get_mode = 0;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
(td_void)(data);
|
|
check_disp_id(disp_id);
|
|
if (mode == NULL) {
|
|
soc_err_disp("para penMode is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_macrovision(disp, &get_mode);
|
|
*mode = (uapi_disp_macrovision_mode)get_mode;
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_cgms(uapi_disp disp_id, const uapi_disp_cgms_cfg *cgms_cfg)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
ext_drv_disp_cgmsa_cfg disp_cgms_cgf;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
if (cgms_cfg == NULL) {
|
|
soc_err_disp("para pstCgmsCfg is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
if (cgms_cfg->mode >= UAPI_DISP_CGMS_MODE_MAX || cgms_cfg->type >= UAPI_DISP_CGMS_TYPE_MAX) {
|
|
soc_err_disp("pstCgmsCfg para is invalid.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
(td_void) transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
(td_void) transfer_cgms_cfg(cgms_cfg, &disp_cgms_cgf, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_cgms(disp, (ext_drv_disp_cgmsa_cfg *)&disp_cgms_cgf);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_snapshot_attr(uapi_disp disp_id, const uapi_disp_snap_attr *snap_attr)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_snapshot_attr snap_attr_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (snap_attr == TD_NULL) {
|
|
soc_err_disp("para pst_snap_attr is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
if (snap_attr->snap_type != UAPI_DISP_SNAP_TYPE_VIDEOGFX) {
|
|
soc_err_disp("snap only support videocfx(0) type, set %d invalid!\n", snap_attr->snap_type);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
snap_attr_tmp.width = snap_attr->width;
|
|
snap_attr_tmp.height = snap_attr->height;
|
|
ret = ext_mpi_disp_snapshot_set_attr(disp, &snap_attr_tmp);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_acquire_snapshot(uapi_disp disp_id, uapi_video_frame_info *frame_info)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_video_frame frame = { 0 };
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
if (frame_info == NULL) {
|
|
soc_err_disp("para pstSnapShotFrame is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
ret = ext_mpi_disp_snapshot_acquire(disp, &frame);
|
|
if (ret == TD_SUCCESS) {
|
|
ret = transfer_frame(frame_info, &frame, TD_FALSE);
|
|
if (ret != TD_SUCCESS) {
|
|
ext_fatal_win("trans frame infor failed!\n");
|
|
ret = SOC_ERR_VO_FRAME_INFO_ERROR;
|
|
}
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_release_snapshot(uapi_disp disp_id, const uapi_video_frame_info *frame_info)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
ext_drv_video_frame frame = { 0 };
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
if (frame_info == NULL) {
|
|
soc_err_disp("para pst_snap_shot_frame is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
ret = transfer_frame((uapi_video_frame_info *)frame_info, &frame, TD_TRUE);
|
|
if (ret != TD_SUCCESS) {
|
|
ext_fatal_win("trans frame infor failed!\n");
|
|
return SOC_ERR_VO_FRAME_INFO_ERROR;
|
|
}
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
ret = ext_mpi_disp_snapshot_release(disp, &frame);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_panel_3d(uapi_disp disp_id, const td_bool enable)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id > UAPI_DISPLAY2) {
|
|
soc_err_disp("isp_id is invalid disp %d.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_panel_3d(disp, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_panel_3d(uapi_disp disp_id, td_bool *enable)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id > UAPI_DISPLAY2) {
|
|
soc_err_disp("isp_id is invalid disp %d.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_panel_3d(disp, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_right_eye_first(uapi_disp disp_id, td_bool *enable)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id > UAPI_DISPLAY2) {
|
|
soc_err_disp("isp_id is invalid disp %d.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
ret = ext_mpi_disp_get_righteyefirst(disp, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_create_cast(uapi_disp disp_id, const uapi_disp_cast_attr *attr, td_handle *cast_handle)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_cast_cfg cfg = { 0 };
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
if (attr == NULL) {
|
|
soc_err_disp("para pstAttr is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
if (cast_handle == NULL) {
|
|
soc_err_disp("para phCast is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
if (attr->format >= UAPI_FORMAT_MAX) {
|
|
soc_err_disp("pstAttr->enFormat para is invalid.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
transfer_cast_cfg(attr, &cfg);
|
|
|
|
ret = ext_mpi_disp_cast_create(disp, &cfg, cast_handle);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_destroy_cast(td_handle cast_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
ret = ext_mpi_disp_cast_destroy(cast_handle);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_cast_enable(td_handle cast_handle, td_bool enable)
|
|
{
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
ret = ext_mpi_disp_cast_set_enable(cast_handle, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_cast_enable(td_handle cast_handle, td_bool *enable)
|
|
{
|
|
td_s32 ret;
|
|
vo_disp_func_enter();
|
|
if (enable == NULL) {
|
|
soc_err_disp("para enable is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
ret = ext_mpi_disp_cast_get_enable(cast_handle, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_acquire_cast_frame(td_handle cast_handle, uapi_video_frame_info *frame_info,
|
|
td_u32 timeout_ms)
|
|
{
|
|
ext_drv_video_frame mpi_frame = { 0 };
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(frame_info);
|
|
|
|
if (timeout_ms > TIMEOUT_MAX_VALUE_MS) {
|
|
ext_err_win("timeout is too big.\n");
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
|
|
ret = ext_mpi_disp_cast_acquire_frame(cast_handle, &mpi_frame);
|
|
if (ret == TD_SUCCESS) {
|
|
ret = transfer_frame(frame_info, &mpi_frame, TD_FALSE);
|
|
if (ret != TD_SUCCESS) {
|
|
ext_fatal_win("trans frame infor failed!\n");
|
|
ret = SOC_ERR_VO_FRAME_INFO_ERROR;
|
|
}
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_release_cast_frame(td_handle cast_handle, const uapi_video_frame_info *frame_info)
|
|
{
|
|
ext_drv_video_frame mpi_frame = { 0 };
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(frame_info);
|
|
|
|
ret = transfer_frame((uapi_video_frame_info *)frame_info, &mpi_frame, TD_TRUE);
|
|
if (ret != TD_SUCCESS) {
|
|
ext_fatal_win("trans frame infor failed!\n");
|
|
return SOC_ERR_VO_FRAME_INFO_ERROR;
|
|
}
|
|
|
|
ret = ext_mpi_disp_cast_releasecast_frame(cast_handle, &mpi_frame);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_right_eye_first(uapi_disp disp_id, const td_bool enable)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id > UAPI_DISPLAY1) {
|
|
soc_err_disp("para disp_id is invalid or not support now.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
if ((enable != TD_TRUE) && (enable != TD_FALSE)) {
|
|
ext_err_win("para bEnable is invalid.\n");
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
ret = ext_mpi_disp_set_righteyefirst(disp, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_virtual_screen(uapi_disp disp_id, td_u32 width, td_u32 height)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id > UAPI_DISPLAY1) {
|
|
soc_err_disp("para disp_id is invalid or not support now.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_virtual_screen(disp, width, height);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_virtual_screen(uapi_disp disp_id, td_u32 *width, td_u32 *height)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(width);
|
|
check_iapi_null_ptr(height);
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_virtual_screen(disp, width, height);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_screenoffset(uapi_disp disp_id,
|
|
uapi_disp_screen_type offset_type, const uapi_disp_offset *offset)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_offset drv_offset = {0};
|
|
ext_drv_disp_screen_type drv_offset_type = {0};
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(offset);
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
transfer_disp_set_offset(offset, &drv_offset);
|
|
transfer_disp_offset_type(&offset_type, &drv_offset_type, TD_TRUE);
|
|
ret = ext_mpi_disp_set_screen_offset(disp, drv_offset_type, &drv_offset);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_screenoffset(uapi_disp disp_id,
|
|
uapi_disp_screen_type *offset_type, uapi_disp_offset *offset)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_offset drv_offset;
|
|
ext_drv_disp_screen_type drv_offset_type;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id > UAPI_DISPLAY1) {
|
|
soc_err_disp("para disp_id is invalid or not support now.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
if (offset == NULL) {
|
|
soc_err_disp("para pstOffset is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
if (offset_type == NULL) {
|
|
soc_err_disp("para offset_type is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_screen_offset(disp, &drv_offset_type, &drv_offset);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
transfer_disp_offset(offset, &drv_offset, TD_FALSE);
|
|
transfer_disp_offset_type(offset_type, &drv_offset_type, TD_FALSE);
|
|
vo_disp_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_pixelmove(uapi_disp disp_id, uapi_disp_pixel_move_mode iapi_mode,
|
|
td_s32 x_offset, td_s32 y_offset)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_pixel_move_mode mpi_mode;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id >= UAPI_DISPLAY_MAX) {
|
|
soc_err_disp("para disp_id(%d) is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
if (iapi_mode == UAPI_DISP_PIXEL_MOVE_JUSTSCAN) {
|
|
mpi_mode = EXT_DRV_DISP_PIXEL_MOVE_JUSTSCAN;
|
|
} else if (iapi_mode == UAPI_DISP_PIXEL_MOVE_OVERSCAN) {
|
|
mpi_mode = EXT_DRV_DISP_PIXEL_MOVE_OVERSCAN;
|
|
} else {
|
|
soc_err_disp("para pixel_move mode(%d) is invalid\n", iapi_mode);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
ret = ext_mpi_disp_set_pixelmove(disp, mpi_mode, x_offset, y_offset);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_pixelmove(uapi_disp disp_id, uapi_disp_pixel_move_mode *iapi_mode,
|
|
td_s32 *x_offset, td_s32 *y_offset)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_pixel_move_mode mpi_mode;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id > UAPI_DISPLAY1) {
|
|
soc_err_disp("para disp_id(%d) is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
check_iapi_null_ptr(iapi_mode);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_pixelmove(disp, &mpi_mode, x_offset, y_offset);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
if (mpi_mode == EXT_DRV_DISP_PIXEL_MOVE_JUSTSCAN) {
|
|
*iapi_mode = UAPI_DISP_PIXEL_MOVE_JUSTSCAN;
|
|
} else if (mpi_mode == EXT_DRV_DISP_PIXEL_MOVE_OVERSCAN) {
|
|
*iapi_mode = UAPI_DISP_PIXEL_MOVE_OVERSCAN;
|
|
} else {
|
|
soc_err_disp("para pixel_move mode(%d) is invalid\n", mpi_mode);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
vo_disp_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_memc_range(uapi_disp disp_id, uapi_disp_range *range)
|
|
{
|
|
TD_UNUSED(disp_id);
|
|
TD_UNUSED(range);
|
|
if (range != TD_NULL) {
|
|
range->min = 0;
|
|
range->max = 0;
|
|
}
|
|
return SOC_ERR_DISP_NOT_SUPPORT;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_memc_demo(uapi_disp disp_id, const uapi_disp_memc_demo *memc_demo)
|
|
{
|
|
ext_drv_display disp_channel = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_memc_demo disp_memc_demo = {0};
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(memc_demo);
|
|
|
|
if (disp_id != UAPI_DISPLAY0) {
|
|
soc_err_disp("para disp%d is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp_channel, TD_TRUE);
|
|
transfer_disp_set_memc_demo(memc_demo, &disp_memc_demo);
|
|
ret = ext_mpi_disp_set_memc_demo(disp_channel, &disp_memc_demo);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_memc_demo(uapi_disp disp_id, uapi_disp_memc_demo *memc_demo)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp_channel = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_memc_demo disp_memc_demo;
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(memc_demo);
|
|
|
|
if (disp_id != UAPI_DISPLAY0) {
|
|
soc_err_disp("para disp%d is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
if (memc_demo == NULL) {
|
|
soc_err_disp("para enable is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp_channel, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_memc_demo(disp_channel, &disp_memc_demo);
|
|
if (ret == TD_SUCCESS) {
|
|
transfer_disp_get_memc_demo(memc_demo, &disp_memc_demo);
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_memc_level(uapi_disp disp_id, td_u32 memc_level)
|
|
{
|
|
ext_drv_display disp_channel = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id != UAPI_DISPLAY0) {
|
|
soc_err_disp("para disp%d is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp_channel, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_memc_level(disp_channel, memc_level);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_memc_level(uapi_disp disp_id, td_u32 *memc_level)
|
|
{
|
|
ext_drv_display disp_channel = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id != UAPI_DISPLAY0) {
|
|
soc_err_disp("para disp%d is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
if (memc_level == NULL) {
|
|
soc_err_disp("para memc_level is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp_channel, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_memc_level(disp_channel, memc_level);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_memc_enable(uapi_disp disp_id, td_bool enable)
|
|
{
|
|
ext_drv_display disp_channel = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
disp_check_bool(enable);
|
|
|
|
if (disp_id != UAPI_DISPLAY0) {
|
|
soc_err_disp("para disp%d is invalid or not support now.\n", enable);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp_channel, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_memc_enable(disp_channel, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_memc_enable(uapi_disp disp_id, td_bool *enable)
|
|
{
|
|
ext_drv_display disp_channel = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (enable == NULL) {
|
|
soc_err_disp("para enable is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
if (disp_id != UAPI_DISPLAY0) {
|
|
soc_err_disp("para disp%d is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp_channel, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_memc_enable(disp_channel, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_judder_free (uapi_disp disp_id, td_bool enable)
|
|
{
|
|
ext_drv_display disp_channel = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
disp_check_bool(enable);
|
|
|
|
if (disp_id != UAPI_DISPLAY0) {
|
|
soc_err_disp("para disp%d is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp_channel, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_judder_free(disp_channel, enable);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("set judder free enable failed, ret->0x%x\n", ret);
|
|
}
|
|
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_judder_free (uapi_disp disp_id, td_bool *enable)
|
|
{
|
|
ext_drv_display disp_channel = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(enable);
|
|
|
|
if (disp_id != UAPI_DISPLAY0) {
|
|
soc_err_disp("para disp%d is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp_channel, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_judder_free(disp_channel, enable);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("get judder free enable state failed, ret->0x%x\n", ret);
|
|
}
|
|
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_flip(uapi_disp disp_id, td_bool hor_flip, td_bool ver_flip)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id > UAPI_DISPLAY1) {
|
|
soc_err_disp("para disp_id(%d) is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
ret = ext_mpi_disp_set_flip(disp, hor_flip, ver_flip);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_flip(uapi_disp disp_id, td_bool *hor_flip, td_bool *ver_flip)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id > UAPI_DISPLAY1) {
|
|
soc_err_disp("para disp_id(%d) is invalid or not support now.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
ret = ext_mpi_disp_get_flip(disp, hor_flip, ver_flip);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_hdr_type(uapi_disp disp_id, const uapi_disp_hdr_type hdr_type)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_out_type mpi_disp_type = EXT_DRV_DISP_TYPE_NORMAL;
|
|
uapi_disp_hdr_type iapi_hdr_type;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
|
|
if (hdr_type >= UAPI_DISP_HDR_TYPE_MAX) {
|
|
soc_err_disp("para enIapiDispType is invalid.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
iapi_hdr_type = hdr_type;
|
|
transfer_disp_type(&iapi_hdr_type, &mpi_disp_type, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_disp_output(disp, mpi_disp_type);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_hdr_type(uapi_disp disp_id, uapi_disp_hdr_type *hdr_type)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_out_type mpi_disp_type;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
if (hdr_type == NULL) {
|
|
soc_err_disp("para penHDRType is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_disp_output(disp, &mpi_disp_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
transfer_disp_type(hdr_type, &mpi_disp_type, TD_FALSE);
|
|
vo_disp_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_color_space(uapi_disp disp_id, uapi_disp_color_space color_space)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
uapi_disp_color_space iapi_color_space;
|
|
ext_drv_disp_output_color_space mpi_color_space = EXT_DRV_DISP_COLOR_SPACE_BUTT;
|
|
td_s32 ret;
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
if (color_space >= UAPI_DISP_COLOR_SPACE_MAX) {
|
|
soc_err_disp("para enColorSpace is invalid.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
iapi_color_space = color_space;
|
|
transfer_disp_color_space(&iapi_color_space, &mpi_color_space, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_color_space(disp, mpi_color_space);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
vo_disp_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_color_space(uapi_disp disp_id, uapi_disp_color_space *color_space)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_output_color_space mpi_color_space = EXT_DRV_DISP_COLOR_SPACE_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
|
|
if (color_space == NULL) {
|
|
soc_err_disp("para penColorSpace is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_color_space(disp, &mpi_color_space);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
transfer_disp_color_space(color_space, &mpi_color_space, TD_FALSE);
|
|
vo_disp_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_sink_capability(uapi_disp disp_id, const uapi_disp_sink_capability *sink_cap)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_sink_capability sink_capability = {0};
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
|
|
check_iapi_null_ptr(sink_cap);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
transfer_disp_set_capability(sink_cap, &sink_capability);
|
|
|
|
ret = ext_mpi_disp_set_sink_capability(disp, &sink_capability);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_hdr_match_content(uapi_disp disp_id, uapi_disp_hdr_match_mode match_content_mode)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_match_content_mode disp_match_content_mode = EXT_DRV_DISP_MATCH_CONTENT_MODE_NONE;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
transfer_hdr_match_content(&match_content_mode, &disp_match_content_mode, TD_TRUE);
|
|
ret = ext_mpi_disp_set_hdr_match_content(disp, disp_match_content_mode);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_hdr_match_content(uapi_disp disp_id, uapi_disp_hdr_match_mode *match_content_mode)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_match_content_mode disp_match_content_mode = EXT_DRV_DISP_MATCH_CONTENT_MODE_NONE;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(match_content_mode);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
ret = ext_mpi_disp_get_hdr_match_content(disp, &disp_match_content_mode);
|
|
if (ret == TD_SUCCESS) {
|
|
transfer_hdr_match_content(match_content_mode, &disp_match_content_mode, TD_FALSE);
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_output_status(uapi_disp disp_id, uapi_disp_output_status *output_status)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_output_status disp_out_status = { 0 };
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
if (disp_id > UAPI_DISPLAY1) {
|
|
soc_err_disp("para disp_id is invalid or not support now.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
if (output_status == NULL) {
|
|
soc_err_disp("para pstOutputStatus is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_output_status(disp, &disp_out_status);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
transfer_disp_type(&output_status->actual_out_hdr_type, &disp_out_status.actual_output_type, TD_FALSE);
|
|
transfer_disp_color_space(&output_status->actual_out_colorpace, &disp_out_status.actual_output_colorspace,
|
|
TD_FALSE);
|
|
output_status->refresh_rate = disp_out_status.refresh_rate;
|
|
vo_disp_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_hdr_priority_mode(uapi_disp disp_id, uapi_disp_hdr_priority_mode priority_mode)
|
|
{
|
|
ext_drv_display disp_channel = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_hdr_priority_mode hdr_priority_mode = EXT_DRV_DISP_HDR_PRIORITY_MAX;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
if (priority_mode >= UAPI_DISP_HDR_PRIORITY_MAX) {
|
|
soc_err_disp("para enPriorityMode->%d is invalid or not support now.\n", priority_mode);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &disp_channel, TD_TRUE);
|
|
mpi_disp_transfer_priority_mode(&priority_mode, &hdr_priority_mode, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_hdr_priority_mode(disp_channel, hdr_priority_mode);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_hdr_priority_mode(uapi_disp disp_id, uapi_disp_hdr_priority_mode *priority_mode)
|
|
{
|
|
ext_drv_display disp_channel = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_hdr_priority_mode hdr_priority_mode = EXT_DRV_DISP_HDR_PRIORITY_MAX;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(priority_mode);
|
|
|
|
check_disp_id(disp_id);
|
|
transfer_disp_id(&disp_id, &disp_channel, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_hdr_priority_mode(disp_channel, &hdr_priority_mode);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("get priority mode failed,ret->%#x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_disp_transfer_priority_mode(priority_mode, &hdr_priority_mode, TD_FALSE);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_intf_status(uapi_disp disp_id, uapi_disp_intf_group *intf_status)
|
|
{
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_intf drv_intf[UAPI_DISP_INTF_MAX_NUMBER] = {{0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}};
|
|
td_u32 intf_num = 0;
|
|
td_u32 u;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
if (intf_status == TD_NULL) {
|
|
soc_err_disp("disp_id_intfStatus is null.\n");
|
|
return SOC_ERR_DISP_NULL_PTR;
|
|
}
|
|
|
|
transfer_disp_id(&disp_id, &(disp), TD_TRUE);
|
|
ret = ext_mpi_disp_get_intf_status(disp, drv_intf, UAPI_DISP_INTF_MAX_NUMBER, &intf_num);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("get intf status failed(%x)!\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
for (u = 0; u < intf_num; u++) {
|
|
ret = transfer_intf_m_to_u(&intf_status->intf[u], &(drv_intf[u]));
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("intf transfer failed(num = %x)!\n", intf_num);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
intf_status->number = intf_num;
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_capability(uapi_disp disp_id, uapi_disp_capability *disp_cap)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_capability drv_disp_capability;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(disp_cap);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_capability(disp, &drv_disp_capability);
|
|
if (ret == TD_SUCCESS) {
|
|
transfer_disp_get_capability(disp_cap, &drv_disp_capability);
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_disp_format(const uapi_disp disp_id[], const uapi_disp_format format[], td_u32 disp_num)
|
|
{
|
|
td_s32 ret;
|
|
td_u32 number;
|
|
ext_drv_display disp[DISP_CHANNEL_MAX_NUMBER] = { EXT_DRV_DISPLAY_BUTT, EXT_DRV_DISPLAY_BUTT };
|
|
ext_drv_disp_format_param set_format_param[DISP_CHANNEL_MAX_NUMBER];
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(format);
|
|
check_iapi_null_ptr(disp_id);
|
|
|
|
ret = memset_s(set_format_param, sizeof(set_format_param), 0, sizeof(set_format_param));
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
if (disp_num == 0 || disp_num > DISP_CHANNEL_MAX_NUMBER) {
|
|
soc_err_disp("multi channel number(%d) is error\n", disp_num);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
} else if (disp_num == DISP_CHANNEL_MAX_NUMBER) {
|
|
if (disp_id[0] == disp_id[1]) {
|
|
soc_err_disp("same disp_id(%d) cannot be set twice\n", disp_id[0]);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
}
|
|
|
|
for (number = 0; number < disp_num; number++) {
|
|
transfer_set_disp_id(&disp_id[number], &disp[number]);
|
|
if (disp[number] != EXT_DRV_DISPLAY_0 && disp[number] != EXT_DRV_DISPLAY_1) {
|
|
soc_err_disp("disp is error.\n");
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
ret = transfer_enc_set_fmt(&(format[number].video_format), &(set_format_param[number].format));
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("param disp and fmt trans error.\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = transfer_disp_set_3d_mode(&(format[number].mode_3d), &(set_format_param[number].disp_3d_mode));
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("stereo mode trans error.\n");
|
|
return ret;
|
|
}
|
|
|
|
transfer_intf_set_bitwidth(&(format[number].bit_depth),
|
|
&(set_format_param[number].intf_output[0].bit_width));
|
|
transfer_intf_set_pixelfmt(&(format[number].pixel_format),
|
|
&(set_format_param[number].intf_output[0].pixel_fmt));
|
|
set_format_param[number].qft_attr.factor = format[number].qft_attr.factor;
|
|
}
|
|
|
|
ret = ext_mpi_disp_set_timing(disp, set_format_param, disp_num);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_disp_format(uapi_disp disp_id, uapi_disp_format *format)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_format_param get_chan_mode = { 0 };
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(format);
|
|
|
|
check_disp_id(disp_id);
|
|
|
|
transfer_disp_id(&disp_id, &disp, TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_timing(disp, &get_chan_mode);
|
|
if (ret == TD_SUCCESS) {
|
|
transfer_multi_get_disp_format(format, &get_chan_mode);
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_intf_enable(uapi_disp disp_id, const uapi_disp_intf *intf, td_bool enable)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_disp_intf drv_intf;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(intf);
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
transfer_intf_u_to_m(intf, &drv_intf);
|
|
|
|
ret = ext_mpi_disp_set_intf_enable(disp, &drv_intf, enable);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("param disp and fmt trans error.\n");
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_intf_enable(uapi_disp disp_id, uapi_disp_intf *intf, td_bool *enable)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_disp_intf drv_intf;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(intf);
|
|
check_iapi_null_ptr(enable);
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
transfer_intf_u_to_m(intf, &drv_intf);
|
|
|
|
ret = ext_mpi_disp_get_intf_enable(disp, &drv_intf, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_vrr_enable(uapi_disp disp_id, td_bool enable)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_set_vrr_enable(disp, enable);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("ext_mpi_disp_set_vrr_enable error.\n");
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_vrr_enable(uapi_disp disp_id, td_bool *enable)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
|
|
ret = ext_mpi_disp_get_vrr_enable(disp, enable);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("ext_mpi_disp_get_vrr_enable error.\n");
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_vrr_attr(uapi_disp disp_id, const uapi_disp_vrr_attr *vrr_attr)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_disp_vrr_attr disp_vrr_attr;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(vrr_attr);
|
|
|
|
if ((vrr_attr->vrr_min == 0) || (vrr_attr->vrr_min >= vrr_attr->vrr_max)) {
|
|
soc_err_disp("vrr_min:%d, vrr_max:%d invalid.\n", vrr_attr->vrr_min, vrr_attr->vrr_max);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
transfer_vrr_iapi2mpi(vrr_attr, &disp_vrr_attr);
|
|
ret = ext_mpi_disp_set_vrr_attr(disp, &disp_vrr_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("param disp and fmt trans error.\n");
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_vrr_attr(uapi_disp disp_id, uapi_disp_vrr_attr *vrr_attr)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_disp_vrr_attr disp_vrr_attr = {0};
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(vrr_attr);
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
ret = ext_mpi_disp_get_vrr_attr(disp, &disp_vrr_attr);
|
|
if (ret == TD_SUCCESS) {
|
|
transfer_vrr_mpi2iapi(vrr_attr, &disp_vrr_attr);
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_qms_enable(uapi_disp disp_id, td_bool enable)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
|
|
transfer_disp_id(&(disp_id), &disp, TD_TRUE);
|
|
ret = ext_mpi_disp_set_qms_enable(disp, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_qms_enable(uapi_disp disp_id, td_bool *enable)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(enable);
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
ret = ext_mpi_disp_get_qms_enable(disp, enable);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_qms_attr(uapi_disp disp_id, const uapi_disp_qms_attr *qms_attr)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_disp_qms_attr disp_qms = {0};
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(qms_attr);
|
|
disp_check_bool(qms_attr->m_delta);
|
|
|
|
if (qms_attr->dst_rate == 0) {
|
|
soc_err_disp("dst_rate:%d, invalid.\n", qms_attr->dst_rate);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
disp_qms.dst_rate = qms_attr->dst_rate;
|
|
disp_qms.m_delta = qms_attr->m_delta;
|
|
ret = ext_mpi_disp_set_qms_attr(disp, &disp_qms);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("param disp and fmt trans error.\n");
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_qms_attr(uapi_disp disp_id, uapi_disp_qms_attr *qms_attr)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_disp_qms_attr disp_qms = {0};
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(qms_attr);
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
ret = ext_mpi_disp_get_qms_attr(disp, &disp_qms);
|
|
if (ret == TD_SUCCESS) {
|
|
qms_attr->dst_rate = disp_qms.dst_rate;
|
|
qms_attr->m_delta = disp_qms.m_delta;
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_qft_attr(uapi_disp disp_id, const uapi_disp_qft_attr *qft_attr)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_disp_qft_attr disp_qft = {0};
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(qft_attr);
|
|
|
|
if (qft_attr->factor == 0) {
|
|
soc_err_disp("factor:%d, invalid.\n", qft_attr->factor);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
disp_qft.factor = qft_attr->factor;
|
|
ret = ext_mpi_disp_set_qft_attr(disp, &disp_qft);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_err_disp("param disp and fmt trans error.\n");
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_qft_attr(uapi_disp disp_id, uapi_disp_qft_attr *qft_attr)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_qft_attr disp_qft = {0};
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(qft_attr);
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
ret = ext_mpi_disp_get_qft_attr(disp, &disp_qft);
|
|
if (ret == TD_SUCCESS) {
|
|
qft_attr->factor = disp_qft.factor;
|
|
}
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_allm_mode(uapi_disp disp_id, uapi_disp_allm_mode allm_mode)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_allm_mode mpi_allm_mode;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
if (allm_mode == UAPI_DISP_ALLM_MODE_AUTO) {
|
|
mpi_allm_mode = EXT_DRV_DISP_ALLM_MODE_AUTO;
|
|
} else if (allm_mode == UAPI_DISP_ALLM_MODE_ON) {
|
|
mpi_allm_mode = EXT_DRV_DISP_ALLM_MODE_ON;
|
|
} else if (allm_mode == UAPI_DISP_ALLM_MODE_OFF) {
|
|
mpi_allm_mode = EXT_DRV_DISP_ALLM_MODE_OFF;
|
|
} else {
|
|
ext_err_win("allm_mode is invalid,cur:%d max:%d.\n", allm_mode, UAPI_DISP_ALLM_MODE_MAX);
|
|
return SOC_ERR_VO_INVALID_PARA;
|
|
}
|
|
|
|
ret = ext_mpi_disp_set_allm(disp, mpi_allm_mode);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_allm_mode(uapi_disp disp_id, uapi_disp_allm_mode *allm_mode)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
ext_drv_disp_allm_mode mpi_allm_mode = EXT_DRV_DISP_ALLM_MODE_MAX;
|
|
|
|
vo_disp_func_enter();
|
|
check_disp_id(disp_id);
|
|
check_iapi_null_ptr(allm_mode);
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
ret = ext_mpi_disp_get_allm(disp, &mpi_allm_mode);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
transfer_allm_mode_m_to_u(&mpi_allm_mode, allm_mode);
|
|
vo_disp_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_state(uapi_disp disp_id, uapi_disp_state *state)
|
|
{
|
|
ext_drv_disp_state mpi_state = { 0 };
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
td_s32 ret;
|
|
|
|
vo_disp_func_enter();
|
|
check_iapi_null_ptr(state);
|
|
if (disp_id > UAPI_DISPLAY2) {
|
|
soc_err_disp("para disp_id(%d) is invalid.\n", disp_id);
|
|
return SOC_ERR_DISP_INVALID_PARA;
|
|
}
|
|
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
mpi_state.master_disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
ret = ext_mpi_disp_get_state(disp, &mpi_state);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
state->is_open = mpi_state.is_open;
|
|
state->is_slave = mpi_state.is_slave;
|
|
transfer_disp_id(&(state->master_disp), &(mpi_state.master_disp), TD_FALSE);
|
|
vo_disp_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_secure_view_flag(uapi_disp disp_id, td_u32 secure_view_flag)
|
|
{
|
|
TD_UNUSED(disp_id);
|
|
TD_UNUSED(secure_view_flag);
|
|
return SOC_ERR_DISP_NOT_SUPPORT;
|
|
}
|
|
|
|
td_s32 uapi_disp_set_power_state(uapi_disp disp_id, uapi_disp_power_state power_state)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_disp_power_state drv_ower_state;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
if (power_state == UAPI_DISP_POWER_ON) {
|
|
drv_ower_state = EXT_DRV_DISP_POWER_ON;
|
|
} else if (power_state == UAPI_DISP_POWER_OFF) {
|
|
drv_ower_state = EXT_DRV_DISP_POWER_OFF;
|
|
} else {
|
|
drv_ower_state = EXT_DRV_DISP_POWER_MAX;
|
|
}
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
ret = ext_mpi_disp_set_power_state(disp, drv_ower_state);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
vo_disp_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_disp_get_power_state(uapi_disp disp_id, uapi_disp_power_state *power_state)
|
|
{
|
|
td_s32 ret;
|
|
ext_drv_disp_power_state drv_ower_state;
|
|
ext_drv_display disp = EXT_DRV_DISPLAY_BUTT;
|
|
|
|
vo_disp_func_enter();
|
|
transfer_disp_id(&(disp_id), &(disp), TD_TRUE);
|
|
ret = ext_mpi_disp_get_power_state(disp, &drv_ower_state);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
if (drv_ower_state == EXT_DRV_DISP_POWER_ON) {
|
|
*power_state = UAPI_DISP_POWER_ON;
|
|
} else if (drv_ower_state == EXT_DRV_DISP_POWER_OFF) {
|
|
*power_state = UAPI_DISP_POWER_OFF;
|
|
} else {
|
|
*power_state = UAPI_DISP_POWER_MAX;
|
|
}
|
|
vo_disp_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|