subsys/bluetooth/controller/ll_sw/ull_sched.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2018-2022 Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <zephyr/sys/byteorder.h>
 #include <zephyr/bluetooth/hci.h>

 #include "hal/ccm.h"
 #include "hal/radio.h"
 #include "hal/ticker.h"

 #include "util/util.h"
 #include "util/memq.h"
 #include "util/mayfly.h"
 #include "util/dbuf.h"
 #include "util/mem.h"

 #include "ticker/ticker.h"

 #include "pdu_df.h"
 #include "lll/pdu_vendor.h"
 #include "pdu.h"

 #include "lll.h"
 #include "lll/lll_vendor.h"
 #include "lll/lll_adv_types.h"
 #include "lll_adv.h"
 #include "lll/lll_adv_pdu.h"
 #include "lll_adv_sync.h"
 #include "lll_scan.h"
 #include "lll/lll_df_types.h"
 #include "lll_conn.h"
 #include "lll_conn_iso.h"

 #include "ll_sw/ull_tx_queue.h"

 #include "ull_adv_types.h"
 #include "ull_scan_types.h"
 #include "ull_conn_types.h"

 #include "isoal.h"
 #include "ull_iso_types.h"
 #include "ull_conn_iso_types.h"

 #include "ull_internal.h"
 #include "ull_adv_internal.h"
 #include "ull_conn_internal.h"
 #include "ull_conn_iso_internal.h"

 #include "ll_feat.h"

 #include "hal/debug.h"


 #if defined(CONFIG_BT_CENTRAL)
 static void after_cen_offset_get(uint16_t conn_interval, uint32_t ticks_slot,
 				 uint32_t ticks_anchor,
 				 uint32_t *win_offset_us);
 static bool ticker_match_cen_op_cb(uint8_t ticker_id, uint32_t ticks_slot,
 				   uint32_t ticks_to_expire, void *op_context);
 #endif /* CONFIG_BT_CENTRAL */

 typedef struct ull_hdr *(*ull_hdr_get_func)(uint8_t ticker_id,
 					    uint32_t *ticks_slot);
 static uint8_t after_match_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
 				    ticker_op_match_func ticker_match_op_cb,
 				    ull_hdr_get_func ull_hdr_get_cb,
 				    uint32_t *ticks_anchor,
 				    uint32_t *ticks_to_expire_match,
 				    uint32_t *remainder_match,
 				    uint32_t *ticks_slot_match);
 static void ticker_op_cb(uint32_t status, void *param);
 static struct ull_hdr *ull_hdr_get_cb(uint8_t ticker_id, uint32_t *ticks_slot);

 #if (defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)) || \
 	defined(CONFIG_BT_CTLR_CENTRAL_ISO)
 static int group_free_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
 			       uint32_t *ticks_to_expire_prev,
 			       uint32_t *ticks_slot_prev,
 			       uint32_t *ticks_anchor);
 static bool ticker_match_any_op_cb(uint8_t ticker_id, uint32_t ticks_slot,
 				   uint32_t ticks_to_expire, void *op_context);
 #endif /* (CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER) ||
 	* CONFIG_BT_CTLR_CENTRAL_ISO
 	*/

 #if defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)
 int ull_sched_adv_aux_sync_free_anchor_get(uint32_t ticks_slot_abs,
 					   uint32_t *ticks_anchor)
 {
 	uint32_t ticks_to_expire;
 	uint32_t ticks_slot;

 	return group_free_slot_get(TICKER_USER_ID_THREAD, ticks_slot_abs,
 				   &ticks_to_expire, &ticks_slot, ticks_anchor);
 }
 #endif /* CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER */

 #if defined(CONFIG_BT_CTLR_CENTRAL_ISO)
 int ull_sched_conn_iso_free_offset_get(uint32_t ticks_slot_abs,
 				       uint32_t *ticks_to_expire)
 {
 	uint32_t ticks_anchor;
 	uint32_t ticks_slot;
 	int err;

 	err = group_free_slot_get(TICKER_USER_ID_ULL_LOW, ticks_slot_abs,
 				  ticks_to_expire, &ticks_slot, &ticks_anchor);
 	if (err) {
 		return err;
 	}

 	*ticks_to_expire += ticks_slot;

 	return err;
 }
 #endif /* CONFIG_BT_CTLR_CENTRAL_ISO */

 #if defined(CONFIG_BT_CONN)
 #if defined(CONFIG_BT_CENTRAL)
 int ull_sched_after_cen_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
 				 uint32_t *ticks_anchor, uint32_t *us_offset)
 {
 	uint32_t ticks_to_expire;
 	uint32_t ticks_slot;
 	uint32_t remainder;
 	uint8_t ticker_id;

 	ticker_id = after_match_slot_get(user_id, ticks_slot_abs,
 					 ticker_match_cen_op_cb, ull_hdr_get_cb,
 					 ticks_anchor, &ticks_to_expire,
 					 &remainder, &ticks_slot);
 	if (ticker_id != TICKER_NULL) {
 		uint32_t central_spacing_us;
 		uint32_t remainder_us;
 		uint32_t slot_us;

 		/* When CONFIG_BT_CTLR_CENTRAL_SPACING is used then ticks_slot
 		 * returned converts to slot_us that is less than or equal to
 		 * CONFIG_BT_CTLR_CENTRAL_SPACING, because floor value in ticks
 		 * is returned as ticks_slot.
 		 * Hence, use CONFIG_BT_CTLR_CENTRAL_SPACING without margin.
 		 *
 		 * If actual ticks_slot in microseconds is larger than
 		 * CONFIG_BT_CTLR_CENTRAL_SPACING, then add margin between
 		 * central radio events.
 		 */
 		slot_us = HAL_TICKER_TICKS_TO_US(ticks_slot);
 		if (slot_us > CONFIG_BT_CTLR_CENTRAL_SPACING) {
 			central_spacing_us = slot_us;
 			central_spacing_us += (EVENT_TICKER_RES_MARGIN_US << 1);
 		} else {
 			central_spacing_us = CONFIG_BT_CTLR_CENTRAL_SPACING;
 		}

 		remainder_us = remainder;
 		hal_ticker_remove_jitter(&ticks_to_expire, &remainder_us);

 		*us_offset = HAL_TICKER_TICKS_TO_US(ticks_to_expire) +
 			     remainder_us + central_spacing_us;

 		return 0;
 	}

 	return -ECHILD;
 }

 void ull_sched_mfy_after_cen_offset_get(void *param)
 {
 	struct lll_prepare_param *p = param;
 	struct lll_scan *lll = p->param;
 	uint32_t ticks_slot_overhead;
 	uint32_t ticks_at_expire;
 	uint32_t remainder_us;
 	struct ll_conn *conn;

 	conn = HDR_LLL2ULL(lll->conn);
 	if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
 		ticks_slot_overhead = MAX(conn->ull.ticks_active_to_start,
 					  conn->ull.ticks_prepare_to_start);
 	} else {
 		ticks_slot_overhead = 0U;
 	}

 	ticks_at_expire = p->ticks_at_expire;
 	remainder_us = p->remainder;
 	hal_ticker_remove_jitter(&ticks_at_expire, &remainder_us);

 	after_cen_offset_get(lll->conn->interval,
 			     (ticks_slot_overhead + conn->ull.ticks_slot),
 			     ticks_at_expire, &lll->conn_win_offset_us);
 	if (lll->conn_win_offset_us) {
 		lll->conn_win_offset_us +=
 			HAL_TICKER_TICKS_TO_US(p->ticks_at_expire -
 					       ticks_at_expire) -
 			remainder_us;
 	}
 }
 #endif /* CONFIG_BT_CENTRAL */

 void ull_sched_mfy_win_offset_use(void *param)
 {
 	struct ll_conn *conn = param;
 	uint32_t ticks_slot_overhead;

 	if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
 		ticks_slot_overhead = MAX(conn->ull.ticks_active_to_start,
 					  conn->ull.ticks_prepare_to_start);
 	} else {
 		ticks_slot_overhead = 0U;
 	}

 	/*
 	 * TODO: update calculationg of the win_offset
 	 * when updating the connection update procedure
 	 * see the legacy code from Zephyr v3.3 for inspiration
 	 */
 }

 #if defined(CONFIG_BT_CTLR_CONN_PARAM_REQ)
 void ull_sched_mfy_free_win_offset_calc(void *param)
 {
 	uint32_t ticks_to_offset_default = 0U;
 	uint32_t *ticks_to_offset_next;

 	ticks_to_offset_next = &ticks_to_offset_default;

 	/*
 	 * TODO: update when updating the connection update procedure
 	 * see the legacy code from Zephyr v3.3 for inspiration
 	 */
 }

 void ull_sched_mfy_win_offset_select(void *param)
 {
 #define OFFSET_S_MAX 6
 #define OFFSET_M_MAX 6

 	/*
 	 * TODO: update calculation of win_offset when
 	 * updating the connection update procedure
 	 * see the legacy code from Zephyr v3.3 for inspiration
 	 */

 #undef OFFSET_S_MAX
 #undef OFFSET_M_MAX
 }

 /*
  * TODO: probably we need a function for calculating the window offset
  * see the legacy code from Zephyr v3.3 for inspiration
  */
 #endif /* CONFIG_BT_CTLR_CONN_PARAM_REQ */

 #if defined(CONFIG_BT_CENTRAL)
 static void after_cen_offset_get(uint16_t conn_interval, uint32_t ticks_slot,
 				 uint32_t ticks_anchor,
 				 uint32_t *win_offset_us)
 {
 	uint32_t ticks_anchor_offset = ticks_anchor;
 	int err;

 	err = ull_sched_after_cen_slot_get(TICKER_USER_ID_ULL_LOW, ticks_slot,
 					   &ticks_anchor_offset,
 					   win_offset_us);
 	if (err) {
 		return;
 	}

 	if ((ticks_anchor_offset - ticks_anchor) & BIT(HAL_TICKER_CNTR_MSBIT)) {
 		*win_offset_us -= HAL_TICKER_TICKS_TO_US(
 			ticker_ticks_diff_get(ticks_anchor,
 					      ticks_anchor_offset));
 	} else {
 		*win_offset_us += HAL_TICKER_TICKS_TO_US(
 			ticker_ticks_diff_get(ticks_anchor_offset,
 					      ticks_anchor));
 	}

 	/* Round positive offset value in the future to within one connection
 	 * interval value.
 	 * Offsets in the past, value with MSBit set, are handled by caller by
 	 * adding radio end time and connection interval as necessary to get a
 	 * window offset in future when establishing a connection.
 	 */
 	if ((*win_offset_us & BIT(31)) == 0) {
 		uint32_t conn_interval_us = conn_interval * CONN_INT_UNIT_US;

 		while (*win_offset_us > conn_interval_us) {
 			*win_offset_us -= conn_interval_us;
 		}
 	}
 }
 #endif /* CONFIG_BT_CENTRAL */
 #endif /* CONFIG_BT_CONN */

 #if (defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)) || \
 	defined(CONFIG_BT_CTLR_CENTRAL_ISO)
 static int group_free_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
 			       uint32_t *ticks_to_expire_prev,
 			       uint32_t *ticks_slot_prev,
 			       uint32_t *ticks_anchor)
 {
 	uint32_t remainder_prev;
 	uint8_t ticker_id;

 	ticker_id = after_match_slot_get(user_id, ticks_slot_abs,
 					 ticker_match_any_op_cb, ull_hdr_get_cb,
 					 ticks_anchor, ticks_to_expire_prev,
 					 &remainder_prev, ticks_slot_prev);
 	if (ticker_id != TICKER_NULL) {
 		uint32_t ticks_to_expire;
 		uint32_t ticks_slot;

 		ticks_to_expire = *ticks_to_expire_prev;
 		ticks_slot = *ticks_slot_prev;

 		if (false) {

 #if defined(CONFIG_BT_BROADCASTER)
 		} 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;

 			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;

 				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);
 			}

 			return 0;

 #if defined(CONFIG_BT_CTLR_ADV_PERIODIC)
 		} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_SYNC_BASE,
 				    TICKER_ID_ADV_SYNC_LAST)) {
 			*ticks_anchor += ticks_to_expire;
 			*ticks_anchor += ticks_slot;

 			if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
 				const struct ll_adv_sync_set *sync;

 				sync = ull_adv_sync_get(ticker_id -
 							TICKER_ID_ADV_SYNC_BASE);
 				*ticks_anchor +=
 					MAX(sync->ull.ticks_active_to_start,
 					    sync->ull.ticks_prepare_to_start);
 			}

 			return 0;

 #if defined(CONFIG_BT_CTLR_ADV_ISO)
 		} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_ISO_BASE,
 				    TICKER_ID_ADV_ISO_LAST)) {
 			*ticks_anchor += ticks_to_expire;
 			*ticks_anchor += ticks_slot;

 			if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
 				const struct ll_adv_iso_set *iso;

 				iso = ull_adv_iso_get(ticker_id -
 						      TICKER_ID_ADV_ISO_BASE);
 				*ticks_anchor +=
 					MAX(iso->ull.ticks_active_to_start,
 					    iso->ull.ticks_prepare_to_start);
 			}

 			return 0;

 #endif /* CONFIG_BT_CTLR_ADV_ISO */
 #endif /* CONFIG_BT_CTLR_ADV_PERIODIC */
 #endif /* CONFIG_BT_BROADCASTER */

 #if defined(CONFIG_BT_CONN)
 		} else if (IN_RANGE(ticker_id, TICKER_ID_CONN_BASE,
 				    TICKER_ID_CONN_LAST)) {
 			*ticks_anchor += ticks_to_expire;
 			*ticks_anchor += ticks_slot;

 			return 0;
 #endif /* CONFIG_BT_CONN */

 		}
 	}

 	return -ECHILD;
 }
 #endif /* (CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER) ||
 	* CONFIG_BT_CTLR_CENTRAL_ISO
 	*/

 static uint8_t after_match_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
 				    ticker_op_match_func ticker_match_op_cb,
 				    ull_hdr_get_func ull_hdr_get_cb,
 				    uint32_t *ticks_anchor,
 				    uint32_t *ticks_to_expire_match,
 				    uint32_t *remainder_match,
 				    uint32_t *ticks_slot_match)
 {
 	uint32_t ticks_to_expire_prev;
 	uint32_t ticks_slot_abs_prev;
 	uint32_t ticks_anchor_prev;
 	uint32_t ticks_to_expire;
 	uint32_t remainder_prev;
 	uint32_t remainder;
 	uint8_t ticker_id_prev;
 	uint8_t ticker_id;
 	uint8_t retry;

 	/* As we may place the event between two other events, ensure there is
 	 * space for 4 times +/- 16 us jitter. I.e. with 32KHz sleep clock,
 	 * ~30.517 us after previous event, ~30.517 us before and after current
 	 * event, and an ~30.517 us before next event. Hence 8 time of ceil
 	 * value 16 us (30.517 / 2) or 4 times EVENT_TICKER_RES_MARGIN_US.
 	 */
 	ticks_slot_abs += HAL_TICKER_US_TO_TICKS(EVENT_TICKER_RES_MARGIN_US << 2);

 	/* There is a possibility that ticker nodes expire during iterations in
 	 * this function causing the reference ticks_anchor returned for the
 	 * found ticker to change. In this case the iterations have to be
 	 * restarted with the new reference ticks_anchor value.
 	 * Simultaneous continuous scanning on 1M and Coded PHY, alongwith
 	 * directed advertising and one other state/role could expire in quick
 	 * succession, hence have a retry count of 4.
 	 */
 	retry = 4U;

 	/* Initialize variable required for iterations to find a free slot */
 	ticker_id = ticker_id_prev = TICKER_NULL;
 	ticks_anchor_prev = 0U;
 	ticks_to_expire = ticks_to_expire_prev = 0U;
 	remainder = remainder_prev = 0U;
 	ticks_slot_abs_prev = 0U;
 	while (1) {
 		uint32_t ticks_slot_abs_curr = 0U;
 		uint32_t ticks_to_expire_normal;
 		uint32_t volatile ret_cb;
 		uint32_t ticks_slot;
 		struct ull_hdr *hdr;
 		uint32_t ret;
 		bool success;

 		ret_cb = TICKER_STATUS_BUSY;
 #if defined(CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH)
 		ret = ticker_next_slot_get_ext(TICKER_INSTANCE_ID_CTLR, user_id,
 					       &ticker_id, ticks_anchor,
 					       &ticks_to_expire, &remainder,
 					       NULL, /* lazy */
 					       ticker_match_op_cb,
 					       NULL, /* match_op_context */
 					       ticker_op_cb, (void *)&ret_cb);
 #else /* !CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH */
 		ret = ticker_next_slot_get(TICKER_INSTANCE_ID_CTLR, user_id,
 					   &ticker_id, ticks_anchor,
 					   &ticks_to_expire,
 					   ticker_op_cb, (void *)&ret_cb);
 #endif /* !CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH */
 		if (ret == TICKER_STATUS_BUSY) {
 			while (ret_cb == TICKER_STATUS_BUSY) {
 				ticker_job_sched(TICKER_INSTANCE_ID_CTLR,
 						 user_id);
 			}
 		}

 		/* Using a local variable to address the Coverity rule:
 		 * Incorrect expression  (ASSERT_SIDE_EFFECT)
 		 * Argument "ret_cb" of LL_ASSERT() has a side effect
 		 * because the variable is volatile.  The containing function
 		 * might work differently in a non-debug build.
 		 */
 		success = (ret_cb == TICKER_STATUS_SUCCESS);
 		LL_ASSERT(success);

 		/* There is a possibility that tickers expire while we
 		 * iterate through the active list of tickers, start over with
 		 * a fresh iteration.
 		 */
 		if ((ticker_id_prev != TICKER_NULL) &&
 		    (*ticks_anchor != ticks_anchor_prev)) {
 			LL_ASSERT(retry);
 			retry--;

 			ticker_id = ticker_id_prev = TICKER_NULL;

 			continue;
 		}

 		/* No more active tickers with slot */
 		if (ticker_id == TICKER_NULL) {
 			break;
 		}

 #if !defined(CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH)
 		if (!ticker_match_op_cb(ticker_id, 0, 0, NULL)) {
 			continue;
 		}
 #endif /* CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH */

 		hdr = ull_hdr_get_cb(ticker_id, &ticks_slot);
 		if (!hdr) {
 			continue;
 		}

 		ticks_to_expire_normal = ticks_to_expire;

 #if defined(CONFIG_BT_CTLR_LOW_LAT)
 #if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
 		if (hdr->ticks_prepare_to_start & XON_BITMASK) {
 			const uint32_t ticks_prepare_to_start =
 				MAX(hdr->ticks_active_to_start,
 				    hdr->ticks_preempt_to_start);

 			ticks_slot_abs_curr = hdr->ticks_prepare_to_start &
 					      ~XON_BITMASK;
 			ticks_to_expire_normal -= ticks_slot_abs_curr -
 						  ticks_prepare_to_start;
 		} else
 #endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */
 		{
 			const uint32_t ticks_prepare_to_start =
 				MAX(hdr->ticks_active_to_start,
 				    hdr->ticks_prepare_to_start);

 			ticks_slot_abs_curr = ticks_prepare_to_start;
 		}
 #endif

 		ticks_slot_abs_curr += ticks_slot;

 		if ((ticker_id_prev != TICKER_NULL) &&
 		    (ticker_ticks_diff_get(ticks_to_expire_normal,
 					   ticks_to_expire_prev) >
 		     (ticks_slot_abs_prev + ticks_slot_abs))) {
 			break;
 		}

 		ticks_anchor_prev = *ticks_anchor;
 		ticker_id_prev = ticker_id;
 		ticks_to_expire_prev = ticks_to_expire_normal;
 		remainder_prev = remainder;
 		ticks_slot_abs_prev = ticks_slot_abs_curr;
 	}

 	if (ticker_id_prev != TICKER_NULL) {
 		*ticks_to_expire_match = ticks_to_expire_prev;
 		*remainder_match = remainder_prev;
 		*ticks_slot_match = ticks_slot_abs_prev;
 	}

 	return ticker_id_prev;
 }

 static void ticker_op_cb(uint32_t status, void *param)
 {
 	*((uint32_t volatile *)param) = status;
 }

 #if (defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)) || \
 	defined(CONFIG_BT_CTLR_CENTRAL_ISO)
 static bool ticker_match_any_op_cb(uint8_t ticker_id, uint32_t ticks_slot,
 				   uint32_t ticks_to_expire, void *op_context)
 {
 	ARG_UNUSED(ticks_slot);
 	ARG_UNUSED(ticks_to_expire);
 	ARG_UNUSED(op_context);

 	return false ||

 #if defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)
 	       IN_RANGE(ticker_id, TICKER_ID_ADV_AUX_BASE,
 			TICKER_ID_ADV_AUX_LAST) ||

 #if defined(CONFIG_BT_CTLR_ADV_PERIODIC)
 	       IN_RANGE(ticker_id, TICKER_ID_ADV_SYNC_BASE,
 			TICKER_ID_ADV_SYNC_LAST) ||

 #if defined(CONFIG_BT_CTLR_ADV_ISO)
 	       IN_RANGE(ticker_id, TICKER_ID_ADV_ISO_BASE,
 			TICKER_ID_ADV_ISO_LAST) ||
 #endif /* CONFIG_BT_CTLR_ADV_ISO */
 #endif /* CONFIG_BT_CTLR_ADV_PERIODIC */
 #endif /* CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER */

 #if defined(CONFIG_BT_CONN)
 	       IN_RANGE(ticker_id, TICKER_ID_CONN_BASE,
 			TICKER_ID_CONN_LAST) ||

 #if defined(CONFIG_BT_CTLR_CENTRAL_ISO)
 	       IN_RANGE(ticker_id, TICKER_ID_CONN_ISO_BASE,
 			TICKER_ID_CONN_ISO_LAST) ||
 #endif /* CONFIG_BT_CTLR_CENTRAL_ISO */
 #endif /* CONFIG_BT_CONN */

 	       false;
 }
 #endif /* (CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER) ||
 	* CONFIG_BT_CTLR_CENTRAL_ISO
 	*/

 #if defined(CONFIG_BT_CENTRAL)
 static bool ticker_match_cen_op_cb(uint8_t ticker_id, uint32_t ticks_slot,
 				   uint32_t ticks_to_expire, void *op_context)
 {
 	ARG_UNUSED(ticks_slot);
 	ARG_UNUSED(ticks_to_expire);
 	ARG_UNUSED(op_context);

 	return IN_RANGE(ticker_id, TICKER_ID_CONN_BASE,
 			TICKER_ID_CONN_LAST) ||
 #if defined(CONFIG_BT_CTLR_CENTRAL_ISO) && \
 		(CONFIG_BT_CTLR_CENTRAL_SPACING == 0)
 	       IN_RANGE(ticker_id, TICKER_ID_CONN_ISO_BASE,
 			TICKER_ID_CONN_ISO_LAST) ||
 #endif /* CONFIG_BT_CTLR_CENTRAL_ISO &&
 	*  (CONFIG_BT_CTLR_CENTRAL_SPACING == 0)
 	*/
 	       false;
 }
 #endif /* CONFIG_BT_CENTRAL */

 static struct ull_hdr *ull_hdr_get_cb(uint8_t ticker_id, uint32_t *ticks_slot)
 {
 	if (false) {

 #if defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)
 	} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_AUX_BASE,
 		     TICKER_ID_ADV_AUX_LAST)) {
 		struct ll_adv_aux_set *aux;

 		aux = ull_adv_aux_get(ticker_id - TICKER_ID_ADV_AUX_BASE);
 		if (aux) {
 			if (IS_ENABLED(CONFIG_BT_CTLR_ADV_RESERVE_MAX)) {
 				uint32_t time_us;

 				time_us = ull_adv_aux_time_get(aux, PDU_AC_PAYLOAD_SIZE_MAX,
 							       PDU_AC_PAYLOAD_SIZE_MAX);
 				*ticks_slot = HAL_TICKER_US_TO_TICKS(time_us);
 			} else {
 				*ticks_slot = aux->ull.ticks_slot;

 #if defined(CONFIG_BT_CTLR_ADV_AUX_SYNC_OFFSET) && \
 	(CONFIG_BT_CTLR_ADV_AUX_SYNC_OFFSET != 0)
 				struct ll_adv_sync_set *sync;

 				sync = HDR_LLL2ULL(aux->lll.adv->sync);
 				if (sync->ull.ticks_slot > *ticks_slot) {
 					*ticks_slot = sync->ull.ticks_slot;
 				}
 #endif /* CONFIG_BT_CTLR_ADV_AUX_SYNC_OFFSET */

 			}

 			return &aux->ull;
 		}

 #if defined(CONFIG_BT_CTLR_ADV_PERIODIC)
 	} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_SYNC_BASE,
 		     TICKER_ID_ADV_SYNC_LAST)) {
 		struct ll_adv_sync_set *sync;

 		sync = ull_adv_sync_get(ticker_id - TICKER_ID_ADV_SYNC_BASE);
 		if (sync) {
 			if (IS_ENABLED(CONFIG_BT_CTLR_ADV_RESERVE_MAX)) {
 				uint32_t time_us;

 				time_us = ull_adv_sync_time_get(sync, PDU_AC_PAYLOAD_SIZE_MAX);
 				*ticks_slot = HAL_TICKER_US_TO_TICKS(time_us);
 			} else {
 				*ticks_slot = sync->ull.ticks_slot;
 			}

 			return &sync->ull;
 		}

 #if defined(CONFIG_BT_CTLR_ADV_ISO)
 	} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_ISO_BASE,
 			    TICKER_ID_ADV_ISO_LAST)) {
 		struct ll_adv_iso_set *adv_iso;

 		adv_iso = ull_adv_iso_get(ticker_id - TICKER_ID_ADV_ISO_BASE);
 		if (adv_iso) {
 			*ticks_slot = adv_iso->ull.ticks_slot;

 			return &adv_iso->ull;
 		}

 #endif /* CONFIG_BT_CTLR_ADV_ISO */
 #endif /* CONFIG_BT_CTLR_ADV_PERIODIC */
 #endif /* CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER */

 #if defined(CONFIG_BT_CONN)
 	} else if (IN_RANGE(ticker_id, TICKER_ID_CONN_BASE,
 			    TICKER_ID_CONN_LAST)) {
 		struct ll_conn *conn;

 		conn = ll_conn_get(ticker_id - TICKER_ID_CONN_BASE);
 		if (conn && !conn->lll.role) {
 			if (IS_ENABLED(CONFIG_BT_CTLR_CENTRAL_RESERVE_MAX)) {
 				uint32_t ready_delay_us;
 				uint16_t max_tx_time;
 				uint16_t max_rx_time;
 				uint32_t time_us;

 #if defined(CONFIG_BT_CTLR_PHY)
 				ready_delay_us =
 					lll_radio_tx_ready_delay_get(conn->lll.phy_tx,
 								     conn->lll.phy_flags);
 #else
 				ready_delay_us =
 					lll_radio_tx_ready_delay_get(0U, 0U);
 #endif

 #if defined(CONFIG_BT_CTLR_PHY_CODED)
 				max_tx_time = PDU_DC_MAX_US(LL_LENGTH_OCTETS_TX_MAX,
 							    PHY_CODED);
 				max_rx_time = PDU_DC_MAX_US(LL_LENGTH_OCTETS_RX_MAX,
 							    PHY_CODED);
 #else /* !CONFIG_BT_CTLR_PHY_CODED */
 				max_tx_time = PDU_DC_MAX_US(LL_LENGTH_OCTETS_TX_MAX,
 							    PHY_1M);
 				max_rx_time = PDU_DC_MAX_US(LL_LENGTH_OCTETS_RX_MAX,
 							    PHY_1M);
 #endif /* !CONFIG_BT_CTLR_PHY_CODED */

 				time_us = EVENT_OVERHEAD_START_US +
 					  ready_delay_us +  max_rx_time +
 					  EVENT_IFS_US + max_tx_time;
 				*ticks_slot = HAL_TICKER_US_TO_TICKS(time_us);
 			} else {
 				*ticks_slot = conn->ull.ticks_slot;
 			}

 			if (*ticks_slot < CONFIG_BT_CTLR_CENTRAL_SPACING) {
 				*ticks_slot =
 					HAL_TICKER_US_TO_TICKS(CONFIG_BT_CTLR_CENTRAL_SPACING);
 			}

 			return &conn->ull;
 		}

 #if defined(CONFIG_BT_CTLR_CENTRAL_ISO)
 	} else if (IN_RANGE(ticker_id, TICKER_ID_CONN_ISO_BASE,
 			    TICKER_ID_CONN_ISO_LAST)) {
 		struct ll_conn_iso_group *cig;

 		cig = ll_conn_iso_group_get(ticker_id - TICKER_ID_CONN_ISO_BASE);
 		if (cig) {
 			*ticks_slot = cig->ull.ticks_slot;

 			return &cig->ull;
 		}

 #endif /* CONFIG_BT_CTLR_CENTRAL_ISO */
 #endif /* CONFIG_BT_CONN */

 	}

 	return NULL;
 }
	/*
	* Copyright (c) 2018-2022 Nordic Semiconductor ASA
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <zephyr/sys/byteorder.h>
	#include <zephyr/bluetooth/hci.h>

	#include "hal/ccm.h"
	#include "hal/radio.h"
	#include "hal/ticker.h"

	#include "util/util.h"
	#include "util/memq.h"
	#include "util/mayfly.h"
	#include "util/dbuf.h"
	#include "util/mem.h"

	#include "ticker/ticker.h"

	#include "pdu_df.h"
	#include "lll/pdu_vendor.h"
	#include "pdu.h"

	#include "lll.h"
	#include "lll/lll_vendor.h"
	#include "lll/lll_adv_types.h"
	#include "lll_adv.h"
	#include "lll/lll_adv_pdu.h"
	#include "lll_adv_sync.h"
	#include "lll_scan.h"
	#include "lll/lll_df_types.h"
	#include "lll_conn.h"
	#include "lll_conn_iso.h"

	#include "ll_sw/ull_tx_queue.h"

	#include "ull_adv_types.h"
	#include "ull_scan_types.h"
	#include "ull_conn_types.h"

	#include "isoal.h"
	#include "ull_iso_types.h"
	#include "ull_conn_iso_types.h"

	#include "ull_internal.h"
	#include "ull_adv_internal.h"
	#include "ull_conn_internal.h"
	#include "ull_conn_iso_internal.h"

	#include "ll_feat.h"

	#include "hal/debug.h"


	#if defined(CONFIG_BT_CENTRAL)
	static void after_cen_offset_get(uint16_t conn_interval, uint32_t ticks_slot,
	uint32_t ticks_anchor,
	uint32_t *win_offset_us);
	static bool ticker_match_cen_op_cb(uint8_t ticker_id, uint32_t ticks_slot,
	uint32_t ticks_to_expire, void *op_context);
	#endif /* CONFIG_BT_CENTRAL */

	typedef struct ull_hdr (ull_hdr_get_func)(uint8_t ticker_id,
	uint32_t *ticks_slot);
	static uint8_t after_match_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
	ticker_op_match_func ticker_match_op_cb,
	ull_hdr_get_func ull_hdr_get_cb,
	uint32_t *ticks_anchor,
	uint32_t *ticks_to_expire_match,
	uint32_t *remainder_match,
	uint32_t *ticks_slot_match);
	static void ticker_op_cb(uint32_t status, void *param);
	static struct ull_hdr ull_hdr_get_cb(uint8_t ticker_id, uint32_t ticks_slot);

	#if (defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)) \|\| \
	defined(CONFIG_BT_CTLR_CENTRAL_ISO)
	static int group_free_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
	uint32_t *ticks_to_expire_prev,
	uint32_t *ticks_slot_prev,
	uint32_t *ticks_anchor);
	static bool ticker_match_any_op_cb(uint8_t ticker_id, uint32_t ticks_slot,
	uint32_t ticks_to_expire, void *op_context);
	#endif /* (CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER) \|\|
	* CONFIG_BT_CTLR_CENTRAL_ISO
	*/

	#if defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)
	int ull_sched_adv_aux_sync_free_anchor_get(uint32_t ticks_slot_abs,
	uint32_t *ticks_anchor)
	{
	uint32_t ticks_to_expire;
	uint32_t ticks_slot;

	return group_free_slot_get(TICKER_USER_ID_THREAD, ticks_slot_abs,
	&ticks_to_expire, &ticks_slot, ticks_anchor);
	}
	#endif /* CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER */

	#if defined(CONFIG_BT_CTLR_CENTRAL_ISO)
	int ull_sched_conn_iso_free_offset_get(uint32_t ticks_slot_abs,
	uint32_t *ticks_to_expire)
	{
	uint32_t ticks_anchor;
	uint32_t ticks_slot;
	int err;

	err = group_free_slot_get(TICKER_USER_ID_ULL_LOW, ticks_slot_abs,
	ticks_to_expire, &ticks_slot, &ticks_anchor);
	if (err) {
	return err;
	}

	*ticks_to_expire += ticks_slot;

	return err;
	}
	#endif /* CONFIG_BT_CTLR_CENTRAL_ISO */

	#if defined(CONFIG_BT_CONN)
	#if defined(CONFIG_BT_CENTRAL)
	int ull_sched_after_cen_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
	uint32_t ticks_anchor, uint32_t us_offset)
	{
	uint32_t ticks_to_expire;
	uint32_t ticks_slot;
	uint32_t remainder;
	uint8_t ticker_id;

	ticker_id = after_match_slot_get(user_id, ticks_slot_abs,
	ticker_match_cen_op_cb, ull_hdr_get_cb,
	ticks_anchor, &ticks_to_expire,
	&remainder, &ticks_slot);
	if (ticker_id != TICKER_NULL) {
	uint32_t central_spacing_us;
	uint32_t remainder_us;
	uint32_t slot_us;

	/* When CONFIG_BT_CTLR_CENTRAL_SPACING is used then ticks_slot
	* returned converts to slot_us that is less than or equal to
	* CONFIG_BT_CTLR_CENTRAL_SPACING, because floor value in ticks
	* is returned as ticks_slot.
	* Hence, use CONFIG_BT_CTLR_CENTRAL_SPACING without margin.
	*
	* If actual ticks_slot in microseconds is larger than
	* CONFIG_BT_CTLR_CENTRAL_SPACING, then add margin between
	* central radio events.
	*/
	slot_us = HAL_TICKER_TICKS_TO_US(ticks_slot);
	if (slot_us > CONFIG_BT_CTLR_CENTRAL_SPACING) {
	central_spacing_us = slot_us;
	central_spacing_us += (EVENT_TICKER_RES_MARGIN_US << 1);
	} else {
	central_spacing_us = CONFIG_BT_CTLR_CENTRAL_SPACING;
	}

	remainder_us = remainder;
	hal_ticker_remove_jitter(&ticks_to_expire, &remainder_us);

	*us_offset = HAL_TICKER_TICKS_TO_US(ticks_to_expire) +
	remainder_us + central_spacing_us;

	return 0;
	}

	return -ECHILD;
	}

	void ull_sched_mfy_after_cen_offset_get(void *param)
	{
	struct lll_prepare_param *p = param;
	struct lll_scan *lll = p->param;
	uint32_t ticks_slot_overhead;
	uint32_t ticks_at_expire;
	uint32_t remainder_us;
	struct ll_conn *conn;

	conn = HDR_LLL2ULL(lll->conn);
	if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
	ticks_slot_overhead = MAX(conn->ull.ticks_active_to_start,
	conn->ull.ticks_prepare_to_start);
	} else {
	ticks_slot_overhead = 0U;
	}

	ticks_at_expire = p->ticks_at_expire;
	remainder_us = p->remainder;
	hal_ticker_remove_jitter(&ticks_at_expire, &remainder_us);

	after_cen_offset_get(lll->conn->interval,
	(ticks_slot_overhead + conn->ull.ticks_slot),
	ticks_at_expire, &lll->conn_win_offset_us);
	if (lll->conn_win_offset_us) {
	lll->conn_win_offset_us +=
	HAL_TICKER_TICKS_TO_US(p->ticks_at_expire -
	ticks_at_expire) -
	remainder_us;
	}
	}
	#endif /* CONFIG_BT_CENTRAL */

	void ull_sched_mfy_win_offset_use(void *param)
	{
	struct ll_conn *conn = param;
	uint32_t ticks_slot_overhead;

	if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
	ticks_slot_overhead = MAX(conn->ull.ticks_active_to_start,
	conn->ull.ticks_prepare_to_start);
	} else {
	ticks_slot_overhead = 0U;
	}

	/*
	* TODO: update calculationg of the win_offset
	* when updating the connection update procedure
	* see the legacy code from Zephyr v3.3 for inspiration
	*/
	}

	#if defined(CONFIG_BT_CTLR_CONN_PARAM_REQ)
	void ull_sched_mfy_free_win_offset_calc(void *param)
	{
	uint32_t ticks_to_offset_default = 0U;
	uint32_t *ticks_to_offset_next;

	ticks_to_offset_next = &ticks_to_offset_default;

	/*
	* TODO: update when updating the connection update procedure
	* see the legacy code from Zephyr v3.3 for inspiration
	*/
	}

	void ull_sched_mfy_win_offset_select(void *param)
	{
	#define OFFSET_S_MAX 6
	#define OFFSET_M_MAX 6

	/*
	* TODO: update calculation of win_offset when
	* updating the connection update procedure
	* see the legacy code from Zephyr v3.3 for inspiration
	*/

	#undef OFFSET_S_MAX
	#undef OFFSET_M_MAX
	}

	/*
	* TODO: probably we need a function for calculating the window offset
	* see the legacy code from Zephyr v3.3 for inspiration
	*/
	#endif /* CONFIG_BT_CTLR_CONN_PARAM_REQ */

	#if defined(CONFIG_BT_CENTRAL)
	static void after_cen_offset_get(uint16_t conn_interval, uint32_t ticks_slot,
	uint32_t ticks_anchor,
	uint32_t *win_offset_us)
	{
	uint32_t ticks_anchor_offset = ticks_anchor;
	int err;

	err = ull_sched_after_cen_slot_get(TICKER_USER_ID_ULL_LOW, ticks_slot,
	&ticks_anchor_offset,
	win_offset_us);
	if (err) {
	return;
	}

	if ((ticks_anchor_offset - ticks_anchor) & BIT(HAL_TICKER_CNTR_MSBIT)) {
	*win_offset_us -= HAL_TICKER_TICKS_TO_US(
	ticker_ticks_diff_get(ticks_anchor,
	ticks_anchor_offset));
	} else {
	*win_offset_us += HAL_TICKER_TICKS_TO_US(
	ticker_ticks_diff_get(ticks_anchor_offset,
	ticks_anchor));
	}

	/* Round positive offset value in the future to within one connection
	* interval value.
	* Offsets in the past, value with MSBit set, are handled by caller by
	* adding radio end time and connection interval as necessary to get a
	* window offset in future when establishing a connection.
	*/
	if ((*win_offset_us & BIT(31)) == 0) {
	uint32_t conn_interval_us = conn_interval * CONN_INT_UNIT_US;

	while (*win_offset_us > conn_interval_us) {
	*win_offset_us -= conn_interval_us;
	}
	}
	}
	#endif /* CONFIG_BT_CENTRAL */
	#endif /* CONFIG_BT_CONN */

	#if (defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)) \|\| \
	defined(CONFIG_BT_CTLR_CENTRAL_ISO)
	static int group_free_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
	uint32_t *ticks_to_expire_prev,
	uint32_t *ticks_slot_prev,
	uint32_t *ticks_anchor)
	{
	uint32_t remainder_prev;
	uint8_t ticker_id;

	ticker_id = after_match_slot_get(user_id, ticks_slot_abs,
	ticker_match_any_op_cb, ull_hdr_get_cb,
	ticks_anchor, ticks_to_expire_prev,
	&remainder_prev, ticks_slot_prev);
	if (ticker_id != TICKER_NULL) {
	uint32_t ticks_to_expire;
	uint32_t ticks_slot;

	ticks_to_expire = *ticks_to_expire_prev;
	ticks_slot = *ticks_slot_prev;

	if (false) {

	#if defined(CONFIG_BT_BROADCASTER)
	} 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;

	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;

	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);
	}

	return 0;

	#if defined(CONFIG_BT_CTLR_ADV_PERIODIC)
	} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_SYNC_BASE,
	TICKER_ID_ADV_SYNC_LAST)) {
	*ticks_anchor += ticks_to_expire;
	*ticks_anchor += ticks_slot;

	if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
	const struct ll_adv_sync_set *sync;

	sync = ull_adv_sync_get(ticker_id -
	TICKER_ID_ADV_SYNC_BASE);
	*ticks_anchor +=
	MAX(sync->ull.ticks_active_to_start,
	sync->ull.ticks_prepare_to_start);
	}

	return 0;

	#if defined(CONFIG_BT_CTLR_ADV_ISO)
	} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_ISO_BASE,
	TICKER_ID_ADV_ISO_LAST)) {
	*ticks_anchor += ticks_to_expire;
	*ticks_anchor += ticks_slot;

	if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
	const struct ll_adv_iso_set *iso;

	iso = ull_adv_iso_get(ticker_id -
	TICKER_ID_ADV_ISO_BASE);
	*ticks_anchor +=
	MAX(iso->ull.ticks_active_to_start,
	iso->ull.ticks_prepare_to_start);
	}

	return 0;

	#endif /* CONFIG_BT_CTLR_ADV_ISO */
	#endif /* CONFIG_BT_CTLR_ADV_PERIODIC */
	#endif /* CONFIG_BT_BROADCASTER */

	#if defined(CONFIG_BT_CONN)
	} else if (IN_RANGE(ticker_id, TICKER_ID_CONN_BASE,
	TICKER_ID_CONN_LAST)) {
	*ticks_anchor += ticks_to_expire;
	*ticks_anchor += ticks_slot;

	return 0;
	#endif /* CONFIG_BT_CONN */

	}
	}

	return -ECHILD;
	}
	#endif /* (CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER) \|\|
	* CONFIG_BT_CTLR_CENTRAL_ISO
	*/

	static uint8_t after_match_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
	ticker_op_match_func ticker_match_op_cb,
	ull_hdr_get_func ull_hdr_get_cb,
	uint32_t *ticks_anchor,
	uint32_t *ticks_to_expire_match,
	uint32_t *remainder_match,
	uint32_t *ticks_slot_match)
	{
	uint32_t ticks_to_expire_prev;
	uint32_t ticks_slot_abs_prev;
	uint32_t ticks_anchor_prev;
	uint32_t ticks_to_expire;
	uint32_t remainder_prev;
	uint32_t remainder;
	uint8_t ticker_id_prev;
	uint8_t ticker_id;
	uint8_t retry;

	/* As we may place the event between two other events, ensure there is
	* space for 4 times +/- 16 us jitter. I.e. with 32KHz sleep clock,
	* ~30.517 us after previous event, ~30.517 us before and after current
	* event, and an ~30.517 us before next event. Hence 8 time of ceil
	* value 16 us (30.517 / 2) or 4 times EVENT_TICKER_RES_MARGIN_US.
	*/
	ticks_slot_abs += HAL_TICKER_US_TO_TICKS(EVENT_TICKER_RES_MARGIN_US << 2);

	/* There is a possibility that ticker nodes expire during iterations in
	* this function causing the reference ticks_anchor returned for the
	* found ticker to change. In this case the iterations have to be
	* restarted with the new reference ticks_anchor value.
	* Simultaneous continuous scanning on 1M and Coded PHY, alongwith
	* directed advertising and one other state/role could expire in quick
	* succession, hence have a retry count of 4.
	*/
	retry = 4U;

	/* Initialize variable required for iterations to find a free slot */
	ticker_id = ticker_id_prev = TICKER_NULL;
	ticks_anchor_prev = 0U;
	ticks_to_expire = ticks_to_expire_prev = 0U;
	remainder = remainder_prev = 0U;
	ticks_slot_abs_prev = 0U;
	while (1) {
	uint32_t ticks_slot_abs_curr = 0U;
	uint32_t ticks_to_expire_normal;
	uint32_t volatile ret_cb;
	uint32_t ticks_slot;
	struct ull_hdr *hdr;
	uint32_t ret;
	bool success;

	ret_cb = TICKER_STATUS_BUSY;
	#if defined(CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH)
	ret = ticker_next_slot_get_ext(TICKER_INSTANCE_ID_CTLR, user_id,
	&ticker_id, ticks_anchor,
	&ticks_to_expire, &remainder,
	NULL, /* lazy */
	ticker_match_op_cb,
	NULL, /* match_op_context */
	ticker_op_cb, (void *)&ret_cb);
	#else /* !CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH */
	ret = ticker_next_slot_get(TICKER_INSTANCE_ID_CTLR, user_id,
	&ticker_id, ticks_anchor,
	&ticks_to_expire,
	ticker_op_cb, (void *)&ret_cb);
	#endif /* !CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH */
	if (ret == TICKER_STATUS_BUSY) {
	while (ret_cb == TICKER_STATUS_BUSY) {
	ticker_job_sched(TICKER_INSTANCE_ID_CTLR,
	user_id);
	}
	}

	/* Using a local variable to address the Coverity rule:
	* Incorrect expression (ASSERT_SIDE_EFFECT)
	* Argument "ret_cb" of LL_ASSERT() has a side effect
	* because the variable is volatile. The containing function
	* might work differently in a non-debug build.
	*/
	success = (ret_cb == TICKER_STATUS_SUCCESS);
	LL_ASSERT(success);

	/* There is a possibility that tickers expire while we
	* iterate through the active list of tickers, start over with
	* a fresh iteration.
	*/
	if ((ticker_id_prev != TICKER_NULL) &&
	(*ticks_anchor != ticks_anchor_prev)) {
	LL_ASSERT(retry);
	retry--;

	ticker_id = ticker_id_prev = TICKER_NULL;

	continue;
	}

	/* No more active tickers with slot */
	if (ticker_id == TICKER_NULL) {
	break;
	}

	#if !defined(CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH)
	if (!ticker_match_op_cb(ticker_id, 0, 0, NULL)) {
	continue;
	}
	#endif /* CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH */

	hdr = ull_hdr_get_cb(ticker_id, &ticks_slot);
	if (!hdr) {
	continue;
	}

	ticks_to_expire_normal = ticks_to_expire;

	#if defined(CONFIG_BT_CTLR_LOW_LAT)
	#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
	if (hdr->ticks_prepare_to_start & XON_BITMASK) {
	const uint32_t ticks_prepare_to_start =
	MAX(hdr->ticks_active_to_start,
	hdr->ticks_preempt_to_start);

	ticks_slot_abs_curr = hdr->ticks_prepare_to_start &
	~XON_BITMASK;
	ticks_to_expire_normal -= ticks_slot_abs_curr -
	ticks_prepare_to_start;
	} else
	#endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */
	{
	const uint32_t ticks_prepare_to_start =
	MAX(hdr->ticks_active_to_start,
	hdr->ticks_prepare_to_start);

	ticks_slot_abs_curr = ticks_prepare_to_start;
	}
	#endif

	ticks_slot_abs_curr += ticks_slot;

	if ((ticker_id_prev != TICKER_NULL) &&
	(ticker_ticks_diff_get(ticks_to_expire_normal,
	ticks_to_expire_prev) >
	(ticks_slot_abs_prev + ticks_slot_abs))) {
	break;
	}

	ticks_anchor_prev = *ticks_anchor;
	ticker_id_prev = ticker_id;
	ticks_to_expire_prev = ticks_to_expire_normal;
	remainder_prev = remainder;
	ticks_slot_abs_prev = ticks_slot_abs_curr;
	}

	if (ticker_id_prev != TICKER_NULL) {
	*ticks_to_expire_match = ticks_to_expire_prev;
	*remainder_match = remainder_prev;
	*ticks_slot_match = ticks_slot_abs_prev;
	}

	return ticker_id_prev;
	}

	static void ticker_op_cb(uint32_t status, void *param)
	{
	((uint32_t volatile )param) = status;
	}

	#if (defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)) \|\| \
	defined(CONFIG_BT_CTLR_CENTRAL_ISO)
	static bool ticker_match_any_op_cb(uint8_t ticker_id, uint32_t ticks_slot,
	uint32_t ticks_to_expire, void *op_context)
	{
	ARG_UNUSED(ticks_slot);
	ARG_UNUSED(ticks_to_expire);
	ARG_UNUSED(op_context);

	return false \|\|

	#if defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)
	IN_RANGE(ticker_id, TICKER_ID_ADV_AUX_BASE,
	TICKER_ID_ADV_AUX_LAST) \|\|

	#if defined(CONFIG_BT_CTLR_ADV_PERIODIC)
	IN_RANGE(ticker_id, TICKER_ID_ADV_SYNC_BASE,
	TICKER_ID_ADV_SYNC_LAST) \|\|

	#if defined(CONFIG_BT_CTLR_ADV_ISO)
	IN_RANGE(ticker_id, TICKER_ID_ADV_ISO_BASE,
	TICKER_ID_ADV_ISO_LAST) \|\|
	#endif /* CONFIG_BT_CTLR_ADV_ISO */
	#endif /* CONFIG_BT_CTLR_ADV_PERIODIC */
	#endif /* CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER */

	#if defined(CONFIG_BT_CONN)
	IN_RANGE(ticker_id, TICKER_ID_CONN_BASE,
	TICKER_ID_CONN_LAST) \|\|

	#if defined(CONFIG_BT_CTLR_CENTRAL_ISO)
	IN_RANGE(ticker_id, TICKER_ID_CONN_ISO_BASE,
	TICKER_ID_CONN_ISO_LAST) \|\|
	#endif /* CONFIG_BT_CTLR_CENTRAL_ISO */
	#endif /* CONFIG_BT_CONN */

	false;
	}
	#endif /* (CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER) \|\|
	* CONFIG_BT_CTLR_CENTRAL_ISO
	*/

	#if defined(CONFIG_BT_CENTRAL)
	static bool ticker_match_cen_op_cb(uint8_t ticker_id, uint32_t ticks_slot,
	uint32_t ticks_to_expire, void *op_context)
	{
	ARG_UNUSED(ticks_slot);
	ARG_UNUSED(ticks_to_expire);
	ARG_UNUSED(op_context);

	return IN_RANGE(ticker_id, TICKER_ID_CONN_BASE,
	TICKER_ID_CONN_LAST) \|\|
	#if defined(CONFIG_BT_CTLR_CENTRAL_ISO) && \
	(CONFIG_BT_CTLR_CENTRAL_SPACING == 0)
	IN_RANGE(ticker_id, TICKER_ID_CONN_ISO_BASE,
	TICKER_ID_CONN_ISO_LAST) \|\|
	#endif /* CONFIG_BT_CTLR_CENTRAL_ISO &&
	* (CONFIG_BT_CTLR_CENTRAL_SPACING == 0)
	*/
	false;
	}
	#endif /* CONFIG_BT_CENTRAL */

	static struct ull_hdr ull_hdr_get_cb(uint8_t ticker_id, uint32_t ticks_slot)
	{
	if (false) {

	#if defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_BROADCASTER)
	} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_AUX_BASE,
	TICKER_ID_ADV_AUX_LAST)) {
	struct ll_adv_aux_set *aux;

	aux = ull_adv_aux_get(ticker_id - TICKER_ID_ADV_AUX_BASE);
	if (aux) {
	if (IS_ENABLED(CONFIG_BT_CTLR_ADV_RESERVE_MAX)) {
	uint32_t time_us;

	time_us = ull_adv_aux_time_get(aux, PDU_AC_PAYLOAD_SIZE_MAX,
	PDU_AC_PAYLOAD_SIZE_MAX);
	*ticks_slot = HAL_TICKER_US_TO_TICKS(time_us);
	} else {
	*ticks_slot = aux->ull.ticks_slot;

	#if defined(CONFIG_BT_CTLR_ADV_AUX_SYNC_OFFSET) && \
	(CONFIG_BT_CTLR_ADV_AUX_SYNC_OFFSET != 0)
	struct ll_adv_sync_set *sync;

	sync = HDR_LLL2ULL(aux->lll.adv->sync);
	if (sync->ull.ticks_slot > *ticks_slot) {
	*ticks_slot = sync->ull.ticks_slot;
	}
	#endif /* CONFIG_BT_CTLR_ADV_AUX_SYNC_OFFSET */

	}

	return &aux->ull;
	}

	#if defined(CONFIG_BT_CTLR_ADV_PERIODIC)
	} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_SYNC_BASE,
	TICKER_ID_ADV_SYNC_LAST)) {
	struct ll_adv_sync_set *sync;

	sync = ull_adv_sync_get(ticker_id - TICKER_ID_ADV_SYNC_BASE);
	if (sync) {
	if (IS_ENABLED(CONFIG_BT_CTLR_ADV_RESERVE_MAX)) {
	uint32_t time_us;

	time_us = ull_adv_sync_time_get(sync, PDU_AC_PAYLOAD_SIZE_MAX);
	*ticks_slot = HAL_TICKER_US_TO_TICKS(time_us);
	} else {
	*ticks_slot = sync->ull.ticks_slot;
	}

	return &sync->ull;
	}

	#if defined(CONFIG_BT_CTLR_ADV_ISO)
	} else if (IN_RANGE(ticker_id, TICKER_ID_ADV_ISO_BASE,
	TICKER_ID_ADV_ISO_LAST)) {
	struct ll_adv_iso_set *adv_iso;

	adv_iso = ull_adv_iso_get(ticker_id - TICKER_ID_ADV_ISO_BASE);
	if (adv_iso) {
	*ticks_slot = adv_iso->ull.ticks_slot;

	return &adv_iso->ull;
	}

	#endif /* CONFIG_BT_CTLR_ADV_ISO */
	#endif /* CONFIG_BT_CTLR_ADV_PERIODIC */
	#endif /* CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_BROADCASTER */

	#if defined(CONFIG_BT_CONN)
	} else if (IN_RANGE(ticker_id, TICKER_ID_CONN_BASE,
	TICKER_ID_CONN_LAST)) {
	struct ll_conn *conn;

	conn = ll_conn_get(ticker_id - TICKER_ID_CONN_BASE);
	if (conn && !conn->lll.role) {
	if (IS_ENABLED(CONFIG_BT_CTLR_CENTRAL_RESERVE_MAX)) {
	uint32_t ready_delay_us;
	uint16_t max_tx_time;
	uint16_t max_rx_time;
	uint32_t time_us;

	#if defined(CONFIG_BT_CTLR_PHY)
	ready_delay_us =
	lll_radio_tx_ready_delay_get(conn->lll.phy_tx,
	conn->lll.phy_flags);
	#else
	ready_delay_us =
	lll_radio_tx_ready_delay_get(0U, 0U);
	#endif

	#if defined(CONFIG_BT_CTLR_PHY_CODED)
	max_tx_time = PDU_DC_MAX_US(LL_LENGTH_OCTETS_TX_MAX,
	PHY_CODED);
	max_rx_time = PDU_DC_MAX_US(LL_LENGTH_OCTETS_RX_MAX,
	PHY_CODED);
	#else /* !CONFIG_BT_CTLR_PHY_CODED */
	max_tx_time = PDU_DC_MAX_US(LL_LENGTH_OCTETS_TX_MAX,
	PHY_1M);
	max_rx_time = PDU_DC_MAX_US(LL_LENGTH_OCTETS_RX_MAX,
	PHY_1M);
	#endif /* !CONFIG_BT_CTLR_PHY_CODED */

	time_us = EVENT_OVERHEAD_START_US +
	ready_delay_us + max_rx_time +
	EVENT_IFS_US + max_tx_time;
	*ticks_slot = HAL_TICKER_US_TO_TICKS(time_us);
	} else {
	*ticks_slot = conn->ull.ticks_slot;
	}

	if (*ticks_slot < CONFIG_BT_CTLR_CENTRAL_SPACING) {
	*ticks_slot =
	HAL_TICKER_US_TO_TICKS(CONFIG_BT_CTLR_CENTRAL_SPACING);
	}

	return &conn->ull;
	}

	#if defined(CONFIG_BT_CTLR_CENTRAL_ISO)
	} else if (IN_RANGE(ticker_id, TICKER_ID_CONN_ISO_BASE,
	TICKER_ID_CONN_ISO_LAST)) {
	struct ll_conn_iso_group *cig;

	cig = ll_conn_iso_group_get(ticker_id - TICKER_ID_CONN_ISO_BASE);
	if (cig) {
	*ticks_slot = cig->ull.ticks_slot;

	return &cig->ull;
	}

	#endif /* CONFIG_BT_CTLR_CENTRAL_ISO */
	#endif /* CONFIG_BT_CONN */

	}

	return NULL;
	}