pinebuds/services/bt_app/app_bt_func.cpp

/***************************************************************************
 *
 * Copyright 2015-2019 BES.
 * All rights reserved. All unpublished rights reserved.
 *
 * No part of this work may be used or reproduced in any form or by any
 * means, or stored in a database or retrieval system, without prior written
 * permission of BES.
 *
 * Use of this work is governed by a license granted by BES.
 * This work contains confidential and proprietary information of
 * BES. which is protected by copyright, trade secret,
 * trademark and other intellectual property rights.
 *
 ****************************************************************************/
#include "cmsis_os.h"
#include "string.h"
#include "hal_trace.h"

#include "bluetooth.h"
#include "besbt.h"
#include "app_bt_func.h"
#include "hfp_api.h"
#include "app_bt.h"
#include "os_api.h"
#include "app_ble_mode_switch.h"

extern "C" void OS_NotifyEvm(void);
static const char * const app_bt_func_table_str[] =
{
    "Me_switch_sco",
    "ME_SwitchRole",
    "ME_SetConnectionRole",
    "MeDisconnectLink",
    "ME_StopSniff",
    "ME_SetAccessibleMode",
    "Me_SetLinkPolicy",
    "CMGR_SetSniffTimer",
    "CMGR_SetSniffInofToAllHandlerByRemDev",
    "A2DP_OpenStream",
    "A2DP_CloseStream",
    "A2DP_SetMasterRole",
    "HF_CreateServiceLink",
    "HF_DisconnectServiceLink",
    "HF_CreateAudioLink",
    "HF_DisconnectAudioLink",
    "HF_EnableSniffMode",
    "HF_SetMasterRole",
    "HS_CreateServiceLink",
    "HS_CreateAudioLink",
    "HS_DisconnectAudioLink",
    "HS_EnableSniffMode",
    "HS_DisconnectServiceLink",
    "BT_Control_SleepMode",
    "BT_Custom_Func",
    "ME_StartSniff",
    "DIP_QuryService",
    "A2DP_Force_OpenStream",
    "HF_Force_CreateServiceLink",
    "app_set_access_mode_test",
    "app_set_adv_mode_test",
    "FPGA_write_mem_test",
    "FPGA_read_mem_test",
};

#define APP_BT_MAILBOX_MAX (40)
osMailQDef (app_bt_mailbox, APP_BT_MAILBOX_MAX, APP_BT_MAIL);
static osMailQId app_bt_mailbox = NULL;

static btif_accessible_mode_t gBT_DEFAULT_ACCESS_MODE = BTIF_BAM_NOT_ACCESSIBLE;
static uint8_t bt_access_mode_set_pending = 0;
void app_set_accessmode(btif_accessible_mode_t mode)
{
#if !defined(IBRT)
    const btif_access_mode_info_t info = { BTIF_BT_DEFAULT_INQ_SCAN_INTERVAL,
                                    BTIF_BT_DEFAULT_INQ_SCAN_WINDOW,
                                    BTIF_BT_DEFAULT_PAGE_SCAN_INTERVAL,
                                    BTIF_BT_DEFAULT_PAGE_SCAN_WINDOW };
    bt_status_t status;
    osapi_lock_stack();
    gBT_DEFAULT_ACCESS_MODE = mode;

    status =   btif_me_set_accessible_mode(mode, &info);
    TRACE(1,"app_set_accessmode status=0x%x",status);

    if(status == BT_STS_IN_PROGRESS)
        bt_access_mode_set_pending = 1;
    else
        bt_access_mode_set_pending = 0;
    osapi_unlock_stack();
#endif
}

bool app_is_access_mode_set_pending(void)
{
    return bt_access_mode_set_pending;
}

extern "C" void app_bt_accessmode_set(btif_accessible_mode_t mode);
void app_set_pending_access_mode(void)
{
    if (bt_access_mode_set_pending)
    {
        TRACE(1,"Pending for change access mode to %d", gBT_DEFAULT_ACCESS_MODE);
        bt_access_mode_set_pending = 0;
        app_bt_accessmode_set(gBT_DEFAULT_ACCESS_MODE);
    }
}

