Lines Matching full:if
45 #if (BLETEST_THROUGHPUT_TEST == 1)
50 * 1) I think if we are initiating and we already have a connection with
53 * i) When a connection create is issued, if we already are connected
55 * ii) If we receive an advertisement while initiating and want to send
76 * 6) Use error code 0x3E correctly! Connection failed to establish. If you
77 * read the LE connection complete event, it says that if the connection
81 * 7) How does peer address get set if we are using whitelist? Look at filter
90 * I may extend a connection event too long although if it is always in terms
95 * response. Well, it should. If this packet will overrun the next scheduled
129 #if (MYNEWT_VAL(BLE_MAX_CONNECTIONS) >= 255)
221 #if (BLE_LL_BT5_PHY_SUPPORTED == 1)
223 * Checks to see if we should start a PHY update procedure
225 * If current phy is not one of the preferred we need to start control
228 * XXX: we could also decide to change the PHY if RSSI is really good
240 /* If no host preferences or */ in ble_ll_conn_chk_phy_upd_start()
241 if (((csm->phy_data.host_pref_tx_phys_mask == 0) && in ble_ll_conn_chk_phy_upd_start()
271 if (connsm->conn_itvl_usecs == 31) { in ble_ll_conn_calc_itvl_ticks()
296 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION)
298 * Called to determine if the received PDU is an empty PDU or not.
307 if ((llid == BLE_LL_LLID_DATA_FRAG) && (rxbuf[1] == 0)) { in ble_ll_conn_is_empty_pdu()
328 if ((int32_t)(s1->last_scheduled - s2->last_scheduled) < 0) { in ble_ll_conn_is_lru()
348 if (g_ble_ll_conn_cur_sm) { in ble_ll_conn_get_ce_end_time()
360 * -> Disable the wait for response timer, if running.
385 * NOTE: the connection state machine may be NULL if we are calling in ble_ll_conn_current_sm_over()
389 if (connsm) { in ble_ll_conn_current_sm_over()
407 if ((handle != 0) && (handle <= MYNEWT_VAL(BLE_MAX_CONNECTIONS))) { in ble_ll_conn_find_active_conn()
409 if (connsm->conn_state == BLE_LL_CONN_STATE_IDLE) { in ble_ll_conn_find_active_conn()
425 if (connsm) { in ble_ll_conn_sm_get()
455 if (time_since_last_anchor > 0) { in ble_ll_conn_calc_window_widening()
484 if (chanbyte) { in ble_ll_conn_calc_used_chans()
485 if (chanbyte == 0xff) { in ble_ll_conn_calc_used_chans()
490 if (chanbyte & mask) { in ble_ll_conn_calc_used_chans()
523 if (aa_low == aa_high) { in ble_ll_conn_calc_access_addr()
529 if ((temp == 0) || (temp == 0xFC00)) { in ble_ll_conn_calc_access_addr()
539 if (mask & temp) { in ble_ll_conn_calc_access_addr()
541 if (bits_diff > 1) { in ble_ll_conn_calc_access_addr()
546 if (bits_diff <= 1) { in ble_ll_conn_calc_access_addr()
558 if (mask & aa) { in ble_ll_conn_calc_access_addr()
559 if (prev_bit == 0) { in ble_ll_conn_calc_access_addr()
566 if (prev_bit == 0) { in ble_ll_conn_calc_access_addr()
574 if (prev_bit) { in ble_ll_conn_calc_access_addr()
579 if (mask == 0x00000100 && ones < 3) { in ble_ll_conn_calc_access_addr()
584 if (mask == 0x00010000 && transitions > 11) { in ble_ll_conn_calc_access_addr()
589 if (consecutive > 6) { in ble_ll_conn_calc_access_addr()
597 if (mask != 0x80000000) { in ble_ll_conn_calc_access_addr()
602 if (transitions > 24) { in ble_ll_conn_calc_access_addr()
628 if (usable_chans != 0) { in ble_ll_conn_remapped_channel()
631 if (usable_chans & mask) { in ble_ll_conn_remapped_channel()
632 if (cntr == remap_index) { in ble_ll_conn_remapped_channel()
648 #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2) == 1)
701 * If unmapped channel is the channel index of a used channel it is used in ble_ll_conn_calc_dci_csa2()
705 if (conn->chanmap[channel_unmapped >> 3] & bitpos) { in ble_ll_conn_calc_dci_csa2()
724 if (curchan > BLE_PHY_NUM_DATA_CHANS) { in ble_ll_conn_calc_dci_csa1()
733 if (conn->chanmap[curchan >> 3] & bitpos) { in ble_ll_conn_calc_dci_csa1()
757 #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2) == 1) in ble_ll_conn_calc_dci()
758 if (CONN_F_CSA2_SUPP(conn)) { in ble_ll_conn_calc_dci()
792 #if !MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_conn_reset_pending_aux_conn_rsp()
798 if (!connsm) { in ble_ll_conn_reset_pending_aux_conn_rsp()
802 if (CONN_F_AUX_CONN_REQ(connsm)) { in ble_ll_conn_reset_pending_aux_conn_rsp()
816 #if !MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_conn_init_pending_aux_conn_rsp()
822 if (!connsm) { in ble_ll_conn_init_pending_aux_conn_rsp()
832 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_conn_init_wfr_timer_exp()
837 if (!connsm) { in ble_ll_conn_init_wfr_timer_exp()
844 if (scansm && scansm->cur_aux_data) { in ble_ll_conn_init_wfr_timer_exp()
845 if (ble_ll_scan_aux_data_unref(scansm->cur_aux_data)) { in ble_ll_conn_init_wfr_timer_exp()
874 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION)
948 #if MYNEWT_VAL(BLE_LL_STRICT_CONN_SCHEDULING) in ble_ll_conn_get_next_sched_time()
956 /* NOTE: We dont care if this time is tick short. */ in ble_ll_conn_get_next_sched_time()
959 if ((connsm->anchor_point_usecs + connsm->conn_itvl_usecs) >= 31) { in ble_ll_conn_get_next_sched_time()
963 if (ble_ll_sched_next_time(&next_sched_time)) { in ble_ll_conn_get_next_sched_time()
964 if (CPUTIME_LT(next_sched_time, ce_end)) { in ble_ll_conn_get_next_sched_time()
974 * Called to check if certain connection state machine flags have been
984 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_chk_csm_flags()
985 if (connsm->csmflags.cfbit.send_ltk_req) { in ble_ll_conn_chk_csm_flags()
987 * Send Long term key request event to host. If masked, we need to in ble_ll_conn_chk_csm_flags()
990 if (ble_ll_hci_ev_ltk_req(connsm)) { in ble_ll_conn_chk_csm_flags()
1004 if (connsm->csmflags.cfbit.host_expects_upd_event) { in ble_ll_conn_chk_csm_flags()
1006 if (IS_PENDING_CTRL_PROC(connsm, BLE_LL_CTRL_PROC_CONN_UPDATE)) { in ble_ll_conn_chk_csm_flags()
1009 if (IS_PENDING_CTRL_PROC(connsm, BLE_LL_CTRL_PROC_CONN_PARAM_REQ)) { in ble_ll_conn_chk_csm_flags()
1018 /* Check if we need to send PHY update complete event */ in ble_ll_conn_chk_csm_flags()
1019 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_conn_chk_csm_flags()
1020 if (CONN_F_PHY_UPDATE_EVENT(connsm)) { in ble_ll_conn_chk_csm_flags()
1021 if (!ble_ll_hci_ev_phy_update(connsm, BLE_ERR_SUCCESS)) { in ble_ll_conn_chk_csm_flags()
1044 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_conn_adjust_pyld_len()
1047 if (connsm->phy_tx_transition != BLE_PHY_TRANSITION_INVALID) { in ble_ll_conn_adjust_pyld_len()
1064 if (ret > connsm->eff_max_tx_octets) { in ble_ll_conn_adjust_pyld_len()
1068 if (ret > phy_max_tx_octets) { in ble_ll_conn_adjust_pyld_len()
1103 * We need to check if we are retrying a pdu or if there is a pdu on in ble_ll_conn_tx_data_pdu()
1107 if (!connsm->cur_tx_pdu && !CONN_F_EMPTY_PDU_TXD(connsm) && !pkthdr) { in ble_ll_conn_tx_data_pdu()
1113 * If we dont have a pdu we have previously transmitted, take it off in ble_ll_conn_tx_data_pdu()
1117 if (!connsm->cur_tx_pdu && !CONN_F_EMPTY_PDU_TXD(connsm)) { in ble_ll_conn_tx_data_pdu()
1122 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_tx_data_pdu()
1124 * If we are encrypting, we are only allowed to send certain in ble_ll_conn_tx_data_pdu()
1125 * kinds of LL control PDU's. If none is enqueued, send empty pdu! in ble_ll_conn_tx_data_pdu()
1127 if (connsm->enc_data.enc_state > CONN_ENC_S_ENCRYPTED) { in ble_ll_conn_tx_data_pdu()
1128 if (!ble_ll_ctrl_enc_allowed_pdu_tx(pkthdr)) { in ble_ll_conn_tx_data_pdu()
1134 * We will allow a next packet if it itself is allowed or we are in ble_ll_conn_tx_data_pdu()
1139 if (nextpkthdr && !ble_ll_ctrl_enc_allowed_pdu_tx(nextpkthdr) in ble_ll_conn_tx_data_pdu()
1164 if (connsm->cur_tx_pdu) { in ble_ll_conn_tx_data_pdu()
1170 if (cur_offset == 0) { in ble_ll_conn_tx_data_pdu()
1173 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_tx_data_pdu()
1174 if (connsm->enc_data.enc_state > CONN_ENC_S_ENCRYPTED) { in ble_ll_conn_tx_data_pdu()
1175 /* We will allow a next packet if it itself is allowed */ in ble_ll_conn_tx_data_pdu()
1177 if (nextpkthdr && !ble_ll_ctrl_enc_allowed_pdu_tx(nextpkthdr) in ble_ll_conn_tx_data_pdu()
1188 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_tx_data_pdu()
1189 if (connsm->enc_data.enc_state > CONN_ENC_S_ENCRYPTED) { in ble_ll_conn_tx_data_pdu()
1190 /* We will allow a next packet if it itself is allowed */ in ble_ll_conn_tx_data_pdu()
1191 if (nextpkthdr && !ble_ll_ctrl_enc_allowed_pdu_tx(nextpkthdr)) { in ble_ll_conn_tx_data_pdu()
1200 * Set the more data data flag if we have more data to send and we in ble_ll_conn_tx_data_pdu()
1203 if ((nextpkthdr || ((cur_offset + cur_txlen) < pktlen)) && in ble_ll_conn_tx_data_pdu()
1209 limitations if we have started update */ in ble_ll_conn_tx_data_pdu()
1212 * Dont bother to set the MD bit if we cannot do the following: in ble_ll_conn_tx_data_pdu()
1223 if ((cur_offset + cur_txlen) < pktlen) { in ble_ll_conn_tx_data_pdu()
1226 if (nextpkthdr->omp_len > connsm->eff_max_tx_octets) { in ble_ll_conn_tx_data_pdu()
1236 * now. This is not the most accurate especially if we have in ble_ll_conn_tx_data_pdu()
1239 #if BLE_LL_BT5_PHY_SUPPORTED in ble_ll_conn_tx_data_pdu()
1249 if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { in ble_ll_conn_tx_data_pdu()
1254 if ((int32_t)((os_cputime_get32() + ticks) - next_event_time) < 0) { in ble_ll_conn_tx_data_pdu()
1259 /* If we send an empty PDU we need to initialize the header */ in ble_ll_conn_tx_data_pdu()
1261 if (CONN_F_EMPTY_PDU_TXD(connsm)) { in ble_ll_conn_tx_data_pdu()
1276 if (connsm->tx_seqnum) { in ble_ll_conn_tx_data_pdu()
1280 /* If we have more data, set the bit */ in ble_ll_conn_tx_data_pdu()
1281 if (md) { in ble_ll_conn_tx_data_pdu()
1286 if (connsm->next_exp_seqnum) { in ble_ll_conn_tx_data_pdu()
1294 * If we are a slave, check to see if this transmission will end the in ble_ll_conn_tx_data_pdu()
1295 * connection event. We will end the connection event if we have in ble_ll_conn_tx_data_pdu()
1299 * XXX: for a slave, we dont check to see if we can: in ble_ll_conn_tx_data_pdu()
1306 if ((connsm->csmflags.cfbit.terminate_ind_rxd) || in ble_ll_conn_tx_data_pdu()
1320 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_tx_data_pdu()
1326 if (llid == BLE_LL_LLID_CTRL) { in ble_ll_conn_tx_data_pdu()
1334 if (is_ctrl && (opcode == BLE_LL_CTRL_START_ENC_RSP)) { in ble_ll_conn_tx_data_pdu()
1345 } else if (is_ctrl && (opcode == BLE_LL_CTRL_START_ENC_REQ)) { in ble_ll_conn_tx_data_pdu()
1354 if (txend_func == NULL) { in ble_ll_conn_tx_data_pdu()
1359 } else if (is_ctrl && (opcode == BLE_LL_CTRL_PAUSE_ENC_RSP)) { in ble_ll_conn_tx_data_pdu()
1364 if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { in ble_ll_conn_tx_data_pdu()
1371 if (txend_func == NULL) { in ble_ll_conn_tx_data_pdu()
1383 /* If encrypted set packet counter */ in ble_ll_conn_tx_data_pdu()
1384 if (CONN_F_ENCRYPTED(connsm)) { in ble_ll_conn_tx_data_pdu()
1388 if (txend_func == NULL) { in ble_ll_conn_tx_data_pdu()
1395 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_conn_tx_data_pdu()
1402 if (!rc) { in ble_ll_conn_tx_data_pdu()
1412 if (CONN_F_EMPTY_PDU_TXD(connsm)) { in ble_ll_conn_tx_data_pdu()
1414 } else if ((hdr_byte & BLE_LL_DATA_HDR_LLID_MASK) == BLE_LL_LLID_CTRL) { in ble_ll_conn_tx_data_pdu()
1442 /* XXX: note that we can extend end time here if we want. Look at this */ in ble_ll_conn_event_start_cb()
1462 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) in ble_ll_conn_event_start_cb()
1466 if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { in ble_ll_conn_event_start_cb()
1470 if (!rc) { in ble_ll_conn_event_start_cb()
1471 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_event_start_cb()
1472 if (CONN_F_ENCRYPTED(connsm)) { in ble_ll_conn_event_start_cb()
1482 if (!rc) { in ble_ll_conn_event_start_cb()
1493 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_event_start_cb()
1494 if (CONN_F_ENCRYPTED(connsm)) { in ble_ll_conn_event_start_cb()
1504 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_conn_event_start_cb()
1512 if (rc) { in ble_ll_conn_event_start_cb()
1518 * Set flag that tells slave to set last anchor point if a packet in ble_ll_conn_event_start_cb()
1555 if (rc == BLE_LL_SCHED_STATE_DONE) { in ble_ll_conn_event_start_cb()
1568 * Called to determine if the device is allowed to send the next pdu in the
1569 * connection event. This will always return 'true' if we are a slave. If we
1595 #if BLE_LL_BT5_PHY_SUPPORTED in ble_ll_conn_can_send_next_pdu()
1602 if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { in ble_ll_conn_can_send_next_pdu()
1607 if (!txpdu) { in ble_ll_conn_can_send_next_pdu()
1609 if (pkthdr) { in ble_ll_conn_can_send_next_pdu()
1617 limitations if we have started update */ in ble_ll_conn_can_send_next_pdu()
1618 if (txpdu) { in ble_ll_conn_can_send_next_pdu()
1621 if (rem_bytes > connsm->eff_max_tx_octets) { in ble_ll_conn_can_send_next_pdu()
1633 if ((usecs + add_usecs) >= allowed_usecs) { in ble_ll_conn_can_send_next_pdu()
1641 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_PING)
1670 if (!connsm->csmflags.cfbit.pending_hci_rd_features || in ble_ll_conn_rd_features_timer_cb()
1747 /* Set own address type and peer address if needed */ in ble_ll_conn_master_init()
1749 if (hcc->filter_policy == 0) { in ble_ll_conn_master_init()
1758 if (hcc->min_ce_len > (connsm->conn_itvl * 2)) { in ble_ll_conn_master_init()
1764 if (hcc->max_ce_len > (connsm->conn_itvl * 2)) { in ble_ll_conn_master_init()
1788 #if (BLE_LL_BT5_PHY_SUPPORTED == 1)
1818 if (phy == BLE_PHY_CODED) { in ble_ll_conn_init_phy()
1841 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
1850 /* Set own address type and peer address if needed */ in ble_ll_conn_ext_master_init()
1852 if (hcc->filter_policy == 0) { in ble_ll_conn_ext_master_init()
1873 if (hcc_params->min_ce_len > (connsm->conn_itvl * 2)) { in ble_ll_conn_ext_set_params()
1879 if (hcc_params->max_ce_len > (connsm->conn_itvl * 2)) { in ble_ll_conn_ext_set_params()
1887 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_conn_ext_set_params()
1898 #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2) == 1) in ble_ll_conn_set_csa()
1899 if (chsel) { in ble_ll_conn_set_csa()
1945 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_conn_sm_new()
1963 * Set handle in connection update procedure to 0. If the handle in ble_ll_conn_sm_new()
1999 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_sm_new()
2004 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_PING) in ble_ll_conn_sm_new()
2044 /* See if effective times have changed */ in ble_ll_conn_datalen_update()
2046 if (eff_time != connsm->eff_max_rx_time) { in ble_ll_conn_datalen_update()
2051 if (eff_time != connsm->eff_max_tx_time) { in ble_ll_conn_datalen_update()
2058 if (eff_bytes != connsm->eff_max_rx_octets) { in ble_ll_conn_datalen_update()
2063 if (eff_bytes != connsm->eff_max_tx_octets) { in ble_ll_conn_datalen_update()
2068 if (send_event) { in ble_ll_conn_datalen_update()
2086 #if MYNEWT_VAL(BLE_LL_STRICT_CONN_SCHEDULING) in ble_ll_conn_end()
2096 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_PING) in ble_ll_conn_end()
2103 /* Free the current transmit pdu if there is one. */ in ble_ll_conn_end()
2104 if (connsm->cur_tx_pdu) { in ble_ll_conn_end()
2113 if (!pkthdr) { in ble_ll_conn_end()
2125 #if MYNEWT_VAL(BLE_LL_STRICT_CONN_SCHEDULING) in ble_ll_conn_end()
2139 * If we have features and there's pending HCI command, send an event before in ble_ll_conn_end()
2142 if (connsm->csmflags.cfbit.pending_hci_rd_features && in ble_ll_conn_end()
2149 * If there is still pending read features request HCI command, send an in ble_ll_conn_end()
2152 if (connsm->csmflags.cfbit.pending_hci_rd_features) { in ble_ll_conn_end()
2162 * If the ble error is "success" it means that the reset command was in ble_ll_conn_end()
2165 if (ble_err && (ble_err != BLE_ERR_UNK_CONN_ID || in ble_ll_conn_end()
2201 /* If unable to start terminate procedure, start it now */ in ble_ll_conn_next_event()
2202 if (connsm->disconnect_reason && !CONN_F_TERMINATE_STARTED(connsm)) { in ble_ll_conn_next_event()
2206 if (CONN_F_TERMINATE_STARTED(connsm) && (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE)) { in ble_ll_conn_next_event()
2215 * XXX: TODO Probably want to add checks to see if we need to start in ble_ll_conn_next_event()
2222 * latency if we are doing one of these updates as long as we in ble_ll_conn_next_event()
2229 if (connsm->csmflags.cfbit.allow_slave_latency && in ble_ll_conn_next_event()
2233 if (connsm->csmflags.cfbit.pkt_rxd) { in ble_ll_conn_next_event()
2241 /* We can use pre-calculated values for one interval if latency is 1. */ in ble_ll_conn_next_event()
2242 if (latency == 1) { in ble_ll_conn_next_event()
2251 if (connsm->anchor_point_usecs >= 31) { in ble_ll_conn_next_event()
2257 * If a connection update has been scheduled and the event counter in ble_ll_conn_next_event()
2262 if (connsm->csmflags.cfbit.conn_update_sched && in ble_ll_conn_next_event()
2267 if ((connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) || in ble_ll_conn_next_event()
2284 if (upd->winoffset != 0) { in ble_ll_conn_next_event()
2290 if (connsm->anchor_point_usecs >= 31) { in ble_ll_conn_next_event()
2304 * If there is a channel map request pending and we have reached the in ble_ll_conn_next_event()
2306 * If we received a channel map update with an instant equal to the event in ble_ll_conn_next_event()
2312 if (connsm->csmflags.cfbit.chanmap_update_scheduled && in ble_ll_conn_next_event()
2318 on slave side. Could ignore it or see if still enqueued. */ in ble_ll_conn_next_event()
2331 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_conn_next_event()
2332 if (CONN_F_PHY_UPDATE_SCHED(connsm) && in ble_ll_conn_next_event()
2336 if (connsm->phy_data.new_tx_phy) { in ble_ll_conn_next_event()
2343 if (connsm->phy_data.new_rx_phy) { in ble_ll_conn_next_event()
2362 * If we are trying to terminate connection, check if next wake time is in ble_ll_conn_next_event()
2363 * passed the termination timeout. If so, no need to continue with in ble_ll_conn_next_event()
2366 if (CONN_F_TERMINATE_STARTED(connsm)) { in ble_ll_conn_next_event()
2367 if ((int32_t)(connsm->terminate_timeout - connsm->anchor_point) <= 0) { in ble_ll_conn_next_event()
2374 * the transmit window if we still have one. in ble_ll_conn_next_event()
2376 #if MYNEWT_VAL(BLE_LL_STRICT_CONN_SCHEDULING) in ble_ll_conn_next_event()
2381 if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { in ble_ll_conn_next_event()
2384 if (cur_ww >= max_ww) { in ble_ll_conn_next_event()
2438 * Set first connection event time. If slave the endtime is the receive end in ble_ll_conn_created()
2443 if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { in ble_ll_conn_created()
2457 if (rxhdr->rxinfo.channel < BLE_PHY_NUM_DATA_CHANS) { in ble_ll_conn_created()
2476 if (connsm->anchor_point_usecs == 31) { in ble_ll_conn_created()
2483 #if MYNEWT_VAL(BLE_LL_STRICT_CONN_SCHEDULING) in ble_ll_conn_created()
2497 if (ble_ll_conn_next_event(connsm)) { in ble_ll_conn_created()
2506 if (rc) { in ble_ll_conn_created()
2507 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_conn_created()
2509 * If we have default phy preferences and they are different than in ble_ll_conn_created()
2513 * XXX: should we attempt to start this without knowing if in ble_ll_conn_created()
2516 if (!ble_ll_conn_chk_phy_upd_start(connsm)) { in ble_ll_conn_created()
2520 if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { in ble_ll_conn_created()
2525 #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2) == 1) in ble_ll_conn_created()
2535 * if it has some additional features to use. in ble_ll_conn_created()
2567 /* Check if we need to resume scanning */ in ble_ll_conn_event_end()
2574 /* If we have transmitted the terminate IND successfully, we are done */ in ble_ll_conn_event_end()
2575 if ((connsm->csmflags.cfbit.terminate_ind_txd) || in ble_ll_conn_event_end()
2577 if (connsm->csmflags.cfbit.terminate_ind_txd) { in ble_ll_conn_event_end()
2582 if (ble_err == 0) { in ble_ll_conn_event_end()
2594 * If we have received a packet, we can set the current transmit window in ble_ll_conn_event_end()
2597 if (connsm->csmflags.cfbit.pkt_rxd) { in ble_ll_conn_event_end()
2601 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_PING) in ble_ll_conn_event_end()
2603 * If we are encrypted and have passed the authenticated payload timeout in ble_ll_conn_event_end()
2617 if (ble_ll_conn_next_event(connsm)) { in ble_ll_conn_event_end()
2626 /* See if we need to start any control procedures */ in ble_ll_conn_event_end()
2636 if (ble_ll_conn_next_event(connsm)) { in ble_ll_conn_event_end()
2645 * end. If the next connection event is going to start past the supervision in ble_ll_conn_event_end()
2657 if (connsm->conn_state == BLE_LL_CONN_STATE_CREATED) { in ble_ll_conn_event_end()
2666 if ((int32_t)(connsm->anchor_point - connsm->last_rxd_pdu_cputime) >= tmo) { in ble_ll_conn_event_end()
2671 /* If we have completed packets, send an event */ in ble_ll_conn_event_end()
2674 /* If we have features and there's pending HCI command, send an event */ in ble_ll_conn_event_end()
2675 if (connsm->csmflags.cfbit.pending_hci_rd_features && in ble_ll_conn_event_end()
2705 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) in ble_ll_conn_req_pdu_update()
2717 if (addr_type) { in ble_ll_conn_req_pdu_update()
2724 if (inita) { in ble_ll_conn_req_pdu_update()
2726 if (inita_type) { in ble_ll_conn_req_pdu_update()
2732 if ((connsm->own_addr_type & 1) == 0) { in ble_ll_conn_req_pdu_update()
2740 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) in ble_ll_conn_req_pdu_update()
2741 if (connsm->own_addr_type > BLE_HCI_ADV_OWN_ADDR_RANDOM) { in ble_ll_conn_req_pdu_update()
2744 if (is_rpa) { in ble_ll_conn_req_pdu_update()
2745 if (rpa_index >= 0) { in ble_ll_conn_req_pdu_update()
2749 if (ble_ll_resolv_enabled()) { in ble_ll_conn_req_pdu_update()
2755 * If peer in on resolving list, we use RPA generated with Local IRK in ble_ll_conn_req_pdu_update()
2759 if (rl) { in ble_ll_conn_req_pdu_update()
2767 if (addr) { in ble_ll_conn_req_pdu_update()
2779 /* Returns true if the address matches the connection peer address having in
2788 #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) == 1) in ble_ll_conn_is_peer_adv()
2794 if (!connsm) { in ble_ll_conn_is_peer_adv()
2802 if (addr_type == connsm->peer_addr_type) { in ble_ll_conn_is_peer_adv()
2803 #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) == 1) in ble_ll_conn_is_peer_adv()
2807 * If the Host has added the peer device to the resolving list in ble_ll_conn_is_peer_adv()
2811 if (ble_ll_resolv_enabled()) { in ble_ll_conn_is_peer_adv()
2813 if (rl && (rl->rl_priv_mode == BLE_HCI_PRIVACY_NETWORK) && in ble_ll_conn_is_peer_adv()
2823 #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) == 1) in ble_ll_conn_is_peer_adv()
2824 /* Check if peer uses RPA. If so and it match, use it as controller in ble_ll_conn_is_peer_adv()
2827 if ((index < 0) || in ble_ll_conn_is_peer_adv()
2836 if ((index < 0) || in ble_ll_conn_is_peer_adv()
2843 if ((index < 0) || in ble_ll_conn_is_peer_adv()
2856 if (peer_addr) { in ble_ll_conn_is_peer_adv()
2857 if (!memcmp(peer_addr, connsm->peer_addr, BLE_DEV_ADDR_LEN)) { in ble_ll_conn_is_peer_adv()
2904 if (end_trans == BLE_PHY_TRANSITION_NONE) { in ble_ll_conn_request_send()
2915 * event. This generally should not happen, but if it does we stop the
2925 if (g_ble_ll_conn_cur_sm) { in ble_ll_conn_event_halt()
2945 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) in ble_ll_init_rx_pkt_in()
2953 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_pkt_in()
2958 * There shall be one more, if not something went very wrong in ble_ll_init_rx_pkt_in()
2960 if (aux_data && !ble_ll_scan_aux_data_unref(aux_data)) { in ble_ll_init_rx_pkt_in()
2968 if (!connsm) { in ble_ll_init_rx_pkt_in()
2972 if (!BLE_MBUF_HDR_CRC_OK(ble_hdr)) { in ble_ll_init_rx_pkt_in()
2976 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_pkt_in()
2977 if (BLE_MBUF_HDR_AUX_INVALID(ble_hdr)) { in ble_ll_init_rx_pkt_in()
2981 if (pdu_type == BLE_ADV_PDU_TYPE_ADV_EXT_IND) { in ble_ll_init_rx_pkt_in()
2982 if (BLE_MBUF_HDR_WAIT_AUX(ble_hdr)) { in ble_ll_init_rx_pkt_in()
2984 if (!ble_ll_sched_aux_scan(ble_hdr, connsm->scansm, aux_data)) { in ble_ll_init_rx_pkt_in()
2993 if (CONN_F_AUX_CONN_REQ(connsm)) { in ble_ll_init_rx_pkt_in()
2995 if (pdu_type != BLE_ADV_PDU_TYPE_AUX_CONNECT_RSP) { in ble_ll_init_rx_pkt_in()
3001 /* If we have sent a connect request, we need to enter CONNECTION state */ in ble_ll_init_rx_pkt_in()
3002 if (connsm && CONN_F_CONN_REQ_TXD(connsm)) { in ble_ll_init_rx_pkt_in()
3005 if (ble_ll_scan_adv_decode_addr(pdu_type, rxbuf, ble_hdr, in ble_ll_init_rx_pkt_in()
3012 if (ble_ll_scan_whitelist_enabled()) { in ble_ll_init_rx_pkt_in()
3014 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) in ble_ll_init_rx_pkt_in()
3016 * Did we resolve this address? If so, set correct peer address in ble_ll_init_rx_pkt_in()
3021 if (rpa_index >= 0) { in ble_ll_init_rx_pkt_in()
3035 if (connsm->rpa_index >= 0) { in ble_ll_init_rx_pkt_in()
3038 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) in ble_ll_init_rx_pkt_in()
3051 if (ble_hdr->rxinfo.channel < BLE_PHY_NUM_DATA_CHANS) { in ble_ll_init_rx_pkt_in()
3057 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_pkt_in()
3058 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_init_rx_pkt_in()
3069 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_pkt_in()
3094 if (!connsm) { in ble_ll_init_rx_isr_start()
3098 if ((pdu_type == BLE_ADV_PDU_TYPE_ADV_IND) || in ble_ll_init_rx_isr_start()
3104 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_start()
3105 if (pdu_type == BLE_ADV_PDU_TYPE_ADV_EXT_IND && in ble_ll_init_rx_isr_start()
3107 if (connsm->scansm->cur_aux_data) { in ble_ll_init_rx_isr_start()
3137 #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2) == 1) in ble_ll_conn_req_pdu_make()
3139 if (chan >= BLE_PHY_NUM_DATA_CHANS) { in ble_ll_conn_req_pdu_make()
3201 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) in ble_ll_init_rx_isr_end()
3204 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_end()
3210 /* Get connection state machine to use if connection to be established */ in ble_ll_init_rx_isr_end()
3217 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_end()
3219 if (scansm->cur_aux_data) { in ble_ll_init_rx_isr_end()
3222 if (ble_ll_scan_aux_data_unref(ble_hdr->rxinfo.user_data) == 0) { in ble_ll_init_rx_isr_end()
3229 if (!crcok) { in ble_ll_init_rx_isr_end()
3230 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_end()
3239 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_end()
3240 /* If we sent AUX_CONNECT_REQ, we only expect AUX_CONNECT_RSP here */ in ble_ll_init_rx_isr_end()
3241 if (CONN_F_AUX_CONN_REQ(connsm)) { in ble_ll_init_rx_isr_end()
3242 if (pdu_type != BLE_ADV_PDU_TYPE_AUX_CONNECT_RSP) { in ble_ll_init_rx_isr_end()
3254 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_end()
3255 if (pdu_type == BLE_ADV_PDU_TYPE_ADV_EXT_IND) { in ble_ll_init_rx_isr_end()
3256 if (!scansm) { in ble_ll_init_rx_isr_end()
3259 if (!scansm->ext_scanning) { in ble_ll_init_rx_isr_end()
3264 if (rc < 0) { in ble_ll_init_rx_isr_end()
3275 if (ble_ll_scan_adv_decode_addr(pdu_type, rxbuf, ble_hdr, in ble_ll_init_rx_isr_end()
3279 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_end()
3289 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_end()
3293 /* If this is not connectable adv mode, lets skip it */ in ble_ll_init_rx_isr_end()
3294 if (!(ext_adv_mode & BLE_LL_EXT_ADV_MODE_CONN)) { in ble_ll_init_rx_isr_end()
3298 if (!adv_addr) { in ble_ll_init_rx_isr_end()
3303 if (!init_addr) { in ble_ll_init_rx_isr_end()
3306 /* if there is direct address lets fall down and check it.*/ in ble_ll_init_rx_isr_end()
3311 if (!inita_is_rpa) { in ble_ll_init_rx_isr_end()
3313 /* Resolving will be done later. Check if identity InitA matches */ in ble_ll_init_rx_isr_end()
3314 if (!ble_ll_is_our_devaddr(init_addr, init_addr_type)) { in ble_ll_init_rx_isr_end()
3318 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) == 0 in ble_ll_init_rx_isr_end()
3320 /* If privacy is off - reject RPA InitA*/ in ble_ll_init_rx_isr_end()
3338 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) in ble_ll_init_rx_isr_end()
3339 if (ble_ll_is_rpa(adv_addr, addr_type) && ble_ll_resolv_enabled()) { in ble_ll_init_rx_isr_end()
3341 if (index >= 0) { in ble_ll_init_rx_isr_end()
3351 if ((rl->rl_priv_mode == BLE_HCI_PRIVACY_NETWORK) && in ble_ll_init_rx_isr_end()
3358 * If the InitA is a RPA, we must see if it resolves based on the in ble_ll_init_rx_isr_end()
3361 if (init_addr && inita_is_rpa && in ble_ll_init_rx_isr_end()
3368 if (chk_wl) { in ble_ll_init_rx_isr_end()
3373 if (init_addr && inita_is_rpa) { in ble_ll_init_rx_isr_end()
3377 } else if (init_addr) { in ble_ll_init_rx_isr_end()
3379 /* If resolving is off and InitA is RPA we reject advertising */ in ble_ll_init_rx_isr_end()
3380 if (inita_is_rpa && !ble_ll_resolv_enabled()) { in ble_ll_init_rx_isr_end()
3384 /* Let's see if we have IRK with that peer.*/ in ble_ll_init_rx_isr_end()
3390 if (rl && !inita_is_rpa && in ble_ll_init_rx_isr_end()
3397 * If the InitA is a RPA, we must see if it resolves based on the in ble_ll_init_rx_isr_end()
3400 if (inita_is_rpa) { in ble_ll_init_rx_isr_end()
3401 if (!rl || !ble_ll_resolv_rpa(init_addr, rl->rl_local_irk)) { in ble_ll_init_rx_isr_end()
3409 if (chk_wl) { in ble_ll_init_rx_isr_end()
3410 if (!ble_ll_whitelist_match(peer, peer_addr_type, resolved)) { in ble_ll_init_rx_isr_end()
3415 if (!ble_ll_conn_is_peer_adv(addr_type, adv_addr, index)) { in ble_ll_init_rx_isr_end()
3424 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_end()
3425 /* Check if we should send AUX_CONNECT_REQ and wait for AUX_CONNECT_RSP */ in ble_ll_init_rx_isr_end()
3426 if (ble_hdr->rxinfo.channel < BLE_PHY_NUM_DATA_CHANS) { in ble_ll_init_rx_isr_end()
3430 if (connsm->scansm->ext_scanning) { in ble_ll_init_rx_isr_end()
3446 if (ble_ll_sched_master_new(connsm, ble_hdr, pyld_len)) { in ble_ll_init_rx_isr_end()
3456 if (rc) { in ble_ll_init_rx_isr_end()
3461 if (init_addr && !inita_is_rpa) { in ble_ll_init_rx_isr_end()
3467 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_end()
3468 if (ble_hdr->rxinfo.channel < BLE_PHY_NUM_DATA_CHANS) { in ble_ll_init_rx_isr_end()
3482 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) in ble_ll_init_rx_isr_end()
3483 if (ble_hdr->rxinfo.user_data) { in ble_ll_init_rx_isr_end()
3488 * We have to restart receive if we cant hand up pdu. We return 0 so that in ble_ll_init_rx_isr_end()
3492 if (rxpdu == NULL) { in ble_ll_init_rx_isr_end()
3495 * I cannot say I like this solution, but if we cannot allocate a PDU in ble_ll_init_rx_isr_end()
3500 if (CONN_F_CONN_REQ_TXD(connsm) == 1) { in ble_ll_init_rx_isr_end()
3512 if (rc) { in ble_ll_init_rx_isr_end()
3537 if (g_ble_ll_conn_cur_sm == connsm) { in ble_ll_conn_timeout()
3543 /* Check if we need to resume scanning */ in ble_ll_conn_timeout()
3544 if (was_current) { in ble_ll_conn_timeout()
3567 * care if this is the response we were waiting for or not; the code in ble_ll_conn_rx_isr_start()
3569 * if needed in ble_ll_conn_rx_isr_start()
3573 if (connsm) { in ble_ll_conn_rx_isr_start()
3575 if (aa != connsm->access_addr) { in ble_ll_conn_rx_isr_start()
3592 /* Set anchor point (and last) if 1st rxd frame in connection event */ in ble_ll_conn_rx_isr_start()
3593 if (connsm->csmflags.cfbit.slave_set_last_anchor) { in ble_ll_conn_rx_isr_start()
3622 if (BLE_MBUF_HDR_CRC_OK(hdr)) { in ble_ll_conn_rx_data_pdu()
3627 if (connsm) { in ble_ll_conn_rx_data_pdu()
3641 if ((llid == 0) || in ble_ll_conn_rx_data_pdu()
3647 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_rx_data_pdu()
3648 /* Check if PDU is allowed when encryption is started. If not, in ble_ll_conn_rx_data_pdu()
3653 if ((connsm->enc_data.enc_state > CONN_ENC_S_PAUSE_ENC_RSP_WAIT) && in ble_ll_conn_rx_data_pdu()
3660 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_PING) in ble_ll_conn_rx_data_pdu()
3662 * Reset authenticated payload timeout if valid MIC. NOTE: we dont in ble_ll_conn_rx_data_pdu()
3666 if ((connsm->enc_data.enc_state == CONN_ENC_S_ENCRYPTED) && in ble_ll_conn_rx_data_pdu()
3676 * If we are a slave, we can only start to use slave latency in ble_ll_conn_rx_data_pdu()
3679 if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { in ble_ll_conn_rx_data_pdu()
3680 if (hdr_byte & BLE_LL_DATA_HDR_NESN_MASK) { in ble_ll_conn_rx_data_pdu()
3686 * Discard the received PDU if the sequence number is the same in ble_ll_conn_rx_data_pdu()
3690 if (rxd_sn != connsm->last_rxd_sn) { in ble_ll_conn_rx_data_pdu()
3694 /* No need to do anything if empty pdu */ in ble_ll_conn_rx_data_pdu()
3695 if ((llid == BLE_LL_LLID_DATA_FRAG) && (acl_len == 0)) { in ble_ll_conn_rx_data_pdu()
3699 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_rx_data_pdu()
3701 * XXX: should we check to see if we are in a state where we in ble_ll_conn_rx_data_pdu()
3704 if (BLE_MBUF_HDR_MIC_FAILURE(hdr)) { in ble_ll_conn_rx_data_pdu()
3711 if (llid == BLE_LL_LLID_CTRL) { in ble_ll_conn_rx_data_pdu()
3714 if (ble_ll_ctrl_rx_pdu(connsm, rxpdu)) { in ble_ll_conn_rx_data_pdu()
3789 * now is that we should not ack the packet if we have no receive in ble_ll_conn_rx_isr_end()
3790 * buffers available. We want to free up our transmit PDU if it was in ble_ll_conn_rx_isr_end()
3791 * acked, but we should not ack the received frame if we cant hand it up. in ble_ll_conn_rx_isr_end()
3797 * We should have a current connection state machine. If we dont, we just in ble_ll_conn_rx_isr_end()
3802 if (!connsm) { in ble_ll_conn_rx_isr_end()
3813 #if BLE_LL_BT5_PHY_SUPPORTED in ble_ll_conn_rx_isr_end()
3822 * Check the packet CRC. A connection event can continue even if the in ble_ll_conn_rx_isr_end()
3823 * received PDU does not pass the CRC check. If we receive two consecutive in ble_ll_conn_rx_isr_end()
3826 if (!BLE_MBUF_HDR_CRC_OK(rxhdr)) { in ble_ll_conn_rx_isr_end()
3828 * Increment # of consecutively received CRC errors. If more than in ble_ll_conn_rx_isr_end()
3832 if (connsm->cons_rxd_bad_crc >= 2) { in ble_ll_conn_rx_isr_end()
3835 if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { in ble_ll_conn_rx_isr_end()
3853 * LLID. This should really never happen but if it does we will just in ble_ll_conn_rx_isr_end()
3856 if ((hdr_byte & BLE_LL_DATA_HDR_LLID_MASK) == 0) { in ble_ll_conn_rx_isr_end()
3864 if ((hdr_byte & BLE_LL_DATA_HDR_LLID_MASK) == BLE_LL_LLID_CTRL) { in ble_ll_conn_rx_isr_end()
3870 * If SN bit from header does not match NESN in connection, this is in ble_ll_conn_rx_isr_end()
3875 if (rxpdu && ((hdr_sn && conn_nesn) || (!hdr_sn && !conn_nesn))) { in ble_ll_conn_rx_isr_end()
3877 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_rx_isr_end()
3878 if (CONN_F_ENCRYPTED(connsm) && !ble_ll_conn_is_empty_pdu(rxbuf)) { in ble_ll_conn_rx_isr_end()
3888 * Check NESN bit from header. If same as tx seq num, the transmission in ble_ll_conn_rx_isr_end()
3891 if (CONN_F_EMPTY_PDU_TXD(connsm) || connsm->cur_tx_pdu) { in ble_ll_conn_rx_isr_end()
3894 if ((hdr_nesn && conn_sn) || (!hdr_nesn && !conn_sn)) { in ble_ll_conn_rx_isr_end()
3902 /* If we transmitted the empty pdu, clear flag */ in ble_ll_conn_rx_isr_end()
3903 if (CONN_F_EMPTY_PDU_TXD(connsm)) { in ble_ll_conn_rx_isr_end()
3909 * Determine if we should remove packet from queue or if there in ble_ll_conn_rx_isr_end()
3913 if (txpdu) { in ble_ll_conn_rx_isr_end()
3914 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_rx_isr_end()
3915 if (connsm->enc_data.tx_encrypted) { in ble_ll_conn_rx_isr_end()
3920 if ((txhdr->txinfo.hdr_byte & BLE_LL_DATA_HDR_LLID_MASK) in ble_ll_conn_rx_isr_end()
3925 if (rc) { in ble_ll_conn_rx_isr_end()
3935 if (txhdr->txinfo.offset >= OS_MBUF_PKTLEN(txpdu)) { in ble_ll_conn_rx_isr_end()
3936 /* If l2cap pdu, increment # of completed packets */ in ble_ll_conn_rx_isr_end()
3937 if (txhdr->txinfo.pyld_len != 0) { in ble_ll_conn_rx_isr_end()
3938 #if (BLETEST_THROUGHPUT_TEST == 1) in ble_ll_conn_rx_isr_end()
3942 if (connsm->completed_pkts > 2) { in ble_ll_conn_rx_isr_end()
3953 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_conn_rx_isr_end()
3954 if (is_ctrl && (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) in ble_ll_conn_rx_isr_end()
3968 /* If this is a TERMINATE_IND, we have to reply */ in ble_ll_conn_rx_isr_end()
3970 /* If we received a terminate IND, we must set some flags */ in ble_ll_conn_rx_isr_end()
3971 if (is_ctrl && (opcode == BLE_LL_CTRL_TERMINATE_IND) in ble_ll_conn_rx_isr_end()
3977 if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { in ble_ll_conn_rx_isr_end()
3982 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_rx_isr_end()
3983 if (is_ctrl && (opcode == BLE_LL_CTRL_PAUSE_ENC_RSP)) { in ble_ll_conn_rx_isr_end()
3990 /* If reply flag set, send data pdu and continue connection event */ in ble_ll_conn_rx_isr_end()
3992 if (rx_pyld_len && CONN_F_ENCRYPTED(connsm)) { in ble_ll_conn_rx_isr_end()
3995 if (reply && ble_ll_conn_can_send_next_pdu(connsm, begtime, add_usecs)) { in ble_ll_conn_rx_isr_end()
4001 if (rxpdu) { in ble_ll_conn_rx_isr_end()
4006 /* Send link layer a connection end event if over */ in ble_ll_conn_rx_isr_end()
4007 if (rc) { in ble_ll_conn_rx_isr_end()
4037 /* Set mbuf length and packet length if a control PDU */ in ble_ll_conn_enqueue_pkt()
4038 if (hdr_byte == BLE_LL_LLID_CTRL) { in ble_ll_conn_enqueue_pkt()
4055 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) in ble_ll_conn_enqueue_pkt()
4056 if (connsm->enc_data.enc_state > CONN_ENC_S_ENCRYPTED) { in ble_ll_conn_enqueue_pkt()
4060 * If this is one of the following types we need to insert it at in ble_ll_conn_enqueue_pkt()
4064 if (llid == BLE_LL_LLID_CTRL) { in ble_ll_conn_enqueue_pkt()
4074 if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { in ble_ll_conn_enqueue_pkt()
4080 /* If encryption has been paused, we don't want to send any packets from the in ble_ll_conn_enqueue_pkt()
4083 if (connsm->enc_data.enc_state == CONN_ENC_S_PAUSED) { in ble_ll_conn_enqueue_pkt()
4097 if (lifo) { in ble_ll_conn_enqueue_pkt()
4124 /* See if we have an active matching connection handle */ in ble_ll_conn_tx_pkt_in()
4127 if (connsm) { in ble_ll_conn_tx_pkt_in()
4130 if (pb == 0) { in ble_ll_conn_tx_pkt_in()
4160 /* Do nothing if same channel map */ in ble_ll_conn_set_global_chanmap()
4162 if (!memcmp(conn_params->master_chan_map, chanmap, BLE_LL_CONN_CHMAP_LEN)) { in ble_ll_conn_set_global_chanmap()
4172 if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { in ble_ll_conn_set_global_chanmap()
4202 /* Ignore the connection request if we are already connected*/ in ble_ll_conn_slave_start()
4205 if (!memcmp(&connsm->peer_addr, inita, BLE_DEV_ADDR_LEN)) { in ble_ll_conn_slave_start()
4206 if (rxbuf[0] & BLE_ADV_PDU_HDR_TXADD_MASK) { in ble_ll_conn_slave_start()
4207 if (connsm->peer_addr_type & 1) { in ble_ll_conn_slave_start()
4211 if ((connsm->peer_addr_type & 1) == 0) { in ble_ll_conn_slave_start()
4218 /* Allocate a connection. If none available, dont do anything */ in ble_ll_conn_slave_start()
4220 if (connsm == NULL) { in ble_ll_conn_slave_start()
4243 if ((connsm->tx_win_off > connsm->conn_itvl) || in ble_ll_conn_slave_start()
4254 if ((connsm->supervision_tmo * 10000) <= temp ) { in ble_ll_conn_slave_start()
4263 if (temp > 8) { in ble_ll_conn_slave_start()
4266 if (connsm->tx_win_size > temp) { in ble_ll_conn_slave_start()
4276 if (connsm->num_used_chans < 2) { in ble_ll_conn_slave_start()
4284 #if (BLE_LL_BT5_PHY_SUPPORTED == 1) in ble_ll_conn_slave_start()
4295 if (!rc) { in ble_ll_conn_slave_start()
4329 /* Kill the current one first (if one is running) */ in ble_ll_conn_module_reset()
4330 if (g_ble_ll_conn_cur_sm) { in ble_ll_conn_module_reset()
4336 /* Free the global connection complete event if there is one */ in ble_ll_conn_module_reset()
4337 if (g_ble_ll_conn_comp_ev) { in ble_ll_conn_module_reset()
4348 if (!connsm) { in ble_ll_conn_module_reset()
4362 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CODED_PHY) in ble_ll_conn_module_reset()
4370 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CODED_PHY) in ble_ll_conn_module_reset()