895 lines
23 KiB
C
895 lines
23 KiB
C
/**
|
|
****************************************************************************************
|
|
* @addtogroup PRF
|
|
* @{
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
* INCLUDE FILES
|
|
****************************************************************************************
|
|
*/
|
|
|
|
#include "rwip_config.h"
|
|
|
|
#if (BLE_PROFILES)
|
|
#include "prf.h"
|
|
#include "att.h"
|
|
|
|
|
|
#if (BLE_HT_THERMOM)
|
|
extern const struct prf_task_cbs* htpt_prf_itf_get(void);
|
|
#endif // (BLE_HT_THERMOM)
|
|
|
|
#if (BLE_HT_COLLECTOR)
|
|
extern const struct prf_task_cbs* htpc_prf_itf_get(void);
|
|
#endif // (BLE_HT_COLLECTOR)
|
|
|
|
#if (BLE_DIS_SERVER)
|
|
extern const struct prf_task_cbs* diss_prf_itf_get(void);
|
|
#endif // (BLE_HT_THERMOM)
|
|
|
|
#if (BLE_DIS_CLIENT)
|
|
extern const struct prf_task_cbs* disc_prf_itf_get(void);
|
|
#endif // (BLE_DIS_CLIENT)
|
|
|
|
#if (BLE_BP_SENSOR)
|
|
extern const struct prf_task_cbs* blps_prf_itf_get(void);
|
|
#endif // (BLE_BP_SENSOR)
|
|
|
|
#if (BLE_BP_COLLECTOR)
|
|
extern const struct prf_task_cbs* blpc_prf_itf_get(void);
|
|
#endif // (BLE_BP_COLLECTOR)
|
|
|
|
#if (BLE_TIP_SERVER)
|
|
extern const struct prf_task_cbs* tips_prf_itf_get(void);
|
|
#endif // (BLE_TIP_SERVER)
|
|
|
|
#if (BLE_TIP_CLIENT)
|
|
extern const struct prf_task_cbs* tipc_prf_itf_get(void);
|
|
#endif // (BLE_TIP_CLIENT)
|
|
|
|
#if (BLE_HR_SENSOR)
|
|
extern const struct prf_task_cbs* hrps_prf_itf_get(void);
|
|
#endif // (BLE_HR_SENSOR)
|
|
|
|
#if (BLE_HR_COLLECTOR)
|
|
extern const struct prf_task_cbs* hrpc_prf_itf_get(void);
|
|
#endif // (BLE_HR_COLLECTOR)
|
|
|
|
#if (BLE_FINDME_LOCATOR)
|
|
extern const struct prf_task_cbs* findl_prf_itf_get(void);
|
|
#endif // (BLE_FINDME_LOCATOR)
|
|
|
|
#if (BLE_FINDME_TARGET)
|
|
extern const struct prf_task_cbs* findt_prf_itf_get(void);
|
|
#endif // (BLE_FINDME_TARGET)
|
|
|
|
#if (BLE_PROX_MONITOR)
|
|
extern const struct prf_task_cbs* proxm_prf_itf_get(void);
|
|
#endif // (BLE_PROX_MONITOR)
|
|
|
|
#if (BLE_PROX_REPORTER)
|
|
extern const struct prf_task_cbs* proxr_prf_itf_get(void);
|
|
#endif // (BLE_PROX_REPORTER)
|
|
|
|
#if (BLE_SP_CLIENT)
|
|
extern const struct prf_task_cbs* scppc_prf_itf_get(void);
|
|
#endif // (BLE_SP_CLENT)
|
|
|
|
#if (BLE_SP_SERVER)
|
|
extern const struct prf_task_cbs* scpps_prf_itf_get(void);
|
|
#endif // (BLE_SP_SERVER)
|
|
|
|
#if (BLE_BATT_CLIENT)
|
|
extern const struct prf_task_cbs* basc_prf_itf_get(void);
|
|
#endif // (BLE_BATT_CLIENT)
|
|
|
|
#if (BLE_BATT_SERVER)
|
|
extern const struct prf_task_cbs* bass_prf_itf_get(void);
|
|
#endif // (BLE_BATT_SERVER)
|
|
|
|
#if (BLE_HID_DEVICE)
|
|
extern const struct prf_task_cbs* hogpd_prf_itf_get(void);
|
|
#endif // (BLE_HID_DEVICE)
|
|
|
|
#if (BLE_HID_BOOT_HOST)
|
|
extern const struct prf_task_cbs* hogpbh_prf_itf_get(void);
|
|
#endif // (BLE_HID_BOOT_HOST)
|
|
|
|
#if (BLE_HID_REPORT_HOST)
|
|
extern const struct prf_task_cbs* hogprh_prf_itf_get(void);
|
|
#endif // (BLE_HID_REPORT_HOST)
|
|
|
|
#if (BLE_GL_COLLECTOR)
|
|
extern const struct prf_task_cbs* glpc_prf_itf_get(void);
|
|
#endif // (BLE_GL_COLLECTOR)
|
|
|
|
#if (BLE_GL_SENSOR)
|
|
extern const struct prf_task_cbs* glps_prf_itf_get(void);
|
|
#endif // (BLE_GL_SENSOR)
|
|
|
|
#if (BLE_RSC_COLLECTOR)
|
|
extern const struct prf_task_cbs* rscpc_prf_itf_get(void);
|
|
#endif // (BLE_RSC_COLLECTOR)
|
|
|
|
#if (BLE_RSC_SENSOR)
|
|
extern const struct prf_task_cbs* rscps_prf_itf_get(void);
|
|
#endif // (BLE_RSC_COLLECTOR)
|
|
|
|
#if (BLE_CSC_COLLECTOR)
|
|
extern const struct prf_task_cbs* cscpc_prf_itf_get(void);
|
|
#endif // (BLE_CSC_COLLECTOR)
|
|
|
|
#if (BLE_CSC_SENSOR)
|
|
extern const struct prf_task_cbs* cscps_prf_itf_get(void);
|
|
#endif // (BLE_CSC_COLLECTOR)
|
|
|
|
#if (BLE_AN_CLIENT)
|
|
extern const struct prf_task_cbs* anpc_prf_itf_get(void);
|
|
#endif // (BLE_AN_CLIENT)
|
|
|
|
#if (BLE_AN_SERVER)
|
|
extern const struct prf_task_cbs* anps_prf_itf_get(void);
|
|
#endif // (BLE_AN_SERVER)
|
|
|
|
#if (BLE_PAS_CLIENT)
|
|
extern const struct prf_task_cbs* paspc_prf_itf_get(void);
|
|
#endif // (BLE_PAS_CLIENT)
|
|
|
|
#if (BLE_PAS_SERVER)
|
|
extern const struct prf_task_cbs* pasps_prf_itf_get(void);
|
|
#endif // (BLE_PAS_SERVER)
|
|
|
|
#if (BLE_CP_COLLECTOR)
|
|
extern const struct prf_task_cbs* cppc_prf_itf_get(void);
|
|
#endif //(BLE_CP_COLLECTOR)
|
|
|
|
#if (BLE_CP_SENSOR)
|
|
extern const struct prf_task_cbs* cpps_prf_itf_get(void);
|
|
#endif //(BLE_CP_SENSOR)
|
|
|
|
#if (BLE_LN_COLLECTOR)
|
|
extern const struct prf_task_cbs* lanc_prf_itf_get(void);
|
|
#endif //(BLE_CP_COLLECTOR)
|
|
|
|
#if (BLE_LN_SENSOR)
|
|
extern const struct prf_task_cbs* lans_prf_itf_get(void);
|
|
#endif //(BLE_CP_SENSOR)
|
|
|
|
#if (BLE_IPS_SERVER)
|
|
extern const struct prf_task_cbs* ipss_prf_itf_get(void);
|
|
#endif //(BLE_IPS_SERVER)
|
|
|
|
#if (BLE_IPS_CLIENT)
|
|
extern const struct prf_task_cbs* ipsc_prf_itf_get(void);
|
|
#endif //(BLE_IPS_CLIENT)
|
|
|
|
#if (BLE_ENV_SERVER)
|
|
extern const struct prf_task_cbs* envs_prf_itf_get(void);
|
|
#endif //(BLE_ENV_SERVER)
|
|
|
|
#if (BLE_ENV_CLIENT)
|
|
extern const struct prf_task_cbs* envc_prf_itf_get(void);
|
|
#endif //(BLE_ENV_CLIENT
|
|
|
|
#if (BLE_WSC_SERVER)
|
|
extern const struct prf_task_cbs* wscs_prf_itf_get(void);
|
|
#endif //(BLE_WSC_SERVER)
|
|
|
|
#if (BLE_WSC_CLIENT)
|
|
extern const struct prf_task_cbs* wscc_prf_itf_get(void);
|
|
#endif //(BLE_WSC_CLIENT
|
|
|
|
#if (BLE_BCS_SERVER)
|
|
extern const struct prf_task_cbs* bcss_prf_itf_get(void);
|
|
#endif //(BLE_BCS_SERVER)
|
|
|
|
#if (BLE_BCS_CLIENT)
|
|
extern const struct prf_task_cbs* bcsc_prf_itf_get(void);
|
|
#endif //(BLE_BCS_CLIENT)
|
|
|
|
#ifdef BLE_AM0_HEARING_AID_SERV
|
|
extern const struct prf_task_cbs* am0_has_prf_itf_get(void);
|
|
#endif // BLE_AM0_HEARING_AID_SERV
|
|
|
|
#if (BLE_UDS_SERVER)
|
|
extern const struct prf_task_cbs* udss_prf_itf_get(void);
|
|
#endif //(BLE_UDS_SERVER)
|
|
|
|
#if (BLE_UDS_CLIENT)
|
|
extern const struct prf_task_cbs* udsc_prf_itf_get(void);
|
|
#endif //(BLE_UDS_CLIENT)
|
|
|
|
#if (BLE_VOICEPATH)
|
|
extern const struct prf_task_cbs* voicepath_prf_itf_get(void);
|
|
#endif //(BLE_VOICEPATH)
|
|
|
|
#if (BLE_DATAPATH_SERVER)
|
|
extern const struct prf_task_cbs* datapathps_prf_itf_get(void);
|
|
#endif //(BLE_DATAPATH_SERVER)
|
|
|
|
#if (BLE_OTA)
|
|
extern const struct prf_task_cbs* ota_prf_itf_get(void);
|
|
#endif //(BLE_OTA)
|
|
|
|
#if (BLE_TOTA)
|
|
extern const struct prf_task_cbs* tota_prf_itf_get(void);
|
|
#endif //(BLE_TOTA)
|
|
|
|
#if (BLE_BMS)
|
|
extern const struct prf_task_cbs* bms_prf_itf_get(void);
|
|
#endif //(BLE_BMS)
|
|
|
|
|
|
#if (BLE_ANC_CLIENT)
|
|
extern const struct prf_task_cbs* ancc_prf_itf_get(void);
|
|
#endif //(BLE_ANC_CLIENT)
|
|
|
|
#if (BLE_AMS_CLIENT)
|
|
extern const struct prf_task_cbs* amsc_prf_itf_get(void);
|
|
#endif //(BLE_AMS_CLIENT)
|
|
|
|
#if (BLE_GFPS_PROVIDER)
|
|
extern const struct prf_task_cbs* gfpsp_prf_itf_get(void);
|
|
#endif //(BLE_GFPS_PROVIDER)
|
|
|
|
#ifdef BLE_AI_VOICE
|
|
extern const struct prf_task_cbs* ai_prf_itf_get(void);
|
|
#endif
|
|
|
|
#if (ANCS_PROXY_ENABLE)
|
|
extern const struct prf_task_cbs* ancs_proxy_prf_itf_get(void);
|
|
extern const struct prf_task_cbs* ams_proxy_prf_itf_get(void);
|
|
#endif
|
|
|
|
#if (BLE_TILE)
|
|
extern const struct prf_task_cbs* tile_prf_itf_get(void);
|
|
#endif //(BLE_TILE)
|
|
|
|
/*
|
|
* TYPE DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
|
|
/*
|
|
* DEFINES
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
* MACROS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
|
|
/*
|
|
* GLOBAL VARIABLE DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
struct prf_env_tag prf_env;
|
|
|
|
/*
|
|
* LOCAL FUNCTIONS DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Retrieve profile interface
|
|
****************************************************************************************
|
|
*/
|
|
static const struct prf_task_cbs * prf_itf_get(uint16_t task_id)
|
|
{
|
|
const struct prf_task_cbs* prf_cbs = NULL;
|
|
|
|
BLE_DBG(">>>>>> prf_itf_get task_id: %d task_id %d<<<<<<\n", KE_TYPE_GET(task_id), task_id);
|
|
switch(KE_TYPE_GET(task_id))
|
|
{
|
|
#if (BLE_HT_THERMOM)
|
|
case TASK_ID_HTPT:
|
|
prf_cbs = htpt_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_HT_THERMOM)
|
|
|
|
#if (BLE_HT_COLLECTOR)
|
|
case TASK_ID_HTPC:
|
|
prf_cbs = htpc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_HT_COLLECTOR)
|
|
|
|
#if (BLE_DIS_SERVER)
|
|
case TASK_ID_DISS:
|
|
prf_cbs = diss_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_DIS_SERVER)
|
|
|
|
#if (BLE_DIS_CLIENT)
|
|
case TASK_ID_DISC:
|
|
prf_cbs = disc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_DIS_CLIENT)
|
|
|
|
#if (BLE_BP_SENSOR)
|
|
case TASK_ID_BLPS:
|
|
prf_cbs = blps_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_BP_SENSOR)
|
|
|
|
#if (BLE_BP_COLLECTOR)
|
|
case TASK_ID_BLPC:
|
|
prf_cbs = blpc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_BP_COLLECTOR)
|
|
|
|
#if (BLE_TIP_SERVER)
|
|
case TASK_ID_TIPS:
|
|
prf_cbs = tips_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_TIP_SERVER)
|
|
|
|
#if (BLE_TIP_CLIENT)
|
|
case TASK_ID_TIPC:
|
|
prf_cbs = tipc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_TIP_CLIENT)
|
|
|
|
#if (BLE_HR_SENSOR)
|
|
case TASK_ID_HRPS:
|
|
prf_cbs = hrps_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_HR_SENSOR)
|
|
|
|
#if (BLE_HR_COLLECTOR)
|
|
case TASK_ID_HRPC:
|
|
prf_cbs = hrpc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_HR_COLLECTOR)
|
|
|
|
#if (BLE_FINDME_LOCATOR)
|
|
case TASK_ID_FINDL:
|
|
prf_cbs = findl_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_FINDME_LOCATOR)
|
|
|
|
#if (BLE_FINDME_TARGET)
|
|
case TASK_ID_FINDT:
|
|
prf_cbs = findt_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_FINDME_TARGET)
|
|
|
|
#if (BLE_PROX_MONITOR)
|
|
case TASK_ID_PROXM:
|
|
prf_cbs = proxm_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_PROX_MONITOR)
|
|
|
|
#if (BLE_PROX_REPORTER)
|
|
case TASK_ID_PROXR:
|
|
prf_cbs = proxr_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_PROX_REPORTER)
|
|
|
|
#if (BLE_SP_SERVER)
|
|
case TASK_ID_SCPPS:
|
|
prf_cbs = scpps_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_SP_SERVER)
|
|
|
|
#if (BLE_SP_CLIENT)
|
|
case TASK_ID_SCPPC:
|
|
prf_cbs = scppc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_SP_CLIENT)
|
|
|
|
#if (BLE_BATT_SERVER)
|
|
case TASK_ID_BASS:
|
|
prf_cbs = bass_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_BATT_SERVER)
|
|
|
|
#if (BLE_BATT_CLIENT)
|
|
case TASK_ID_BASC:
|
|
prf_cbs = basc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_BATT_CLIENT)
|
|
|
|
#if (BLE_HID_DEVICE)
|
|
case TASK_ID_HOGPD:
|
|
prf_cbs = hogpd_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_HID_DEVICE)
|
|
|
|
#if (BLE_HID_BOOT_HOST)
|
|
case TASK_ID_HOGPBH:
|
|
prf_cbs = hogpbh_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_HID_BOOT_HOST)
|
|
|
|
#if (BLE_HID_REPORT_HOST)
|
|
case TASK_ID_HOGPRH:
|
|
prf_cbs = hogprh_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_HID_REPORT_HOST)
|
|
|
|
#if (BLE_GL_COLLECTOR)
|
|
case TASK_ID_GLPC:
|
|
prf_cbs = glpc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_GL_COLLECTOR)
|
|
|
|
#if (BLE_GL_SENSOR)
|
|
case TASK_ID_GLPS:
|
|
prf_cbs = glps_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_GL_SENSOR)
|
|
|
|
#if (BLE_RSC_COLLECTOR)
|
|
case TASK_ID_RSCPC:
|
|
prf_cbs = rscpc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_RSC_COLLECTOR)
|
|
|
|
#if (BLE_RSC_SENSOR)
|
|
case TASK_ID_RSCPS:
|
|
prf_cbs = rscps_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_RSC_SENSOR)
|
|
|
|
#if (BLE_CSC_COLLECTOR)
|
|
case TASK_ID_CSCPC:
|
|
prf_cbs = cscpc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_CSC_COLLECTOR)
|
|
|
|
#if (BLE_CSC_SENSOR)
|
|
case TASK_ID_CSCPS:
|
|
prf_cbs = cscps_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_CSC_SENSOR)
|
|
|
|
#if (BLE_CP_COLLECTOR)
|
|
case TASK_ID_CPPC:
|
|
prf_cbs = cppc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_CP_COLLECTOR)
|
|
|
|
#if (BLE_CP_SENSOR)
|
|
case TASK_ID_CPPS:
|
|
prf_cbs = cpps_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_CP_SENSOR)
|
|
|
|
#if (BLE_LN_COLLECTOR)
|
|
case TASK_ID_LANC:
|
|
prf_cbs = lanc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_LN_COLLECTOR)
|
|
|
|
#if (BLE_LN_SENSOR)
|
|
case TASK_ID_LANS:
|
|
prf_cbs = lans_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_LN_SENSOR)
|
|
|
|
#if (BLE_AN_CLIENT)
|
|
case TASK_ID_ANPC:
|
|
prf_cbs = anpc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_AN_CLIENT)
|
|
|
|
#if (BLE_AN_SERVER)
|
|
case TASK_ID_ANPS:
|
|
prf_cbs = anps_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_AN_SERVER)
|
|
|
|
#if (BLE_PAS_CLIENT)
|
|
case TASK_ID_PASPC:
|
|
prf_cbs = paspc_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_PAS_CLIENT)
|
|
|
|
#if (BLE_PAS_SERVER)
|
|
case TASK_ID_PASPS:
|
|
prf_cbs = pasps_prf_itf_get();
|
|
break;
|
|
#endif // (BLE_PAS_SERVER)
|
|
|
|
#ifdef BLE_AM0_HEARING_AID_SERV
|
|
case TASK_ID_AM0_HAS:
|
|
prf_cbs = am0_has_prf_itf_get();
|
|
break;
|
|
#endif // defined(BLE_AM0_HEARING_AID_SERV)
|
|
|
|
#if (BLE_IPS_SERVER)
|
|
case TASK_ID_IPSS:
|
|
prf_cbs = ipss_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_IPS_SERVER)
|
|
|
|
#if (BLE_IPS_CLIENT)
|
|
case TASK_ID_IPSC:
|
|
prf_cbs = ipsc_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_IPS_CLIENT)
|
|
|
|
#if (BLE_ENV_SERVER)
|
|
case TASK_ID_ENVS:
|
|
prf_cbs = envs_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_ENV_SERVER)
|
|
|
|
#if (BLE_ENV_CLIENT)
|
|
case TASK_ID_ENVC:
|
|
prf_cbs = envc_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_ENV_CLIENT
|
|
|
|
#if (BLE_WSC_SERVER)
|
|
case TASK_ID_WSCS:
|
|
prf_cbs = wscs_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_WSC_SERVER)
|
|
|
|
#if (BLE_WSC_CLIENT)
|
|
case TASK_ID_WSCC:
|
|
prf_cbs = wscc_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_WSC_CLIENT
|
|
|
|
#if (BLE_BCS_SERVER)
|
|
case TASK_ID_BCSS:
|
|
prf_cbs = bcss_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_BCS_SERVER)
|
|
|
|
#if (BLE_BCS_CLIENT)
|
|
case TASK_ID_BCSC:
|
|
prf_cbs = bcsc_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_BCS_CLIENT)
|
|
|
|
#if (BLE_UDS_SERVER)
|
|
case TASK_ID_UDSS:
|
|
prf_cbs = udss_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_UDS_SERVER)
|
|
|
|
#if (BLE_UDS_CLIENT)
|
|
case TASK_ID_UDSC:
|
|
prf_cbs = udsc_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_UDS_CLIENT)
|
|
|
|
#if (BLE_VOICEPATH)
|
|
case TASK_ID_VOICEPATH:
|
|
prf_cbs = voicepath_prf_itf_get();
|
|
break;
|
|
#endif //(TASK_ID_VOICEPATH)
|
|
|
|
#if (BLE_OTA)
|
|
case TASK_ID_OTA:
|
|
prf_cbs = ota_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_OTA)
|
|
|
|
#if (BLE_TOTA)
|
|
case TASK_ID_TOTA:
|
|
prf_cbs = tota_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_TOTA)
|
|
|
|
#if (BLE_BMS)
|
|
case TASK_ID_BMS:
|
|
prf_cbs = bms_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_BMS)
|
|
|
|
#if (BLE_ANC_CLIENT)
|
|
case TASK_ID_ANCC:
|
|
prf_cbs = ancc_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_ANC_CLIENT)
|
|
|
|
#if (BLE_AMS_CLIENT)
|
|
case TASK_ID_AMSC:
|
|
prf_cbs = amsc_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_AMS_CLIENT)
|
|
|
|
#if (BLE_TILE)
|
|
case TASK_ID_TILE:
|
|
prf_cbs = tile_prf_itf_get();
|
|
break;
|
|
#endif //(TASK_ID_TILE)
|
|
|
|
#if (ANCS_PROXY_ENABLE)
|
|
case TASK_ID_ANCSP:
|
|
prf_cbs = ancs_proxy_prf_itf_get();
|
|
break;
|
|
case TASK_ID_AMSP:
|
|
prf_cbs = ams_proxy_prf_itf_get();
|
|
break;
|
|
#endif //(ANCS_PROXY_ENABLE)
|
|
|
|
#if (BLE_GFPS_PROVIDER)
|
|
case TASK_ID_GFPSP:
|
|
prf_cbs = gfpsp_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_GFPS_PROVIDER)
|
|
|
|
#if (BLE_AI_VOICE)
|
|
case TASK_ID_AI:
|
|
prf_cbs = ai_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_AMA)
|
|
|
|
#if (BLE_DATAPATH_SERVER)
|
|
case TASK_ID_DATAPATHPS:
|
|
prf_cbs = datapathps_prf_itf_get();
|
|
break;
|
|
#endif //(BLE_DATAPATH_SERVER)
|
|
|
|
default: /* Nothing to do */
|
|
break;
|
|
}
|
|
|
|
return prf_cbs;
|
|
}
|
|
|
|
/*
|
|
* EXPORTED FUNCTIONS DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
void prf_init(bool reset)
|
|
{
|
|
uint8_t i;
|
|
|
|
BLE_FUNC_ENTER();
|
|
|
|
BLE_DBG(">>>>>> prf_create reset %d<<<<<<\n", reset);
|
|
if (!reset)
|
|
{
|
|
// FW boot profile initialization
|
|
for(i = 0; i < BLE_NB_PROFILES ; i++)
|
|
{
|
|
prf_env.prf[i].env = NULL;
|
|
prf_env.prf[i].task = TASK_GAPC + i +1;
|
|
prf_env.prf[i].id = TASK_ID_INVALID;
|
|
|
|
// Initialize Task Descriptor
|
|
prf_env.prf[i].desc.msg_handler_tab = NULL;
|
|
prf_env.prf[i].desc.state = NULL;
|
|
prf_env.prf[i].desc.idx_max = 0;
|
|
prf_env.prf[i].desc.msg_cnt = 0;
|
|
|
|
ke_task_create(prf_env.prf[i].task, &(prf_env.prf[i].desc));
|
|
BLE_DBG("prf_init prf_env.prf[%d].task: %d\n", i, prf_env.prf[i].task);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// FW boot profile destruction
|
|
for(i = 0; i < BLE_NB_PROFILES ; i++)
|
|
{
|
|
// Get Profile API
|
|
const struct prf_task_cbs * cbs = prf_itf_get(prf_env.prf[i].id);
|
|
if(cbs != NULL)
|
|
{
|
|
// request to destroy profile
|
|
cbs->destroy(&(prf_env.prf[i]));
|
|
}
|
|
// unregister profile
|
|
prf_env.prf[i].id = TASK_ID_INVALID;
|
|
prf_env.prf[i].desc.msg_handler_tab = NULL;
|
|
prf_env.prf[i].desc.state = NULL;
|
|
prf_env.prf[i].desc.idx_max = 0;
|
|
prf_env.prf[i].desc.msg_cnt = 0;
|
|
|
|
// Request kernel to flush task messages
|
|
ke_task_msg_flush(KE_TYPE_GET(prf_env.prf[i].task));
|
|
}
|
|
}
|
|
|
|
BLE_FUNC_LEAVE();
|
|
}
|
|
|
|
|
|
uint8_t prf_add_profile(struct gapm_profile_task_add_cmd * params, ke_task_id_t* prf_task)
|
|
{
|
|
uint8_t i;
|
|
uint8_t status = GAP_ERR_NO_ERROR;
|
|
|
|
BLE_DBG(">>>>>> prf_add_profile <<<<<<\n");
|
|
|
|
// retrieve profile callback
|
|
const struct prf_task_cbs * cbs = prf_itf_get(params->prf_task_id);
|
|
if(cbs == NULL)
|
|
{
|
|
// profile API not available
|
|
status = GAP_ERR_INVALID_PARAM;
|
|
}
|
|
|
|
// check if profile not already present in task list
|
|
if(status == GAP_ERR_NO_ERROR)
|
|
{
|
|
for(i = 0; i < BLE_NB_PROFILES ; i++)
|
|
{
|
|
if(prf_env.prf[i].id == params->prf_task_id)
|
|
{
|
|
status = GAP_ERR_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(status == GAP_ERR_NO_ERROR)
|
|
{
|
|
// find first available task
|
|
for(i = 0; i < BLE_NB_PROFILES ; i++)
|
|
{
|
|
// available task found
|
|
if(prf_env.prf[i].id == TASK_ID_INVALID)
|
|
{
|
|
// initialize profile
|
|
status = cbs->init(&(prf_env.prf[i]), &(params->start_hdl), params->app_task, params->sec_lvl, params->param);
|
|
|
|
// initialization succeed
|
|
if(status == GAP_ERR_NO_ERROR)
|
|
{
|
|
// register profile
|
|
prf_env.prf[i].id = params->prf_task_id;
|
|
*prf_task = prf_env.prf[i].task;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(i == BLE_NB_PROFILES)
|
|
{
|
|
status = GAP_ERR_INSUFF_RESOURCES;
|
|
}
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
|
|
|
|
void prf_create(uint8_t conidx)
|
|
{
|
|
uint8_t i;
|
|
/* simple connection creation handler, nothing to do. */
|
|
|
|
BLE_DBG(">>>>>> prf_create <<<<<<\n");
|
|
// execute create function of each profiles
|
|
for(i = 0; i < BLE_NB_PROFILES ; i++)
|
|
{
|
|
// Get Profile API
|
|
const struct prf_task_cbs * cbs = prf_itf_get(prf_env.prf[i].id);
|
|
if(cbs != NULL)
|
|
{
|
|
// call create callback
|
|
cbs->create(&(prf_env.prf[i]), conidx);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void prf_cleanup(uint8_t conidx, uint8_t reason)
|
|
{
|
|
uint8_t i;
|
|
/* simple connection creation handler, nothing to do. */
|
|
|
|
BLE_DBG(">>>>>> prf_cleanup <<<<<<\n");
|
|
// execute create function of each profiles
|
|
for(i = 0; i < BLE_NB_PROFILES ; i++)
|
|
{
|
|
// Get Profile API
|
|
const struct prf_task_cbs * cbs = prf_itf_get(prf_env.prf[i].id);
|
|
if(cbs != NULL)
|
|
{
|
|
// call cleanup callback
|
|
cbs->cleanup(&(prf_env.prf[i]), conidx, reason);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
prf_env_t* prf_env_get(uint16_t prf_id)
|
|
{
|
|
prf_env_t* env = NULL;
|
|
uint8_t i;
|
|
// find if profile present in profile tasks
|
|
BLE_DBG("%s prf_id %d", __func__, prf_id);
|
|
for(i = 0; i < BLE_NB_PROFILES ; i++)
|
|
{
|
|
// check if profile identifier is known
|
|
if(prf_env.prf[i].id == prf_id)
|
|
{
|
|
env = prf_env.prf[i].env;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return env;
|
|
}
|
|
|
|
ke_task_id_t prf_src_task_get(prf_env_t* env, uint8_t conidx)
|
|
{
|
|
ke_task_id_t task = PERM_GET(env->prf_task, PRF_TASK);
|
|
|
|
BLE_DBG("%s conidx %d", __func__, conidx);
|
|
if(PERM_GET(env->prf_task, PRF_MI))
|
|
{
|
|
task = KE_BUILD_ID(task, conidx);
|
|
}
|
|
|
|
return task;
|
|
}
|
|
|
|
ke_task_id_t prf_dst_task_get(prf_env_t* env, uint8_t conidx)
|
|
{
|
|
ke_task_id_t task = PERM_GET(env->app_task, PRF_TASK);
|
|
|
|
BLE_DBG("%s app_task %d conidx %d", __func__, env->app_task, conidx);
|
|
if(PERM_GET(env->app_task, PRF_MI))
|
|
{
|
|
task = KE_BUILD_ID(task, conidx);
|
|
}
|
|
|
|
return task;
|
|
}
|
|
|
|
|
|
ke_task_id_t prf_get_id_from_task(ke_msg_id_t task)
|
|
{
|
|
ke_task_id_t id = TASK_ID_INVALID;
|
|
uint8_t idx = KE_IDX_GET(task);
|
|
uint8_t i;
|
|
task = KE_TYPE_GET(task);
|
|
|
|
BLE_DBG("%s task %d", __func__, task);
|
|
// find if profile present in profile tasks
|
|
for(i = 0; i < BLE_NB_PROFILES ; i++)
|
|
{
|
|
// check if profile identifier is known
|
|
if(prf_env.prf[i].task == task)
|
|
{
|
|
id = prf_env.prf[i].id;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return KE_BUILD_ID(id, idx);
|
|
}
|
|
|
|
ke_task_id_t prf_get_task_from_id(ke_msg_id_t id)
|
|
{
|
|
ke_task_id_t task = TASK_NONE;
|
|
uint8_t idx = KE_IDX_GET(id);
|
|
uint8_t i;
|
|
id = KE_TYPE_GET(id);
|
|
|
|
BLE_DBG("%s id %d", __func__, id);
|
|
// find if profile present in profile tasks
|
|
for(i = 0; i < BLE_NB_PROFILES ; i++)
|
|
{
|
|
// check if profile identifier is known
|
|
if(prf_env.prf[i].id == id)
|
|
{
|
|
task = prf_env.prf[i].task;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return KE_BUILD_ID(task, idx);
|
|
}
|
|
|
|
|
|
#endif // (BLE_PROFILES)
|
|
|
|
/// @} PRF
|