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.
2263 lines
51 KiB
2263 lines
51 KiB
/******************************************************************************
|
|
* Copyright (c) Hisilicon Technologies Co., Ltd. 2012-2019. All rights reserved.
|
|
* Description: panel mpi module
|
|
* Author: sdk
|
|
* Create: 2012-11-19
|
|
******************************************************************************/
|
|
#include "mpi_panel.h"
|
|
#include <unistd.h>
|
|
#include <sys/ioctl.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <pthread.h>
|
|
#include <limits.h>
|
|
#include "mpi_memory_ext.h"
|
|
#include "securec.h"
|
|
|
|
#ifdef __cplusplus
|
|
#if __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
#endif
|
|
|
|
static td_s32 g_panel_dev_fd = -1;
|
|
static pthread_mutex_t g_panel_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
static const td_char g_panel_dev_name[] = "/dev/soc_panel";
|
|
|
|
#define mpi_panel_lock() (void)pthread_mutex_lock(&g_panel_mutex)
|
|
#define mpi_panel_unlock() (void)pthread_mutex_unlock(&g_panel_mutex)
|
|
|
|
td_s32 ext_mpi_panel_init(td_void)
|
|
{
|
|
td_char path[PATH_MAX] = {0};
|
|
|
|
soc_info_func_enter();
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd > 0) {
|
|
mpi_panel_unlock();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
if (realpath(g_panel_dev_name, path) == TD_NULL) {
|
|
soc_log_err("get realpath error!\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
g_panel_dev_fd = open(path, O_RDWR | O_NONBLOCK, 0);
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("open PANEL err.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
ext_mpi_panel_parse_panel_demura(g_panel_dev_fd);
|
|
ext_mpi_panel_parse_panel_acc(g_panel_dev_fd);
|
|
|
|
mpi_panel_unlock();
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_deinit(td_void)
|
|
{
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
mpi_panel_unlock();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
ret = close(g_panel_dev_fd);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("deinit PANEL err.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
g_panel_dev_fd = -1;
|
|
|
|
mpi_panel_unlock();
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_power_on(ext_panel_id panel_id, td_bool enable)
|
|
{
|
|
td_s32 ret;
|
|
panel_power_on panel_power = {0};
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
panel_power.id = panel_id;
|
|
panel_power.power_on = enable;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_POWERON, &panel_power);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_POWERON failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_power_on(ext_panel_id panel_id, td_bool *enable)
|
|
{
|
|
td_s32 ret;
|
|
panel_power_on panel_power = {0};
|
|
|
|
if (enable == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
panel_power.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_POWERON, &panel_power);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_POWERON failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*enable = panel_power.power_on;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_backlight_power_on(ext_panel_id panel_id, td_bool enable)
|
|
{
|
|
td_s32 ret;
|
|
panel_bl_power_on panel_bl_power = {0};
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
panel_bl_power.id = panel_id;
|
|
panel_bl_power.enable = enable;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_BACKLIGHT_POWERON, &panel_bl_power);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_BACKLIGHT_POWERON failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_backlight_power_on(ext_panel_id panel_id, td_bool *enable)
|
|
{
|
|
td_s32 ret;
|
|
panel_bl_power_on panel_bl_power = {0};
|
|
|
|
if (enable == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
panel_bl_power.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_BACKLIGHT_POWERON, &panel_bl_power);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_BACKLIGHT_POWERON failed.\n");
|
|
return ret;
|
|
}
|
|
*enable = panel_bl_power.enable;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_panel_aspect(ext_panel_id panel_id, ext_panel_aspect_info *aspect)
|
|
{
|
|
td_s32 ret;
|
|
errno_t err;
|
|
panel_aspect aspect_info = {0};
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
aspect_info.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_ASPECT, &aspect_info);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_ASPECT failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
err = memcpy_s(aspect, sizeof(ext_panel_aspect_info), &aspect_info.aspect, sizeof(aspect_info.aspect));
|
|
if (err != EOK) {
|
|
soc_log_err("memcpy_s panel_aspect_info failed, err = %d\n", err);
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_panel_3d_type(ext_panel_id panel_id, ext_panel_3d_type *type)
|
|
{
|
|
panel_3d_type_info type_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (type == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
type_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_3D_TYPE, &type_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_3D_TYPE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*type = type_tmp.type_3d;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_dynamic_backlight_enable(ext_panel_id panel_id, td_bool enable)
|
|
{
|
|
td_s32 ret;
|
|
panel_dynamic_bl_enable enable_tmp = {0};
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
enable_tmp.id = panel_id;
|
|
enable_tmp.enable = enable;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_DYNAMICBL_BACKLIGHT_ENABLE, &enable_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_DYNAMICBL_BACKLIGHT_ENABLE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_dynamic_backlight_enable(ext_panel_id panel_id, td_bool *enable)
|
|
{
|
|
panel_dynamic_bl_enable enable_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (enable == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
enable_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_DYNAMICBL_BACKLIGHT_ENABLE, &enable_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_DYNAMICBL_BACKLIGHT_ENABLE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*enable = enable_tmp.enable;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_backlight_range(ext_panel_id panel_id, ext_panel_range *range)
|
|
{
|
|
panel_bl_range range_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (range == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
range_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_BACKLIGHT_RANGE, &range_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_BACKLIGHT_RANGE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
range->min = range_tmp.bl_range.min;
|
|
range->max = range_tmp.bl_range.max;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_backlight_level(ext_panel_id panel_id, td_u32 level)
|
|
{
|
|
panel_bl_level level_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
level_tmp.id = panel_id;
|
|
level_tmp.level = level;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_BACKLIGHT_LEVEL, &level_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_BACKLIGHT_LEVEL failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_backlight_level(ext_panel_id panel_id, td_u32 *level)
|
|
{
|
|
panel_bl_level level_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
if (level == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
level_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_BACKLIGHT_LEVEL, &level_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_BACKLIGHT_LEVEL failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*level = level_tmp.level;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_dim_strength_info(ext_panel_id panel_id, ext_panel_dim_strength_info *dim_strength_info)
|
|
{
|
|
panel_dim_strength str_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (dim_strength_info == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
str_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_DIM_STRGTH_INFO, &str_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_DIM_STRGTH_INFO failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
dim_strength_info->dim_range.max = str_tmp.dim_strength.dim_range.max;
|
|
dim_strength_info->dim_range.min = str_tmp.dim_strength.dim_range.min;
|
|
dim_strength_info->dim_type = str_tmp.dim_strength.dim_type;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_dim_strength_level(ext_panel_id panel_id, td_u32 level)
|
|
{
|
|
panel_dim_level level_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
level_tmp.id = panel_id;
|
|
level_tmp.level = level;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_DIM_STRGTH_LEVEL, &level_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_DIM_STRGTH_LEVEL failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_dim_strength_level(ext_panel_id panel_id, td_u32 *level)
|
|
{
|
|
panel_dim_level level_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (level == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
level_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_DIM_STRGTH_LEVEL, &level_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_DIM_STRGTH_LEVEL failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*level = level_tmp.level;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_localdimming_demo_mode(ext_panel_id panel_id, ext_panel_ldm_demo_mode demo_mode)
|
|
{
|
|
panel_ldm_demo demo_mode_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
demo_mode_tmp.id = panel_id;
|
|
demo_mode_tmp.ld_demo_mode = demo_mode;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_DIM_DEMO_MODE, &demo_mode_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_DIM_DEMO_MODE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_localdimming_demo_mode(ext_panel_id panel_id, ext_panel_ldm_demo_mode *demo_mode)
|
|
{
|
|
panel_ldm_demo demo_mode_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (demo_mode == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
demo_mode_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_DIM_DEMO_MODE, &demo_mode_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_DIM_DEMO_MODE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*demo_mode = demo_mode_tmp.ld_demo_mode;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_voltage_range(ext_panel_id panel_id, panel_signal_list *list)
|
|
{
|
|
panel_signal signal_tmp = {0};
|
|
td_s32 ret;
|
|
errno_t err;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
signal_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_VOLTAGE_RANGE, &signal_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_VOLTAGE_RANGE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
err = memcpy_s(list, sizeof(panel_signal_list), &signal_tmp.signal_mode, sizeof(signal_tmp.signal_mode));
|
|
if (err != EOK) {
|
|
soc_log_err("memcpy_s panel_signal_list failed, err = %d\n", err);
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_voltage(ext_panel_id panel_id, td_u32 com_voltage)
|
|
{
|
|
panel_voltage com_voltage_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
com_voltage_tmp.id = panel_id;
|
|
com_voltage_tmp.com_voltage = com_voltage;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_VOLTAGE, &com_voltage_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_VOLTAGE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_voltage(ext_panel_id panel_id, td_u32 *com_voltage)
|
|
{
|
|
panel_voltage com_voltage_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (com_voltage == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
com_voltage_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_VOLTAGE, &com_voltage_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_VOLTAGE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*com_voltage = com_voltage_tmp.com_voltage;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_current_range(ext_panel_id panel_id, panel_signal_list *list)
|
|
{
|
|
panel_signal signal_tmp = {0};
|
|
td_s32 ret;
|
|
errno_t err;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
signal_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_CURRENT_RANGE, &signal_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_CURRENT_RANGE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
err = memcpy_s(list, sizeof(panel_signal_list), &signal_tmp.signal_mode, sizeof(signal_tmp.signal_mode));
|
|
if (err != EOK) {
|
|
soc_log_err("memcpy_s panel_signal_list failed, err = %d\n", err);
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_current(ext_panel_id panel_id, td_u32 current)
|
|
{
|
|
panel_current current_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
current_tmp.id = panel_id;
|
|
current_tmp.drv_current = current;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_CURRENT, ¤t_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_CURRENT failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_current(ext_panel_id panel_id, td_u32 *current)
|
|
{
|
|
panel_current current_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (current == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
current_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_CURRENT, ¤t_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_CURRENT failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*current = current_tmp.drv_current;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_emphasis_range(ext_panel_id panel_id, panel_signal_list *list)
|
|
{
|
|
panel_signal signal_tmp = {0};
|
|
td_s32 ret;
|
|
errno_t err;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
signal_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_EMPHASIS_RANGE, &signal_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_EMPHASIS_RANGE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
err = memcpy_s(list, sizeof(panel_signal_list), &signal_tmp.signal_mode, sizeof(signal_tmp.signal_mode));
|
|
if (err != EOK) {
|
|
soc_log_err("memcpy_s panel_signal_list failed, err = %d\n", err);
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_emphasis(ext_panel_id panel_id, td_u32 panel_emp)
|
|
{
|
|
panel_emp_info emp_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
emp_tmp.id = panel_id;
|
|
emp_tmp.panel_emp = panel_emp;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_EMPHASIS, &emp_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_EMPHASIS failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_emphasis(ext_panel_id panel_id, td_u32 *panel_emp)
|
|
{
|
|
panel_emp_info emp_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (panel_emp == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
emp_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_EMPHASIS, &emp_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_EMPHASIS failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*panel_emp = emp_tmp.panel_emp;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_spread_enable(ext_panel_id panel_id, td_bool enable)
|
|
{
|
|
panel_spread_enable enable_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
enable_tmp.id = panel_id;
|
|
enable_tmp.enable = enable;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_SPREAD_ENABLE, &enable_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_SPREAD_ENABLE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_spread_enable(ext_panel_id panel_id, td_bool *enable)
|
|
{
|
|
panel_spread_enable enable_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (enable == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
enable_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_SPREAD_ENABLE, &enable_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_SPREAD_ENABLE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*enable = enable_tmp.enable;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_spread_ratio_range(ext_panel_id panel_id, ext_panel_range *range)
|
|
{
|
|
panel_ratio_range range_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (range == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
range_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_SPREAD_RATIO_RANGE, &range_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_SPREAD_RATIO_RANGE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
range->max = range_tmp.ratio_range.max;
|
|
range->min = range_tmp.ratio_range.min;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_spread_ratio(ext_panel_id panel_id, td_u32 spread_ratio)
|
|
{
|
|
panel_spread_ratio ratio_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
ratio_tmp.id = panel_id;
|
|
ratio_tmp.spread_ratio = spread_ratio;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_SPREAD_RATIO, &ratio_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_SPREAD_RATIO failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_spread_ratio(ext_panel_id panel_id, td_u32 *spread_ratio)
|
|
{
|
|
panel_spread_ratio ratio_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (spread_ratio == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
ratio_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_SPREAD_RATIO, &ratio_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_SPREAD_RATIO failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*spread_ratio = ratio_tmp.spread_ratio;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_spread_freq_range(ext_panel_id panel_id, panel_signal_list *list)
|
|
{
|
|
panel_signal signal_tmp = {0};
|
|
td_s32 ret;
|
|
errno_t err;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
signal_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_SPREAD_FREQ_RANGE, &signal_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_SPREAD_FREQ_RANGE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
err = memcpy_s(list, sizeof(panel_signal_list), &signal_tmp.signal_mode, sizeof(signal_tmp.signal_mode));
|
|
if (err != EOK) {
|
|
soc_log_err("memcpy_s panel_signal_list failed, err = %d\n", err);
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_spread_freq(ext_panel_id panel_id, td_u32 spread_freq)
|
|
{
|
|
panel_spread_freq freq_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
freq_tmp.id = panel_id;
|
|
freq_tmp.spread_freq = spread_freq;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_SPREAD_FREQ, &freq_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_SPREAD_FREQ failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_spread_freq(ext_panel_id panel_id, td_u32 *spread_freq)
|
|
{
|
|
panel_spread_freq freq_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (spread_freq == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
freq_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_SPREAD_FREQ, &freq_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_SPREAD_FREQ failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*spread_freq = freq_tmp.spread_freq;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_panel_name(ext_panel_id panel_id, ext_panel_name *panel_name)
|
|
{
|
|
panel_name_info name_tmp = {0};
|
|
td_s32 ret;
|
|
errno_t err;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
name_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_PANEL_NAME, &name_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_PANEL_NAME failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
err = memcpy_s(panel_name, sizeof(ext_panel_name), &name_tmp.name, sizeof(name_tmp.name));
|
|
if (err != EOK) {
|
|
soc_log_err("memcpy_s panel_name failed, err = %d\n", err);
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_bit_depth(ext_panel_id panel_id, ext_panel_bit_depth depth)
|
|
{
|
|
panel_bit_depth_info depth_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
depth_tmp.id = panel_id;
|
|
depth_tmp.bit_depth = depth;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_BIT_DEPTH, &depth_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_BIT_DEPTH failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_bit_depth(ext_panel_id panel_id, ext_panel_bit_depth *depth)
|
|
{
|
|
panel_bit_depth_info depth_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (depth == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
depth_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_BIT_DEPTH, &depth_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_BIT_DEPTH failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*depth = depth_tmp.bit_depth;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_lvds_attr(ext_panel_id panel_id, ext_panel_lvds_attr *lvds_attr)
|
|
{
|
|
panel_lvds lvds_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (lvds_attr == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
lvds_tmp.id = panel_id;
|
|
lvds_tmp.lvds_attr.lvds_fmt = lvds_attr->lvds_fmt;
|
|
lvds_tmp.lvds_attr.lvds_link.link_map0 = lvds_attr->lvds_link.link_map0;
|
|
lvds_tmp.lvds_attr.lvds_link.link_map1 = lvds_attr->lvds_link.link_map1;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_LVDS_ATTR, &lvds_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_SET_LVDS_ATTR failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_lvds_attr(ext_panel_id panel_id, ext_panel_lvds_attr *lvds_attr)
|
|
{
|
|
td_s32 ret;
|
|
panel_lvds lvds_tmp = {0};
|
|
|
|
if (lvds_attr == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
lvds_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_LVDS_ATTR, &lvds_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_LVDS_ATTR failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
lvds_attr->lvds_fmt = lvds_tmp.lvds_attr.lvds_fmt;
|
|
lvds_attr->lvds_link.link_map0 = lvds_tmp.lvds_attr.lvds_link.link_map0;
|
|
lvds_attr->lvds_link.link_map1 = lvds_tmp.lvds_attr.lvds_link.link_map1;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_interface_type(ext_panel_id panel_id, ext_panel_intf_type *intf_type)
|
|
{
|
|
panel_intf_type_info type_tmp = {0};
|
|
td_s32 ret;
|
|
|
|
if (intf_type == TD_NULL) {
|
|
return TD_FAILURE;
|
|
}
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
type_tmp.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_INTF_TYPE, &type_tmp);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("PANEL_CMD_GET_INTF_TYPE failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*intf_type = type_tmp.intf_type;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_struct_len(td_u32 panel_id, td_u32 struct_type, td_u32 *length)
|
|
{
|
|
td_s32 ret;
|
|
panel_struct_info panel_data;
|
|
|
|
soc_info_func_enter();
|
|
|
|
if (length == TD_NULL) {
|
|
soc_log_err("INPUT data is invalid.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
if (ext_mpi_panel_init() != TD_SUCCESS) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
panel_data.id = panel_id;
|
|
panel_data.data_type = struct_type;
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_STRUCT_LENGTH, &panel_data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("ext_mpi_panel_get_struct_len failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*length = panel_data.length;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_struct_info(td_u32 panel_id, td_u32 struct_type, td_u32 length, td_u8 *panel_info)
|
|
{
|
|
td_s32 ret;
|
|
panel_struct_info panel_data;
|
|
|
|
soc_info_func_enter();
|
|
|
|
if (panel_info == TD_NULL) {
|
|
soc_log_err("input data is invalid.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
if (ext_mpi_panel_init() != TD_SUCCESS) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
if (memset_s(panel_info, length, 0, length) != EOK) {
|
|
soc_log_err("panel info init failure!!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
panel_data.id = panel_id;
|
|
panel_data.data_type = struct_type;
|
|
panel_data.length = length;
|
|
panel_data.panel_info = (td_uintptr_t)panel_info;
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_STRUCT_INFO, &panel_data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("ext_mpi_panel_get_info failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_struct_info(td_u32 panel_id, td_u32 struct_type, td_u32 length, const td_void *panel_info)
|
|
{
|
|
td_s32 ret;
|
|
panel_struct_info panel_data;
|
|
|
|
soc_info_func_enter();
|
|
|
|
if (panel_info == TD_NULL) {
|
|
soc_log_err("input data is invalid.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
if (ext_mpi_panel_init() != TD_SUCCESS) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
panel_data.id = panel_id;
|
|
panel_data.data_type = struct_type;
|
|
panel_data.length = length;
|
|
panel_data.panel_info = (td_uintptr_t)panel_info;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_STRUCT_INFO, &panel_data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("ext_mpi_panel_set_info failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
panel_info = TD_NULL;
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_config_info(ext_panel_id panel_id, ext_panel_config *config_info)
|
|
{
|
|
td_s32 ret;
|
|
errno_t err;
|
|
ext_panel_abnormal_config abnormal_config = {0};
|
|
soc_info_func_enter();
|
|
|
|
if (config_info == TD_NULL) {
|
|
soc_log_err("input data is invalid.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
abnormal_config.id = panel_id;
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_CONFIG_INFO, &abnormal_config);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("ext_mpi_panel_get_config_info failed.\n");
|
|
return ret;
|
|
}
|
|
err = memcpy_s(config_info, sizeof(ext_panel_config), &abnormal_config.panel_config,
|
|
sizeof(abnormal_config.panel_config));
|
|
if (err != EOK) {
|
|
soc_log_err("memcpy_s pstStatusInfo failed, err = %d\n", err);
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_connect_status(ext_panel_id panel_id, ext_panel_connect_status *status_info)
|
|
{
|
|
td_s32 ret;
|
|
panel_connect_status connect_status = {0};
|
|
soc_info_func_enter();
|
|
|
|
if (status_info == TD_NULL) {
|
|
soc_log_err("input data is invalid.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
connect_status.id = panel_id;
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_CONNECT_STATUS, &connect_status);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("ext_mpi_panel_get_connect_status failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
*status_info = connect_status.connect_status;
|
|
soc_info_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_enable_3d(const ext_panel_id panel_id, const td_bool enable)
|
|
{
|
|
td_s32 ret;
|
|
ext_panel_3d_type_cfg cfg_3d = {0};
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
cfg_3d.id = panel_id;
|
|
cfg_3d.is_enable = enable;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_3D_TYPE, &cfg_3d);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("ext_mpi_panel_enable_3d failed. 0x%x\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_index(const ext_panel_id panel_id, const td_u32 panel_index)
|
|
{
|
|
td_s32 ret;
|
|
ext_panel_change_param_cfg cfg_new_param = {0};
|
|
soc_info_func_enter();
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
cfg_new_param.id = panel_id;
|
|
cfg_new_param.new_index = panel_index;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_INDEX, &cfg_new_param);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("ext_mpi_panel_enable_3d failed. 0x%x\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
td_s32 ext_mpi_panel_get_index(const ext_panel_id panel_id, td_u32 *panel_index)
|
|
{
|
|
td_s32 ret;
|
|
ext_panel_change_param_cfg cfg_new_param = {0};
|
|
soc_info_func_enter();
|
|
|
|
if (panel_index == TD_NULL) {
|
|
soc_log_err("input data is invalid.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
|
|
cfg_new_param.id = panel_id;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_INDEX, &cfg_new_param);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("ext_mpi_panel_enable_3d failed. 0x%x\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
*panel_index = cfg_new_param.new_index;
|
|
|
|
soc_info_func_exit();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_capability(const ext_panel_id panel_id, ext_drv_panel_capability *panel_cap)
|
|
{
|
|
td_s32 ret;
|
|
ext_panel_capability get_panel_cap = {0};
|
|
|
|
soc_info_func_enter();
|
|
mpi_panel_lock();
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
mpi_panel_unlock();
|
|
get_panel_cap.id = panel_id;
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_CAPABILITY, &get_panel_cap);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("ext_mpi_panel_enable_3d failed. 0x%x\n", ret);
|
|
return ret;
|
|
}
|
|
ret = memcpy_s(panel_cap, sizeof(ext_drv_panel_capability), &get_panel_cap.panel_cap,
|
|
sizeof(get_panel_cap.panel_cap));
|
|
if (ret != EOK) {
|
|
soc_log_err("memcpy_s ext_panel_capability failed, ret = %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
soc_info_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_read_reg(td_u32 addr, td_u32 *data)
|
|
{
|
|
td_s32 ret;
|
|
ext_panel_reg reg = {0};
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
reg.addr = addr;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_REG, ®);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set reg fail!\n");
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
*data = reg.data;
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_write_reg(td_u32 addr, td_u32 data)
|
|
{
|
|
td_s32 ret;
|
|
ext_panel_reg reg = {0};
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
reg.addr = addr;
|
|
reg.data = data;
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_REG, ®);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set reg fail!\n");
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_od_head(ext_drv_panel_od_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_OD_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get od head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_od_head(ext_drv_panel_od_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_OD_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set od head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_od_region(ext_drv_panel_od_data *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_OD_REGION, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get od region fail :%d\n", ret);
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_od_region(ext_drv_panel_od_data *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_OD_REGION, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set od region fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_lineod_head(ext_drv_panel_lineod_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_LINEOD_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get lineod head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_lineod_head(ext_drv_panel_lineod_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_LINEOD_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set lineod head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_ctc_head(ext_drv_panel_ctc_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_CTC_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get ctc head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_ctc_head(ext_drv_panel_ctc_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_CTC_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set ctc head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_vac_head(ext_drv_panel_vac_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_VAC_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get vac head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_vac_head(ext_drv_panel_vac_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_VAC_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set vac head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_gamma_head(ext_drv_panel_gamma_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_GAMMA_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get gamma head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_gamma_head(ext_drv_panel_gamma_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_GAMMA_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set gamma head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_dither_head(ext_drv_panel_dither_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_DITHER_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get dither head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_dither_head(ext_drv_panel_dither_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_DITHER_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set dither head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_mura_head(ext_drv_panel_mura_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_MURA_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get vac head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_mura_head(const ext_drv_panel_mura_head *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_MURA_HEAD, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set mura head fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_lut_info(ext_drv_panel_lut_info *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_LUT_INFO, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get lut fail :%d\n", ret);
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_set_lut_info(ext_drv_panel_lut_info *data)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (data == TD_NULL) {
|
|
soc_log_err("data is null pointer!\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_SET_LUT_INFO, data);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("set lut fail :%d\n", ret);
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return ret;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_custom_param_size(const ext_panel_id panel_id, td_u32 *param_size)
|
|
{
|
|
ext_panel_custom_param_size cst_param_size = {0};
|
|
td_s32 ret;
|
|
|
|
if (param_size == TD_NULL || panel_id >= EXT_PANEL_ID_MAX) {
|
|
soc_log_err("param_size is NULLor panel_id error.\n");
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
cst_param_size.id = panel_id;
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_CUSTM_PARAM_SIZE, &cst_param_size);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get custom param fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
*param_size = cst_param_size.size;
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 ext_mpi_panel_get_custom_param(const ext_panel_id panel_id, td_u8 *param, td_u32 param_size)
|
|
{
|
|
td_s32 ret;
|
|
ext_panel_custom_param cst_param = {0};
|
|
td_u32 cpy_size;
|
|
|
|
mpi_panel_lock();
|
|
|
|
if (g_panel_dev_fd < 0) {
|
|
soc_log_err("PANEL is not init.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
if (param == TD_NULL) {
|
|
soc_log_err("param error.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
cst_param.id = panel_id;
|
|
ret = ioctl(g_panel_dev_fd, PANEL_CMD_GET_CUSTM_PARAM, &cst_param);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("get custom param fail!\n");
|
|
mpi_panel_unlock();
|
|
return ret;
|
|
}
|
|
|
|
cpy_size = (param_size > PANEL_CUSTOM_PARAM_MAX_SIZE) ? PANEL_CUSTOM_PARAM_MAX_SIZE : param_size;
|
|
ret = memcpy_s(param, param_size, cst_param.custom_param, cpy_size);
|
|
if (ret != EOK) {
|
|
soc_log_err("memcpy_s fail.\n");
|
|
mpi_panel_unlock();
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
mpi_panel_unlock();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
#if __cplusplus
|
|
}
|
|
#endif
|
|
#endif /* end of #ifdef __cplusplus */
|
|
|