/******************************************************************************
* 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, &current_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, &current_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, &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, &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 */