Bluetooth: Controller: Schedule BIG event after Periodic Advertising

Add implementation to schedule BIG events after Periodic
Advertising when Periodic Advertising is enabled after
Extended Advertising has already been enabled.

Signed-off-by: Vinayak Kariappa Chettimada <[email protected]>

Author: cvinayak

subsys/bluetooth/controller/ll_sw/ull_adv.c

@@ -1476,7 +1476,9 @@ uint8_t ll_adv_enable(uint8_t enable)
 			 * started.
 			 */
 			if (sync) {
+				uint32_t ticks_slot_overhead;
 				uint32_t ticks_slot_aux;
+
 #if defined(CONFIG_BT_CTLR_ADV_RESERVE_MAX)
 				uint32_t us_slot;
 
@@ -1509,8 +1511,10 @@ uint8_t ll_adv_enable(uint8_t enable)
 						EVENT_OVERHEAD_START_US +
 						(EVENT_TICKER_RES_MARGIN_US << 1));
 
+				ticks_slot_overhead = ull_adv_sync_evt_init(adv, sync);
 				ret = ull_adv_sync_start(adv, sync,
-							 ticks_anchor_sync);
+							 ticks_anchor_sync,
+							 ticks_slot_overhead);
 				if (ret) {
 					goto failure_cleanup;
 				}

subsys/bluetooth/controller/ll_sw/ull_adv_internal.h

@@ -229,10 +229,15 @@ void ull_adv_sync_release(struct ll_adv_sync_set *sync);
 uint32_t ull_adv_sync_time_get(const struct ll_adv_sync_set *sync,
 			       uint8_t pdu_len);
 
