You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by an...@apache.org on 2022/08/30 11:48:53 UTC
[mynewt-nimble] branch master updated (5a7f7df9 -> c9cbc3cb)
This is an automated email from the ASF dual-hosted git repository.
andk pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git
from 5a7f7df9 babblesim: Add syscfg def indicating BabbleSim bsp
new 87825c23 nimble/ll: Check advertising data length
new 933445d6 nimble/ll: Remove min/max interval from advsm
new e9e2ccfa nimble/ll: Use syscfg val to reserve slot for aux scan
new c9cbc3cb nimble/ll: Adjust names in adv structs
The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
nimble/controller/src/ble_ll_adv.c | 451 ++++++++++++++++++++------------
nimble/controller/src/ble_ll_scan_aux.c | 2 +-
2 files changed, 281 insertions(+), 172 deletions(-)
[mynewt-nimble] 03/04: nimble/ll: Use syscfg val to reserve slot for aux scan
Posted by an...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
andk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git
commit e9e2ccfa8a22184ce54a3150229e3d12b3e954fc
Author: Andrzej Kaczmarek <an...@codecoup.pl>
AuthorDate: Tue Aug 23 11:50:37 2022 +0200
nimble/ll: Use syscfg val to reserve slot for aux scan
Turns out we have syscfg val for aux scan payload, but we forgot to
use it.
---
nimble/controller/src/ble_ll_scan_aux.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/nimble/controller/src/ble_ll_scan_aux.c b/nimble/controller/src/ble_ll_scan_aux.c
index 56f1c528..ed69055b 100644
--- a/nimble/controller/src/ble_ll_scan_aux.c
+++ b/nimble/controller/src/ble_ll_scan_aux.c
@@ -756,7 +756,7 @@ ble_ll_scan_aux_sched(struct ble_ll_scan_aux_data *aux, uint32_t pdu_time,
return -1;
}
- max_aux_time_us = ble_ll_pdu_tx_time_get(BLE_LL_MAX_PAYLOAD_LEN,
+ max_aux_time_us = ble_ll_pdu_tx_time_get(MYNEWT_VAL(BLE_LL_SCHED_SCAN_AUX_PDU_LEN),
ble_ll_phy_to_phy_mode(aux->sec_phy, 0));
rc = ble_ll_sched_scan_aux(&aux->sch, pdu_time, pdu_time_rem, offset_us,
[mynewt-nimble] 02/04: nimble/ll: Remove min/max interval from advsm
Posted by an...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
andk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git
commit 933445d6c9b87b21a204a4c65daea71239209e88
Author: Andrzej Kaczmarek <an...@codecoup.pl>
AuthorDate: Tue Aug 23 00:50:30 2022 +0200
nimble/ll: Remove min/max interval from advsm
We don't use it anywhere, just need calculated interval.
---
nimble/controller/src/ble_ll_adv.c | 8 --------
1 file changed, 8 deletions(-)
diff --git a/nimble/controller/src/ble_ll_adv.c b/nimble/controller/src/ble_ll_adv.c
index 7e672fd1..c2057f70 100644
--- a/nimble/controller/src/ble_ll_adv.c
+++ b/nimble/controller/src/ble_ll_adv.c
@@ -106,8 +106,6 @@ struct ble_ll_adv_sm
int8_t adv_txpwr;
uint16_t flags;
uint16_t props;
- uint16_t adv_itvl_min;
- uint16_t adv_itvl_max;
uint32_t adv_itvl_usecs;
uint32_t adv_event_start_time;
uint32_t adv_pdu_start_time;
@@ -1903,8 +1901,6 @@ ble_ll_adv_set_adv_params(const uint8_t *cmdbuf, uint8_t len)
advsm->peer_addr_type = cmd->peer_addr_type;
advsm->adv_filter_policy = adv_filter_policy;
advsm->adv_chanmask = cmd->chan_map;
- advsm->adv_itvl_min = adv_itvl_min;
- advsm->adv_itvl_max = adv_itvl_max;
advsm->adv_itvl_usecs = adv_itvl_usecs;
advsm->props = props;
@@ -3543,8 +3539,6 @@ ble_ll_adv_ext_set_param(const uint8_t *cmdbuf, uint8_t len,
advsm->own_addr_type = cmd->own_addr_type;
advsm->adv_filter_policy = cmd->filter_policy;
advsm->adv_chanmask = cmd->pri_chan_map;
- advsm->adv_itvl_min = adv_itvl_min;
- advsm->adv_itvl_max = adv_itvl_max;
advsm->adv_itvl_usecs = adv_itvl_usecs;
advsm->pri_phy = cmd->pri_phy;
advsm->sec_phy = cmd->sec_phy;
@@ -5217,8 +5211,6 @@ ble_ll_adv_sm_init(struct ble_ll_adv_sm *advsm)
{
memset(advsm, 0, sizeof(struct ble_ll_adv_sm));
- advsm->adv_itvl_min = BLE_HCI_ADV_ITVL_DEF;
- advsm->adv_itvl_max = BLE_HCI_ADV_ITVL_DEF;
advsm->adv_chanmask = BLE_HCI_ADV_CHANMASK_DEF;
/* Initialize advertising tx done event */
[mynewt-nimble] 01/04: nimble/ll: Check advertising data length
Posted by an...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
andk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git
commit 87825c238e8cf48d1b43379b298cd6344ce83b46
Author: Andrzej Kaczmarek <an...@codecoup.pl>
AuthorDate: Tue Aug 23 00:07:27 2022 +0200
nimble/ll: Check advertising data length
This adds check for advertising/scan response data length when adding
data to advertising instance or changing instance parameters.
This fixes HCI/DDI/BI-62-C.
---
nimble/controller/src/ble_ll_adv.c | 312 +++++++++++++++++++++++++------------
1 file changed, 215 insertions(+), 97 deletions(-)
diff --git a/nimble/controller/src/ble_ll_adv.c b/nimble/controller/src/ble_ll_adv.c
index 0ffa1afc..7e672fd1 100644
--- a/nimble/controller/src/ble_ll_adv.c
+++ b/nimble/controller/src/ble_ll_adv.c
@@ -1357,117 +1357,173 @@ ble_ll_adv_aux_scannable_pdu_payload_len(struct ble_ll_adv_sm *advsm)
return len;
}
-static void
-ble_ll_adv_aux_calculate(struct ble_ll_adv_sm *advsm,
- struct ble_ll_adv_aux *aux, uint16_t aux_data_offset)
+static uint16_t
+ble_ll_adv_aux_calculate_payload(struct ble_ll_adv_sm *advsm, uint16_t props,
+ struct os_mbuf *data, uint32_t data_offset,
+ uint8_t *data_len_o, uint8_t *ext_hdr_flags_o)
{
- uint16_t rem_aux_data_len;
- uint8_t hdr_len;
+ uint16_t rem_data_len;
+ uint8_t data_len;
+ uint8_t ext_hdr_flags;
+ uint8_t ext_hdr_len;
bool chainable;
+ bool first_pdu;
- BLE_LL_ASSERT(!aux->sch.enqueued);
- BLE_LL_ASSERT((AUX_DATA_LEN(advsm) > aux_data_offset) ||
- (AUX_DATA_LEN(advsm) == 0 && aux_data_offset == 0));
-
- aux->aux_data_offset = aux_data_offset;
- aux->aux_data_len = 0;
- aux->payload_len = 0;
- aux->ext_hdr = 0;
+ /* Note: advsm shall only be used to check if periodic advertising is
+ * enabled, other parameters in advsm may have different values than
+ * those we want to check (e.g. when reconfiguring instance).
+ */
-#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2)
- aux->chan = ble_ll_utils_dci_csa2(advsm->event_cntr++,
- advsm->channel_id,
- g_ble_ll_data.chan_map_num_used,
- g_ble_ll_data.chan_map);
-#else
- aux->chan = ble_ll_utils_remapped_channel(ble_ll_rand() % BLE_PHY_NUM_DATA_CHANS,
- g_ble_ll_data.chan_map);
-#endif
+ rem_data_len = (data ? OS_MBUF_PKTLEN(data) : 0) - data_offset;
+ BLE_LL_ASSERT((int16_t)rem_data_len >= 0);
- rem_aux_data_len = AUX_DATA_LEN(advsm) - aux_data_offset;
- chainable = !(advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_CONNECTABLE);
+ first_pdu = (data_offset == 0);
+ chainable = !(props & BLE_HCI_LE_SET_EXT_ADV_PROP_CONNECTABLE);
- hdr_len = BLE_LL_EXT_ADV_HDR_LEN;
+ ext_hdr_flags = 0;
+ ext_hdr_len = BLE_LL_EXT_ADV_HDR_LEN;
- if (!(advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_SCANNABLE)) {
- /* ADI */
- aux->ext_hdr |= (1 << BLE_LL_EXT_ADV_DATA_INFO_BIT);
- hdr_len += BLE_LL_EXT_ADV_DATA_INFO_SIZE;
+ /* ADI for anything but scannable */
+ if (!(props & BLE_HCI_LE_SET_EXT_ADV_PROP_SCANNABLE)) {
+ ext_hdr_flags |= (1 << BLE_LL_EXT_ADV_DATA_INFO_BIT);
+ ext_hdr_len += BLE_LL_EXT_ADV_DATA_INFO_SIZE;
}
- /* AdvA for 1st PDU in chain (i.e. AUX_ADV_IND or AUX_SCAN_RSP) */
- if (aux_data_offset == 0 &&
- !(advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_ANON_ADV)) {
- aux->ext_hdr |= (1 << BLE_LL_EXT_ADV_ADVA_BIT);
- hdr_len += BLE_LL_EXT_ADV_ADVA_SIZE;
+ /* AdvA in 1st PDU, except for anonymous */
+ if (first_pdu &&
+ !(props & BLE_HCI_LE_SET_EXT_ADV_PROP_ANON_ADV)) {
+ ext_hdr_flags |= (1 << BLE_LL_EXT_ADV_ADVA_BIT);
+ ext_hdr_len += BLE_LL_EXT_ADV_ADVA_SIZE;
}
- /* Note: this function does not calculate AUX_ADV_IND when advertising is
- * scannable. Instead it is calculated in ble_ll_adv_aux_schedule_first().
+ /* TargetA in 1st PDU, if directed
*
- * However this function calculates length of AUX_SCAN_RSP and according
- * to BT 5.0 Vol 6 Part B, 2.3.2.3, TargetA shall not be include there.
- *
- * This is why TargetA is added to all directed advertising here unless it
- * is scannable one.
- *
- * Note. TargetA shall not be also in AUX_CHAIN_IND
+ * Note that for scannable this calculates AUX_SCAN_RSP which shall not
+ * include TargetA (see: Core 5.3, Vol 6, Part B, 2.3.2.3). For scannable
+ * TargetA is included in AUX_ADV_IND which is in that case calculated in
+ * ble_ll_adv_aux_schedule_first().
*/
- if (aux_data_offset == 0 &&
- (advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_DIRECTED) &&
- !(advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_SCANNABLE)) {
- aux->ext_hdr |= (1 << BLE_LL_EXT_ADV_TARGETA_BIT);
- hdr_len += BLE_LL_EXT_ADV_TARGETA_SIZE;
+ if (first_pdu &&
+ (props & BLE_HCI_LE_SET_EXT_ADV_PROP_DIRECTED) &&
+ !(props & BLE_HCI_LE_SET_EXT_ADV_PROP_SCANNABLE)) {
+ ext_hdr_flags |= (1 << BLE_LL_EXT_ADV_TARGETA_BIT);
+ ext_hdr_len += BLE_LL_EXT_ADV_TARGETA_SIZE;
}
- /* TxPower if configured.
- * Note: TxPower should not be be present in AUX_CHAIN_IND
- */
- if (aux_data_offset == 0 &&
- (advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_INC_TX_PWR)) {
- aux->ext_hdr |= (1 << BLE_LL_EXT_ADV_TX_POWER_BIT);
- hdr_len += BLE_LL_EXT_ADV_TX_POWER_SIZE;
+ /* TxPower in 1st PDU, if configured */
+ if (first_pdu &&
+ (props & BLE_HCI_LE_SET_EXT_ADV_PROP_INC_TX_PWR)) {
+ ext_hdr_flags |= (1 << BLE_LL_EXT_ADV_TX_POWER_BIT);
+ ext_hdr_len += BLE_LL_EXT_ADV_TX_POWER_SIZE;
}
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV)
- /* SyncInfo for 1st PDU in chain (i.e. AUX_ADV_IND only) if periodic
- * advertising is enabled
- */
- if (aux_data_offset == 0 && advsm->periodic_adv_active) {
- aux->ext_hdr |= (1 << BLE_LL_EXT_ADV_SYNC_INFO_BIT);
- hdr_len += BLE_LL_EXT_ADV_SYNC_INFO_SIZE;
+ /* SyncInfo in 1st PDU, if periodic advertising is enabled */
+ if (first_pdu && advsm->periodic_adv_active) {
+ ext_hdr_flags |= (1 << BLE_LL_EXT_ADV_SYNC_INFO_BIT);
+ ext_hdr_len += BLE_LL_EXT_ADV_SYNC_INFO_SIZE;
}
#endif
- /* if we have any fields in ext header we need to add flags, note that Aux
- * PTR is handled later and it will account for flags if needed
+ /* Flags, if any field is present in header
+ *
+ * Note that this does not account for AuxPtr which is added later if
+ * remaining data does not fit in single PDU.
*/
- if (aux->ext_hdr) {
- hdr_len += BLE_LL_EXT_ADV_FLAGS_SIZE;
+ if (ext_hdr_flags) {
+ ext_hdr_len += BLE_LL_EXT_ADV_FLAGS_SIZE;
}
- /* AdvData always */
- aux->aux_data_len = min(BLE_LL_MAX_PAYLOAD_LEN - hdr_len, rem_aux_data_len);
+ /* AdvData */
+ data_len = min(BLE_LL_MAX_PAYLOAD_LEN - ext_hdr_len, rem_data_len);
/* AuxPtr if there are more AdvData remaining that we can fit here */
- if (chainable && (rem_aux_data_len > aux->aux_data_len)) {
- /* adjust for flags that needs to be added if AuxPtr is only field
- * in Extended Header
- */
- if (!aux->ext_hdr) {
- hdr_len += BLE_LL_EXT_ADV_FLAGS_SIZE;
- aux->aux_data_len -= BLE_LL_EXT_ADV_FLAGS_SIZE;
- }
+ if (chainable && (rem_data_len > data_len)) {
+ /* Add flags if not already added */
+ if (!ext_hdr_flags) {
+ ext_hdr_len += BLE_LL_EXT_ADV_FLAGS_SIZE;
+ data_len -= BLE_LL_EXT_ADV_FLAGS_SIZE;
+ }
- aux->ext_hdr |= (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT);
- hdr_len += BLE_LL_EXT_ADV_AUX_PTR_SIZE;
- aux->aux_data_len -= BLE_LL_EXT_ADV_AUX_PTR_SIZE;
+ ext_hdr_flags |= (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT);
+ ext_hdr_len += BLE_LL_EXT_ADV_AUX_PTR_SIZE;
- /* PDU payload should be full if chained */
- BLE_LL_ASSERT(hdr_len + aux->aux_data_len == BLE_LL_MAX_PAYLOAD_LEN);
+ data_len -= BLE_LL_EXT_ADV_AUX_PTR_SIZE;
+
+ /* PDU payload should be full if adding AuxPtr */
+ BLE_LL_ASSERT(ext_hdr_len + data_len == BLE_LL_MAX_PAYLOAD_LEN);
}
- aux->payload_len = hdr_len + aux->aux_data_len;
+ *data_len_o = data_len;
+ *ext_hdr_flags_o = ext_hdr_flags;
+
+ return ext_hdr_len + data_len;
+}
+
+static void
+ble_ll_adv_aux_calculate(struct ble_ll_adv_sm *advsm,
+ struct ble_ll_adv_aux *aux, uint16_t data_offset)
+{
+ BLE_LL_ASSERT(!aux->sch.enqueued);
+ BLE_LL_ASSERT((AUX_DATA_LEN(advsm) > data_offset) ||
+ (AUX_DATA_LEN(advsm) == 0 && data_offset == 0));
+
+#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CSA2)
+ aux->chan = ble_ll_utils_dci_csa2(advsm->event_cntr++,
+ advsm->channel_id,
+ g_ble_ll_data.chan_map_num_used,
+ g_ble_ll_data.chan_map);
+#else
+ aux->chan = ble_ll_utils_remapped_channel(ble_ll_rand() % BLE_PHY_NUM_DATA_CHANS,
+ g_ble_ll_data.chan_map);
+#endif
+
+ aux->aux_data_offset = data_offset;
+ aux->payload_len = ble_ll_adv_aux_calculate_payload(advsm, advsm->props,
+ *advsm->aux_data,
+ data_offset,
+ &aux->aux_data_len,
+ &aux->ext_hdr);
+}
+
+static bool
+ble_ll_adv_aux_check_data_itvl(struct ble_ll_adv_sm *advsm, uint16_t props,
+ uint8_t pri_phy, uint8_t sec_phy,
+ struct os_mbuf *data, uint32_t interval_us)
+{
+ uint32_t max_usecs;
+ uint16_t data_offset;
+ uint16_t pdu_len;
+ uint8_t data_len;
+ uint8_t ext_hdr_flags;
+
+ /* FIXME:
+ * We should include PDUs on primary channel when calculating advertising
+ * event duration, but the actual time varies a bit in our case due to
+ * scheduling. For now let's assume we always schedule all PDUs 300us apart
+ * and we use shortest possible payload (ADI+AuxPtr, no AdvA).
+ *
+ * Note that calculations below do not take channel map and max skip into
+ * account, but we do not support max skip anyway for now.
+ */
+
+ max_usecs = 3 * (ble_ll_pdu_tx_time_get(7, pri_phy) + 300) +
+ BLE_LL_MAFS + MYNEWT_VAL(BLE_LL_SCHED_AUX_MAFS_DELAY);
+
+ data_offset = 0;
+
+ do {
+ pdu_len = ble_ll_adv_aux_calculate_payload(advsm, props, data, data_offset,
+ &data_len, &ext_hdr_flags);
+
+ max_usecs += ble_ll_pdu_tx_time_get(pdu_len, sec_phy);
+ max_usecs += BLE_LL_MAFS + MYNEWT_VAL(BLE_LL_SCHED_AUX_CHAIN_MAFS_DELAY);
+
+ data_offset += data_len;
+
+ } while (ext_hdr_flags & (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT));
+
+ return max_usecs < interval_us;
}
static void
@@ -1485,8 +1541,8 @@ ble_ll_adv_aux_schedule_next(struct ble_ll_adv_sm *advsm)
struct ble_ll_adv_aux *aux;
struct ble_ll_adv_aux *aux_next;
struct ble_ll_sched_item *sch;
- uint16_t rem_aux_data_len;
- uint16_t next_aux_data_offset;
+ uint16_t rem_data_len;
+ uint16_t next_data_offset;
uint32_t max_usecs;
BLE_LL_ASSERT(advsm->aux_active);
@@ -1512,14 +1568,14 @@ ble_ll_adv_aux_schedule_next(struct ble_ll_adv_sm *advsm)
return;
}
- next_aux_data_offset = aux->aux_data_offset + aux->aux_data_len;
+ next_data_offset = aux->aux_data_offset + aux->aux_data_len;
- BLE_LL_ASSERT(AUX_DATA_LEN(advsm) >= next_aux_data_offset);
+ BLE_LL_ASSERT(AUX_DATA_LEN(advsm) >= next_data_offset);
- rem_aux_data_len = AUX_DATA_LEN(advsm) - next_aux_data_offset;
- BLE_LL_ASSERT(rem_aux_data_len > 0);
+ rem_data_len = AUX_DATA_LEN(advsm) - next_data_offset;
+ BLE_LL_ASSERT(rem_data_len > 0);
- ble_ll_adv_aux_calculate(advsm, aux_next, next_aux_data_offset);
+ ble_ll_adv_aux_calculate(advsm, aux_next, next_data_offset);
max_usecs = ble_ll_pdu_tx_time_get(aux_next->payload_len, advsm->sec_phy);
aux_next->start_time = aux->sch.end_time +
@@ -1738,6 +1794,7 @@ ble_ll_adv_set_adv_params(const uint8_t *cmdbuf, uint8_t len)
uint8_t adv_filter_policy;
uint16_t adv_itvl_min;
uint16_t adv_itvl_max;
+ uint32_t adv_itvl_usecs;
uint16_t props;
if (len != sizeof(*cmd)) {
@@ -1833,6 +1890,14 @@ ble_ll_adv_set_adv_params(const uint8_t *cmdbuf, uint8_t len)
return BLE_ERR_INV_HCI_CMD_PARMS;
}
+ /* Determine the advertising interval we will use */
+ if (props & BLE_HCI_LE_SET_EXT_ADV_PROP_HD_DIRECTED) {
+ /* Set it to max. allowed for high duty cycle advertising */
+ adv_itvl_usecs = BLE_LL_ADV_PDU_ITVL_HD_MS_MAX;
+ } else {
+ adv_itvl_usecs = adv_itvl_max * BLE_LL_ADV_ITVL;
+ }
+
/* Fill out rest of advertising state machine */
advsm->own_addr_type = cmd->own_addr_type;
advsm->peer_addr_type = cmd->peer_addr_type;
@@ -1840,6 +1905,7 @@ ble_ll_adv_set_adv_params(const uint8_t *cmdbuf, uint8_t len)
advsm->adv_chanmask = cmd->chan_map;
advsm->adv_itvl_min = adv_itvl_min;
advsm->adv_itvl_max = adv_itvl_max;
+ advsm->adv_itvl_usecs = adv_itvl_usecs;
advsm->props = props;
return 0;
@@ -2712,15 +2778,6 @@ ble_ll_adv_sm_start(struct ble_ll_adv_sm *advsm)
(access_addr & 0x0000ffff);
#endif
- /* Determine the advertising interval we will use */
- if (advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_HD_DIRECTED) {
- /* Set it to max. allowed for high duty cycle advertising */
- advsm->adv_itvl_usecs = BLE_LL_ADV_PDU_ITVL_HD_MS_MAX;
- } else {
- advsm->adv_itvl_usecs = (uint32_t)advsm->adv_itvl_max;
- advsm->adv_itvl_usecs *= BLE_LL_ADV_ITVL;
- }
-
/* Set first advertising channel */
adv_chan = ble_ll_adv_first_chan(advsm);
advsm->adv_chan = adv_chan;
@@ -2991,6 +3048,19 @@ ble_ll_adv_set_scan_rsp_data(const uint8_t *data, uint8_t datalen,
if (!advsm->new_scan_rsp_data) {
return BLE_ERR_MEM_CAPACITY;
}
+
+#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
+ if (!(advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY) &&
+ !ble_ll_adv_aux_check_data_itvl(advsm, advsm->props, advsm->pri_phy,
+ advsm->sec_phy,
+ advsm->new_scan_rsp_data,
+ advsm->adv_itvl_usecs)) {
+ os_mbuf_free_chain(advsm->new_scan_rsp_data);
+ advsm->new_scan_rsp_data = NULL;
+ return BLE_ERR_PACKET_TOO_LONG;
+ }
+#endif
+
ble_ll_adv_flags_set(advsm, BLE_LL_ADV_SM_FLAG_NEW_SCAN_RSP_DATA);
} else {
ble_ll_adv_update_data_mbuf(&advsm->scan_rsp_data, new_data,
@@ -3000,6 +3070,16 @@ ble_ll_adv_set_scan_rsp_data(const uint8_t *data, uint8_t datalen,
}
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
+ if (!(advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY) &&
+ !ble_ll_adv_aux_check_data_itvl(advsm, advsm->props, advsm->pri_phy,
+ advsm->sec_phy,
+ advsm->scan_rsp_data,
+ advsm->adv_itvl_usecs)) {
+ os_mbuf_free_chain(advsm->scan_rsp_data);
+ advsm->scan_rsp_data = NULL;
+ return BLE_ERR_PACKET_TOO_LONG;
+ }
+
/* DID shall be updated when host provides new scan response data */
ble_ll_adv_update_did(advsm);
#endif
@@ -3133,6 +3213,18 @@ ble_ll_adv_set_adv_data(const uint8_t *data, uint8_t datalen, uint8_t instance,
if (!advsm->new_adv_data) {
return BLE_ERR_MEM_CAPACITY;
}
+
+#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
+ if (!(advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY) &&
+ !ble_ll_adv_aux_check_data_itvl(advsm, advsm->props, advsm->pri_phy,
+ advsm->sec_phy, advsm->new_adv_data,
+ advsm->adv_itvl_usecs)) {
+ os_mbuf_free_chain(advsm->new_adv_data);
+ advsm->new_adv_data = NULL;
+ return BLE_ERR_PACKET_TOO_LONG;
+ }
+#endif
+
ble_ll_adv_flags_set(advsm, BLE_LL_ADV_SM_FLAG_NEW_ADV_DATA);
} else {
ble_ll_adv_update_data_mbuf(&advsm->adv_data, new_data,
@@ -3142,6 +3234,15 @@ ble_ll_adv_set_adv_data(const uint8_t *data, uint8_t datalen, uint8_t instance,
}
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
+ if (!(advsm->props & BLE_HCI_LE_SET_EXT_ADV_PROP_LEGACY) &&
+ !ble_ll_adv_aux_check_data_itvl(advsm, advsm->props, advsm->pri_phy,
+ advsm->sec_phy, advsm->adv_data,
+ advsm->adv_itvl_usecs)) {
+ os_mbuf_free_chain(advsm->adv_data);
+ advsm->adv_data = NULL;
+ return BLE_ERR_PACKET_TOO_LONG;
+ }
+
/* DID shall be updated when host provides new advertising data */
ble_ll_adv_update_did(advsm);
#endif
@@ -3230,6 +3331,7 @@ ble_ll_adv_ext_set_param(const uint8_t *cmdbuf, uint8_t len,
struct ble_ll_adv_sm *advsm;
uint32_t adv_itvl_min;
uint32_t adv_itvl_max;
+ uint32_t adv_itvl_usecs;
uint16_t props;
int rc;
@@ -3411,6 +3513,21 @@ ble_ll_adv_ext_set_param(const uint8_t *cmdbuf, uint8_t len,
goto done;
}
+ /* Determine the advertising interval we will use */
+ if (props & BLE_HCI_LE_SET_EXT_ADV_PROP_HD_DIRECTED) {
+ /* Set it to max. allowed for high duty cycle advertising */
+ adv_itvl_usecs = BLE_LL_ADV_PDU_ITVL_HD_MS_MAX;
+ } else {
+ adv_itvl_usecs = adv_itvl_max * BLE_LL_ADV_ITVL;
+ }
+
+ if (!ble_ll_adv_aux_check_data_itvl(advsm, props, cmd->pri_phy, cmd->sec_phy,
+ advsm->adv_data, adv_itvl_usecs) ||
+ !ble_ll_adv_aux_check_data_itvl(advsm, props, cmd->pri_phy, cmd->sec_phy,
+ advsm->scan_rsp_data, adv_itvl_usecs)) {
+ return BLE_ERR_PACKET_TOO_LONG;
+ }
+
rc = BLE_ERR_SUCCESS;
if (cmd->tx_power == 127) {
@@ -3428,6 +3545,7 @@ ble_ll_adv_ext_set_param(const uint8_t *cmdbuf, uint8_t len,
advsm->adv_chanmask = cmd->pri_chan_map;
advsm->adv_itvl_min = adv_itvl_min;
advsm->adv_itvl_max = adv_itvl_max;
+ advsm->adv_itvl_usecs = adv_itvl_usecs;
advsm->pri_phy = cmd->pri_phy;
advsm->sec_phy = cmd->sec_phy;
/* Update SID only */
[mynewt-nimble] 04/04: nimble/ll: Adjust names in adv structs
Posted by an...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
andk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git
commit c9cbc3cb15828e0d03ac6e3df5693f39efc8b715
Author: Andrzej Kaczmarek <an...@codecoup.pl>
AuthorDate: Tue Aug 23 15:40:08 2022 +0200
nimble/ll: Adjust names in adv structs
Skip aux and sync prefixes since it's quite obvious as those members
are in aux and sync structs.
---
nimble/controller/src/ble_ll_adv.c | 139 ++++++++++++++++++-------------------
1 file changed, 69 insertions(+), 70 deletions(-)
diff --git a/nimble/controller/src/ble_ll_adv.c b/nimble/controller/src/ble_ll_adv.c
index c2057f70..85500d57 100644
--- a/nimble/controller/src/ble_ll_adv.c
+++ b/nimble/controller/src/ble_ll_adv.c
@@ -58,10 +58,10 @@
struct ble_ll_adv_aux {
struct ble_ll_sched_item sch;
uint32_t start_time;
- uint16_t aux_data_offset;
+ uint16_t data_offset;
uint8_t chan;
- uint8_t ext_hdr;
- uint8_t aux_data_len;
+ uint8_t ext_hdr_flags;
+ uint8_t data_len;
uint8_t payload_len;
};
@@ -69,10 +69,10 @@ struct ble_ll_adv_aux {
struct ble_ll_adv_sync {
struct ble_ll_sched_item sch;
uint32_t start_time;
- uint16_t sync_data_offset;
+ uint16_t data_offset;
uint8_t chan;
- uint8_t ext_hdr;
- uint8_t sync_data_len;
+ uint8_t ext_hdr_flags;
+ uint8_t data_len;
uint8_t payload_len;
};
@@ -732,17 +732,17 @@ ble_ll_adv_aux_pdu_make(uint8_t *dptr, void *pducb_arg, uint8_t *hdr_byte)
adv_mode |= BLE_LL_EXT_ADV_MODE_CONN;
}
- ext_hdr_len = aux->payload_len - BLE_LL_EXT_ADV_HDR_LEN - aux->aux_data_len;
+ ext_hdr_len = aux->payload_len - BLE_LL_EXT_ADV_HDR_LEN - aux->data_len;
dptr[0] = (adv_mode << 6) | ext_hdr_len;
dptr += 1;
/* only put flags if needed */
- if (aux->ext_hdr) {
- dptr[0] = aux->ext_hdr;
+ if (aux->ext_hdr_flags) {
+ dptr[0] = aux->ext_hdr_flags;
dptr += 1;
}
- if (aux->ext_hdr & (1 << BLE_LL_EXT_ADV_ADVA_BIT)) {
+ if (aux->ext_hdr_flags & (1 << BLE_LL_EXT_ADV_ADVA_BIT)) {
/* Set TxAdd to random if needed. */
if (advsm->flags & BLE_LL_ADV_SM_FLAG_TX_ADD) {
@@ -753,7 +753,7 @@ ble_ll_adv_aux_pdu_make(uint8_t *dptr, void *pducb_arg, uint8_t *hdr_byte)
dptr += BLE_LL_EXT_ADV_ADVA_SIZE;
}
- if (aux->ext_hdr & (1 << BLE_LL_EXT_ADV_TARGETA_BIT)) {
+ if (aux->ext_hdr_flags & (1 << BLE_LL_EXT_ADV_TARGETA_BIT)) {
memcpy(dptr, advsm->initiator_addr, BLE_LL_EXT_ADV_TARGETA_SIZE);
dptr += BLE_LL_EXT_ADV_TARGETA_SIZE;
@@ -763,13 +763,13 @@ ble_ll_adv_aux_pdu_make(uint8_t *dptr, void *pducb_arg, uint8_t *hdr_byte)
}
}
- if (aux->ext_hdr & (1 << BLE_LL_EXT_ADV_DATA_INFO_BIT)) {
+ if (aux->ext_hdr_flags & (1 << BLE_LL_EXT_ADV_DATA_INFO_BIT)) {
dptr[0] = advsm->adi & 0x00ff;
dptr[1] = advsm->adi >> 8;
dptr += BLE_LL_EXT_ADV_DATA_INFO_SIZE;
}
- if (aux->ext_hdr & (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT)) {
+ if (aux->ext_hdr_flags & (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT)) {
if (!AUX_NEXT(advsm)->sch.enqueued) {
/*
* Trim data here in case we do not have next aux scheduled. This
@@ -791,20 +791,20 @@ ble_ll_adv_aux_pdu_make(uint8_t *dptr, void *pducb_arg, uint8_t *hdr_byte)
}
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV)
- if (aux->ext_hdr & (1 << BLE_LL_EXT_ADV_SYNC_INFO_BIT)) {
+ if (aux->ext_hdr_flags & (1 << BLE_LL_EXT_ADV_SYNC_INFO_BIT)) {
ble_ll_adv_put_syncinfo(advsm, NULL, NULL, dptr);
dptr += BLE_LL_EXT_ADV_SYNC_INFO_SIZE;
}
#endif
- if (aux->ext_hdr & (1 << BLE_LL_EXT_ADV_TX_POWER_BIT)) {
+ if (aux->ext_hdr_flags & (1 << BLE_LL_EXT_ADV_TX_POWER_BIT)) {
dptr[0] = advsm->adv_txpwr + ble_ll_get_tx_pwr_compensation();
dptr += BLE_LL_EXT_ADV_TX_POWER_SIZE;
}
- if (aux->aux_data_len) {
- os_mbuf_copydata(*advsm->aux_data, aux->aux_data_offset,
- aux->aux_data_len, dptr);
+ if (aux->data_len) {
+ os_mbuf_copydata(*advsm->aux_data, aux->data_offset,
+ aux->data_len, dptr);
}
*hdr_byte = pdu_type;
@@ -1476,12 +1476,12 @@ ble_ll_adv_aux_calculate(struct ble_ll_adv_sm *advsm,
g_ble_ll_data.chan_map);
#endif
- aux->aux_data_offset = data_offset;
+ aux->data_offset = data_offset;
aux->payload_len = ble_ll_adv_aux_calculate_payload(advsm, advsm->props,
*advsm->aux_data,
data_offset,
- &aux->aux_data_len,
- &aux->ext_hdr);
+ &aux->data_len,
+ &aux->ext_hdr_flags);
}
static bool
@@ -1562,11 +1562,11 @@ ble_ll_adv_aux_schedule_next(struct ble_ll_adv_sm *advsm)
* Do not schedule next aux if current aux does not have AuxPtr in extended
* header as this means we do not need subsequent ADV_CHAIN_IND to be sent.
*/
- if (!(aux->ext_hdr & (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT))) {
+ if (!(aux->ext_hdr_flags & (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT))) {
return;
}
- next_data_offset = aux->aux_data_offset + aux->aux_data_len;
+ next_data_offset = aux->data_offset + aux->data_len;
BLE_LL_ASSERT(AUX_DATA_LEN(advsm) >= next_data_offset);
@@ -2131,17 +2131,17 @@ ble_ll_adv_sync_pdu_make(uint8_t *dptr, void *pducb_arg, uint8_t *hdr_byte)
/* non-connectable and non-scannable */
adv_mode = 0;
- ext_hdr_len = sync->payload_len - BLE_LL_EXT_ADV_HDR_LEN - sync->sync_data_len;
+ ext_hdr_len = sync->payload_len - BLE_LL_EXT_ADV_HDR_LEN - sync->data_len;
dptr[0] = (adv_mode << 6) | ext_hdr_len;
dptr += 1;
/* only put flags if needed */
- if (sync->ext_hdr) {
- dptr[0] = sync->ext_hdr;
+ if (sync->ext_hdr_flags) {
+ dptr[0] = sync->ext_hdr_flags;
dptr += 1;
}
- if (sync->ext_hdr & (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT)) {
+ if (sync->ext_hdr_flags & (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT)) {
if (!SYNC_NEXT(advsm)->sch.enqueued) {
/*
* Trim data here in case we do not have next sync scheduled. This
@@ -2160,14 +2160,14 @@ ble_ll_adv_sync_pdu_make(uint8_t *dptr, void *pducb_arg, uint8_t *hdr_byte)
dptr += BLE_LL_EXT_ADV_AUX_PTR_SIZE;
}
- if (sync->ext_hdr & (1 << BLE_LL_EXT_ADV_TX_POWER_BIT)) {
+ if (sync->ext_hdr_flags & (1 << BLE_LL_EXT_ADV_TX_POWER_BIT)) {
dptr[0] = advsm->adv_txpwr + ble_ll_get_tx_pwr_compensation();
dptr += BLE_LL_EXT_ADV_TX_POWER_SIZE;
}
- if (sync->sync_data_len) {
- os_mbuf_copydata(advsm->periodic_adv_data, sync->sync_data_offset,
- sync->sync_data_len, dptr);
+ if (sync->data_len) {
+ os_mbuf_copydata(advsm->periodic_adv_data, sync->data_offset,
+ sync->data_len, dptr);
}
*hdr_byte = pdu_type;
@@ -2291,34 +2291,33 @@ adv_tx_done:
static void
ble_ll_adv_sync_calculate(struct ble_ll_adv_sm *advsm,
- struct ble_ll_adv_sync *sync,
- uint16_t sync_data_offset,
+ struct ble_ll_adv_sync *sync, uint16_t data_offset,
uint8_t chan)
{
- uint16_t rem_sync_data_len;
- uint8_t hdr_len;
+ uint16_t rem_data_len;
+ uint8_t ext_hdr_len;
BLE_LL_ASSERT(!sync->sch.enqueued);
- BLE_LL_ASSERT((SYNC_DATA_LEN(advsm) > sync_data_offset) ||
- (SYNC_DATA_LEN(advsm) == 0 && sync_data_offset == 0));
+ BLE_LL_ASSERT((SYNC_DATA_LEN(advsm) > data_offset) ||
+ (SYNC_DATA_LEN(advsm) == 0 && data_offset == 0));
- sync->sync_data_offset = sync_data_offset;
- sync->sync_data_len = 0;
+ sync->data_offset = data_offset;
+ sync->data_len = 0;
sync->payload_len = 0;
- sync->ext_hdr = 0;
+ sync->ext_hdr_flags = 0;
sync->chan = chan;
- rem_sync_data_len = SYNC_DATA_LEN(advsm) - sync_data_offset;
+ rem_data_len = SYNC_DATA_LEN(advsm) - data_offset;
- hdr_len = BLE_LL_EXT_ADV_HDR_LEN;
+ ext_hdr_len = BLE_LL_EXT_ADV_HDR_LEN;
/* TxPower if configured
* Note: TxPower shall not be present in chain PDU for SYNC
*/
- if (sync_data_offset == 0 &&
+ if (data_offset == 0 &&
(advsm->periodic_adv_props & BLE_HCI_LE_SET_PERIODIC_ADV_PROP_INC_TX_PWR)) {
- sync->ext_hdr |= (1 << BLE_LL_EXT_ADV_TX_POWER_BIT);
- hdr_len += BLE_LL_EXT_ADV_TX_POWER_SIZE;
+ sync->ext_hdr_flags |= (1 << BLE_LL_EXT_ADV_TX_POWER_BIT);
+ ext_hdr_len += BLE_LL_EXT_ADV_TX_POWER_SIZE;
}
/* if we have any fields in ext header we need to add flags, note that Aux
@@ -2328,32 +2327,32 @@ ble_ll_adv_sync_calculate(struct ble_ll_adv_sm *advsm,
* how Aux calculate works and this also make it easier to add more fields
* into flags if needed in future
*/
- if (sync->ext_hdr) {
- hdr_len += BLE_LL_EXT_ADV_FLAGS_SIZE;
+ if (sync->ext_hdr_flags) {
+ ext_hdr_len += BLE_LL_EXT_ADV_FLAGS_SIZE;
}
/* AdvData always */
- sync->sync_data_len = min(BLE_LL_MAX_PAYLOAD_LEN - hdr_len, rem_sync_data_len);
+ sync->data_len = min(BLE_LL_MAX_PAYLOAD_LEN - ext_hdr_len, rem_data_len);
/* AuxPtr if there are more AdvData remaining that we can fit here */
- if ((rem_sync_data_len > sync->sync_data_len)) {
- /* adjust for flags that needs to be added if AuxPtr is only field
- * in Extended Header
- */
- if (!sync->ext_hdr) {
- hdr_len += BLE_LL_EXT_ADV_FLAGS_SIZE;
- sync->sync_data_len -= BLE_LL_EXT_ADV_FLAGS_SIZE;
- }
+ if ((rem_data_len > sync->data_len)) {
+ /* adjust for flags that needs to be added if AuxPtr is only field
+ * in Extended Header
+ */
+ if (!sync->ext_hdr_flags) {
+ ext_hdr_len += BLE_LL_EXT_ADV_FLAGS_SIZE;
+ sync->data_len -= BLE_LL_EXT_ADV_FLAGS_SIZE;
+ }
- sync->ext_hdr |= (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT);
- hdr_len += BLE_LL_EXT_ADV_AUX_PTR_SIZE;
- sync->sync_data_len -= BLE_LL_EXT_ADV_AUX_PTR_SIZE;
+ sync->ext_hdr_flags |= (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT);
+ ext_hdr_len += BLE_LL_EXT_ADV_AUX_PTR_SIZE;
+ sync->data_len -= BLE_LL_EXT_ADV_AUX_PTR_SIZE;
- /* PDU payload should be full if chained */
- BLE_LL_ASSERT(hdr_len + sync->sync_data_len == BLE_LL_MAX_PAYLOAD_LEN);
+ /* PDU payload should be full if chained */
+ BLE_LL_ASSERT(ext_hdr_len + sync->data_len == BLE_LL_MAX_PAYLOAD_LEN);
}
- sync->payload_len = hdr_len + sync->sync_data_len;
+ sync->payload_len = ext_hdr_len + sync->data_len;
}
static void
@@ -2433,8 +2432,8 @@ ble_ll_adv_periodic_schedule_next(struct ble_ll_adv_sm *advsm)
struct ble_ll_adv_sync *sync;
struct ble_ll_adv_sync *sync_next;
struct ble_ll_sched_item *sch;
- uint16_t rem_sync_data_len;
- uint16_t next_sync_data_offset;
+ uint16_t rem_data_len;
+ uint16_t next_data_offset;
uint32_t max_usecs;
uint8_t chan;
@@ -2457,16 +2456,16 @@ ble_ll_adv_periodic_schedule_next(struct ble_ll_adv_sm *advsm)
* Do not schedule next sync if current sync does not have AuxPtr in extended
* header as this means we do not need subsequent ADV_CHAIN_IND to be sent.
*/
- if (!(sync->ext_hdr & (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT))) {
+ if (!(sync->ext_hdr_flags & (1 << BLE_LL_EXT_ADV_AUX_PTR_BIT))) {
return;
}
- next_sync_data_offset = sync->sync_data_offset + sync->sync_data_len;
+ next_data_offset = sync->data_offset + sync->data_len;
- BLE_LL_ASSERT(SYNC_DATA_LEN(advsm) >= next_sync_data_offset);
+ BLE_LL_ASSERT(SYNC_DATA_LEN(advsm) >= next_data_offset);
- rem_sync_data_len = SYNC_DATA_LEN(advsm) - next_sync_data_offset;
- BLE_LL_ASSERT(rem_sync_data_len > 0);
+ rem_data_len = SYNC_DATA_LEN(advsm) - next_data_offset;
+ BLE_LL_ASSERT(rem_data_len > 0);
/* we use separate counter for chaining */
chan = ble_ll_utils_dci_csa2(advsm->periodic_chain_event_cntr++,
@@ -2474,7 +2473,7 @@ ble_ll_adv_periodic_schedule_next(struct ble_ll_adv_sm *advsm)
advsm->periodic_num_used_chans,
advsm->periodic_chanmap);
- ble_ll_adv_sync_calculate(advsm, sync_next, next_sync_data_offset, chan);
+ ble_ll_adv_sync_calculate(advsm, sync_next, next_data_offset, chan);
max_usecs = ble_ll_pdu_tx_time_get(sync_next->payload_len, advsm->sec_phy);
sync_next->start_time = sync->sch.end_time +