void FmpAppCallback(FmpChannel *channel, FmpEvent event, U32 status, void *ptr, U16 len)
{
FmpCallbackParms parms;
switch (event)
{
case FMPEVENT_OPEN:
case FMPEVENT_CLOSED:
parms.parm.rem_dev = ptr;
break;
case FMPEVENT_GATT_QUERY_CNF:
if (status != BT_STATUS_SUCCESS)
{
fmp_free(channel->servicedb);
}
break;
case FMPEVENT_SET_ALERT_LEVEL_REQ:
case FMPEVENT_SET_ALERT_LEVEL_CNF:
parms.parm.level = *(U8 *)ptr;
break;
default:
break;
}
parms.event = event;
parms.len = len;
parms.status = status;
FMP(fmp_callback)(channel, &parms);
}
BtStatus FMP_Close(FmpChannel *channel)
{
BtStatus status = BT_STATUS_FAILED;
/* Validate parameters */
CheckUnlockedParm(BT_STATUS_INVALID_PARM, channel != 0);
OS_LockStack();
CheckLockedParm(BT_STATUS_NOT_FOUND,
IsNodeOnList(&FMP(dev_list), &(channel->node)));
// check state
if (channel->state == FMP_STATE_OPEN)
{
status = GattDisconnect(channel->link);
}
if (status == BT_STATUS_SUCCESS)
{
FmpClearConnection(channel, status);
}
OS_UnlockStack();
return status;
}
FmpChannel *FmpFindChannelByAddr(BD_ADDR *bd_addr)
{
FmpChannel *channel;
channel = (FmpChannel *)GetHeadList(&FMP(dev_list));
while ((ListEntry *)channel != &FMP(dev_list))
{
if ((channel->link != NULL) &&
fmp_dev_addr_equal(bd_addr, &channel->link->bdAddr))
{
return channel;
}
/* try the next node in the device list */
channel = (FmpChannel *)GetNextNode(&channel->node);
}
return NULL;
}
FmpChannel *FmpFindChannelByLink(BtRemoteDevice *remote_dev)
{
FmpChannel *channel;
channel = (FmpChannel *)GetHeadList(&FMP(dev_list));
while ((ListEntry *)channel != &FMP(dev_list))
{
if ((channel->link == remote_dev) ||
((channel->cmgr_handler.bdc != 0) &&
(channel->cmgr_handler.bdc->link == remote_dev)) )
{
return channel;
}
/* try the next node in the device list */
channel = (FmpChannel *)GetNextNode(&channel->node);
}
return NULL;
}
BtStatus FMP_Open(FmpChannel **channel, BD_ADDR *addr)
{
BtStatus status = BT_STATUS_FAILED;
FmpChannel *ch;
CheckUnlockedParm(BT_STATUS_INVALID_PARM, addr != 0);
OS_LockStack();
kal_trace(BT_TRACE_BLE_PROFILES, FMP_OPENCONNECTION);
if ((*channel != NULL) && IsNodeOnList(&FMP(dev_list), &((*channel)->node)))
{
ch = *channel;
}
else
{
ch = FmpNewChannel();
if (ch == NULL)
{
return BT_STATUS_NO_RESOURCES;
}
}
if (ch->state == FMP_STATE_CLOSED)
{
status = CMGR_CreateDataLink(&ch->cmgr_handler, addr);
kal_trace(BT_TRACE_BLE_PROFILES, FMP_CREATEDATALINK_STATUS, status);
if (status == BT_STATUS_SUCCESS)
{
status = GattClientConnect(ch->cmgr_handler.remDev);
}
if (status != BT_STATUS_SUCCESS && status != BT_STATUS_PENDING)
{
FmpFreeChannel(ch);
return status;
}
ch->state = FMP_STATE_OPENING;
*channel = ch;
}
OS_UnlockStack();
return status;
}
void FMP_Init(void)
{
OS_LockStack();
#if XA_CONTEXT_PTR == XA_ENABLED
OS_MemSet((U8 *)fmpcx, 0, sizeof(FmpContext));
#else /* XA_CONTEXT_PTR == XA_ENABLED */
OS_MemSet((U8 *)&fmpcx, 0, sizeof(FmpContext));
#endif /* XA_CONTEXT_PTR == XA_ENABLED */
/* Initialize Lists */
InitializeListHead(&FMP(dev_list));
kal_trace(BT_TRACE_BLE_PROFILES, FMP_INITIALIZED);
OS_UnlockStack();
}
BtStatus FMP_Deregister(FmpServiceTypeFlag service_flag)
{
BtStatus status = BT_STATUS_SUCCESS;
OS_LockStack();
if (FMP(service_flag) == 0)
{
/* It is actually invalid deregistration, return directly */
return status;
}
if ((service_flag & FMP_SERVICE_TYPE_LOCATOR_FLAG) &&
(FMP(service_flag) & FMP_SERVICE_TYPE_LOCATOR_FLAG))
{
FMP(service_flag) &= ~FMP_SERVICE_TYPE_LOCATOR_FLAG;
}
if ((service_flag & FMP_SERVICE_TYPE_TARGET_FLAG) &&
(FMP(service_flag) & FMP_SERVICE_TYPE_TARGET_FLAG))
{
FmpAttDB_Deregistration();
FMP(service_flag) &= ~FMP_SERVICE_TYPE_TARGET_FLAG;
}
if (FMP(service_flag) == 0)
{
BT_GattUnregisterConnectedEvent(&FMP(gatt_handler));
ATTDB_UnRegisterBondStatus(&FMP(bond_handler));
FMP(fmp_callback) = NULL;
}
OS_UnlockStack();
return status;
}
BtStatus FMP_Register(FmpCallback callback, FmpServiceTypeFlag service_flag)
{
BtStatus status = BT_STATUS_FAILED;
OS_LockStack();
if ((service_flag & FMP_SERVICE_TYPE_LOCATOR_FLAG) &&
((FMP(service_flag) & FMP_SERVICE_TYPE_LOCATOR_FLAG) == 0))
{
status = BT_STATUS_SUCCESS;
}
if ((service_flag & FMP_SERVICE_TYPE_TARGET_FLAG) &&
((FMP(service_flag) & FMP_SERVICE_TYPE_TARGET_FLAG) == 0))
{
status = FmpAttDB_Registration();
}
if (status == BT_STATUS_SUCCESS)
{
if (FMP(service_flag) == 0)
{
/* register the GATT callback to handle connection */
BT_GattRegisterConnectedEvent(&(FMP(gatt_handler)), FmpGattEventCallback);
/* register bond callback to obtain bond status */
FMP(bond_handler).callback = FmpBondingCallback;
ATTDB_RegisterBondStatus(&FMP(bond_handler));
FMP(fmp_callback) = callback;
}
FMP(service_flag) |= service_flag;
}
OS_UnlockStack();
return status;
}
FmpChannel *FmpNewChannel(void)
{
FmpChannel *ch;
U8 i;
ch = (FmpChannel *)fmp_malloc(sizeof(FmpChannel));
if (ch != NULL)
{
OS_MemSet((U8 *)ch, 0, sizeof(FmpChannel));
InsertTailList(&FMP(dev_list), &(ch->node));
CMGR_RegisterHandler(&ch->cmgr_handler, FmpCmgrCallback);
/* Initialize packet pool for each device */
InitializeListHead(&ch->packet_pool);
for (i = 0; i < FMP_NUM_TX_PACKETS; i++)
{
InsertTailList(&ch->packet_pool, &ch->packets[i].node);
}
}
return ch;
}