void app_retry_setting_access_mode(void)
{
    TRACE(0,"Former setting access mode failed, retry it.");
    app_bt_accessmode_set(gBT_DEFAULT_ACCESS_MODE);
}

#define PENDING_SET_LINKPOLICY_REQ_BUF_CNT  5
static BT_SET_LINKPOLICY_REQ_T pending_set_linkpolicy_req[PENDING_SET_LINKPOLICY_REQ_BUF_CNT];

static uint8_t pending_set_linkpolicy_in_cursor = 0;
static uint8_t pending_set_linkpolicy_out_cursor = 0;

static void app_bt_print_pending_set_linkpolicy_req(void)
{
    TRACE(0,"Pending set link policy requests:");
    uint8_t index = pending_set_linkpolicy_out_cursor;
    while (index != pending_set_linkpolicy_in_cursor)
    {
        TRACE(3,"index %d RemDev %p LinkPolicy %d", index,
            pending_set_linkpolicy_req[index].remDev,
            pending_set_linkpolicy_req[index].policy);
        index++;
        if (PENDING_SET_LINKPOLICY_REQ_BUF_CNT == index)
        {
            index = 0;
        }
    }
}

static void app_bt_push_pending_set_linkpolicy(btif_remote_device_t *remDev, btif_link_policy_t policy)
{
    // go through the existing pending list to see if the remDev is already in
    uint8_t index = pending_set_linkpolicy_out_cursor;
    while (index != pending_set_linkpolicy_in_cursor)
    {
        if (remDev == pending_set_linkpolicy_req[index].remDev)
        {
            pending_set_linkpolicy_req[index].policy = policy;
            return;
        }
        index++;
        if (PENDING_SET_LINKPOLICY_REQ_BUF_CNT == index)
        {
            index = 0;
        }
    }

    pending_set_linkpolicy_req[pending_set_linkpolicy_in_cursor].remDev = remDev;
    pending_set_linkpolicy_req[pending_set_linkpolicy_in_cursor].policy = policy;
    pending_set_linkpolicy_in_cursor++;
    if (PENDING_SET_LINKPOLICY_REQ_BUF_CNT == pending_set_linkpolicy_in_cursor)
    {
        pending_set_linkpolicy_in_cursor = 0;
    }

    app_bt_print_pending_set_linkpolicy_req();
}

BT_SET_LINKPOLICY_REQ_T* app_bt_pop_pending_set_linkpolicy(void)
{
    if (pending_set_linkpolicy_out_cursor == pending_set_linkpolicy_in_cursor)
    {
        return NULL;
    }

    BT_SET_LINKPOLICY_REQ_T* ptReq = &pending_set_linkpolicy_req[pending_set_linkpolicy_out_cursor];
    pending_set_linkpolicy_out_cursor++;
    if (PENDING_SET_LINKPOLICY_REQ_BUF_CNT == pending_set_linkpolicy_out_cursor)
    {
        pending_set_linkpolicy_out_cursor = 0;
    }

    app_bt_print_pending_set_linkpolicy_req();
    return ptReq;
}

void app_bt_set_linkpolicy(btif_remote_device_t *remDev, btif_link_policy_t policy)
{
    if (btif_me_get_remote_device_state(remDev) == BTIF_BDS_CONNECTED)
    {
        bt_status_t ret = btif_me_set_link_policy(remDev, policy);
        TRACE(3,"%s policy %d returns %d", __FUNCTION__, policy, ret);

        osapi_lock_stack();
        if (BT_STS_IN_PROGRESS == ret)
        {
            app_bt_push_pending_set_linkpolicy(remDev, policy);
        }
        osapi_unlock_stack();
    }
}

