#ifdef SUPPORT_MS_EXTENSIONS
#pragma bss_seg(".adc_file.data.bss")
#pragma data_seg(".adc_file.data")
#pragma const_seg(".adc_file.text.const")
#pragma code_seg(".adc_file.text")
#endif
#include "source_node.h"
#include "asm/audio_adc.h"
#include "audio_config.h"
#include "adc_file.h"
#include "gpio_config.h"
#include "effects/effects_adj.h"
#include "audio_cvp.h"
#include "asm/audio_common.h"
#if TCFG_AUDIO_ANC_ENABLE
#include "audio_anc.h"
#endif
#if TCFG_AUDIO_DUT_ENABLE
#include "audio_dut_control.h"
#endif

#if defined(TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN) && TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
#include "icsd_adt_app.h"
#endif

#if TCFG_AUDIO_DUT_ENABLE
#include "audio_dut_control.h"
#endif

#if 1
#define adc_file_log	printf
#else
#define adc_file_log(...)
#endif/*log_en*/

extern struct audio_adc_hdl adc_hdl;
extern const struct adc_platform_cfg adc_platform_cfg_table[AUDIO_ADC_MAX_NUM];

#define ESCO_ADC_BUF_NUM        2	//mic_adc采样buf个数

struct adc_file_common ;
struct adc_file_hdl {
    char name[16];
    void *source_node;
    struct stream_node *node;
    enum stream_scene scene;
    struct adc_mic_ch mic_ch;
    struct audio_adc_output_hdl adc_output;
    s16 *adc_buf;
    struct adc_file_common *adc_f;
    u16 sample_rate;
    u16 irq_points;
    u8 adc_seq;
    u8 Qval;
    u8 start;
    u8 dump_cnt;
    u8 ch_num;
};

struct adc_file_common {
    u8 read_flag;				//读取配置的标志
    struct adc_file_hdl *hdl;	//当前ADC节点的句柄
    struct adc_file_cfg cfg;	//ADC的参数信息
    struct adc_platform_cfg platform_cfg[AUDIO_ADC_MAX_NUM];
};

struct adc_file_global {
    u8 fixed_ch_num;
    s16 *fixed_buf;						//固定的ADCbuffer
    struct adc_file_cfg cfg;	//ESCO ADC的参数信息
};

static struct adc_file_common esco_adc_f = {0};
static struct adc_file_global esco_adc_file_g = {0};

/*根据mic通道值获取使用的第几个mic*/
u8 audio_get_mic_index(u8 mic_ch)
{
    u8 i = 0;
    for (i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
        if (mic_ch & 0x1) {
            return i;
        }
        mic_ch >>= 1;
    }
    return 0;
}

/*根据mic通道值获取使用了多少个mic*/
u8 audio_get_mic_num(u32 mic_ch)
{
    u8 mic_num = 0;
    for (int i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
        if (mic_ch & BIT(i)) {
            mic_num++;
        }
    }
    return mic_num;
}

u8 audio_anc_adt_mic_ch_num_get()
{
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
    return adc_hdl.anc_adt_mic_ch_num;
#else
    return 0;
#endif/*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
}

struct adc_file_cfg *audio_adc_file_get_cfg(void)
{
    return &esco_adc_f.cfg;
}

struct adc_platform_cfg *audio_adc_platform_get_cfg(void)
{
    return &esco_adc_f.platform_cfg[0];
}

u8 audio_adc_file_get_esco_mic_num(void)
{
    u8 mic_en = 0;
    for (int i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
        if (esco_adc_f.cfg.mic_en_map & BIT(i)) {
            mic_en++;
        }
    }
    return mic_en;
}

u8 audio_adc_file_get_mic_en_map(void)
{
    return esco_adc_f.cfg.mic_en_map;
}

void audio_adc_file_set_mic_en_map(u8 mic_en_map)
{
    esco_adc_f.cfg.mic_en_map = mic_en_map;
}


