/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2020-2020. All rights reserved.
 * Description: sif drv
 * Author: Audio
 * Create: 2020-04-16
 */

#include "drv_sif.h"
#include "soc_log.h"
#include "osal_ext.h"
#include "soc_errno.h"
#include "soc_module.h"
#include "drv_sys_ext.h"
#include "linux/huanglong/securec.h"
#include "drv_sif_hal.h"
#include "drv_ioctl_sif.h"
#include "drv_sif_private.h"
#include "drv_sif_hal_v4_0.h"

#define SIGN_BIT        0x8000
#define REG_MAX_16BITS  0xffff
#define SIF_SAMPLE_FREQ 18432  /* 18.432M */

sif_drv_ctx g_sif_drv_dev = {0};

static td_s32 g_sif_suspend_flag = 0;
static td_s32 g_sif_resume_flag = 0;

static osal_atomic g_sif_open_cnt = {TD_NULL};
static osal_semaphore g_sif_mutex = {TD_NULL};

/**************************************************************************
addr value
0x02 0x00    set sample rate
0x09 0x05    set AAOS control and AAOS mode
0x80 0x08    set demulator mode:4.5_m_hz or 6.5_m_hz
0x00 0x00    set attributes relate to ASD:ASD atuo or system select
0x41 0x04    set mute ctl:mute override,left muted or right muted setting
***************************************************************************/
static td_s32 sif_get_carri_shift_value(td_u32 *shift_value);
static td_u32 sif_get_quality1(td_void);
static td_u32 sif_get_quality2(td_void);
static td_s32 sif_get_out_mode(ext_sif_aaos_mode *paaos_mode);
static td_s32 sif_set_over_mode(ext_sif_over_deviation over_mode);
static td_s32 sif_get_over_mode(ext_sif_over_deviation *over_mode);
static td_void sif_get_btsc_support(td_bool *support);
static td_s32 sif_suspend(td_void);
static td_s32 sif_resume(td_void);

td_void sif_proc_show_help(td_void)
{
    osal_proc_echo("=============================================sif"
        "================================================\n");
    osal_proc_echo("echo    command   para    path              "
        "explanation\n");
    osal_proc_echo("echo    syssel    DK      > /proc/msp/sif   "
        "set system select    para(DK/BG/I/KOREA/BTSC/EIAJ)\n");
    osal_proc_echo("echo    overmode  50      > /proc/msp/sif   "
        "set over modulation  para(50k/100k/200k/384k/540k)\n");
    osal_proc_echo("echo    ascs      1       > /proc/msp/sif   "
        "ascs on\n");
    osal_proc_echo("echo    ascs      0       > /proc/msp/sif   "
        "ascs off\n");
    osal_proc_echo("==============================================="
        "=================================================\n");
}

static td_u8 *sys_sel_to_str(td_void)
{
    sif_sys_sel sys_sel = sif_hal_get_det_standard();

    switch (sys_sel) {
        case SIF_SYS_SEL_BG_FM:
            return "BG_FM";
        case SIF_SYS_SEL_BG_NICAM:
            return "bg_nicam";
        case SIF_SYS_SEL_L:
            return "secam_l";
        case SIF_SYS_SEL_I:
            return "sys_i";
        case SIF_SYS_SEL_DK1:
            return "dk1";
        case SIF_SYS_SEL_DK2:
            return "dk2";
        case SIF_SYS_SEL_DK3:
            return "dk3";
        case SIF_SYS_SEL_DK_NICAM:
            return "nicam_dk";
        case SIF_SYS_SEL_KOREA:
            return "korea";
        case SIF_SYS_SEL_EIAJ:
            return "eiaj";
        case SIF_SYS_SEL_BTSC:
            return "btsc";
        default:
            return "sys_sel_no";
    }
}

static td_u8 *en_asdctl45_to_str(const sif_hal_attr *pdev_attr)
{
    switch (pdev_attr->asd45_ctl) {
        case SIF_ASDCTL_45M_BTSC:
            return "btsc";
        case SIF_ASDCTL_45M_EIAJ:
            return "eiaj";
        case SIF_ASDCTL_45M_M_KOREA:
            return "korea";
        case SIF_ASDCTL_45M_PAL_SUM:
            return "pal_sum";
        default:
            return "radio";
    }
}

static td_u8 *en_asdctl65_to_str(const sif_hal_attr *pdev_attr)
{
    switch (pdev_attr->asd65_ctl) {
        case SIF_ASDCTL_65M_SECAM_L:
            return "secam_l";
        case SIF_ASDCTL_65M_DK:
            return "DK";
        default:
            return "NONE";
    }
}

static td_u8 *en_filter1_to_str(const sif_hal_attr *pdev_attr)
{
    switch (pdev_attr->flt1) {
        case SIF_DEMOD1_FILTER_50K:
            return "50K";
        case SIF_DEMOD1_FILTER_100K:
            return "100K";
        case SIF_DEMOD1_FILTER_384K:
            return "384K";
        case SIF_DEMOD1_FILTER_540K:
            return "540K";
        case SIF_DEMOD1_FILTER_200K:
            return "200K";
        case SIF_DEMOD1_FILTER_BUTT:
        default:
            return "";
    }
}

static td_u8 *en_carri_status1_to_str(ext_sif_aaos_mode aaos_mode)
{
    switch (aaos_mode) {
        case EXT_SIF_AAOS_MODE_MONO:
            return "mono";
        case EXT_SIF_AAOS_MODE_STEREO:
            return "stereo";
        case EXT_SIF_AAOS_MODE_DUAL:
            return "dual";
        case EXT_SIF_AAOS_MODE_MONO_SAP:
            return "mono_sap";
        case EXT_SIF_AAOS_MODE_STEREO_SAP:
            return "stereo_sap";
        case EXT_SIF_AAOS_MODE_NICAM_MONO:
            return "nicam_mono";
        case EXT_SIF_AAOS_MODE_NICAM_STEREO:
            return "nicam_stereo";
        case EXT_SIF_AAOS_MODE_NICAM_DUAL:
            return "nicam_dual";
        case EXT_SIF_AAOS_MODE_NICAM_FM_MOMO:
            return "nicam_fm_mono";
        case EXT_SIF_AAOS_MODE_MAX:
        default:
            return "";
    }
}

static td_u8 *deviation1_to_str(const sif_hal_attr *pdev_attr)
{
    switch (pdev_attr->deviation1) {
        case SIF_DEVIATION_50K:
            return "50K";
        case SIF_DEVIATION_100K:
            return "100K";
        case SIF_DEVIATION_384K:
            return "384K";
        case SIF_DEVIATION_540K:
            return "540K";
        case SIF_DEVIATION_200K:
            return "200K";
        case SIF_DEVIATION_BUTT:
        default:
            return "";
    }
}

static td_u8 *en_dem_mode_to_str(sif_hal_attr *pdev_attr)
{
    sif_hal_get_demulator_mode(&pdev_attr->demula_mode);
    switch (pdev_attr->demula_mode) {
        case SIF_DEMOD1_MODE_FM:
            return "fm";
        case SIF_DEMOD1_MODE_AM:
            return "am";
        case SIF_DEMOD1_MODE_BUTT:
        default:
            return "";
    }
}

static td_u8 *en_out_to_str(sif_aaos_outmode output)
{
    switch (output) {
        case SIF_AAOS_OUTMODE_MONO:
            return "mono";
        case SIF_AAOS_OUTMODE_L_OR_R:
            return "LR";
        case SIF_AAOS_OUTMODE_A:
            return "A";
        case SIF_AAOS_OUTMODE_B:
            return "B";
        case SIF_AAOS_OUTMODE_BUTT:
        default:
            return "";
    }
}

static td_u8 *en_ascs_mode_to_str(const sif_hal_attr *pdev_attr)
{
    switch (pdev_attr->ascs_chg_mode) {
        case SIF_ASCS_CHGMODE_NOT_AUTO:
            return "no_auto";
        case SIF_ASCS_CHGMODE_AFTER_RST:
            return "aft_rst";
        case SIF_ASCS_CHGMODE_AUTO:
            return "auto";
        case SIF_ASCS_CHGMODE_AUTO1:
            return "auto1";
        case SIF_ASCS_CHGMODE_BUTT:
        default:
            return "";
    }
}

static td_u8 *en_ascs_ctl_to_str(const sif_hal_attr *pdev_attr)
{
    switch (pdev_attr->ascs_ctl) {
        case SIF_ASCS_MODE_DISABLE:
            return "disable";
        case SIF_ASCS_MODE_ONETIME:
            return "one_time";
        case SIF_ASCS_MODE_ALWAYS:
            return "always";
        case SIF_ASCS_MODE_ALWAYS1:
            return "always1";
        case SIF_ASCS_MODE_BUTT:
        default:
            return "";
    }
}

static td_u8 *en_carri1_to_str(sif_hal_attr *pdev_attr)
{
    td_u32 carri_freq = sif_hal_get_carri1_freq();

    switch (carri_freq) {
        case SIF_DEMOD1_45M_18432M:
            return "4.5M";
        case SIF_DEMOD1_55M_18432M:
            return "5.5M";
        case SIF_DEMOD1_60M_18432M:
            return "6.0M";
        case SIF_DEMOD1_65M_18432M:
            return "6.5M";
        default:
            return "no_freq";
    }
}

static td_u8 *en_carri2_to_str(sif_hal_attr *pdev_attr)
{
    td_u32 carri_freq = sif_hal_get_carri12_freq();

    switch (carri_freq) {
        case SIF_DEMOD2_4_724212M_18432M:
            return "4.724M";
        case SIF_DEMOD2_57421875M_18432M:
            return "5.742M";
        case SIF_DEMOD2_585M_18432M:
            return "5.85M";
        case SIF_DEMOD2_62578125M_18432M:
            return "6.26M";
        case SIF_DEMOD2_6552M_18432M:
            return "6.55M";
        case SIF_DEMOD2_6741875M_18432M:
            return "6.74M";
        default:
            return "no_freq";
    }
}

