/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2020-2021. All rights reserved.
 * Description : Frontend mpi interface
 * Author : Hisilicon
 * Create : 2020/09/15
 */

#include "mpi_frontend_ext.h"

#include <sys/ioctl.h>
#include <pthread.h>
#include <fcntl.h>
#include <unistd.h>

#include "soc_log.h"
#include "td_type.h"
#include "soc_errno.h"
#include "iapi_frontend.h"
#include "mpi_frontend.h"

td_s32  g_tuner_fd = 0;

pthread_mutex_t g_tuner_mutex = PTHREAD_MUTEX_INITIALIZER;
#define ext_tuner_lock()        (void)pthread_mutex_lock(&g_tuner_mutex);
#define ext_tuner_unlock()      (void)pthread_mutex_unlock(&g_tuner_mutex);

td_s32 frontend_get_fd(td_void)
{
    return g_tuner_fd;
}

td_s32 ext_mpi_frontend_init(td_void)
{
    td_s32 tuner_fd = 0;

    ext_tuner_lock();
    tuner_fd = open("/dev/soc_frontend", O_RDWR, 0);
    if (tuner_fd < 0) {
        soc_log_err("open %s failed\n", "/dev/soc_frontend");
        ext_tuner_unlock();
        return SOC_ERR_FRONTEND_NOT_OPEN;
    }
    g_tuner_fd = tuner_fd;
    ext_tuner_unlock();

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_deinit(td_void)
{
    ext_tuner_lock();
    close(g_tuner_fd);
    ext_tuner_unlock();

    g_tuner_fd = 0;

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_open(td_u32 port_id)
{
    if (port_id >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(port_id) invalid.\n");
        soc_err_print_u32(port_id);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_close(td_u32 port_id)
{
    td_s32 ret;
    fe_ioctrl_data tuner_data = {0};

    if (port_id >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(port_id) invalid.\n");
        soc_err_print_u32(port_id);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    tuner_data.port = port_id;
    ret = ioctl(frontend_get_fd(), FRONTEND_CLOSE_CMD, &tuner_data);
    if (ret != TD_SUCCESS) {
        soc_log_err("Tuner FRONTEND_CLOSE_CMD error\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_set_attr(fe_ioctrl_attr fe_attr)
{
    td_s32 ret;

    if (fe_attr.port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_attr.port) invalid.\n");
        soc_err_print_u32(fe_attr.port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_SET_ATTR_CMD, &fe_attr);
    if (ret != TD_SUCCESS) {
        soc_log_err("TUNER_SET_ATTR_CMD error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_get_attr(fe_ioctrl_attr *fe_attr)
{
    td_s32 ret;

    if (fe_attr == TD_NULL) {
        soc_log_err("Input parameter(fe_attr) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_attr->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_attr->port)invalid.\n");
        soc_err_print_u32(fe_attr->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_ATTR_CMD, fe_attr);
    if (ret != TD_SUCCESS) {
        soc_log_err("TUNER_GET_ATTR_CMD error.\n");
        return ret;
    }

    return ret;
}

td_s32 ext_mpi_frontend_get_capability(fe_ioctrl_capability *capability)
{
    td_s32 ret;

    if (capability == TD_NULL) {
        soc_log_err("Input parameter(capability) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_CAPABILITY_CMD, capability);
    if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_GET_CAPABILITY_CMD error,ret:%#x.\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_connect(fe_ioctrl_signal *fe_connect_para)
{
    td_s32 ret;

    if (fe_connect_para == TD_NULL) {
        soc_log_err("Input parameter(fe_connect_para) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_connect_para->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_connect_para->port) invalid.\n");
        soc_err_print_u32(fe_connect_para->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(frontend_get_fd(), FRONTEND_CONNECT_CMD, fe_connect_para);
    if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_CONNECT_CMD error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_disconnect(td_u32 port_id)
{
    td_s32 ret;

    if (port_id >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(port_id) invalid.\n");
        soc_err_print_u32(port_id);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(frontend_get_fd(), FRONTEND_DISCONNECT_CMD, &port_id);
    if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_DISCONNECT_CMD error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_get_status(fe_ioctrl_status *fe_status)
{
    td_s32 ret;

    if (fe_status == TD_NULL) {
        soc_log_err("Input parameter(lock_status) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_status->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_status->port) invalid.\n");
        soc_err_print_u32(fe_status->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_STATUS_CMD, fe_status);
    if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_GET_STATUS_CMD error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_get_ber(fe_ioctrl_ber_per *fe_ber)
{
    td_s32 ret;

    if (fe_ber == TD_NULL) {
        soc_log_err("Input parameter(tmp_tuner_ber) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_ber->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(tmp_tuner_ber->port) invalid.\n");
        soc_err_print_u32(fe_ber->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_BER_CMD, fe_ber);
    if (ret == SOC_ERR_FRONTEND_CONNECT_FAIL) {
        soc_log_warn("Signal not connect.\n");
        return SOC_ERR_FRONTEND_CONNECT_FAIL;
    } else if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_GET_BER_CMD error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_get_per(fe_ioctrl_ber_per *fe_per)
{
    td_s32 ret;

    if (fe_per == TD_NULL) {
        soc_log_err("Input parameter(tmp_tuner_per) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_per->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_per->port) invalid.\n");
        soc_err_print_u32(fe_per->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_PER_CMD, fe_per);
    if (ret == SOC_ERR_FRONTEND_CONNECT_FAIL) {
        soc_log_warn("Signal not connect.\n");
        return SOC_ERR_FRONTEND_CONNECT_FAIL;
    } else if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_GET_PER_CMD error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_get_snr(fe_ioctrl_snr *fe_snr)
{
    td_s32 ret;

    if (fe_snr == TD_NULL) {
        soc_log_err("Input parameter(fe_snr) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_snr->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_snr->port) invalid.\n");
        soc_err_print_u32(fe_snr->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_SNR_CMD, fe_snr);
    if (ret == SOC_ERR_FRONTEND_CONNECT_FAIL) {
        soc_log_warn("Signal not connect.\n");
        return SOC_ERR_FRONTEND_CONNECT_FAIL;
    } else if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_GET_SNR_CMD error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_get_signal_strength(fe_ioctrl_data_buf *fe_strength)
{
    td_s32 ret;

    if (fe_strength == TD_NULL) {
        soc_log_err("Input parameter(signal_strength) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_strength->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_strength->port) invalid.\n");
        soc_err_print_u32(fe_strength->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_SIGNALSTRENGTH_CMD, fe_strength);
    if (ret == SOC_ERR_FRONTEND_CONNECT_FAIL) {
        soc_log_warn("Signal not connect.\n");
        return SOC_ERR_FRONTEND_CONNECT_FAIL;
    } else if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_GET_SIGNALSTRENGTH_CMD error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_get_signal_quality(fe_ioctrl_data *fe_quality)
{
    td_s32 ret;

    if (fe_quality == TD_NULL) {
        soc_log_err("Input parameter(fe_quality) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_quality->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_quality->port) invalid.\n");
        soc_err_print_u32(fe_quality->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_SIGANLQUALITY_CMD, fe_quality);
    if (ret == SOC_ERR_FRONTEND_CONNECT_FAIL) {
        soc_log_warn("Signal not connect.\n");
        return SOC_ERR_FRONTEND_CONNECT_FAIL;
    } else if (ret == SOC_ERR_FRONTEND_INVALID_FUNCTION) {
        soc_log_notice("not support.\n");
        return SOC_ERR_FRONTEND_INVALID_FUNCTION;
    } else if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_GET_SIGANLQUALITY_CMD error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_get_real_freq_symb(fe_ioctrl_data_buf *fe_freq_symb)
{
    td_s32 ret;

    if (fe_freq_symb == TD_NULL) {
        soc_log_err("Input parameter(fe_freq_symb) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_freq_symb->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_freq_symb->port) invalid.\n");
        soc_err_print_u32(fe_freq_symb->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_FREQ_SYMB_OFFSET, fe_freq_symb);
    if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_GET_FREQ_SYMB_OFFSET error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

/* Obtains current signal information of the TUNER, used in satellite and terrestrial, not necessary for cable */
td_s32 ext_mpi_frontend_get_signal_info(fe_ioctrl_signal_info *fe_signal_info)
{
    td_s32 ret;

    if (fe_signal_info == TD_NULL) {
        soc_log_err("Input parameter(fe_signal_info) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_signal_info->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_signal_info->port) invalid.\n");
        soc_err_print_u32(fe_signal_info->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_SIGANLINFO_CMD, fe_signal_info);
    if (ret != TD_SUCCESS) {
        soc_log_err("FRONTEND_GET_SIGANLINFO_CMD error.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_standby(td_u32 port_id)
{
    td_s32 ret;
    fe_ioctrl_standby fe_standby = {0};

    if (port_id >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(port_id) invalid.\n");
        soc_err_print_u32(port_id);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    fe_standby.port = port_id;
    fe_standby.standby = 1;
    ret = ioctl(g_tuner_fd, FRONTEND_STANDBY_CMD, &fe_standby);
    if (ret != TD_SUCCESS) {
        soc_log_err("Tuner standby fail.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_frontend_wake_up(td_u32 port_id)
{
    td_s32 ret;
    fe_ioctrl_standby fe_standby = {0};

    if (port_id >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(port_id) invalid.\n");
        soc_err_print_u32(port_id);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    fe_standby.port = port_id;
    fe_standby.standby = 0;
    ret = ioctl(g_tuner_fd, FRONTEND_STANDBY_CMD, &fe_standby);
    if (ret != TD_SUCCESS) {
        soc_log_err("Tuner wake up fail.\n");
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 mpi_frontend_get_cfg(fe_ioctrl_config *fe_cfg)
{
    td_s32 ret;

    if (fe_cfg == TD_NULL) {
        soc_log_err("Input parameter(fe_cfg) is TD_NULL.\n");
        return SOC_ERR_FRONTEND_INVALID_POINT;
    }

    if (fe_cfg->port >= MPI_FRONTEND_NUM) {
        soc_log_err("Input parameter(fe_cfg->port) invalid.\n");
        soc_err_print_u32(fe_cfg->port);
        return SOC_ERR_FRONTEND_INVALID_PARA;
    }

    ret = ioctl(g_tuner_fd, FRONTEND_GET_CONFIG_CMD, &fe_cfg);
    if (ret != TD_SUCCESS) {
        soc_log_err("frontend get config fail.\n");
        return ret;
    }

    return TD_SUCCESS;
}