#define COUNT_OF_PENDING_REMOTE_DEV_TO_EXIT_SNIFF_MODE  8
static btif_remote_device_t* pendingRemoteDevToExitSniffMode[COUNT_OF_PENDING_REMOTE_DEV_TO_EXIT_SNIFF_MODE];
static uint8_t  maskOfRemoteDevPendingForExitingSniffMode = 0;
void app_check_pending_stop_sniff_op(void)
{
    if (maskOfRemoteDevPendingForExitingSniffMode > 0)
    {
        for (uint8_t index = 0;index < COUNT_OF_PENDING_REMOTE_DEV_TO_EXIT_SNIFF_MODE;index++)
        {
            if (maskOfRemoteDevPendingForExitingSniffMode & (1 << index))
            {
                btif_remote_device_t* remDev = pendingRemoteDevToExitSniffMode[index];
                if (!btif_me_is_op_in_progress(remDev))
                {
                    if (btif_me_get_remote_device_state(remDev) == BTIF_BDS_CONNECTED){
                        if (btif_me_get_current_mode(remDev) == BTIF_BLM_SNIFF_MODE){
                            TRACE(1,"!!! stop sniff currmode:%d\n",  btif_me_get_current_mode(remDev));
                            bt_status_t ret = btif_me_stop_sniff(remDev);
                            TRACE(1,"Return status %d", ret);
                            if (BT_STS_IN_PROGRESS != ret)
                            {
                                maskOfRemoteDevPendingForExitingSniffMode &= (~(1<<index));
                                break;
                            }
                        }
                    }
                }
            }
        }

        if (maskOfRemoteDevPendingForExitingSniffMode > 0)
        {
            osapi_notify_evm();
        }
    }
}

static void app_add_pending_stop_sniff_op(btif_remote_device_t* remDev)
{
    for (uint8_t index = 0;index < COUNT_OF_PENDING_REMOTE_DEV_TO_EXIT_SNIFF_MODE;index++)
    {
        if (maskOfRemoteDevPendingForExitingSniffMode & (1 << index))
        {
            if (pendingRemoteDevToExitSniffMode[index] == remDev)
            {
                return;
            }
        }
    }

    for (uint8_t index = 0;index < COUNT_OF_PENDING_REMOTE_DEV_TO_EXIT_SNIFF_MODE;index++)
    {
        if (0 == (maskOfRemoteDevPendingForExitingSniffMode & (1 << index)))
        {
            pendingRemoteDevToExitSniffMode[index] = remDev;
            maskOfRemoteDevPendingForExitingSniffMode |= (1 << index);
        }
    }
}

#ifdef FPGA
extern "C" bt_status_t app_tws_ibrt_set_access_mode(btif_accessible_mode_t mode);
void app_start_ble_adv_for_test(void);
#endif