static const td_char *en_quality_to_str(td_u32 quality)
{
    td_u32 i;
    const struct {
        td_u32 down_quality;
        td_u32 up_quality;
        const td_char *str;
    } quality_str[] = {
        { 0, 0x0001, "<-36dB" },
        { 0x0001, 0x0004, "-36~-24dB" },
        { 0x0004, 0x0010, "-24~-12dB" },
        { 0x0010, 0x0040, "-12~0dB" },
        { 0x0040, 0x0100, "0~12dB" },
        { 0x0100, 0x0400, "12~24dB" },
        { 0x0400, 0x1000, "24~36dB" },
        { 0x1000, 0x4000, "36~48dB" },
        { 0x4000, 0xFFFF, "48~60dB" },
    };

    for (i = 0; i < (sizeof(quality_str) / sizeof(quality_str[0])); i++) {
        if ((quality >= quality_str[i].down_quality) && (quality < quality_str[i].up_quality)) {
            return quality_str[i].str;
        }
    }

    return ">60dB";
}

#define SIF_PROC_TITLE_LINE_LENGTH 72
static td_void sif_repeat_char_print(td_void *s, const td_char *t, td_u32 len)
{
    td_u32 i;
    for (i = 0; i < len; i++) {
        if (s != TD_NULL) {
            osal_seq_printf(s, "%s", t);
        } else {
            osal_proc_echo("%s", t);
        }
    }
}

static td_void sif_proc_title_print(td_void *s, const td_char *str, td_u32 len)
{
    td_u32 len1;
    td_u32 len2;

    len1 = (len - strlen(str)) / 2; /* 2: div 2 */
    len2 = len - len1 - strlen(str);
    sif_repeat_char_print(s, "-", len1);
    osal_seq_printf(s, "%s", str);
    sif_repeat_char_print(s, "-", len2);
    osal_seq_printf(s, "\n");
}

static td_void sif_proc_tail_print(td_void *s, td_u32 len)
{
    sif_repeat_char_print(s, "=", len);
    osal_seq_printf(s, "\n");
}

static td_void sif_proc_show_base(td_void *s, sif_hal_attr *pdev_attr)
{
    td_s32 ret;
    ext_sif_aaos_mode aaos_mode = EXT_SIF_AAOS_MODE_MONO;

    ret = sif_get_out_mode(&aaos_mode);
    if (ret != TD_SUCCESS) {
        soc_log_err("get_out_mode is failed!\n");
        return;
    }

    osal_seq_printf(s, "[sif]%s\n", VERSION_STRING);
    sif_proc_title_print(s, "sif", SIF_PROC_TITLE_LINE_LENGTH);
    osal_seq_printf(s, "%-14s:%-56s|\n", "carrier", en_carri_status1_to_str(aaos_mode));

    sif_proc_title_print(s, "deviation", SIF_PROC_TITLE_LINE_LENGTH);
    osal_seq_printf(s, "%-14s:%-8s|", "filter1", en_filter1_to_str(pdev_attr));
    osal_seq_printf(s, "%-14s:%-8s|", "deviation", deviation1_to_str(pdev_attr));
    osal_seq_printf(s, "%-14s:%-8s|\n", "fm_mode", en_dem_mode_to_str(pdev_attr));

    sif_proc_title_print(s, "system", SIF_PROC_TITLE_LINE_LENGTH);
    osal_seq_printf(s, "%-14s:%-8s|", "sys_sel", sys_sel_to_str());
    osal_seq_printf(s, "%-14s:%-8s|", "asd_ctl45", en_asdctl45_to_str(pdev_attr));
    osal_seq_printf(s, "%-14s:%-8s|\n", "asd_ctl65", en_asdctl65_to_str(pdev_attr));

    sif_proc_title_print(s, "aaos", SIF_PROC_TITLE_LINE_LENGTH);
    osal_seq_printf(s, "%-14s:%-8d|", "aaos_en", pdev_attr->aaos_en);
    osal_seq_printf(s, "%-14s:%-8s|", "l_out", en_out_to_str(pdev_attr->l_output));
    osal_seq_printf(s, "%-14s:%-8s|\n", "r_out", en_out_to_str(pdev_attr->r_output));

    sif_proc_title_print(s, "ascs", SIF_PROC_TITLE_LINE_LENGTH);
    osal_seq_printf(s, "%-14s:%-8s|", "ascs_mode", en_ascs_mode_to_str(pdev_attr));
    osal_seq_printf(s, "%-14s:%-8s|", "ascs_ctl", en_ascs_ctl_to_str(pdev_attr));
    osal_seq_printf(s, "%24s\n", "|");

    sif_proc_title_print(s, "mutectl", SIF_PROC_TITLE_LINE_LENGTH);
    osal_seq_printf(s, "%-14s:%-8d|", "mute_en", pdev_attr->mute_en);
    osal_seq_printf(s, "%-14s:%-8d|", "mute_l", pdev_attr->mute_l);
    osal_seq_printf(s, "%-14s:%-8d|\n", "mute_r", pdev_attr->mute_r);

    sif_proc_title_print(s, "carrier", SIF_PROC_TITLE_LINE_LENGTH);
    osal_seq_printf(s, "%-14s:%-8s|", "carrier1", en_carri1_to_str(pdev_attr));
    osal_seq_printf(s, "%-14s:%-8s|", "carrier2", en_carri2_to_str(pdev_attr));
    osal_seq_printf(s, "%24s\n", "|");
}

static td_void sif_proc_show(td_void *s)
{
    td_s32 ret;
    sif_hal_attr *pdev_attr = TD_NULL;
    td_u32 shfit_value = 0;
    td_u32 deviation;
    td_u32 negative = TD_FALSE;
    td_bool btsc_support = TD_FALSE;

    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        sif_proc_title_print(s, "sif", SIF_PROC_TITLE_LINE_LENGTH);
        sif_proc_tail_print(s, SIF_PROC_TITLE_LINE_LENGTH);
        return;
    }

    pdev_attr = &g_sif_drv_dev.dev_attr;
    sif_proc_show_base(s, pdev_attr);

    /* quality */
    ret = sif_get_carri_shift_value(&shfit_value);
    if (ret != TD_SUCCESS) {
        soc_log_err("get_carri_shift_value is failed!\n");
    }

    deviation = sif_hal_get_phase_value();

    if ((shfit_value) & SIGN_BIT) {
        negative = TD_TRUE;
        shfit_value = REG_MAX_16BITS - shfit_value;
    }

    shfit_value = shfit_value * SIF_SAMPLE_FREQ / (1 << 20);  /* (shfit * fs) / 2^20 */
    deviation = deviation * SIF_SAMPLE_FREQ / (1 << 20);    /* (phase * FS) / 2^20 */

    sif_proc_title_print(s, "nonstandard", SIF_PROC_TITLE_LINE_LENGTH);
    osal_seq_printf(s, "%-14s:%c%-7d|", "shift1_khz", (negative == TD_TRUE) ? '-' : '+', shfit_value);
    osal_seq_printf(s, "%-14s:%-8d|", "deviation_khz", deviation);
    osal_seq_printf(s, "%24s\n", "|");

    sif_proc_title_print(s, "quality", SIF_PROC_TITLE_LINE_LENGTH);
    osal_seq_printf(s, "%-14s:%-8s|", "qual1", en_quality_to_str(sif_get_quality1()));
    osal_seq_printf(s, "%-14s:%-8s|", "qual2", en_quality_to_str(sif_get_quality2()));
    osal_seq_printf(s, "%-14s:0x%-6x|\n", "qual_comp1", ((sif_get_quality1()) & (REG_MAX_16BITS)) >> 3); /* /2^3 */
    osal_seq_printf(s, "%-14s:0x%-6x|", "qual_comp2", ((sif_get_quality2()) & (REG_MAX_16BITS)) >> 3); /* /2^3 */
    osal_seq_printf(s, "%24s%24s\n", "|", "|");

    sif_get_btsc_support(&btsc_support);
    sif_proc_title_print(s, "otp", SIF_PROC_TITLE_LINE_LENGTH);
    osal_seq_printf(s, "%-14s:%-56s|\n", "btsc", (btsc_support == TD_TRUE) ? "support" : "unsupport");

    sif_proc_tail_print(s, SIF_PROC_TITLE_LINE_LENGTH);
    osal_proc_echo("\n");
}

td_s32 sif_drv_read_proc(td_void *s, td_void *data)
{
    td_s32 ret;
    ret = osal_sem_down_interruptible(&g_sif_mutex);
    if (ret != TD_SUCCESS) {
        soc_log_err("lock g_sif_mutex failed\n");
        return ret;
    }

    if (s == TD_NULL) {
        soc_log_err("s is null\n");
        osal_sem_up(&g_sif_mutex);
        return SOC_ERR_SIF_NULL_PTR;
    }
    sif_proc_show(s);
    osal_sem_up(&g_sif_mutex);
    return TD_SUCCESS;
}