void audio_adc_file_global_cfg_init(void)
{
    memcpy(&esco_adc_file_g.cfg, &esco_adc_f.cfg, sizeof(struct adc_file_cfg));
#if TCFG_AUDIO_ANC_ENABLE &&  (defined CONFIG_CPU_BR28)
    if (!esco_adc_file_g.fixed_buf) {
        //JL701 ANC开启ADC必须固定buffer /中断点数
        if (esco_adc_file_g.cfg.mic_en_map & AUDIO_ADC_MIC_0) {
            esco_adc_file_g.fixed_ch_num++;
        }
        if (esco_adc_file_g.cfg.mic_en_map & AUDIO_ADC_MIC_1) {
            esco_adc_file_g.fixed_ch_num++;
        }
        if (esco_adc_file_g.cfg.mic_en_map & AUDIO_ADC_MIC_2) {
            esco_adc_file_g.fixed_ch_num++;
        }
        if (esco_adc_file_g.cfg.mic_en_map & AUDIO_ADC_MIC_3) {
            esco_adc_file_g.fixed_ch_num++;
        }
        if (!adc_hdl.hw_buf) {
            u8 adc_num = adc_hdl.max_adc_num;
#if defined(TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN) && TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
            adc_num = adc_hdl.max_adc_num > get_icsd_adt_mic_num() ? adc_hdl.max_adc_num : get_icsd_adt_mic_num();
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
            esco_adc_file_g.fixed_buf = malloc(ESCO_ADC_BUF_NUM * 256 * ((adc_hdl.bit_width == ADC_BIT_WIDTH_16) ? 2 : 4) * adc_num);
        }
    }
#endif/*TCFG_AUDIO_ANC_ENABLE && CONFIG_CPU_BR28*/
}

void audio_adc_fixed_digital_set_buffs(void)
{
    audio_adc_mic_set_buffs(NULL, esco_adc_file_g.fixed_buf, 256 * 2, ESCO_ADC_BUF_NUM);
    audio_adc_set_buf_fix(1, &adc_hdl);
}

void audio_all_adc_file_init(void)
{
#if 0
    int subid = 0;
    char node_name[16];
    struct adc_file_cfg adc_cfg;
    for (subid = 0; subid < 0xff; subid++) { //遍历所有adc节点来获取累计开了多少路mic
        if (jlstream_read_node_data_new(NODE_UUID_ADC, subid, &adc_cfg, node_name)) {
            adc_file_log("read adc cfg :%d,%x,%s,%x\n", __LINE__, subid, node_name, adc_cfg.mic_en_map);
            for (int i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
                if (adc_cfg.mic_en_map & BIT(i)) {
                    audio_adc_add_ch(&adc_hdl, i);
                }
            }
        }
    }
#else
    for (int i = 0; i < AUDIO_ADC_MAX_NUM; i++) { //默认按最大通道开ADC 数字
        audio_adc_add_ch(&adc_hdl, i);
    }
#endif
}

void audio_adc_file_init(void)  //通话的ADC节点配置
{
    u32 i;
    if (!esco_adc_f.read_flag) {
        esco_adc_f.hdl = NULL;
        /*
         *解析配置文件内效果配置
         * */
        int len;
        char mode_index = 0;
        char cfg_index = 0;//目标配置项序号
        struct cfg_info info = {0};
        if (!jlstream_read_form_node_info_base(mode_index, "esco_adc", cfg_index, &info)) {
            len = jlstream_read_form_cfg_data(&info, &esco_adc_f.cfg);
        } else {
            len = 0;
        }

        if (len != sizeof(struct adc_file_cfg)) {
            printf("esco_adc_file read cfg data err !!!\n");
            /* while (1); */
        }
        memcpy(&esco_adc_f.platform_cfg, adc_platform_cfg_table, sizeof(struct adc_platform_cfg) * AUDIO_ADC_MAX_NUM);

        adc_file_log(" %s len %d, sizeof(cfg) %d\n", __func__,  len, (int)sizeof(struct adc_file_cfg));

#if 0
        adc_file_log(" esco_adc_f.cfg.mic_en_map = %x\n", esco_adc_f.cfg.mic_en_map);
        for (i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
            adc_file_log(" esco_adc_f.cfg.param[%d].mic_gain      = %d\n", i, esco_adc_f.cfg.param[i].mic_gain);
            adc_file_log(" esco_adc_f.cfg.param[%d].mic_pre_gain  = %d\n", i, esco_adc_f.cfg.param[i].mic_pre_gain);
        }
#endif
        esco_adc_f.read_flag = 1;
        for (i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
            if (esco_adc_f.cfg.mic_en_map & BIT(i)) {
                audio_adc_add_ch(&adc_hdl, i);
            }
        }
    }

    /* audio_all_adc_file_init(); */
    audio_adc_file_global_cfg_init();
}

