#define MCLR_EN(en)    p33_fast_access(P3_PR_PWR, BIT(3), en);

//* 参数使用说明：如果测试盒测试到未修改频偏前数值是+20 ，那么就填bt_osc_offset_set(20);   如果测试到是-20 那么就填bt_osc_offset_set(-20); 
extern void bt_osc_offset_set(s32 offset);  

//uboot and ota.bin串口tx
// 如果是USB口 设置为 USBDP/USBDM
#ifndef CONFIG_UBOOT_DEBUG_PIN
#define CONFIG_UBOOT_DEBUG_PIN                  PA01
#endif

    u32 port = PORTA;//指定IO
    u32 pin = PORT_PIN_2;
    gpio_hw_set_direction(port, pin, 1);//0:out, 1:in
    gpio_hw_set_die(port, pin, 0);
    gpio_hw_set_dieh(port, pin, 0);
    gpio_hw_set_pull_up(port, pin, GPIO_PULLUP_10K);
    gpio_hw_set_pull_down(port, pin, GPIO_PULLDOWN_10K);
    gpio_hw_set_output_value(port, pin, 0);

#define AD_CH_IO_VBAT_PORT        IO_PORTB_02   //选择一个有ADC功能IO口采集vbat电压，电压不能超过 vddio
adc_add_sampioch(adc_io2ch(AD_CH_IO_VBAT_PORT));
adc_set_sample_period(adc_io2ch(AD_CH_IO_VBAT_PORT), PMU_CH_SAMPLE_PERIOD);

    //DAC高阻态
    SFR(JL_ADDA->DAA_CON2,    23,  1,   1);            //SDDAC_PA_TRIM_EN_11v
    //PB7初始化
    gpio_set_mode(IO_PORT_SPILT(IO_PORTB_07), PORT_INPUT_FLOATING);
    gpio_set_function(IO_PORT_SPILT(IO_PORTB_07), PORT_FUNC_GPADC); 
   //获取PB7 AD 值
    u32 adc_v = adc_get_value_blocking(ADC_CH_IO_PB7);

    //初始化 PB7 ad输入
    gpio_set_mode(IO_PORT_SPILT(IO_PORTB_07), PORT_INPUT_FLOATING);
    gpio_set_function(IO_PORT_SPILT(IO_PORTB_07), PORT_FUNC_GPADC);
    //触发DAC R高阻态
    play_tone_file(get_tone_files()->max_vol);
    tone_player_stop();
    //获取PB7 AD 值
    u32 adc_v = adc_get_value_blocking(ADC_CH_IO_PB7);

u32 dev_cnt = 0;
dev_cnt += dev_online("udisk0");
dev_cnt += dev_online("sd0");

通用输出通道选择
0：uart0_tx
1：uart1_rts 
2：spi0_do
3：spi1_do
4：tmr0_pwm
5：tmr1_pwm
6：tmr2_pwm
7：tmr3_pwm
8：mc_pwm0_h
9：mc_pwm0_l
10：mc_pwm1_h
11：mc_pwm1_l
12：clkout1
13：clkout2
14：gp_ich0
15：gp_ich1

void norflash_set_write_protect_en(void)
{
    struct vm_info vm = {0};
    norflash_ioctl(NULL, IOCTL_GET_VM_INFO, (u32)&vm);
    norflash_set_write_protect(1, vm.vm_saddr);
}

void norflash_set_write_protect_remove(void)
{
    norflash_set_write_protect(0, 0);
}

void cpu_assert_debug()
{
    asm("[--sp] = {rets}");
#if CONFIG_DEBUG_ENABLE
    log_flush();
    local_irq_disable();
    while (1);
#else
    p33_tx_1byte(P3_SFLAG0, 0xac);
    cpu_reset();
    // P3_PCNT_SET0 = 0xac;
    // cpu_reset();
#endif
}

    u8 reset_if = 1;
    if (freq == 106000 || freq == 98000 || freq == 90000 || freq == 82000) {
        reset_if = 0;
    }
    if(reset_if){
        u32 fmrx_clk = clk_get("fmrx") / 1000;
        u8 if_step = (float)(1500 * 160 / (fmrx_clk / 2));
        SFR(JL_FM->FMRX_CON9, 5, 7, if_step);
    }