td_s32 drv_sif_proc_cmd_syssel(unsigned int argc, char (*argv)[PROC_CMD_SINGEL_LENGTH_MAX], td_void *private)
{
    td_s32 ret;
    ext_sif_standard_type sys_sel = EXT_SIF_STANDARD_DK;

    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_notice("current state is not open, can not set syssel!\n");
        return TD_SUCCESS;
    }

    if (argc != 2) { /* 2 is argc num. */
        soc_log_err("the number of param should be 2.\n");
        return TD_FAILURE;
    }

    if (argv == TD_NULL) {
        return TD_FAILURE;
    }

    if (!strncmp(argv[1], "DK", 2)) { /* 2 is number of characters to compare */
        sys_sel = EXT_SIF_STANDARD_DK;
    } else if (!strncmp(argv[1], "BG", 2)) { /* 2 is number of characters to compare */
        sys_sel = EXT_SIF_STANDARD_BG;
    } else if (!strncmp(argv[1], "I", 1)) {
        sys_sel = EXT_SIF_STANDARD_I;
    } else if (!strncmp(argv[1], "L", 1)) {
        sys_sel = EXT_SIF_STANDARD_L;
    } else if (!strncmp(argv[1], "KOREA", 5)) { /* 5 is number of characters to compare */
        sys_sel = EXT_SIF_STANDARD_M_A2;
    } else if (!strncmp(argv[1], "BTSC", 4)) { /* 4 is number of characters to compare */
        sys_sel = EXT_SIF_STANDARD_M_BTSC;
    } else if (!strncmp(argv[1], "EIAJ", 4)) { /* 4 is number of characters to compare */
        sys_sel = EXT_SIF_STANDARD_M_EIA_J;
    } else {
        soc_log_err("the SIF sys_sel is not valid, can not set sys_sel!\n");
        return TD_FAILURE;
    }

    ret = dspreg_sif_set_sys_sel(sys_sel);
    if (ret != TD_SUCCESS) {
        soc_log_err("set syssel failure!\n");
        soc_err_print_err_code(ret);
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 drv_sif_proc_cmd_overmode(unsigned int argc, char (*argv)[PROC_CMD_SINGEL_LENGTH_MAX], td_void *private)
{
    td_s32 ret;
    ext_sif_over_deviation over_mode = EXT_SIF_OVER_DEVIATION_50K;

    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_notice("current state is not open, can not set overmode!\n");
        return TD_SUCCESS;
    }

    if (argc != 2) { /* 2 is argc num. */
        soc_log_err("the number of param should be 2.\n");
        return TD_FAILURE;
    }

    if (argv == TD_NULL) {
        return TD_FAILURE;
    }

    if (strstr(argv[1], "50k")) {
        over_mode = EXT_SIF_OVER_DEVIATION_50K;
    } else if (strstr(argv[1], "100k")) {
        over_mode = EXT_SIF_OVER_DEVIATION_100K;
    } else if (strstr(argv[1], "200k")) {
        over_mode = EXT_SIF_OVER_DEVIATION_200K;
    } else if (strstr(argv[1], "384k")) {
        over_mode = EXT_SIF_OVER_DEVIATION_384K;
    } else if (strstr(argv[1], "540k")) {
        over_mode = EXT_SIF_OVER_DEVIATION_540K;
    } else {
        soc_log_err("the SIF over_mode is not valid, can not set over_mode!\n");
        return TD_FAILURE;
    }

    ret = sif_set_over_mode(over_mode);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(sif_set_over_mode, ret);
        return ret;
    }

    return TD_SUCCESS;
}

td_s32 drv_sif_proc_cmd_ascs(unsigned int argc, char (*argv)[PROC_CMD_SINGEL_LENGTH_MAX], td_void *private)
{
    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_notice("current state is not open, can not set ascs!\n");
        return TD_SUCCESS;
    }
    if (argc != 2) { /* 2 is argc num. */
        soc_log_err("the number of param should be 2.\n");
        return TD_FAILURE;
    }

    if (argv == TD_NULL) {
        return TD_FAILURE;
    }

    if (strstr(argv[1], "1")) {
        g_sif_drv_dev.dev_attr.ascs_chg_mode = SIF_ASCS_CHGMODE_AUTO;
        g_sif_drv_dev.dev_attr.ascs_ctl = SIF_ASCS_MODE_ALWAYS;
        sif_hal_set_ascs_chg_mod(g_sif_drv_dev.dev_attr.ascs_chg_mode);
        sif_hal_set_ascs_en(g_sif_drv_dev.dev_attr.ascs_ctl);
    } else if (strstr(argv[1], "0")) {
        g_sif_drv_dev.dev_attr.ascs_chg_mode = SIF_ASCS_CHGMODE_NOT_AUTO;
        g_sif_drv_dev.dev_attr.ascs_ctl = SIF_ASCS_MODE_DISABLE;
        sif_hal_set_ascs_chg_mod(g_sif_drv_dev.dev_attr.ascs_chg_mode);
        sif_hal_set_ascs_en(g_sif_drv_dev.dev_attr.ascs_ctl);
    } else {
        soc_log_err("switch ascs param is valid, can not switch ascs on|off!\n");
        return TD_FAILURE;
    }

    return TD_SUCCESS;
}

int drv_sif_proc_cmd_save_help(unsigned int argc, char (*argv)[PROC_CMD_SINGEL_LENGTH_MAX], td_void *private)
{
    sif_proc_show_help();
    return TD_SUCCESS;
}

static struct {
    ext_chip_name_id chip_name_id;
    ext_chip_revision chip_revision;
} g_sif_chip_info = {
    .chip_name_id = 0,
    .chip_revision = CHIP_REVISION_MAX,
};

static const sif_chip_compatible g_sif_chip_compatible[] = {
    {CHIP_NAME_RESERVED5},
    {CHIP_NAME_RESERVED2},
    {CHIP_NAME_RESERVED17},
    {CHIP_NAME_RESERVED19},
    {CHIP_NAME_HI3751V811},
};

td_bool sif_check_reserved5_reserved17_compatible(td_void)
{
    td_u32 i;

    for (i = 0; i < (sizeof(g_sif_chip_compatible) / sizeof(g_sif_chip_compatible[0])); i++) {
        if (g_sif_chip_compatible[i].chip_name_id == g_sif_chip_info.chip_name_id) {
            return TD_TRUE;
        }
    }

    return TD_FALSE;
}

td_bool sif_check_reserved9_compatible(td_void)
{
#if defined(CONFIG_SOCT_TEE_SUPPORT)
    if (((g_sif_chip_info.chip_name_id == CHIP_NAME_RESERVED9) ||
        (g_sif_chip_info.chip_name_id == CHIP_NAME_RESERVED8)) &&
        ((g_sif_chip_info.chip_revision == CHIP_REVISION_B) ||
        (g_sif_chip_info.chip_revision == CHIP_REVISION_C))) {
        return TD_TRUE;
    }
#endif
    return TD_FALSE;
}

static td_s32 sif_open_dev(td_void)
{
    td_s32 ret;
    ext_drv_sys_get_chip_name_id(&g_sif_chip_info.chip_name_id);
    ext_drv_sys_get_chip_revision(&g_sif_chip_info.chip_revision);
    if ((sif_check_reserved5_reserved17_compatible() == TD_FALSE) &&
        (sif_check_reserved9_compatible() == TD_FALSE)) {
        soc_log_err("not support sif!\n");
        return SOC_ERR_SIF_NOTSUPPORT;
    }

    ret = sif_hal_init();
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(sif_hal_init, ret);
        return ret;
    }

    ret = dspreg_sif_init();
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(dspreg_sif_init, ret);
        sif_hal_deinit();
        return ret;
    }

    return ret;
}

static td_s32 sif_close_dev(td_void)
{
    dspreg_sif_deinit();

    sif_hal_deinit();

    return TD_SUCCESS;
}

td_void sif_osal_init(td_void)
{
    td_s32 ret;

    ret = osal_sem_init(&g_sif_mutex, 1);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(osal_sem_init, ret);
    }

    osal_atomic_init(&g_sif_open_cnt);
}

td_void sif_osal_deinit(td_void)
{
    osal_atomic_destroy(&g_sif_open_cnt);

    osal_sem_destroy(&g_sif_mutex);
}

td_s32 sif_drv_open(td_void *private_data)
{
    td_s32 ret;

    ret = osal_sem_down_interruptible(&g_sif_mutex);
    if (ret != TD_SUCCESS) {
        soc_log_err("lock g_sif_mutex failed\n");
        return ret;
    }

    memset_s(&g_sif_drv_dev, sizeof(sif_drv_ctx), 0, sizeof(sif_drv_ctx));

    if (osal_atomic_inc_return(&g_sif_open_cnt) == 1) {
        if (sif_open_dev() != TD_SUCCESS) {
            soc_log_fatal("sif_open_dev err!\n");
            osal_atomic_dec(&g_sif_open_cnt);
            osal_sem_up(&g_sif_mutex);
            return SOC_ERR_SIF_DEV_OPENED;
        }

        soc_sif_asd_init(&g_sif_drv_dev.asd_drvier);
        g_sif_drv_dev.asd_drvier.asd_thread =
            osal_kthread_create(asd_thread_work, &g_sif_drv_dev.asd_drvier, "asd_thread", 0);
        if (g_sif_drv_dev.asd_drvier.asd_thread == TD_NULL) {
            soc_log_err("creat asd_thread_work failed\n");
            osal_sem_up(&g_sif_mutex);
            return SOC_ERR_SIF_NULL_PTR;
        }

        if (sif_check_reserved9_compatible() == TD_TRUE) {
            if (sif_work_init() != TD_SUCCESS) {
                soc_log_err("call sif_work_init failed!\n");
                osal_sem_up(&g_sif_mutex);
                return SOC_ERR_SIF_INVALID_PARA;
            }
        }
    }

    g_sif_drv_dev.dev_open = TD_FALSE;

    osal_sem_up(&g_sif_mutex);
    return TD_SUCCESS;
}

td_s32 sif_drv_close(td_void *private_data)
{
    td_s32 ret;

    ret = osal_sem_down_interruptible(&g_sif_mutex);
    if (ret != TD_SUCCESS) {
        soc_log_err("lock g_sif_mutex failed\n");
        return ret;
    }

    if ((osal_atomic_read(&g_sif_open_cnt) != 0) && osal_atomic_dec_and_test(&g_sif_open_cnt)) {
        if (sif_check_reserved9_compatible() == TD_TRUE) {
            sif_work_deinit();
        }
        if (sif_close_dev() != TD_SUCCESS) {
            soc_log_fatal("sif_close_dev err!\n");
            osal_sem_up(&g_sif_mutex);
            return SOC_ERR_SIF_DEV_CLOSED;
        }
        osal_kthread_destroy(g_sif_drv_dev.asd_drvier.asd_thread, 1);
    }

    g_sif_drv_dev.dev_open = TD_FALSE;
    osal_sem_up(&g_sif_mutex);

    return TD_SUCCESS;
}