+/* helper function to calculate ticks_slot and return slot overhead */
+uint32_t ull_adv_sync_evt_init(struct ll_adv_set *adv,
+			       struct ll_adv_sync_set *sync);
+
 /* helper function to start periodic advertising */
 uint32_t ull_adv_sync_start(struct ll_adv_set *adv,
 			    struct ll_adv_sync_set *sync,
-			    uint32_t ticks_anchor);
+			    uint32_t ticks_anchor,
+			    uint32_t ticks_slot_overhead);
 
 /* helper function to update periodic advertising event time reservation */
 uint8_t ull_adv_sync_time_update(struct ll_adv_sync_set *sync,

subsys/bluetooth/controller/ll_sw/ull_adv_iso.c

@@ -939,6 +939,8 @@ static uint32_t adv_iso_start(struct ll_adv_iso_set *adv_iso,
 	ticks_slot = adv_iso->ull.ticks_slot + ticks_slot_overhead;
 
 	/* Find the slot after Periodic Advertisings events */
+	ticks_anchor = ticker_ticks_now_get() +
+		       HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
 	err = ull_sched_adv_aux_sync_free_slot_get(TICKER_USER_ID_THREAD,
 						   ticks_slot, &ticks_anchor);
 	if (!err) {
@@ -947,9 +949,6 @@ static uint32_t adv_iso_start(struct ll_adv_iso_set *adv_iso,
 					    EVENT_OVERHEAD_START_US) -
 					EVENT_OVERHEAD_START_US +
 					(EVENT_TICKER_RES_MARGIN_US << 1));
-	} else {
-		ticks_anchor = ticker_ticks_now_get() +
-			       HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
 	}
 
 	/* setup to use ISO create prepare function for first radio event */

subsys/bluetooth/controller/ll_sw/ull_adv_sync.c

@@ -40,6 +40,7 @@
 
 #include "ull_internal.h"
 #include "ull_chan_internal.h"
+#include "ull_sched_internal.h"
 #include "ull_adv_internal.h"
 
 #include "ll.h"
@@ -836,6 +837,7 @@ uint8_t ll_adv_sync_enable(uint8_t handle, uint8_t enable)
 		struct pdu_adv_sync_info *sync_info;
 		uint8_t value[1 + sizeof(sync_info)];
 		uint32_t ticks_slot_overhead_aux;
+		uint32_t ticks_slot_overhead;
 		struct lll_adv_aux *lll_aux;
 		struct ll_adv_aux_set *aux;
 		uint32_t ticks_anchor_sync;
@@ -860,6 +862,12 @@ uint8_t ll_adv_sync_enable(uint8_t handle, uint8_t enable)
 		(void)memcpy(&sync_info, &value[1], sizeof(sync_info));
 		ull_adv_sync_info_fill(sync, sync_info);
 
+		/* Calculate the ticks_slot and return slot overhead */
+		ticks_slot_overhead = ull_adv_sync_evt_init(adv, sync);
+
+		/* If Auxiliary PDU already active, find and schedule Periodic
+		 * advertising follow it.
+		 */
 		if (lll_aux) {
 			/* Auxiliary set already active (due to other fields
 			 * being already present or being started prior).
@@ -868,15 +876,27 @@ uint8_t ll_adv_sync_enable(uint8_t handle, uint8_t enable)
 			ticks_anchor_aux = 0U; /* unused in this path */
 			ticks_slot_overhead_aux = 0U; /* unused in this path */
 
-			/* TODO: Find the anchor after the group of active
-			 *       auxiliary sets such that Periodic Advertising
-			 *       events are placed in non-overlapping timeline
-			 *       when auxiliary and Periodic Advertising have
-			 *       similar event interval.
+			/* Find the anchor after the group of active auxiliary
+			 * sets such that Periodic Advertising events are placed
+			 * in non-overlapping timeline when auxiliary and
+			 * Periodic Advertising have similar event interval.
 			 */
-			ticks_anchor_sync =
-				ticker_ticks_now_get() +
+			ticks_anchor_sync = ticker_ticks_now_get() +
 				HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
+
+#if defined(CONFIG_BT_CTLR_SCHED_ADVANCED)
+			err = ull_sched_adv_aux_sync_free_slot_get(TICKER_USER_ID_THREAD,
+								   sync->ull.ticks_slot,
+								   &ticks_anchor_sync);
+			if (!err) {
+				ticks_anchor_sync += HAL_TICKER_US_TO_TICKS(
+					MAX(EVENT_MAFS_US,
+					    EVENT_OVERHEAD_START_US) -
+					EVENT_OVERHEAD_START_US +
+					(EVENT_TICKER_RES_MARGIN_US << 1));
+			}
+#endif /* CONFIG_BT_CTLR_SCHED_ADVANCED */
+
 		} else {
 			/* Auxiliary set will be started due to inclusion of
 			 * sync info field.
@@ -897,7 +917,8 @@ uint8_t ll_adv_sync_enable(uint8_t handle, uint8_t enable)
 					(EVENT_TICKER_RES_MARGIN_US << 1));
 		}
 
-		ret = ull_adv_sync_start(adv, sync, ticks_anchor_sync);
+		ret = ull_adv_sync_start(adv, sync, ticks_anchor_sync,
+					 ticks_slot_overhead);
 		if (ret) {
 			sync_remove(sync, adv, 1U);
 
@@ -1053,19 +1074,14 @@ uint32_t ull_adv_sync_time_get(const struct ll_adv_sync_set *sync,
 	return time_us;
 }
 
-uint32_t ull_adv_sync_start(struct ll_adv_set *adv,
-			    struct ll_adv_sync_set *sync,
-			    uint32_t ticks_anchor)
+uint32_t ull_adv_sync_evt_init(struct ll_adv_set *adv,
+			       struct ll_adv_sync_set *sync)
 {
 	struct lll_adv_sync *lll_sync;
 	uint32_t ticks_slot_overhead;
 	uint32_t ticks_slot_offset;
-	uint32_t volatile ret_cb;
 	struct pdu_adv *ter_pdu;
-	uint32_t interval_us;
-	uint8_t sync_handle;
 	uint32_t time_us;
-	uint32_t ret;
 
 	ull_hdr_init(&sync->ull);
 
@@ -1090,6 +1106,19 @@ uint32_t ull_adv_sync_start(struct ll_adv_set *adv,
 		ticks_slot_overhead = 0U;
 	}
 
+	return ticks_slot_overhead;
+}
+
+uint32_t ull_adv_sync_start(struct ll_adv_set *adv,
+			    struct ll_adv_sync_set *sync,
+			    uint32_t ticks_anchor,
+			    uint32_t ticks_slot_overhead)
+{
+	uint32_t volatile ret_cb;
+	uint32_t interval_us;
+	uint8_t sync_handle;
+	uint32_t ret;
+
 	interval_us = (uint32_t)sync->interval * PERIODIC_INT_UNIT_US;
 
 	sync_handle = sync_handle_get(sync);

subsys/bluetooth/controller/ll_sw/ull_sched.c

@@ -95,14 +95,28 @@ int ull_sched_adv_aux_sync_free_slot_get(uint8_t user_id,
 
 		} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_AUX_BASE,
 				    TICKER_ID_ADV_AUX_LAST)) {
+			const struct ll_adv_aux_set *aux;
+
 			*ticks_anchor += ticks_to_expire;
 			*ticks_anchor += ticks_slot;
 
-			if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
-				const struct ll_adv_aux_set *aux;
+			aux = ull_adv_aux_get(ticker_id -
+					      TICKER_ID_ADV_AUX_BASE);
+
+#if defined(CONFIG_BT_CTLR_ADV_PERIODIC)
+			if (aux->lll.adv->sync) {
+				const struct ll_adv_sync_set *sync;
 
-				aux = ull_adv_aux_get(ticker_id -
-						      TICKER_ID_ADV_AUX_BASE);
+				sync = HDR_LLL2ULL(aux->lll.adv->sync);
+				if (sync->is_started) {
+					*ticks_anchor += sync->ull.ticks_slot;
+					*ticks_anchor += HAL_TICKER_US_TO_TICKS(
+						EVENT_TICKER_RES_MARGIN_US << 1);
+				}
+			}
+#endif /* CONFIG_BT_CTLR_ADV_PERIODIC */
+
+			if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
 				*ticks_anchor +=
 					MAX(aux->ull.ticks_active_to_start,
 					    aux->ull.ticks_prepare_to_start);