static inline int app_bt_mail_process(APP_BT_MAIL* mail_p)
{
    bt_status_t status = BT_STS_LAST_CODE;
    if (mail_p->request_id != CMGR_SetSniffTimer_req){
        TRACE(3,"[BT_FUNC] src_thread:0x%08x call request_id=%x->:%s", mail_p->src_thread, mail_p->request_id,app_bt_func_table_str[mail_p->request_id]);
    }
    switch (mail_p->request_id) {
        case Me_switch_sco_req:
            status = btif_me_switch_sco(mail_p->param.Me_switch_sco_param.scohandle);
            break;
        case ME_SwitchRole_req:
            status = btif_me_switch_role(mail_p->param.ME_SwitchRole_param.remDev);
            break;
        case ME_SetConnectionRole_req:
            status = btif_me_set_connection_role(mail_p->param.BtConnectionRole_param.role);
            break;
        case MeDisconnectLink_req:
            status = btif_me_force_disconnect_link_with_reason(NULL, mail_p->param.MeDisconnectLink_param.remDev, BTIF_BEC_USER_TERMINATED, TRUE);
            break;
        case ME_StopSniff_req:
        {
            if (btif_me_get_remote_device_state(mail_p->param.ME_StopSniff_param.remDev) == BTIF_BDS_CONNECTED)
            {
                status = btif_me_stop_sniff(mail_p->param.ME_StopSniff_param.remDev);
                if (BT_STS_IN_PROGRESS == status)
                {
                    app_add_pending_stop_sniff_op(mail_p->param.ME_StopSniff_param.remDev);
                }
            }
            break;
        }
        case ME_StartSniff_req:
        {
            if (btif_me_get_remote_device_state(mail_p->param.ME_StartSniff_param.remDev) == BTIF_BDS_CONNECTED)
            {
                status = btif_me_start_sniff (mail_p->param.ME_StartSniff_param.remDev,
                    &(mail_p->param.ME_StartSniff_param.sniffInfo));
            }
            break;
        }
        case BT_Control_SleepMode_req:
        {
            btif_me_write_bt_sleep_enable(mail_p->param.ME_BtControlSleepMode_param.isEnable);
            break;
        }
        case ME_SetAccessibleMode_req:
            app_set_accessmode(mail_p->param.ME_SetAccessibleMode_param.mode);
            break;
        case Me_SetLinkPolicy_req:
            app_bt_set_linkpolicy(mail_p->param.Me_SetLinkPolicy_param.remDev,
                                      mail_p->param.Me_SetLinkPolicy_param.policy);
            break;
        case CMGR_SetSniffTimer_req:
            if (mail_p->param.CMGR_SetSniffTimer_param.SniffInfo.maxInterval == 0){
                status = btif_cmgr_set_sniff_timer(mail_p->param.CMGR_SetSniffTimer_param.Handler,
                                            NULL,
                                            mail_p->param.CMGR_SetSniffTimer_param.Time);
            }else{
                status = btif_cmgr_set_sniff_timer(mail_p->param.CMGR_SetSniffTimer_param.Handler,
                                            &mail_p->param.CMGR_SetSniffTimer_param.SniffInfo,
                                            mail_p->param.CMGR_SetSniffTimer_param.Time);
            }
            break;
        case CMGR_SetSniffInofToAllHandlerByRemDev_req:
            status = btif_cmgr_set_sniff_info_to_all_handler_by_remdev(&mail_p->param.CMGR_SetSniffInofToAllHandlerByRemDev_param.SniffInfo,
                                                            mail_p->param.CMGR_SetSniffInofToAllHandlerByRemDev_param.RemDev);
            break;
        case A2DP_OpenStream_req:
            status = btif_a2dp_open_stream(mail_p->param.A2DP_OpenStream_param.Stream,
                                     mail_p->param.A2DP_OpenStream_param.Addr);
            if ((BT_STS_NO_RESOURCES == status) || (BT_STS_IN_PROGRESS == status))
            {
                app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                app_bt_reset_reconnect_timer(mail_p->param.A2DP_OpenStream_param.Addr);
            }
            else
            {
                app_bt_accessmode_set(BTIF_BAM_NOT_ACCESSIBLE);
            }
            break;
        case A2DP_CloseStream_req:
            status = btif_a2dp_close_stream(mail_p->param.A2DP_CloseStream_param.Stream);
            break;
        case A2DP_SetMasterRole_req:
            status = btif_a2dp_set_master_role(mail_p->param.A2DP_SetMasterRole_param.Stream,
                                        mail_p->param.A2DP_SetMasterRole_param.Flag);
            break;
        case HF_CreateServiceLink_req:
            status = btif_hf_create_service_link(mail_p->param.HF_CreateServiceLink_param.Chan,
                                          mail_p->param.HF_CreateServiceLink_param.Addr);
            if ((BT_STS_NO_RESOURCES == status) || (BT_STS_IN_PROGRESS == status))
            {
                app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                app_bt_reset_reconnect_timer(mail_p->param.HF_CreateServiceLink_param.Addr);
            }
            else
            {
                app_bt_accessmode_set(BTIF_BAM_NOT_ACCESSIBLE);
            }
            break;
        case HF_DisconnectServiceLink_req:
            status = btif_hf_disconnect_service_link(mail_p->param.HF_DisconnectServiceLink_param.Chan);
            break;
        case HF_CreateAudioLink_req:
            status = btif_hf_create_audio_link(mail_p->param.HF_CreateAudioLink_param.Chan);
            break;
        case HF_DisconnectAudioLink_req:
            status = btif_hf_disc_audio_link(mail_p->param.HF_DisconnectAudioLink_param.Chan);
            break;
        case HF_EnableSniffMode_req:
            status = btif_hf_enable_sniff_mode(mail_p->param.HF_EnableSniffMode_param.Chan,
                                        mail_p->param.HF_EnableSniffMode_param.Enable);
            break;
        case HF_SetMasterRole_req:
            status = btif_hf_set_master_role(mail_p->param.HF_SetMasterRole_param.Chan,
                                      mail_p->param.HF_SetMasterRole_param.Flag);
            break;
#ifdef BTIF_DIP_DEVICE
        case DIP_QuryService_req:
            status = btif_dip_query_for_service(mail_p->param.DIP_QuryService_param.dip_client,
                              mail_p->param.DIP_QuryService_param.remDev);
            break;
#endif
#if defined (__HSP_ENABLE__)
        case HS_CreateServiceLink_req:
            app_bt_accessmode_set(BTIF_BAM_NOT_ACCESSIBLE);
            status = HS_CreateServiceLink(mail_p->param.HS_CreateServiceLink_param.Chan,
                                          mail_p->param.HS_CreateServiceLink_param.Addr);
            break;
        case HS_CreateAudioLink_req:
            status = HS_CreateAudioLink(mail_p->param.HS_CreateAudioLink_param.Chan);
            break;
        case HS_DisconnectAudioLink_req:
            status = HS_DisconnectAudioLink(mail_p->param.HS_DisconnectAudioLink_param.Chan);
            break;
        case HS_DisconnectServiceLink_req:
            status = HS_DisconnectServiceLink(mail_p->param.HS_DisconnectServiceLink_param.Chan);
            break;
        case HS_EnableSniffMode_req:
            status = HS_EnableSniffMode(mail_p->param.HS_EnableSniffMode_param.Chan,
                                        mail_p->param.HS_EnableSniffMode_param.Enable);
            break;
#endif
#ifdef FPGA
        case BT_Set_Access_Mode_Test:
#if defined(IBRT)
            app_tws_ibrt_set_access_mode(mail_p->param.ME_SetAccessibleMode_param.mode);
#else
            app_set_accessmode(mail_p->param.ME_SetAccessibleMode_param.mode);
#endif
            break;
        case BT_Set_Adv_Mode_Test:
#if defined(IBRT)
        app_start_ble_adv_for_test();
#endif            
            break;
        case Write_Controller_Memory_Test:
        {
            status = btif_me_write_controller_memory(mail_p->param.Me_writecontrollermem_param.addr,
                                                     mail_p->param.Me_writecontrollermem_param.memval,
                                                     mail_p->param.Me_writecontrollermem_param.type);
            break;
        }
        case Read_Controller_Memory_Test:
        {
            status = btif_me_read_controller_memory(mail_p->param.Me_readcontrollermem_param.addr,
                                                     mail_p->param.Me_readcontrollermem_param.len,
                                                     mail_p->param.Me_readcontrollermem_param.type);
            break;
        }
#endif        
        case BT_Custom_Func_req:
            if (mail_p->param.CustomFunc_param.func_ptr){
                TRACE(3,"func:0x%08x,param0:0x%08x, param1:0x%08x",
                      mail_p->param.CustomFunc_param.func_ptr,
                      mail_p->param.CustomFunc_param.param0,
                      mail_p->param.CustomFunc_param.param1);
                ((APP_BTTHREAD_REQ_CUSTOMER_CALL_CB_T)(mail_p->param.CustomFunc_param.func_ptr))(
                    (void *)mail_p->param.CustomFunc_param.param0,
                    (void *)mail_p->param.CustomFunc_param.param1);
            }
            break;
    }

    if (mail_p->request_id != CMGR_SetSniffTimer_req){
        TRACE(2,"[BT_FUNC] exit request_id:%d :status:%d", mail_p->request_id, status);
    }
    return 0;
}