static td_s32 sif_drv_suspend(td_void *private_data)
{
    td_s32 ret;

    ret = osal_sem_down_interruptible(&g_sif_mutex);
    if (ret != TD_SUCCESS) {
        soc_log_err("lock g_sif_mutex failed\n");
        return ret;
    }

    if (osal_atomic_read(&g_sif_open_cnt) != 0) {
        ret = sif_suspend();
        if (ret != TD_SUCCESS) {
            soc_log_fatal("SIF suspend fail\n");
            osal_sem_up(&g_sif_mutex);
            return SOC_ERR_SIF_DEVICE_BUSY;
        }
    }

    osal_sem_up(&g_sif_mutex);

    return TD_SUCCESS;
}

td_s32 sif_pm_suspend(td_void *private_data)
{
    td_s32 ret;

    ret = sif_drv_suspend(private_data);
    if (ret == TD_SUCCESS) {
        soc_print("SIF suspend OK\n");
    }

    return ret;
}

td_s32 sif_pm_lowpower_enter(td_void *private_data)
{
    td_s32 ret;

    ret = sif_drv_suspend(private_data);
    if (ret == TD_SUCCESS) {
        soc_print("SIF lowpower enter OK\n");
    }

    return ret;
}

static td_s32 sif_drv_resume(td_void *private_data)
{
    td_s32 ret;

    ret = osal_sem_down_interruptible(&g_sif_mutex);
    if (ret != TD_SUCCESS) {
        soc_log_err("lock g_sif_mutex failed\n");
        return ret;
    }

    if (osal_atomic_read(&g_sif_open_cnt) != 0) {
        ret = sif_resume();
        if (ret != TD_SUCCESS) {
            soc_log_fatal("SIF resume fail\n");
            osal_sem_up(&g_sif_mutex);
            return SOC_ERR_SIF_DEVICE_BUSY;
        }
    }

    osal_sem_up(&g_sif_mutex);

    return TD_SUCCESS;
}

td_s32 sif_pm_resume(td_void *private_data)
{
    td_s32 ret;
    ret = sif_drv_resume(private_data);
    if (ret == TD_SUCCESS) {
        soc_print("SIF resume OK\n");
    }

    return ret;
}

td_s32 sif_pm_lowpower_exit(td_void *private_data)
{
    td_s32 ret;
    ret = sif_drv_resume(private_data);
    if (ret == TD_SUCCESS) {
        soc_print("SIF lowpower exit OK\n");
    }

    return ret;
}

static td_s32 sif_check_dev_status(td_void)
{
    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_err("current state is not open, can not get syssel!\n");
        return SOC_ERR_SIF_NOT_OPEN;
    }

    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_START) {
        soc_log_err("current state is not start, can not get syssel!\n");
        return SOC_ERR_SIF_NOT_START;
    }

    return TD_SUCCESS;
}

static td_void sif_get_sys_sel_val(sif_sys_sel sys_sel, ext_sif_standard_type *psys_sel)
{
    switch (sys_sel) {
        case SIF_SYS_SEL_BG_FM:
            *psys_sel = EXT_SIF_STANDARD_BG_A2;
            break;
        case SIF_SYS_SEL_BG_NICAM:
            *psys_sel = EXT_SIF_STANDARD_BG_NICAM;
            break;
        case SIF_SYS_SEL_I:
            *psys_sel = EXT_SIF_STANDARD_I;
            break;
        case SIF_SYS_SEL_DK1:
            *psys_sel = EXT_SIF_STANDARD_DK1_A2;
            break;
        case SIF_SYS_SEL_DK2:
            *psys_sel = EXT_SIF_STANDARD_DK2_A2;
            break;
        case SIF_SYS_SEL_DK3:
            *psys_sel = EXT_SIF_STANDARD_DK3_A2;
            break;
        case SIF_SYS_SEL_DK_NICAM:
            *psys_sel = EXT_SIF_STANDARD_DK_NICAM;
            break;
        case SIF_SYS_SEL_L:
            *psys_sel = EXT_SIF_STANDARD_L;
            break;
        case SIF_SYS_SEL_BTSC:
            *psys_sel = EXT_SIF_STANDARD_M_BTSC;
            break;
        case SIF_SYS_SEL_KOREA:
            *psys_sel = EXT_SIF_STANDARD_M_A2;
            break;
        case SIF_SYS_SEL_EIAJ:
            *psys_sel = EXT_SIF_STANDARD_M_EIA_J;
            break;
        case SIF_SYS_SEL_FM_RADIO_EUROPE:
        case SIF_SYS_SEL_FM_RADIO_US:
        case SIF_SYS_SEL_FM_RADIO_EUROPE1:
        case SIF_SYS_SEL_FM_RADIO_EUROPE2:
            *psys_sel = EXT_SIF_STANDARD_NOTSTANDARD;
            break;
        case SIF_SYS_SEL_FM_RADIO_EUROPE3:
            *psys_sel = EXT_SIF_STANDARD_UNKNOW; /* try to decode nostandard signal */
            break;
        default:
            *psys_sel = EXT_SIF_STANDARD_UNKNOW;
            break;
    }
}

static td_void sif_get_need_ascs_detect_status(td_bool *need_ascs_detect)
{
    if ((g_sif_drv_dev.dev_attr.sys_sel >= SIF_SYS_SEL_BG_FM) &&
        (g_sif_drv_dev.dev_attr.sys_sel <= SIF_SYS_SEL_BG_NICAM)) {
        *need_ascs_detect = TD_TRUE;
    }

    if ((g_sif_drv_dev.dev_attr.sys_sel >= SIF_SYS_SEL_DK1) &&
        (g_sif_drv_dev.dev_attr.sys_sel <= SIF_SYS_SEL_DK_NICAM)) {
        *need_ascs_detect = TD_TRUE;
    }

    if ((g_sif_drv_dev.aaos_mode != EXT_SIF_AAOS_MODE_MONO) &&
        (g_sif_drv_dev.aaos_mode != EXT_SIF_AAOS_MODE_NICAM_MONO)) {
        *need_ascs_detect = TD_FALSE;
    }
}

static td_s32 sif_get_sys_sel(ext_sif_standard_type *psys_sel)
{
    td_s32 ret;
    sif_sys_sel sys_sel = SIF_SYS_SEL_BUTT;
    td_bool need_ascs_detect = TD_FALSE;
    static td_u32 wait_ascs_cnt = 0;
    sif_sys_sel ascs_sys_sel = SIF_SYS_SEL_BUTT;
    td_bool get_sys_sel_from_ascs = TD_FALSE;

    soc_dbg_func_enter();
    if (psys_sel == TD_NULL) {
        soc_log_err("psys_sel is null!\n");
        return SOC_ERR_SIF_NULL_PTR;
    }

    ret = sif_check_dev_status();
    if (ret != TD_SUCCESS) {
        return ret;
    }

    sif_get_need_ascs_detect_status(&need_ascs_detect);

    if (need_ascs_detect == TD_TRUE) {
        osal_msleep(5); /* 5 is sleep time. */
        wait_ascs_cnt++;

        if (wait_ascs_cnt > 40) { /* 40 is a threshold */
            wait_ascs_cnt = 0;
            sif_hal_set_ascs_en(SIF_ASCS_MODE_ONETIME);
            osal_msleep(20); /* 20 is sleep time. */
        }

        ascs_sys_sel = (sif_sys_sel)sif_hal_get_ascs_result();
        if ((ascs_sys_sel != SIF_SYS_SEL_FM_RADIO_EUROPE3) && (g_sif_drv_dev.dev_attr.sys_sel != ascs_sys_sel)) {
            get_sys_sel_from_ascs = TD_TRUE;
        }
    }

    if (get_sys_sel_from_ascs == TD_TRUE) {
        soc_log_info("ASCS result: syssel\n");
        soc_info_print_s32(ascs_sys_sel);
        sys_sel = ascs_sys_sel;
    } else {
        sys_sel = sif_hal_get_det_standard();
    }

    sif_get_sys_sel_val(sys_sel, psys_sel);

    g_sif_drv_dev.dev_attr.sys_sel = sys_sel;
    g_sif_drv_dev.sif_stand = *psys_sel;

    soc_dbg_func_exit();
    return TD_SUCCESS;
}

static td_void sif_get_btsc_support(td_bool *support)
{
    sif_hal_get_btsc_support(support);
}

static td_void sif_btsc_get_out_mode(ext_sif_aaos_mode *pen_mode)
{
    td_bool stereo;
    td_bool sap;

    stereo = sif_hal_is_stereo();
    sap = sif_hal_is_bi_sap();
    if (sap == TD_TRUE) {
        *pen_mode = stereo ? EXT_SIF_AAOS_MODE_STEREO_SAP : EXT_SIF_AAOS_MODE_MONO_SAP;
    } else {
        *pen_mode = stereo ? EXT_SIF_AAOS_MODE_STEREO : EXT_SIF_AAOS_MODE_MONO;
    }
}

