bt_rf_PA_control_io_remap(IO_PORTB_06,IO_PORTB_07); //701N 有其他芯片可能没有这个   txen->PB6

// wav最大支持比特率，单位kbps
const int WAV_MAX_BITRATEV = (48 * 2 * 12);
//  支持的最大采样率
const int CONFIG_DEC_SUPPORT_SAMPLERATE = 96000; 

// const u16 llns_frame_size[4][2] = {
//     {16000, 80},
//     {32000, 160},
//     {44100, 220},
//     {48000, 240},
// };

u8 tar = nor_label;
music_mode[tar].eq_parm.global_gain = global_gain_tab[eq_mode];
music_mode[tar].eq_parm.seg_num = ARRAY_SIZE(eq_tab_normal);
memcpy(music_mode[tar].eq_parm.seg, seg, sizeof(eq_tab_normal));

__set_sbc_cap_bitpool(53); //35~53之间，音箱建议直接设置为53
__set_aac_bitrate(320 * 1000);//范围131k~320K

#if AUDIO_VOCAL_REMOVE_EN
    mix_vocal_remove_hdl = vocal_remove_open(ch_num, sr, 100, 200, 13000);
    u8 dac_connect_mode =  TCFG_AUDIO_DAC_CONNECT_MODE;
    if (dac_connect_mode == DAC_OUTPUT_MONO_L) {
        vocal_remove_mix_ch_switch = channel_switch_open(AUDIO_CH_DIFF, 0);
    } else if (dac_connect_mode == DAC_OUTPUT_MONO_R) {
        vocal_remove_mix_ch_switch = channel_switch_open(AUDIO_CH_DIFF, 0);
    }
#endif

#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_MONO_LR_DIFF)
    // mic_data_viewer = audio_data_viewer_open(mic_data_viewer_callback);
    // mic_data_viewer_entry = audio_data_viewer_entry_get(mic_data_viewer);

    extern void last_data_viewer_callback(u8 ch, s16 *data, u32 len);
    mic_data_viewer = audio_data_viewer_open(last_data_viewer_callback);
    mic_data_viewer_entry = audio_data_viewer_entry_get(mic_data_viewer);
#endif

static void pcm_LR_to_DUAL_DIFF_32(s32 *pcm_lr, s32 *pcm_dual_diff, int points_per_ch)
{
    s32 pcm_L;
    s32 pcm_R;
    s32 pcm_diff;
    int i = 0;

    for (i = 0; i < points_per_ch; i++, pcm_lr += 2) {
        pcm_L = *pcm_lr;
        pcm_R = *(pcm_lr + 1);
        pcm_diff = (s32)(((int)pcm_L + pcm_R) >> 1);
        *pcm_dual_diff++ = pcm_diff;
        *pcm_dual_diff++ = -pcm_diff;
        // *pcm_dual_diff++ = (pcm_diff == -8388608) ? (8388607) : (-pcm_diff);
        *pcm_dual_diff = data_sat_s24(*pcm_dual_diff);
    }
}
void last_data_viewer_callback(u8 ch, s16 *data, u32 len)
{
    if (global_bit_wide) {
        pcm_LR_to_DUAL_DIFF_32((s32 *)data, (s32 *)data, len / 2 / 2 / 2);
    } else {
        pcm_LR_to_DUAL_DIFF(data, data, len / 2 / 2);
    }
}

/*
 *DAC 位宽(bit width)配置
 *16bit：DAC_16BIT_MODE
 *24bit：DAC_24BIT_MODE
 * */
#define TCFG_AUDIO_DAC_BIT_WIDTH           DAC_16BIT_MODE

static void pcm_LR_to_DUAL_DIFF_32(s32 *pcm_lr, s32 *pcm_dual_diff, int points_per_ch)
{
    s32 pcm_L;
    s32 pcm_R;
    s32 pcm_diff;
    int i = 0;

    for (i = 0; i < points_per_ch; i++, pcm_lr += 2) {
        pcm_L = *pcm_lr;
        pcm_R = *(pcm_lr + 1);
        pcm_diff = (s32)(((int)pcm_L + pcm_R) >> 1);
        
        // s32 *cur_addr = pcm_dual_diff;

        *pcm_dual_diff++ = pcm_diff;
        // *pcm_dual_diff++ = -pcm_diff;
        // *cur_addr = data_sat_s24(*cur_addr);

        *pcm_dual_diff++ = (pcm_diff == PCM_24BIT_SAT_MIN) ? (PCM_24BIT_SAT_MAX) : (-pcm_diff);
    }
}

static void pcm_LR_to_DUAL_DIFF_32(s32 *pcm_lr, s32 *pcm_dual_diff, int points_per_ch)
{
    s32 pcm_L;
    s32 pcm_R;
    s32 pcm_diff;
    int i = 0;

    for (i = 0; i < points_per_ch; i++, pcm_lr += 2) {
        pcm_L = *pcm_lr;
        pcm_R = *(pcm_lr + 1);
        pcm_diff = (s32)(((int)pcm_L + pcm_R) >> 1);
        *pcm_dual_diff++ = pcm_diff;
        // *pcm_dual_diff++ = -pcm_diff;
        // *pcm_dual_diff = data_sat_s24(*pcm_dual_diff);
        *pcm_dual_diff++ = (pcm_diff == PCM_24BIT_SAT_MIN) ? (PCM_24BIT_SAT_MAX) : (-pcm_diff);
    }
}

#if defined(TCFG_AUDIO_ADC_BIT_MODE)&&ADC_BIT_WIDTH_24&&(TCFG_AUDIO_ADC_BIT_MODE == ADC_BIT_WIDTH_24)
    dec->pcm_dec.bit_wide = global_bit_wide;
#endif

struct pcm_decoder {
    u16 ch_num : 4;            // 声道数
    u16 output_ch_num : 4;    // 输出声道数
    u16 output_ch_type : 4;    // 输出声道类型
    u16 dec_no_out_sound : 1;    // 解码不直接输出声音（用于TWS转发）
    u16 bit_wide;
    u32 sample_rate;    // 采样率
    struct audio_decoder decoder;    // 解码句柄
    void *read_priv;    // 数据获取私有句柄
    int (*read_data)(void *priv, void *buf, int len);    // 数据获取
};

//bit_wide 0:16bit  1:32bit
channel_switch_set_bit_wide(vocal_remove_mix_ch_switch, 1);