static inline int app_bt_mail_alloc(APP_BT_MAIL** mail)
{
    *mail = (APP_BT_MAIL*)osMailAlloc(app_bt_mailbox, 0);
    ASSERT(*mail, "app_bt_mail_alloc error");
    return 0;
}

static inline int app_bt_mail_send(APP_BT_MAIL* mail)
{
    osStatus status;

    ASSERT(mail, "osMailAlloc NULL");
    status = osMailPut(app_bt_mailbox, mail);
    ASSERT(osOK == status, "osMailAlloc Put failed");

    OS_NotifyEvm();

    return (int)status;
}

static inline int app_bt_mail_free(APP_BT_MAIL* mail_p)
{
    osStatus status;

    status = osMailFree(app_bt_mailbox, mail_p);
    ASSERT(osOK == status, "osMailAlloc Put failed");

    return (int)status;
}

static inline int app_bt_mail_get(APP_BT_MAIL** mail_p)
{
    osEvent evt;
    evt = osMailGet(app_bt_mailbox, 0);
    if (evt.status == osEventMail) {
        *mail_p = (APP_BT_MAIL *)evt.value.p;
        return 0;
    }
    return -1;
}

static void app_bt_mail_poll(void)
{
    APP_BT_MAIL *mail_p = NULL;
    if (!app_bt_mail_get(&mail_p)){
        app_bt_mail_process(mail_p);
        app_bt_mail_free(mail_p);
        osapi_notify_evm();
    }
}

