/*********************************************************************
* @fn gapRole_processGAPMsg
*
* @brief Process an incoming task message.
*
* @param pMsg - message to process
*
* @return none
*/
static uint8_t gapRole_processGAPMsg(gapEventHdr_t *pMsg)
{
uint8_t notify = FALSE; // State changed notify the app? (default no)
switch (pMsg->opcode)
{
case GAP_DEVICE_INIT_DONE_EVENT:
{
gapDeviceInitDoneEvent_t *pPkt = (gapDeviceInitDoneEvent_t *)pMsg;
bStatus_t stat = pPkt->hdr.status;
if (stat == SUCCESS)
{
// Save off the generated keys
VOID osal_snv_write(BLE_NVID_IRK, KEYLEN, gapRole_IRK);
VOID osal_snv_write(BLE_NVID_CSRK, KEYLEN, gapRole_SRK);
// Save off the information
VOID memcpy(gapRole_bdAddr, pPkt->devAddr, B_ADDR_LEN);
// Update the advertising data
stat = GAP_UpdateAdvertisingData(selfEntity,
TRUE, gapRole_AdvertDataLen, gapRole_AdvertData);
}
if (stat != SUCCESS)
{
gapRole_abort();
}
notify = TRUE;
}
break;
case GAP_ADV_DATA_UPDATE_DONE_EVENT:
{
gapAdvDataUpdateEvent_t *pPkt = (gapAdvDataUpdateEvent_t *)pMsg;
if (pPkt->hdr.status == SUCCESS)
{
if (pPkt->adType)
{
// Setup the Response Data
pPkt->hdr.status = GAP_UpdateAdvertisingData(selfEntity,
FALSE, gapRole_ScanRspDataLen, gapRole_ScanRspData);
}
else if (Util_isActive(&startAdvClock) == FALSE)
{
// Start advertising
gapRole_setEvent(START_ADVERTISING_EVT);
}
}
if (pPkt->hdr.status != SUCCESS)
{
// Set into Error state
gapRole_abort();
notify = TRUE;
}
}
break;
case GAP_MAKE_DISCOVERABLE_DONE_EVENT:
case GAP_END_DISCOVERABLE_DONE_EVENT:
{
gapMakeDiscoverableRspEvent_t *pPkt = (gapMakeDiscoverableRspEvent_t *)pMsg;
if (pPkt->hdr.status == SUCCESS)
{
if (pMsg->opcode == GAP_MAKE_DISCOVERABLE_DONE_EVENT)
{
gapRole_AdvEnabled = TRUE;
}
else // GAP_END_DISCOVERABLE_DONE_EVENT
{
if (gapRole_AdvertOffTime != 0) //restart advertising if param is set
{
if ((gapRole_AdvEnabled) || (gapRole_AdvNonConnEnabled))
{
Util_restartClock(&startAdvClock, gapRole_AdvertOffTime);
}
}
else
{
// Since gapRole_AdvertOffTime is set to 0, the device should not
// automatically become discoverable again after a period of time.
// Set enabler to FALSE; device will become discoverable again when
// this value gets set to TRUE
if (gapRole_AdvEnabled == TRUE)
{
gapRole_AdvEnabled = FALSE;
}
}
}
notify = TRUE;
}
else if (pPkt->hdr.status == LL_STATUS_ERROR_COMMAND_DISALLOWED) //we're already advertising
{
notify = FALSE;
}
else
{
gapRole_abort();
}
}
break;
case GAP_LINK_ESTABLISHED_EVENT:
{
gapEstLinkReqEvent_t *pPkt = (gapEstLinkReqEvent_t *)pMsg;
uint8_t advertEnable = TRUE;
if (pPkt->hdr.status == SUCCESS)
{
// Notify the Bond Manager to the connection
VOID GAPBondMgr_LinkEst(pPkt->devAddrType, pPkt->devAddr,
pPkt->connectionHandle, pPkt->connRole);
//advertising will stop after connection formed as slave
if ((pPkt->connRole) == GAP_PROFILE_PERIPHERAL)
{
gapRole_AdvEnabled = FALSE;
//reenable advertising
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&advertEnable, NULL);
}
}
else if (pPkt->hdr.status == bleGAPConnNotAcceptable)
{
// Set enabler to FALSE; device will become discoverable again when
// this value gets set to TRUE
gapRole_AdvEnabled = FALSE;
}
else
{
gapRole_abort();
}
notify = TRUE;
}
break;
case GAP_LINK_TERMINATED_EVENT:
{
gapTerminateLinkEvent_t *pPkt = (gapTerminateLinkEvent_t *)pMsg;
linkDBInfo_t pInfo;
linkDB_GetInfo(pPkt->connectionHandle, &pInfo);
// notify bond manager
GAPBondMgr_LinkTerm(pPkt->connectionHandle);
notify = TRUE;
}
break;
case GAP_SLAVE_REQUESTED_SECURITY_EVENT:
{
uint16_t connHandle = ((gapSlaveSecurityReqEvent_t *)pMsg)->connectionHandle;
uint8_t authReq = ((gapSlaveSecurityReqEvent_t *)pMsg)->authReq;
GAPBondMgr_SlaveReqSecurity(connHandle, authReq);
}
break;
case GAP_LINK_PARAM_UPDATE_EVENT:
{
gapLinkUpdateEvent_t *pPkt = (gapLinkUpdateEvent_t *)pMsg;
// Cancel connection param update timeout timer (if active)
Util_stopClock(&updateTimeoutClock);
if (pPkt->hdr.status == SUCCESS)
{
notify = TRUE;
}
}
break;
default:
notify = TRUE;
break;
}
if (notify == TRUE) //app needs to take further action
{
if (pGapRoles_AppCGs && pGapRoles_AppCGs->pfnPassThrough)
{
return (pGapRoles_AppCGs->pfnPassThrough((gapMultiRoleEvent_t *)pMsg));
}
}
return TRUE;
}
/*********************************************************************
* @brief Set a GAP Role parameter.
*
* Public function defined in peripheral.h.
*/
bStatus_t GAPRole_SetParameter(uint16_t param, uint8_t len, void *pValue, uint8 connHandle)
{
bStatus_t ret = SUCCESS;
switch (param)
{
case GAPROLE_IRK:
if (len == KEYLEN)
{
VOID memcpy(gapRole_IRK, pValue, KEYLEN) ;
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_SRK:
if (len == KEYLEN)
{
VOID memcpy(gapRole_SRK, pValue, KEYLEN) ;
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_SIGNCOUNTER:
if (len == sizeof (uint32_t))
{
gapRole_signCounter = *((uint32_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADVERT_ENABLED: //connectable advertising
if (len == sizeof(uint8_t))
{
// Non-connectable advertising must be disabled.
if (gapRole_AdvNonConnEnabled != TRUE)
{
uint8_t oldAdvEnabled = gapRole_AdvEnabled;
gapRole_AdvEnabled = *((uint8_t*)pValue);
if ((oldAdvEnabled) && (gapRole_AdvEnabled == FALSE))
{
return GAP_EndDiscoverable(selfEntity);
}
else if ((oldAdvEnabled == FALSE) && (gapRole_AdvEnabled))
{
// Turn on advertising.
if (linkDB_NumActive() >= MAX_NUM_BLE_CONNS) //don't do conn adv if we don't have any avilable links
{
return bleNoResources; // no more available links
}
else
{
gapRole_setEvent(START_ADVERTISING_EVT);
}
}
}
else
{
ret = bleIncorrectMode;
}
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_NONCONN_ENABLED:
if (len == sizeof(uint8_t))
{
// Connectable advertising must be disabled.
if (gapRole_AdvEnabled != TRUE)
{
uint8_t oldAdvEnabled = gapRole_AdvNonConnEnabled;
gapRole_AdvNonConnEnabled = *((uint8_t*)pValue);
if ((oldAdvEnabled) && (gapRole_AdvNonConnEnabled == FALSE))
{
VOID GAP_EndDiscoverable(selfEntity);
}
else if ((oldAdvEnabled == FALSE) && (gapRole_AdvNonConnEnabled))
{ //turnon advertising
gapRole_setEvent(START_ADVERTISING_EVT);
}
}
else
{
ret = bleIncorrectMode;
}
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADVERT_OFF_TIME:
if (len == sizeof (uint16_t))
{
gapRole_AdvertOffTime = *((uint16_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADVERT_DATA:
if (len <= B_MAX_ADV_LEN)
{
VOID memset(gapRole_AdvertData, 0, B_MAX_ADV_LEN);
VOID memcpy(gapRole_AdvertData, pValue, len);
gapRole_AdvertDataLen = len;
// Update the advertising data
ret = GAP_UpdateAdvertisingData(selfEntity,
TRUE, gapRole_AdvertDataLen, gapRole_AdvertData);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_SCAN_RSP_DATA:
if (len <= B_MAX_ADV_LEN)
{
VOID memset(gapRole_ScanRspData, 0, B_MAX_ADV_LEN);
VOID memcpy(gapRole_ScanRspData, pValue, len);
gapRole_ScanRspDataLen = len;
// Update the Response Data
ret = GAP_UpdateAdvertisingData(selfEntity,
FALSE, gapRole_ScanRspDataLen, gapRole_ScanRspData);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_EVENT_TYPE:
if ((len == sizeof (uint8_t)) && (*((uint8_t*)pValue) <= GAP_ADTYPE_ADV_LDC_DIRECT_IND))
{
gapRole_AdvEventType = *((uint8_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_DIRECT_TYPE:
if ((len == sizeof (uint8_t)) && (*((uint8_t*)pValue) <= ADDRMODE_PRIVATE_RESOLVE))
{
gapRole_AdvDirectType = *((uint8_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_DIRECT_ADDR:
if (len == B_ADDR_LEN)
{
VOID memcpy(gapRole_AdvDirectAddr, pValue, B_ADDR_LEN) ;
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_CHANNEL_MAP:
if ((len == sizeof (uint8_t)) && (*((uint8_t*)pValue) <= 0x07))
{
gapRole_AdvChanMap = *((uint8_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_FILTER_POLICY:
if ((len == sizeof (uint8_t)) && (*((uint8_t*)pValue) <= GAP_FILTER_POLICY_WHITE))
{
gapRole_AdvFilterPolicy = *((uint8_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_MAX_SCAN_RES:
if (len == sizeof (uint8_t))
{
gapRoleMaxScanRes = *((uint8_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
default:
// The param value isn't part of this profile, try the GAP.
if ((param < TGAP_PARAMID_MAX) && (len == sizeof (uint16_t)))
{
ret = GAP_SetParamValue(param, *((uint16_t*)pValue));
}
else
{
ret = INVALIDPARAMETER;
}
break;
}
return (ret);
}
/*********************************************************************
* @fn gapRole_clockHandler
*
* @brief Clock handler function
*
* @param a0 - event
*
* @return none
*/
void gapRole_clockHandler(UArg a0)
{
gapRole_setEvent(a0);
}
/*********************************************************************
* @brief Set a GAP Role parameter.
*
* Public function defined in peripheral.h.
*/
bStatus_t GAPRole_SetParameter(uint16_t param, uint8_t len, void *pValue)
{
bStatus_t ret = SUCCESS;
switch (param)
{
case GAPROLE_IRK:
if (len == KEYLEN)
{
VOID memcpy(gapRole_IRK, pValue, KEYLEN) ;
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_SRK:
if (len == KEYLEN)
{
VOID memcpy(gapRole_SRK, pValue, KEYLEN) ;
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_SIGNCOUNTER:
if (len == sizeof (uint32_t))
{
gapRole_signCounter = *((uint32_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADVERT_ENABLED:
if (len == sizeof(uint8_t))
{
// Non-connectable advertising must be disabled.
if (gapRole_AdvNonConnEnabled != TRUE)
{
uint8_t oldAdvEnabled = gapRole_AdvEnabled;
gapRole_AdvEnabled = *((uint8_t*)pValue);
if ((oldAdvEnabled) && (gapRole_AdvEnabled == FALSE))
{
// Turn off advertising.
if ((gapRole_state == GAPROLE_ADVERTISING)
|| (gapRole_state == GAPROLE_WAITING_AFTER_TIMEOUT))
{
VOID GAP_EndDiscoverable(selfEntity);
}
}
else if ((oldAdvEnabled == FALSE) && (gapRole_AdvEnabled))
{
// Turn on advertising.
if ((gapRole_state == GAPROLE_STARTED)
|| (gapRole_state == GAPROLE_WAITING)
|| (gapRole_state == GAPROLE_WAITING_AFTER_TIMEOUT))
{
gapRole_setEvent(START_ADVERTISING_EVT);
}
}
}
else
{
ret = bleIncorrectMode;
}
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_NONCONN_ENABLED:
if (len == sizeof(uint8_t))
{
// Connectable advertising must be disabled.
if (gapRole_AdvEnabled != TRUE)
{
uint8_t oldAdvEnabled = gapRole_AdvNonConnEnabled;
gapRole_AdvNonConnEnabled = *((uint8_t*)pValue);
if ((oldAdvEnabled) && (gapRole_AdvNonConnEnabled == FALSE))
{
if ((gapRole_state == GAPROLE_ADVERTISING_NONCONN)
|| (gapRole_state == GAPROLE_CONNECTED_ADV)
|| (gapRole_state == GAPROLE_WAITING_AFTER_TIMEOUT))
{
VOID GAP_EndDiscoverable(selfEntity);
}
}
else if ((oldAdvEnabled == FALSE) && (gapRole_AdvNonConnEnabled))
{
// Turn on advertising.
if ((gapRole_state == GAPROLE_STARTED)
|| (gapRole_state == GAPROLE_WAITING)
|| (gapRole_state == GAPROLE_CONNECTED)
|| (gapRole_state == GAPROLE_WAITING_AFTER_TIMEOUT))
{
gapRole_setEvent(START_ADVERTISING_EVT);
}
}
}
else
{
ret = bleIncorrectMode;
}
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADVERT_OFF_TIME:
if (len == sizeof (uint16_t))
{
gapRole_AdvertOffTime = *((uint16_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADVERT_DATA:
if (len <= B_MAX_ADV_LEN)
{
VOID memset(gapRole_AdvertData, 0, B_MAX_ADV_LEN);
VOID memcpy(gapRole_AdvertData, pValue, len);
gapRole_AdvertDataLen = len;
// Update the advertising data
ret = GAP_UpdateAdvertisingData(selfEntity,
TRUE, gapRole_AdvertDataLen, gapRole_AdvertData);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_SCAN_RSP_DATA:
if (len <= B_MAX_ADV_LEN)
{
VOID memset(gapRole_ScanRspData, 0, B_MAX_ADV_LEN);
VOID memcpy(gapRole_ScanRspData, pValue, len);
gapRole_ScanRspDataLen = len;
// Update the Response Data
ret = GAP_UpdateAdvertisingData(selfEntity,
FALSE, gapRole_ScanRspDataLen, gapRole_ScanRspData);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_EVENT_TYPE:
if ((len == sizeof (uint8_t)) && (*((uint8_t*)pValue) <= GAP_ADTYPE_ADV_LDC_DIRECT_IND))
{
gapRole_AdvEventType = *((uint8_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_DIRECT_TYPE:
if ((len == sizeof (uint8_t)) && (*((uint8_t*)pValue) <= ADDRTYPE_PRIVATE_RESOLVE))
{
gapRole_AdvDirectType = *((uint8_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_DIRECT_ADDR:
if (len == B_ADDR_LEN)
{
VOID memcpy(gapRole_AdvDirectAddr, pValue, B_ADDR_LEN) ;
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_CHANNEL_MAP:
if ((len == sizeof (uint8_t)) && (*((uint8_t*)pValue) <= 0x07))
{
gapRole_AdvChanMap = *((uint8_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_ADV_FILTER_POLICY:
if ((len == sizeof (uint8_t)) && (*((uint8_t*)pValue) <= GAP_FILTER_POLICY_WHITE))
{
gapRole_AdvFilterPolicy = *((uint8_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_PARAM_UPDATE_ENABLE:
if ((len == sizeof (uint8_t)) && (*((uint8_t*)pValue) <= TRUE))
{
gapRole_ParamUpdateEnable = *((uint8_t*)pValue);
}
else
{
ret = bleInvalidRange;
}
break;
case GAPROLE_MIN_CONN_INTERVAL:
{
uint16_t newInterval = *((uint16_t*)pValue);
if ( len == sizeof (uint16_t) &&
(newInterval >= MIN_CONN_INTERVAL) &&
(newInterval <= MAX_CONN_INTERVAL))
{
gapRole_MinConnInterval = newInterval;
}
else
{
ret = bleInvalidRange;
}
}
break;
case GAPROLE_MAX_CONN_INTERVAL:
{
uint16_t newInterval = *((uint16_t*)pValue);
if ( len == sizeof (uint16_t) &&
(newInterval >= MIN_CONN_INTERVAL) &&
(newInterval <= MAX_CONN_INTERVAL))
{
gapRole_MaxConnInterval = newInterval;
}
else
{
ret = bleInvalidRange;
}
}
break;
case GAPROLE_SLAVE_LATENCY:
{
uint16_t latency = *((uint16_t*)pValue);
if (len == sizeof (uint16_t) && (latency < MAX_SLAVE_LATENCY))
{
gapRole_SlaveLatency = latency;
}
else
{
ret = bleInvalidRange;
}
}
break;
case GAPROLE_TIMEOUT_MULTIPLIER:
{
uint16_t newTimeout = *((uint16_t*)pValue);
if (len == sizeof (uint16_t)
&& (newTimeout >= MIN_TIMEOUT_MULTIPLIER) && (newTimeout <= MAX_TIMEOUT_MULTIPLIER))
{
gapRole_TimeoutMultiplier = newTimeout;
}
else
{
ret = bleInvalidRange;
}
}
break;
case GAPROLE_PARAM_UPDATE_REQ:
{
uint8_t req = *((uint8_t*)pValue);
if (len == sizeof (uint8_t) && (req == TRUE))
{
// Make sure we don't send an L2CAP Connection Parameter Update Request
// command within TGAP(conn_param_timeout) of an L2CAP Connection Parameter
// Update Response being received.
if (Util_isActive(&updateTimeoutClock) == FALSE)
{
// Start connection update procedure
ret = gapRole_startConnUpdate(GAPROLE_NO_ACTION);
if (ret == SUCCESS)
{
// Connection update requested by app, cancel such pending procedure (if active)
Util_stopClock(&startUpdateClock);
}
}
else
{
ret = blePending;
}
}
else
{
ret = bleInvalidRange;
}
}
break;
default:
// The param value isn't part of this profile, try the GAP.
if ((param < TGAP_PARAMID_MAX) && (len == sizeof (uint16_t)))
{
ret = GAP_SetParamValue(param, *((uint16_t*)pValue));
}
else
{
ret = INVALIDPARAMETER;
}
break;
}
return (ret);
}
/*********************************************************************
* @fn gapRole_processGAPMsg
*
* @brief Process an incoming task message.
*
* @param pMsg - message to process
*
* @return none
*/
static void gapRole_processGAPMsg(gapEventHdr_t *pMsg)
{
uint8_t notify = FALSE; // State changed notify the app? (default no)
switch (pMsg->opcode)
{
case GAP_DEVICE_INIT_DONE_EVENT:
{
gapDeviceInitDoneEvent_t *pPkt = (gapDeviceInitDoneEvent_t *)pMsg;
bStatus_t stat = pPkt->hdr.status;
if (stat == SUCCESS)
{
// Save off the generated keys
VOID osal_snv_write(BLE_NVID_IRK, KEYLEN, gapRole_IRK);
VOID osal_snv_write(BLE_NVID_CSRK, KEYLEN, gapRole_SRK);
// Save off the information
VOID memcpy(gapRole_bdAddr, pPkt->devAddr, B_ADDR_LEN);
gapRole_state = GAPROLE_STARTED;
// Update the advertising data
stat = GAP_UpdateAdvertisingData(selfEntity,
TRUE, gapRole_AdvertDataLen, gapRole_AdvertData);
}
if (stat != SUCCESS)
{
gapRole_state = GAPROLE_ERROR;
}
notify = TRUE;
}
break;
case GAP_ADV_DATA_UPDATE_DONE_EVENT:
{
gapAdvDataUpdateEvent_t *pPkt = (gapAdvDataUpdateEvent_t *)pMsg;
if (pPkt->hdr.status == SUCCESS)
{
if (pPkt->adType)
{
// Setup the Response Data
pPkt->hdr.status = GAP_UpdateAdvertisingData(selfEntity,
FALSE, gapRole_ScanRspDataLen, gapRole_ScanRspData);
}
else if ((gapRole_state != GAPROLE_ADVERTISING) &&
(gapRole_state != GAPROLE_CONNECTED_ADV) &&
(gapRole_state != GAPROLE_CONNECTED ||
gapRole_AdvNonConnEnabled == TRUE) &&
(Util_isActive(&startAdvClock) == FALSE))
{
// Start advertising
gapRole_setEvent(START_ADVERTISING_EVT);
}
}
if (pPkt->hdr.status != SUCCESS)
{
// Set into Error state
gapRole_state = GAPROLE_ERROR;
notify = TRUE;
}
}
break;
case GAP_MAKE_DISCOVERABLE_DONE_EVENT:
case GAP_END_DISCOVERABLE_DONE_EVENT:
{
gapMakeDiscoverableRspEvent_t *pPkt = (gapMakeDiscoverableRspEvent_t *)pMsg;
if (pPkt->hdr.status == SUCCESS)
{
if (pMsg->opcode == GAP_MAKE_DISCOVERABLE_DONE_EVENT)
{
if (gapRole_state == GAPROLE_CONNECTED)
{
gapRole_state = GAPROLE_CONNECTED_ADV;
}
else if (gapRole_AdvEnabled)
{
gapRole_state = GAPROLE_ADVERTISING;
}
else
{
gapRole_state = GAPROLE_ADVERTISING_NONCONN;
}
}
else // GAP_END_DISCOVERABLE_DONE_EVENT
{
if (gapRole_AdvertOffTime != 0)
{
if ((gapRole_AdvEnabled) || (gapRole_AdvNonConnEnabled))
{
Util_restartClock(&startAdvClock, gapRole_AdvertOffTime);
}
}
else
{
// Since gapRole_AdvertOffTime is set to 0, the device should not
// automatically become discoverable again after a period of time.
// Set enabler to FALSE; device will become discoverable again when
// this value gets set to TRUE
if (gapRole_AdvEnabled == TRUE)
{
gapRole_AdvEnabled = FALSE;
}
else
{
gapRole_AdvNonConnEnabled = FALSE;
}
}
// Update state.
if (gapRole_state == GAPROLE_CONNECTED_ADV)
{
// In the Advertising Off period
gapRole_state = GAPROLE_CONNECTED;
}
else
{
// In the Advertising Off period
gapRole_state = GAPROLE_WAITING;
}
}
}
else
{
gapRole_state = GAPROLE_ERROR;
}
notify = TRUE;
}
break;
case GAP_LINK_ESTABLISHED_EVENT:
{
gapEstLinkReqEvent_t *pPkt = (gapEstLinkReqEvent_t *)pMsg;
if (pPkt->hdr.status == SUCCESS)
{
VOID memcpy(gapRole_ConnectedDevAddr, pPkt->devAddr, B_ADDR_LEN);
gapRole_ConnectionHandle = pPkt->connectionHandle;
gapRole_state = GAPROLE_CONNECTED;
// Store connection information
gapRole_ConnInterval = pPkt->connInterval;
gapRole_ConnSlaveLatency = pPkt->connLatency;
gapRole_ConnTimeout = pPkt->connTimeout;
gapRole_ConnectedDevAddrType = pPkt->devAddrType;
// Check whether update parameter request is enabled
if (gapRole_ParamUpdateEnable == TRUE)
{
// Get the minimum time upon connection establishment before the
// peripheral can start a connection update procedure.
uint16_t timeout = GAP_GetParamValue(TGAP_CONN_PAUSE_PERIPHERAL);
Util_restartClock(&startUpdateClock, timeout*1000);
}
// Notify the Bond Manager to the connection
VOID GAPBondMgr_LinkEst(pPkt->devAddrType, pPkt->devAddr,
pPkt->connectionHandle, GAP_PROFILE_PERIPHERAL);
}
else if (pPkt->hdr.status == bleGAPConnNotAcceptable)
{
// Set enabler to FALSE; device will become discoverable again when
// this value gets set to TRUE
gapRole_AdvEnabled = FALSE;
// Go to WAITING state, and then start advertising
gapRole_state = GAPROLE_WAITING;
}
else
{
gapRole_state = GAPROLE_ERROR;
}
notify = TRUE;
}
break;
case GAP_LINK_TERMINATED_EVENT:
{
gapTerminateLinkEvent_t *pPkt = (gapTerminateLinkEvent_t *)pMsg;
GAPBondMgr_LinkTerm(pPkt->connectionHandle);
memset(gapRole_ConnectedDevAddr, 0, B_ADDR_LEN);
// Erase connection information
gapRole_ConnInterval = 0;
gapRole_ConnSlaveLatency = 0;
gapRole_ConnTimeout = 0;
gapRole_ConnTermReason = pPkt->reason;
// Cancel all connection parameter update timers (if any active)
Util_stopClock(&startUpdateClock);
Util_stopClock(&updateTimeoutClock);
notify = TRUE;
gapRole_ConnectionHandle = INVALID_CONNHANDLE;
// If device was advertising when connection dropped
if (gapRole_AdvNonConnEnabled)
{
// Continue advertising.
gapRole_state = GAPROLE_ADVERTISING_NONCONN;
}
// Else go to WAITING state.
else
{
if(pPkt->reason == LL_SUPERVISION_TIMEOUT_TERM)
{
gapRole_state = GAPROLE_WAITING_AFTER_TIMEOUT;
}
else
{
gapRole_state = GAPROLE_WAITING;
}
// Start advertising, if enabled.
gapRole_setEvent(START_ADVERTISING_EVT);
}
}
break;
case GAP_LINK_PARAM_UPDATE_EVENT:
{
gapLinkUpdateEvent_t *pPkt = (gapLinkUpdateEvent_t *)pMsg;
// Cancel connection param update timeout timer (if active)
Util_stopClock(&updateTimeoutClock);
if (pPkt->hdr.status == SUCCESS)
{
// Store new connection parameters
gapRole_ConnInterval = pPkt->connInterval;
gapRole_ConnSlaveLatency = pPkt->connLatency;
gapRole_ConnTimeout = pPkt->connTimeout;
// Make sure there's no pending connection update procedure
if(Util_isActive(&startUpdateClock) == FALSE)
{
// Notify the application with the new connection parameters
if (pGapRoles_ParamUpdateCB != NULL)
{
(*pGapRoles_ParamUpdateCB)(gapRole_ConnInterval,
gapRole_ConnSlaveLatency,
gapRole_ConnTimeout);
}
}
}
}
break;
case GAP_PAIRING_REQ_EVENT:
{
gapPairingReqEvent_t *pPkt = (gapPairingReqEvent_t *)pMsg;
// Send Pairing Failed Response
VOID GAP_TerminateAuth(pPkt->connectionHandle,
SMP_PAIRING_FAILED_NOT_SUPPORTED);
}
break;
default:
break;
}
if (notify == TRUE)
{
// Notify the application with the new state change
if (pGapRoles_AppCGs && pGapRoles_AppCGs->pfnStateChange)
{
pGapRoles_AppCGs->pfnStateChange(gapRole_state);
}
}
}
/*********************************************************************
* @fn gapRole_processGAPMsg
*
* @brief Process an incoming task message.
*
* @param pMsg - message to process
*
* @return none
*/
static uint8_t gapRole_processGAPMsg(gapEventHdr_t *pMsg) {
uint8_t notify = FALSE; // State changed notify the app? (default no)
switch (pMsg->opcode) {
case GAP_DEVICE_INIT_DONE_EVENT: {
gapDeviceInitDoneEvent_t *pPkt = (gapDeviceInitDoneEvent_t *) pMsg;
bStatus_t stat = pPkt->hdr.status;
if (stat == SUCCESS) {
// Save off the generated keys
VOID osal_snv_write(BLE_NVID_IRK, KEYLEN, gapRole_IRK);
VOID osal_snv_write(BLE_NVID_CSRK, KEYLEN, gapRole_SRK);
// Save off the information
VOID memcpy(gapRole_bdAddr, pPkt->devAddr, B_ADDR_LEN);
gapRole_peripheralState = GAPROLE_STARTED;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
// Update the advertising data
stat = GAP_UpdateAdvertisingData(selfEntity,
TRUE, gapRole_AdvertDataLen, gapRole_AdvertData);
}
if (stat != SUCCESS) {
gapRole_peripheralState = GAPROLE_ERROR;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
//gapRole_abort();
}
notify = TRUE;
}
break;
case GAP_ADV_DATA_UPDATE_DONE_EVENT: {
gapAdvDataUpdateEvent_t *pPkt = (gapAdvDataUpdateEvent_t *) pMsg;
if (pPkt->hdr.status == SUCCESS)
{
if (pPkt->adType)
{
// Setup the Response Data
pPkt->hdr.status = GAP_UpdateAdvertisingData(selfEntity,
FALSE, gapRole_ScanRspDataLen, gapRole_ScanRspData);
}
else if ((gapRole_peripheralState != GAPROLE_ADVERTISING) &&
(gapRole_peripheralState != GAPROLE_CONNECTED_ADV) &&
(gapRole_peripheralState != GAPROLE_CONNECTED ||
gapRole_AdvNonConnEnabled == TRUE) &&
(Util_isActive(&startAdvClock) == FALSE))
{
// Start advertising
gapRole_setEvent(START_ADVERTISING_EVT);
}
notify = FALSE;
}else {
// Set into Error state
gapRole_peripheralState = GAPROLE_ERROR;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
//gapRole_abort();
notify = TRUE;
}
}
break;
case GAP_MAKE_DISCOVERABLE_DONE_EVENT:
case GAP_END_DISCOVERABLE_DONE_EVENT: {
gapMakeDiscoverableRspEvent_t *pPkt = (gapMakeDiscoverableRspEvent_t *) pMsg;
if (pPkt->hdr.status == SUCCESS) {
if (pMsg->opcode == GAP_MAKE_DISCOVERABLE_DONE_EVENT) {
if (gapRole_peripheralState == GAPROLE_CONNECTED) {
gapRole_peripheralState = GAPROLE_CONNECTED_ADV;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
} else if (gapRole_AdvEnabled) {
gapRole_peripheralState = GAPROLE_ADVERTISING;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
} else {
gapRole_peripheralState = GAPROLE_ADVERTISING_NONCONN;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
}
} else // GAP_END_DISCOVERABLE_DONE_EVENT
{
if (gapRole_AdvertOffTime != 0) //restart advertising if param is set
{
if ((gapRole_AdvEnabled) || (gapRole_AdvNonConnEnabled)) {
Util_restartClock(&startAdvClock, gapRole_AdvertOffTime);
}
} else {
// Since gapRole_AdvertOffTime is set to 0, the device should not
// automatically become discoverable again after a period of time.
// Set enabler to FALSE; device will become discoverable again when
// this value gets set to TRUE
if (gapRole_AdvEnabled == TRUE) {
gapRole_AdvEnabled = FALSE;
} else {
gapRole_AdvNonConnEnabled = FALSE;
}
}
// Update state.
if (gapRole_peripheralState == GAPROLE_CONNECTED_ADV) {
// In the Advertising Off period
gapRole_peripheralState = GAPROLE_CONNECTED;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
} else {
// In the Advertising Off period
gapRole_peripheralState = GAPROLE_WAITING;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
}
}
notify = TRUE;
} else if (pPkt->hdr.status == LL_STATUS_ERROR_COMMAND_DISALLOWED) //we're already advertising
{
notify = FALSE;
} else {
gapRole_peripheralState = GAPROLE_ERROR;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
//gapRole_abort();
}
}
break;
case GAP_LINK_ESTABLISHED_EVENT: {
gapEstLinkReqEvent_t *pPkt = (gapEstLinkReqEvent_t *) pMsg;
if (pPkt->hdr.status == SUCCESS) {
//add to database
gapRoleInfo_Add(pPkt);
// advertising will stop when a connection forms in the peripheral role
if (pPkt->connRole == GAP_PROFILE_PERIPHERAL) {
gapRole_peripheralState = GAPROLE_CONNECTED;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
// Check whether update parameter request is enabled
if (gapRole_ParamUpdateEnable == TRUE) {
// Get the minimum time upon connection establishment before the
// peripheral can start a connection update procedure.
uint16_t timeout = GAP_GetParamValue(
TGAP_CONN_PAUSE_PERIPHERAL);
Util_restartClock(&startUpdateClock, timeout * 1000);
}
}
// Notify the Bond Manager to the connection
VOID GAPBondMgr_LinkEst(pPkt->devAddrType, pPkt->devAddr, pPkt->connectionHandle, pPkt->connRole);
} else if (pPkt->hdr.status == bleGAPConnNotAcceptable) {
// Set enabler to FALSE; device will become discoverable again when
// this value gets set to TRUE
gapRole_AdvEnabled = FALSE;
// Go to WAITING state, and then start advertising
if (pPkt->connRole == GAP_PROFILE_PERIPHERAL) {
gapRole_peripheralState = GAPROLE_WAITING;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
}
} else {
if (pPkt->connRole == GAP_PROFILE_PERIPHERAL) {
gapRole_peripheralState = GAPROLE_ERROR;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
} else {
gapRole_abort();
}
}
notify = TRUE;
}
break;
case GAP_LINK_TERMINATED_EVENT: {
gapTerminateLinkEvent_t *pPkt = (gapTerminateLinkEvent_t *) pMsg;
// notify bond manager
GAPBondMgr_LinkTerm(pPkt->connectionHandle);
// Erase connection information (maybe make this a function)
uint8 connHandleIndex = gapRoleInfo_Find(pPkt->connectionHandle);
multiConnInfo[connHandleIndex].gapRole_ConnectionHandle = INVALID_CONNHANDLE;
multiConnInfo[connHandleIndex].gapRole_ConnInterval = 0;
multiConnInfo[connHandleIndex].gapRole_ConnSlaveLatency = 0;
multiConnInfo[connHandleIndex].gapRole_ConnTimeout = 0;
// Cancel all connection parameter update timers (if any active)
Util_stopClock(&startUpdateClock);
Util_stopClock(&updateTimeoutClock);
notify = TRUE;
if (multiConnInfo[connHandleIndex].gapRole_ConnRole == GAP_PROFILE_PERIPHERAL) {
// If device was advertising when connection dropped
if (gapRole_AdvNonConnEnabled) {
// Continue advertising.
gapRole_peripheralState = GAPROLE_ADVERTISING_NONCONN;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
}
// Else go to WAITING state.
else {
if (pPkt->reason == LL_SUPERVISION_TIMEOUT_TERM) {
gapRole_peripheralState = GAPROLE_WAITING_AFTER_TIMEOUT;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
} else {
gapRole_peripheralState = GAPROLE_WAITING;
gapRole_peripheralStateChangeHandler(gapRole_peripheralState);
}
// Start advertising, if enabled.
gapRole_setEvent(START_ADVERTISING_EVT);
}
}
}
break;
case GAP_LINK_PARAM_UPDATE_EVENT: {
gapLinkUpdateEvent_t *pPkt = (gapLinkUpdateEvent_t *) pMsg;
// Cancel connection param update timeout timer (if active)
Util_stopClock(&updateTimeoutClock);
if (pPkt->hdr.status == SUCCESS) {
// Store new connection parameters
// gapRole_ConnInterval = pPkt->connInterval;
// gapRole_ConnSlaveLatency = pPkt->connLatency;
// gapRole_ConnTimeout = pPkt->connTimeout;
// Make sure there's no pending connection update procedure
if (Util_isActive(&startUpdateClock) == FALSE) {
// // Notify the application with the new connection parameters
// if (pGapRoles_ParamUpdateCB != NULL)
// {
// (*pGapRoles_ParamUpdateCB)(gapRole_ConnInterval,
// gapRole_ConnSlaveLatency,
// gapRole_ConnTimeout);
// }
}
}
notify = TRUE;
}
break;
case GAP_PAIRING_REQ_EVENT: {
gapPairingReqEvent_t *pPkt = (gapPairingReqEvent_t *) pMsg;
// Send Pairing Failed Response
VOID GAP_TerminateAuth(pPkt->connectionHandle,
SMP_PAIRING_FAILED_NOT_SUPPORTED);
}
break;
case GAP_SLAVE_REQUESTED_SECURITY_EVENT: {
uint16_t connHandle = ((gapSlaveSecurityReqEvent_t *)pMsg)->connectionHandle;
uint8_t authReq = ((gapSlaveSecurityReqEvent_t *)pMsg)->authReq;
GAPBondMgr_SlaveReqSecurity(connHandle, authReq);
}
break;
case GAP_DEVICE_INFO_EVENT:
case GAP_DEVICE_DISCOVERY_EVENT:
notify = TRUE;
break;
default:
notify = FALSE;
break;
}
if (notify == TRUE) //app needs to take further action
{
if (pGapRoles_AppCGs && pGapRoles_AppCGs->pfnPassThrough) {
return (pGapRoles_AppCGs->pfnPassThrough((gapMultiRoleEvent_t *) pMsg));
}
}
return TRUE;
}