static u8 vocal_remove_status = 0;
vocal_remove_hdl *a2dp_vocal_remove_hdl = NULL;
vocal_remove_hdl *linein_vocal_remove_hdl = NULL;
vocal_remove_hdl *music_file_vocal_remove_hdl = NULL;

//开关人声消除算法
void vocal_remove_switch(u8 sw)
{
    printf("----------------->>>>>sw:%d\n",sw);
    local_irq_disable();
    vocal_remove_status = sw;

    if(a2dp_vocal_remove_hdl){
        audio_vocal_remove_sw(a2dp_vocal_remove_hdl, !sw);
    }
    if(linein_vocal_remove_hdl){
        audio_vocal_remove_sw(linein_vocal_remove_hdl, !sw);
    }
    if(music_file_vocal_remove_hdl){
        audio_vocal_remove_sw(music_file_vocal_remove_hdl, !sw);
    }
    local_irq_enable();
}

//获取开关状态
u8 vocal_remove_get_status(void)
{
   return vocal_remove_status;
}

//设置开关状态
void vocal_remove_set_status(u8 ste)
{
    vocal_remove_status = ste;
}

static bool can_read_data = 0;

AT(.fm_data_code)
int linein_sample_read(void *hdl, void *data, int len)
{
    struct linein_sample_hdl *linein = (struct linein_sample_hdl *)hdl;
#if 0
// no wait
    u8 count = 0;
__retry:
    if (cbuf_get_data_size(&linein->cbuf) < len) {
        local_irq_disable();
        os_sem_set(&linein->sem, 0);
        local_irq_enable();
        os_sem_pend(&linein->sem, 2);
        if (cbuf_get_data_size(&linein->cbuf) < len) {
            if (++count > 4) {
                return 0;
            }
            goto __retry;
        }

    }
#endif
    u16 point_offset = 1;
#if defined(TCFG_AUDIO_ADC_BIT_MODE)&&ADC_BIT_WIDTH_24&&(TCFG_AUDIO_ADC_BIT_MODE == ADC_BIT_WIDTH_24)
    point_offset = 2;
#endif
    u32 tlen = ADC_LINEIN_IRQ_POINTS << point_offset * linein->channel_num;
    if (tlen > len) {
        tlen = len;
    }
    
#if 1
    int cbuf_data_len = cbuf_get_data_len(&linein->cbuf);
    printf("cbuf_data_len=%d,total=%d",cbuf_data_len,linein->cbuf.total_len);
    if(!(cbuf_data_len < linein->cbuf.total_len * 1 /4)) {
        //缓冲数据少于1/2,不读取数据，等缓冲
        can_read_data = 1;
        putchar('y');
    } else {
        putchar('x');
    }

    if(can_read_data) {
        int rlen = cbuf_read(&linein->cbuf, data, tlen);
    // printf("tlen=%d,len=%d,rlen=%d",tlen,len,rlen);
        local_irq_disable();
        if (rlen < tlen) {
            linein->wait_resume = 1;
        }
        local_irq_enable();

        return rlen;
    } else {
        memset(data, 0x00, len);
        return len;
    }
    
#else    
    int cbuf_data_len = cbuf_get_data_len(&linein->cbuf);
    printf("cbuf_data_len=%d",cbuf_data_len);
    int rlen = cbuf_read(&linein->cbuf, data, tlen);
    // printf("tlen=%d,len=%d,rlen=%d",tlen,len,rlen);



    local_irq_disable();
    if (rlen < tlen) {
        linein->wait_resume = 1;
    }
    local_irq_enable();

    return rlen;
#endif
}

    if (music_mode_seq0 != mode_id){
        return 0;
    }

#define RECORDER_MIX_EN    ENABLE//混合录音使能, 需要录制例如蓝牙、FM、 LINEIN才开
#define TCFG_MIC_EFFECT_ENABLE    ENABLE

#define TCFG_REVERB_SAMPLERATE_DEFUAL (48000)
#define MIC_EFFECT_SAMPLERATE            (48000)

#if defined(EXT_HP_LP_SECTIONS) && EXT_HP_LP_SECTIONS
extern const struct eq_seg_info eq_tab_normal[10+EXT_HP_LP_SECTIONS];
#else
extern const struct eq_seg_info eq_tab_normal[10];
#endif

NOISEGATE_API_STRUCT *audio_noisegate_open_demo(u32 ns_name, u32 sample_rate, u32 ch_num)
{
    u8 ns_gate_bit_width = global_bit_wide?1:0;
#if AUDIO_NOISE_GATE_ENABLE
    NoiseGateParam_TOOL_SET *parm = NULL;
 
#if MUSIC_NOISE_GATE_EN
    if (ns_name == AEID_MUSIC_NS_GATE) {
        parm = &music_noisegate_parm[nor_label];
        #if AUDIO_VBASS_32BIT_OUT_EN
        ns_gate_bit_width = 1;
        #endif
    } else if (ns_name == AEID_AUX_NS_GATE) {
        parm = &music_noisegate_parm[aux_label];
        #if AUDIO_VBASS_32BIT_OUT_EN
        ns_gate_bit_width = 1;
        #endif
    }
#endif
#if defined(TCFG_MIC_EFFECT_ENABLE) && TCFG_MIC_EFFECT_ENABLE
    if (ns_name == AEID_MIC_NS_GATE) {
        u8 mode = get_mic_eff_mode();
        struct eff_parm *mic_eff = &eff_mode[mode];
        parm =  &mic_eff->noise_gate_parm;
    }
#endif
 
    if (!parm) {
        return NULL;
    }
    NoiseGateParam noisegate_parm = {0};
    noisegate_parm.attackTime = parm->parm.attackTime;
    noisegate_parm.releaseTime = parm->parm.releaseTime;
    noisegate_parm.threshold = parm->parm.threshold;
    noisegate_parm.low_th_gain = parm->parm.low_th_gain;
    noisegate_parm.sampleRate = sample_rate;
    noisegate_parm.channel = ch_num;
    noisegate_parm.pcm_info.IndataBit = ns_gate_bit_width;
    noisegate_parm.pcm_info.OutdataBit = ns_gate_bit_width;
    noisegate_parm.pcm_info.IndataInc = (ch_num == 1) ? 1 : 2;
    noisegate_parm.pcm_info.OutdataInc = (ch_num == 1) ? 1 : 2;
    noisegate_parm.pcm_info.Qval = global_bit_wide ? 23 : 15;
    NOISEGATE_API_STRUCT *hdl = audio_noisegate_open(ns_name,  &noisegate_parm);
    audio_noisegate_bypass(ns_name, parm->is_bypass);
    return hdl;
#else
    return NULL;
#endif
}

     u8 cnt = 0;
        while(alink_get_hwptr(iis->hw_ch) != alink_get_swptr(iis->hw_ch))
        {
            os_time_dly(1);
            cnt++;
            if(cnt>20)
            {
                break;
            }
        }