void audio_adc_cfg_init(struct adc_file_common *adc_f)  //通话外其他ADC节点读配置
{
    if (!adc_f->read_flag) {
        /* adc_f->hdl = NULL; */
        /*
         *解析配置文件内效果配置
         * */
        int len = sizeof(adc_f->cfg);
        char mode_index = 0;
        char cfg_index = 0;//目标配置项序号
        struct cfg_info info = {0};
        if (!jlstream_read_form_node_info_base(mode_index, adc_f->hdl->name, cfg_index, &info)) {
            jlstream_read_form_cfg_data(&info, &adc_f->cfg);
        } else {
            len = 0;
        }
        if (len != sizeof(struct adc_file_cfg)) {
            printf("adc_file read cfg data err !!!\n");
        }
        memcpy(&adc_f->platform_cfg, adc_platform_cfg_table, sizeof(struct adc_platform_cfg) * AUDIO_ADC_MAX_NUM);
        adc_file_log(" %s len %d, sizeof(cfg) %d\n", __func__,  len, (int)sizeof(struct adc_file_cfg));
        u32 i;
#if 0
        adc_file_log(" adc_f->cfg.mic_en_map = %x\n", adc_f->cfg.mic_en_map);
        for (i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
            adc_file_log(" adc_f->cfg.param[%d].mic_gain      = %d\n", i, adc_f->cfg.param[i].mic_gain);
            adc_file_log(" adc_f->cfg.param[%d].mic_pre_gain  = %d\n", i, adc_f->cfg.param[i].mic_pre_gain);
        }
#endif

        adc_f->hdl->ch_num = 0;
        adc_f->read_flag = 1;
        for (i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
            if (adc_f->cfg.mic_en_map & BIT(i)) {
                audio_adc_add_ch(&adc_hdl, i);
                adc_f->hdl->ch_num++;
            }
        }
    }
}

void audio_adc_file_set_gain(u8 mic_index, u8 mic_gain)
{
    if (mic_index > AUDIO_ADC_MAX_NUM) {
        adc_file_log("mic_index[%d] err !!!", mic_index);
    }
    esco_adc_f.cfg.param[mic_index].mic_gain = mic_gain;
    if (esco_adc_f.hdl) {
        audio_adc_mic_set_gain(&esco_adc_f.hdl->mic_ch, BIT(mic_index), mic_gain);
    }
}

u8 audio_adc_file_get_gain(u8 mic_index)
{
    audio_adc_file_init();	//如果获取的时候没有初始化，则跑初始化流程

    return esco_adc_f.cfg.param[mic_index].mic_gain;
}

u8 audio_adc_file_get_mic_mode(u8 mic_index)
{
    audio_adc_file_init();	//如果获取的时候没有初始化，则跑初始化流程
    return esco_adc_f.platform_cfg[mic_index].mic_mode;
}

/**
 * @brief       MIC 的中断回调函数
 *
 * @param _hdl  MIC 节点的操作句柄
 * @param data  MIC 中断采集到的数据地址
 * @param len   MIC 单个通道中断采集到的数据字节长度
 */