err = wireless_trans_transmit("big_rx", data, length, &param);

    case WIRELESS_DEV_OP_SEND_PACKET:
        res = big_rx_ops.send_packet((const uint8_t *)va_arg(argptr, int), va_arg(argptr, int), (big_stream_param_t *)va_arg(argptr, int));
        break;

dac_hdl.state = 0;
audio_dac_close(&dac_hdl);

//log特征
[00:00:00.290]tone_callback: 8, 0
[00:00:00.662][SD]sd status = 1
[00:00:00.663]sd dev msg 53443000, 0, 7e5aff0
[00:00:00.663]DEVICE_EVENT_FROM_SD0
[00:00:00.663]DEVICE_EVENT_IN
[00:00:00.663]sd0 add start
[00:00:00.664][SD]sd0 open !
[00:00:00.730][SD]sd is 2.0 SDHC !
[00:00:00.732][SD]sd init step 1 is success !

[00:00:00.741]<error> [SD]sdc receive data crc error !


[00:00:00.742]<error> [SD]sdmmc send acmd51 error ! >>> DAT0 line has poor contact , and DAT0 is always at high level !

[00:00:00.770][SD]sd is 2.0 SDHC !
[00:00:00.772][SD]sd init step 1 is success !

[00:00:00.781]<error> [SD]sdc receive data crc error !


[00:00:00.782]<error> [SD]sdmmc send acmd51 error ! >>> DAT0 line has poor contact , and DAT0 is always at high level !

[00:00:00.810][SD]sd is 2.0 SDHC !
[00:00:00.812][SD]sd init step 1 is success !

[00:00:00.821]<error> [SD]sdc receive data crc error !


[00:00:00.822]<error> [SD]sdmmc send acmd51 error ! >>> DAT0 line has poor contact , and DAT0 is always at high level !

[00:00:00.823]__dev_manager_add, sd0 add ok, dev->fmnt = 0,  0
[00:00:01.041][STREAM]dec_err: 40
[00:00:01.065][STREAM]dec_end: 0
[00:00:01.070][AUDIO-DAC]DAV VOL0 : 0x40004000
[00:00:01.101][fade]state:idle,max_volume:100,cur:0,0
[00:00:01.101]set_vol[idle]:=0
[00:00:01.101][SW_DVOL]Gain:0,AVOL:14,DVOL:16384

static void ui_strick_loop()
{
    int msg[1];
    if (__ui_display->init) {

        if(__ui_display->tmp_menu_ret_cnt){
            if(--__ui_display->tmp_menu_ret_cnt==0){
                msg[0] = UI_MSG_STRICK;
                g_printf("------msg----");
                post_ui_msg(msg, 1);
            }else{
                return;
            }
        }
        if (__ui_display->auto_reflash_time && ((++__ui_display->time_count) >= __ui_display->auto_reflash_time)) {
            ui_menu_reflash(0);//自动刷新主页
            __ui_display->time_count = 0;
        }

        // if (__ui_display->tmp_menu_ret_cnt && ((--__ui_display->tmp_menu_ret_cnt) == 0)) {
        //     msg[0] = UI_MSG_STRICK;
        //     post_ui_msg(msg, 1);
        // }
    }
}

        // bt_cmd_prepare(USER_CTRL_AVCTP_OPID_PLAY, 0, NULL);
            u8 *bt_addr = NULL;
            u8 addr[6];
        if (a2dp_player_get_btaddr(addr)) {
                bt_addr = addr;
        }
        bt_cmd_prepare_for_addr(bt_addr, USER_CTRL_AVCTP_OPID_PLAY, 0, NULL);

extern void unmask_enter_critical(void);//调用关闭不可屏蔽中断

