diff --git a/nimble/controller/include/controller/ble_ll.h b/nimble/controller/include/controller/ble_ll.h index dfda8cfeb..898907a19 100644 --- a/nimble/controller/include/controller/ble_ll.h +++ b/nimble/controller/include/controller/ble_ll.h @@ -108,11 +108,13 @@ struct ble_ll_obj /* Current Link Layer state */ uint8_t ll_state; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) /* Number of ACL data packets supported */ uint8_t ll_num_acl_pkts; /* ACL data packet size */ uint16_t ll_acl_pkt_size; +#endif /* Preferred PHY's */ uint8_t ll_pref_tx_phys; @@ -129,14 +131,18 @@ struct ble_ll_obj struct ble_ll_pkt_q ll_rx_pkt_q; /* Packet transmit queue */ +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) struct ble_npl_event ll_tx_pkt_ev; +#endif struct ble_ll_pkt_q ll_tx_pkt_q; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) /* Data buffer overflow event */ struct ble_npl_event ll_dbuf_overflow_ev; /* Number of completed packets event */ struct ble_npl_event ll_comp_pkt_ev; +#endif /* HW error callout */ struct ble_npl_callout ll_hw_err_timer; @@ -214,12 +220,24 @@ extern STATS_SECT_DECL(ble_ll_stats) ble_ll_stats; /* States */ #define BLE_LL_STATE_STANDBY (0) +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) #define BLE_LL_STATE_ADV (1) +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) #define BLE_LL_STATE_SCANNING (2) +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_LL_STATE_CONNECTION (4) +#endif +#if MYNEWT_VAL(BLE_LL_DTM) #define BLE_LL_STATE_DTM (5) +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) && MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) #define BLE_LL_STATE_SYNC (6) +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) && MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) #define BLE_LL_STATE_SCAN_AUX (7) +#endif /* LL Features */ #define BLE_LL_FEAT_LE_ENCRYPTION (0x0000000001) diff --git a/nimble/controller/include/controller/ble_ll_conn.h b/nimble/controller/include/controller/ble_ll_conn.h index 7128dcb96..c3073c6e7 100644 --- a/nimble/controller/include/controller/ble_ll_conn.h +++ b/nimble/controller/include/controller/ble_ll_conn.h @@ -34,8 +34,13 @@ extern "C" { /* Roles */ #define BLE_LL_CONN_ROLE_NONE (0) + +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_LL_CONN_ROLE_MASTER (1) +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) #define BLE_LL_CONN_ROLE_SLAVE (2) +#endif /* Connection states */ #define BLE_LL_CONN_STATE_IDLE (0) @@ -370,8 +375,17 @@ struct ble_ll_conn_sm #define CONN_F_AUX_CONN_REQ(csm) ((csm)->csmflags.cfbit.aux_conn_req) /* Role */ +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define CONN_IS_MASTER(csm) (csm->conn_role == BLE_LL_CONN_ROLE_MASTER) +#else +#define CONN_IS_MASTER(csm) (false) +#endif + +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) #define CONN_IS_SLAVE(csm) (csm->conn_role == BLE_LL_CONN_ROLE_SLAVE) +#else +#define CONN_IS_SLAVE(csm) (false) +#endif /* * Given a handle, returns an active connection state machine (or NULL if the diff --git a/nimble/controller/include/controller/ble_ll_scan.h b/nimble/controller/include/controller/ble_ll_scan.h index 77f9fa426..a44e43137 100644 --- a/nimble/controller/include/controller/ble_ll_scan.h +++ b/nimble/controller/include/controller/ble_ll_scan.h @@ -152,14 +152,18 @@ struct ble_ll_scan_sm struct ble_ll_scan_phy *scanp_next; struct ble_ll_scan_phy scan_phys[BLE_LL_SCAN_PHY_NUMBER]; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) /* Connection sm for initiator scan */ struct ble_ll_conn_sm *connsm; +#endif }; /* Scan types */ #define BLE_SCAN_TYPE_PASSIVE (BLE_HCI_SCAN_TYPE_PASSIVE) #define BLE_SCAN_TYPE_ACTIVE (BLE_HCI_SCAN_TYPE_ACTIVE) +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_SCAN_TYPE_INITIATE (2) +#endif /*---- HCI ----*/ /* Set scanning parameters */ @@ -219,7 +223,11 @@ uint8_t *ble_ll_scan_get_local_rpa(void); void ble_ll_scan_sm_stop(int chk_disable); /* Resume scanning */ +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) void ble_ll_scan_chk_resume(void); +#else +static inline void ble_ll_scan_chk_resume(void) { }; +#endif /* Called when wait for response timer expires in scanning mode */ void ble_ll_scan_wfr_timer_exp(void); diff --git a/nimble/controller/src/ble_ll.c b/nimble/controller/src/ble_ll.c index b5a527abb..0560b61da 100644 --- a/nimble/controller/src/ble_ll.c +++ b/nimble/controller/src/ble_ll.c @@ -226,8 +226,10 @@ STATS_NAME_START(ble_ll_stats) STATS_NAME_END(ble_ll_stats) static void ble_ll_event_rx_pkt(struct ble_npl_event *ev); +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) static void ble_ll_event_tx_pkt(struct ble_npl_event *ev); static void ble_ll_event_dbuf_overflow(struct ble_npl_event *ev); +#endif #if MYNEWT @@ -579,10 +581,23 @@ ble_ll_set_random_addr(const uint8_t *cmdbuf, uint8_t len, bool hci_adv_ext) * Test specification extends this also to initiating. */ - if (g_ble_ll_conn_create_sm.connsm || ble_ll_scan_enabled() || - (!hci_adv_ext && ble_ll_adv_enabled())) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + if (g_ble_ll_conn_create_sm.connsm) { return BLE_ERR_CMD_DISALLOWED; } +#endif + +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) + if (ble_ll_scan_enabled()){ + return BLE_ERR_CMD_DISALLOWED; + } +#endif + +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) + if (!hci_adv_ext && ble_ll_adv_enabled()) { + return BLE_ERR_CMD_DISALLOWED; + } +#endif if (!ble_ll_is_valid_random_addr(cmd->addr)) { return BLE_ERR_INV_HCI_CMD_PARMS; @@ -591,12 +606,14 @@ ble_ll_set_random_addr(const uint8_t *cmdbuf, uint8_t len, bool hci_adv_ext) memcpy(g_random_addr, cmd->addr, BLE_DEV_ADDR_LEN); #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) /* For instance 0 we need same address if legacy advertising might be * used. If extended advertising is in use than this command doesn't * affect instance 0. */ if (!hci_adv_ext) ble_ll_adv_set_random_addr(cmd->addr, 0); +#endif #endif return BLE_ERR_SUCCESS; @@ -670,18 +687,23 @@ ble_ll_wfr_timer_exp(void *arg) /* If we have started a reception, there is nothing to do here */ if (!rx_start) { switch (lls) { +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) case BLE_LL_STATE_ADV: ble_ll_adv_wfr_timer_exp(); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_LL_STATE_CONNECTION: ble_ll_conn_wfr_timer_exp(); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) case BLE_LL_STATE_SCANNING: ble_ll_scan_wfr_timer_exp(); break; -#if MYNEWT_VAL(BLE_LL_DTM) - case BLE_LL_STATE_DTM: - ble_ll_dtm_wfr_timer_exp(); +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) + case BLE_LL_STATE_SCAN_AUX: + ble_ll_scan_aux_wfr_timer_exp(); break; #endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) @@ -689,9 +711,10 @@ ble_ll_wfr_timer_exp(void *arg) ble_ll_sync_wfr_timer_exp(); break; #endif -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) - case BLE_LL_STATE_SCAN_AUX: - ble_ll_scan_aux_wfr_timer_exp(); +#endif +#if MYNEWT_VAL(BLE_LL_DTM) + case BLE_LL_STATE_DTM: + ble_ll_dtm_wfr_timer_exp(); break; #endif default: @@ -708,6 +731,7 @@ ble_ll_wfr_timer_exp(void *arg) * Context: Link layer task * */ +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) static void ble_ll_tx_pkt_in(void) { @@ -747,6 +771,7 @@ ble_ll_tx_pkt_in(void) ble_ll_conn_tx_pkt_in(om, handle, length); } } +#endif /** * Count Link Layer statistics for received PDUs @@ -763,7 +788,12 @@ ble_ll_count_rx_stats(struct ble_mbuf_hdr *hdr, uint16_t len, uint8_t pdu_type) bool connection_data; crcok = BLE_MBUF_HDR_CRC_OK(hdr); + +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) connection_data = (BLE_MBUF_HDR_RX_STATE(hdr) == BLE_LL_STATE_CONNECTION); +#else + connection_data = false; +#endif #if MYNEWT_VAL(BLE_LL_DTM) /* Reuse connection stats for DTM */ @@ -830,22 +860,22 @@ ble_ll_rx_pkt_in(void) /* Process the data or advertising pdu */ /* Process the PDU */ switch (BLE_MBUF_HDR_RX_STATE(ble_hdr)) { +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_LL_STATE_CONNECTION: ble_ll_conn_rx_data_pdu(m, ble_hdr); /* m is going to be free by function above */ m = NULL; break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) case BLE_LL_STATE_ADV: ble_ll_adv_rx_pkt_in(pdu_type, rxbuf, ble_hdr); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) case BLE_LL_STATE_SCANNING: ble_ll_scan_rx_pkt_in(pdu_type, m, ble_hdr); break; -#if MYNEWT_VAL(BLE_LL_DTM) - case BLE_LL_STATE_DTM: - ble_ll_dtm_rx_pkt_in(m, ble_hdr); - break; -#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) case BLE_LL_STATE_SYNC: ble_ll_sync_rx_pkt_in(m, ble_hdr); @@ -855,6 +885,12 @@ ble_ll_rx_pkt_in(void) case BLE_LL_STATE_SCAN_AUX: ble_ll_scan_aux_rx_pkt_in(m, ble_hdr); break; +#endif +#endif +#if MYNEWT_VAL(BLE_LL_DTM) + case BLE_LL_STATE_DTM: + ble_ll_dtm_rx_pkt_in(m, ble_hdr); + break; #endif default: /* Any other state should never occur */ @@ -883,6 +919,7 @@ ble_ll_rx_pdu_in(struct os_mbuf *rxpdu) ble_npl_eventq_put(&g_ble_ll_data.ll_evq, &g_ble_ll_data.ll_rx_pkt_ev); } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) /** * Called to put a packet on the Link Layer transmit packet queue. * @@ -913,6 +950,7 @@ ble_ll_data_buffer_overflow(void) { ble_npl_eventq_put(&g_ble_ll_data.ll_evq, &g_ble_ll_data.ll_dbuf_overflow_ev); } +#endif /** * Called when a HW error occurs. @@ -970,20 +1008,20 @@ ble_ll_rx_start(uint8_t *rxbuf, uint8_t chan, struct ble_mbuf_hdr *rxhdr) pdu_type); switch (g_ble_ll_data.ll_state) { +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_LL_STATE_CONNECTION: rc = ble_ll_conn_rx_isr_start(rxhdr, ble_phy_access_addr_get()); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTERL) case BLE_LL_STATE_ADV: rc = ble_ll_adv_rx_isr_start(pdu_type); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) case BLE_LL_STATE_SCANNING: rc = ble_ll_scan_rx_isr_start(pdu_type, &rxhdr->rxinfo.flags); break; -#if MYNEWT_VAL(BLE_LL_DTM) - case BLE_LL_STATE_DTM: - rc = ble_ll_dtm_rx_isr_start(rxhdr, ble_phy_access_addr_get()); - break; -#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) case BLE_LL_STATE_SYNC: rc = ble_ll_sync_rx_isr_start(pdu_type, rxhdr); @@ -993,6 +1031,12 @@ ble_ll_rx_start(uint8_t *rxbuf, uint8_t chan, struct ble_mbuf_hdr *rxhdr) case BLE_LL_STATE_SCAN_AUX: rc = ble_ll_scan_aux_rx_isr_start(pdu_type, rxhdr); break; +#endif +#endif +#if MYNEWT_VAL(BLE_LL_DTM) + case BLE_LL_STATE_DTM: + rc = ble_ll_dtm_rx_isr_start(rxhdr, ble_phy_access_addr_get()); + break; #endif default: /* Should not be in this state! */ @@ -1044,12 +1088,14 @@ ble_ll_rx_end(uint8_t *rxbuf, struct ble_mbuf_hdr *rxhdr) } #endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (BLE_MBUF_HDR_RX_STATE(rxhdr) == BLE_LL_STATE_CONNECTION) { rc = ble_ll_conn_rx_isr_end(rxbuf, rxhdr); return rc; } +#endif -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) && MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) if (BLE_MBUF_HDR_RX_STATE(rxhdr) == BLE_LL_STATE_SYNC) { rc = ble_ll_sync_rx_isr_end(rxbuf, rxhdr); return rc; @@ -1097,6 +1143,7 @@ ble_ll_rx_end(uint8_t *rxbuf, struct ble_mbuf_hdr *rxhdr) /* Hand packet to the appropriate state machine (if crc ok) */ rxpdu = NULL; switch (BLE_MBUF_HDR_RX_STATE(rxhdr)) { +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) case BLE_LL_STATE_ADV: if (!badpkt) { rxpdu = ble_ll_rxpdu_alloc(len + BLE_LL_PDU_HDR_LEN); @@ -1106,6 +1153,8 @@ ble_ll_rx_end(uint8_t *rxbuf, struct ble_mbuf_hdr *rxhdr) } rc = ble_ll_adv_rx_isr_end(pdu_type, rxpdu, crcok); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) case BLE_LL_STATE_SCANNING: if (!badpkt) { rxpdu = ble_ll_rxpdu_alloc(len + BLE_LL_PDU_HDR_LEN); @@ -1125,6 +1174,7 @@ ble_ll_rx_end(uint8_t *rxbuf, struct ble_mbuf_hdr *rxhdr) } rc = ble_ll_scan_aux_rx_isr_end(rxpdu, crcok); break; +#endif #endif default: rc = -1; @@ -1181,6 +1231,7 @@ ble_ll_event_rx_pkt(struct ble_npl_event *ev) ble_ll_rx_pkt_in(); } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) static void ble_ll_event_tx_pkt(struct ble_npl_event *ev) { @@ -1198,6 +1249,7 @@ ble_ll_event_comp_pkts(struct ble_npl_event *ev) { ble_ll_conn_num_comp_pkts_event_send(NULL); } +#endif /** * Link Layer task. @@ -1314,9 +1366,11 @@ ble_ll_set_host_feat(const uint8_t *cmdbuf, uint8_t len) return BLE_ERR_INV_HCI_CMD_PARMS; } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (!SLIST_EMPTY(&g_ble_ll_conn_active_list)) { return BLE_ERR_CMD_DISALLOWED; } +#endif if ((cmd->bit_num > 0x3F) || (cmd->val > 1)) { return BLE_ERR_INV_HCI_CMD_PARMS; @@ -1423,19 +1477,23 @@ ble_ll_reset(void) OS_ENTER_CRITICAL(sr); ble_phy_disable(); ble_ll_sched_stop(); +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) ble_ll_scan_reset(); +#endif ble_ll_rfmgmt_reset(); OS_EXIT_CRITICAL(sr); +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) /* Stop any advertising */ ble_ll_adv_reset(); +#endif #if MYNEWT_VAL(BLE_LL_DTM) ble_ll_dtm_reset(); #endif /* Stop sync */ -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) && MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) ble_ll_sync_reset(); #endif @@ -1450,8 +1508,10 @@ ble_ll_reset(void) g_ble_ll_data.ll_pref_tx_phys = 0; g_ble_ll_data.ll_pref_rx_phys = 0; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) /* Reset connection module */ ble_ll_conn_module_reset(); +#endif /* All this does is re-initialize the event masks so call the hci init */ ble_ll_hci_init(); @@ -1612,9 +1672,11 @@ ble_ll_init(void) /* Get pointer to global data object */ lldata = &g_ble_ll_data; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) /* Set acl pkt size and number */ lldata->ll_num_acl_pkts = MYNEWT_VAL(BLE_ACL_BUF_COUNT); lldata->ll_acl_pkt_size = MYNEWT_VAL(BLE_ACL_BUF_SIZE); +#endif /* Initialize eventq */ ble_npl_eventq_init(&lldata->ll_evq); @@ -1625,11 +1687,15 @@ ble_ll_init(void) /* Initialize transmit (from host) and receive packet (from phy) event */ ble_npl_event_init(&lldata->ll_rx_pkt_ev, ble_ll_event_rx_pkt, NULL); +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) ble_npl_event_init(&lldata->ll_tx_pkt_ev, ble_ll_event_tx_pkt, NULL); +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) /* Initialize data buffer overflow event and completed packets */ ble_npl_event_init(&lldata->ll_dbuf_overflow_ev, ble_ll_event_dbuf_overflow, NULL); ble_npl_event_init(&lldata->ll_comp_pkt_ev, ble_ll_event_comp_pkts, NULL); +#endif /* Initialize the HW error timer */ ble_npl_callout_init(&g_ble_ll_data.ll_hw_err_timer, @@ -1643,14 +1709,20 @@ ble_ll_init(void) /* Init the scheduler */ ble_ll_sched_init(); +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) /* Initialize advertiser */ ble_ll_adv_init(); +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) /* Initialize a scanner */ ble_ll_scan_init(); +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) /* Initialize the connection module */ ble_ll_conn_module_init(); +#endif /* Set the supported features. NOTE: we always support extended reject. */ features = BLE_LL_FEAT_EXTENDED_REJ; @@ -1696,8 +1768,10 @@ ble_ll_init(void) #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) features |= BLE_LL_FEAT_PERIODIC_ADV; +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) ble_ll_sync_init(); #endif +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV_SYNC_TRANSFER) features |= BLE_LL_FEAT_SYNC_TRANS_RECV; diff --git a/nimble/controller/src/ble_ll_adv.c b/nimble/controller/src/ble_ll_adv.c index 64a3b4034..8a6cd1fe5 100644 --- a/nimble/controller/src/ble_ll_adv.c +++ b/nimble/controller/src/ble_ll_adv.c @@ -42,6 +42,8 @@ #include "controller/ble_ll_rfmgmt.h" #include "ble_ll_conn_priv.h" +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) + /* XXX: TODO * 1) Need to look at advertising and scan request PDUs. Do I allocate these * once? Do I use a different pool for smaller ones? Do I statically declare @@ -118,7 +120,9 @@ struct ble_ll_adv_sm struct os_mbuf *new_adv_data; struct os_mbuf *scan_rsp_data; struct os_mbuf *new_scan_rsp_data; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) uint8_t *conn_comp_ev; +#endif struct ble_npl_event adv_txdone_ev; struct ble_ll_sched_item adv_sch; #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2) @@ -954,6 +958,7 @@ struct aux_conn_rsp_data { * * @param advsm */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) static uint8_t ble_ll_adv_aux_conn_rsp_pdu_make(uint8_t *dptr, void *pducb_arg, uint8_t *hdr_byte) @@ -1002,6 +1007,7 @@ ble_ll_adv_aux_conn_rsp_pdu_make(uint8_t *dptr, void *pducb_arg, return pdulen; } #endif +#endif /** * Called to indicate the advertising event is over. @@ -1750,6 +1756,7 @@ ble_ll_adv_set_adv_params(const uint8_t *cmdbuf, uint8_t len) adv_filter_policy = cmd->filter_policy; switch (cmd->type) { +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) case BLE_HCI_ADV_TYPE_ADV_DIRECT_IND_HD: adv_filter_policy = BLE_HCI_ADV_FILT_NONE; memcpy(advsm->peer_addr, cmd->peer_addr, BLE_DEV_ADDR_LEN); @@ -1769,6 +1776,7 @@ ble_ll_adv_set_adv_params(const uint8_t *cmdbuf, uint8_t len) case BLE_HCI_ADV_TYPE_ADV_IND: props = BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY_IND; break; +#endif case BLE_HCI_ADV_TYPE_ADV_NONCONN_IND: props = BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY_NONCONN; break; @@ -1935,11 +1943,13 @@ ble_ll_adv_sm_stop(struct ble_ll_adv_sm *advsm) ble_npl_eventq_remove(&g_ble_ll_data.ll_evq, &advsm->adv_sec_txdone_ev); #endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) /* If there is an event buf we need to free it */ if (advsm->conn_comp_ev) { ble_hci_trans_buf_free(advsm->conn_comp_ev); advsm->conn_comp_ev = NULL; } +#endif ble_ll_adv_active_chanset_clear(advsm); @@ -1962,6 +1972,7 @@ ble_ll_adv_sm_stop_timeout(struct ble_ll_adv_sm *advsm) } #endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) /* * For high duty directed advertising we need to send connection * complete event with proper status @@ -1971,6 +1982,7 @@ ble_ll_adv_sm_stop_timeout(struct ble_ll_adv_sm *advsm) advsm->conn_comp_ev, advsm); advsm->conn_comp_ev = NULL; } +#endif /* Disable advertising */ ble_ll_adv_sm_stop(advsm); @@ -1992,11 +2004,13 @@ ble_ll_adv_sm_stop_limit_reached(struct ble_ll_adv_sm *advsm) * be used if HD directed advertising was terminated before timeout due to * events count limit. For now just use same code as with duration timeout. */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_HD_DIRECTED) { ble_ll_conn_comp_event_send(NULL, BLE_ERR_DIR_ADV_TMO, advsm->conn_comp_ev, advsm); advsm->conn_comp_ev = NULL; } +#endif /* Disable advertising */ ble_ll_adv_sm_stop(advsm); @@ -2629,7 +2643,6 @@ ble_ll_adv_sm_start(struct ble_ll_adv_sm *advsm) { uint8_t adv_chan; uint8_t *addr; - uint8_t *evbuf; uint32_t start_delay_us; #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2) uint32_t access_addr; @@ -2657,16 +2670,17 @@ ble_ll_adv_sm_start(struct ble_ll_adv_sm *advsm) * Get an event with which to send the connection complete event if * this is connectable */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_CONNECTABLE) { /* We expect this to be NULL but if not we wont allocate one... */ if (advsm->conn_comp_ev == NULL) { - evbuf = ble_hci_trans_buf_alloc(BLE_HCI_TRANS_BUF_EVT_HI); - if (!evbuf) { + advsm->conn_comp_ev = ble_hci_trans_buf_alloc(BLE_HCI_TRANS_BUF_EVT_HI); + if (!advsm->conn_comp_ev) { return BLE_ERR_MEM_CAPACITY; } - advsm->conn_comp_ev = evbuf; } } +#endif /* Set advertising address */ if ((advsm->own_addr_type & 1) == 0) { @@ -3282,9 +3296,11 @@ ble_ll_adv_ext_set_param(const uint8_t *cmdbuf, uint8_t len, /* if legacy bit is set possible values are limited */ switch (props) { +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) case BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY_IND: case BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY_LD_DIR: case BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY_HD_DIR: +#endif case BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY_SCAN: case BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY_NONCONN: break; @@ -3293,6 +3309,12 @@ ble_ll_adv_ext_set_param(const uint8_t *cmdbuf, uint8_t len, goto done; } } else { +#if !MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + if (props & BLE_HCI_LE_SET_EXT_ADV_PROP_CONNECTABLE) { + rc = BLE_ERR_INV_HCI_CMD_PARMS; + goto done; + } +#endif /* HD directed advertising allowed only on legacy PDUs */ if (props & BLE_HCI_LE_SET_EXT_ADV_PROP_HD_DIRECTED) { rc = BLE_ERR_INV_HCI_CMD_PARMS; @@ -4096,6 +4118,7 @@ ble_ll_adv_periodic_set_info_transfer(const uint8_t *cmdbuf, uint8_t len, * @param [in] addr_type Public address (0) or random address (1). * @return Return 1 if already connected, 0 otherwise. */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) static int ble_ll_adv_already_connected(const uint8_t* addr, uint8_t addr_type) { @@ -4118,6 +4141,7 @@ ble_ll_adv_already_connected(const uint8_t* addr, uint8_t addr_type) return 0; } +#endif /** * Called when the LL receives a scan request or connection request @@ -4143,9 +4167,11 @@ ble_ll_adv_rx_req(uint8_t pdu_type, struct os_mbuf *rxpdu) uint8_t *peer; struct ble_mbuf_hdr *ble_hdr; struct ble_ll_adv_sm *advsm; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) struct aux_conn_rsp_data rsp_data; #endif +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) struct ble_ll_resolv_entry *rl; #endif @@ -4252,6 +4278,7 @@ ble_ll_adv_rx_req(uint8_t pdu_type, struct os_mbuf *rxpdu) STATS_INC(ble_ll_stats, scan_rsp_txg); } } else if (pdu_type == BLE_ADV_PDU_TYPE_AUX_CONNECT_REQ) { +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) /* See if the device is already connected */ if (ble_ll_adv_already_connected(peer, peer_addr_type)) { return -1; @@ -4284,6 +4311,7 @@ ble_ll_adv_rx_req(uint8_t pdu_type, struct os_mbuf *rxpdu) ble_ll_adv_flags_set(advsm, BLE_LL_ADV_SM_FLAG_CONN_RSP_TXD); STATS_INC(ble_ll_stats, aux_conn_rsp_tx); } +#endif #endif } @@ -4300,6 +4328,7 @@ ble_ll_adv_rx_req(uint8_t pdu_type, struct os_mbuf *rxpdu) * * @return 0: no connection started. 1: connection started */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) static int ble_ll_adv_conn_req_rxd(uint8_t *rxbuf, struct ble_mbuf_hdr *hdr, struct ble_ll_adv_sm *advsm) @@ -4390,6 +4419,7 @@ ble_ll_adv_conn_req_rxd(uint8_t *rxbuf, struct ble_mbuf_hdr *hdr, return valid; } +#endif /** * Called on phy rx pdu end when in advertising state. @@ -4498,9 +4528,11 @@ ble_ll_adv_rx_pkt_in(uint8_t ptype, uint8_t *rxbuf, struct ble_mbuf_hdr *hdr) adv_event_over = 1; if (BLE_MBUF_HDR_CRC_OK(hdr)) { if (ptype == BLE_ADV_PDU_TYPE_CONNECT_IND) { +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (ble_ll_adv_conn_req_rxd(rxbuf, hdr, advsm)) { adv_event_over = 0; } +#endif } else { if ((ptype == BLE_ADV_PDU_TYPE_SCAN_REQ) && (hdr->rxinfo.flags & BLE_MBUF_HDR_F_SCAN_RSP_TXD)) { @@ -4937,11 +4969,11 @@ ble_ll_adv_can_chg_whitelist(void) * * @return uint8_t* Pointer to event buffer */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) void ble_ll_adv_send_conn_comp_ev(struct ble_ll_conn_sm *connsm, struct ble_mbuf_hdr *rxhdr) { - uint8_t *evbuf; struct ble_ll_adv_sm *advsm; #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) @@ -4950,12 +4982,11 @@ ble_ll_adv_send_conn_comp_ev(struct ble_ll_conn_sm *connsm, advsm = &g_ble_ll_adv_sm[0]; #endif - evbuf = advsm->conn_comp_ev; - assert(evbuf != NULL); + assert(advsm->conn_comp_ev != NULL); + ble_ll_conn_comp_event_send(connsm, BLE_ERR_SUCCESS, advsm->conn_comp_ev, + advsm); advsm->conn_comp_ev = NULL; - ble_ll_conn_comp_event_send(connsm, BLE_ERR_SUCCESS, evbuf, advsm); - #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2) ble_ll_hci_ev_le_csa(connsm); #endif @@ -4967,6 +4998,7 @@ ble_ll_adv_send_conn_comp_ev(struct ble_ll_conn_sm *connsm, } #endif } +#endif /** * Returns the local resolvable private address currently being using by @@ -5128,3 +5160,5 @@ ble_ll_adv_init(void) ble_ll_adv_sm_init(&g_ble_ll_adv_sm[i]); } } + +#endif diff --git a/nimble/controller/src/ble_ll_conn.c b/nimble/controller/src/ble_ll_conn.c index 30a381e1e..2fb65869e 100644 --- a/nimble/controller/src/ble_ll_conn.c +++ b/nimble/controller/src/ble_ll_conn.c @@ -117,6 +117,11 @@ extern void bletest_completed_pkt(uint16_t handle); * 1) The current connection event has not ended but a schedule item starts */ +/* Global LL connection parameters */ +struct ble_ll_conn_global_params g_ble_ll_conn_params; + +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + /* This is a dummy structure we use for the empty PDU */ struct ble_ll_empty_pdu { @@ -130,18 +135,19 @@ struct ble_ll_empty_pdu #error "Maximum # of connections is 254" #endif +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) /* Global connection complete event. Used when initiating */ uint8_t *g_ble_ll_conn_comp_ev; - -/* Global LL connection parameters */ -struct ble_ll_conn_global_params g_ble_ll_conn_params; +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV_SYNC_TRANSFER) /* Global default sync transfer params */ struct ble_ll_conn_sync_transfer_params g_ble_ll_conn_sync_transfer_params; #endif +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) struct ble_ll_conn_create_sm g_ble_ll_conn_create_sm; +#endif /* Pointer to current connection */ struct ble_ll_conn_sm *g_ble_ll_conn_cur_sm; @@ -443,6 +449,7 @@ ble_ll_conn_itvl_to_ticks(uint32_t itvl, uint32_t *itvl_ticks, * * @return uint8_t* */ +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) static uint8_t * ble_ll_init_get_conn_comp_ev(void) { @@ -454,6 +461,7 @@ ble_ll_init_get_conn_comp_ev(void) return evbuf; } +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) /** @@ -701,6 +709,7 @@ ble_ll_conn_start_rx_encrypt(void *arg) !CONN_IS_MASTER(connsm)); } +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) static void ble_ll_conn_start_rx_unencrypt(void *arg) { @@ -710,6 +719,7 @@ ble_ll_conn_start_rx_unencrypt(void *arg) CONN_F_ENCRYPTED(connsm) = 0; ble_phy_encrypt_disable(); } +#endif static void ble_ll_conn_txend_encrypt(void *arg) @@ -721,6 +731,7 @@ ble_ll_conn_txend_encrypt(void *arg) ble_ll_conn_current_sm_over(connsm); } +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) static void ble_ll_conn_rxend_unencrypt(void *arg) { @@ -730,6 +741,7 @@ ble_ll_conn_rxend_unencrypt(void *arg) CONN_F_ENCRYPTED(connsm) = 0; ble_ll_conn_current_sm_over(connsm); } +#endif static void ble_ll_conn_continue_rx_encrypt(void *arg) @@ -978,7 +990,7 @@ ble_ll_conn_tx_pdu(struct ble_ll_conn_sm *connsm) * packets can be let go. */ if (nextpkthdr && !ble_ll_ctrl_enc_allowed_pdu_tx(nextpkthdr) - && ((connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) || + && (CONN_IS_MASTER(connsm) || !ble_ll_ctrl_is_start_enc_rsp(m))) { nextpkthdr = NULL; } @@ -1025,7 +1037,7 @@ ble_ll_conn_tx_pdu(struct ble_ll_conn_sm *connsm) /* We will allow a next packet if it itself is allowed */ pkthdr = OS_MBUF_PKTHDR(connsm->cur_tx_pdu); if (nextpkthdr && !ble_ll_ctrl_enc_allowed_pdu_tx(nextpkthdr) - && ((connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) || + && (CONN_IS_MASTER(connsm) || !ble_ll_ctrl_is_start_enc_rsp(connsm->cur_tx_pdu))) { nextpkthdr = NULL; } @@ -1094,9 +1106,11 @@ ble_ll_conn_tx_pdu(struct ble_ll_conn_sm *connsm) ble_ll_pdu_tx_time_get(next_txlen, tx_phy_mode) + ble_ll_pdu_tx_time_get(cur_txlen, tx_phy_mode); +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { ticks += (BLE_LL_IFS + connsm->eff_max_rx_time); } +#endif ticks = os_cputime_usecs_to_ticks(ticks); if (CPUTIME_LT(os_cputime_get32() + ticks, next_event_time)) { @@ -1152,7 +1166,7 @@ conn_tx_pdu: * overrun next scheduled item. */ if ((connsm->csmflags.cfbit.terminate_ind_rxd) || - ((connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) && (md == 0) && + (CONN_IS_SLAVE(connsm) && (md == 0) && (connsm->cons_rxd_bad_crc == 0) && ((connsm->last_rxd_hdr_byte & BLE_LL_DATA_HDR_MD_MASK) == 0) && !ble_ll_ctrl_is_terminate_ind(hdr_byte, m->om_data[0]))) { @@ -1205,7 +1219,17 @@ conn_tx_pdu: * The slave sends the PAUSE_ENC_RSP encrypted. The master sends * it unencrypted (note that link was already set unencrypted). */ - if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: + CONN_F_ENCRYPTED(connsm) = 0; + connsm->enc_data.enc_state = CONN_ENC_S_PAUSED; + connsm->enc_data.tx_encrypted = 0; + ble_phy_encrypt_disable(); + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: CONN_F_ENCRYPTED(connsm) = 1; connsm->enc_data.tx_encrypted = 1; ble_phy_encrypt_enable(connsm->enc_data.tx_pkt_cntr, @@ -1217,11 +1241,11 @@ conn_tx_pdu: } else { txend_func = ble_ll_conn_rxend_unencrypt; } - } else { - CONN_F_ENCRYPTED(connsm) = 0; - connsm->enc_data.enc_state = CONN_ENC_S_PAUSED; - connsm->enc_data.tx_encrypted = 0; - ble_phy_encrypt_disable(); + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } } else { /* If encrypted set packet counter */ @@ -1278,7 +1302,9 @@ static int ble_ll_conn_event_start_cb(struct ble_ll_sched_item *sch) { int rc; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) uint32_t usecs; +#endif uint32_t start; struct ble_ll_conn_sm *connsm; @@ -1319,7 +1345,9 @@ ble_ll_conn_event_start_cb(struct ble_ll_sched_item *sch) ble_phy_mode_set(connsm->phy_data.tx_phy_mode, connsm->phy_data.rx_phy_mode); #endif - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: /* Set start time of transmission */ start = sch->start_time + g_ble_ll_sched_offset_ticks; rc = ble_phy_tx_set_start_time(start, sch->remainder); @@ -1345,7 +1373,10 @@ ble_ll_conn_event_start_cb(struct ble_ll_sched_item *sch) STATS_INC(ble_ll_conn_stats, conn_ev_late); rc = BLE_LL_SCHED_STATE_DONE; } - } else { + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) if (CONN_F_ENCRYPTED(connsm)) { ble_phy_encrypt_enable(connsm->enc_data.rx_pkt_cntr, @@ -1401,6 +1432,11 @@ ble_ll_conn_event_start_cb(struct ble_ll_sched_item *sch) /* Set next wakeup time to connection event end time */ rc = BLE_LL_SCHED_STATE_RUNNING; } + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } if (rc == BLE_LL_SCHED_STATE_DONE) { @@ -1432,6 +1468,7 @@ static int ble_ll_conn_can_send_next_pdu(struct ble_ll_conn_sm *connsm, uint32_t begtime, uint32_t add_usecs) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) int rc; uint16_t rem_bytes; uint32_t ticks; @@ -1487,6 +1524,9 @@ ble_ll_conn_can_send_next_pdu(struct ble_ll_conn_sm *connsm, uint32_t begtime, } return rc; +#else + return 1; +#endif } #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_PING) @@ -1527,6 +1567,7 @@ ble_ll_conn_auth_pyld_timer_start(struct ble_ll_conn_sm *connsm) } #endif +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) static void ble_ll_conn_master_common_init(struct ble_ll_conn_sm *connsm) { @@ -1588,6 +1629,7 @@ ble_ll_conn_master_init(struct ble_ll_conn_sm *connsm, connsm->min_ce_len = cc_params->min_ce_len; connsm->max_ce_len = cc_params->max_ce_len; } +#endif #if (BLE_LL_BT5_PHY_SUPPORTED == 1) @@ -1643,6 +1685,7 @@ ble_ll_conn_init_phy(struct ble_ll_conn_sm *connsm, int phy) #endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) static void ble_ll_conn_create_set_params(struct ble_ll_conn_sm *connsm, uint8_t phy) { @@ -1658,6 +1701,7 @@ ble_ll_conn_create_set_params(struct ble_ll_conn_sm *connsm, uint8_t phy) connsm->conn_itvl_usecs = cc_params->conn_itvl_usecs; } #endif +#endif static void ble_ll_conn_set_csa(struct ble_ll_conn_sm *connsm, bool chsel) @@ -1998,8 +2042,10 @@ ble_ll_conn_next_event(struct ble_ll_conn_sm *connsm) { uint16_t latency; uint32_t itvl; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) uint32_t cur_ww; uint32_t max_ww; +#endif struct ble_ll_conn_upd_req *upd; uint32_t ticks; uint32_t usecs; @@ -2012,7 +2058,7 @@ ble_ll_conn_next_event(struct ble_ll_conn_sm *connsm) ble_ll_ctrl_terminate_start(connsm); } - if (CONN_F_TERMINATE_STARTED(connsm) && (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE)) { + if (CONN_F_TERMINATE_STARTED(connsm) && CONN_IS_SLAVE(connsm)) { /* Some of the devices waits whole connection interval to ACK our * TERMINATE_IND sent as a Slave. Since we are here it means we are still waiting for ACK. * Make sure we catch it in next connection event. @@ -2072,8 +2118,8 @@ ble_ll_conn_next_event(struct ble_ll_conn_sm *connsm) /* Set flag so we send connection update event */ upd = &connsm->conn_update_req; - if ((connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) || - ((connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) && + if (CONN_IS_MASTER(connsm) || + (CONN_IS_SLAVE(connsm) && IS_PENDING_CTRL_PROC(connsm, BLE_LL_CTRL_PROC_CONN_PARAM_REQ)) || (connsm->conn_itvl != upd->interval) || (connsm->slave_latency != upd->latency) || @@ -2208,6 +2254,7 @@ ble_ll_conn_next_event(struct ble_ll_conn_sm *connsm) #else itvl = MYNEWT_VAL(BLE_LL_CONN_INIT_SLOTS) * BLE_LL_SCHED_TICKS_PER_SLOT; #endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { cur_ww = ble_ll_utils_calc_window_widening(connsm->anchor_point, @@ -2221,6 +2268,7 @@ ble_ll_conn_next_event(struct ble_ll_conn_sm *connsm) connsm->slave_cur_window_widening = cur_ww; itvl += os_cputime_usecs_to_ticks(cur_ww + connsm->slave_cur_tx_win_usecs); } +#endif itvl -= g_ble_ll_sched_offset_ticks; connsm->ce_end_time = connsm->anchor_point + itvl; @@ -2246,9 +2294,13 @@ static int ble_ll_conn_created(struct ble_ll_conn_sm *connsm, struct ble_mbuf_hdr *rxhdr) { int rc; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) uint8_t *evbuf; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) uint32_t endtime; uint32_t usecs; +#endif /* XXX: TODO this assumes we received in 1M phy */ @@ -2273,6 +2325,7 @@ ble_ll_conn_created(struct ble_ll_conn_sm *connsm, struct ble_mbuf_hdr *rxhdr) * the transmit window offset from the end of the connection request. */ rc = 1; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { /* * With a 32.768 kHz crystal we dont care about the remaining usecs @@ -2334,6 +2387,7 @@ ble_ll_conn_created(struct ble_ll_conn_sm *connsm, struct ble_mbuf_hdr *rxhdr) } } } +#endif /* Send connection complete event to inform host of connection */ if (rc) { @@ -2350,9 +2404,9 @@ ble_ll_conn_created(struct ble_ll_conn_sm *connsm, struct ble_mbuf_hdr *rxhdr) CONN_F_CTRLR_PHY_UPDATE(connsm) = 1; } #endif - if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { - ble_ll_adv_send_conn_comp_ev(connsm, rxhdr); - } else { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: evbuf = ble_ll_init_get_conn_comp_ev(); ble_ll_conn_comp_event_send(connsm, BLE_ERR_SUCCESS, evbuf, NULL); #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2) @@ -2368,6 +2422,16 @@ ble_ll_conn_created(struct ble_ll_conn_sm *connsm, struct ble_mbuf_hdr *rxhdr) * if it has some additional features to use. */ ble_ll_ctrl_proc_start(connsm, BLE_LL_CTRL_PROC_FEATURE_XCHG); + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: + ble_ll_adv_send_conn_comp_ev(connsm, rxhdr); + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } } @@ -2676,6 +2740,7 @@ ble_ll_conn_event_halt(void) } } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) int ble_ll_conn_send_connect_req(struct os_mbuf *rxpdu, struct ble_ll_scan_addr_data *addrd, @@ -2793,8 +2858,10 @@ ble_ll_conn_created_on_legacy(struct os_mbuf *rxpdu, ble_ll_conn_master_start(BLE_PHY_1M, csa, addrd, targeta); } +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) void ble_ll_conn_created_on_aux(struct os_mbuf *rxpdu, struct ble_ll_scan_addr_data *addrd, @@ -2814,6 +2881,7 @@ ble_ll_conn_created_on_aux(struct os_mbuf *rxpdu, ble_ll_conn_master_start(phy, 1, addrd, targeta); } +#endif #endif /* BLE_LL_CFG_FEAT_LL_EXT_ADV */ /** @@ -2984,11 +3052,13 @@ ble_ll_conn_rx_data_pdu(struct os_mbuf *rxpdu, struct ble_mbuf_hdr *hdr) * If we are a slave, we can only start to use slave latency * once we have received a NESN of 1 from the master */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { if (hdr_byte & BLE_LL_DATA_HDR_NESN_MASK) { connsm->csmflags.cfbit.allow_slave_latency = 1; } } +#endif /* * Discard the received PDU if the sequence number is the same @@ -3172,11 +3242,21 @@ ble_ll_conn_rx_isr_end(uint8_t *rxbuf, struct ble_mbuf_hdr *rxhdr) if (connsm->cons_rxd_bad_crc >= 2) { reply = 0; } else { - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: reply = CONN_F_LAST_TXD_MD(connsm); - } else { + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: /* A slave always responds with a packet */ reply = 1; + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } } } else { @@ -3290,7 +3370,7 @@ ble_ll_conn_rx_isr_end(uint8_t *rxbuf, struct ble_mbuf_hdr *rxhdr) #if (BLE_LL_BT5_PHY_SUPPORTED == 1) if (BLE_LL_LLID_IS_CTRL(hdr_byte) && - (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) && + CONN_IS_SLAVE(connsm) && (opcode == BLE_LL_CTRL_PHY_UPDATE_IND)) { connsm->phy_tx_transition = ble_ll_ctrl_phy_tx_transition_get(rxbuf[3]); @@ -3315,11 +3395,21 @@ chk_rx_terminate_ind: connsm->rxd_disconnect_reason = rxbuf[3]; } - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: reply = CONN_F_LAST_TXD_MD(connsm) || (hdr_byte & BLE_LL_DATA_HDR_MD_MASK); - } else { + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: /* A slave always replies */ reply = 1; + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } } @@ -3407,9 +3497,11 @@ ble_ll_conn_enqueue_pkt(struct ble_ll_conn_sm *connsm, struct os_mbuf *om, lifo = 1; break; case BLE_LL_CTRL_PAUSE_ENC_RSP: +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { lifo = 1; } +#endif break; case BLE_LL_CTRL_ENC_REQ: case BLE_LL_CTRL_ENC_RSP: @@ -3480,7 +3572,7 @@ ble_ll_conn_tx_pkt_in(struct os_mbuf *om, uint16_t handle, uint16_t length) os_mbuf_free_chain(om); } } - +#endif /** * Called to set the global channel mask that we use for all connections. * @@ -3490,7 +3582,9 @@ ble_ll_conn_tx_pkt_in(struct os_mbuf *om, uint16_t handle, uint16_t length) void ble_ll_conn_set_global_chanmap(uint8_t num_used_chans, const uint8_t *chanmap) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) struct ble_ll_conn_sm *connsm; +#endif struct ble_ll_conn_global_params *conn_params; /* Do nothing if same channel map */ @@ -3503,14 +3597,17 @@ ble_ll_conn_set_global_chanmap(uint8_t num_used_chans, const uint8_t *chanmap) conn_params->num_used_chans = num_used_chans; memcpy(conn_params->master_chan_map, chanmap, BLE_LL_CONN_CHMAP_LEN); +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) /* Perform channel map update */ SLIST_FOREACH(connsm, &g_ble_ll_conn_active_list, act_sle) { if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { ble_ll_ctrl_proc_start(connsm, BLE_LL_CTRL_PROC_CHAN_MAP_UPD); } } +#endif } +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) /** * Called when a device has received a connect request while advertising and * the connect request has passed the advertising filter policy and is for @@ -3524,6 +3621,7 @@ ble_ll_conn_set_global_chanmap(uint8_t num_used_chans, const uint8_t *chanmap) * * @return 0: connection not started; 1 connecton started */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) int ble_ll_conn_slave_start(uint8_t *rxbuf, uint8_t pat, struct ble_mbuf_hdr *rxhdr, bool force_csa2) @@ -3642,6 +3740,7 @@ err_slave_start: STATS_INC(ble_ll_conn_stats, slave_rxd_bad_conn_req_params); return 0; } +#endif #define MAX_TIME_UNCODED(_maxbytes) \ ble_ll_pdu_tx_time_get(_maxbytes + BLE_LL_DATA_MIC_LEN, \ @@ -3672,6 +3771,7 @@ ble_ll_conn_module_reset(void) ble_ll_conn_end(connsm, BLE_ERR_SUCCESS); } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) /* Free the global connection complete event if there is one */ if (g_ble_ll_conn_comp_ev) { ble_hci_trans_buf_free(g_ble_ll_conn_comp_ev); @@ -3680,6 +3780,7 @@ ble_ll_conn_module_reset(void) /* Reset connection we are attempting to create */ g_ble_ll_conn_create_sm.connsm = NULL; +#endif /* Now go through and end all the connections */ while (1) { @@ -3791,3 +3892,4 @@ ble_ll_conn_module_init(void) /* Call reset to finish reset of initialization */ ble_ll_conn_module_reset(); } +#endif diff --git a/nimble/controller/src/ble_ll_conn_hci.c b/nimble/controller/src/ble_ll_conn_hci.c index 6489af0d5..2e50713e8 100644 --- a/nimble/controller/src/ble_ll_conn_hci.c +++ b/nimble/controller/src/ble_ll_conn_hci.c @@ -34,6 +34,8 @@ #include "controller/ble_ll_adv.h" #include "ble_ll_conn_priv.h" +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + /* * Used to limit the rate at which we send the number of completed packets * event to the host. This is the os time at which we can send an event. @@ -158,7 +160,9 @@ ble_ll_conn_comp_event_send(struct ble_ll_conn_sm *connsm, uint8_t status, enh_ev->peer_addr_type = connsm->peer_addr_type; memcpy(enh_ev->peer_addr, connsm->peer_addr, BLE_DEV_ADDR_LEN); - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: if (connsm->inita_identity_used) { /* We used identity address in CONNECT_IND which can be just * fine if @@ -173,8 +177,16 @@ ble_ll_conn_comp_event_send(struct ble_ll_conn_sm *connsm, uint8_t status, } else { rpa = NULL; } - } else { + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: rpa = ble_ll_adv_get_local_rpa(advsm); + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } if (rpa) { @@ -189,20 +201,33 @@ ble_ll_conn_comp_event_send(struct ble_ll_conn_sm *connsm, uint8_t status, #endif if (enh_ev->peer_addr_type > BLE_HCI_CONN_PEER_ADDR_RANDOM) { - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: rpa = ble_ll_scan_get_peer_rpa(); - } else { + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: rpa = ble_ll_adv_get_peer_rpa(advsm); + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } + memcpy(enh_ev->peer_rpa, rpa, BLE_DEV_ADDR_LEN); } enh_ev->conn_itvl = htole16(connsm->conn_itvl); enh_ev->conn_latency = htole16(connsm->slave_latency); enh_ev->supervision_timeout = htole16(connsm->supervision_tmo); +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { enh_ev->mca = connsm->master_sca; } +#endif } ble_ll_hci_event_send(hci_ev); @@ -227,9 +252,11 @@ ble_ll_conn_comp_event_send(struct ble_ll_conn_sm *connsm, uint8_t status, ev->conn_itvl = htole16(connsm->conn_itvl); ev->conn_latency = htole16(connsm->slave_latency); ev->supervision_timeout = htole16(connsm->supervision_tmo); +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { ev->mca = connsm->master_sca; } +#endif } ble_ll_hci_event_send(hci_ev); @@ -826,10 +853,12 @@ ble_ll_conn_hci_read_rem_features(const uint8_t *cmdbuf, uint8_t len) */ if (!connsm->csmflags.cfbit.rxd_features && !IS_PENDING_CTRL_PROC(connsm, BLE_LL_CTRL_PROC_FEATURE_XCHG)) { +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if ((connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) && !(ble_ll_read_supp_features() & BLE_LL_FEAT_SLAVE_INIT)) { return BLE_ERR_CMD_DISALLOWED; } +#endif ble_ll_ctrl_proc_start(connsm, BLE_LL_CTRL_PROC_FEATURE_XCHG); } @@ -880,9 +909,11 @@ ble_ll_conn_hci_update(const uint8_t *cmdbuf, uint8_t len) /* See if this feature is supported on both sides */ if ((connsm->conn_features & BLE_LL_FEAT_CONN_PARM_REQ) == 0) { +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { return BLE_ERR_UNSUPP_REM_FEATURE; } +#endif ctrl_proc = BLE_LL_CTRL_PROC_CONN_UPDATE; } else { ctrl_proc = BLE_LL_CTRL_PROC_CONN_PARAM_REQ; @@ -895,14 +926,24 @@ ble_ll_conn_hci_update(const uint8_t *cmdbuf, uint8_t len) * slave. */ if (connsm->csmflags.cfbit.awaiting_host_reply) { - if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { - return BLE_ERR_LMP_COLLISION; - } else { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: connsm->csmflags.cfbit.awaiting_host_reply = 0; /* XXX: If this fails no reject ind will be sent! */ ble_ll_ctrl_reject_ind_send(connsm, connsm->host_reply_opcode, BLE_ERR_LMP_COLLISION); + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: + return BLE_ERR_LMP_COLLISION; + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } } @@ -910,11 +951,13 @@ ble_ll_conn_hci_update(const uint8_t *cmdbuf, uint8_t len) * If we are a slave and the master has initiated the channel map * update procedure we should deny the slave request for now. */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (connsm->csmflags.cfbit.chanmap_update_scheduled) { if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { return BLE_ERR_DIFF_TRANS_COLL; } } +#endif /* Retrieve command data */ hcu = &connsm->conn_param_req; @@ -1301,6 +1344,7 @@ ble_ll_conn_hci_rd_chan_map(const uint8_t *cmdbuf, uint8_t len, *rsplen = sizeof(*rsp); return rc; } +#endif /** * Called when the host issues the LE command "set host channel classification" @@ -1334,6 +1378,8 @@ ble_ll_conn_hci_set_chan_class(const uint8_t *cmdbuf, uint8_t len) return BLE_ERR_SUCCESS; } +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + #if MYNEWT_VAL(BLE_LL_CFG_FEAT_DATA_LEN_EXT) int ble_ll_conn_hci_set_data_len(const uint8_t *cmdbuf, uint8_t len, @@ -1421,8 +1467,10 @@ ble_ll_conn_hci_le_start_encrypt(const uint8_t *cmdbuf, uint8_t len) connsm = ble_ll_conn_find_active_conn(le16toh(cmd->conn_handle)); if (!connsm) { rc = BLE_ERR_UNK_CONN_ID; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) } else if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { rc = BLE_ERR_UNSPECIFIED; +#endif } else if (connsm->cur_ctrl_proc == BLE_LL_CTRL_PROC_ENCRYPT) { /* * The specification does not say what to do here but the host should @@ -1475,11 +1523,13 @@ ble_ll_conn_hci_le_ltk_reply(const uint8_t *cmdbuf, uint8_t len, goto ltk_key_cmd_complete; } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) /* Should never get this if we are a master! */ if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { rc = BLE_ERR_UNSPECIFIED; goto ltk_key_cmd_complete; } +#endif /* The connection should be awaiting a reply. If not, just discard */ if (connsm->enc_data.enc_state != CONN_ENC_S_LTK_REQ_WAIT) { @@ -1532,11 +1582,13 @@ ble_ll_conn_hci_le_ltk_neg_reply(const uint8_t *cmdbuf, uint8_t len, goto ltk_key_cmd_complete; } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) /* Should never get this if we are a master! */ if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { rc = BLE_ERR_UNSPECIFIED; goto ltk_key_cmd_complete; } +#endif /* The connection should be awaiting a reply. If not, just discard */ if (connsm->enc_data.enc_state != CONN_ENC_S_LTK_REQ_WAIT) { @@ -1916,3 +1968,4 @@ ble_ll_set_default_sync_transfer_params(const uint8_t *cmdbuf, uint8_t len) return BLE_ERR_SUCCESS; } #endif +#endif diff --git a/nimble/controller/src/ble_ll_conn_priv.h b/nimble/controller/src/ble_ll_conn_priv.h index d1a4a3e88..73e410607 100644 --- a/nimble/controller/src/ble_ll_conn_priv.h +++ b/nimble/controller/src/ble_ll_conn_priv.h @@ -64,6 +64,7 @@ struct ble_ll_conn_global_params { uint8_t master_chan_map[BLE_LL_CONN_CHMAP_LEN]; uint8_t num_used_chans; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) uint8_t supp_max_tx_octets; uint8_t supp_max_rx_octets; uint8_t conn_init_max_tx_octets; @@ -74,6 +75,7 @@ struct ble_ll_conn_global_params uint16_t conn_init_max_tx_time_coded; uint16_t supp_max_tx_time; uint16_t supp_max_rx_time; +#endif }; extern struct ble_ll_conn_global_params g_ble_ll_conn_params; diff --git a/nimble/controller/src/ble_ll_ctrl.c b/nimble/controller/src/ble_ll_ctrl.c index 94d73a9bb..432045e67 100644 --- a/nimble/controller/src/ble_ll_ctrl.c +++ b/nimble/controller/src/ble_ll_ctrl.c @@ -31,6 +31,8 @@ #include "controller/ble_ll_sync.h" #include "ble_ll_conn_priv.h" +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + /* To use spec sample data for testing */ #undef BLE_LL_ENCRYPT_USE_TEST_DATA @@ -314,8 +316,7 @@ ble_ll_ctrl_conn_param_pdu_proc(struct ble_ll_conn_sm *connsm, uint8_t *dptr, * update the connection parameters. This means that the previous * check is all we need for a master (when receiving a request). */ - if ((connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) || - (opcode == BLE_LL_CTRL_CONN_PARM_RSP)) { + if (CONN_IS_SLAVE(connsm) || (opcode == BLE_LL_CTRL_CONN_PARM_RSP)) { /* * Not sure what to do about the slave. It is possible that the * current connection parameters are not the same ones as the local host @@ -488,11 +489,13 @@ ble_ll_ctrl_proc_unk_rsp(struct ble_ll_conn_sm *connsm, uint8_t *dptr, uint8_t * break; case BLE_LL_CTRL_CONN_PARM_REQ: BLE_LL_CONN_CLEAR_FEATURE(connsm, BLE_LL_FEAT_CONN_PARM_REQ); +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { ble_ll_ctrl_conn_upd_make(connsm, rspdata, NULL); connsm->reject_reason = BLE_ERR_SUCCESS; return BLE_LL_CTRL_CONN_UPDATE_IND; } +#endif /* note: fall-through intentional */ case BLE_LL_CTRL_CONN_PARM_RSP: ctrl_proc = BLE_LL_CTRL_PROC_CONN_PARAM_REQ; @@ -674,6 +677,7 @@ ble_ll_ctrl_phy_update_proc_complete(struct ble_ll_conn_sm *connsm) } } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) /** * * There is probably a better way for the controller to choose which PHY use. @@ -713,6 +717,7 @@ ble_ll_ctrl_find_new_phy(uint8_t phy_mask_prefs) * @param ctrdata: Pointer to where CtrData of UPDATE_IND pdu starts * @param slave_req flag denoting if slave requested this. 0: no 1:yes */ + static void ble_ll_ctrl_phy_update_ind_make(struct ble_ll_conn_sm *connsm, uint8_t *dptr, uint8_t *ctrdata, int slave_req) @@ -729,10 +734,12 @@ ble_ll_ctrl_phy_update_ind_make(struct ble_ll_conn_sm *connsm, uint8_t *dptr, rx_phys = dptr[1]; /* If we are master, check if slave requested symmetric PHY */ +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { is_slave_sym = tx_phys == rx_phys; is_slave_sym &= __builtin_popcount(tx_phys) == 1; } +#endif /* Get m_to_s and s_to_m masks */ if (slave_req) { @@ -818,6 +825,7 @@ ble_ll_ctrl_phy_update_ind_make(struct ble_ll_conn_sm *connsm, uint8_t *dptr, ctrdata[1] = s_to_m; put_le16(ctrdata + 2, instant); } +#endif /** * Create a LL_PHY_REQ or LL_PHY_RSP pdu @@ -872,7 +880,9 @@ ble_ll_ctrl_rx_phy_req(struct ble_ll_conn_sm *connsm, uint8_t *req, err = ble_ll_ctrl_proc_with_instant_initiated(connsm, BLE_LL_CTRL_PROC_PHY_UPDATE); - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: if (err) { ble_ll_ctrl_rej_ext_ind_make(BLE_LL_CTRL_PHY_REQ, err, rsp); rsp_opcode = BLE_LL_CTRL_REJECT_IND_EXT; @@ -885,7 +895,10 @@ ble_ll_ctrl_rx_phy_req(struct ble_ll_conn_sm *connsm, uint8_t *req, ble_ll_ctrl_phy_update_ind_make(connsm, req, rsp, 1); rsp_opcode = BLE_LL_CTRL_PHY_UPDATE_IND; } - } else { + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: /* XXX: deal with other control procedures that we need to stop */ if (err) { if (connsm->cur_ctrl_proc == BLE_LL_CTRL_PROC_PHY_UPDATE) { @@ -913,7 +926,13 @@ ble_ll_ctrl_rx_phy_req(struct ble_ll_conn_sm *connsm, uint8_t *req, /* Start response timer */ connsm->cur_ctrl_proc = BLE_LL_CTRL_PROC_PHY_UPDATE; ble_ll_ctrl_start_rsp_timer(connsm); + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } + return rsp_opcode; } @@ -933,7 +952,10 @@ ble_ll_ctrl_rx_phy_rsp(struct ble_ll_conn_sm *connsm, uint8_t *dptr, uint8_t rsp_opcode; rsp_opcode = BLE_ERR_MAX; - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: if (connsm->cur_ctrl_proc == BLE_LL_CTRL_PROC_PHY_UPDATE) { ble_ll_ctrl_phy_update_ind_make(connsm, dptr, rsp, 0); ble_npl_callout_stop(&connsm->ctrl_proc_rsp_timer); @@ -946,8 +968,16 @@ ble_ll_ctrl_rx_phy_rsp(struct ble_ll_conn_sm *connsm, uint8_t *dptr, * * XXX: TODO count some stat? */ - } else { + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: rsp_opcode = BLE_LL_CTRL_UNKNOWN_RSP; + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } /* NOTE: slave should never receive one of these */ @@ -976,9 +1006,11 @@ ble_ll_ctrl_rx_phy_update_ind(struct ble_ll_conn_sm *connsm, uint8_t *dptr) uint16_t instant; uint16_t delta; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { return BLE_LL_CTRL_UNKNOWN_RSP; } +#endif /* * Reception stops the procedure response timer but does not @@ -1434,9 +1466,11 @@ static uint8_t ble_ll_ctrl_rx_enc_req(struct ble_ll_conn_sm *connsm, uint8_t *dptr, uint8_t *rspdata) { - if (connsm->conn_role != BLE_LL_CONN_ROLE_SLAVE) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { return BLE_LL_CTRL_UNKNOWN_RSP; } +#endif connsm->enc_data.enc_state = CONN_ENC_S_ENC_RSP_TO_BE_SENT; @@ -1479,15 +1513,27 @@ ble_ll_ctrl_rx_start_enc_req(struct ble_ll_conn_sm *connsm) /* Only master should receive start enc request */ rc = BLE_ERR_MAX; - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: /* We only want to send a START_ENC_RSP if we havent yet */ if (connsm->enc_data.enc_state == CONN_ENC_S_START_ENC_REQ_WAIT) { connsm->enc_data.enc_state = CONN_ENC_S_START_ENC_RSP_WAIT; rc = BLE_LL_CTRL_START_ENC_RSP; } - } else { + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: rc = BLE_LL_CTRL_UNKNOWN_RSP; + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } + return rc; } @@ -1502,7 +1548,7 @@ ble_ll_ctrl_rx_pause_enc_req(struct ble_ll_conn_sm *connsm) * ignore it... */ rc = BLE_ERR_MAX; - if ((connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) && + if (CONN_IS_SLAVE(connsm) && (connsm->enc_data.enc_state == CONN_ENC_S_ENCRYPTED)) { rc = BLE_LL_CTRL_PAUSE_ENC_RSP; } else { @@ -1525,16 +1571,28 @@ ble_ll_ctrl_rx_pause_enc_rsp(struct ble_ll_conn_sm *connsm) { int rc; - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: rc = BLE_LL_CTRL_PAUSE_ENC_RSP; - } else if (connsm->enc_data.enc_state == CONN_ENC_S_PAUSE_ENC_RSP_WAIT) { - /* Master sends back unencrypted LL_PAUSE_ENC_RSP. - * From this moment encryption is paused. - */ - rc = BLE_ERR_MAX; - connsm->enc_data.enc_state = CONN_ENC_S_PAUSED; - } else { - rc = BLE_LL_CTRL_UNKNOWN_RSP; + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: + if (connsm->enc_data.enc_state == CONN_ENC_S_PAUSE_ENC_RSP_WAIT) { + /* Master sends back unencrypted LL_PAUSE_ENC_RSP. + * From this moment encryption is paused. + */ + rc = BLE_ERR_MAX; + connsm->enc_data.enc_state = CONN_ENC_S_PAUSED; + } else { + rc = BLE_LL_CTRL_UNKNOWN_RSP; + } + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } return rc; @@ -1559,9 +1617,9 @@ ble_ll_ctrl_rx_start_enc_rsp(struct ble_ll_conn_sm *connsm) return BLE_ERR_MAX; } - /* If master, we are done. Stop control procedure and sent event to host */ - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { - + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: ble_ll_ctrl_proc_stop(connsm, BLE_LL_CTRL_PROC_ENCRYPT); /* We are encrypted */ @@ -1570,7 +1628,10 @@ ble_ll_ctrl_rx_start_enc_rsp(struct ble_ll_conn_sm *connsm) ble_ll_conn_auth_pyld_timer_start(connsm); #endif rc = BLE_ERR_MAX; - } else { + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: /* Procedure has completed but slave needs to send START_ENC_RSP */ rc = BLE_LL_CTRL_START_ENC_RSP; @@ -1578,6 +1639,11 @@ ble_ll_ctrl_rx_start_enc_rsp(struct ble_ll_conn_sm *connsm) if (connsm->cur_ctrl_proc == BLE_LL_CTRL_PROC_ENCRYPT) { ble_ll_ctrl_proc_stop(connsm, BLE_LL_CTRL_PROC_ENCRYPT); } + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } /* @@ -1692,14 +1758,24 @@ ble_ll_ctrl_conn_param_reply(struct ble_ll_conn_sm *connsm, uint8_t *rsp, { uint8_t rsp_opcode; - if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { - /* Create a connection parameter response */ - ble_ll_ctrl_conn_param_pdu_make(connsm, rsp + 1, req); - rsp_opcode = BLE_LL_CTRL_CONN_PARM_RSP; - } else { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: /* Create a connection update pdu */ ble_ll_ctrl_conn_upd_make(connsm, rsp + 1, req); rsp_opcode = BLE_LL_CTRL_CONN_UPDATE_IND; + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: + /* Create a connection parameter response */ + ble_ll_ctrl_conn_param_pdu_make(connsm, rsp + 1, req); + rsp_opcode = BLE_LL_CTRL_CONN_PARM_RSP; + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } return rsp_opcode; @@ -1732,14 +1808,24 @@ ble_ll_ctrl_rx_reject_ind(struct ble_ll_conn_sm *connsm, uint8_t *dptr, switch (connsm->cur_ctrl_proc) { case BLE_LL_CTRL_PROC_CONN_PARAM_REQ: if (opcode == BLE_LL_CTRL_REJECT_IND_EXT) { - /* As a master we should send connection update indication in this point */ - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + switch (connsm->conn_role) { + #if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: + /* As a master we should send connection update indication in this point */ rsp_opcode = BLE_LL_CTRL_CONN_UPDATE_IND; ble_ll_ctrl_conn_upd_make(connsm, rspdata, NULL); connsm->reject_reason = BLE_ERR_SUCCESS; - } else { + break; + #endif + #if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: ble_ll_ctrl_proc_stop(connsm, BLE_LL_CTRL_PROC_CONN_PARAM_REQ); ble_ll_hci_ev_conn_update(connsm, ble_error); + break; + #endif + default: + BLE_LL_ASSERT(0); + break; } } break; @@ -1792,9 +1878,11 @@ ble_ll_ctrl_rx_conn_update(struct ble_ll_conn_sm *connsm, uint8_t *dptr) struct ble_ll_conn_upd_req *reqdata; /* Only a slave should receive this */ +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { return BLE_LL_CTRL_UNKNOWN_RSP; } +#endif /* Retrieve parameters */ reqdata = &connsm->conn_update_req; @@ -1913,12 +2001,12 @@ ble_ll_ctrl_rx_feature_req(struct ble_ll_conn_sm *connsm, uint8_t *dptr, * requests if we are a slave. */ if (opcode == BLE_LL_CTRL_SLAVE_FEATURE_REQ) { - if (connsm->conn_role != BLE_LL_CONN_ROLE_MASTER) { + if (!CONN_IS_MASTER(connsm)) { return BLE_LL_CTRL_UNKNOWN_RSP; } } else { /* XXX: not sure this is correct but do it anyway */ - if (connsm->conn_role != BLE_LL_CONN_ROLE_SLAVE) { + if (!CONN_IS_SLAVE(connsm)) { return BLE_LL_CTRL_UNKNOWN_RSP; } } @@ -2018,15 +2106,24 @@ ble_ll_ctrl_rx_conn_param_req(struct ble_ll_conn_sm *connsm, uint8_t *dptr, * transaction collision error code. */ if (IS_PENDING_CTRL_PROC(connsm, BLE_LL_CTRL_PROC_CONN_PARAM_REQ)) { - if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { - ble_ll_ctrl_proc_stop(connsm, BLE_LL_CTRL_PROC_CONN_PARAM_REQ); - ble_ll_hci_ev_conn_update(connsm, BLE_ERR_LMP_COLLISION); - } else { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: /* The master sends reject ind ext w/error code 0x23 */ rsp_opcode = BLE_LL_CTRL_REJECT_IND_EXT; rspbuf[1] = BLE_LL_CTRL_CONN_PARM_REQ; rspbuf[2] = BLE_ERR_LMP_COLLISION; return rsp_opcode; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: + ble_ll_ctrl_proc_stop(connsm, BLE_LL_CTRL_PROC_CONN_PARAM_REQ); + ble_ll_hci_ev_conn_update(connsm, BLE_ERR_LMP_COLLISION); + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } } @@ -2034,6 +2131,7 @@ ble_ll_ctrl_rx_conn_param_req(struct ble_ll_conn_sm *connsm, uint8_t *dptr, * If we are a master and we currently performing a channel map * update procedure we need to return an error */ +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if ((connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) && (connsm->csmflags.cfbit.chanmap_update_scheduled)) { rsp_opcode = BLE_LL_CTRL_REJECT_IND_EXT; @@ -2041,6 +2139,7 @@ ble_ll_ctrl_rx_conn_param_req(struct ble_ll_conn_sm *connsm, uint8_t *dptr, rspbuf[2] = BLE_ERR_DIFF_TRANS_COLL; return rsp_opcode; } +#endif /* Process the received connection parameter request */ rsp_opcode = ble_ll_ctrl_conn_param_pdu_proc(connsm, dptr, rspbuf, @@ -2055,9 +2154,11 @@ ble_ll_ctrl_rx_conn_param_rsp(struct ble_ll_conn_sm *connsm, uint8_t *dptr, uint8_t rsp_opcode; /* A slave should never receive this response */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { return BLE_LL_CTRL_UNKNOWN_RSP; } +#endif /* * This case should never happen! It means that the slave initiated a @@ -2131,9 +2232,11 @@ ble_ll_ctrl_rx_chanmap_req(struct ble_ll_conn_sm *connsm, uint8_t *dptr) uint16_t instant; uint16_t conn_events; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { return BLE_LL_CTRL_UNKNOWN_RSP; } +#endif /* If instant is in the past, we have to end the connection */ instant = get_le16(dptr + BLE_LL_CONN_CHMAP_LEN); @@ -2188,10 +2291,20 @@ ble_ll_ctrl_proc_init(struct ble_ll_conn_sm *connsm, int ctrl_proc) ble_ll_ctrl_chanmap_req_make(connsm, ctrdata); break; case BLE_LL_CTRL_PROC_FEATURE_XCHG: - if (connsm->conn_role == BLE_LL_CONN_ROLE_MASTER) { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: opcode = BLE_LL_CTRL_FEATURE_REQ; - } else { + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: opcode = BLE_LL_CTRL_SLAVE_FEATURE_REQ; + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } put_le64(ctrdata, ble_ll_read_supp_features()); break; @@ -2849,6 +2962,7 @@ ble_ll_ctrl_tx_done(struct os_mbuf *txpdu, struct ble_ll_conn_sm *connsm) connsm->enc_data.enc_state = CONN_ENC_S_LTK_REQ_WAIT; connsm->csmflags.cfbit.send_ltk_req = 1; break; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) case BLE_LL_CTRL_START_ENC_RSP: if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { connsm->enc_data.enc_state = CONN_ENC_S_ENCRYPTED; @@ -2863,7 +2977,9 @@ ble_ll_ctrl_tx_done(struct os_mbuf *txpdu, struct ble_ll_conn_sm *connsm) } break; #endif +#endif #if (BLE_LL_BT5_PHY_SUPPORTED == 1) +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) case BLE_LL_CTRL_PHY_REQ: if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { connsm->phy_tx_transition = @@ -2871,6 +2987,7 @@ ble_ll_ctrl_tx_done(struct os_mbuf *txpdu, struct ble_ll_conn_sm *connsm) connsm->phy_data.req_pref_tx_phys_mask); } break; +#endif case BLE_LL_CTRL_PHY_UPDATE_IND: connsm->phy_tx_transition = ble_ll_ctrl_phy_tx_transition_get(txpdu->om_data[2]); @@ -2890,3 +3007,4 @@ ble_ll_ctrl_init_conn_sm(struct ble_ll_conn_sm *connsm) ble_npl_callout_init(&connsm->ctrl_proc_rsp_timer, &g_ble_ll_data.ll_evq, ble_ll_ctrl_proc_rsp_timer_cb, connsm); } +#endif diff --git a/nimble/controller/src/ble_ll_hci.c b/nimble/controller/src/ble_ll_hci.c index 7bbc6774c..d36867291 100644 --- a/nimble/controller/src/ble_ll_hci.c +++ b/nimble/controller/src/ble_ll_hci.c @@ -322,8 +322,14 @@ ble_ll_hci_le_read_bufsize(uint8_t *rspbuf, uint8_t *rsplen) { struct ble_hci_le_rd_buf_size_rp *rp = (void *) rspbuf; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) rp->data_len = htole16(g_ble_ll_data.ll_acl_pkt_size); rp->data_packets = g_ble_ll_data.ll_num_acl_pkts; +#else + /* TODO check if can just not support this command */ + rp->data_len = 0; + rp->data_packets = 0; +#endif *rsplen = sizeof(*rp); return BLE_ERR_SUCCESS; @@ -410,6 +416,7 @@ ble_ll_hci_chk_phy_masks(uint8_t all_phys, uint8_t tx_phys, uint8_t rx_phys, * * @return int */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) static int ble_ll_hci_le_set_def_phy(const uint8_t *cmdbuf, uint8_t len) { @@ -426,6 +433,7 @@ ble_ll_hci_le_set_def_phy(const uint8_t *cmdbuf, uint8_t len) return rc; } #endif +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_DATA_LEN_EXT) /** @@ -658,6 +666,7 @@ ble_ll_hci_le_cmd_send_cmd_status(uint16_t ocf) } #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) /** HCI LE read maximum advertising data length command. Returns the controllers * max supported advertising data length; * @@ -695,6 +704,7 @@ ble_ll_adv_rd_sup_adv_sets(uint8_t *rspbuf, uint8_t *rsplen) *rsplen = sizeof(*rsp); return BLE_ERR_SUCCESS; } +#endif static bool ble_ll_is_valid_adv_mode(uint8_t ocf) @@ -887,6 +897,7 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, rc = ble_ll_set_random_addr(cmdbuf, len, false); #endif break; +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) case BLE_HCI_OCF_LE_SET_ADV_PARAMS: rc = ble_ll_adv_set_adv_params(cmdbuf, len); break; @@ -904,12 +915,15 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, case BLE_HCI_OCF_LE_SET_ADV_ENABLE: rc = ble_ll_hci_adv_set_enable(cmdbuf, len); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) case BLE_HCI_OCF_LE_SET_SCAN_PARAMS: rc = ble_ll_scan_hci_set_params(cmdbuf, len); break; case BLE_HCI_OCF_LE_SET_SCAN_ENABLE: rc = ble_ll_scan_hci_set_enable(cmdbuf, len); break; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_HCI_OCF_LE_CREATE_CONN: rc = ble_ll_conn_hci_create(cmdbuf, len); break; @@ -918,6 +932,8 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, rc = ble_ll_conn_create_cancel(cb); } break; +#endif +#endif case BLE_HCI_OCF_LE_RD_WHITE_LIST_SIZE: if (len == 0) { rc = ble_ll_whitelist_read_size(rspbuf, rsplen); @@ -934,18 +950,22 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, case BLE_HCI_OCF_LE_RMV_WHITE_LIST: rc = ble_ll_whitelist_rmv(cmdbuf, len); break; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_HCI_OCF_LE_CONN_UPDATE: rc = ble_ll_conn_hci_update(cmdbuf, len); break; +#endif case BLE_HCI_OCF_LE_SET_HOST_CHAN_CLASS: rc = ble_ll_conn_hci_set_chan_class(cmdbuf, len); break; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_HCI_OCF_LE_RD_CHAN_MAP: rc = ble_ll_conn_hci_rd_chan_map(cmdbuf, len, rspbuf, rsplen); break; case BLE_HCI_OCF_LE_RD_REM_FEAT: rc = ble_ll_conn_hci_read_rem_features(cmdbuf, len); break; +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) case BLE_HCI_OCF_LE_ENCRYPT: rc = ble_ll_hci_le_encrypt(cmdbuf, len, rspbuf, rsplen); @@ -957,15 +977,19 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, } break; #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_HCI_OCF_LE_START_ENCRYPT: rc = ble_ll_conn_hci_le_start_encrypt(cmdbuf, len); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) case BLE_HCI_OCF_LE_LT_KEY_REQ_REPLY: rc = ble_ll_conn_hci_le_ltk_reply(cmdbuf, len, rspbuf, rsplen); break; case BLE_HCI_OCF_LE_LT_KEY_REQ_NEG_REPLY: rc = ble_ll_conn_hci_le_ltk_neg_reply(cmdbuf, len, rspbuf, rsplen); break; +#endif #endif case BLE_HCI_OCF_LE_RD_SUPP_STATES : if (len == 0) { @@ -985,12 +1009,14 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, } break; #endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_HCI_OCF_LE_REM_CONN_PARAM_RR: rc = ble_ll_conn_hci_param_rr(cmdbuf, len, rspbuf, rsplen); break; case BLE_HCI_OCF_LE_REM_CONN_PARAM_NRR: rc = ble_ll_conn_hci_param_nrr(cmdbuf, len, rspbuf, rsplen); break; +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_DATA_LEN_EXT) case BLE_HCI_OCF_LE_SET_DATA_LEN: rc = ble_ll_conn_hci_set_data_len(cmdbuf, len, rspbuf, rsplen); @@ -1042,6 +1068,7 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, break; #endif #if (BLE_LL_BT5_PHY_SUPPORTED == 1) +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_HCI_OCF_LE_RD_PHY: rc = ble_ll_conn_hci_le_rd_phy(cmdbuf, len, rspbuf, rsplen); break; @@ -1052,6 +1079,7 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, rc = ble_ll_conn_hci_le_set_phy(cmdbuf, len); break; #endif +#endif #if MYNEWT_VAL(BLE_LL_DTM) case BLE_HCI_OCF_LE_RX_TEST_V2: rc = ble_ll_hci_dtm_rx_test_v2(cmdbuf, len); @@ -1060,6 +1088,7 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, rc = ble_ll_hci_dtm_tx_test_v2(cmdbuf, len); break; #endif +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) case BLE_HCI_OCF_LE_SET_ADV_SET_RND_ADDR: rc = ble_ll_adv_hci_set_random_addr(cmdbuf, len); @@ -1106,6 +1135,8 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, break; #endif #endif +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) case BLE_HCI_OCF_LE_SET_EXT_SCAN_PARAM: rc = ble_ll_scan_hci_set_ext_params(cmdbuf, len); @@ -1113,10 +1144,12 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, case BLE_HCI_OCF_LE_SET_EXT_SCAN_ENABLE: rc = ble_ll_scan_hci_set_ext_enable(cmdbuf, len); break; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_HCI_OCF_LE_EXT_CREATE_CONN: rc = ble_ll_conn_hci_ext_create(cmdbuf, len); break; #endif +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) case BLE_HCI_OCF_LE_PERIODIC_ADV_CREATE_SYNC: rc = ble_ll_sync_create(cmdbuf, len); @@ -1150,6 +1183,7 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, rc = ble_ll_sync_receive_enable(cmdbuf, len); break; #endif +#endif #endif case BLE_HCI_OCF_LE_RD_TRANSMIT_POWER: if (len == 0) { @@ -1170,12 +1204,16 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, break; #endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV_SYNC_TRANSFER) +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) case BLE_HCI_OCF_LE_PERIODIC_ADV_SYNC_TRANSFER: rc = ble_ll_sync_transfer(cmdbuf, len, rspbuf, rsplen); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) case BLE_HCI_OCF_LE_PERIODIC_ADV_SET_INFO_TRANSFER: rc = ble_ll_adv_periodic_set_info_transfer(cmdbuf, len, rspbuf, rsplen); break; +#endif case BLE_HCI_OCF_LE_PERIODIC_ADV_SYNC_TRANSFER_PARAMS: rc = ble_ll_set_sync_transfer_params(cmdbuf, len, rspbuf, rsplen); break; @@ -1274,6 +1312,7 @@ ble_ll_hci_le_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf, return rc; } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) static int ble_ll_hci_disconnect(const uint8_t *cmdbuf, uint8_t len) { @@ -1293,6 +1332,7 @@ ble_ll_hci_disconnect(const uint8_t *cmdbuf, uint8_t len) return ble_ll_conn_hci_disconnect_cmd(cmd); } +#endif /** * Process a link control command sent from the host to the controller. The HCI @@ -1313,18 +1353,18 @@ ble_ll_hci_link_ctrl_cmd_proc(const uint8_t *cmdbuf, uint8_t len, uint16_t ocf) int rc; switch (ocf) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) case BLE_HCI_OCF_DISCONNECT_CMD: rc = ble_ll_hci_disconnect(cmdbuf, len); /* Send command status instead of command complete */ rc += (BLE_ERR_MAX + 1); break; - case BLE_HCI_OCF_RD_REM_VER_INFO: rc = ble_ll_conn_hci_rd_rem_ver_cmd(cmdbuf, len); /* Send command status instead of command complete */ rc += (BLE_ERR_MAX + 1); break; - +#endif default: rc = BLE_ERR_UNKNOWN_HCI_CMD; break; @@ -1518,9 +1558,11 @@ ble_ll_hci_status_params_cmd_proc(const uint8_t *cmdbuf, uint8_t len, int rc; switch (ocf) { +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_HCI_OCF_RD_RSSI: rc = ble_ll_conn_hci_rd_rssi(cmdbuf, len, rspbuf, rsplen); break; +#endif default: rc = BLE_ERR_UNKNOWN_HCI_CMD; break; @@ -1705,7 +1747,12 @@ ble_ll_hci_cmd_rx(uint8_t *cmdbuf, void *arg) int ble_ll_hci_acl_rx(struct os_mbuf *om, void *arg) { +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) ble_ll_acl_data_in(om); +#else + /* host should never send ACL in that case but if it does just ignore it */ + os_mbuf_free_chain(om); +#endif return 0; } diff --git a/nimble/controller/src/ble_ll_resolv.c b/nimble/controller/src/ble_ll_resolv.c index f85e26a8a..86f8ea783 100644 --- a/nimble/controller/src/ble_ll_resolv.c +++ b/nimble/controller/src/ble_ll_resolv.c @@ -50,14 +50,31 @@ struct ble_ll_resolv_entry g_ble_ll_resolv_list[MYNEWT_VAL(BLE_LL_RESOLV_LIST_SI static int ble_ll_is_controller_busy(void) { -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) && MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) if (ble_ll_sync_enabled()) { return 1; } #endif - return ble_ll_adv_enabled() || ble_ll_scan_enabled() || - g_ble_ll_conn_create_sm.connsm; +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) + if (ble_ll_adv_enabled()) { + return 1; + } +#endif + +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) + if (ble_ll_scan_enabled()) { + return 1; + } +#endif + +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + if (g_ble_ll_conn_create_sm.connsm) { + return 1; + } +#endif + + return 0; } /** * Called to determine if a change is allowed to the resolving list at this @@ -155,7 +172,9 @@ ble_ll_resolv_rpa_timer_cb(struct ble_npl_event *ev) ble_npl_callout_reset(&g_ble_ll_resolv_data.rpa_timer, g_ble_ll_resolv_data.rpa_tmo); +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) ble_ll_adv_rpa_timeout(); +#endif } /** diff --git a/nimble/controller/src/ble_ll_scan.c b/nimble/controller/src/ble_ll_scan.c index 6e78f3245..987ab463f 100644 --- a/nimble/controller/src/ble_ll_scan.c +++ b/nimble/controller/src/ble_ll_scan.c @@ -43,6 +43,8 @@ #include "controller/ble_ll_sync.h" #include "ble_ll_conn_priv.h" +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) + /* * XXX: * 1) I think I can guarantee that we dont process things out of order if @@ -879,7 +881,9 @@ ble_ll_scan_sm_stop(int chk_disable) OS_ENTER_CRITICAL(sr); +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) scansm->connsm = NULL; +#endif /* Disable scanning state machine */ scansm->scan_enabled = 0; @@ -1087,12 +1091,20 @@ ble_ll_scan_event_proc(struct ble_npl_event *ev) */ start_scan = inside_window; switch (ble_ll_state_get()) { +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) case BLE_LL_STATE_ADV: +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_LL_STATE_CONNECTION: +#endif +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) case BLE_LL_STATE_SYNC: +#endif +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) case BLE_LL_STATE_SCAN_AUX: start_scan = false; break; +#endif case BLE_LL_STATE_SCANNING: /* Must disable PHY since we will move to a new channel */ ble_phy_disable(); @@ -1184,6 +1196,7 @@ ble_ll_scan_rx_isr_start(uint8_t pdu_type, uint16_t *rxflags) } break; #endif +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_SCAN_TYPE_INITIATE: if ((pdu_type == BLE_ADV_PDU_TYPE_ADV_IND) || (pdu_type == BLE_ADV_PDU_TYPE_ADV_DIRECT_IND)) { @@ -1197,6 +1210,7 @@ ble_ll_scan_rx_isr_start(uint8_t pdu_type, uint16_t *rxflags) } #endif break; +#endif default: break; } @@ -1342,6 +1356,7 @@ ble_ll_scan_rx_filter(uint8_t own_addr_type, uint8_t scan_filt_policy, return 0; } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) int ble_ll_scan_rx_check_init(struct ble_ll_scan_addr_data *addrd) { @@ -1364,6 +1379,7 @@ ble_ll_scan_rx_check_init(struct ble_ll_scan_addr_data *addrd) return 0; } +#endif static int ble_ll_scan_rx_isr_end_on_adv(uint8_t pdu_type, uint8_t *rxbuf, @@ -1388,6 +1404,7 @@ ble_ll_scan_rx_isr_end_on_adv(uint8_t pdu_type, uint8_t *rxbuf, return 0; } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if ((scanp->scan_type == BLE_SCAN_TYPE_INITIATE) && !(scansm->scan_filt_policy & 0x01)) { rc = ble_ll_scan_rx_check_init(addrd); @@ -1395,6 +1412,7 @@ ble_ll_scan_rx_isr_end_on_adv(uint8_t pdu_type, uint8_t *rxbuf, return 0; } } +#endif rxinfo->flags |= BLE_MBUF_HDR_F_DEVMATCH; #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) @@ -1415,10 +1433,19 @@ ble_ll_scan_rx_isr_end_on_adv(uint8_t pdu_type, uint8_t *rxbuf, /* Allow responding to all PDUs when initiating since unwanted PDUs were * already filtered out in isr_start. */ - return ((scanp->scan_type == BLE_SCAN_TYPE_ACTIVE) && - ((pdu_type == BLE_ADV_PDU_TYPE_ADV_IND) || - (pdu_type == BLE_ADV_PDU_TYPE_ADV_SCAN_IND))) || - (scanp->scan_type == BLE_SCAN_TYPE_INITIATE); + if ((scanp->scan_type == BLE_SCAN_TYPE_ACTIVE) && + ((pdu_type == BLE_ADV_PDU_TYPE_ADV_IND) || + (pdu_type == BLE_ADV_PDU_TYPE_ADV_SCAN_IND))) { + return 1; + } + +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + if (scanp->scan_type == BLE_SCAN_TYPE_INITIATE) { + return 1; + } +#endif + + return 0; } static int @@ -1599,12 +1626,14 @@ ble_ll_scan_rx_isr_end(struct os_mbuf *rxpdu, uint8_t crcok) return 0; } break; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_SCAN_TYPE_INITIATE: if (ble_ll_conn_send_connect_req(rxpdu, &addrd, 0) == 0) { hdr->rxinfo.flags |= BLE_MBUF_HDR_F_CONNECT_IND_TXD; return 0; } break; +#endif } } @@ -1924,14 +1953,15 @@ ble_ll_scan_rx_pkt_in_on_legacy(uint8_t pdu_type, struct os_mbuf *om, void ble_ll_scan_rx_pkt_in(uint8_t ptype, struct os_mbuf *om, struct ble_mbuf_hdr *hdr) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) struct ble_mbuf_hdr_rxinfo *rxinfo; + uint8_t *targeta; +#endif struct ble_ll_scan_sm *scansm; struct ble_ll_scan_addr_data addrd; - uint8_t *targeta; uint8_t max_pdu_type; scansm = &g_ble_ll_scan_sm; - rxinfo = &hdr->rxinfo; /* Ignore PDUs we do not expect here */ max_pdu_type = BLE_ADV_PDU_TYPE_ADV_SCAN_IND; @@ -1954,7 +1984,10 @@ ble_ll_scan_rx_pkt_in(uint8_t ptype, struct os_mbuf *om, struct ble_mbuf_hdr *hd } #endif - if (scansm->scanp->scan_type == BLE_SCAN_TYPE_INITIATE) { + switch (scansm->scanp->scan_type) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_SCAN_TYPE_INITIATE: + rxinfo = &hdr->rxinfo; if (rxinfo->flags & BLE_MBUF_HDR_F_CONNECT_IND_TXD) { /* We need to keep original TargetA in case it was resolved, so rl * can be updated properly. @@ -1967,8 +2000,11 @@ ble_ll_scan_rx_pkt_in(uint8_t ptype, struct os_mbuf *om, struct ble_mbuf_hdr *hd ble_ll_conn_created_on_legacy(om, &addrd, targeta); return; } - } else { + break; +#endif + default: ble_ll_scan_rx_pkt_in_on_legacy(ptype, om, hdr, &addrd); + break; } ble_ll_scan_chk_resume(); @@ -2290,6 +2326,7 @@ ble_ll_scan_set_enable(uint8_t enable, uint8_t filter_dups, uint16_t period, /* if already enable we just need to update parameters */ if (scansm->scan_enabled) { /* Controller does not allow initiating and scanning.*/ +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) for (i = 0; i < BLE_LL_SCAN_PHY_NUMBER; i++) { scanp_phy = &scansm->scan_phys[i]; if (scanp_phy->configured && @@ -2297,6 +2334,7 @@ ble_ll_scan_set_enable(uint8_t enable, uint8_t filter_dups, uint16_t period, return BLE_ERR_CMD_DISALLOWED; } } +#endif #if MYNEWT_VAL(BLE_LL_NUM_SCAN_DUP_ADVS) /* update filter policy */ @@ -2426,6 +2464,7 @@ ble_ll_scan_can_chg_whitelist(void) return rc; } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) int ble_ll_scan_initiator_start(struct ble_ll_conn_sm *connsm, uint8_t ext, struct ble_ll_conn_create_scan *cc_scan) @@ -2504,6 +2543,7 @@ ble_ll_scan_initiator_start(struct ble_ll_conn_sm *connsm, uint8_t ext, return rc; } +#endif /** * Checks to see if the scanner is enabled. @@ -2679,3 +2719,5 @@ ble_ll_scan_init(void) ble_ll_scan_aux_init(); #endif } + +#endif diff --git a/nimble/controller/src/ble_ll_scan_aux.c b/nimble/controller/src/ble_ll_scan_aux.c index f1e56bd3e..69ab10cde 100644 --- a/nimble/controller/src/ble_ll_scan_aux.c +++ b/nimble/controller/src/ble_ll_scan_aux.c @@ -19,7 +19,7 @@ #include -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) && MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) #include #include @@ -670,9 +670,11 @@ ble_ll_scan_aux_break_ev(struct ble_npl_event *ev) void ble_ll_scan_aux_break(struct ble_ll_scan_aux_data *aux) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (aux->flags & BLE_LL_SCAN_AUX_F_W4_CONNECT_RSP) { ble_ll_conn_send_connect_req_cancel(); } +#endif ble_npl_event_init(&aux->break_ev, ble_ll_scan_aux_break_ev, aux); ble_ll_event_send(&aux->break_ev); @@ -1069,9 +1071,11 @@ ble_ll_scan_aux_rx_isr_end_on_ext(struct ble_ll_scan_sm *scansm, aux->adi = adi; aux->flags |= BLE_LL_SCAN_AUX_F_HAS_ADI; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (aux->scan_type == BLE_SCAN_TYPE_INITIATE) { aux->flags |= BLE_LL_SCAN_AUX_F_CONNECTABLE; } +#endif if (do_match) { aux->flags |= BLE_LL_SCAN_AUX_F_MATCHED; @@ -1304,6 +1308,7 @@ ble_ll_scan_aux_rx_isr_end(struct os_mbuf *rxpdu, uint8_t crcok) goto done; } +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if ((aux->scan_type == BLE_SCAN_TYPE_INITIATE) && !(scan_filt_policy & 0x01)) { rc = ble_ll_scan_rx_check_init(&addrd); @@ -1312,6 +1317,7 @@ ble_ll_scan_aux_rx_isr_end(struct os_mbuf *rxpdu, uint8_t crcok) goto done; } } +#endif aux->flags |= BLE_LL_SCAN_AUX_F_MATCHED; @@ -1330,6 +1336,7 @@ ble_ll_scan_aux_rx_isr_end(struct os_mbuf *rxpdu, uint8_t crcok) return 0; } break; +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) case BLE_SCAN_TYPE_INITIATE: if (ble_ll_conn_send_connect_req(rxpdu, &addrd, 1) == 0) { /* AUX_CONNECT_REQ sent, keep PHY enabled to continue */ @@ -1341,6 +1348,9 @@ ble_ll_scan_aux_rx_isr_end(struct os_mbuf *rxpdu, uint8_t crcok) rxinfo->flags |= BLE_MBUF_HDR_F_IGNORED; } break; +#endif + default: + break; } done: @@ -1456,7 +1466,7 @@ ble_ll_scan_aux_sync_check(struct os_mbuf *rxpdu, } #endif - +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) static int ble_ll_scan_aux_check_connect_rsp(uint8_t *rxbuf, struct ble_ll_scan_pdu_data *pdu_data, @@ -1586,6 +1596,7 @@ done: } ble_ll_scan_aux_free(aux); } +#endif void ble_ll_scan_aux_rx_pkt_in(struct os_mbuf *rxpdu, struct ble_mbuf_hdr *rxhdr) @@ -1604,10 +1615,12 @@ ble_ll_scan_aux_rx_pkt_in(struct os_mbuf *rxpdu, struct ble_mbuf_hdr *rxhdr) BLE_LL_ASSERT(aux); +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) if (aux->scan_type == BLE_SCAN_TYPE_INITIATE) { ble_ll_scan_aux_rx_pkt_in_for_initiator(rxpdu, rxhdr); return; } +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) sync_check = ble_ll_sync_enabled() && @@ -1745,4 +1758,4 @@ ble_ll_scan_aux_init(void) BLE_LL_ASSERT(err == 0); } -#endif /* BLE_LL_CFG_FEAT_LL_EXT_ADV */ \ No newline at end of file +#endif /* BLE_LL_CFG_FEAT_LL_EXT_ADV */ diff --git a/nimble/controller/src/ble_ll_sched.c b/nimble/controller/src/ble_ll_sched.c index 0a9be9c8a..fe47dbc62 100644 --- a/nimble/controller/src/ble_ll_sched.c +++ b/nimble/controller/src/ble_ll_sched.c @@ -112,7 +112,9 @@ ble_ll_sched_preempt(struct ble_ll_sched_item *sch, { struct ble_ll_sched_item *entry; struct ble_ll_sched_item *next; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) struct ble_ll_conn_sm *connsm; +#endif entry = first; @@ -123,25 +125,33 @@ ble_ll_sched_preempt(struct ble_ll_sched_item *sch, entry->enqueued = 0; switch (entry->sched_type) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) case BLE_LL_SCHED_TYPE_CONN: connsm = (struct ble_ll_conn_sm *)entry->cb_arg; ble_ll_event_send(&connsm->conn_ev_end); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) case BLE_LL_SCHED_TYPE_ADV: ble_ll_adv_event_rmvd_from_sched(entry->cb_arg); break; -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) +#endif +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) && MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) case BLE_LL_SCHED_TYPE_SCAN_AUX: ble_ll_scan_aux_break(entry->cb_arg); break; #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) case BLE_LL_SCHED_TYPE_PERIODIC: ble_ll_adv_periodic_rmvd_from_sched(entry->cb_arg); break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) case BLE_LL_SCHED_TYPE_SYNC: ble_ll_sync_rmvd_from_sched(entry->cb_arg); break; #endif +#endif #endif default: BLE_LL_ASSERT(0); @@ -302,16 +312,17 @@ ble_ll_sched_is_overlap(struct ble_ll_sched_item *s1, static int ble_ll_sched_overlaps_current(struct ble_ll_sched_item *sch) { - int rc; + int rc = 0; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) uint32_t ce_end_time; - rc = 0; if (ble_ll_state_get() == BLE_LL_STATE_CONNECTION) { ce_end_time = ble_ll_conn_get_ce_end_time(); if (CPUTIME_GT(ce_end_time, sch->start_time)) { rc = 1; } } +#endif return rc; } @@ -334,7 +345,9 @@ int ble_ll_sched_conn_reschedule(struct ble_ll_conn_sm *connsm) { struct ble_ll_sched_item *sch; +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) uint32_t usecs; +#endif os_sr_t sr; int rc; @@ -343,13 +356,24 @@ ble_ll_sched_conn_reschedule(struct ble_ll_conn_sm *connsm) /* Set schedule start and end times */ sch->start_time = connsm->anchor_point - g_ble_ll_sched_offset_ticks; - if (connsm->conn_role == BLE_LL_CONN_ROLE_SLAVE) { + switch (connsm->conn_role) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) + case BLE_LL_CONN_ROLE_MASTER: + sch->remainder = connsm->anchor_point_usecs; + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_CONN_ROLE_SLAVE: usecs = connsm->slave_cur_window_widening; sch->start_time -= (os_cputime_usecs_to_ticks(usecs) + 1); sch->remainder = 0; - } else { - sch->remainder = connsm->anchor_point_usecs; + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } + sch->end_time = connsm->ce_end_time; /* Better be past current time or we just leave */ @@ -802,7 +826,7 @@ usecs_to_ticks_fast(uint32_t usecs) } #endif -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) && MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) /* * Determines if the schedule item overlaps the currently running schedule * item. This function cares about connection and sync. @@ -815,9 +839,11 @@ ble_ll_sched_sync_overlaps_current(struct ble_ll_sched_item *sch) state = ble_ll_state_get(); switch (state) { +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) case BLE_LL_STATE_CONNECTION: end_time = ble_ll_conn_get_ce_end_time(); break; +#endif case BLE_LL_STATE_SYNC: end_time = ble_ll_sync_get_event_end_time(); break; @@ -1037,10 +1063,24 @@ ble_ll_sched_adv_resched_pdu(struct ble_ll_sched_item *sch) OS_ENTER_CRITICAL(sr); lls = ble_ll_state_get(); - if ((lls == BLE_LL_STATE_ADV) || (lls == BLE_LL_STATE_CONNECTION) || - (lls == BLE_LL_STATE_SYNC)) { + switch(lls) { +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) + case BLE_LL_STATE_ADV: OS_EXIT_CRITICAL(sr); return -1; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_STATE_CONNECTION: + OS_EXIT_CRITICAL(sr); + return -1; +#endif +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) && MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) + case BLE_LL_STATE_SYNC: + OS_EXIT_CRITICAL(sr); + return -1; +#endif + default: + break; } rc = ble_ll_sched_insert(sch, 0, preempt_none); @@ -1161,25 +1201,40 @@ ble_ll_sched_execute_item(struct ble_ll_sched_item *sch) /* We have to disable the PHY no matter what */ ble_phy_disable(); - if (lls == BLE_LL_STATE_SCANNING) { + switch (lls) { +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) + case BLE_LL_STATE_SCANNING: ble_ll_state_set(BLE_LL_STATE_STANDBY); ble_ll_scan_halt(); - } else if (lls == BLE_LL_STATE_ADV) { - STATS_INC(ble_ll_stats, sched_state_adv_errs); - ble_ll_adv_halt(); + break; #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) - } else if (lls == BLE_LL_STATE_SYNC) { + case BLE_LL_STATE_SYNC: STATS_INC(ble_ll_stats, sched_state_sync_errs); ble_ll_sync_halt(); + break; #endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) - } else if (lls == BLE_LL_STATE_SCAN_AUX) { + case BLE_LL_STATE_SCAN_AUX: ble_ll_state_set(BLE_LL_STATE_STANDBY); ble_ll_scan_aux_halt(); + break; #endif - } else { +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) + case BLE_LL_STATE_ADV: + STATS_INC(ble_ll_stats, sched_state_adv_errs); + ble_ll_adv_halt(); + break; +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) || MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) + case BLE_LL_STATE_CONNECTION: STATS_INC(ble_ll_stats, sched_state_conn_errs); ble_ll_conn_event_halt(); + break; +#endif + default: + BLE_LL_ASSERT(0); + break; } sched: diff --git a/nimble/controller/src/ble_ll_supp_cmd.c b/nimble/controller/src/ble_ll_supp_cmd.c index 6ceeaebb0..2fc0d7d3a 100644 --- a/nimble/controller/src/ble_ll_supp_cmd.c +++ b/nimble/controller/src/ble_ll_supp_cmd.c @@ -27,7 +27,11 @@ #include "controller/ble_ll_hci.h" /* Octet 0 */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_SUPP_CMD_DISCONNECT (1 << 5) +#else +#define BLE_SUPP_CMD_DISCONNECT (0 << 5) +#endif #define BLE_LL_SUPP_CMD_OCTET_0 (BLE_SUPP_CMD_DISCONNECT) /* Octet 5 */ @@ -64,7 +68,12 @@ /* Octet 15 */ #define BLE_SUPP_CMD_RD_BD_ADDR (1 << 1) + +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_SUPP_CMD_RD_RSSI (1 << 5) +#else +#define BLE_SUPP_CMD_RD_RSSI (0 << 5) +#endif #define BLE_LL_SUPP_CMD_OCTET_15 \ ( \ @@ -77,9 +86,15 @@ #define BLE_SUPP_CMD_LE_RD_BUF_SIZE (1 << 1) #define BLE_SUPP_CMD_LE_RD_LOC_FEAT (1 << 2) #define BLE_SUPP_CMD_LE_SET_RAND_ADDR (1 << 4) +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) #define BLE_SUPP_CMD_LE_SET_ADV_PARAMS (1 << 5) #define BLE_SUPP_CMD_LE_SET_ADV_TX_PWR (1 << 6) #define BLE_SUPP_CMD_LE_SET_ADV_DATA (1 << 7) +#else +#define BLE_SUPP_CMD_LE_SET_ADV_PARAMS (0 << 5) +#define BLE_SUPP_CMD_LE_SET_ADV_TX_PWR (0 << 6) +#define BLE_SUPP_CMD_LE_SET_ADV_DATA (0 << 7) +#endif #define BLE_LL_SUPP_CMD_OCTET_25 \ ( \ @@ -93,12 +108,28 @@ ) /* Octet 26 */ +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) #define BLE_SUPP_CMD_LE_SET_SCAN_RSP_DATA (1 << 0) #define BLE_SUPP_CMD_LE_SET_ADV_ENABLE (1 << 1) +#else +#define BLE_SUPP_CMD_LE_SET_SCAN_RSP_DATA (0 << 0) +#define BLE_SUPP_CMD_LE_SET_ADV_ENABLE (0 << 1) +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) #define BLE_SUPP_CMD_LE_SET_SCAN_PARAMS (1 << 2) #define BLE_SUPP_CMD_LE_SET_SCAN_ENABLE (1 << 3) +#else +#define BLE_SUPP_CMD_LE_SET_SCAN_PARAMS (0 << 2) +#define BLE_SUPP_CMD_LE_SET_SCAN_ENABLE (0 << 3) +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_SUPP_CMD_LE_CREATE_CONN (1 << 4) #define BLE_SUPP_CMD_LE_CREATE_CONN_CANCEL (1 << 5) +#else +#define BLE_SUPP_CMD_LE_CREATE_CONN (0 << 4) +#define BLE_SUPP_CMD_LE_CREATE_CONN_CANCEL (0 << 5) + +#endif #define BLE_SUPP_CMD_LE_RD_WHITELIST_SIZE (1 << 6) #define BLE_SUPP_CMD_LE_CLR_WHITELIST (1 << 7) @@ -117,10 +148,19 @@ /* Octet 27 */ #define BLE_SUPP_CMD_LE_ADD_DEV_WHITELIST (1 << 0) #define BLE_SUPP_CMD_LE_RMV_DEV_WHITELIST (1 << 1) +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_SUPP_CMD_LE_CONN_UPDATE (1 << 2) +#else +#define BLE_SUPP_CMD_LE_CONN_UPDATE (0 << 2) +#endif #define BLE_SUPP_CMD_LE_SET_HOST_CHAN_CLASS (1 << 3) +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_SUPP_CMD_LE_RD_CHAN_MAP (1 << 4) #define BLE_SUPP_CMD_LE_RD_REM_USED_FEAT (1 << 5) +#else +#define BLE_SUPP_CMD_LE_RD_CHAN_MAP (0 << 4) +#define BLE_SUPP_CMD_LE_RD_REM_USED_FEAT (0 << 5) +#endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) #define BLE_SUPP_CMD_LE_ENCRYPT (1 << 6) #else @@ -142,10 +182,19 @@ /* Octet 28 */ #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_SUPP_CMD_LE_START_ENCRYPT (1 << 0) +#else +#define BLE_SUPP_CMD_LE_START_ENCRYPT (0 << 0) +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) #define BLE_SUPP_CMD_LE_LTK_REQ_REPLY (1 << 1) #define BLE_SUPP_CMD_LE_LTK_REQ_NEG_REPLY (1 << 2) #else +#define BLE_SUPP_CMD_LE_LTK_REQ_REPLY (0 << 1) +#define BLE_SUPP_CMD_LE_LTK_REQ_NEG_REPLY (0 << 2) +#endif +#else #define BLE_SUPP_CMD_LE_START_ENCRYPT (0 << 0) #define BLE_SUPP_CMD_LE_LTK_REQ_REPLY (0 << 1) #define BLE_SUPP_CMD_LE_LTK_REQ_NEG_REPLY (0 << 2) @@ -175,6 +224,7 @@ ) /* Octet 33 */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_SUPP_CMD_LE_REM_CONN_PRR (1 << 4) #define BLE_SUPP_CMD_LE_REM_CONN_PRNR (1 << 5) #if MYNEWT_VAL(BLE_LL_CFG_FEAT_DATA_LEN_EXT) @@ -184,6 +234,13 @@ #define BLE_SUPP_CMD_LE_SET_DATALEN (0 << 6) #define BLE_SUPP_CMD_LE_RD_SUGG_DATALEN (0 << 7) #endif +#else +#define BLE_SUPP_CMD_LE_REM_CONN_PRR (0 << 4) +#define BLE_SUPP_CMD_LE_REM_CONN_PRNR (0 << 5) +#define BLE_SUPP_CMD_LE_SET_DATALEN (0 << 6) +#define BLE_SUPP_CMD_LE_RD_SUGG_DATALEN (0 << 7) +#endif + #define BLE_LL_SUPP_CMD_OCTET_33 \ ( \ @@ -194,11 +251,15 @@ ) /* Octet 34 */ +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #if MYNEWT_VAL(BLE_LL_CFG_FEAT_DATA_LEN_EXT) #define BLE_SUPP_CMD_LE_WR_SUGG_DATALEN (1 << 0) #else #define BLE_SUPP_CMD_LE_WR_SUGG_DATALEN (0 << 0) #endif +#else +#define BLE_SUPP_CMD_LE_WR_SUGG_DATALEN (0 << 0) +#endif #define BLE_SUPP_CMD_LE_READ_LOCAL_P256_PK (0 << 1) #define BLE_SUPP_CMD_LE_GENERATE_DH_KEY (0 << 2) #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) @@ -239,6 +300,7 @@ #endif #define BLE_SUPP_CMD_LE_RD_MAX_DATALEN (1 << 3) #if (BLE_LL_BT5_PHY_SUPPORTED == 1) +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_SUPP_CMD_LE_READ_PHY (1 << 4) #define BLE_SUPP_CMD_LE_SET_DEFAULT_PHY (1 << 5) #define BLE_SUPP_CMD_LE_SET_PHY (1 << 6) @@ -247,6 +309,11 @@ #define BLE_SUPP_CMD_LE_SET_DEFAULT_PHY (0 << 5) #define BLE_SUPP_CMD_LE_SET_PHY (0 << 6) #endif +#else +#define BLE_SUPP_CMD_LE_READ_PHY (0 << 4) +#define BLE_SUPP_CMD_LE_SET_DEFAULT_PHY (0 << 5) +#define BLE_SUPP_CMD_LE_SET_PHY (0 << 6) +#endif #if MYNEWT_VAL(BLE_LL_DTM) #define BLE_SUPP_CMD_LE_ENHANCED_RX_TEST (1 << 7) @@ -273,7 +340,7 @@ #define BLE_SUPP_CMD_LE_ENHANCED_TX_TEST (0 << 0) #endif -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) && MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) #define BLE_SUPP_CMD_LE_SET_ADVS_RAND_ADDR (1 << 1) #define BLE_SUPP_CMD_LE_SET_EXT_ADV_PARAM (1 << 2) #define BLE_SUPP_CMD_LE_SET_EXT_ADV_DATA (1 << 3) @@ -304,14 +371,14 @@ ) /* Octet 37 */ -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) && MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) #define BLE_SUPP_CMD_LE_REMOVE_ADVS (1 << 0) #define BLE_SUPP_CMD_LE_CLEAR_ADVS (1 << 1) #else #define BLE_SUPP_CMD_LE_REMOVE_ADVS (0 << 0) #define BLE_SUPP_CMD_LE_CLEAR_ADVS (0 << 1) #endif -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) && MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) #define BLE_SUPP_CMD_LE_SET_PADV_PARAM (1 << 2) #define BLE_SUPP_CMD_LE_SET_PADV_DATA (1 << 3) #define BLE_SUPP_CMD_LE_SET_PADV_ENABLE (1 << 4) @@ -321,10 +388,19 @@ #define BLE_SUPP_CMD_LE_SET_PADV_ENABLE (0 << 4) #endif #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) #define BLE_SUPP_CMD_LE_SET_EXT_SCAN_PARAM (1 << 5) #define BLE_SUPP_CMD_LE_SET_EXT_SCAN_ENABLE (1 << 6) +#else +#define BLE_SUPP_CMD_LE_SET_EXT_SCAN_PARAM (0 << 5) +#define BLE_SUPP_CMD_LE_SET_EXT_SCAN_ENABLE (0 << 6) +#endif +#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) #define BLE_SUPP_CMD_LE_EXT_CREATE_CONN (1 << 7) #else +#define BLE_SUPP_CMD_LE_EXT_CREATE_CONN (0 << 7) +#endif +#else #define BLE_SUPP_CMD_LE_SET_EXT_SCAN_PARAM (0 << 5) #define BLE_SUPP_CMD_LE_SET_EXT_SCAN_ENABLE (0 << 6) #define BLE_SUPP_CMD_LE_EXT_CREATE_CONN (0 << 7) @@ -343,7 +419,7 @@ ) /* Octet 38 */ -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) && MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) #define BLE_SUPP_CMD_LE_PADV_CREATE_SYNC (1 << 0) #define BLE_SUPP_CMD_LE_PADV_CREATE_SYNC_C (1 << 1) #define BLE_SUPP_CMD_LE_PADV_TERMINATE_SYNC (1 << 2) @@ -391,7 +467,8 @@ ) /* Octet 40 */ -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) && MYNEWT_VAL(BLE_VERSION) >= 51 +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) && MYNEWT_VAL(BLE_VERSION) >= 51 && \ + MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) #define BLE_SUPP_CMD_LE_PADV_RECV_ENABLE (1 << 5) #else #define BLE_SUPP_CMD_LE_PADV_RECV_ENABLE (0 << 5) diff --git a/nimble/controller/src/ble_ll_sync.c b/nimble/controller/src/ble_ll_sync.c index 4b2004953..7b6208ce1 100644 --- a/nimble/controller/src/ble_ll_sync.c +++ b/nimble/controller/src/ble_ll_sync.c @@ -41,7 +41,7 @@ #include "stats/stats.h" -#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) +#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV) && MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) /* defines number of events that can be lost during sync establishment * before failed to be established error is reported diff --git a/nimble/controller/src/ble_ll_whitelist.c b/nimble/controller/src/ble_ll_whitelist.c index 04ec6428b..12d841a7f 100644 --- a/nimble/controller/src/ble_ll_whitelist.c +++ b/nimble/controller/src/ble_ll_whitelist.c @@ -48,8 +48,6 @@ struct ble_ll_whitelist_entry g_ble_ll_whitelist[BLE_LL_WHITELIST_SIZE]; static int ble_ll_whitelist_chg_allowed(void) { - int rc; - /* * This command is not allowed if: * -> advertising uses the whitelist and we are currently advertising. @@ -57,11 +55,19 @@ ble_ll_whitelist_chg_allowed(void) * -> initiating uses whitelist and a LE create connection command is in * progress */ - rc = 1; - if (!ble_ll_adv_can_chg_whitelist() || !ble_ll_scan_can_chg_whitelist()) { - rc = 0; +#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER) + if (ble_ll_adv_can_chg_whitelist()) { + return 1; } - return rc; +#endif + +#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER) + if (ble_ll_scan_can_chg_whitelist()) { + return 1; + } +#endif + + return 0; } /** diff --git a/nimble/controller/syscfg.yml b/nimble/controller/syscfg.yml index 7c3324271..62c9c4ad9 100644 --- a/nimble/controller/syscfg.yml +++ b/nimble/controller/syscfg.yml @@ -23,6 +23,30 @@ syscfg.defs: this setting shall not be overriden. value: 1 + BLE_LL_ROLE_CENTRAL: + description: 'Enables controller support for the Central role.' + value: MYNEWT_VAL(BLE_ROLE_CENTRAL) + restrictions: + - 'BLE_LL_ROLE_OBSERVER if 1' + + BLE_LL_ROLE_PERIPHERAL: + description: 'Enables controller support for the Peripheral role.' + value: MYNEWT_VAL(BLE_ROLE_PERIPHERAL) + restrictions: + - 'BLE_LL_ROLE_BROADCASTER if 1' + + BLE_LL_ROLE_BROADCASTER: + description: 'Enables controller support for the Broadcaster role.' + value: MYNEWT_VAL(BLE_ROLE_BROADCASTER) + restrictions: + - 'BLE_LL_ROLE_OBSERVER if 0' + + BLE_LL_ROLE_OBSERVER: + description: 'Enables controller support for the Observer role.' + value: MYNEWT_VAL(BLE_ROLE_OBSERVER) + restrictions: + - 'BLE_LL_ROLE_BROADCASTER if 0' + BLE_HW_WHITELIST_ENABLE: description: > Used to enable hardware white list @@ -184,21 +208,21 @@ syscfg.defs: description: > This option enables/disables encryption support in the controller. This option saves both both code and RAM. - value: '1' + value: 'MYNEWT_VAL_BLE_LL_ROLE_CENTRAL || MYNEWT_VAL_BLE_LL_ROLE_PERIPHERAL' BLE_LL_CFG_FEAT_CONN_PARAM_REQ: description: > This option enables/disables the connection parameter request procedure. This is implemented in the controller but is disabled by default. - value: '1' + value: 'MYNEWT_VAL_BLE_LL_ROLE_CENTRAL || MYNEWT_VAL_BLE_LL_ROLE_PERIPHERAL' BLE_LL_CFG_FEAT_SLAVE_INIT_FEAT_XCHG: description: > This option allows a slave to initiate the feature exchange procedure. This feature is implemented but currently has no impact on code or ram size - value: '1' + value: 'MYNEWT_VAL_BLE_LL_ROLE_CENTRAL || MYNEWT_VAL_BLE_LL_ROLE_PERIPHERAL' BLE_LL_CFG_FEAT_LE_PING: description: > @@ -213,7 +237,7 @@ syscfg.defs: the controller. If enabled, the controller is allowed to change the size of tx/rx pdu's used in a connection. This option has only minor impact on code size and non on RAM. - value: '1' + value: 'MYNEWT_VAL_BLE_LL_ROLE_CENTRAL || MYNEWT_VAL_BLE_LL_ROLE_PERIPHERAL' BLE_LL_CFG_FEAT_LL_PRIVACY: description: > @@ -248,8 +272,6 @@ syscfg.defs: This option is used to enable/disable support for Periodic Advertising Feature. value: MYNEWT_VAL(BLE_PERIODIC_ADV) - restrictions: - - 'BLE_LL_CFG_FEAT_LL_EXT_ADV if 1' BLE_LL_CFG_FEAT_LL_PERIODIC_ADV_SYNC_CNT: description: > @@ -273,6 +295,8 @@ syscfg.defs: limit number of ACL packets sent at once from controller to avoid congestion on HCI transport if feature is also supported by host. value: 0 + restrictions: + - '(BLE_ROLE_CENTRAL || BLE_ROLE_PERIPHERAL) if 1' BLE_LL_CFG_FEAT_LL_SCA_UPDATE: description: > diff --git a/nimble/syscfg.yml b/nimble/syscfg.yml index b5cfc585d..32fbaf987 100644 --- a/nimble/syscfg.yml +++ b/nimble/syscfg.yml @@ -67,6 +67,7 @@ syscfg.defs: value: 0 restrictions: - 'BLE_PERIODIC_ADV if 1' + - '(BLE_ROLE_CENTRAL || BLE_ROLE_PERIPHERAL) if 1' BLE_EXT_ADV_MAX_SIZE: description: > diff --git a/nimble/transport/uart/src/ble_hci_uart.c b/nimble/transport/uart/src/ble_hci_uart.c index 2cad55a7d..ac49b30b0 100644 --- a/nimble/transport/uart/src/ble_hci_uart.c +++ b/nimble/transport/uart/src/ble_hci_uart.c @@ -755,7 +755,9 @@ ble_hci_uart_rx_skip_acl(uint8_t data) if (rxd_bytes == ble_hci_uart_state.rx_acl.len) { /* XXX: I dont like this but for now this denotes controller only */ #if MYNEWT_VAL(BLE_CONTROLLER) +#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL) ble_ll_data_buffer_overflow(); +#endif #endif ble_hci_uart_state.rx_type = BLE_HCI_UART_H4_NONE; }