static td_void sif_a2_get_out_mode(ext_sif_aaos_mode *pen_mode)
{
    td_bool det_out_mode;
    sif_audmode_det aud_mode;
    *pen_mode = EXT_SIF_AAOS_MODE_MONO;

    det_out_mode = sif_hal_is_sec_car_exist();
    if (det_out_mode == TD_FALSE) {
        return;
    }

    aud_mode = sif_hal_get_aud_mod_det();
    switch (aud_mode) {
        case SIF_AUDMODE_MONO:
            *pen_mode = EXT_SIF_AAOS_MODE_MONO;
            break;

        case SIF_AUDMODE_STEREO:
            if (sif_hal_is_stereo() != TD_TRUE) {
                break;
            }

            *pen_mode = EXT_SIF_AAOS_MODE_STEREO;
            break;

        case SIF_AUDMODE_BILIGUAL:
            if (sif_hal_is_bi_sap() != TD_TRUE) {
                break;
            }

            *pen_mode = EXT_SIF_AAOS_MODE_DUAL;
            break;

        default:
            *pen_mode = EXT_SIF_AAOS_MODE_MONO;
            break;
    }
}

static td_void sif_nicam_get_out_mode(ext_sif_aaos_mode *pen_mode)
{
    sif_nicam_ctrl nicam_ctl;
    sif_anadig_status ana_mode;

    ana_mode = sif_hal_get_ana_dig_status();
    if (ana_mode != SIF_ANADIG_STATUS_DIG) {
        return;
    }

    nicam_ctl = sif_hal_get_nicam_ctrl();
    switch (nicam_ctl) {
        case SIF_NICAM_CTRL_STEREO:
            *pen_mode = EXT_SIF_AAOS_MODE_NICAM_STEREO;
            break;
        case SIF_NICAM_CTRL_MONODATA:
            *pen_mode = EXT_SIF_AAOS_MODE_NICAM_MONO;
            break;
        case SIF_NICAM_CTRL_DUALMONO:
            *pen_mode = EXT_SIF_AAOS_MODE_NICAM_DUAL;
            break;
        default:
            break;
    }
}

static td_void sif_eiaj_get_out_mode(ext_sif_aaos_mode *pen_mode)
{
    td_bool det_out_mode;
    sif_audmode_det aud_mode;

    det_out_mode = sif_hal_is_prm_car_exist();
    if (det_out_mode == TD_FALSE) {
        return;
    }

    aud_mode = sif_hal_get_aud_mod_det();
    switch (aud_mode) {
        case SIF_AUDMODE_MONO:
            *pen_mode = EXT_SIF_AAOS_MODE_MONO;
            break;
        case SIF_AUDMODE_BILIGUAL:
            *pen_mode = EXT_SIF_AAOS_MODE_DUAL;
            break;
        case SIF_AUDMODE_STEREO:
            *pen_mode = EXT_SIF_AAOS_MODE_STEREO;
            break;
        default:
            *pen_mode = EXT_SIF_AAOS_MODE_MONO;
            break;
    }
}

static td_s32 sif_get_out_mode(ext_sif_aaos_mode *paaos_mode)
{
    td_s32 ret;
    ext_sif_aaos_mode mode = EXT_SIF_AAOS_MODE_MONO;
    ext_sif_standard_type sys_sel = EXT_SIF_STANDARD_UNKNOW;

    soc_dbg_func_enter();

    ret = sif_check_dev_status();
    if (ret != TD_SUCCESS) {
        return ret;
    }

    ret = sif_get_sys_sel(&sys_sel);
    if (ret != TD_SUCCESS) {
        soc_log_err("get_sys_sel is failed!\n");
    }

    switch (g_sif_drv_dev.dev_attr.sys_sel) {
        case SIF_SYS_SEL_BTSC:
            sif_btsc_get_out_mode(&mode);
            break;
        case SIF_SYS_SEL_BG_FM:
        case SIF_SYS_SEL_DK1:
        case SIF_SYS_SEL_DK2:
        case SIF_SYS_SEL_DK3:
        case SIF_SYS_SEL_KOREA: /* FM-korea */
            sif_a2_get_out_mode(&mode);
            break;
        case SIF_SYS_SEL_L:
        case SIF_SYS_SEL_BG_NICAM:
        case SIF_SYS_SEL_DK_NICAM:
        case SIF_SYS_SEL_I:
            sif_nicam_get_out_mode(&mode);
            break;
        case SIF_SYS_SEL_EIAJ:
            sif_eiaj_get_out_mode(&mode);
            break;
        case SIF_SYS_SEL_FM_RADIO_US:
        case SIF_SYS_SEL_FM_RADIO_EUROPE1:
        case SIF_SYS_SEL_FM_RADIO_EUROPE2:
        case SIF_SYS_SEL_FM_RADIO_EUROPE3:
            mode = EXT_SIF_AAOS_MODE_MONO;
            break;
        default:
            mode = EXT_SIF_AAOS_MODE_MONO;
            break;
    }

    g_sif_drv_dev.aaos_mode = mode;
    *paaos_mode = mode;

    soc_dbg_func_exit();
    return TD_SUCCESS;
}

static inline td_void sif_get_aaos_nicam_forced_mono(td_void)
{
    if (g_sif_drv_dev.dev_attr.sys_sel == SIF_SYS_SEL_BTSC) {
        g_sif_drv_dev.dev_attr.btsc_sap = TD_FALSE;
        sif_hal_set_btsc_sap(SIF_SIGSEL_BTSC_STEREO);
    }

    g_sif_drv_dev.dev_attr.l_output = SIF_AAOS_OUTMODE_MONO;
    g_sif_drv_dev.dev_attr.r_output = SIF_AAOS_OUTMODE_MONO;
    g_sif_drv_dev.dev_attr.aaos_en = TD_FALSE;
}

static inline td_void sif_get_aaos_nicam_stereo(td_void)
{
    if (g_sif_drv_dev.dev_attr.sys_sel == SIF_SYS_SEL_BTSC) {
        g_sif_drv_dev.dev_attr.btsc_sap = TD_FALSE;
        sif_hal_set_btsc_sap(SIF_SIGSEL_BTSC_STEREO);
    }

    g_sif_drv_dev.dev_attr.l_output = SIF_AAOS_OUTMODE_L_OR_R;
    g_sif_drv_dev.dev_attr.r_output = SIF_AAOS_OUTMODE_L_OR_R;
    g_sif_drv_dev.dev_attr.aaos_en = TD_TRUE;
}

static inline td_void sif_get_aaos_nicam_dual_b(td_void)
{
    if (g_sif_drv_dev.dev_attr.sys_sel == SIF_SYS_SEL_BTSC) {
        g_sif_drv_dev.dev_attr.btsc_sap = TD_TRUE;
        sif_hal_set_btsc_sap(SIF_SIGSEL_BTSC_SAP);
    }

    g_sif_drv_dev.dev_attr.l_output = SIF_AAOS_OUTMODE_B;
    g_sif_drv_dev.dev_attr.r_output = SIF_AAOS_OUTMODE_B;
    g_sif_drv_dev.dev_attr.aaos_en = TD_TRUE;
}

static inline td_void sif_get_aaos_btsc_sap(td_void)
{
    if (g_sif_drv_dev.dev_attr.sys_sel == SIF_SYS_SEL_BTSC) {
        g_sif_drv_dev.dev_attr.btsc_sap = TD_TRUE;
        sif_hal_set_btsc_sap(SIF_SIGSEL_BTSC_SAP);
    }

    g_sif_drv_dev.dev_attr.l_output = SIF_AAOS_OUTMODE_B;
    g_sif_drv_dev.dev_attr.r_output = SIF_AAOS_OUTMODE_B;
    g_sif_drv_dev.dev_attr.aaos_en = TD_TRUE;
}

static inline td_void sif_get_aaos_nicam_dual_ab(td_void)
{
    if (g_sif_drv_dev.dev_attr.sys_sel == SIF_SYS_SEL_BTSC) {
        g_sif_drv_dev.dev_attr.btsc_sap = TD_TRUE;
        sif_hal_set_btsc_sap(SIF_SIGSEL_BTSC_SAP);
    }
    g_sif_drv_dev.dev_attr.l_output = SIF_AAOS_OUTMODE_A;
    g_sif_drv_dev.dev_attr.r_output = SIF_AAOS_OUTMODE_B;
    g_sif_drv_dev.dev_attr.aaos_en = TD_TRUE;
}

static inline td_void sif_get_aaos_btsc_stereo(td_void)
{
    g_sif_drv_dev.dev_attr.l_output = SIF_AAOS_OUTMODE_L_OR_R;
    g_sif_drv_dev.dev_attr.r_output = SIF_AAOS_OUTMODE_L_OR_R;
    g_sif_drv_dev.dev_attr.aaos_en = TD_TRUE;
}

static td_void sif_get_aaos_by_outmode(ext_sif_out_mode out_mode)
{
    switch (out_mode) {
        case EXT_SIF_OUT_MODE_MONO:
        case EXT_SIF_OUT_MODE_NICAM_MONO:
            g_sif_drv_dev.dev_attr.l_output = SIF_AAOS_OUTMODE_MONO;
            g_sif_drv_dev.dev_attr.r_output = SIF_AAOS_OUTMODE_MONO;
            g_sif_drv_dev.dev_attr.aaos_en = TD_TRUE;
            break;
        case EXT_SIF_OUT_MODE_BTSC_MONO:
            g_sif_drv_dev.dev_attr.l_output = SIF_AAOS_OUTMODE_MONO;
            g_sif_drv_dev.dev_attr.r_output = SIF_AAOS_OUTMODE_MONO;
            g_sif_drv_dev.dev_attr.aaos_en = TD_TRUE;
            break;
        case EXT_SIF_OUT_MODE_NICAM_FORCED_MONO:
            sif_get_aaos_nicam_forced_mono();
            break;
        case EXT_SIF_OUT_MODE_STEREO:
        case EXT_SIF_OUT_MODE_NICAM_STEREO:
            sif_get_aaos_nicam_stereo();
            break;
        case EXT_SIF_OUT_MODE_BTSC_STEREO:
            sif_get_aaos_btsc_stereo();
            break;
        case EXT_SIF_OUT_MODE_DUAL_A:
        case EXT_SIF_OUT_MODE_NICAM_DUAL_A:
            g_sif_drv_dev.dev_attr.l_output = SIF_AAOS_OUTMODE_A;
            g_sif_drv_dev.dev_attr.r_output = SIF_AAOS_OUTMODE_A;
            g_sif_drv_dev.dev_attr.aaos_en = TD_TRUE;
            break;
        case EXT_SIF_OUT_MODE_DUAL_B:
        case EXT_SIF_OUT_MODE_NICAM_DUAL_B:
            sif_get_aaos_nicam_dual_b();
            break;
        case EXT_SIF_OUT_MODE_BTSC_SAP:
            sif_get_aaos_btsc_sap();
            break;
        case EXT_SIF_OUT_MODE_DUAL_AB:
        case EXT_SIF_OUT_MODE_NICAM_DUAL_AB:
            sif_get_aaos_nicam_dual_ab();
            break;
        default:
            soc_log_warn("set invalid out mode:\n");
            soc_warn_print_u32(out_mode);
            g_sif_drv_dev.dev_attr.l_output = SIF_AAOS_OUTMODE_L_OR_R;
            g_sif_drv_dev.dev_attr.r_output = SIF_AAOS_OUTMODE_L_OR_R;
            g_sif_drv_dev.dev_attr.aaos_en = TD_TRUE;
            break;
    }
}

