rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/services/bt_app/app_bt_func.cpp

869 lines
28 KiB
C++
Raw Blame History

/***************************************************************************
*
* 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 "hal_trace.h"
#include "string.h"
#include "app_ble_mode_switch.h"
#include "app_bt.h"
#include "app_bt_func.h"
#include "besbt.h"
#include "bluetooth.h"
#include "hfp_api.h"
#include "os_api.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;
}
Reference in New Issue View Git Blame Copy Permalink