int app_bt_mail_init(void)
{
    app_bt_mailbox = osMailCreate(osMailQ(app_bt_mailbox), NULL);
    if (app_bt_mailbox == NULL)  {
        TRACE(0,"Failed to Create app_mailbox\n");
        return -1;
    }
    Besbt_hook_handler_set(BESBT_HOOK_USER_1, app_bt_mail_poll);

    return 0;
}

int app_bt_Me_switch_sco(uint16_t  scohandle)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = Me_switch_sco_req;
    mail->param.Me_switch_sco_param.scohandle = scohandle;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_ME_SwitchRole(btif_remote_device_t* remDev)
{
#if !defined(IBRT)
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = ME_SwitchRole_req;
    mail->param.ME_SwitchRole_param.remDev = remDev;
    app_bt_mail_send(mail);
#endif
    return 0;
}

int app_bt_ME_SetConnectionRole(btif_connection_role_t  role)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = ME_SetConnectionRole_req;
    mail->param.BtConnectionRole_param.role = role;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_MeDisconnectLink(btif_remote_device_t* remDev)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = MeDisconnectLink_req;
    mail->param.MeDisconnectLink_param.remDev = remDev;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_ME_StopSniff(btif_remote_device_t *remDev)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = ME_StopSniff_req;
    mail->param.ME_StopSniff_param.remDev = remDev;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_ME_StartSniff(btif_remote_device_t *remDev, btif_sniff_info_t* sniffInfo)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = ME_StartSniff_req;
    mail->param.ME_StartSniff_param.remDev = remDev;
    mail->param.ME_StartSniff_param.sniffInfo = *sniffInfo;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_ME_ControlSleepMode(bool isEnabled)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = BT_Control_SleepMode_req;
    mail->param.ME_BtControlSleepMode_param.isEnable = isEnabled;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_ME_SetAccessibleMode(btif_accessible_mode_t mode, const btif_access_mode_info_t *info)
{
#if defined(BLE_ONLY_ENABLED)
    return 0;
#endif

    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = ME_SetAccessibleMode_req;
    mail->param.ME_SetAccessibleMode_param.mode = mode;
    memcpy(&mail->param.ME_SetAccessibleMode_param.info, info, sizeof(btif_access_mode_info_t));
    app_bt_mail_send(mail);
    return 0;
}