/*
 *DAC 位宽(bit width)配置
 *16bit：DAC_16BIT_MODE
 *24bit：DAC_24BIT_MODE
 * */
#define TCFG_AUDIO_DAC_BIT_WIDTH           DAC_24BIT_MODE

#define AUDIO_SPECTRUM_CONFIG         1  //频响能量值获取接口

static void esco_plc_run_32(s32 *data, u16 len, u8 repair)
{
    u16 repair_point, tmp_point;
    s16 tmp_buf[PLC_FRAME_LEN]; //24转16的临时buf
    tmp_point = len / 4;

#if 0    //debug
    static u16 repair_cnt = 0;
    if (repair) {
        repair_cnt++;
        y_printf("[E%d]", repair_cnt);
    } else {
        repair_cnt = 0;
    }
    //log_i("[%d]",point);
#endif/*debug*/
    while (tmp_point) {
        repair_point = (tmp_point > PLC_FRAME_LEN) ? PLC_FRAME_LEN : tmp_point;
        tmp_point = tmp_point - repair_point;
        audio_convert_data_32bit_to_16bit_round(data, tmp_buf, repair_point);
        PLC_run(tmp_buf, tmp_buf, repair_point, repair);
        audio_convert_data_16bit_to_32bit_round(tmp_buf, data, repair_point);
        data += repair_point;
    }
}

const char *bt_get_ble_name()
{
    return (const char *)(bt_cfg.ble_name);
}

const u8 CONST_AEC_DLY_EST = 0;

#if ((AUDIO_OUTPUT_WAY == AUDIO_OUTPUT_WAY_FM) || (TCFG_AEC_SIMPLEX))
    aec_param->dly_est = 0;
#else
    aec_param->dly_est = 0;
#endif

    uint32_t             pair_public_code;  //公共配对码
    uint32_t             pair_bind_code;    //要绑定的私有配对码
    uint16_t             pair_sw_time;      //公共配对码和私有配对码scan切换周期
    s8                   pair_rssi;         //配对功能允许的有效rssi范围

//如果编译报 config_bb_optimized_ctrl 未定义，在编译到的文件中添加定义
const int config_bb_optimized_ctrl=0;

void hw_close_dac(void)
{
    memset(JL_ADDA, 0x0, sizeof(JL_ADDA_TypeDef));
    SFR(JL_ADDA->DAA_CON2, 15,  1,  1);
    SFR(JL_ADDA->DAA_CON2,  5,  1,  1);
}