static td_s32 sif_set_out_mode(ext_sif_out_mode out_mode)
{
    td_s32 ret;
    ext_sif_standard_type sys_sel_type = EXT_SIF_STANDARD_UNKNOW;

    soc_dbg_func_enter();
    ret = sif_get_sys_sel(&sys_sel_type);
    if (ret != TD_SUCCESS) {
        soc_log_err("get_sys_sel is failed!\n");
    }

    ret = sif_check_dev_status();
    if (ret != TD_SUCCESS) {
        return ret;
    }

    sif_get_aaos_by_outmode(out_mode);

    sif_hal_set_aaos_lf_sel(g_sif_drv_dev.dev_attr.l_output);
    sif_hal_set_aaos_rt_sel(g_sif_drv_dev.dev_attr.r_output);
    sif_hal_aaos_en(g_sif_drv_dev.dev_attr.aaos_en);

    soc_dbg_func_exit();
    return TD_SUCCESS;
}

static td_s32 sif_set_carri_shift(td_u32 carri_shift)
{
    soc_info_func_enter();

    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_err("current state is not open, can not set carrier shift!\n");
        return SOC_ERR_SIF_NOT_OPEN;
    }

    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_START) {
        soc_log_err("current state is not start, can not set carrier shift!\n");
        return SOC_ERR_SIF_NOT_START;
    }

    g_sif_drv_dev.dev_attr.crri_freq1 = carri_shift;
    sif_hal_set_demod_carri_freq1(g_sif_drv_dev.dev_attr.crri_freq1);

    soc_info_func_exit();
    return TD_SUCCESS;
}

/* the order of value is wrong on logic, should exchange here */
static ext_sif_over_deviation g_real_over_mode[EXT_SIF_OVER_DEVIATION_MAX] = {
    EXT_SIF_OVER_DEVIATION_50K,
    EXT_SIF_OVER_DEVIATION_100K,
    EXT_SIF_OVER_DEVIATION_540K,
    EXT_SIF_OVER_DEVIATION_200K,
    EXT_SIF_OVER_DEVIATION_384K,
};

static td_s32 sif_set_over_mode(ext_sif_over_deviation over_mode)
{
    soc_info_func_enter();

    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_err("current state is not open, can not set over mode!\n");
        return SOC_ERR_SIF_NOT_OPEN;
    }

    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_START) {
        soc_log_err("current state is not start, can not set over mode!\n");
        return SOC_ERR_SIF_NOT_START;
    }

    if (over_mode >= EXT_SIF_OVER_DEVIATION_MAX) {
        soc_log_err("invalid over mode param error: \n");
        soc_err_print_u32(over_mode);
        return SOC_ERR_SIF_INVALID_PARA;
    }

    if ((g_sif_drv_dev.dev_attr.sys_sel == SIF_SYS_SEL_BTSC) || (g_sif_drv_dev.dev_attr.sys_sel == SIF_SYS_SEL_EIAJ) ||
        (g_sif_drv_dev.dev_attr.sys_sel == SIF_SYS_SEL_KOREA)) {
        g_sif_drv_dev.dev_attr.flt1 = SIF_DEMOD1_FILTER_100K;
        g_sif_drv_dev.dev_attr.deviation1 = SIF_DEVIATION_100K;
    } else {
        g_sif_drv_dev.dev_attr.flt1 = (sif_filter1)g_real_over_mode[over_mode];
        g_sif_drv_dev.dev_attr.deviation1 = (sif_deviation1)g_real_over_mode[over_mode];
    }

    sif_hal_set_filter1(g_sif_drv_dev.dev_attr.flt1);
    sif_hal_set_deviation1(g_sif_drv_dev.dev_attr.deviation1);
    sif_hal_set_deviation2(g_sif_drv_dev.dev_attr.deviation1);

    soc_info_func_exit();
    return TD_SUCCESS;
}

/* the order of value is wrong on logic, should exchange here */
static sif_deviation1 g_real_deviation1[SIF_DEVIATION_BUTT] = {
    EXT_SIF_OVER_DEVIATION_50K,
    EXT_SIF_OVER_DEVIATION_100K,
    EXT_SIF_OVER_DEVIATION_384K,
    EXT_SIF_OVER_DEVIATION_540K,
    EXT_SIF_OVER_DEVIATION_200K,
};

static td_s32 sif_get_over_mode(ext_sif_over_deviation *pover_mode)
{
    sif_deviation1 deviation1 = SIF_DEVIATION_BUTT;

    soc_info_func_enter();
    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_err("current state is not open, can not start ASD detect!\n");
        return SOC_ERR_SIF_NOT_OPEN;
    }

    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_START) {
        soc_log_err("current state is not stop, can not set attr!\n");
        return SOC_ERR_SIF_NOT_START;
    }

    sif_hal_get_deviation1(&deviation1);

    *pover_mode = (ext_sif_over_deviation)g_real_deviation1[deviation1];

    soc_info_func_exit();
    return TD_SUCCESS;
}

static td_s32 sif_set_auto_mute(td_bool auto_mute)
{
    if (auto_mute == TD_FALSE) {
        sif_hal_set_mute_right(TD_FALSE);
        sif_hal_set_mute_left(TD_FALSE);
    }

    sif_hal_set_mute_auto(auto_mute);

    return TD_SUCCESS;
}

static td_s32 sif_set_freq_error(ext_sif_freq_err_threshold freq_err)
{
    sif_freq_err_threshold hal_freq_err = SIF_FREQ_ERR_THRESHOLD_27K;

    switch (freq_err) {
        case EXT_SIF_FREQ_ERR_THRESHOLD_10K:
            hal_freq_err = SIF_FREQ_ERR_THRESHOLD_10K;
            break;
        case EXT_SIF_FREQ_ERR_THRESHOLD_20K:
            hal_freq_err = SIF_FREQ_ERR_THRESHOLD_20K;
            break;
        case EXT_SIF_FREQ_ERR_THRESHOLD_27K:
            hal_freq_err = SIF_FREQ_ERR_THRESHOLD_27K;
            break;
        case EXT_SIF_FREQ_ERR_THRESHOLD_30K:
            hal_freq_err = SIF_FREQ_ERR_THRESHOLD_30K;
            break;
        case EXT_SIF_FREQ_ERR_THRESHOLD_40K:
            hal_freq_err = SIF_FREQ_ERR_THRESHOLD_40K;
            break;
        case EXT_SIF_FREQ_ERR_THRESHOLD_50K:
            hal_freq_err = SIF_FREQ_ERR_THRESHOLD_50K;
            break;
        default:
            hal_freq_err = SIF_FREQ_ERR_THRESHOLD_27K;
            break;
    }

    sif_hal_set_freq_err(hal_freq_err);

    return TD_SUCCESS;
}

static td_s32 sif_set_attr(ext_sif_attr attr)
{
    td_s32 ret;
    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_err("current state is not open, can not set attr!\n");
        return SOC_ERR_SIF_NOT_OPEN;
    }

    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_STOP) {
        soc_log_err("current state is not stop, can not set attr!\n");
        return SOC_ERR_SIF_NOT_STOP;
    }

    ret = memcpy_s(&g_sif_drv_dev.attr, sizeof(ext_sif_attr), &attr, sizeof(attr));
    if (ret != TD_SUCCESS) {
        soc_log_err("memcpy_s failed");
        return ret;
    }

    ret = sif_set_freq_error(g_sif_drv_dev.attr.freq_threshold);
    if (ret != TD_SUCCESS) {
        soc_log_err("sif_set_freq_error is failed!\n");
    }
    ret = sif_set_auto_mute(g_sif_drv_dev.attr.auto_mute);
    if (ret != TD_SUCCESS) {
        soc_log_err("sif_set_auto_mute is failed!\n");
    }

    return TD_SUCCESS;
}

static td_s32 sif_get_attr(ext_sif_attr *attr)
{
    td_s32 ret;
    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_err("current state is not open, can not get attr!\n");
        return SOC_ERR_SIF_NOT_OPEN;
    }

    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_START) {
        soc_log_err("current state is not start, can not get attr!\n");
        return SOC_ERR_SIF_NOT_START;
    }

    ret = memcpy_s(attr, sizeof(ext_sif_attr), &g_sif_drv_dev.attr, sizeof(g_sif_drv_dev.attr));
    if (ret != TD_SUCCESS) {
        soc_log_err("memcpy_s failed");
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 sif_open(td_void)
{
    soc_info_func_enter();

    g_sif_drv_dev.curn_status = SIF_CHANNEL_STATUS_STOP;

    g_sif_drv_dev.dev_open = TD_TRUE;

    soc_info_func_exit();
    return TD_SUCCESS;
}

static td_s32 sif_close(td_void)
{
    soc_info_func_enter();

    /* 复位即ok */
    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_STOP) {
        soc_log_err("current state is not stop, can not close sif!\n");
        return SOC_ERR_SIF_NOT_STOP;
    }

    g_sif_drv_dev.dev_open = TD_FALSE;

    soc_info_func_exit();
    return TD_SUCCESS;
}

