Mbed OS Reference | lctr_int_conn.h Source File

Go to the documentation of this file.
 /*************************************************************************************************/
 /*!
  *  \file
  *
  *  \brief  Internal link layer controller connection interface file.
  *
  *  Copyright (c) 2013-2019 Arm Ltd. All Rights Reserved.
  *
  *  Copyright (c) 2019-2020 Packetcraft, Inc.
  *  
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
  *  You may obtain a copy of the License at
  *  
  *      http://www.apache.org/licenses/LICENSE-2.0
  *  
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 /*************************************************************************************************/
 
 #ifndef LCTR_INT_CONN_H
 #define LCTR_INT_CONN_H
 
 #include "lctr_int.h"
 #include "lctr_api_conn.h"
 #include "lctr_pdu_conn.h"
 #include "lctr_pdu_adv.h"
 #include "lmgr_api_conn.h"
 #include "ll_defs.h"
 #include "sch_api.h"
 #include "bb_ble_api.h"
 #include "bb_ble_api_op.h"
 #include "wsf_cs.h"
 #include "wsf_msg.h"
 #include "wsf_timer.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /**************************************************************************************************
   Macros
 **************************************************************************************************/
 
 #define LCTR_MAX_CONS_CRC           2   /*!< Maximum number of consecutive CRC failures. */
 
 #define LCTR_DATA_PDU_START_OFFSET  2   /*!< Data PDU start offset in a buffer (match ACL header size). */
 
 #define LCTR_DATA_PDU_FC_OFFSET     0   /*!< Flow control fields data PDU offset. */
 #define LCTR_DATA_PDU_LEN_OFFSET    1   /*!< Length field data PDU offset. */
 
 #define LCTR_MAX_INSTANT            32767   /*!< Maximum instant value for connection update. */
 
 #define LCTR_CTRL_DATA_HANDLE       0xFF    /*!< Connection handle used for LL control PDUs. */
 
 #define LCTR_LE_PING_ATTEMPTS       4   /*!< LE Ping attempts. */
 
 #define LCTR_CH_SEL_MAX             2   /*!< Total number of channel selection algorithms. */
 
 /*! \brief      Resolve the connection handle from the context pointer. */
 #define LCTR_GET_CONN_HANDLE(pCtx)  (pCtx - pLctrConnTbl)
 
 /*! \brief      Resolve connection context from the handle. */
 #define LCTR_GET_CONN_CTX(h)        &(pLctrConnTbl[h])
 
 /*! \brief      Resolve txPower from phy index. */
 #define LCTR_GET_TXPOWER(pCtx, phy, option) \
         (pCtx->phyTxPower[phy - (((phy == LL_PHY_LE_CODED) && (option ==  BB_PHY_OPTIONS_BLE_S2)) ? 0 : 1)])
 
 /*! \brief      Set the txpower of a specified PHY. */
 #define LCTR_SET_TXPOWER(pCtx, phy, pow) (pCtx->phyTxPower[phy - 1] = pow)
 
 /*! \brief      Low threshold for power monitoring. */
 #define LCTR_RSSI_LOW_THRESHOLD     -65
 
 /*! \brief      High threshold for power monitoring. */
 #define LCTR_RSSI_HIGH_THRESHOLD    -30
 
 /*! \brief      Minimum time spent until request. */
 #define LCTR_PC_MIN_TIME            15
 
 /*! \brief      Default request of increase/decrease in value. */
 #define LCTR_PC_REQUEST_VAL         5
 
 /*! \brief      Special reset terminate reason. */
 #define LCTR_RESET_TERM_REASON  0xFF
 
 /**************************************************************************************************
   Data Types
 **************************************************************************************************/
 
 /*! \brief      Connected states. */
 enum
 {
   LCTR_CONN_STATE_INITIALIZED,          /*!< Connection initialized. */
   LCTR_CONN_STATE_ESTABLISHED_STARTUP,  /*!< Connection established before ready to start LLCP. */
   LCTR_CONN_STATE_ESTABLISHED_READY,    /*!< Connection established and ready to start LLCP. */
   LCTR_CONN_STATE_TERMINATING           /*!< Connection terminating. */
 };
 
 /*! \brief      LLCP states. */
 enum
 {
   LCTR_LLCP_STATE_IDLE,                 /*!< LLCP idle state. */
   LCTR_LLCP_STATE_BUSY,                 /*!< LLCP busy state. */
   LCTR_LLCP_STATE_TOTAL                 /*!< Total number of LLCP states. */
 };
 
 /*! \brief      Common LLCP states. */
 enum
 {
   LCTR_CMN_STATE_IDLE,                 /*!< LLCP idle state. */
   LCTR_CMN_STATE_BUSY,                 /*!< LLCP busy state. */
   LCTR_CMN_STATE_TOTAL                 /*!< Total number of LLCP states. */
 };
 
 /*! \brief      SVT states. */
 enum
 {
   LCTR_SVT_STATE_IDLE,                 /*!< SVT idle state. */
   LCTR_SVT_STATE_URGENT,               /*!< SVT urgent state. */
   LCTR_SVT_STATE_FATAL,                /*!< SVT fatal state. */
   LCTR_SVT_STATE_TOTAL                 /*!< Total number of SVT state. */
 };
 
 /*! \brief      Periodic sync source. */
 enum
 {
   LCTR_SYNC_SRC_SCAN,               /*!< Periodic sync info from scanner. */
   LCTR_SYNC_SRC_BCST,               /*!< Periodic sync info from broadcaster. */
   LCTR_SYNC_SRC_TOTAL               /*!< Total number of periodic sync source. */
 };
 
 /*! \brief      Common LLCP procedure IDs. */
 enum
 {
   /* Common SM LLCP procedures. */
   LCTR_PROC_CMN_TERM,                   /*!< Termination procedure. */
   LCTR_PROC_CMN_CH_MAP_UPD,             /*!< Channel map update procedure. */
   LCTR_PROC_CMN_FEAT_EXCH,              /*!< Feature exchange procedure. */
   LCTR_PROC_CMN_VER_EXCH,               /*!< Version exchange procedure. */
   LCTR_PROC_CMN_DATA_LEN_UPD,           /*!< Data length update procedure. */
   LCTR_PROC_CMN_SET_MIN_USED_CHAN,      /*!< Set minimum number of used channels procedure. */
   LCTR_PROC_CMN_PER_ADV_SYNC_TRSF,      /*!< Periodic advertising sync transfer procedure. */
   LCTR_PROC_CMN_REQ_PEER_SCA,           /*!< Request peer SCA procedure. */
   LCTR_PROC_CMN_TOTAL,                  /*!< Total number of common procedures. */
 
   /* Custom SM LLCP procedures. */
   LCTR_PROC_CONN_UPD,                   /*!< Connection update procedure. */
   LCTR_PROC_CONN_PARAM,                 /*!< Connection parameter procedure. */
   LCTR_PROC_ENCRYPT,                    /*!< Encryption Start or Restart procedure. */
   LCTR_PROC_LE_PING,                    /*!< LE Ping procedure. */
   LCTR_PROC_PHY_UPD,                    /*!< PHY update procedure. */
   LCTR_PROC_PHY_UPD_PEER,               /*!< Peer-initiated PHY update procedure. */
   LCTR_PROC_CIS_EST,                    /*!< CIS establishment procedure. */
   LCTR_PROC_CIS_EST_PEER,               /*!< Peer-initiated CIS establishment procedure. */
   LCTR_PROC_CIS_TERM,                   /*!< CIS termination procedure. */
   LCTR_PROC_CIS_TERM_PEER,              /*!< Peer-initiated CIS termination procedure. */
   LCTR_PROC_PWR_IND,                    /*!< Power indication prodecure. */
   LCTR_PROC_PWR_CTRL,                   /*!< Power control procedure. */
 
   LCTR_PROC_INVALID = 0xFF              /*!< Invalid ID. */
 
   /* Note: additional procedures without instants can be overridden. */
 };
 
 /*! \brief        Power control monitor schemes. */
 enum
 {
   LCTR_PC_MONITOR_AUTO,                /*!< Automatic monitoring scheme. */
   LCTR_PC_MONITOR_PATH_LOSS,           /*!< Path loss monitoring scheme. */
 
   LCTR_PC_MONITOR_SCHEME_TOTAL         /*!< Total number of monitoring schemes. */
 };
 
 /*! \brief        Power control scheme states. */
 enum
 {
   LCTR_PC_MONITOR_DISABLED,            /*!< Disabled monitoring. */
   LCTR_PC_MONITOR_ENABLED,             /*!< Monitoring enabled. */
   LCTR_PC_MONITOR_READY                /*!< Monitoring ready for enable. */
 };
 
 /*! \brief      Check if CIS is enabled by the CIS handle signature. */
 typedef bool_t (*lctrCheckCisEstCisFn_t)(uint16_t cisHandle);
 /*! \brief      Check for CIS termination signature. */
 typedef bool_t (*lctrCheckTermFn_t)(uint16_t aclHandle);
 /*! \brief      Check if there is a CIS established by the ACL handle signature. */
 typedef bool_t (*lctrCheckCisEstAclFn_t)(uint16_t aclHandle);
 
 /*! \brief      Connection context. */
 typedef struct
 {
   bool_t            enabled;            /*!< Context enabled. */
   uint8_t           state;              /*!< Current state. */
   uint8_t           role;               /*!< Connection role. */
   uint32_t          opModeFlags;        /*!< Operational mode flags. */
 
   /* Host/API */
   uint8_t           termReason;         /*!< Termination reason code. */
   uint8_t           replyWaitingMsk;    /*!< Host reply waiting mask. */
 
   /* BB data */
   BbOpDesc_t        connBod;            /*!< Connection BOD. */
   BbBleData_t       bleData;            /*!< BLE BB operation data. */
 
   union
   {
     struct
     {
       uint16_t      totalAcc;           /*!< Combined sleep clock inaccuracy. */
       uint16_t      lastActiveEvent;    /*!< Last active event counter. */
       uint32_t      txWinSizeUsec;      /*!< Tx window size. */
       uint32_t      anchorPointUsec;    /*!< Anchor point in microseconds. */
       uint32_t      unsyncedTime;       /*!< Unsynced time in BB tick before connection update. */
       bool_t        initAckRcvd;        /*!< Ack received from master. */
       bool_t        abortSlvLatency;    /*!< If TRUE abort slave latency. */
 
       uint8_t       consCrcFailed;      /*!< Number of consecutive CRC failures. */
       bool_t        syncWithMaster;     /*!< Flag indicating synchronize packet received from master. */
       bool_t        rxFromMaster;       /*!< At least one successful packet received from master. */
       uint32_t      firstRxStartTsUsec; /*!< Timestamp of the first received frame regardless of CRC error in microseconds. */
 
     } slv;                              /*!< Slave connection specific data. */
 
     struct
     {
       bool_t        sendConnUpdInd;     /*!< Send LL_CONNECTION_UPDATE_IND flag. */
     } mst;                              /*!< Master connection specific data. */
   } data;                               /*!< Role specific data. */
 
   /* Connection event parameters */
   uint16_t          maxLatency;         /*!< Maximum latency. */
   uint16_t          eventCounter;       /*!< Connection event counter. */
   uint16_t          connInterval;       /*!< Connection interval. */
 
   /* RF parameters */
   int8_t            rssi;               /*!< RSSI. */
   uint8_t           lastRxStatus;       /*!< Status code of last rx. */
 
   /* Channel parameters */
   uint8_t           lastChanIdx;        /*!< Current channel index. */
   uint8_t           hopInc;             /*!< Hop increment. */
   uint8_t           numUsedChan;        /*!< Number of used channels. */
   uint64_t          chanMask;           /*!< Channel mask. */
   uint8_t           chanRemapTbl[LL_CHAN_DATA_MAX_IDX + 1];
                                         /*!< Channel remapping table. */
   uint8_t           usedChSel;          /*!< Used channel selection. */
   uint16_t          chIdentifier;       /*!< Channel identifier. */
   uint32_t          crcInit;            /*!< CRC initialization value. */
   uint32_t          accessAddr;         /*!< Connection access address. */
   int8_t            phyTxPower[LL_PC_PHY_TOTAL];
                                         /*!< Saved txPower configuration for PHYs. */
 
   /* Flow control */
   lctrDataPduHdr_t  txHdr;              /*!< Transmit data PDU header. */
   lctrDataPduHdr_t  rxHdr;              /*!< Receive data PDU header. */
   wsfQueue_t        txLeuQ;             /*!< Transmit LE-U queue. */
   wsfQueue_t        txArqQ;             /*!< Transmit ARQ queue. */
   wsfQueue_t        rxDataQ;            /*!< Receive data pending queue. */
   uint8_t           numTxComp;          /*!< Number of completed Tx buffers. */
   uint8_t           numRxPend;          /*!< Number of Rx pending buffers. */
   bool_t            emptyPduPend;       /*!< Empty PDU ACK pending. */
   bool_t            emptyPduFirstAtt;   /*!< Empty PDU first attempt. */
   bool_t            forceStartPdu;      /*!< Next data will be forced to be a start PDU */
 
   /* Supervision */
   uint16_t          supTimeoutMs;       /*!< Supervision timeout in milliseconds. */
   wsfTimer_t        tmrSupTimeout;      /*!< Supervision timer. */
   bool_t            connEst;            /*!< Connection established. */
   uint8_t           svtState;           /*!< SVT urgency state. */
 
   /* Encryption */
   bool_t            pauseRxData;        /*!< Pause Rx data PDUs. */
   bool_t            pauseTxData;        /*!< Pause Tx data PDUs. */
   uint8_t           ltk[LL_KEY_LEN];    /*!< Long term key. */
   uint8_t           skd[LL_SKD_LEN];    /*!< Session key diversifier. */
   uint8_t           iv[LL_IV_LEN];      /*!< Initialization vector. */
   uint8_t           rand[LL_RAND_LEN];  /*!< Random number. */
   uint16_t          ediv;               /*!< Encrypted diversifier. */
 
   uint64_t          txPktCounter;       /*!< Transmit packet counter. */
   uint64_t          rxPktCounter;       /*!< Transmit packet counter. */
 
   /* Authentication */
   uint32_t          pingPeriodMs;       /*!< Ping period in milliseconds. */
   wsfTimer_t        tmrPingTimeout;     /*!< Ping timer. */
   uint32_t          authTimeoutMs;      /*!< Authentication payload timeout in milliseconds. */
   wsfTimer_t        tmrAuthTimeout;     /*!< Authentication payload timer. */
 
   LlEncMode_t       newEncMode;         /*!< Pending encryption mode. */
   bool_t            pendEncMode;        /*!< New encryption mode pending. */
 
   bool_t            keyUpdFlag;         /*!< Flag for key update. */
 
   /* Peer device info */
   uint8_t           numSentVerInd;      /*!< Number of sent LL_VERSION_IND. */
   bool_t            remoteVerValid;     /*!< Peer version data valid. */
   lctrVerInd_t      remoteVer;          /*!< Peer version data. */
   bool_t            featExchFlag;       /*!< Flag for completed feature exchange. */
   uint64_t          usedFeatSet;        /*!< Used feature set. */
   uint8_t           peerSca;            /*!< Peer SCA. */
 
   int8_t            peerTxPower;        /*!< Peer reported txPower. */
   uint8_t           peerPwrLimits;      /*!< Peer power limits field. */
   uint8_t           peerApr[LL_PC_PHY_TOTAL];
                                         /*!< Acceptable reduction of power as calculated by the peer. */
 
   /* Data length */
   lctrDataLen_t     localDataPdu;       /*!< Local Data PDU parameters. */
   lctrDataLen_t     effDataPdu;         /*!< Effective Data PDU parameters. */
   uint16_t          localConnDurUsec;   /*!< Local connection event duration. */
   uint16_t          effConnDurUsec;     /*!< Effective connection event duration. */
 
   /* PHY */
   uint8_t           allPhys;            /*!< Default all PHYs. */
   uint8_t           txPhys;             /*!< Default transmitter PHYs. */
   uint8_t           rxPhys;             /*!< Default receiver PHYs. */
   uint8_t           txPhysPending;      /*!< Pending transmitter PHYs. */
 
   /* Peer minimum number of used channels */
   uint8_t           peerMinUsedChan[LL_MAX_PHYS];
                                         /*!< Peer minimum number of used channels for PHYs. */
 
   /* Periodic sync indication */
   bool_t            sendPerSync;        /*!< Send LL_PERIODIC_SYNC_IND flag. */
   uint8_t           perSyncSrc;         /*!< Periodic sync source. */
   uint16_t          perServiceData;     /*!< ID for periodic sync indication. */
   uint16_t          perSyncHandle;      /*!< Periodic sync handle. */
 
   /* PAST(Periodic advertising sync transfer) parameters. */
   uint8_t           syncMode;           /*!< Sync transfer mode. */
   uint16_t          syncSkip;           /*!< Sync skip for periodic adv sync transfer. */
   uint16_t          syncTimeout;        /*!< Sync timeout for periodic adv sync transfer. */
 
   /* LLCP */
   uint8_t           llcpState;          /*!< Current LLCP state. */
   uint8_t           encState;           /*!< Current encryption state. */
   uint8_t           pingState;          /*!< Current ping state. */
   uint8_t           connUpdState;       /*!< Connection update state. */
   uint8_t           phyUpdState;        /*!< PHY update state. */
   uint8_t           cmnState;           /*!< Common LLCP state. */
   bool_t            peerReplyWaiting;   /*!< Peer waiting for reply. */
   bool_t            llcpInstantComp;    /*!< Procedure instant completed. */
   bool_t            termAckReqd;        /*!< Ack required for Rx'ed LL_TERMINATE_IND. */
   bool_t            ackAfterCtrlPdu;    /*!< Ack Tx'ed after last Control PDU Rx'ed. */
   bool_t            llcpIsOverridden;   /*!< Is the current procedure overridden by other procedure. */
   bool_t            isSlvReadySent;     /*!< True if slave ready to initiate startup LLCP procedure is sent. */
   bool_t            isFirstNonCtrlPdu;  /*!< True if first non-control PDU from master and slave. */
   bool_t            isSlvPhyUpdInstant; /*!< True if slave is in PHY update instant state. */
   uint8_t           llcpActiveProc;     /*!< Current procedure. */
   uint32_t          llcpNotifyMask;     /*!< Host notification mask. */
   uint32_t          llcpPendMask;       /*!< Pending LLCP procedures. */
   uint32_t          llcpIncompMask;     /*!< Incomplete LLCP procedures. */
   LlConnSpec_t      connUpdSpec;        /*!< Host connection update specification. */
   lctrConnUpdInd_t  connUpd;            /*!< Connection update parameters. */
   lctrConnParam_t   connParam;          /*!< Stored peer connection parameter request or response. */
   lctrChanMapInd_t  chanMapUpd;         /*!< Channel map parameters. */
   lctrPhy_t         phyReq;             /*!< Stored peer PHY request. */
   lctrPhyUpdInd_t   phyUpd;             /*!< PHY update parameters. */
   wsfTimer_t        tmrProcRsp;         /*!< Procedure response timer. */
   uint8_t           scaUpdAction;       /*!< Sca update action variable. */
   bool_t            readRemoteTxPower;  /*!< Currently reading remote txPower. */
   int8_t            scaMod;             /*!< Local sca override modifier. */
   uint8_t           reqErrCode;         /*!< LLCP error code. */
 
   /* Power Control */
   int8_t            delta;              /*!< Power control delta storage. */
   bool_t            peerReqRecvd;       /*!< Peer request received. */
   uint8_t           reqPhy;             /*!< PHY of most recent power control request. */
   bool_t            powerRptLocal;      /*!< Currently reporting local power changes. */
   bool_t            powerRptRemote;     /*!< Currently reporting remote power changes. */
   uint8_t           powerMonitorScheme; /*!< Active power monitoring scheme. */
   uint8_t           monitoringState;    /*!< Current state of active power monitoring scheme. */
   bool_t            controllerInitRead; /*!< A controller initiated read command. */
   union
   {
     struct
     {
       int8_t highThreshold;             /*!< High extreme RSSI threshold. */
       int8_t lowThreshold;              /*!< Low extreme RSSI threshold. */
       uint8_t minTimeSpent;             /*!< Minimum time spent in an extreme RSSI zone to trigger a request. */
       uint8_t curTimeSpent;             /*!< Current time spent in an extreme RSSI zone. */
       uint8_t requestVal;               /*!< Value of increase/decrease in power to request. */
     } autoMonitor;                      /*!< Autonomous RSSI monitoring specific data. */
 
     struct
     {
       uint8_t highThreshold;            /*!< Path loss high threshold. */
       uint8_t highHysteresis;           /*!< Path loss high hysteresis. */
       uint8_t lowThreshold;             /*!< Path loss low threshold. */
       uint8_t lowHysteresis;            /*!< Path loss low hysteresis. */
       uint8_t minTimeSpent;             /*!< Minimum time spent to trigger an event. */
       uint8_t curTimeSpent;             /*!< Current time spent in a new path loss zone. */
       uint8_t curZone;                  /*!< Current path loss zone. */
       uint8_t newZone;                  /*!< New zone. */
       bool_t initialPathLossRead;       /*!< A power control request is required to start path loss monitoring. */
     } pathLoss;                         /*!< Path loss parameters. */
   } pclMonitorParam;                    /*!< Power control monitoring data. */
 
   /* CIS */
   uint16_t                llcpCisHandle;           /*!< CIS handle for the LLCP procedure. */
   lctrCheckTermFn_t       checkCisTerm;            /*!< Pointer to the check CIS termination function. */
   lctrCheckCisEstAclFn_t  checkCisEstAcl;          /*!< Pointer to the check if CIS is established function. */
   uint8_t                 cisRssiExtremeTimeSpent; /*!< CIS's current time spent in an extreme zone. */
 } lctrConnCtx_t;
 
 /*! \brief      Call signature of a cipher block handler. */
 typedef void (*lctrCipherBlkHdlr_t)(PalCryptoEnc_t *pEnc, uint8_t id, uint8_t dir);
 
 /*! \brief      Call signature of a packet encryption handler. */
 typedef bool_t (*lctrPktEncHdlr_t)(PalCryptoEnc_t *pEnc, uint8_t *pHdr, uint8_t *pBuf, uint8_t *pMic);
 
 /*! \brief      Call signature of a packet decryption handler. */
 typedef bool_t (*lctrPktDecHdlr_t)(PalCryptoEnc_t *pEnc, uint8_t *pBuf);
 
 /*! \brief      Call signature of a set packet count handler. */
 typedef void (*lctrPktCntHdlr_t)(PalCryptoEnc_t *pEnc, uint64_t pktCnt);
 
 /*! \brief      Call signature of a LLCP state machine handler. */
 typedef bool_t (*LctrLlcpHdlr_t)(lctrConnCtx_t *pCtx, uint8_t event);
 
 /*! \brief      Call signature of a control PDU handler. */
 typedef void (*lctrCtrlPduHdlr_t)(lctrConnCtx_t *pCtx, uint8_t *pBuf);
 
 /*! \brief      Call signature of a Channel state machine handler. */
 typedef uint8_t (*LctrChSelHdlr_t)(lctrConnCtx_t *pCtx, uint16_t numSkip);
 
 /*! \brief      Call signature of an action handler. */
 typedef void (*lctrLlcpEh_t)(lctrConnCtx_t *pCtx);
 
 /*! \brief      Call signature of a power monitor function. */
 typedef void (*lctrPcMonAct_t)(lctrConnCtx_t *pCtx);
 
 /*! \brief      Call signature of power change indication handler. */
 typedef void (*lctrPcPowInd_t)(lctrConnCtx_t *pCtx, uint8_t phy, int8_t delta, int8_t txPower, bool_t phyChange);
 
 /*! \brief      Call signature of power report notification handler. */
 typedef void (*lctrPcNotifyPwr_t)(lctrConnCtx_t *pCtx, uint8_t reason, uint8_t phy, int8_t txPower, uint8_t limits, int8_t delta);
 
 /*! \brief      Call signature of CIS pend disconnect function. */
 typedef bool_t (*lctrPendCisDisc_t)(lctrConnCtx_t *pCtx);
 
 /*! \brief      LLCP state machine handlers. */
 enum
 {
   LCTR_LLCP_SM_ENCRYPT,                 /*!< Encryption LLCP state machine. */
   LCTR_LLCP_SM_PING,                    /*!< Ping state machine. */
   LCTR_LLCP_SM_CONN_UPD,                /*!< Connection update state machine. */
   LCTR_LLCP_SM_PHY_UPD,                 /*!< PHY update state machine. */
   LCTR_LLCP_SM_CIS_EST,                 /*!< CIS establishment state machine. */
   LCTR_LLCP_SM_CIS_TERM,                /*!< CIS termination state machine. */
   LCTR_LLCP_SM_PC,                     /*!< Power control state machine. */
   LCTR_LLCP_SM_CMN,                     /*!< Common LLCP state machine. */
   LCTR_LLCP_SM_TOTAL                    /*!< Total number of LLCP state machine. */
 };
 
 /**************************************************************************************************
   Global Variables
 **************************************************************************************************/
 
 extern lctrCipherBlkHdlr_t lctrInitCipherBlkHdlr;
 extern lctrPktEncHdlr_t lctrPktEncryptHdlr;
 extern lctrPktDecHdlr_t lctrPktDecryptHdlr;
 extern lctrPktCntHdlr_t lctrSetEncryptPktCountHdlr;
 extern lctrPktCntHdlr_t lctrSetDecryptPktCountHdlr;
 extern lctrConnCtx_t *pLctrConnTbl;
 extern lctrDataPdu_t lctrDataPdu;
 extern lctrConnMsg_t *pLctrConnMsg;
 extern const LctrVsHandlers_t *pLctrVsHdlrs;
 extern lctrCtrlPduHdlr_t lctrCtrlPduHdlr;
 extern LctrChSelHdlr_t lctrChSelHdlr[LCTR_CH_SEL_MAX];
 extern lctrCheckCisEstCisFn_t  lctrCheckCisEstCisFn;
 extern lctrLlcpEh_t lctrSendPerSyncFromScanFn;
 extern lctrLlcpEh_t lctrSendPerSyncFromBcstFn;
 extern lctrLlcpEh_t lctrStorePeriodicSyncTrsfFn;
 extern lctrLlcpEh_t lctrSendPeriodicSyncIndFn;
 extern lctrLlcpEh_t lctrReceivePeriodicSyncIndFn;
 extern lctrPcMonAct_t lctrPcActTbl[LCTR_PC_MONITOR_SCHEME_TOTAL];
 extern lctrPcPowInd_t lctrSendPowerChangeIndCback;
 extern lctrPcNotifyPwr_t lctrNotifyPowerReportIndCback;
 
 /**************************************************************************************************
   Function Declarations
 **************************************************************************************************/
 
 /* Initialization */
 void lctrConnDefaults(void);
 
 /* Builder */
 lctrConnCtx_t *lctrAllocConnCtx(void);
 void lctrFreeConnCtx(lctrConnCtx_t *pCtx);
 uint8_t lctrSelectNextDataChannel(lctrConnCtx_t *pCtx, uint16_t numSkip);
 uint8_t lctrSelectNextChannel2(lctrConnCtx_t *pCtx, uint16_t numSkip);
 void lctrBuildRemapTable(lctrConnCtx_t *pCtx);
 
 /* Task event handler */
 void lctrConnTxCompletedHandler(void);
 void lctrConnRxPendingHandler(void);
 
 /* Connection update actions */
 void lctrStoreConnUpdateSpec(lctrConnCtx_t *pCtx);
 void lctrSendConnUpdateInd(lctrConnCtx_t *pCtx);
 void lctrStoreConnUpdate(lctrConnCtx_t *pCtx);
 void lctrNotifyHostConnUpdateInd(lctrConnCtx_t *pCtx, uint8_t status);
 void lctrActNotifyHostConnUpdSuccess(lctrConnCtx_t *pCtx);
 void lctrActHostNegReply(lctrConnCtx_t *pCtx);
 void lctrActPeerRejectConnParam(lctrConnCtx_t *pCtx);
 
 /* Channel map actions */
 void lctrStoreChanMapUpdate(lctrConnCtx_t *pCtx);
 void lctrSendChanMapUpdateInd(lctrConnCtx_t *pCtx);
 void lctrStoreChanMap(lctrConnCtx_t *pCtx);
 
 /* Feature exchange actions */
 void lctrSendFeatureReq(lctrConnCtx_t *pCtx);
 void lctrSendFeatureRsp(lctrConnCtx_t *pCtx);
 void lctrStoreUsedFeatures(lctrConnCtx_t *pCtx);
 
 /* Version exchange actions */
 void lctrSendVersionInd(lctrConnCtx_t *pCtx);
 void lctrStoreRemoteVer(lctrConnCtx_t *pCtx);
 void lctrNotifyHostReadRemoteVerCnf(lctrConnCtx_t *pCtx);
 
 /* Terminate actions */
 void lctrSendTerminateInd(lctrConnCtx_t *pCtx);
 void lctrNotifyHostDisconnectInd(lctrConnCtx_t *pCtx);
 void lctrStoreTerminateReason(lctrConnCtx_t *pCtx);
 void lctrStoreDisconnectReason(lctrConnCtx_t *pCtx);
 void lctrStoreConnFailEstablishTerminateReason(lctrConnCtx_t *pCtx);
 void lctrStoreLlcpTimeoutTerminateReason(lctrConnCtx_t *pCtx);
 void lctrStoreResetTerminateReason(lctrConnCtx_t *pCtx);
 void lctrStoreInstantPassedTerminateReason(lctrConnCtx_t *pCtx);
 void lctrStoreMicFailedTerminateReason(lctrConnCtx_t *pCtx);
 
 /* Connection parameter actions */
 void lctrStoreConnParamReq(lctrConnCtx_t *pCtx);
 void lctrStoreConnParamRsp(lctrConnCtx_t *pCtx);
 void lctrStoreConnParamSpec(lctrConnCtx_t *pCtx);
 void lctrSendConnParamReq(lctrConnCtx_t *pCtx);
 void lctrSendConnParamRsp(lctrConnCtx_t *pCtx);
 void lctrNotifyHostConnParamInd(lctrConnCtx_t *pCtx);
 
 /* Data length exchange actions */
 void lctrStoreLocalDataLength(lctrConnCtx_t *pCtx);
 void lctrSendDataLengthReq(lctrConnCtx_t *pCtx);
 void lctrSendDataLengthRsp(lctrConnCtx_t *pCtx);
 void lctrStoreRemoteDataLength(lctrConnCtx_t *pCtx);
 void lctrNotifyHostDataLengthInd(lctrConnCtx_t *pCtx, uint8_t status);
 
 /* Set minimum number of used channels actions */
 void lctrSendSetMinUsedChanInd(lctrConnCtx_t *pCtx);
 void lctrStoreSetMinUsedChan(lctrConnCtx_t *pCtx);
 
 /* Send periodic sync indication actions */
 void lctrActStorePeriodicSyncTrsf(lctrConnCtx_t *pCtx);
 void lctrActSendPeriodicSyncInd(lctrConnCtx_t *pCtx);
 void lctrActReceivePeriodicSyncInd(lctrConnCtx_t *pCtx);
 void lctrStorePeriodicSyncTrsf(lctrConnCtx_t *pCtx);
 void lctrSendPeriodicSyncInd(lctrConnCtx_t *pCtx);
 void lctrReceivePeriodicSyncInd(lctrConnCtx_t *pCtx);
 void lctrSendPerSyncFromScan(lctrConnCtx_t *pCtx);
 void lctrSendPerSyncFromBcst(lctrConnCtx_t *pCtx);
 
 /* Request peer SCA actions. */
 void lctrStoreScaAction(lctrConnCtx_t *pCtx);
 void lctrSendPeerScaReq(lctrConnCtx_t *pCtx);
 void lctrSendPeerScaRsp(lctrConnCtx_t *pCtx);
 void lctrStorePeerSca(lctrConnCtx_t *pCtx);
 void lctrNotifyHostPeerScaCnf(lctrConnCtx_t *pCtx);
 
 /* Unknown/Unsupported */
 void lctrSendUnknownRsp(lctrConnCtx_t *pCtx);
 void lctrSendRejectInd(lctrConnCtx_t *pCtx, uint8_t reason, bool_t forceRejectExtInd);
 
 /* Tx data path */
 uint16_t lctrTxFragLen(lctrConnCtx_t *pTx);
 uint16_t lctrTxInitMem(uint8_t *pFreeMem, uint32_t freeMemSize);
 uint8_t *lctrTxCtrlPduAlloc(uint8_t pduLen);
 void lctrTxDataPduQueue(lctrConnCtx_t *pCtx, uint16_t fragLen, lctrAclHdr_t *pAclHdr, uint8_t *pAclBuf);
 void lctrTxCtrlPduQueue(lctrConnCtx_t *pCtx, uint8_t *pBuf);
 uint8_t lctrTxQueuePeek(lctrConnCtx_t *pCtx, PalBbBleTxBufDesc_t *bbDescs, bool_t *pMd);
 bool_t lctrTxQueuePop(lctrConnCtx_t *pCtx);
 void lctrTxQueuePopCleanup(lctrConnCtx_t *pCtx);
 uint8_t lctrTxQueueClear(lctrConnCtx_t *pCtx);
 
 /* Rx data path */
 uint8_t *lctrRxPduAlloc(uint16_t maxRxLen);
 void lctrRxPduFree(uint8_t *pBuf);
 void lctrRxEnq(uint8_t *pBuf, uint16_t eventCounter, uint16_t connHandle);
 uint8_t *lctrRxDeq(uint16_t *pConnHandle);
 void lctrRxConnEnq(lctrConnCtx_t *pCtx, uint8_t *pBuf);
 uint8_t *lctrRxConnDeqAcl(lctrConnCtx_t *pCtx);
 uint8_t lctrRxConnClear(lctrConnCtx_t *pCtx);
 
 /* LLCP */
 void lctrStartLlcpTimer(lctrConnCtx_t *pCtx);
 void lctrStopLlcpTimer(lctrConnCtx_t *pCtx);
 void lctrStartPendingLlcp(lctrConnCtx_t *pCtx);
 
 /* Data path pause */
 void lctrPauseTxData(lctrConnCtx_t *pCtx);
 void lctrUnpauseTxData(lctrConnCtx_t *pCtx);
 void lctrCheckPauseComplete(lctrConnCtx_t *pCtx);
 void lctrPauseRxData(lctrConnCtx_t *pCtx);
 void lctrUnpauseRxData(lctrConnCtx_t *pCtx);
 
 /* Packet times */
 void lctrSetPacketTimeRestriction(lctrConnCtx_t *pCtx, uint8_t txPhys);
 void lctrRemovePacketTimeRestriction(lctrConnCtx_t *pCtx);
 uint16_t lctrCalcConnDurationUsec(lctrConnCtx_t *pCtx, const lctrDataLen_t *pDataLen);
 
 /* Scheduler */
 BbOpDesc_t *lctrConnResolveConflict(BbOpDesc_t *pNewOp, BbOpDesc_t *pExistOp);
 
 /* ISR */
 uint8_t *lctrProcessRxAck(lctrConnCtx_t *pCtx);
 void lctrTxPduAck(lctrConnCtx_t *pCtx);
 bool_t lctrProcessTxAck(lctrConnCtx_t *pCtx);
 void lctrProcessTxAckCleanup(lctrConnCtx_t *pCtx);
 uint16_t lctrSetupForTx(lctrConnCtx_t *pCtx, uint8_t rxStatus, bool_t reqTx);
 void lctrRxPostProcessing(lctrConnCtx_t *pCtx, uint8_t *pRxBuf, uint8_t *pNextRxBuf, bool_t loadRxBuf);
 
 /* Helper */
 void lctrSendConnMsg(lctrConnCtx_t *pCtx, uint8_t event);
 bool_t lctrExceededMaxDur(lctrConnCtx_t *pCtx, uint32_t ceStart, uint32_t pendDurUsec);
 uint32_t lctrCalcPingPeriodMs(lctrConnCtx_t *pCtx, uint32_t authTimeoutMs);
 uint8_t lctrComputeSca(void);
 uint32_t lctrConnGetAnchorPoint(lctrConnCtx_t *pCtx, uint16_t ceCounter);
 void lctrInitPhyTxPower(lctrConnCtx_t *pCtx);
 uint8_t lctrGetPowerLimits(int8_t txPower);
 
 /* Reservation */
 uint32_t lctrGetConnRefTime(uint8_t connHandle, uint32_t *pDurUsec);
 
 /*************************************************************************************************/
 /*!
  *  \brief  Set flags for link termination.
  *
  *  \param  pCtx    Connection context.
  */
 /*************************************************************************************************/
 static inline void lctrFlagLinkTerm(lctrConnCtx_t *pCtx)
 {
   bool_t removeBod = (pCtx->state == LCTR_CONN_STATE_ESTABLISHED_READY);
 
   pCtx->state = LCTR_CONN_STATE_TERMINATING;    /* signals ISR to terminate link */
   pCtx->llcpState = LCTR_LLCP_STATE_IDLE;       /* signals ISR do not wait to send TERMINATE_IND */
 
   if (removeBod)
   {
     SchRemove(&pCtx->connBod);
   }
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Service the Control PDU ACK state after a successful reception.
  *
  *  \param  pCtx    Connection context.
  */
 /*************************************************************************************************/
 static inline void lctrCheckControlPduAck(lctrConnCtx_t *pCtx)
 {
   if (pCtx->rxHdr.llid == LL_LLID_CTRL_PDU)
   {
     /* Control PDU received; reset Tx ACK pending state. */
     pCtx->ackAfterCtrlPdu = FALSE;
   }
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Service the Control PDU ACK state after a successful transmission.
  *
  *  \param  pCtx    Connection context.
  */
 /*************************************************************************************************/
 static inline void lctrSetControlPduAck(lctrConnCtx_t *pCtx)
 {
   /* Unconditionally set state upon Tx completion. */
   pCtx->ackAfterCtrlPdu = TRUE;
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Set flags for link termination.
  *
  *  \param  pCtx    Connection context.
  *
  *  \return TRUE if connection is terminated, FALSE otherwise.
  */
 /*************************************************************************************************/
 static inline bool_t lctrCheckForLinkTerm(lctrConnCtx_t *pCtx)
 {
   if (pCtx->state == LCTR_CONN_STATE_TERMINATING)
   {
     /* Peer device is LL_TERMINATE_IND initiator. */
     if (pCtx->termAckReqd)                  /* Tx Ack required after Rx of LL_TERMINATE_IND */
     {
       if (pCtx->ackAfterCtrlPdu)            /*     guarantee Ack Tx'ed */
       {
         return TRUE;
       }
     }
     /* Local device is LL_TERMINATE_IND initiator. */
     else if ((pCtx->llcpState == LCTR_LLCP_STATE_IDLE) || /* LL_TERMINATE_IND not pending */
              (pCtx->txArqQ.pHead == NULL))                /* guarantee LL_TERMINATE_IND is Ack'ed */
                                                           /*     i.e. "WsfQueueEmpty(&pCtx->txArqQ)" (optimized for ISR) */
     {
       return TRUE;
     }
   }
 
   return FALSE;
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Increment the Tx/encrypt packet counter.
  *
  *  \param  pCtx    Connection context.
  */
 /*************************************************************************************************/
 static inline void lctrIncPacketCounterTx(lctrConnCtx_t *pCtx)
 {
   if (lctrSetEncryptPktCountHdlr)
   {
     PalCryptoEnc_t * const pEnc = &pCtx->bleData.chan.enc;
 
     if ((pEnc->enaEncrypt) &&
         (pEnc->nonceMode == PAL_BB_NONCE_MODE_PKT_CNTR))
     {
       pCtx->txPktCounter++;
     }
   }
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Increment the Rx/decrypt packet counter.
  *
  *  \param  pCtx    Connection context.
  */
 /*************************************************************************************************/
 static inline void lctrIncPacketCounterRx(lctrConnCtx_t *pCtx)
 {
   if (lctrSetEncryptPktCountHdlr)
   {
     PalCryptoEnc_t * const pEnc = &pCtx->bleData.chan.enc;
 
     if ((pEnc->enaEncrypt) &&
         (pEnc->nonceMode == PAL_BB_NONCE_MODE_PKT_CNTR))
     {
       pCtx->rxPktCounter++;
     }
   }
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Set the transmit packet counter value in the BB.
  *
  *  \param  pCtx    Connection context.
  */
 /*************************************************************************************************/
 static inline void lctrSetBbPacketCounterTx(lctrConnCtx_t *pCtx)
 {
   if (lctrSetEncryptPktCountHdlr)
   {
     PalCryptoEnc_t * const pEnc = &pCtx->bleData.chan.enc;
 
     if (!pEnc->enaEncrypt)
     {
       return;
     }
 
     switch (pEnc->nonceMode)
     {
       case PAL_BB_NONCE_MODE_PKT_CNTR:
         lctrSetEncryptPktCountHdlr(pEnc, pCtx->txPktCounter);
         break;
       case PAL_BB_NONCE_MODE_EXT16_CNTR:
         lctrSetEncryptPktCountHdlr(pEnc, pCtx->eventCounter);
         break;
       default:
         break;
     }
   }
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Set the receive packet counter value in the BB.
  *
  *  \param  pCtx    Connection context.
  */
 /*************************************************************************************************/
 static inline void lctrSetBbPacketCounterRx(lctrConnCtx_t *pCtx)
 {
   if (lctrSetDecryptPktCountHdlr)
   {
     PalCryptoEnc_t * const pEnc = &pCtx->bleData.chan.enc;
 
     if (!pEnc->enaDecrypt)
     {
       return;
     }
 
     switch (pEnc->nonceMode)
     {
       case PAL_BB_NONCE_MODE_PKT_CNTR:
         lctrSetDecryptPktCountHdlr(pEnc, pCtx->rxPktCounter);
         break;
       case PAL_BB_NONCE_MODE_EXT16_CNTR:
         lctrSetDecryptPktCountHdlr(pEnc, pCtx->eventCounter);
         break;
       default:
         break;
     }
   }
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Check if procedure is active, if not pend the procedure.
  *
  *  \param  pCtx        Connection context.
  *  \param  proc        Procedure ID to check/pend.
  *
  *  \return TRUE if active procedure, FALSE if pended.
  */
 /*************************************************************************************************/
 static inline bool_t lctrCheckActiveOrPend(lctrConnCtx_t *pCtx, uint8_t proc)
 {
   if (pCtx->llcpActiveProc == proc)
   {
     return TRUE;
   }
   else
   {
     pCtx->llcpPendMask |= 1 << proc;
     return FALSE;
   }
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief      Store connection timeout termination reason.
  *
  *  \param      pCtx    Connection context.
  */
 /*************************************************************************************************/
 static inline void lctrStoreConnTimeoutTerminateReason(lctrConnCtx_t *pCtx)
 {
   if (pCtx->termReason == LL_ERROR_CODE_CONN_FAILED_TO_ESTABLISH)
   {
     pCtx->termReason = LL_ERROR_CODE_CONN_TIMEOUT;
   }
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Increment available Tx data buffers.
  */
 /*************************************************************************************************/
 static inline void lctrDataTxIncAvailBuf(void)
 {
   WSF_CS_INIT();
 
   WSF_CS_ENTER();
   lmgrConnCb.availTxBuf++;
   WSF_CS_EXIT();
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Decrement available Tx data buffers.
  */
 /*************************************************************************************************/
 static inline void lctrDataTxDecAvailBuf(void)
 {
   WSF_CS_INIT();
 
   WSF_CS_ENTER();
   lmgrConnCb.availTxBuf--;
   WSF_CS_EXIT();
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief  Increment available Rx data buffers.
 *
  *  \param  numBufs     Number of completed packets.
   */
 /*************************************************************************************************/
 static inline void lctrDataRxIncAvailBuf(uint8_t numBufs)
 {
   WSF_CS_INIT();
 
   WSF_CS_ENTER();
   lmgrConnCb.availRxBuf += numBufs;
   WSF_CS_EXIT();
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief      Get connection operational mode flags.
  *
  *  \param      pCtx    Connection context to get the flag.
  *  \param      flag    Flags.
  *
  *  \return     Status error code.
  *
  *  Set mode flags governing LL operations of a given connection.
  */
 /*************************************************************************************************/
 static inline bool_t lctrGetConnOpFlag(lctrConnCtx_t *pCtx, uint32_t flag)
 {
   return (pCtx->opModeFlags & flag) ? TRUE : FALSE;
 }
 
 /*************************************************************************************************/
 /*!
  *  \brief      Get LLCP procedure ID.
  *
  *  \param      event   Event.
  *
  *  \return     LLCP procedure event ID.
  */
 /*************************************************************************************************/
 static inline uint8_t lctrGetProcId(uint8_t event)
 {
   switch (event)
   {
     case LCTR_CONN_MSG_API_CHAN_MAP_UPDATE:
       return LCTR_PROC_CMN_CH_MAP_UPD;
 
     case LCTR_CONN_MSG_API_REMOTE_FEATURE:
       return LCTR_PROC_CMN_FEAT_EXCH;
 
     case LCTR_CONN_MSG_API_SET_MIN_USED_CHAN:
       return LCTR_PROC_CMN_SET_MIN_USED_CHAN;
 
     case LCTR_CONN_MSG_API_REMOTE_VERSION:
       return LCTR_PROC_CMN_VER_EXCH;
 
     case LCTR_CONN_MSG_API_DISCONNECT:
       return LCTR_PROC_CMN_TERM;
 
     case LCTR_CONN_MSG_API_DATA_LEN_CHANGE:
       return LCTR_PROC_CMN_DATA_LEN_UPD;
 
     case LCTR_CONN_MSG_API_PER_ADV_SYNC_TRSF:
       return LCTR_PROC_CMN_PER_ADV_SYNC_TRSF;
 
     case LCTR_CONN_MSG_API_REQ_PEER_SCA:
       return LCTR_PROC_CMN_REQ_PEER_SCA;
 
     case LCTR_CONN_MSG_API_CONN_UPDATE:
       return LCTR_PROC_CONN_UPD;
 
     case LCTR_CONN_MSG_API_PHY_UPDATE:
       return LCTR_PROC_PHY_UPD;
 
     case LCTR_CONN_MSG_API_START_ENC:
       return LCTR_PROC_ENCRYPT;
 
     default:
       return LCTR_PROC_INVALID;
   }
 }
 
 #ifdef __cplusplus
 };
 #endif
 
 #endif /* LCTR_INT_CONN_H */
Important Information for this Arm website