void user_led7_timer_close()
{
    y_printf("user_led7_timer_close:%d\n", user_led7_timer);
    if (user_led7_timer) {
        gptimer_pause(user_led7_timer);
    }
}

[EXTRA_CFG_PARAM]
OTP_CFG_SIZE=256;

//模式切换时 参数更新接口
void set_mic_reverb_mode_by_id(u8 mode)

/**
*接口会更新reverb中的wet
*max_leve：最大等级值
*level：当前等级值
*如果当前情景配置工具里面reverb wet 为120 那么更新下去值为  120*level/max_level
**/
void mic_effect_reverb_wet_set(int max_level,int level){
    if (g_mic_effect == NULL || g_mic_effect->sub_0_plate_reverb_hdl == NULL) {
        return ;
    }
    
    int wet;
    static int max=-1;
    if(max<0){
        max=g_mic_effect->sub_0_plate_reverb_hdl->reverb_parm_obj.wet;        
    }
    
    printf("reverb max_level=%d level=%d\r\n",max_level,level);

    wet=level*max/max_level;
    if(wet>max)wet=max;
    if(wet<0)wet=0;

    Plate_reverb_parm parm;
    memcpy(&parm, & g_mic_effect->sub_0_plate_reverb_hdl->reverb_parm_obj, sizeof(Plate_reverb_parm));
    parm.wet = wet;
    update_plate_reverb_parm(g_mic_effect->sub_0_plate_reverb_hdl, &parm);
    //reverb_wet_level=level;
    printf("reverb wet=%d max=%d",g_mic_effect->sub_0_plate_reverb_hdl->reverb_parm_obj.wet,max);
}

void set_mic_current_scene(u8 index) 
{
    mic_scene = index;
    printf("---- mic_scene = %d",mic_scene);
}

void reverb_update_parm(u8 mode_index, char *node_name, u8 cfg_index)
{
    plate_reverb_param_tool_set cfg = {0};
    int ret = jlstream_read_form_data(mode_index, node_name, cfg_index, &cfg);
    if (!ret) {
        printf("read parm err, %s, %s\n", __func__, node_name);
        return;
    }
    printf("cfg.bypass=%d",cfg.is_bypass);
    jlstream_set_node_param(NODE_UUID_PLATE_REVERB, node_name, &cfg, sizeof(cfg));
    jlstream_set_node_param(NODE_UUID_PLATE_REVERB_LITE, node_name, &cfg, sizeof(cfg));
}

apps\soundbox\wireless_trans\le_audio\big\le_broadcast.c
int broadcast_audio_all_close(u16 big_hdl)
{
    u8 i;
    struct broadcast_hdl *p;
    void *recorder = 0;
    struct broadcast_rx_audio_hdl player;

    player.le_audio = 0;
    player.rx_stream = 0;

    broadcast_mutex_pend(&broadcast_mutex, __LINE__);
    spin_lock(&broadcast_lock);
    list_for_each_entry(p, &broadcast_list_head, entry) {
        if (p->big_hdl == big_hdl) {
            //关闭原来的recorder
            if (broadcast_role == BROADCAST_ROLE_TRANSMITTER) {
                for (i = 0; i < get_bis_num(BROADCAST_ROLE_TRANSMITTER); i++) {
                    if (p->bis_hdl_info[i].recorder) {
                        recorder = p->bis_hdl_info[i].recorder;
                        p->bis_hdl_info[i].recorder = NULL;
                        p->bis_hdl_info[i].init_ok = 0;
                    }
                    spin_unlock(&broadcast_lock);

                    if (recorder) {
                        if (le_audio_switch_ops && le_audio_switch_ops->tx_le_audio_close) {
                            le_audio_switch_ops->tx_le_audio_close(recorder);
                        }
                    }
                    spin_lock(&broadcast_lock);
                }
            } else if (broadcast_role == BROADCAST_ROLE_RECEIVER) {
                for (i = 0; i < get_bis_num(BROADCAST_ROLE_RECEIVER); i++) {
                    if (p->bis_hdl_info[i].rx_player.le_audio) {
                        player.le_audio = p->bis_hdl_info[i].rx_player.le_audio;
                        p->bis_hdl_info[i].rx_player.le_audio = NULL;
                        p->bis_hdl_info[i].init_ok = 0;
                    }

                    if (p->bis_hdl_info[i].rx_player.rx_stream) {
                        player.rx_stream = p->bis_hdl_info[i].rx_player.rx_stream;
                        p->bis_hdl_info[i].rx_player.rx_stream = NULL;
                        p->bis_hdl_info[i].init_ok = 0;
                    }
                    spin_unlock(&broadcast_lock);

                    if (player.le_audio && player.rx_stream) {
                        if (le_audio_switch_ops && le_audio_switch_ops->rx_le_audio_close) {
                            le_audio_switch_ops->rx_le_audio_close(&player);
                            player.le_audio = NULL;
                            player.rx_stream = NULL;
                        }
                    }
                    spin_lock(&broadcast_lock);
                }
            }
        }
    }
    spin_unlock(&broadcast_lock);
    broadcast_mutex_post(&broadcast_mutex, __LINE__);

    return 0;
}


