Bluetooth: Controller: ISO Sync Receiver with ticks_slot_window

subsys/bluetooth/controller/Kconfig.ll_sw_split

@@ -430,6 +430,13 @@ config BT_CTLR_ADV_RESERVE_MAX
 	  corresponding to the Advertising Data present at the time of the
 	  start/enable of Advertising is used.
 
+config BT_CTLR_ADV_AUX_SLOT_WINDOW
+	bool "Reschedule Extended Advertising Auxiliary PDUs"
+	depends on BT_BROADCASTER && BT_CTLR_ADV_EXT
+	select BT_TICKER_EXT
+	help
+	  Reschedule Extended Advertising Auxiliary PDUs.
+
 config BT_CTLR_ADV_ISO_RESERVE_MAX
 	bool "Use maximum Broadcast ISO event time reservation"
 	depends on BT_CTLR_ADV_ISO
@@ -540,6 +547,16 @@ config BT_CTLR_SYNC_ISO_RESERVE_MAX
 	  disabled, then time reservation does not include the pre-transmissions
 	  and any Control subevents.
 
+config BT_CTLR_SYNC_ISO_SLOT_WINDOW_JITTER
+	bool "Wrap ISO Synchronized Receiver event around overlapping roles"
+	depends on BT_CTLR_SYNC_ISO && !BT_CTLR_SYNC_ISO_RESERVE_MAX
+	select BT_TICKER_EXT
+	help
+	  Wrap ISO Synchronized Receiver event around overlapping roles using
+	  ticker ticks_slot_window feature with jitter in window.
+	  LLL implementation can use the ticks_drifts value to determine the
+	  correct subevents to setup for reception.
+
 config BT_CTLR_ADV_ENABLE_STRICT
 	bool "Enforce Strict Advertising Enable/Disable"
 	depends on BT_BROADCASTER
@@ -749,6 +766,19 @@ config BT_CTLR_CENTRAL_RESERVE_MAX
 	  Note, currently this value is only used to space multiple central
 	  connections and not for actual ticker time reservations.
 
+config BT_CTLR_PERIPHERAL_RESERVE_MAX
+	bool "Use maximum data PDU size time reservation for Peripheral"
+	depends on BT_PERIPHERAL
+	default y
+	help
+	  Use the maximum data PDU size time reservation considering the Data
+	  length could be updated from default 27 bytes to maximum support size.
+
+	  If maximum time reservation is disabled then time reservation required
+	  for empty PDU transmission is used. Overlapping radio events will use
+	  the is_abort_cb mechanism to decide on continuation of the connection
+	  event.
+
 config BT_CTLR_EVENT_OVERHEAD_RESERVE_MAX
 	bool "Reserve maximum event overhead in time reservations"
 	default y

subsys/bluetooth/controller/ll_sw/lll.h