/**************************1*********************************/
static int a2dp_audio_is_underrun(struct a2dp_stream_control *ctrl)
{
    if(A2DP_STREAM_UNDERRUN == ctrl->stream_error){
        return true;
    }

/**************************2*********************************/
    if(frame->flags & FRAME_FLAG_FILL_PACKET){
        distance_time = 0;
    }

#include "stream/stream_jlsp_llns.h"
typedef struct {
    void *llns;
    u16 frame_size;//unit:point

} llns_hdl_t;
extern llns_hdl_t llns_hdl;
/*
 * gainfloor:调节底噪大小(0~1)
 * suppress_level:噪声抑制强度(0~6)
 */
void audio_llns_parm_update(float gainfloor, float suppress_level)
{
    llns_param_t parm = {0};
    parm.gainfloor = gainfloor;
    parm.suppress_level = suppress_level;
    if (llns_hdl.llns) {
        /* printf(">>> llns update %x", llns_hdl.llns); */
        /* printf("gainfloor %d, suppress_level %d", (int)parm.gainfloor, (int)parm.suppress_level); */
        JLSP_llns_set_parameters(llns_hdl.llns, &parm);
    }
}

void set_tx_mode(u8 set_mode_normal, u8 set_mode_dut);
set_tx_mode(1, 1);

//================================================//
//                  FS功能控制                       //
//================================================//
const int FATFS_GET_SPACE_USE_RAM = 32 * 1024;///0;//32 * 1024;  //获取剩余容量使用大Buf缓存,加快速度, 必须512倍数

        *(.jl_codec_c_sparse_code)
        *(.jl_codec_e_code)
        *(.jl_codec_d_code)
        *(.jl_codec_c_code)
        *(.jl_codec_ari_c_code)
        *(.jl_codec_c_const)
        *(.jl_codec_const)
        *(.jl_codec_t441k_code)

struct channel_switch *ch_switch;//声道变换

u8 ch_num = audio_output_channel_num(); //获取输出设备的声道数
r_printf("live_stream_player_start: dec_out_ch_num = %d, ch_num = %d\n", ctx->dec_out_ch_num, ch_num);
if (ctx->dec_out_ch_num != ch_num) {
    if (ctx->dec_out_ch_num == 1) {
        ctx->ch_switch = channel_switch_open(AUDIO_CH_LR, 0);
    } else {
        ctx->ch_switch = channel_switch_open(AUDIO_CH_DIFF, 0);
    }
}

if (ctx->ch_switch) {
    entries[entry_cnt++] = &ctx->ch_switch->entry;
}

channel_switch_close(&ctx->ch_switch);

const int config_btctler_bredr_master = 0;
u8 config_btctler_bredr_master_emitter = 1;

audio_way_set_sample_rate(AUDIO_OUT_WAY_TYPE,audio_output_nor_rate());
// audio_way_set_sample_rate(AUDIO_OUT_WAY_TYPE,48000);
audio_way_ioctrl(AUDIO_OUT_WAY_TYPE, SNDCTL_IOCTL_POWER_ON, NULL); 

int audio_adc_mode_set(u8 type, u16 sample_rate, u8 gain)
{
if (adc_mode_hdl == NULL) {
printf("%s %d hdl is NULL err !\n", __func__, __LINE__);
return -1;
}

if (adc_mode_hdl->ch[type].enable == 0) {
printf("audio_adc_mode_channel is not enable err!\n");
return -1;
}
adc_mode_hdl->sample_rate = sample_rate;
adc_mode_hdl->ch[type].gain = gain;
return 0;
}

int audio_linein_open(struct adc_linein_ch *linein, u16 sample_rate, int gain)
{
    printf("%s",__func__);
#if TCFG_AUDIO_ADC_ENABLE

    if (adc_mode_hdl == NULL) {
        printf("%s %d hdl is NULL err !\n", __func__, __LINE__);
        return -1;
    }
#if TCFG_MIC_EFFECT_ENABLE //开混响时启用多路AD
    audio_adc_mode_switch(ADC_LINEIN_MODE);
    
    //设置一下MIC的采样率以及增益
    extern int audio_adc_mode_set(u8 type, u16 sample_rate, u8 gain);
    audio_adc_mode_set(0,effect_mic_stream_parm_default.sample_rate,effect_mic_stream_parm_default.mic_gain);
#else
    adc_mode_hdl->ch[0].enable = 0;
    adc_mode_hdl->ch[1].enable = 1;
    adc_mode_hdl->ch[2].enable = 0;
#endif
    audio_adc_mode_channel_open(1, linein, sample_rate, gain);
    return 0;
#endif // #if TCFG_AUDIO_ADC_ENABLE
    return -1;
}

#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR || TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_DUAL_LR_DIFF || TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_MONO_LR_DIFF)
// #if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR || TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_DUAL_LR_DIFF)
#define DAC_OUTPUT_CHANNELS     2
#elif (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_L || TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_R || TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR_DIFF)
#define DAC_OUTPUT_CHANNELS     1
#elif (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_FRONT_LR_REAR_LR)
#define DAC_OUTPUT_CHANNELS     4
#else
#define DAC_OUTPUT_CHANNELS     3
#endif

#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_MONO_LR_DIFF)
void *mic_data_viewer_last = NULL;
void *mic_data_viewer_last_entry = NULL;

static void pcm_LR_to_DUAL_DIFF(s16 *pcm_lr, s16 *pcm_dual_diff, int points_per_ch)
{
    s16 pcm_L;
    s16 pcm_R;
    s16 pcm_diff;
    int i = 0;
    for (i = 0; i < points_per_ch; i++, pcm_lr += 2) {
        pcm_L = *pcm_lr;
        pcm_R = *(pcm_lr + 1);
        pcm_diff = (s16)(((int)pcm_L + pcm_R) >> 1);
        *pcm_dual_diff++ = pcm_diff;
        *pcm_dual_diff++ = (pcm_diff == -32768) ? (32767) : (-pcm_diff);
    }
}
static void last_data_viewer_callback(u8 ch, s16 *data, u32 len)
{
    pcm_LR_to_DUAL_DIFF(data, data, len / 2 / 2);
}
#endif

#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_MONO_LR_DIFF)
    mic_data_viewer_last = audio_data_viewer_open(last_data_viewer_callback);
    mic_data_viewer_last_entry = audio_data_viewer_entry_get(mic_data_viewer_last);

#endif

#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_MONO_LR_DIFF)
    if (mic_data_viewer_last_entry) {
        entries[entry_cnt++] = mic_data_viewer_last_entry;
    }
#endif

    ///初始化数字音量
    struct audio_stream_entry *dvol_entry;
    if (effect->parm.effect_config & BIT(MIC_EFFECT_CONFIG_DVOL)) {
        effect_dvol_default_parm.ch_total = ch_num;
#if defined(SYS_DIGVOL_GROUP_EN)&&SYS_DIGVOL_GROUP_EN
        dvol_entry = sys_digvol_group_ch_open("mic_mic", -1, &effect_dvol_default_parm);
        effect->d_vol = audio_dig_vol_group_hdl_get(sys_digvol_group, "mic_mic");
#else
        effect->d_vol = audio_dig_vol_open((audio_dig_vol_param *)&effect_dvol_default_parm);
        dvol_entry = audio_dig_vol_entry_get(effect->d_vol);
#endif /*SYS_DIGVOL_GROUP_EN*/
    }

  if(effect->d_vol) {
        printf("dvol_entry = %d",dvol_entry);
        entries[entry_cnt++] = dvol_entry;
    }

#include "sw_drc.h"
#if TCFG_DRC_ENABLE
static wdrc_struct_TOOL_SET mic_drc_parm[5];
#if (TCFG_MIC_EFFECT_SEL == MIC_EFFECT_REVERB_ECHO_ADVANCE)
static CrossOverParam_TOOL_SET last_crossover;
static wdrc_struct_TOOL_SET last_wdrc_parm[4];
#endif
#endif

void *mic_drc_open(u32 sample_rate, u8 ch_num, u8 drc_name)
{
#if (TCFG_MIC_EFFECT_SEL == MIC_EFFECT_REVERB_ECHO_ADVANCE)
    if(drc_name == AEID_MIC_DRC4) {
        struct  audio_drc_param_parm = {0};
        parm.channels = ch_num;
        parm.sr = sample_rate;
        parm.out_32bit = 1;
        parm.cb = drc_get_filter_info;
        parm.drc_name = drc_name;
        parm.nband = CROSSOVER_EN | MORE_BAND_EN;
        u8 mode = get_mic_eff_mode();
        memcpy(&last_wdrc_parm,&mic_last_drc_parm[mode].wdrc_parm,sizeof(last_wdrc_parm));
        memcpy(&last_crossover,&mic_last_drc_parm[mode].crossover, sizeof(CrossOverParam_TOOL_SET));
        parm.crossover = &last_crossover;
        parm.wdrc = &last_wdrc_parm;
        struct audio_drc *drc = audio_dec_drc_open(&parm);
        return drc;
    }
#endif
#if TCFG_DRC_ENABLE
    u8 mode = get_mic_eff_mode();
    log_i("sample_rate %d %d\n", sample_rate, ch_num);
    struct audio_drc_param parm = {0};
    parm.channels = ch_num;
    parm.sr = sample_rate;
    if (drc_name == AEID_MIC_DRC4) {
        parm.out_32bit = 0;
    }else{
        parm.out_32bit = 1;
    }
    parm.cb = drc_get_filter_info;
    parm.drc_name = drc_name;
    u8 index = get_drc_module_index(drc_name);
    memcpy(&mic_drc_parm[index],&eff_mode[mode].drc_parm[index],sizeof(wdrc_struct_TOOL_SET));
    // parm.wdrc = &eff_mode[mode].drc_parm[index];
    parm.wdrc = &mic_drc_parm[index];
    log_d("=====drc_name %d\n", drc_name);
    struct audio_drc *drc = audio_dec_drc_open(&parm);
    clock_add(EQ_CLK);
    return drc;
#else
    return NULL;
#endif//TCFG_DRC_ENABLE
}

    audio_way_set_sample_rate(AUDIO_OUT_WAY_TYPE,audio_output_nor_rate());
    // audio_way_set_sample_rate(AUDIO_OUT_WAY_TYPE,48000);
    audio_way_ioctrl(AUDIO_OUT_WAY_TYPE, SNDCTL_IOCTL_POWER_ON, NULL);  
    printf("-------------------------- audio dac power on ------------------------");

if(i == 0){
    while (remain_points--) {
        int valuetemp = 0;
        u8 j = 0;
        for(j = 0;j < adc_mode_hdl->total_ch_num;j++){   //所有通带数据累加
            valuetemp += *(rptr+j);
        }
        if (valuetemp < -32768) {                        //限幅后输出
            valuetemp = -32768;
        } else if (valuetemp > 32767) {
            valuetemp = 32767;
        }
        s16 value = (s16)valuetemp;
        memcpy(wptr, &value, 1 * 2);
        rptr += adc_mode_hdl->total_ch_num;
        wptr += 1;
    }
}
else{
        while (remain_points--) {
            memcpy(wptr, rptr, adc_mode_hdl->ch[i].ch_num * 2);
            rptr += adc_mode_hdl->total_ch_num;
            wptr += adc_mode_hdl->ch[i].ch_num;
        }
}

s32 valuetemp;
s32* value_ptr_s32;
s16* value_ptr_s16;

if(i == 0){ // 混响通路,单声道处理
    while (remain_points--) {
        valuetemp = 0;
        value_ptr_s32 = rptr;
        value_ptr_s16 = rptr;
        if(point_size == 4){
            for(u8 j = 0;j < adc_mode_hdl->ch[i].ch_num;j++){   //所有通带数据累加
                valuetemp += *(value_ptr_s32+j);
            }
            if (valuetemp < PCM_24BIT_SAT_MIN) {                        //限幅后输出
                valuetemp = PCM_24BIT_SAT_MIN;
            } else if (valuetemp > PCM_24BIT_SAT_MAX) {
                valuetemp = PCM_24BIT_SAT_MAX;
            }
        }else{
            u8 j = 0;
            for(j = 0;j < adc_mode_hdl->ch[i].ch_num;j++){   //所有通带数据累加
                valuetemp += *(value_ptr_s16+j);
            }
            if (valuetemp < -32768) {                        //限幅后输出
                valuetemp = -32768;
            } else if (valuetemp > 32767) {
                valuetemp = 32767;
            }
        }

        memcpy(wptr, &valuetemp,  point_size);
        rptr += adc_mode_hdl->total_ch_num * (point_size / 2);
        wptr += (point_size / 2);
    }
}else{
    while (remain_points--) {
        memcpy(wptr, rptr, adc_mode_hdl->ch[i].ch_num * point_size);
        rptr += adc_mode_hdl->total_ch_num * (point_size / 2);
        wptr += adc_mode_hdl->ch[i].ch_num * (point_size / 2);
    }
}

#define    CONFIG_BT_TWS_SNIFF                  0       //[WIP]

int audio_linein_open(struct adc_linein_ch *linein, u16 sample_rate, int gain)
{
#if    TCFG_AUDIO_ADC_ENABLE

    if (adc_mode_hdl == NULL) {
        printf("%s %d hdl is NULL err !\n", __func__, __LINE__);
        return -1;
    }

    if ((adc_mode_hdl->state == 1) || TCFG_MIC_EFFECT_ENABLE) {
        //打开混响宏的情况下，不管后台混响是否开启，都开关一次adc，并打开mic和linein通道
        audio_adc_mode_switch(ADC_LINEIN_MODE);
    } else {
        adc_mode_hdl->ch[0].enable = 0;
        adc_mode_hdl->ch[1].enable = 1;
        adc_mode_hdl->ch[2].enable = 0;
        adc_mode_hdl->mode = ADC_LINEIN_MODE;
    }

    g_printf("---- liein open gain=%d----\r\n",gain);
    audio_adc_mode_channel_open(1, linein, sample_rate, gain);

    /*新增代码  start*/
    audio_linein_set_gain(gain);
    /*新增代码  end*/

    return 0;

#endif // #if TCFG_AUDIO_ADC_ENABLE

    return -1;
}

#define AUDIO_ADC_PGA_CONFIG 1

u8 a2dp_support_delay_report = 0; //置0

void plcnt_iomc_disable(struct touch_key_port *key)
{
    //放电计数引脚选择intputchannel2
    gpio_ich_disable_iutput_signal(key->port, INPUT_CH_SIGNAL_CAP, INPUT_CH_TYPE_GP_ICH);
    /*gpio_set_fun_input_port(key->port, PFI_GP_ICH6);*/
    /*SFR(JL_IOMAP->CON1, 8, 4, 6);*/
}

extern struct audio_adc_hdl adc_hdl;
int audio_mic_enc_open(int (*mic_output)(void *priv, void *buf, int len), u32 code_type)
{
    int err;
    struct audio_fmt fmt;

    switch (code_type) {
    case AUDIO_CODING_OPUS:
        //1. quality:bitrate     0:16kbps    1:32kbps    2:64kbps
        //   quality: MSB_2:(bit7_bit6)     format_mode    //0:百度_无头.                   1:酷狗_eng+range.
        //   quality:LMSB_2:(bit5_bit4)     low_complexity //0:高复杂度,高质量.兼容之前库.  1:低复杂度,低质量.
        //2. sample_rate         sample_rate=16k         ignore
        fmt.quality = 0 /*| LOW_COMPLEX*/;
        fmt.sample_rate = 16000;
        fmt.coding_type = AUDIO_CODING_OPUS;
        break;
    case AUDIO_CODING_SPEEX:
        fmt.quality = 5;
        fmt.complexity = 2;
        fmt.sample_rate = 16000;
        fmt.coding_type = AUDIO_CODING_SPEEX;
        break;
    default:
        printf("do not support this type !!!\n");
        return -1;
        break;
    }

    audio_encoder_task_open();
    if (!mic_enc) {
        mic_enc = zalloc(sizeof(*mic_enc));
        if (!mic_enc) {
            printf("mic_enc NULL !!!\n");
        }
        memset(mic_enc, 0x00, sizeof(*mic_enc));
    }

    mic_enc_output_func_register(mic_output);
    cbuf_init(&mic_enc->pcm_in_cbuf, mic_enc->in_cbuf_buf, MIC_ENC_IN_SIZE * 4);
    os_sem_create(&mic_enc->pcm_frame_sem, 0);
    audio_encoder_open(&mic_enc->encoder, &mic_enc_input, encode_task);
    audio_encoder_set_handler(&mic_enc->encoder, &mic_enc_handler);
    audio_encoder_set_fmt(&mic_enc->encoder, &fmt);
    audio_encoder_set_event_handler(&mic_enc->encoder, mic_enc_event_handler, 0);
    audio_encoder_set_output_buffs(&mic_enc->encoder, mic_enc->output_frame,
                                   sizeof(mic_enc->output_frame), 1);
    if (!mic_enc->encoder.enc_priv) {
        log_e("encoder err, maybe coding(0x%x) disable \n", fmt.coding_type);
        err = -EINVAL;
        goto __err;
    }

    int start_err = audio_encoder_start(&mic_enc->encoder);

#if MIC_USE_MIC_CHANNEL

#if 1
        if(mic_effect_get_status())
        {
            printf("close effect");
            mic_effect_stop();//停止混响,linein等等关于ADC模块的东西
            //不打开mic_ldo
        }
    #if (TCFG_AUDIO_DAC_BIT_WIDTH == DAC_24BIT_MODE)
        extern struct adc_platform_data adc_data;
        adc_data.bit_width = 0;
    #endif

    fmt.sample_rate = 16000;

    if (TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_0) {
        printf("audio_mic_enc_open mic 0");
        audio_adc_mic_open(&mic_enc->mic_ch, TCFG_AUDIO_ADC_MIC_CHA, &adc_hdl);
    } else if (TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_1) {
        printf("audio_mic_enc_open mic 1");
        audio_adc_mic1_open(&mic_enc->mic_ch, TCFG_AUDIO_ADC_MIC_CHA, &adc_hdl);
    } else if (TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_2) {
        printf("audio_mic_enc_open mic 2");
        audio_adc_mic2_open(&mic_enc->mic_ch, TCFG_AUDIO_ADC_MIC_CHA, &adc_hdl);
    } else if (TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_3) {
        printf("audio_mic_enc_open mic 3");
        audio_adc_mic3_open(&mic_enc->mic_ch, TCFG_AUDIO_ADC_MIC_CHA, &adc_hdl);
    }

    /* audio_adc_mic3_open(&mic_enc->mic_ch, TCFG_AUDIO_ADC_MIC_CHA, &adc_hdl); */
    audio_adc_mic_set_sample_rate(&mic_enc->mic_ch, fmt.sample_rate);
    app_var.aec_mic_gain = 15;
    printf(">>>>>>>>>mic gain:%d \n", app_var.aec_mic_gain);
    audio_adc_mic_set_gain(&mic_enc->mic_ch, app_var.aec_mic_gain);
    audio_adc_mic_set_buffs(&mic_enc->mic_ch, mic_enc->adc_buf,
                            ENC_ADC_IRQ_POINTS * 2, ENC_ADC_BUF_NUM);
    mic_enc->adc_output.handler = adc_mic_output_handler;
    audio_adc_add_output_handler(&adc_hdl, &mic_enc->adc_output);


    //app_audio_output_samplerate_set(44100);
    //app_audio_output_start();
    audio_adc_mic_start(&mic_enc->mic_ch);
#else
    if (audio_mic_open(&mic_enc->mic_ch, 16000, 12) == 0) {
        mic_enc->adc_output.handler = adc_mic_output_handler;
        audio_mic_add_output(&mic_enc->adc_output);
        audio_mic_start(&mic_enc->mic_ch);
        audio_adc_mic_0dB_en(1);
    }
#endif
#endif

    printf("mic_enc_open ok %d\n", start_err);


    return 0;
__err:
    audio_encoder_close(&mic_enc->encoder);

    local_irq_disable();
    free(mic_enc);
    mic_enc = NULL;
    local_irq_enable();

    audio_encoder_task_close();

    return err;
}

int audio_mic_enc_close()
{
    if (!mic_enc) {
        return -1;
    }
    printf("audio_mic_enc_close\n");
#if MIC_USE_MIC_CHANNEL
    audio_adc_mic_close(&mic_enc->mic_ch);
    audio_adc_del_output_handler(&adc_hdl, &mic_enc->adc_output);
#endif
    mic_enc_resume();
    audio_encoder_close(&mic_enc->encoder);

    audio_encoder_task_close();

    free(mic_enc);
    mic_enc = NULL;
    #if (TCFG_AUDIO_DAC_BIT_WIDTH == DAC_24BIT_MODE)
      extern struct adc_platform_data adc_data;
      adc_data.bit_width = 1;
    #endif

    printf("audio_mic_enc_close end\n");
    return 0;
}

    sound_pcm_ctl_ioctl(dac->way->stream,  SNDCTL_IOCTL_POWER_OFF, NULL);

//这边将上图左边的代码拷贝下来，自行复制
{
    const usb_dev usb_id = usb_device2id(usb_device);
    usb_write_txcsr(usb_id, MSD_BULK_EP_IN, TXCSRP_SendStall);
    u32 ot = 2000;

    while (1) {
        udelay(100);
        if (ot-- == 0) {
            break;
        }
        if (usb_otg_online(usb_id) == DISCONN_MODE) {
            break;
        }


static void stall_outep(const struct usb_device_t *usb_device)
{
    const usb_dev usb_id = usb_device2id(usb_device);
    usb_write_rxcsr(usb_id, MSD_BULK_EP_OUT, RXCSRP_SendStall);
    u32 ot = 2000;
    udelay(100);
    while (1) {
        if (ot-- == 0) {
            break;
        }
        if (usb_otg_online(usb_id) == DISCONN_MODE) {
            break;

u8 global_hid_config_done = 0;

static void hid_endpoint_init(struct usb_device_t *usb_device, u32 itf)
{
    const usb_dev usb_id = usb_device2id(usb_device);
    usb_g_ep_config(usb_id, HID_EP_IN | USB_DIR_IN, USB_ENDPOINT_XFER_INT, 0, hid_ep_in_dma, MAXP_SIZE_HIDIN);
    usb_enable_ep(usb_id, HID_EP_IN);

    global_hid_config_done = 1;
    /* usb_g_set_intr_hander(usb_id, HID_EP_OUT, hid_rx_data); */
    /* usb_g_ep_config(usb_id, HID_EP_OUT, USB_ENDPOINT_XFER_INT, 1, ep_buffer, MAXP_SIZE_HIDOUT); */
}

void hid_key_handler(struct usb_device_t *usb_device, u32 hid_key)
{
    const usb_dev usb_id = usb_device2id(usb_device);
    if (usb_get_ep_status(usb_id, HID_EP_IN)) {
        return;
    }
    if(!global_hid_config_done) {
        return;
    }
    u16 key_buf = hid_key;
    hid_tx_data(usb_device, (const u8 *)&key_buf, 2);
    os_time_dly(2);
    key_buf = 0;
    hid_tx_data(usb_device, (const u8 *)&key_buf, 2);
}

//forprotect area cfg
PRCT_ADR = CONFIG_PRCT_ADDR;
PRCT_LEN = CONFIG_PRCT_LEN;
PRCT_OPT = CONFIG_PRCT_OPT;

//for volatile memory area cfg
//VM大小默认为CONFIG_VM_LEAST_SIZE，如果代码空间不够可以适当改小，需要满足4*2*n; 改小可能会导致不支持测试盒蓝牙升级（不影响串口升级）
VM_ADR = CONFIG_VM_ADDR;
VM_LEN = CONFIG_VM_LEAST_SIZE;
VM_OPT = CONFIG_VM_OPT;
/********增加部分**********/
LRIF_ADR=AUTO;
LRIF_LEN=0x1000;
LRIF_OPT=1;
/********增加部分**********/

//抢播参数设置：
__set_a2dp_sound_detect_counter(30,30);//第一个参数：后台持续多久音频后抢播；第二个参数：抢播后持续多久后允许被抢播
//补丁使用api：
#if TCFG_BT_SUPPORT_AAC
    void aac_decoder_energy_det_close();
    aac_decoder_energy_det_close();
#endif

extern void free_a2dp_using_decoder_conn();
free_a2dp_using_decoder_conn();

// apps/soundbox/include/build_error.h
#if SOUNDCARD_ENABLE && RECORDER_MIX_EN
// #error "声卡功能和混合录音功能暂不支持同时开启"
#endif

// cpu/br28/audio_enc/audio_recorder_mix.c -> __recorder_mix_start()进行如下修改：
static int __recorder_mix_start(struct __recorder_mix *recorder)
{
    xxxxxx

    char *logo = {"sd0"};   // 直接修改为 sd0 或者 sd1，根据需要调整
    // char *logo = dev_manager_get_phy_logo(dev_manager_find_active(0));//普通设备录音，获取最后活动设备

    xxxxxx
}

//底层会调用该函数
void user_avrcp_status_callback(u8 *addr,u8 flag)
{
    //flag = 0 是暂停，1是播放
    put_buf(addr,6);

}

u16 chip_crc16(void *ptr, u32 len)
{
    return CRC16(ptr,len);
}

     emu_stack_limit_set(1, 0, 0xFFFFFFF);
     emu_stack_limit_set(0, 0, 0xFFFFFFF);

报[1-HCORE] hmem err msg : cpu1 instruction fetch hmem excption死机。
报[1-HCORE] mmu err msg : audio access mmu excption死机

功能说明：
1、TWS区分主从
2、修复从机切模式会回连手机等问题
3、1.4.1SDK支持广播、TWS分时互斥使用：切换模式参考：KEY_WIRELESS_TRANS_MODE_SW 消息处理

CIG模拟TWS对箱功能demo说明：
1、上电开机默认以从机角色开启CIG，若有蓝牙连接、U盘插入或AUX插入事件发生，则自动切换跳转到对应蓝牙、music或linein模式做为主机开启CIG；
2、ADKEY AD0按键双击调用app_connected_role_switch()可主动切换CIG主从角色；
3、ADKEY AD1按键三击调用app_connected_switch()可主动开关CIG；
4、需有一主一从同时开启CIG才可完成CIG连接；
5、蓝牙模式，CIG未连接状态下，主从机均开启经典蓝牙可发现可连接
6、蓝牙模式，CIG已连接状态下，主机开启经典蓝牙可发现可连接，从机则关闭经典蓝牙可发现可连接；
7、关闭蓝牙后台，在music、linein模式下经典蓝牙不可发现不可连接；
8、只有CIG主机角色才可转发蓝牙、MUSIC或AUX音频到CIG从机，主机输出左声道，从机输出右声道；
9、已实现CIG主从机音量同步；
10、CIG完成连接后会记录地址绑定配对，若需要配对新设备，可通过ADKEY AD0按键三击调用app_connected_remove_pairs_addr()清除配对信息，并重新配对；

cig模拟tws&big双模式切换功能demo说明：
1、上电开机进经典蓝牙模式，按键调用KEY_WIRELESS_TRANS_MODE_SW切换经典蓝牙(即关闭BIG与CIG)、BIG或CIG模式；
2、在BIG模式下，需有一发一收同时开启BIG才可完成BIG连接：
    //(1)处于蓝牙模式并且已连接手机设备时，播歌作为广播发送设备，暂停作为广播接收设备。
    //(2)插入linein或U盘时，自动切换到linein或music模式做为广播发送设备；
3、在CIG模式下，需有一主一从同时开启CIG才可完成CIG连接：
    //(1)处于蓝牙模式，已连接手机设备时作为主机角色发起连接，未连接手机设备时作为从机角色发起连接；
    //(2)插入linein或U盘时，自动切换到linein或music模式做为主机角色发起连接；
4、关闭蓝牙后台，在music、linein模式下经典蓝牙不可发现不可连接；
5、蓝牙模式，CIG&BIG未连接状态下，CIG主从机、BIG广播发送设备与接收设备均开启经典蓝牙可发现可连接；
6、蓝牙模式，CIG&BIG作为从机角色/广播接收设备完成连接后关闭经典蓝牙可发现可连接,断开连接恢复经典蓝牙可发现可连接；
7、只有CIG主机角色才可转发蓝牙、MUSIC或AUX音频到CIG从机，主机输出左声道，从机输出右声道；
8、只有BIG广播发送设备才可转发蓝牙、MUSIC或AUX音频到BIG广播接收设备；
9、已实现BIG&CIG主从机/广播接收端音量同步；
10、CIG完成连接后会记录地址绑定配对，若需要配对新设备，可通过按键调用app_connected_remove_pairs_addr()清除配对信息，并重新配对；

功能说明：
1、提供同时叠加播放多个音频文件的功能：接口如下
    void tone_multi_file_play(u8 num);
注意：叠加播放的文件的数量取决于系统能不能跑得过来。使用相同采样率的文件避免变采样可以减少系统占用

功能说明：
1、添加一路AUX叠加输出功能
2、添加《jl701n_soundbox_release_v1.4.1_patch（RECORD_MIX）》补丁

#define TCFG_HW_SPI1_ENABLE     ENABLE_THIS_MOUDLE
#define TCFG_HW_SPI1_PORT_CLK   NO_CONFIG_PORT     // 可不用
#define TCFG_HW_SPI1_PORT_DO    IO_PORT_02
#define TCFG_HW_SPI1_PORT_DI    NO_CONFIG_PORT     // 可不用
#define TCFG_HW_SPI1_BAUD       461538L            // 必须为 153600 的整数倍
#define TCFG_HW_SPI1_MODE       SPI_MODE_BIDIR_1BIT
#define TCFG_HW_SPI1_ROLE       SPI_ROLE_MASTER

#if TCFG_HW_SPI1_ENABLE
struct spi_platform_data spi1_p_data = {
    .port = {
        TCFG_HW_SPI1_PORT_CLK,
        TCFG_HW_SPI1_PORT_DO,
        TCFG_HW_SPI1_PORT_DI,
    },
    .mode = TCFG_HW_SPI1_MODE,
    .clk  = TCFG_HW_SPI1_BAUD,
    .role = TCFG_HW_SPI1_ROLE,
};
#endif

#define DUMMY_BYTE  0xff
#define BUF_MAX_LEN 512U
#define TIME_BYTE   10    // 填充包尾，可延长空闲位高电平时间

static u8 g_tx_buff[BUF_MAX_LEN] __attribute__((aligned(4)));

/**
 * @brief 模拟组包
 * @param spi_tx spi 发送缓存 buffer
 * @param data 实际需要发送的数据
 * @param dLen 数据长度
 * @return 0 组包失败，其他 组包长度
 */
static u16 soft_uart_pkt_create(u8 *spi_tx, u8 const* data, u16 dLen) {
    u8 bit = 0;
    u8 odd = 0;
    u16 pkt_len = 0;
    u8 bit_byte = DUMMY_BYTE;
    size_t i, j;

    if ((dLen * g_bit_per_byte + TIME_BYTE) > BUF_MAX_LEN) return 0;

    while (dLen--) {
        // start bit
        bit_byte = 0x00;
        for (j = 0; j < g_bit_per_byte; j++) spi_tx[pkt_len++] = bit_byte;
        // data bit
        for (i = 0; i < 8; i++) {
            bit = (*data >> i) & 0x01;
            bit_byte = bit ? DUMMY_BYTE : 0x00;
            for (j = 0; j < g_bit_per_byte; j++) spi_tx[pkt_len++] = bit_byte;
            odd ^= bit;
        }
        // parity bit 奇校验
        bit_byte = (odd == 0) ? DUMMY_BYTE : 0;
        for (j = 0; j < g_bit_per_byte; j++) spi_tx[pkt_len++] = bit_byte;
        // stop bit
        bit_byte = DUMMY_BYTE;
        for (j = 0; j < g_bit_per_byte; j++) spi_tx[pkt_len++] = bit_byte;

        odd = 0;
        data++;
    }
    // time delay 空闲位
    memset(&spi_tx[pkt_len], DUMMY_BYTE, TIME_BYTE);
    pkt_len += TIME_BYTE;

    return pkt_len;
}

/**
 * @brief 串口数据 spi 发送
 * @param data 数据
 * @param len 数据长度
 * @param remap_port 映射端口，非 NULL 时会重新映射到输入的端口, 
    其中 NO_CONFIG_PORT 会忽略
    顺序： CLK, DO, DI, D2(wp), D3(hold)
 */
int uart_spi_send(spi_dev spi, u8 const *data, u16 len, spi_remap_port *const remap_port) {
    int ret = 0;
    static u32 __sys_clk = 0;
    u32 cur_sys_clk = 0;

    // 处理变频情况，系统时钟发生改变需要重新设置一遍 spi 时钟
    cur_sys_clk = clk_get("spi");
    if (__sys_clk != cur_sys_clk) {
        __sys_clk = cur_sys_clk;
        ret = spi_set_baud(spi, spi_get_info_clock(spi));
        if (ret < 0) goto __exit;
    }
    // uart 组包
    u16 spi_tx_len = soft_uart_pkt_create(g_tx_buff, data, len);
    // spi pin 重映射
    if (remap_port != NULL) spi_remap_port_fn(spi, remap_port);
    // spi dma 阻塞发送
    ret = spi_dma_send(spi, g_tx_buff, spi_tx_len);

__exit:
    return ret;
}

#include "system/timer.h"
#define SPI_DEV SPI1
void uart_spi_send_test(void *priv) {
    spi_remap_port *io = (spi_remap_port *)priv;
    int ret = 0;
    u8 cmd_data[7] = {0x08, 0x1, 0x3, 0x5, 0x7, 0xff, 0xff};
    static u8 index = 0;
    
    if (index++ > 1) index = 0;
#if UART_SPI_INTERRUPT_ENABLE
    ret = uart_spi_send_for_isr(SPI_DEV, cmd_data, sizeof(cmd_data), &io[index], 10);
#else
    ret = uart_spi_send(SPI_DEV, cmd_data, sizeof(cmd_data), &io[index]);
#endif
    if (ret < 0) {
        log_info("%s, %d", __func__, ret);
    }
}
void uart_spi_send_demo(void) {
    int ret = 0;

    static spi_remap_port io[2] = {
        {
            .port[0] = NO_CONFIG_PORT,
            .port[1] = TCFG_HW_SPI1_PORT_DO,
            .port[2] = NO_CONFIG_PORT,
            .port[3] = NO_CONFIG_PORT,
            .port[4] = NO_CONFIG_PORT,
        },
        {
            .port[0] = NO_CONFIG_PORT,
            .port[1] = IO_PORTA_00,
            .port[2] = NO_CONFIG_PORT,
            .port[3] = NO_CONFIG_PORT,
            .port[4] = NO_CONFIG_PORT,
        },
    };

    for (size_t i = 0; i < 2; i++) {
        gpio_set_direction(io[i].port[1], 0);
        gpio_set_pull_up(io[i].port[1], 0);
        gpio_set_pull_down(io[i].port[1], 0);
        gpio_set_output_value(io[i].port[1], 1);
    }

    ret = uart_spi_open(SPI_DEV);
    if (ret < 0) return;

    (void)sys_timer_add(io, uart_spi_send_test, 50);
    log_info("%s", __func__);
}