static td_s32 sif_start(td_void)
{
    soc_info_func_enter();

    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_err("current state is not open, can not start sif!\n");
        return SOC_ERR_SIF_NOT_OPEN;
    }

    g_sif_drv_dev.dev_attr.ascs_chg_mode = SIF_ASCS_CHGMODE_AFTER_RST;
    g_sif_drv_dev.dev_attr.ascs_ctl = SIF_ASCS_MODE_DISABLE;
    sif_hal_set_ascs_chg_mod(g_sif_drv_dev.dev_attr.ascs_chg_mode);
    sif_hal_set_ascs_en(g_sif_drv_dev.dev_attr.ascs_ctl);

    g_sif_drv_dev.curn_status = SIF_CHANNEL_STATUS_START;

    soc_info_func_exit();
    return TD_SUCCESS;
}

static td_s32 sif_stop(td_void)
{
    soc_info_func_enter();
    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_err("current state is not open, can not stop sif!\n");
        return SOC_ERR_SIF_NOT_OPEN;
    }

    g_sif_drv_dev.curn_status = SIF_CHANNEL_STATUS_STOP;

    soc_info_func_exit();
    return TD_SUCCESS;
}

static td_u32 sif_get_quality1(td_void)
{
    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_START) {
        soc_log_err("current state is not start, can not get quality1!\n");
        return SOC_ERR_SIF_NOT_START;
    }
    return sif_hal_get_quality1();
}

static td_u32 sif_get_quality2(td_void)
{
    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_START) {
        soc_log_err("current state is not start, can not get quality2!\n");
        return SOC_ERR_SIF_NOT_START;
    }

    return sif_hal_get_quality2();
}

static td_s32 sif_get_carri_shift_value(td_u32 *shift_value)
{
    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_START) {
        soc_log_err("current state is not start, can not get carrier shift value!\n");
        return SOC_ERR_SIF_NOT_START;
    }

    *shift_value = sif_hal_get_carrier_shift_value();

    g_sif_drv_dev.dev_attr.carri_shift_value = *shift_value;

    return TD_SUCCESS;
}

static td_s32 sif_suspend(td_void)
{
    td_s32 ret;
    ext_sif_standard_type sys_sel = EXT_SIF_STANDARD_UNKNOW;

    if (!g_sif_suspend_flag) {
        g_sif_suspend_flag = 1;
    }

    /* 7. sap状态 */
    /* 仅在设置输出时设置，默认为解stereo,没有改变就无需设置 */
    /* 6. auto mute */
    /* 设置属性中已经保存该值 */
    /* 5. 输出选择,从寄存器中获取状态 */
    g_sif_drv_dev.dev_attr.l_output = sif_hal_get_aaos_lf_sel();
    g_sif_drv_dev.dev_attr.r_output = sif_hal_get_aaos_rt_sel();
    g_sif_drv_dev.dev_attr.aaos_en = sif_hal_get_aaos_en();

    /* 4. 制式 */
    ret = sif_get_sys_sel(&sys_sel);
    if (ret != TD_SUCCESS) {
        soc_log_err("get_sys_sel is failed!\n");
    }

    dspreg_sif_deinit();

    g_sif_resume_flag = 0;

    return TD_SUCCESS;
}

static td_s32 sif_resume(td_void)
{
    if (!g_sif_resume_flag) {
        dspreg_sif_init();

        /* 3. 阈值 */
        sif_set_freq_error(g_sif_drv_dev.attr.freq_threshold);

        /* 4. 制式 */
        dspreg_sif_set_sys_sel(g_sif_drv_dev.sif_stand);

        /* 5. 设置自动载波跟随 */
        sif_hal_set_ascs_chg_mod(g_sif_drv_dev.dev_attr.ascs_chg_mode);
        sif_hal_set_ascs_en(g_sif_drv_dev.dev_attr.ascs_ctl);

        /* 6. 输出选择 */
        sif_hal_set_aaos_lf_sel(g_sif_drv_dev.dev_attr.l_output);
        sif_hal_set_aaos_rt_sel(g_sif_drv_dev.dev_attr.r_output);
        sif_hal_aaos_en(g_sif_drv_dev.dev_attr.aaos_en);

        /* 7. auto mute */
        sif_set_auto_mute(g_sif_drv_dev.dev_attr.auto_mute);

        /* 8. sap状态 */
        if (g_sif_drv_dev.dev_attr.btsc_sap == TD_TRUE) {
            sif_hal_set_btsc_sap(SIF_SIGSEL_BTSC_SAP);
        }

        g_sif_resume_flag = 1;
    }

    g_sif_suspend_flag = 0;
    return TD_SUCCESS;
}

static td_void sif_reset(td_void)
{
    td_s32 ret;
    /* 保存原来的输出模式 */
    g_sif_drv_dev.dev_attr.l_output = sif_hal_get_aaos_lf_sel();
    g_sif_drv_dev.dev_attr.r_output = sif_hal_get_aaos_rt_sel();
    g_sif_drv_dev.dev_attr.aaos_en = sif_hal_get_aaos_en();

    osal_msleep(2); /* 2 is time for sleep */

    /* 恢复 阈值 */
    ret = sif_set_freq_error(g_sif_drv_dev.attr.freq_threshold);
    if (ret != TD_SUCCESS) {
        soc_log_err("sif_set_freq_error is failed!\n");
    }
    /* 恢复自动载波跟随 */
    sif_hal_set_ascs_chg_mod(g_sif_drv_dev.dev_attr.ascs_chg_mode);
    sif_hal_set_ascs_en(g_sif_drv_dev.dev_attr.ascs_ctl);

    /* 输出选择 */
    sif_hal_set_aaos_lf_sel(g_sif_drv_dev.dev_attr.l_output);
    sif_hal_set_aaos_rt_sel(g_sif_drv_dev.dev_attr.r_output);
    sif_hal_aaos_en(g_sif_drv_dev.dev_attr.aaos_en);

    /* 恢复自动mute */
    ret = sif_set_auto_mute(g_sif_drv_dev.dev_attr.auto_mute);
    if (ret != TD_SUCCESS) {
        soc_log_err("sif_set_auto_mute is failed!\n");
    }
    /* 恢复sap */
    if (g_sif_drv_dev.dev_attr.btsc_sap == TD_TRUE) {
        sif_hal_set_btsc_sap(SIF_SIGSEL_BTSC_SAP);
    }

    return;
}

static int sif_drv_ioctl_standard_type(unsigned int cmd, td_void *arg)
{
    td_s32 ret = TD_FAILURE;
    sif_standard_type_param *sys_sel = (sif_standard_type_param *)arg;

    switch (cmd) {
        case CMD_SIF_SET_STANDDARD:
            sif_reset();
            ret = dspreg_sif_set_sys_sel(sys_sel->stand);
            break;
        case CMD_SIF_GET_ASD_RESULT:
            ret = dspreg_sif_get_asd_result(&sys_sel->stand);
            break;
        case CMD_SIF_GET_STANDARD:
            ret = sif_get_sys_sel(&sys_sel->stand);
            break;
        default:
            soc_log_err("invalid parameter!\n");
            break;
    }

    return ret;
}

static int sif_drv_ioctl_over_deviation(unsigned int cmd, td_void *arg)
{
    td_s32 ret = TD_FAILURE;
    sif_over_deviation_param *over_mod = (sif_over_deviation_param *)arg;

    switch (cmd) {
        case CMD_SIF_SET_OVER_DEV:
            ret = sif_set_over_mode(over_mod->over_mode);
            break;
        case CMD_SIF_GET_OVER_DEV:
            ret = sif_get_over_mode(&over_mod->over_mode);
            break;
        default:
            soc_log_err("invalid parameter!\n");
            break;
    }

    return ret;
}

static const struct {
    sif_sys_sel sys_sel;
    ext_sif_standard_type standard_type;
} g_sif_sys_to_standard[] = {
    {SIF_SYS_SEL_BG_FM, EXT_SIF_STANDARD_BG_A2},
    {SIF_SYS_SEL_BG_NICAM, EXT_SIF_STANDARD_BG_NICAM},
    {SIF_SYS_SEL_I, EXT_SIF_STANDARD_I},
    {SIF_SYS_SEL_DK1, EXT_SIF_STANDARD_DK1_A2},
    {SIF_SYS_SEL_DK2, EXT_SIF_STANDARD_DK2_A2},
    {SIF_SYS_SEL_DK3, EXT_SIF_STANDARD_DK3_A2},
    {SIF_SYS_SEL_DK_NICAM, EXT_SIF_STANDARD_DK_NICAM},
    {SIF_SYS_SEL_L, EXT_SIF_STANDARD_L},
    {SIF_SYS_SEL_BTSC, EXT_SIF_STANDARD_M_BTSC},
    {SIF_SYS_SEL_KOREA, EXT_SIF_STANDARD_M_A2},
    {SIF_SYS_SEL_EIAJ, EXT_SIF_STANDARD_M_EIA_J},
    {SIF_SYS_SEL_FM_RADIO_EUROPE, EXT_SIF_STANDARD_NOTSTANDARD},
    {SIF_SYS_SEL_FM_RADIO_US, EXT_SIF_STANDARD_NOTSTANDARD},
    {SIF_SYS_SEL_FM_RADIO_EUROPE1, EXT_SIF_STANDARD_NOTSTANDARD},
    {SIF_SYS_SEL_FM_RADIO_EUROPE2, EXT_SIF_STANDARD_NOTSTANDARD},
    {SIF_SYS_SEL_FM_RADIO_EUROPE3, EXT_SIF_STANDARD_UNKNOW},
};