int broadcast_audio_all_open(u16 big_hdl)
{

    u8 find = 0;
    struct broadcast_hdl *broadcast_hdl = 0;
    struct le_audio_stream_params params = {0};

    u8 i = 0;
    void *recorder = 0;

    broadcast_mutex_pend(&broadcast_mutex, __LINE__);
    list_for_each_entry(broadcast_hdl, &broadcast_list_head, entry) {
        if (broadcast_hdl->big_hdl == big_hdl) {
            find = 1;
            break;
        }
    }
    broadcast_mutex_post(&broadcast_mutex, __LINE__);

    le_audio_switch_ops = get_broadcast_audio_sw_ops();

    //关闭本地音频播放
    if (le_audio_switch_ops && le_audio_switch_ops->local_audio_close) {
        le_audio_switch_ops->local_audio_close();
    }

    params.fmt.nch = get_big_audio_coding_nch();
    params.fmt.bit_rate = get_big_audio_coding_bit_rate();
    params.fmt.coding_type = LE_AUDIO_CODEC_TYPE;
    params.fmt.frame_dms = get_big_audio_coding_frame_duration();
    params.fmt.sdu_period = get_big_sdu_period_us();
    params.fmt.sample_rate = LE_AUDIO_CODEC_SAMPLERATE;
    params.fmt.dec_ch_mode = LEA_RX_DEC_OUTPUT_CHANNEL;
    params.reference_time = broadcast_audio_reference_time;
    params.conn = broadcast_hdl;

    broadcast_mutex_pend(&broadcast_mutex, __LINE__);
    if (find) {
        if (broadcast_role == BROADCAST_ROLE_TRANSMITTER) {
            for (i = 0; i < get_bis_num(BROADCAST_ROLE_TRANSMITTER); i++) {
                if (!broadcast_hdl->bis_hdl_info[i].recorder) {
                    if (le_audio_switch_ops && le_audio_switch_ops->tx_le_audio_open) {
                        recorder = le_audio_switch_ops->tx_le_audio_open(&params);
                        spin_lock(&broadcast_lock);
                        broadcast_hdl->bis_hdl_info[i].recorder = recorder;
                        broadcast_hdl->bis_hdl_info[i].init_ok = 1;
                        spin_unlock(&broadcast_lock);
                    }
                }
            }
        } else if (broadcast_role == BROADCAST_ROLE_RECEIVER) {
            for (i = 0; i < get_bis_num(BROADCAST_ROLE_RECEIVER); i++) {
                if (!broadcast_hdl->bis_hdl_info[i].bis_hdl) {
                    continue;
                }
                if ((!broadcast_hdl->bis_hdl_info[i].rx_player.le_audio) &&
                    (!broadcast_hdl->bis_hdl_info[i].rx_player.rx_stream)) {
                    if (le_audio_switch_ops && le_audio_switch_ops->rx_le_audio_open) {
                        le_audio_switch_ops->rx_le_audio_open(&broadcast_hdl->bis_hdl_info[i].rx_player, &params);
                        spin_lock(&broadcast_lock);
                        broadcast_hdl->bis_hdl_info[i].init_ok = 1;
                        spin_unlock(&broadcast_lock);
                    }
                }
            }
        }
    }
    broadcast_mutex_post(&broadcast_mutex, __LINE__);
    return 0;
}