@@ -239,6 +239,9 @@
 
 struct lll_prepare_param {
 	uint32_t ticks_at_expire;
+#if defined(CONFIG_BT_CTLR_SYNC_ISO_SLOT_WINDOW_JITTER)
+	uint32_t ticks_drift;
+#endif /* CONFIG_BT_CTLR_SYNC_ISO_SLOT_WINDOW_JITTER */
 	uint32_t remainder;
 	uint16_t lazy;
 #if defined(CONFIG_BT_CTLR_JIT_SCHEDULING)
@@ -505,7 +508,8 @@
 				struct {
 					uint16_t trx_cnt;
 					uint8_t  crc_valid:1;
+					uint8_t  is_aborted:1;
 #if defined(CONFIG_BT_CTLR_SYNC_ISO)
 					uint8_t  estab_failed:1;
 #endif /* CONFIG_BT_CTLR_SYNC_ISO */
 #if defined(CONFIG_BT_CTLR_SYNC_PERIODIC_CTE_TYPE_FILTERING) && \

subsys/bluetooth/controller/ll_sw/lll_conn.h

@@ -48,6 +48,7 @@
 	uint16_t latency;
 
 	uint16_t latency_prepare;
+	uint16_t lazy_prepare;
 	uint16_t latency_event;
 	uint16_t event_counter;
 
@@ -69,12 +70,21 @@
 		struct {
 			uint8_t initiated:1;
 			uint8_t cancelled:1;
+			uint8_t forced:1;
+		};
+
+		struct {
+			uint8_t initiated:1;
+			uint8_t cancelled:1;
+			uint8_t forced:1;
 		} central;
+
 #if defined(CONFIG_BT_PERIPHERAL)
 		struct {
 			uint8_t  initiated:1;
 			uint8_t  cancelled:1;
+			uint8_t  forced:1;
 			uint8_t  latency_enabled:1;
 
 			uint32_t window_widening_periodic_us;
 			uint32_t window_widening_max_us;
@@ -160,6 +170,7 @@
 void lll_conn_flush(uint16_t handle, struct lll_conn *lll);
 
 void lll_conn_prepare_reset(void);
+int lll_conn_is_abort_cb(void *next, void *curr, lll_prepare_cb_t *resume_cb);
 void lll_conn_abort_cb(struct lll_prepare_param *prepare_param, void *param);
 void lll_conn_isr_rx(void *param);
 void lll_conn_isr_tx(void *param);

subsys/bluetooth/controller/ll_sw/lll_conn_iso.h

@@ -93,6 +93,7 @@ struct lll_conn_iso_group {
 
 	/* Accumulates LLL prepare callback latencies */
 	uint16_t latency_prepare;
+	uint16_t lazy_prepare;
 	uint16_t latency_event;
 
 #if defined(CONFIG_BT_CTLR_PERIPHERAL_ISO)

subsys/bluetooth/controller/ll_sw/lll_sync.h

@@ -27,7 +27,8 @@
 	uint8_t filter_policy:1;
 	uint8_t is_rx_enabled:1;
 	uint8_t is_aux_sched:1;
+	uint8_t forced:1;
 
 #if defined(CONFIG_BT_CTLR_SYNC_ISO)
 	uint8_t sca:3;
 #endif /* CONFIG_BT_CTLR_SYNC_ISO */
@@ -41,6 +42,7 @@
 #endif /* CONFIG_BT_CTLR_SCAN_AUX_SYNC_RESERVE_MIN */
 
 	uint16_t skip_prepare;
+	uint16_t lazy_prepare;
 	uint16_t skip_event;
 	uint16_t event_counter;
 

subsys/bluetooth/controller/ll_sw/lll_sync_iso.h

@@ -67,6 +67,8 @@
 	uint8_t chm_chan_map[PDU_CHANNEL_MAP_SIZE];
 	uint8_t chm_chan_count:6;
 
+	uint8_t is_lll_resume:1;
+
 	uint8_t term_reason;
 
 	uint16_t ctrl_instant;

subsys/bluetooth/controller/ll_sw/nordic/lll/lll.c

@@ -45,7 +45,8 @@
 static struct {
 	struct {
 		void              *param;
+		uint32_t          ticks_at_expire;
 		lll_is_abort_cb_t is_abort_cb;
 		lll_abort_cb_t    abort_cb;
 	} curr;
 
@@ -882,6 +883,7 @@
 	LL_ASSERT(!ready || &ready->prepare_param == prepare_param);
 
 	event.curr.param = prepare_param->param;
+	event.curr.ticks_at_expire = prepare_param->ticks_at_expire;
 	event.curr.is_abort_cb = is_abort_cb;
 	event.curr.abort_cb = abort_cb;
 
@@ -962,6 +964,8 @@
 	prepare_param.param = event.curr.param;
 	event.curr.param = NULL;
 
+	prepare_param.ticks_at_expire = event.curr.ticks_at_expire;
+
 	return ull_prepare_enqueue(event.curr.is_abort_cb, event.curr.abort_cb,
 				   &prepare_param, resume_cb, 1);
 }
@@ -1235,15 +1239,45 @@
 	}
 
 	/* Check if current event want to continue */
-	err = event.curr.is_abort_cb(ready->prepare_param.param, event.curr.param, &resume_cb);
+	err = event.curr.is_abort_cb(ready->prepare_param.param,
+				     event.curr.param, &resume_cb);
 	if (!err) {
-		/* Let preemptor LLL know about the cancelled prepare */
+		/* Do not need to ask same event wants to continue */
+		if (event.curr.param != ready->prepare_param.param) {
+			/* Check if ready event want to continue */
+			err = ready->is_abort_cb(NULL,
+						 ready->prepare_param.param,
+						 &resume_cb);
+			if (!err) {
+				err = -ECANCELED;
+
+				goto preempt_cancel_curr;
+			}
+		}
+
+		/* Let the prepare be dequeued from the pipeline */
 		ready->is_aborted = 1;
+
+		/* Check if resume requested */
+		if (err == -EAGAIN) {
+			struct lll_event *next;
+
+			next = ull_prepare_enqueue(ready->is_abort_cb,
+						   ready->abort_cb,
+						   &ready->prepare_param,
+						   resume_cb, 1U);
+			LL_ASSERT(next);
+
+			return;
+		}
+
+		/* Let preemptor LLL know about the cancelled prepare */
 		ready->abort_cb(&ready->prepare_param, ready->prepare_param.param);
 
 		return;
 	}
 
+preempt_cancel_curr:
 	/* Abort the current event */
 	event.curr.abort_cb(NULL, event.curr.param);
 

subsys/bluetooth/controller/ll_sw/nordic/lll/lll_adv.c

@@ -1086,8 +1086,15 @@ static int resume_prepare_cb(struct lll_prepare_param *p)
 static int is_abort_cb(void *next, void *curr, lll_prepare_cb_t *resume_cb)
 {
 #if defined(CONFIG_BT_PERIPHERAL)
-	struct lll_adv *lll = curr;
+	struct lll_adv *lll;
 	struct pdu_adv *pdu;
+
+	/* Prepare being cancelled (no resume for directed adv) */
+	if (!next) {
+		return -ECANCELED;
+	}
+
+	lll = curr;
 #endif /* CONFIG_BT_PERIPHERAL */
 
 	/* TODO: prio check */

subsys/bluetooth/controller/ll_sw/nordic/lll/lll_central.c

@@ -120,7 +120,8 @@ static int prepare_cb(struct lll_prepare_param *p)
 	lll_conn_prepare_reset();
 
 	/* Calculate the current event latency */
-	lll->latency_event = lll->latency_prepare + p->lazy;
+	lll->lazy_prepare = p->lazy;
+	lll->latency_event = lll->latency_prepare + lll->lazy_prepare;
 
 	/* Calculate the current event counter value */
 	event_counter = lll->event_counter + lll->latency_event;

subsys/bluetooth/controller/ll_sw/nordic/lll/lll_conn.c

@@ -59,6 +59,7 @@
 
 static uint8_t crc_expire;
 static uint8_t crc_valid;
+static uint8_t is_aborted;
 static uint16_t trx_cnt;
 
 #if defined(CONFIG_BT_CTLR_LE_ENC)
@@ -142,12 +143,25 @@
 	trx_cnt = 0U;
 	crc_valid = 0U;
 	crc_expire = 0U;
+	is_aborted = 0U;
 
 #if defined(CONFIG_BT_CTLR_LE_ENC)
 	mic_state = LLL_CONN_MIC_NONE;
 #endif /* CONFIG_BT_CTLR_LE_ENC */
 }
 
+int lll_conn_is_abort_cb(void *next, void *curr, lll_prepare_cb_t *resume_cb)
+{
+	struct lll_conn *lll = curr;
+
+	/* Do not abort if near supervision timeout */
+	if (lll->forced) {
+		return 0;
+	}
+
+	return -ECANCELED;
+}
+
 void lll_conn_abort_cb(struct lll_prepare_param *prepare_param, void *param)
 {
 	struct event_done_extra *e;
@@ -156,6 +170,17 @@
 
 	/* NOTE: This is not a prepare being cancelled */
 	if (!prepare_param) {
+		/* Get reference to LLL connection context */
+		lll = param;
+
+		/* For a peripheral role, ensure at least one PDU is tx-ed
+		 * back to central, otherwise let the supervision timeout
+		 * countdown be started.
+		 */
+		if (lll->role && (trx_cnt <= 1U)) {
+			is_aborted = 1U;
+		}
+
 		/* Perform event abort here.
 		 * After event has been cleanly aborted, clean up resources
 		 * and dispatch event done.
@@ -171,9 +196,26 @@
 	err = lll_hfclock_off();
 	LL_ASSERT(err >= 0);
 
-	/* Accumulate the latency as event is aborted while being in pipeline */
+	/* Get reference to LLL connection context */
 	lll = prepare_param->param;
-	lll->latency_prepare += (prepare_param->lazy + 1);
+
+	/* Accumulate the latency as event is aborted while being in pipeline */
+	lll->lazy_prepare = prepare_param->lazy;
+	lll->latency_prepare += (lll->lazy_prepare + 1U);
+
+#if defined(CONFIG_BT_PERIPHERAL)
+	if (lll->role) {
+		/* Accumulate window widening */
+		lll->periph.window_widening_prepare_us +=
+		    lll->periph.window_widening_periodic_us *
+		    (prepare_param->lazy + 1);
+		if (lll->periph.window_widening_prepare_us >
+		    lll->periph.window_widening_max_us) {
+			lll->periph.window_widening_prepare_us =
+				lll->periph.window_widening_max_us;
+		}
+	}
+#endif /* CONFIG_BT_PERIPHERAL */
 
 	/* Extra done event, to check supervision timeout */
 	e = ull_event_done_extra_get();
@@ -867,6 +909,7 @@
 	e->type = EVENT_DONE_EXTRA_TYPE_CONN;
 	e->trx_cnt = trx_cnt;
 	e->crc_valid = crc_valid;
+	e->is_aborted = is_aborted;
 
 #if defined(CONFIG_BT_CTLR_LE_ENC)
 	e->mic_state = mic_state;

subsys/bluetooth/controller/ll_sw/nordic/lll/lll_peripheral.c

@@ -79,18 +79,10 @@
 
 	lll = p->param;
 
-	/* Accumulate window widening */
-	lll->periph.window_widening_prepare_us +=
-	    lll->periph.window_widening_periodic_us * (p->lazy + 1);
-	if (lll->periph.window_widening_prepare_us >
-	    lll->periph.window_widening_max_us) {
-		lll->periph.window_widening_prepare_us =
-			lll->periph.window_widening_max_us;
-	}
-
 	/* Invoke common pipeline handling of prepare */
-	err = lll_prepare(lll_is_abort_cb, lll_conn_abort_cb, prepare_cb, 0, p);
+	err = lll_prepare(lll_conn_is_abort_cb, lll_conn_abort_cb, prepare_cb,
+			  0U, p);
 	LL_ASSERT(!err || err == -EINPROGRESS);
 }
 
 static int init_reset(void)
@@ -132,7 +124,8 @@
 	lll_conn_prepare_reset();
 
 	/* Calculate the current event latency */
-	lll->latency_event = lll->latency_prepare + p->lazy;
+	lll->lazy_prepare = p->lazy;
+	lll->latency_event = lll->latency_prepare + lll->lazy_prepare;
 
 	/* Calculate the current event counter value */
 	event_counter = lll->event_counter + lll->latency_event;
@@ -160,6 +153,15 @@
 					       lll->data_chan_count);
 	}
 
+	/* Accumulate window widening */
+	lll->periph.window_widening_prepare_us +=
+	    lll->periph.window_widening_periodic_us * (lll->lazy_prepare + 1U);
+	if (lll->periph.window_widening_prepare_us >
+	    lll->periph.window_widening_max_us) {
+		lll->periph.window_widening_prepare_us =
+			lll->periph.window_widening_max_us;
+	}
+
 	/* current window widening */
 	lll->periph.window_widening_event_us +=
 		lll->periph.window_widening_prepare_us;