#ifdef FPGA
int app_bt_ME_SetAccessibleMode_Fortest(btif_accessible_mode_t mode, const btif_access_mode_info_t *info)
{
#if defined(BLE_ONLY_ENABLED)
    return 0;
#endif

    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = BT_Set_Access_Mode_Test;
    mail->param.ME_SetAccessibleMode_param.mode = mode;
    memcpy(&mail->param.ME_SetAccessibleMode_param.info, info, sizeof(btif_access_mode_info_t));
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_ME_Set_Advmode_Fortest(uint8_t en)
{


    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = BT_Set_Adv_Mode_Test;
    mail->param.ME_BtSetAdvMode_param.isEnable = en;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_ME_Write_Controller_Memory_Fortest(uint32_t addr,uint32_t val,uint8_t type)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = Write_Controller_Memory_Test;
    mail->param.Me_writecontrollermem_param.addr = addr;
    mail->param.Me_writecontrollermem_param.memval = val;
    mail->param.Me_writecontrollermem_param.type = type;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_ME_Read_Controller_Memory_Fortest(uint32_t addr,uint32_t len,uint8_t type)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = Read_Controller_Memory_Test;
    mail->param.Me_readcontrollermem_param.addr = addr;
    mail->param.Me_readcontrollermem_param.len = len;
    mail->param.Me_readcontrollermem_param.type = type;
    app_bt_mail_send(mail);
    return 0;
}

#endif

int app_bt_Me_SetLinkPolicy(btif_remote_device_t *remDev, btif_link_policy_t policy)
{
#if !defined(IBRT)
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = Me_SetLinkPolicy_req;
    mail->param.Me_SetLinkPolicy_param.remDev = remDev;
    mail->param.Me_SetLinkPolicy_param.policy = policy;
    app_bt_mail_send(mail);
#endif
    return 0;
}

int app_bt_CMGR_SetSniffTimer(   btif_cmgr_handler_t *Handler,
                                                btif_sniff_info_t* SniffInfo,
                                                TimeT Time)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = CMGR_SetSniffTimer_req;
    mail->param.CMGR_SetSniffTimer_param.Handler = Handler;
    if (SniffInfo){
        memcpy(&mail->param.CMGR_SetSniffTimer_param.SniffInfo, SniffInfo, sizeof(btif_sniff_info_t));
    }else{
        memset(&mail->param.CMGR_SetSniffTimer_param.SniffInfo, 0, sizeof(btif_sniff_info_t));
    }
    mail->param.CMGR_SetSniffTimer_param.Time = Time;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_CMGR_SetSniffInfoToAllHandlerByRemDev(btif_sniff_info_t* SniffInfo,
                                                                 btif_remote_device_t *RemDev)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = CMGR_SetSniffInofToAllHandlerByRemDev_req;
    memcpy(&mail->param.CMGR_SetSniffInofToAllHandlerByRemDev_param.SniffInfo, SniffInfo, sizeof(btif_sniff_info_t));
    mail->param.CMGR_SetSniffInofToAllHandlerByRemDev_param.RemDev = RemDev;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_A2DP_OpenStream(a2dp_stream_t *Stream, bt_bdaddr_t *Addr)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = A2DP_OpenStream_req;
    mail->param.A2DP_OpenStream_param.Stream = Stream;
    mail->param.A2DP_OpenStream_param.Addr = Addr;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_A2DP_CloseStream(a2dp_stream_t *Stream)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = A2DP_CloseStream_req;
    mail->param.A2DP_CloseStream_param.Stream = Stream;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_A2DP_SetMasterRole(a2dp_stream_t *Stream, BOOL Flag)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = A2DP_SetMasterRole_req;
    mail->param.A2DP_SetMasterRole_param.Stream = Stream;
    mail->param.A2DP_SetMasterRole_param.Flag = Flag;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_HF_CreateServiceLink(hf_chan_handle_t Chan, bt_bdaddr_t *Addr)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HF_CreateServiceLink_req;
    mail->param.HF_CreateServiceLink_param.Chan = Chan;
    mail->param.HF_CreateServiceLink_param.Addr = Addr;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_HF_DisconnectServiceLink(hf_chan_handle_t Chan)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HF_DisconnectServiceLink_req;
    mail->param.HF_DisconnectServiceLink_param.Chan = Chan;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_HF_CreateAudioLink(hf_chan_handle_t Chan)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HF_CreateAudioLink_req;
    mail->param.HF_CreateAudioLink_param.Chan = Chan;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_HF_DisconnectAudioLink(hf_chan_handle_t Chan)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HF_DisconnectAudioLink_req;
    mail->param.HF_DisconnectAudioLink_param.Chan = Chan;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_HF_EnableSniffMode(hf_chan_handle_t Chan, BOOL Enable)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HF_EnableSniffMode_req;
    mail->param.HF_EnableSniffMode_param.Chan = Chan;
    mail->param.HF_EnableSniffMode_param.Enable = Enable;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_HF_SetMasterRole(hf_chan_handle_t Chan, BOOL Flag)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HF_SetMasterRole_req;
    mail->param.HF_SetMasterRole_param.Chan = Chan;
    mail->param.HF_SetMasterRole_param.Flag = Flag;
    app_bt_mail_send(mail);
    return 0;
}