apps\soundbox\wireless_trans\le_audio\big\app_le_broadcast.c
void user_broadcast_audio_all_close(void)
{
    for (u8 i = 0; i < BIG_MAX_NUMS; i++) {
        if (app_big_hdl_info[i].used && app_big_hdl_info[i].big_hdl) {
            
            line_inf
            broadcast_audio_all_close( app_big_hdl_info[i].big_hdl);//
                       
            // ret = broadcast_close(app_big_hdl_info[i].big_hdl);
            // memset(&app_big_hdl_info[i], 0, sizeof(struct app_big_hdl_t));
            // app_big_hdl_info[i].big_status = status;
        }
    }
}

void user_broadcast_audio_all_open(void)
{
    for (u8 i = 0; i < BIG_MAX_NUMS; i++) {
        if (app_big_hdl_info[i].used && app_big_hdl_info[i].big_hdl) {
            
            line_inf
            broadcast_audio_all_open( app_big_hdl_info[i].big_hdl);//
                    
            // ret = broadcast_close(app_big_hdl_info[i].big_hdl);
            // memset(&app_big_hdl_info[i], 0, sizeof(struct app_big_hdl_t));
            // app_big_hdl_info[i].big_status = status;
        }
    }
}

apps\soundbox\wireless_trans\le_audio\cig\le_connected.c
int le_connected_audio_all_close(u16 cig_hdl)
{
    u8 i;
    int ret;
    void *recorder = 0;
    int player_status = 0;
    struct connected_rx_audio_hdl player;

    player.le_audio = 0;
    player.rx_stream = 0;
    
    if (!connected_init_flag) {
        return -1;
    }
    log_info("--func=%s", __FUNCTION__);
    //TODO:获取播放状态
    if (le_audio_switch_ops && le_audio_switch_ops->play_status) {
        player_status = le_audio_switch_ops->play_status();
    }
    struct connected_hdl *p, *n;
    connected_mutex_pend(&connected_mutex, __LINE__);
    spin_lock(&connected_lock);
    list_for_each_entry_safe(p, n, &connected_list_head, entry) {
        if (p->cig_hdl != cig_hdl) {
            continue;
        }
        for (i = 0; i < CIS_MAX_CONNECTABLE_NUMS; i++) {
            p->cis_hdl_info[i].init_ok = 0;
            // p->cis_hdl_info[i].cis_hdl = 0;
            if (p->cis_hdl_info[i].recorder) {
                recorder = p->cis_hdl_info[i].recorder;
                p->cis_hdl_info[i].recorder = NULL;
            }
            if (p->cis_hdl_info[i].rx_player.le_audio) {
                player.le_audio = p->cis_hdl_info[i].rx_player.le_audio;
                p->cis_hdl_info[i].rx_player.le_audio = NULL;
            }
            if (p->cis_hdl_info[i].rx_player.rx_stream) {
                player.rx_stream = p->cis_hdl_info[i].rx_player.rx_stream;
                p->cis_hdl_info[i].rx_player.rx_stream = NULL;
            }
            spin_unlock(&connected_lock);
            if (recorder) {
                //TODO:关闭recorder
                if (le_audio_switch_ops && le_audio_switch_ops->tx_le_audio_close) {
                    le_audio_switch_ops->tx_le_audio_close(recorder);
                    recorder = NULL;
                }
            }
            if (player.le_audio && player.rx_stream) {
                //TODO:关闭player
                if (le_audio_switch_ops && le_audio_switch_ops->rx_le_audio_close) {
                    le_audio_switch_ops->rx_le_audio_close(&player);
                    player.le_audio = NULL;
                    player.rx_stream = NULL;
                }
            }
            spin_lock(&connected_lock);
        }
    }
    spin_unlock(&connected_lock);
    connected_mutex_post(&connected_mutex, __LINE__);

    return 0;
}