static const struct {
    ext_sif_standard_type standard_type;
    sif_sys_sel sys_sel;
} g_sif_standard_to_sys[] = {
    {EXT_SIF_STANDARD_BG, SIF_SYS_SEL_BG_FM},
    {EXT_SIF_STANDARD_BG_A2, SIF_SYS_SEL_BG_FM},
    {EXT_SIF_STANDARD_BG_NICAM, SIF_SYS_SEL_BG_NICAM},
    {EXT_SIF_STANDARD_I, SIF_SYS_SEL_I},
    {EXT_SIF_STANDARD_DK, SIF_SYS_SEL_DK3},
    {EXT_SIF_STANDARD_DK3_A2, SIF_SYS_SEL_DK3},
    {EXT_SIF_STANDARD_DK1_A2, SIF_SYS_SEL_DK1},
    {EXT_SIF_STANDARD_DK2_A2, SIF_SYS_SEL_DK2},
    {EXT_SIF_STANDARD_DK_NICAM, SIF_SYS_SEL_DK_NICAM},
    {EXT_SIF_STANDARD_M, SIF_SYS_SEL_KOREA},
    {EXT_SIF_STANDARD_M_A2, SIF_SYS_SEL_KOREA},
    {EXT_SIF_STANDARD_M_BTSC, SIF_SYS_SEL_BTSC},
    {EXT_SIF_STANDARD_M_EIA_J, SIF_SYS_SEL_EIAJ},
    {EXT_SIF_STANDARD_L, SIF_SYS_SEL_L},
};

static td_s32 sif_get_standard_try(ext_sif_carrier_attr *attr)
{
    td_s32 i;
    td_s32 ret;

    soc_dbg_func_enter();
    if (g_sif_drv_dev.dev_open == TD_FALSE) {
        soc_log_err("current state is not open, can not try standard!\n");
        return SOC_ERR_SIF_NOT_OPEN;
    }

    if (g_sif_drv_dev.curn_status != SIF_CHANNEL_STATUS_START) {
        soc_log_err("current state is not start, can not try standard!\n");
        return SOC_ERR_SIF_NOT_START;
    }

    ret = sif_hal_get_standard_try((sif_hal_carrier_attr *)attr);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(sif_hal_get_standard_try, ret);
        return ret;
    }

    for (i = 0; i < sizeof(g_sif_sys_to_standard) / sizeof(g_sif_sys_to_standard[0]); i++) {
        if (attr->standard_type == (ext_sif_standard_type)g_sif_sys_to_standard[i].sys_sel) {
            attr->standard_type = g_sif_sys_to_standard[i].standard_type;
            break;
        }
    }

    if (i == sizeof(g_sif_sys_to_standard) / sizeof(g_sif_sys_to_standard[0])) {
        attr->standard_type = EXT_SIF_STANDARD_UNKNOW;
    }

    soc_dbg_func_exit();

    return TD_SUCCESS;
}

static td_u32 sif_set_standard_try_priority(ext_sif_standard_priority_list *priority_list)
{
    td_u32 i;
    td_u32 j;
    td_s32 ret;
    td_u32 list_len = priority_list->list_len;

    if (list_len > EXT_SIF_STANDARD_MAX) {
        soc_log_err("standardtry list length is too big!\n");
        return SOC_ERR_SIF_INVALID_PARA;
    }

    for (i = 0; i < list_len; i++) {
        for (j = 0; j < sizeof(g_sif_standard_to_sys) / sizeof(g_sif_standard_to_sys[0]); j++) {
            if (priority_list->priority_list[i] == g_sif_standard_to_sys[j].standard_type) {
                priority_list->priority_list[i] = (ext_sif_standard_type)g_sif_standard_to_sys[j].sys_sel;
                break;
            }
        }
        if (j == sizeof(g_sif_standard_to_sys) / sizeof(g_sif_standard_to_sys[0])) {
            priority_list->priority_list[i] = (ext_sif_standard_type)SIF_SYS_SEL_FM_RADIO_EUROPE3;
        }
    }

    ret = sif_hal_set_standard_try_priority((sif_hal_syssel_priority_list *)priority_list);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(sif_set_standard_try_priority, ret);
        return ret;
    }
    return TD_SUCCESS;
}

static int sif_drv_ioctl_try_standard(td_void *arg)
{
    sif_carrier_attr_param *attr = (sif_carrier_attr_param *)arg;

    return sif_get_standard_try(&(attr->carrier_attr));
}

static int sif_drv_ioctl_standard_list(const td_void *arg)
{
    sif_standard_list_param *standard_list_param = (sif_standard_list_param *)arg;
    return sif_set_standard_try_priority(&(standard_list_param->priority_list));
}

static int sif_drv_ioctl_start_asd(const td_void *arg)
{
    sif_sysctl_param *sys_ctl = (sif_sysctl_param *)arg;

    hal_set_core_reset(TD_TRUE);
    hal_set_core_reset(TD_FALSE);
    return dspreg_sif_start_asd_detect(sys_ctl->sys_ctl);
}

static int sif_drv_ioctl_asd_cmpl(td_void *arg)
{
    sif_asd_complete_param *asd_cmpl = (sif_asd_complete_param *)arg;

    return dspreg_sif_get_asd_complete(&asd_cmpl->asd_complete);
}

int sif_drv_ioctl_inner_ext(unsigned int cmd, td_void *arg, td_void *private_data)
{
    td_s32 ret;
    sif_attr_param *attr = TD_NULL;

    soc_dbg_func_enter();

    if (arg == TD_NULL) {
        soc_log_err("arg is null!\n");
        return SOC_ERR_SIF_NULL_PTR;
    }

    attr = (sif_attr_param *)arg;

    ret = osal_sem_down_interruptible(&g_sif_mutex);
    if (ret != TD_SUCCESS) {
        soc_log_fatal("lock g_sif_mutex failed\n");
        return ret;
    }

    switch (cmd) {
        case CMD_SIF_SET_ATTR:
            ret = sif_set_attr(attr->sif_attr);
            break;
        case CMD_SIF_GET_ATTR:
            ret = sif_get_attr(&attr->sif_attr);
            break;
        case CMD_SIF_OPEN: { /* fall-through */
            ret = sif_open();
            break;
        }
        case CMD_SIF_CLOSE:
            ret = sif_close();
            break;
        case CMD_SIF_SET_START:
            ret = sif_start();
            break;
        case CMD_SIF_SET_STOP:
            ret = sif_stop();
            break;
        case CMD_SIF_TRY_STANDARD:
            ret = sif_drv_ioctl_try_standard(arg);
            break;
        case CMD_SIF_SET_STANDARD_LIST:
            ret = sif_drv_ioctl_standard_list(arg);
            break;

        default:
            soc_log_err("INVALID IOCTL CMD: %#x\n", cmd);
            ret = SOC_ERR_SIF_INVALID_PARA;
            break;
    }

    osal_sem_up(&g_sif_mutex);
    soc_dbg_func_exit();

    return ret;
}

static td_s32 sif_drv_ioctl_outmode(unsigned int cmd, td_void *arg)
{
    switch (cmd) {
        case CMD_SIF_SET_OUTMODE: {
            sif_out_mode_param *out_mode = (sif_out_mode_param *)arg;
            return sif_set_out_mode(out_mode->out_mode);
        }
        case CMD_SIF_GET_OUTMODE: {
            sif_aaos_mode_param *aaos_mode = (sif_aaos_mode_param *)arg;
            return sif_get_out_mode(&aaos_mode->aaos_mode);
        }
        default:
            soc_log_err("invalid parameter!\n");
            return SOC_ERR_SIF_INVALID_PARA;
    }
}

int sif_drv_ioctl_inner(unsigned int cmd, td_void *arg, td_void *private_data)
{
    td_s32 ret;
    sif_carri_shift_param *carri_shift = (sif_carri_shift_param *)arg;

    soc_dbg_func_enter();
    if (arg == TD_NULL) {
        soc_log_err("arg is null!\n");
        return SOC_ERR_SIF_NULL_PTR;
    }

    ret = osal_sem_down_interruptible(&g_sif_mutex);
    if (ret != TD_SUCCESS) {
        soc_log_fatal("lock g_sif_mutex failed\n");
        return ret;
    }

    switch (cmd) {
        case CMD_SIF_START_ASD:
            ret = sif_drv_ioctl_start_asd(arg);
            break;
        case CMD_SIF_SET_STANDDARD:
        case CMD_SIF_GET_ASD_RESULT:
        case CMD_SIF_GET_STANDARD:
            ret = sif_drv_ioctl_standard_type(cmd, arg);
            break;
        case CMD_SIF_SET_OVER_DEV:
        case CMD_SIF_GET_OVER_DEV:
            ret = sif_drv_ioctl_over_deviation(cmd, arg);
            break;
        case CMD_SIF_SET_CARRI_SHIFT:
            ret = sif_set_carri_shift(carri_shift->carri_shift);
            break;
        case CMD_SIF_SET_OUTMODE:
        case CMD_SIF_GET_OUTMODE: /* fall-through */
            ret = sif_drv_ioctl_outmode(cmd, arg);
            break;
        case CMD_SIF_GET_ASD_CMPL:
            ret = sif_drv_ioctl_asd_cmpl(arg);
            break;
        default:
            soc_log_err("ERR IOCTL CMD: %#x\n", cmd);
            ret = SOC_ERR_SIF_INVALID_PARA;
            break;
    }

    osal_sem_up(&g_sif_mutex);

    soc_dbg_func_exit();
    return ret;
}

sif_drv_ctx* get_sif_drv_dev(void)
{
    return &g_sif_drv_dev;
}