#ifdef BTIF_DIP_DEVICE
int app_bt_dip_QuryService(btif_dip_client_t *client, btif_remote_device_t* rem)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = DIP_QuryService_req;
    mail->param.DIP_QuryService_param.remDev = rem;
    mail->param.DIP_QuryService_param.dip_client = client;
    app_bt_mail_send(mail);
    return 0;
}
#endif

#if defined (__HSP_ENABLE__)
int app_bt_HS_CreateServiceLink(HsChannel *Chan, bt_bdaddr_t *Addr)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HS_CreateServiceLink_req;
    mail->param.HS_CreateServiceLink_param.Chan = Chan;
    mail->param.HS_CreateServiceLink_param.Addr = Addr;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_HS_CreateAudioLink(HsChannel *Chan)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HS_CreateAudioLink_req;
    mail->param.HS_CreateAudioLink_param.Chan = Chan;
    app_bt_mail_send(mail);
    return 0;
}


int app_bt_HS_DisconnectAudioLink(HsChannel *Chan)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HS_DisconnectAudioLink_req;
    mail->param.HS_DisconnectAudioLink_param.Chan = Chan;
    app_bt_mail_send(mail);
    return 0;
}

int app_bt_HS_DisconnectServiceLink(HsChannel *Chan)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HS_DisconnectServiceLink_req;
    mail->param.HS_DisconnectServiceLink_param.Chan = Chan;
    app_bt_mail_send(mail);
    return 0;
}


int app_bt_HS_EnableSniffMode(HsChannel *Chan, BOOL Enable)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = HS_EnableSniffMode_req;
    mail->param.HS_EnableSniffMode_param.Chan = Chan;
    mail->param.HS_EnableSniffMode_param.Enable = Enable;
    app_bt_mail_send(mail);
    return 0;
}

#endif
int app_bt_start_custom_function_in_bt_thread(
    uint32_t param0, uint32_t param1, uint32_t funcPtr)
{
    APP_BT_MAIL* mail;
    app_bt_mail_alloc(&mail);
    mail->src_thread = (uint32_t)osThreadGetId();
    mail->request_id = BT_Custom_Func_req;
    mail->param.CustomFunc_param.func_ptr = funcPtr;
    mail->param.CustomFunc_param.param0 = param0;
    mail->param.CustomFunc_param.param1 = param1;
    app_bt_mail_send(mail);
    return 0;
}