int le_connected_audio_all_open(u16 cig_hdl)
{

    u8 find = 0;
    u8 index = 0;
    struct connected_hdl *connected_hdl = 0;
    struct le_audio_stream_params params = {0};
    cig_hdl_t * hdl = (cig_hdl_t *)cig_hdl;
    
    u8 i = 0;
    void *recorder = 0;
    
    if (!connected_init_flag) {
        return -1;
    }

    connected_mutex_pend(&connected_mutex, __LINE__);
    list_for_each_entry(connected_hdl, &connected_list_head, entry) {
        if (connected_hdl->cig_hdl == cig_hdl) {
            find = 1;
            break;
        }
    }
    connected_mutex_post(&connected_mutex, __LINE__);


    for (i = 0; i < CIS_MAX_CONNECTABLE_NUMS; i++) {
        if (!connected_hdl->cis_hdl_info[i].cis_hdl) {
            index = i;
            break;
        }
    }

    le_audio_switch_ops = get_connected_audio_sw_ops();

    //关闭本地音频播放
    if (le_audio_switch_ops && le_audio_switch_ops->local_audio_close) {
        le_audio_switch_ops->local_audio_close();
    }

    params.fmt.nch = get_cig_audio_coding_nch();
    params.fmt.bit_rate = get_cig_audio_coding_bit_rate();
    params.fmt.coding_type = LE_AUDIO_CODEC_TYPE;
    params.fmt.frame_dms = get_cig_audio_coding_frame_duration();
    params.fmt.sdu_period = get_cig_sdu_period_us();
    params.fmt.sample_rate = LE_AUDIO_CODEC_SAMPLERATE;
    params.fmt.dec_ch_mode = LEA_TX_DEC_OUTPUT_CHANNEL;
    params.reference_time = connected_audio_reference_time;
    params.conn = connected_hdl;

    params.fmt.dec_ch_mode = LEA_RX_DEC_OUTPUT_CHANNEL;

    connected_mutex_pend(&connected_mutex, __LINE__);
    if (find) {
        for (i = 0; i < CIS_MAX_CONNECTABLE_NUMS; i++) {
            if (!connected_hdl->cis_hdl_info[i].cis_hdl) {
                continue;
            }
            if ((!connected_hdl->cis_hdl_info[i].rx_player.le_audio) &&
                (!connected_hdl->cis_hdl_info[i].rx_player.rx_stream)) {
                if (le_audio_switch_ops && le_audio_switch_ops->rx_le_audio_open) {
                    le_audio_switch_ops->rx_le_audio_open(&connected_hdl->cis_hdl_info[i].rx_player, &params);
                    spin_lock(&connected_lock);
                    connected_hdl->cis_hdl_info[i].init_ok = 1;
                    spin_unlock(&connected_lock);
                }
            }
        }
    }
    connected_mutex_post(&connected_mutex, __LINE__);
    return 0;
}

apps\soundbox\wireless_trans\le_audio\cig\app_le_connected.c
void user_le_connected_audio_all_close(void)
{
    for (u8 i = 0; i < CIS_MAX_CONNECTABLE_NUMS; i++) {
        if (app_cig_conn_info[i].used && app_cig_conn_info[i].cig_hdl) {
            le_connected_audio_all_close(app_cig_conn_info[i].cig_hdl);//
            // ret = broadcast_close(app_big_hdl_info[i].big_hdl);
            // memset(&app_big_hdl_info[i], 0, sizeof(struct app_big_hdl_t));
            // app_big_hdl_info[i].big_status = status;
        }
    }
}