static void adc_mic_output_handler(void *_hdl, s16 *data, int len)
{
    struct adc_file_hdl *hdl = (struct adc_file_hdl *)_hdl;
    struct stream_frame *frame;
    /* printf(">> %d %d\n", data[0], data[1]); */

    if (hdl->dump_cnt < 10) {
        hdl->dump_cnt++;
        return;
    }

#if defined(TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN) && TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
    u8 esco_mic_num = audio_adc_file_get_esco_mic_num();
    u8 adt_mic_num = audio_anc_adt_mic_ch_num_get();
    /* 1mic通话，2mic/3mic免摘
     * 2mic通话，3mic免摘*/
    if (esco_mic_num < adt_mic_num) {
        for (int i = 0; i < len / 2; i++) {
            memcpy(&data[esco_mic_num * i], &data[adt_mic_num * i], esco_mic_num * sizeof(short));
        }
    }
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/

    frame = source_plug_get_output_frame(hdl->source_node, (len * hdl->ch_num));
    if (hdl->scene == STREAM_SCENE_ESCO ||
        hdl->scene == STREAM_SCENE_PC_MIC ||
        (hdl->scene == STREAM_SCENE_AI_VOICE)) {	//cvp读dac 参考数据
#if TCFG_AUDIO_DUT_ENABLE
        //打开产测功能，只有算法模式，才会读dac参考数据，避免 data full
        if (cvp_dut_mode_get() == CVP_DUT_MODE_ALGORITHM) {
            audio_cvp_phase_align();
        }
#else
        audio_cvp_phase_align();
#endif
    }
    if (frame) {
#ifdef TCFG_AUDIO_ADC_ENABLE_ALL_DIGITAL_CH
        //ADC DIGITAL 按最大通道数开启时使用
        if (hdl->ch_num != adc_hdl.max_adc_num) {
#else
        if (0) {
#endif
            /* printf("l:%d,%d,%d\n",hdl->adc_seq,hdl->ch_num,adc_hdl.max_adc_num); */
            if (adc_hdl.bit_width != ADC_BIT_WIDTH_16) {
                s32 *s32_src = (s32 *)data;
                s32 *s32_dst = (s32 *)frame->data;
                for (int i = 0; i < len / 4; i++) {
                    for (int j = 0; j < hdl->ch_num; j++) {
                        s32_dst[hdl->ch_num * i + j] = s32_src[adc_hdl.max_adc_num * i + hdl->adc_seq + j];
                    }
                }
            } else {
                s16 *s16_src = data;
                s16 *s16_dst = (s16 *)frame->data;
                for (int i = 0; i < len / 2; i++) {
                    for (int j = 0; j < hdl->ch_num; j++) {
                        s16_dst[hdl->ch_num * i + j] = s16_src[adc_hdl.max_adc_num * i + hdl->adc_seq + j];
                    }
                }
            }
        } else {
            memcpy(frame->data, data, (len * hdl->ch_num));
        }
        len *= hdl->ch_num;
        if (audio_common_mic_mute_en_get()) {	//mute ADC
            memset((u8 *)frame->data, 0x0, len);
        }
        frame->len          = len;
        frame->flags        = FRAME_FLAG_TIMESTAMP_ENABLE | FRAME_FLAG_PERIOD_SAMPLE | FRAME_FLAG_UPDATE_TIMESTAMP;
        frame->timestamp    = audio_jiffies_usec() * TIMESTAMP_US_DENOMINATOR;
        source_plug_put_output_frame(hdl->source_node, frame);
    }
}

static void *adc_init(void *source_node, struct stream_node *node)
{
    struct adc_file_hdl *hdl = zalloc(sizeof(*hdl));
    hdl->source_node = source_node;
    hdl->node = node;
    node->type |= NODE_TYPE_IRQ;


#if ((defined TCFG_CALL_KWS_SWITCH_ENABLE) && TCFG_CALL_KWS_SWITCH_ENABLE)
    extern void smart_voice_mcu_mic_suspend();
    smart_voice_mcu_mic_suspend();
#endif

    return hdl;
}

static void adc_ioc_get_fmt(struct adc_file_hdl *hdl, struct stream_fmt *fmt)
{
    fmt->coding_type = AUDIO_CODING_PCM;

    switch (hdl->scene) {
    case STREAM_SCENE_ESCO:
#if SUPPORT_CHAGE_AUDIO_CLK
        fmt->sample_rate    = audio_common_clock_get() ? 17778 : 16000;
#else
        fmt->sample_rate    = 16000;
#endif
        fmt->channel_mode   = AUDIO_CH_MIX;
        break;
#if TCFG_USB_SLAVE_AUDIO_MIC_ENABLE
    case STREAM_SCENE_PC_MIC:
        fmt->sample_rate    = pc_mic_get_fmt_sample_rate();
        fmt->channel_mode   = AUDIO_CH_MIX;
        break;
#endif
    case STREAM_SCENE_HEARING_AID:
#ifdef TCFG_AUDIO_HEARING_AID_SAMPLE_RATE
        fmt->sample_rate = TCFG_AUDIO_HEARING_AID_SAMPLE_RATE;
#else
        fmt->sample_rate = 44100;
#endif
        fmt->channel_mode   = (hdl->ch_num == 2) ? AUDIO_CH_LR : AUDIO_CH_MIX ;
        break;
    default:
#if SUPPORT_CHAGE_AUDIO_CLK
        fmt->sample_rate    = audio_common_clock_get() ? 49000 : 44100;
#else
        fmt->sample_rate    = 44100;
#endif
        fmt->channel_mode   = (hdl->ch_num == 2) ? AUDIO_CH_LR : AUDIO_CH_MIX ;
        break;
    }
    hdl->sample_rate = fmt->sample_rate;

    if (adc_hdl.bit_width == ADC_BIT_WIDTH_24) {
        fmt->bit_wide = DATA_BIT_WIDE_24BIT;
    } else {
        fmt->bit_wide = DATA_BIT_WIDE_16BIT;
    }
}

static int adc_ioc_set_fmt(struct adc_file_hdl *hdl, struct stream_fmt *fmt)
{
    hdl->sample_rate = fmt->sample_rate;
    return 0;
}

int adc_file_mic_open(struct adc_mic_ch *mic, int ch) //用于打开通话使用的mic
{
    struct mic_open_param mic_param = {0};
    int mic_gain;
    int mic_pre_gain;
    int ch_index;

    u32 i = 0;
    for (i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
        if (ch & BIT(i)) {
            ch_index = i;

            audio_adc_param_fill(&mic_param, &esco_adc_f.platform_cfg[ch_index]);
            mic_gain                = esco_adc_f.cfg.param[ch_index].mic_gain;
            mic_pre_gain            = esco_adc_f.cfg.param[ch_index].mic_pre_gain;

            if ((mic_param.mic_bias_sel == 0) && (esco_adc_f.platform_cfg[ch_index].power_io != 0)) {
                u32 gpio = uuid2gpio(esco_adc_f.platform_cfg[ch_index].power_io);
                gpio_set_mode(IO_PORT_SPILT(gpio), PORT_OUTPUT_HIGH);
            }

            audio_adc_mic_open(mic, AUDIO_ADC_MIC(ch_index), &adc_hdl, &mic_param);
            audio_adc_mic_set_gain(mic, AUDIO_ADC_MIC(ch_index), mic_gain);
            audio_adc_mic_gain_boost(AUDIO_ADC_MIC(ch_index), mic_pre_gain);
        }
    }
    return 0;
}

int adc_file_cfg_mic_open(struct adc_mic_ch *mic, int ch, struct adc_file_common *adc_f) //用于打开通话外其他mic
{
    struct mic_open_param mic_param = {0};
    int mic_gain;
    int mic_pre_gain;
    int ch_index;

    u32 i = 0;
    for (i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
        if (ch & BIT(i)) {
            ch_index = i;

            audio_adc_param_fill(&mic_param, &adc_f->platform_cfg[ch_index]);
            mic_gain                = adc_f->cfg.param[ch_index].mic_gain;
            mic_pre_gain            = adc_f->cfg.param[ch_index].mic_pre_gain;

            if ((mic_param.mic_bias_sel == 0) && (adc_f->platform_cfg[ch_index].power_io != 0)) {
                u32 gpio = uuid2gpio(adc_f->platform_cfg[ch_index].power_io);
                gpio_set_mode(IO_PORT_SPILT(gpio), PORT_OUTPUT_HIGH);
            }

            audio_adc_mic_open(mic, AUDIO_ADC_MIC(ch_index), &adc_hdl, &mic_param);
            audio_adc_mic_set_gain(mic, AUDIO_ADC_MIC(ch_index), mic_gain);
            audio_adc_mic_gain_boost(AUDIO_ADC_MIC(ch_index), mic_pre_gain);
        }
    }
    return 0;
}

static u8 adc_mic_start = 0;

static void adc_open_task(void *_hdl)
{
    struct adc_file_hdl *hdl = (struct adc_file_hdl *)_hdl;

    /*y_printf("adc_mic_start\n");*/

    audio_adc_mic_start(&hdl->mic_ch);
    adc_mic_start = 1;

    while (1) {
        os_time_dly(0xffff);
    }

}

static int adc_file_ioc_start(struct adc_file_hdl *hdl)
{
    int ret = 0;
    /*
     *获取配置文件内的参数,及名字
     * */
    if (hdl->scene == STREAM_SCENE_ESCO) {
        hdl->adc_f = &esco_adc_f;
    } else if (!hdl->adc_f) {
        hdl->adc_f = zalloc(sizeof(struct adc_file_common));
    }
    hdl->adc_f->hdl = hdl;
    if (!jlstream_read_node_data_new(NODE_UUID_ADC, hdl->node->subid, (void *) & (hdl->adc_f->cfg), hdl->name)) {
        printf("%s, read node data err\n", __FUNCTION__);
        return -1;
    }

#if TCFG_AUDIO_DUT_ENABLE
    //产测bypass 模式，MIC的使能位从产测命令读取
    if (cvp_dut_mode_get() == CVP_DUT_MODE_BYPASS) {
        hdl->adc_f->cfg.mic_en_map = cvp_dut_mic_ch_get();
    }
#endif
    if (hdl->scene != STREAM_SCENE_ESCO) {
        audio_adc_cfg_init(hdl->adc_f);
    } else { //初始化通话通道数
        hdl->ch_num = 0;
        for (int i = 0; i < AUDIO_ADC_MIC_MAX_NUM; i++) {
            if (hdl->adc_f->cfg.mic_en_map & BIT(i)) {
                hdl->ch_num++;
            }
        }
    }

    if (jlstream_read_effects_online_param(NODE_UUID_ADC, hdl->name, &hdl->adc_f->cfg, sizeof(hdl->adc_f->cfg))) {
        adc_file_log("get adc online param\n");
    }
    if (hdl->start == 0) {
        hdl->start = 1;
        hdl->dump_cnt = 0;
        //不启动ANC动态MIC增益时，由用户自己保证ANC与通话复用的ADC增益一致
#if TCFG_AUDIO_ANC_ENABLE && TCFG_AUDIO_DYNAMIC_ADC_GAIN
#if (!TCFG_AUDIO_DUAL_MIC_ENABLE && (TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_1)) || \
		(TCFG_AUDIO_DUAL_MIC_ENABLE && (TCFG_AUDIO_DMS_MIC_MANAGE == DMS_MASTER_MIC0))
        anc_dynamic_micgain_start(hdl->adc_f->cfg.param[1].mic_gain);
#else
        anc_dynamic_micgain_start(hdl->adc_f->cfg.param[0].mic_gain);
#endif/*TCFG_AUDIO_DUAL_MIC_ENABLE*/
#endif/*TCFG_AUDIO_ANC_ENABLE && TCFG_AUDIO_DYNAMIC_ADC_GAIN*/

        //br50的LPADC需要根据采样率配置模拟部分的时钟分频,需要先设置采样率才能打开MIC
        audio_adc_mic_set_sample_rate(&hdl->mic_ch, hdl->sample_rate);
        adc_file_cfg_mic_open(&hdl->mic_ch, hdl->adc_f->cfg.mic_en_map, (void *)hdl->adc_f);

        if (esco_adc_file_g.fixed_buf) {
            hdl->adc_buf = esco_adc_file_g.fixed_buf;
            audio_adc_set_buf_fix(1, &adc_hdl);
        }
        if (!hdl->adc_buf && !adc_hdl.hw_buf) {	//避免没有设置ADC的中断点数，以及数据流stop之后重新start申请buffer
            if (!hdl->irq_points) {
                hdl->irq_points = 256;
            }
            hdl->adc_buf = zalloc(ESCO_ADC_BUF_NUM * hdl->irq_points * ((adc_hdl.bit_width == ADC_BIT_WIDTH_16) ? 2 : 4) * (adc_hdl.max_adc_num));
            if (!hdl->adc_buf) {
                ret = -1;
                return ret;
            }
        }
        ret = audio_adc_mic_set_buffs(&hdl->mic_ch, hdl->adc_buf, hdl->irq_points * 2, ESCO_ADC_BUF_NUM);
        if (ret && hdl->adc_buf) {
            free(hdl->adc_buf);
            hdl->adc_buf = NULL;
        }

        hdl->adc_output.priv    = hdl;
        hdl->adc_output.handler = adc_mic_output_handler;
        audio_adc_add_output_handler(&adc_hdl, &hdl->adc_output);
#ifdef CONFIG_CPU_BR36
        /*r_printf("-----create_adc_open_task\n");*/
        adc_mic_start = 0;
        int err = os_task_create(adc_open_task, hdl, 2, 512, 0, "adc_open");
        if (err) {
            adc_mic_start = 1;
            audio_adc_mic_start(&hdl->mic_ch);
        }
#else
        audio_adc_mic_start(&hdl->mic_ch);
#endif
    }
    return ret;
}

static int adc_file_ioc_stop(struct adc_file_hdl *hdl)
{
    if (hdl->start) {
        hdl->start = 0;
#if TCFG_AUDIO_ANC_ENABLE && TCFG_AUDIO_DYNAMIC_ADC_GAIN
        anc_dynamic_micgain_stop();
#endif

#ifdef CONFIG_CPU_BR36
        while (adc_mic_start == 0) {
            os_time_dly(1);
            /*puts("--wait\n");*/
        }
        /*r_printf("-----del_adc_open_task\n");*/
        os_task_del("adc_open");
#endif
        audio_adc_mic_close(&hdl->mic_ch);
        if (!esco_adc_file_g.fixed_buf) {
            hdl->adc_buf = NULL; //在adc 驱动中释放了这个buffer
        }
        audio_adc_del_output_handler(&adc_hdl, &hdl->adc_output);

        for (u32 i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
            if (hdl->adc_f->cfg.mic_en_map & BIT(i)) {
                if ((hdl->adc_f->platform_cfg[i].mic_bias_sel == 0) && (hdl->adc_f->platform_cfg[i].power_io != 0)) {
                    if (!audio_adc_is_active()) {
                        u32 gpio = uuid2gpio(hdl->adc_f->platform_cfg[i].power_io);
                        gpio_set_mode(IO_PORT_SPILT(gpio), PORT_OUTPUT_LOW);
                    }
                }
            }
        }

    }
    return 0;
}

static int adc_file_ioc_update_parm(struct adc_file_hdl *hdl, int parm)
{
    int i;
    int ret = false;
    struct adc_file_cfg *cfg = (struct adc_file_cfg *)parm;
    if (hdl) {
        for (i = 0; i < AUDIO_ADC_MAX_NUM; i++) {
            if (hdl->adc_f->cfg.mic_en_map & BIT(i)) {
                //目前仅支持更新增益
                audio_adc_mic_set_gain(&hdl->mic_ch, BIT(i), cfg->param[i].mic_gain);
                audio_adc_mic_gain_boost(BIT(i), cfg->param[i].mic_pre_gain);
            }
        }
        ret = true;
    }
    return ret;
}

static int adc_ioctl(void *_hdl, int cmd, int arg)
{
    int ret = 0;
    struct adc_file_hdl *hdl = (struct adc_file_hdl *)_hdl;

    switch (cmd) {
    case NODE_IOC_GET_FMT:
        adc_ioc_get_fmt(hdl, (struct stream_fmt *)arg);
        break;
    case NODE_IOC_SET_FMT:
        ret = adc_ioc_set_fmt(hdl, (struct stream_fmt *)arg);
        break;
    case NODE_IOC_SET_SCENE:
        hdl->scene = arg;
        break;
    case NODE_IOC_SET_PRIV_FMT:
        hdl->irq_points = arg;
        break;
    case NODE_IOC_START:
        ret = adc_file_ioc_start(hdl);
        hdl->adc_seq = get_adc_seq(&adc_hdl, hdl->adc_f->cfg.mic_en_map); //查询模拟mic对应的ADC通道
        break;
    case NODE_IOC_SUSPEND:
    case NODE_IOC_STOP:
        adc_file_ioc_stop(hdl);
        break;
    case NODE_IOC_SET_PARAM:
        ret = adc_file_ioc_update_parm(hdl, arg);
        break;
    case NODE_IOC_NODE_CONFIG:
        hdl->ch_num = (u8)arg;
        break;
    }

    return ret;
}

static void adc_release(void *_hdl)
{
    struct adc_file_hdl *hdl = (struct adc_file_hdl *)_hdl;
    if (hdl->adc_f && hdl->scene != STREAM_SCENE_ESCO) {
        free(hdl->adc_f);
        hdl->adc_f = NULL;
    }
    free(hdl);
    esco_adc_f.hdl = NULL;
}


REGISTER_SOURCE_NODE_PLUG(adc_file_plug) = {
    .uuid       = NODE_UUID_ADC,
    .init       = adc_init,
    .ioctl      = adc_ioctl,
    .release    = adc_release,
};

REGISTER_ONLINE_ADJUST_TARGET(adc) = {
    .uuid = NODE_UUID_ADC,
};