/** **************************************************************************************** * * @file lc.h * * @brief Link controller internal definition * * Copyright (C) RivieraWaves 2009-2015 * **************************************************************************************** */ #ifndef LC_INT_H_ #define LC_INT_H_ /** **************************************************************************************** * @addtogroup LC Link Controller * @{ **************************************************************************************** */ /* * INCLUDE FILES **************************************************************************************** */ #include // standard integer #include "rwip_config.h" // stack configuration #include "co_bt.h" // BT standard definitions #include "co_utils.h" // BT utility definitions #include "co_math.h" // BT utility definitions #include "ke_msg.h" // kernel message declaration #include "ke_task.h" // kernel task definitions #include "bt_util_sp.h" // simple pairing computations #include "lc_sco.h" // SCO definitions /* * DEFINES **************************************************************************************** */ /// Maximum number of instances of the LC task #define LC_IDX_MAX MAX_NB_ACTIVE_ACL /* * ENUMERATIONS **************************************************************************************** */ ///Transition collision state or Extended opcode used enum { /// internal: lm_util not used LC_UTIL_NOT_USED, /// internal: lm_util used LC_UTIL_INUSED, }; /// Possible states of the LC task enum LC_STATE { LC_FREE, LC_CONNECTED, LC_MST_WAIT_VERS, LC_MST_WAIT_ENC_SIZE_MSK, LC_SCO_NEGO_ONGOING, LC_SCO_DISC_ONGOING, LC_WAIT_CLK_OFF, LC_WAIT_TIM_ACC_RSP, LC_WAIT_QOS_CFM, LC_WAIT_ACL_ACC, LC_WAIT_TEST_TX_CFM, //10 LC_WAIT_MAX_SLOT_CFM, LC_PUB_KEY_HEADER_INIT_LOC, LC_PUB_KEY_PAYLOAD_INIT_LOC, LC_PUB_KEY_HEADER_RSP_CFM, LC_PUB_KEY_PAYLOAD_RSP_PEER_CFM, LC_REM_NAME_PAGE_CANCEL, LC_WAIT_REM_HL_CON, LC_WAIT_REM_NAME, LC_WAIT_REM_VERS, LC_WAIT_REM_FEATS, //20 LC_WAIT_REM_EXT_FEATS, LC_WAIT_DETACH_REQ_TX_CFM, LC_WAIT_DISC_TO, LC_WAIT_DISC_CFM, LC_WAIT_DETACH_TO, LC_WAIT_PAIR_CFM_INIT, LC_WAIT_PAIR_CFM_RSP, LC_WAIT_AUTH_SRES, LC_WAIT_KEY_EXCH, LC_WAIT_KEY_EXCH_RSP, //30 LC_WAIT_AU_RAND_RSP, LC_WAIT_AU_RAND_PEER_INIT, LC_WAIT_LINK_KEY, LC_WAIT_PIN_CODE, LC_WAIT_SRES_RSP, LC_WAIT_SRES_INIT, LC_WAIT_ENC_MODE_CFM, LC_WAIT_ENC_SIZE_CFM, LC_WAIT_ENC_STOP_CFM_MST, LC_WAIT_ENC_START_CFM, //40 LC_WAIT_ENC_SLV_SIZE, LC_WAIT_ENC_SLV_RESTART, LC_WAIT_EPR_ENC_STOP_REQ_SLV_INIT, LC_WAIT_ENC_START_REQ_SLV, LC_WAIT_EPR_ENC_PAUSE_REQ_MST_INIT, LC_WAIT_SNIFF_REQ, LC_WAIT_SNIFF_ACC_TX_CFM, LC_WAIT_SNIFF_SUB_RSP, LC_WAIT_SNIFF_SUB_RSP_TX_CFM, LC_WAIT_UNSNIFF_ACC, //50 LC_WAIT_UNSNIFF_ACC_TX_CFM, LC_WAIT_SWITCH_CFM, LC_WAIT_SWITCH_CMP, LC_WAIT_MST_SEMI_ACC, LC_WAIT_PKT_TBL_TYP_ACC_CFM, LC_WAIT_HL_IO_CAP_INIT, LC_WAIT_HL_IO_CAP_RSP, LC_WAIT_IO_CAP_INIT_CFM, LC_WAIT_PUB_KEY_HEADER_INIT_PEER, LC_WAIT_PUB_KEY_PAYLOAD_INIT_PEER, //60 LC_WAIT_PUB_KEY_HEADER_RSP_PEER, LC_WAIT_PUB_KEY_PAYLOAD_RSP_PEER, LC_WAIT_NUM_COMP_COMM_INIT_CONF, LC_WAIT_NUM_COMP_COMM_INIT_RANDN_PEER, LC_WAIT_NUM_COMP_COMM_INIT_RANDN_CFM, LC_WAIT_NUM_COMP_USER_CONF_INIT, LC_WAIT_NUM_COMP_USER_CONF_RSP, LC_WAIT_NUM_COMP_RANDN_RSP_PEER, LC_WAIT_NUM_COMP_RANDN_RSP_PEER_CFM, LC_WAIT_DHKEY_RSP, //70 LC_WAIT_DHKEY_CHECK_INIT_PEER, LC_WAIT_DHKEY_CHECK_INIT_CFM, LC_WAIT_DHKEY_CHECK_RSP_PEER_CFM, LC_WAIT_PASSKEY_HL_RPLY, LC_WAIT_PASSKEY_COMM_RSP_PEER, LC_WAIT_PASSKEY_COMM_INIT_PEER, LC_WAIT_PASSKEY_RANDN_INIT_CFM, LC_WAIT_PASSKEY_RANDN_INIT_PEER, LC_WAIT_PASSKEY_RANDN_RSP_PEER, LC_WAIT_PASSKEY_RANDN_RSP_PEER_CFM, //80 LC_WAIT_HL_OOB_DATA, LC_WAIT_OOB_RANDN_RSP_PEER, LC_WAIT_OOB_RANDN_RSP_PEER_CFM, LC_WAIT_OOB_RANDN_INIT_PEER, LC_WAIT_OOB_RANDN_INIT_CFM, LC_WAIT_EPR_RSP, LC_WAIT_EPR_ENC_RESUME_REQ_MST_RSP, LC_WAIT_PWR_CTRL_RES, LC_WAIT_PWR_CTRL_TX_CFM, LC_WAIT_DHKEY_COMPUTING, //90 LC_WAIT_AUTH_STG1_NC_RANDN, LC_WAIT_AUTH_STG1_PK_RANDN, LC_WAIT_DHKEY_RSP_FAIL, LC_WAIT_EPR_PEER_REQ_MST, LC_WAIT_EPR_PEER_REQ_SLV, LC_WAIT_EPR_ENC_PAUSE_REQ_MST_RSP, LC_WAIT_EPR_ENC_STOP_REQ_SLV_RSP, LC_WAIT_RESTART_ENC, LC_WAIT_AU_RAND_SEC_AUTH_INIT, LC_WAIT_SRES_SEC_AUTH_INIT, //100 LC_WAIT_PING_RES, LC_WAIT_SSR_INSTANT, LC_WAIT_PTT_ACC_TX_CFM, #if PCA_SUPPORT LC_WAIT_CLK_ADJ_REQ_ACC_CFM, LC_WAIT_CLK_ADJ_CFM, #endif // PCA_SUPPORT #if RW_BT_MWS_COEX LC_WAIT_SAM_SET_TYPE0_CFM, LC_WAIT_SAM_DEFINE_MAP_CFM, LC_WAIT_SAM_SWITCH_CFM, #endif //RW_BT_MWS_COEX #if RW_DEBUG LC_WAIT_DBG_SEND_LMP_CFM, #endif // RW_DEBUG // Number of states. LC_STATE_MAX }; /* * TYPE DEFINITIONS **************************************************************************************** */ /// LC Link Structure struct lc_link_tag { /// token rate uint32_t TokenRate; /// peak bandwidth uint32_t PeakBandwidth; /// latency uint32_t Latency; /// delay variation uint32_t DelayVariation; /// access latency uint32_t AccessLatency; /// token bucket size uint32_t TokenBucketSize; /// switch instant uint32_t SwitchInstant; /// link timeout value uint16_t LinkTimeout; /// ACL basic packet type uint16_t AclPacketType; /// current packet type uint16_t CurPacketType; /// settings for link policy uint16_t LinkPolicySettings; /// polling interval uint16_t PollInterval; /// slot offset uint16_t SlotOffset; /// failed contact uint16_t FailedContact; /// Rx preferred rate uint16_t RxPreferredRate; /// Authenticated payload time out (expressed in units of 10 ms) uint16_t auth_payl_to; /// Authenticated payload time out margin (expressed in units of 10 ms) uint16_t auth_payl_to_margin; /// device class struct devclass Class; /// transmit current max slot uint8_t TxMaxSlotCur; /// received max slot uint8_t MaxSlotReceived; /// allowed role switch indication uint8_t AllowRoleSwitch; /// device role uint8_t Role; /// reason uint8_t Reason; /// logical transport address uint8_t LtAddr; /// Rx transaction id server uint8_t RxTrIdServer; /// RX transaction id client uint8_t RxTrIdClient; /// RX packet type ID uint8_t RxPktTypeID; /// current mode uint8_t CurrentMode; /// flow direction uint8_t FlowDirection; /// service type uint8_t ServiceType; /// current packet type table uint8_t CurPacketTypeTable; /// temporary packet type table uint8_t ptt_tmp; /// flag uint8_t Flags; /// MIC error counter uint8_t micerr_cnt; /// initiator flag bool Initiator; /// connected state flag bool ConnectedState; /// setup complete flag bool SetupComplete; /// setup complete Rx flag bool SetupCompRx; /// setup complete Tx flag bool SetupCompTx; /// connection complete sent flag bool ConnectionCompleteSent; /// host connected flag bool HostConnected; /// flush continue flag bool FlushContinue; /// minimum power received flag bool MinPowerRcv; /// maximum power received flag bool MaxPowerRcv; /// packet type table 2 MB flag bool PacketTypeTable2Mb; /// quality of service notified flag bool QOSNotified; /// Enhanced Power Control supported by peer bool epc_supported; /// Indicate L2CAP start fragment is pending bool l2cap_start; /// eSCO loopback mode (False: disabled | True: enabled) bool esco_loopback_mode; #if RW_DEBUG /// LMP Packet Discard bool LMPPacketDiscard; #endif //RW_DEBUG }; /// Structure for the version indication struct lc_vers_tag { /// company identification uint16_t compid; /// sub version uint16_t subvers; /// version uint8_t vers; }; /// LC Information Structure struct lc_info_tag { /// remote features (including extended) struct features RemoteFeatures[FEATURE_PAGE_MAX]; /// local bd address struct bd_addr LocalBdAddr; /// bd address struct bd_addr BdAddr; /// remote version struct lc_vers_tag RemVers; /// remote name struct bd_name name_rem; /// boolean for send remote name confirm bool SendRemoteNameCfm; /// Bit field indicating remote features pages received (bit0: page 0 | bit1: page 1 | bit2: page 2) uint8_t RemFeatureRec; /// boolean for received version bool RecvRemVerRec; }; /// LC Encryption Structure struct lc_enc_tag { /// Key given from Host (or generated via pairing) uint8_t key_from_host; /// key size mask uint16_t KeySizeMask; /// key type uint8_t KeyType; /// key flag uint8_t KeyFlag; /// new key flag uint8_t NewKeyFlag; /// status of the key uint8_t KeyStatus; /// status of pin uint8_t PinStatus; /// length of the pin uint8_t PinLength; /// encryption size uint8_t EncSize; /// encryption mode uint8_t EncMode; /// new encryption mode uint8_t NewEncMode; /// encryption enable uint8_t EncEnable; /// Authentication key (secure connections) struct ltk auth_key; /// long term key struct ltk LTKey; /// semi permanent key struct ltk SemiPermanentKey; /// overlay key struct ltk Overlay; /// random rx key struct ltk RandomRx; /// random tx key struct ltk RandomTx; /// encryption key struct ltk EncKey; /// signed response struct sres_nb Sres; /// signed response expected from peer struct sres_nb Sres_expected; /// aco value struct aco Aco; /// pin code struct pin_code PinCode; /// boolean link key valid bool LinkKeyValid ; /// Prevent encryption change event bool PreventEncEvt; }; /// LC Request owner Structure struct lc_req_tag { // Request from local device /// local name request bool LocNameReq; /// local request for extended features bool LocRemoteExtendedReq; /// disconnection request bool LocDetachReq; /// change packet type request bool LocCPTReq; /// encryption request bool LocEncReq; /// authentication request bool LocAuthReq; /// key exchange request bool LocKeyExchangeReq; /// encryption key refresh bool LocEncKeyRefresh; /// switch request bool LocSwitchReq; /// version request bool LocVersReq; /// Flow specification request bool LocFlowSpecReq; // Request from the Peer device /// switch request bool PeerSwitchReq; /// authentication request bool PeerAuthReq; /// encryption request bool PeerEncReq; /// disconnection request bool PeerDetachReq; /// encryption key refresh bool PeerEncKeyRefresh; // Request Internal /// restart encryption request bool RestartEncReq; /// master key request bool MasterKeyReq; }; /// LC Test Mode Structure struct lc_test_mode_tag { /// Data length uint16_t DataLength; /// Test scenario uint8_t TestScenario; /// Hopping mode uint8_t HoppingMode; /// Transmit frequency uint8_t TxFreq; /// Reception frequency uint8_t RxFreq; /// Power control test uint8_t PowerControl; /// Polling period uint8_t PollPeriod; /// Packet type uint8_t PacketType; /// Activation state bool activated; }; /// LC AFH Structure struct lc_afh_tag { /// AFH channel map - defined by the master struct chnl_map ch_map; /// AFH channel classification - computed by the slave struct chnl_map ch_class; /// AFH reporting interval (in slots) uint32_t reporting_interval; /// AFH enable bool en; /// AFH temporary state (state saved during Role switch) bool temp_en; /// AFH reporting enable bool reporting_en; /// AFH lmp_ch_class PDU waiting for Tx confirmation - used to control the flow of lmp_ch_class PDUs bool lmp_ch_class_pending; }; /// LC Simple Pairing Structure struct lc_simple_pairing_tag { /// Environment to perform DH Key computations lm_sp_p192_comp_global_data* lm_sp_p192_dhkey_data; /// Environment to perform DH Key computations lm_sp_p256_comp_global_data* lm_sp_p256_dhkey_data; /// pass key uint32_t Passkey; /// local random number struct byte16 LocRandN; /// remote random number struct byte16 RemRandN; /// local commitment value struct byte16 LocCommitment; /// remote commitment value struct byte16 RemCommitment; /// DH key check key struct ltk DHKeyCheck; /// local IO capability struct io_capability IOCap_loc; /// remote IO capability struct io_capability IOCap_rem; /// encapsulated PDU counter uint8_t EncapPduCtr; /// simple pairing phase1 failure uint8_t SPPhase1Failed; /// simple pairing DH key uint8_t SPDHKey; /// simple pairing transaction id uint8_t SpTId; /// simple pairing initiator bool SPInitiator; /// Secure Connections (true if supported by both controllers and both Hosts) bool sec_con; }; /// LC EPR Structure struct lc_epr_tag { /// epr enable bool on; /// epr role switch bool rsw; /// role switch error code uint8_t rswerror; /// change connection link key epr enable bool cclk; }; /// LC util local transaction detail struct lc_local_trans_details_tag { /// lmp opcode uint8_t Opcode; /// lmp extended opcode uint8_t OpcodeExt; /// boolean if in used uint8_t InUse; }; #if PCA_SUPPORT /// LC piconet clock adjust detail struct lc_pca_tag { bool activated; uint8_t clk_adj_id; }; #endif // PCA_SUPPORT /// LC SAM Pattern detail struct lc_sam_pattern { ///Num slots available for tx (slots) uint16_t n_tx_slots; ///Num slots available for rx (slots) uint16_t n_rx_slots; ///SAM Submaps struct sam_submaps submaps; ///Tsam-sm (slots) uint8_t t_sam_sm; ///Nsam-sm (slots) uint8_t n_sam_sm; ///Num ext submap uint8_t n_ex_sm; }; /// LC SAM Structure struct lc_sam_tag { /// SAM update instant for pending SAM switch (CLK[27:1]) uint32_t instant; /// Tsam interval in a pending SAM pattern (slots) uint16_t t_sam; /// Num tx slots in a pending SAM pattern (slots) uint16_t n_tx_slots; /// Num rx slots in a pending SAM pattern (slots) uint16_t n_rx_slots; /// active local Tsam interval (slots) uint16_t loc_t_sam_av; /// active remote Tsam interval (slots) uint16_t rem_t_sam_av; /// SAM remote type0 submap struct sam_type0_submap rem_submap; /// defined patterns from remote device struct lc_sam_pattern rem_pattern[SAM_INDEX_MAX]; /// Remote SAM index uint8_t rem_idx; /// local SAM index uint8_t loc_idx; /// local SAM index pending acceptance uint8_t loc_idx_wait_cfm; /// Tsam_sm submap interval in a pending SAM pattern (slots) uint8_t t_sam_sm; /// Local SAM tx availability (proportion of 255 max) uint8_t loc_tx_av; /// Local SAM rx availability (proportion of 255 max) uint8_t loc_rx_av; /// Remote SAM tx availability (proportion of 255 max) uint8_t rem_tx_av; /// Remote SAM tx availability (proportion of 255 max) uint8_t rem_rx_av; /// Remote type0 submap is available bool loc_submap0_av; /// SAM Patterns available bool loc_pattern_av[SAM_INDEX_MAX]; /// Remote type0 submap is available bool rem_submap0_av; /// SAM Patterns available bool rem_pattern_av[SAM_INDEX_MAX]; /// a configuration sequence of SAM maps is ongoing bool config_mode; }; /// LC environment structure struct lc_env_tag { /// link data structure struct lc_link_tag link; /// information data structure struct lc_info_tag info; /// encryption data structure struct lc_enc_tag enc; /// test mode data structure struct lc_test_mode_tag tst_mode; /// afh data structure struct lc_afh_tag afh; /// simple pairing data structure struct lc_simple_pairing_tag sp; /// encryption pause resume data structure struct lc_epr_tag epr; /// request data structure struct lc_req_tag req; /// local transaction details struct lc_local_trans_details_tag local_trans_details; #if (MAX_NB_SYNC > 0) /// Host parameters for SCO setup struct lc_sco_host_params_tag sco; #endif // (MAX_NB_SYNC > 0) #if PCA_SUPPORT /// Piconet clock adjust details struct lc_pca_tag pca; #endif // PCA_SUPPORT /// SAM configuration struct lc_sam_tag sam_info; }; /* * GLOBAL VARIABLE DEFINITION ***************************************************************************************** */ /// LC task descriptor extern const struct ke_task_desc TASK_DESC_LC; /// LC task message handlers table extern const struct ke_state_handler lc_default_handler; /// LC task state extern ke_state_t lc_state[LC_IDX_MAX]; /// LC environment variable extern struct lc_env_tag* lc_env[MAX_NB_ACTIVE_ACL]; /* * INLINE FUNCTION DECLARATIONS **************************************************************************************** */ /** **************************************************************************************** * @brief Convert a negotiated offset to a local offset for an activity * * @param[in] offset Offset negotiated at LMP (in half-slots) * @param[in] interval Interval of the activity (in half-slots) * @param[in] clk Local clock (in half-slots) * @param[in] clk_off Clock offset between local clock and master clock (in half-slots) * @param[in] init Initialization method (0: init 1 / 1: init 2), from timing control flags * * @return Offset of the local clock (in half-slots) **************************************************************************************** */ __INLINE uint16_t lc_offset_lmp_to_local(uint16_t offset, uint16_t interval, uint32_t clk, uint32_t clk_off, uint8_t init) { // Current master clock uint32_t master_clock = CLK_ADD_2(clk, clk_off); int32_t diff = offset - CO_MOD((master_clock ^ (init << 27)), interval); // Find an anchor point on local clock uint32_t anchor = CLK_ADD_2(clk, diff); // Derive the offset return (CO_MOD(anchor, interval)); } /** **************************************************************************************** * @brief Convert a local offset to a negotiated offset for an activity * * @param[in] offset Offset of the local clock (in half-slots) * @param[in] interval Interval of the activity (in half-slots) * @param[in] clk Local clock (in half-slots) * @param[in] clk_off Clock offset between local clock and master clock (in half-slots) * @param[in] init Initialization method (0: init 1 / 1: init 2), from timing control flags * * @return Offset negotiated at LMP (in half-slots) **************************************************************************************** */ __INLINE uint16_t lc_offset_local_to_lmp(uint16_t offset, uint16_t interval, uint32_t clk, uint32_t clk_off, uint8_t init) { // Find an anchor point on local clock int32_t diff = offset - CO_MOD(clk, interval); uint32_t anchor = CLK_ADD_2(clk, diff); // Anchor point on master clock uint32_t master_clock = CLK_ADD_2(anchor, clk_off); // Derive the LMP offset return (CO_MOD((master_clock ^ (init << 27)), interval)); } /* * FUNCTION DECLARATIONS **************************************************************************************** */ /** **************************************************************************************** * @brief This function sets the local transaction value * * @param[in] LinkId Linked identifier * @param[in] Opcode Opcode * @param[in] OpcodeExt Extended opcode * @param[in] Mode Mode **************************************************************************************** */ void lc_util_set_loc_trans_coll(uint8_t LinkId, uint8_t Opcode, uint8_t OpcodeExt, uint8_t Mode); /// Send HCI CS event void lc_cmd_stat_send(uint16_t opcode, uint8_t status); /** **************************************************************************************** * @brief Set new AFH map (master only) * * @param[in] pid process identifier. * @param[in] start True if AFH start | False otherwise **************************************************************************************** */ void lc_afh_set(ke_task_id_t pid, bool start); /** **************************************************************************************** * @brief Get the SAM interval on a link. * If both local and remote SAM maps are in operation, the larger interval is returned. * * @param[in] link_id Link identifier * * @return interval (slots) **************************************************************************************** */ uint16_t lc_sam_intv_get(uint8_t link_id); /** **************************************************************************************** * @brief Get the local SAM offset active on a link. * * @param[in] link_id Link identifier * * @return d_sam offset (slots) **************************************************************************************** */ uint16_t lc_sam_loc_offset_get(uint8_t link_id); /** **************************************************************************************** * @brief Get the remote SAM offset active on a link. * * @param[in] link_id Link identifier * * @return d_sam offset (slots) **************************************************************************************** */ uint16_t lc_sam_rem_offset_get(uint8_t link_id); /** **************************************************************************************** * @brief Gets an available slot from the SAM map within specified range. * The offsets refer to a period which is equal to or a multiple of the SAM interval. * If a suitable offset is not found, the lowest value of specified range is returned. * * @param[in] link_id Link identifier * @param[in] offset_min Lower bound of d_sam offsets to search (slots) * @param[in] offset_max Upper bound of d_sam offsets to search (slots) * * @return d_sam offset (slots) **************************************************************************************** */ uint16_t lc_sam_slot_av_get(uint8_t link_id, uint16_t offset_min, uint16_t offset_max); /** **************************************************************************************** * @brief Handle authentication completion. * * @param[in] pid process identifier. * @param[in] reason authentication process status. * **************************************************************************************** */ void lc_auth_cmp(ke_task_id_t pid, uint8_t reason); /** **************************************************************************************** * @brief Handle link key calculation. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_calc_link_key(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle change packet type continuation. * * @param[in] pid process identifier. * @param[in] status authentication process status. * **************************************************************************************** */ void lc_chg_pkt_type_cont(ke_task_id_t pid,uint8_t status); /** **************************************************************************************** * @brief Handle change of packet type complete. * * @param[in] pid process identifier. * @param[in] status change packet type status. * **************************************************************************************** */ void lc_chg_pkt_type_cmp(ke_task_id_t pid, uint8_t status); /** **************************************************************************************** * @brief Handle change of packet type retry. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_chg_pkt_type_retry(ke_task_id_t pid); /** **************************************************************************************** * @brief Start AFH on the link (master only). * * @param[in] pid process identifier. **************************************************************************************** */ void lc_afh_start(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle combination key server. * * @param[in] pid process identifier. * @param[in] key pointer to the unit key * **************************************************************************************** */ void lc_comb_key_svr(ke_task_id_t pid, struct ltk * key); /** **************************************************************************************** * @brief Handle connection completion. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_con_cmp(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle sending of connection complete event. * * @param[in] pid process identifier. * @param[in] status status * **************************************************************************************** */ void lc_con_cmp_evt_send(ke_task_id_t pid, uint8_t status); /** **************************************************************************************** * @brief Handle DHKey SP stage. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_dhkey(ke_task_id_t pid); /** **************************************************************************************** * @brief Process encryption key refresh request. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_enc_key_refresh(ke_task_id_t pid); /** **************************************************************************************** * @brief Check transaction collision. * * @param[in] pid process identifier. * @param[in] enc_mode encryption mode. * **************************************************************************************** */ void lc_end_chk_colli(ke_task_id_t pid, uint8_t enc_mode); /** **************************************************************************************** * @brief Handle encryption completion. * * @param[in] pid process identifier. * @param[in] reason reason * **************************************************************************************** */ void lc_enc_cmp(ke_task_id_t pid, uint8_t reason); /** **************************************************************************************** * @brief Handle encryption pause and resume completion. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_epr_cmp(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle encryption pause and resume on change connection link key. * * @param[in] pid process identifier. * @param[in] reason reason * **************************************************************************************** */ void lc_epr_change_lk(ke_task_id_t pid, uint8_t reason); /** **************************************************************************************** * @brief Handle encryption pause and resume as responder. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_epr_resp(ke_task_id_t pid); /** **************************************************************************************** * @brief Clean up phase for epr during role switch. * * @param[in] pid process identifier. * @param[in] status status * **************************************************************************************** */ void lc_rsw_done(ke_task_id_t pid, uint8_t status); /** **************************************************************************************** * @brief Handle successful encryption pause and resume during role switch * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_epr_rsw_cmp(ke_task_id_t pid, uint8_t status); /** **************************************************************************************** * @brief Initializes calculation of F3. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_init_calc_f3(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle start of mutual authentication for initiator. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_init_start_mutual_auth(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle passkey loop for initiator. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_init_passkey_loop(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle encryption pause and resume initiator side. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_initiator_epr(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle key exchange. * * @param[in] pid process identifier. * @param[in] reason reason * **************************************************************************************** */ void lc_key_exch_end(ke_task_id_t pid, uint8_t reason); /** **************************************************************************************** * @brief Handle legacy pairing - non-simple pairing * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_legacy_pair(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle local role switch processing. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_local_switch(ke_task_id_t pid); /** **************************************************************************************** * @brief Manage maximum packet slot. * * @param[in] pid process identifier. * @param[in] max_slot maximum slot * **************************************************************************************** */ void lc_max_slot_mgt(ke_task_id_t pid, uint8_t max_slot); /** **************************************************************************************** * @brief Handle mutual authentication last part. * * @param[in] pid process identifier. * @param[in] reason reason * **************************************************************************************** */ void lc_mutual_auth_end2(ke_task_id_t pid, uint8_t reason); /** **************************************************************************************** * @brief Handle mutual authentication first part. * * @param[in] pid process identifier. * @param[in] reason reason. * **************************************************************************************** */ void lc_mutual_auth_end(ke_task_id_t pid, uint8_t reason); /** **************************************************************************************** * @brief Handle master key process. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_mst_key(ke_task_id_t pid); /** **************************************************************************************** * @brief Function that sends master key to peer. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_mst_send_mst_key(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle master QOS. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_mst_qos_done(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle pairing procedure * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_pairing_cont(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle passkey. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_passkey_comm(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle packet type table request procedure. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_ptt(ke_task_id_t pid); /** **************************************************************************************** * @brief Completion of the packet type table request. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_ptt_cmp(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle quality of service setup. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_qos_setup(ke_task_id_t pid); /** **************************************************************************************** * @brief Read remote name processing. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_rd_rem_name(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle remote switch procedure. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_rem_switch(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle remote encryption procedure. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_rem_enc(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle remote name request processing. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_rem_name_cont(ke_task_id_t pid); /** **************************************************************************************** * @brief Compute signed responses and ACO * * @param[in] pid process identifier. **************************************************************************************** */ void lc_sec_auth_compute_sres(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle responder secure authentication * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_resp_sec_auth(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle responder authentication * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_resp_auth(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle responder oob wait nonce * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_resp_oob_wait_nonce(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle responder oob nonce. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_resp_oob_nonce(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle responder calculate F3. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_resp_calc_f3(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle connection release * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_release(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_restart_enc(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle restart of encryption procedure. * * @param[in] pid process identifier. * @param[in] reason reason * **************************************************************************************** */ void lc_restart_enc_cont(ke_task_id_t pid, uint8_t reason); /** **************************************************************************************** * @brief Handle restoration of link supervision time out. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_restore_to(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle role switch for devices that does not support EPR. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_rsw_non_epr_back(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle start of LMP time out. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_start_lmp_to(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle start of encryption. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_start_enc(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle start of encryption key size. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_start_enc_key_size(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle start of key exchange procedure. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_start_key_exch(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle start of pass key procedure. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_start_passkey(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle start of pass key loop procedure. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_start_passkey_loop(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle start of out-of-band procedure. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_start_oob(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle numerical comparison for responder. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_resp_num_comp(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle stop of adaptive frequency hopping reporting. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_stop_afh_reporting(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle restoration of adaptive frequency reporting. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_restore_afh_reporting(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle stop encryption procedure. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_stop_enc(ke_task_id_t pid); /** **************************************************************************************** * @brief Skip higher layer OOB request * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_skip_hl_oob_req(ke_task_id_t pid); /** **************************************************************************************** * @brief Send encryption mode request. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_send_enc_mode (ke_task_id_t pid); /** **************************************************************************************** * @brief Send semi-permanent key complete event. * * @param[in] pid process identifier. * @param[in] reason reason * **************************************************************************************** */ void lc_semi_key_cmp(ke_task_id_t pid, uint8_t reason); /** **************************************************************************************** * @brief Start detachment procedure. * * @param[in] reason reason. * @param[in] pid process identifier. **************************************************************************************** */ void lc_detach(ke_task_id_t pid, uint8_t reason); /** **************************************************************************************** * @brief Handle switch complete procedure. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_switch_cmp(ke_task_id_t pid, uint8_t status); /** **************************************************************************************** * @brief Handle simple pairing failure. * * @param[in] pid process identifier. * **************************************************************************************** */ void lc_sp_fail(ke_task_id_t pid); /** **************************************************************************************** * @brief Handle packet type check. * * @param[in] pid process identifier. * @param[in] idx index * **************************************************************************************** */ void lc_packet_type(ke_task_id_t pid, int idx); /** **************************************************************************************** * @brief Handle local authentication procedure. * * @param[in] pid process identifier. * @param[in] idx index instance * **************************************************************************************** */ void lc_loc_auth(ke_task_id_t pid, int idx); /** **************************************************************************************** * @brief Handle pairing procedure. * * @param[in] pid process identifier. * @param[in] idx index instance * **************************************************************************************** */ void lc_pair(ke_task_id_t pid, int idx); /** **************************************************************************************** * @brief Handle exchange of extended features. * * @param[in] pid process identifier. * @param[in] idx index instance * @param[in] page_nb page number * **************************************************************************************** */ void lc_ext_feat(ke_task_id_t pid, int idx, uint8_t page_nb); /** **************************************************************************************** * @brief Function to check the connection sequence. Ensure optional procedures * during connection establishment are executed before sending setup * complete to peer. * * @param[in] pid process identifier. * **************************************************************************************** */ bool lc_conn_seq_done(ke_task_id_t pid); /** **************************************************************************************** * @brief Send encryption change event indication. * * @param[in] idx Link identifier * @param[in] status status **************************************************************************************** */ void lc_send_enc_chg_evt(uint8_t idx, uint8_t status); void lc_version(ke_task_id_t pid, int idx); void lc_locepr_rsw(ke_task_id_t pid); void lc_locepr_lkref(ke_task_id_t pid); void lc_resp_pair(ke_task_id_t pid, int idx); void lc_feat(ke_task_id_t pid, int idx); void lc_hl_connect(ke_task_id_t pid, int idx); /** **************************************************************************************** * @brief This functions is used to free the buffer pointed to by the index. * * @param[in] link_id ACL Link Identifier * @param[in] reason Reason of the simple pairing end **************************************************************************************** */ void lc_sp_end(uint8_t link_id, uint8_t reason); /** **************************************************************************************** * @brief This function disables SAM if enabled on the specified link * * @param[in] link_id ACL Link Identifier **************************************************************************************** */ void lc_sam_disable(uint8_t link_id); /// @} LC #endif // LC_INT_H_