void user_le_connected_audio_all_open(void)
{
    for (u8 i = 0; i < CIS_MAX_CONNECTABLE_NUMS; i++) {
        if (app_cig_conn_info[i].used && app_cig_conn_info[i].cig_hdl) {
            le_connected_audio_all_open( app_cig_conn_info[i].cig_hdl);//
            // ret = broadcast_close(app_big_hdl_info[i].big_hdl);
            // memset(&app_big_hdl_info[i], 0, sizeof(struct app_big_hdl_t));
            // app_big_hdl_info[i].big_status = status;
        }
    }
}

    if (key->event == KEY_ACTION_NO_KEY) {
        if (click_cnt >= 2) {
            u16 multi_click_temp = KEY_ACTION_DOUBLE_CLICK + (click_cnt - 2);
            if (multi_click_temp < KEY_ACTION_MAX) {
                key->event = multi_click_temp;
            }
        } else {
            key->event = KEY_ACTION_CLICK;
        }

    #if ((defined CONFIG_DEBUG_ENABLE) && (TCFG_UART0_ENABLE))
    __this->udev = uart_init(-1, &config);
    #else
    __this->udev = uart_init(1, &config);
    #endif

//*----------------------------------------------------------------------------*/
/**@brief    设备下线预处理
   @param
                event：设备事件
   @return
   @note     根据特殊情景，这里可以处理一些例如io复用处理
*/
/*----------------------------------------------------------------------------*/
static int dev_manager_del_prepare(int *msg)
{
    int ret = 0;
    switch (msg[0]) {
    case DRIVER_EVENT_FROM_SD0:
    case DRIVER_EVENT_FROM_SD1:
    case DRIVER_EVENT_FROM_SD2:
#if (USER_EX_WIRELESS_MIC_RECORD_MODE_EN && TCFG_APP_RECORD_EN)
        extern void ex_record_stream_close(void);
        extern void app_audio_mute(u8 value);
        if (get_rec_stream_state()) {
            ex_record_stream_close();
            app_audio_mute(1);
        }
#endif
        mult_sd_offline_before((char *)msg[2], g_usb_id);
        break;
//#if TCFG_UDISK_ENABLE || TCFG_HOST_AUDIO_ENABLE
//    case DEVICE_EVENT_FROM_OTG:
//        ///host umount
//        usb_host_unmount(g_usb_id);
//        break;
//#endif
    }
    return ret;
}

void audio_dac_power_state(u8 state){
    g_printf("audio_dac_power_state set state=%d 0x%x\n",state,JL_ADDA->DAA_CON2);
    extern struct audio_dac_hdl dac_hdl;
    switch (state){
    case DAC_ANALOG_CLOSE_FINISH:
        SFR(JL_ADDA->DAA_CON2,    23,  1,   1);            //SDDAC_TRIM_EN_11v
        break;
    case DAC_ANALOG_OPEN_FINISH:
        SFR(JL_ADDA->DAA_CON2,    23,  1,   0);            //SDDAC_TRIM_EN_11v
        break;
    default:
        break;
    }
    g_printf("audio_dac_power_state --- 0x%x\n",JL_ADDA->DAA_CON2);
}

//*----------------------------------------------------------------------------*/
/**@brief    linein 入口
  @param    无
  @return
  @note
 */
/*----------------------------------------------------------------------------*/
static int linein_tone_play_end_callback(void *priv, enum stream_event event)
{
    if (false == app_in_mode(APP_MODE_LINEIN)) {
        return 0;
    }
    switch (event) {
    case STREAM_EVENT_NONE:
    case STREAM_EVENT_STOP:
        // 注释掉原来lienin流程
        // app_send_message(APP_MSG_LINEIN_START, 0);

        //关dac偏置 设置dac为高阻态
        dac_power_off();
        break;
    default:
        break;
    }
    return 0;
}


void app_linein_exit()
{
    app_set_current_mode(app_get_mode_by_name(APP_MODE_NULL));        //这里把MODE设置成NULL，防止快速切模式的时候提示音还没播完已经退出当前模式，在提示音回调里还继续开广播
    linein_stop();
    linein_idle_flag = 1;
    app_send_message(APP_MSG_EXIT_MODE, APP_MODE_LINEIN);
    /* tone_player_stop(); */

    //恢复dac设置
    dac_power_on();
}

// 中断回调函数
gpio_irq_callback_p_test1(enum gpio_port port, u32 pin, enum gpio_irq_edge edge)
{
    printf("port%d.%d:%d-cb1\n", port, pin, edge);
}
// 中断初始化
    struct gpio_irq_config_st gpio_irq_config_C = {
        .pin = PORT_PIN_1|PORT_PIN_3|PORT_PIN_4|PORT_PIN_5, //PORT_PIN_
        .irq_edge = PORT_IRQ_EDGE_FALL,//PORT_IRQ_ANYEDGE
        .callback = gpio_irq_callback_p_test1,
        .irq_priority = 2, //中断优先级
    };
    gpio_irq_config(PORTC, &gpio_irq_config_C);

    struct gpio_irq_config_st gpio_irq_config_B = {
        .pin = PORT_PIN_0|PORT_PIN_1|PORT_PIN_3|PORT_PIN_4|PORT_PIN_5|PORT_PIN_6|PORT_PIN_7, //PORT_PIN_
        .irq_edge = PORT_IRQ_EDGE_FALL,//PORT_IRQ_ANYEDGE
        .callback = gpio_irq_callback_p_test1,
        .irq_priority = 2, //中断优先级
    };
    gpio_irq_config(PORTB, &gpio_irq_config_B);

    struct gpio_irq_config_st gpio_irq_config_A = {
        .pin = PORT_PIN_0|PORT_PIN_1|PORT_PIN_3|PORT_PIN_4|PORT_PIN_7, //PORT_PIN_
        .irq_edge = PORT_IRQ_EDGE_FALL,//PORT_IRQ_ANYEDGE
        .callback = gpio_irq_callback_p_test1,
        .irq_priority = 2, //中断优先级
    };
    gpio_irq_config(PORTA, &gpio_irq_config_A);

void mcpwm_test(void) //直接调用即可

void mcpwm_set_duty(int mcpwm_cfg_id, u16 duty)
{
    ASSERT(mcpwm_info[mcpwm_cfg_id] != NULL, "func:%s(), line:%d\n", __func__, __LINE__);
    int id = mcpwm_cfg_id;
    u32 ch = (u32)mcpwm_info[id]->cfg.ch;
    MCPWM_TIMERx_REG *timer_reg = mcpwm_get_timerx_reg(ch);
    MCPWM_CHx_REG *ch_reg = mcpwm_get_chx_reg(ch);

    u16 ch_cmph = 0;
    u16 ch_cmpl = 0;
    u16 tmr_cnt = 0;
    u16 tmr_con = timer_reg->tmr_con;
    u16 tmr_pr = timer_reg->tmr_pr;
    asm("csync");

    ch_cmpl = tmr_pr * duty / 10000;
    printf("---%d---%d---%d\n", ch_cmpl, tmr_pr, duty);
    ch_cmph = ch_cmpl;
    tmr_cnt = 0;
    /* tmr_con |= 0b01; */
    if (duty == 10000) {
        tmr_cnt = 0;
        tmr_con &= ~(0b11);
    } else if (duty == 0) {
        tmr_cnt = ch_cmpl;
        tmr_con &= ~(0b11);
    } else {
        if (mcpwm_info[id]->cfg.aligned_mode == MCPWM_CENTER_ALIGNED) { //中心对齐
            tmr_con |= 0b10; //递增-递降循环模式，中心对齐
        } else {
            tmr_con |= 0b01; //递增模式，边沿对齐
        }
    }

    spin_lock(&mcpwm_lock);
    ch_reg->ch_cmph = ch_cmph;
    ch_reg->ch_cmpl = ch_cmpl;
    u32 mcpwm_con = JL_MCPWM->MCPWM_CON0;
    JL_MCPWM->MCPWM_CON0 |= BIT(16);
    timer_reg->tmr_cnt = tmr_cnt;
    timer_reg->tmr_con = tmr_con;
    JL_MCPWM->MCPWM_CON0 = mcpwm_con;
    spin_unlock(&mcpwm_lock);
}