michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Bluetooth: controller: Avoid sizeof to access ULL/LLL struct member

Browse source 
Avoid using sizeof to access ULL and LLL struct members.
Based on the alignment requirements of structures, due to
padding between structure members, use of sizeof of previous
struct member to access next struct member is incorrect.

Continue to use explicitly stored parent pointer to access
ULL context. Combine event header and ULL header so that
the parent pointer point directly to the combined ULL
struct.

Signed-off-by: Vinayak Kariappa Chettimada <vich@nordicsemi.no>
This commit is contained in:
Vinayak Kariappa Chettimada 2021-04-05 12:56:51 +05:30 • committed by Carles Cufí
commit 82925a8c99
37 changed files with 327 additions and 306 deletions
Download patch file Download diff file Expand all files Collapse all files

39
subsys/bluetooth/controller/ll_sw/lll.h
View file

@ -26,11 +26,6 @@
#define SCAN_INT_UNIT_US 625U
#define CONN_INT_UNIT_US 1250U
#define HDR_ULL(p) ((void *)((uint8_t *)(p) + sizeof(struct evt_hdr)))
#define HDR_ULL2LLL(p) ((struct lll_hdr *)((uint8_t *)(p) + \
sizeof(struct ull_hdr)))
#define HDR_LLL2EVT(p) ((struct evt_hdr *)((struct lll_hdr *)(p))->parent)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
#define XON_BITMASK BIT(31) /* XTAL has been retained from previous prepare */
#endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */
@ -137,23 +132,29 @@ enum {
#define TICKER_ID_ULL_BASE ((TICKER_ID_LLL_PREEMPT) + 1)
enum ull_status {
ULL_STATUS_SUCCESS,
ULL_STATUS_FAILURE,
ULL_STATUS_BUSY,
};
struct evt_hdr {
uint32_t ticks_xtal_to_start;
uint32_t ticks_active_to_start;
uint32_t ticks_preempt_to_start;
uint32_t ticks_slot;
};
struct ull_hdr {
uint8_t volatile ref; /* Number of ongoing (between Prepare and Done)
* events
*/
/* Event parameters */
/* TODO: The intention is to use the greater of the
* ticks_prepare_to_start or ticks_active_to_start as the prepare
* offset. At the prepare tick generate a software interrupt
* servicable by application as the per role configurable advance
* radio event notification, usable for data acquisitions.
* ticks_preempt_to_start is the per role dynamic preempt offset,
* which shall be based on role's preparation CPU usage
* requirements.
*/
struct {
uint32_t ticks_active_to_start;
uint32_t ticks_prepare_to_start;
uint32_t ticks_preempt_to_start;
uint32_t ticks_slot;
};
/* ULL context disabled callback and its parameter */
void (*disabled_cb)(void *param);
void *disabled_param;
};
@ -166,6 +167,8 @@ struct lll_hdr {
#endif /* CONFIG_BT_CTLR_JIT_SCHEDULING */
};
#define HDR_LLL2ULL(p) (((struct lll_hdr *)(p))->parent)
struct lll_prepare_param {
uint32_t ticks_at_expire;
uint32_t remainder;

28
subsys/bluetooth/controller/ll_sw/nordic/lll/lll.c
View file

@ -325,7 +325,7 @@ int lll_done(void *param)
#endif /* CONFIG_BT_CTLR_LOW_LAT_ULL_DONE */
if (param) {
ull = HDR_ULL(((struct lll_hdr *)param)->parent);
ull = HDR_LLL2ULL(param);
}
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT) &&
@ -337,7 +337,7 @@ int lll_done(void *param)
DEBUG_RADIO_CLOSE(0);
} else {
ull = HDR_ULL(((struct lll_hdr *)param)->parent);
ull = HDR_LLL2ULL(param);
}
#if !defined(CONFIG_BT_CTLR_LOW_LAT_ULL_DONE)
@ -397,21 +397,21 @@ void lll_abort_cb(struct lll_prepare_param *prepare_param, void *param)
lll_done(param);
}
uint32_t lll_evt_offset_get(struct evt_hdr *evt)
uint32_t lll_event_offset_get(struct ull_hdr *ull)
{
if (0) {
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
} else if (evt->ticks_xtal_to_start & XON_BITMASK) {
return MAX(evt->ticks_active_to_start,
evt->ticks_preempt_to_start);
} else if (ull->ticks_prepare_to_start & XON_BITMASK) {
return MAX(ull->ticks_active_to_start,
ull->ticks_preempt_to_start);
#endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */
} else {
return MAX(evt->ticks_active_to_start,
evt->ticks_xtal_to_start);
return MAX(ull->ticks_active_to_start,
ull->ticks_prepare_to_start);
}
}
uint32_t lll_preempt_calc(struct evt_hdr *evt, uint8_t ticker_id,
uint32_t lll_preempt_calc(struct ull_hdr *ull, uint8_t ticker_id,
uint32_t ticks_at_event)
{
uint32_t ticks_now;
@ -740,16 +740,16 @@ static void ticker_start_op_cb(uint32_t status, void *param)
static void preempt_ticker_start(struct lll_prepare_param *prepare_param)
{
uint32_t preempt_anchor;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t preempt_to;
uint32_t ret;
/* Calc the preempt timeout */
evt = HDR_LLL2EVT(prepare_param->param);
ull = HDR_LLL2ULL(prepare_param->param);
preempt_anchor = prepare_param->ticks_at_expire;
preempt_to = MAX(evt->ticks_active_to_start,
evt->ticks_xtal_to_start) -
evt->ticks_preempt_to_start;
preempt_to = MAX(ull->ticks_active_to_start,
ull->ticks_prepare_to_start) -
ull->ticks_preempt_to_start;
/* Setup pre empt timeout */
ret = ticker_start(TICKER_INSTANCE_ID_CTLR,

14
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_adv.c
View file

@ -730,7 +730,7 @@ static int prepare_cb(struct lll_prepare_param *p)
uint32_t ticks_at_event;
uint32_t ticks_at_start;
struct pdu_adv *pdu;
struct evt_hdr *evt;
struct ull_hdr *ull;
struct lll_adv *lll;
uint32_t remainder;
uint32_t start_us;
@ -809,8 +809,8 @@ static int prepare_cb(struct lll_prepare_param *p)
}
ticks_at_event = p->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -832,7 +832,7 @@ static int prepare_cb(struct lll_prepare_param *p)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_ADV_BASE +
if (lll_preempt_calc(ull, (TICKER_ID_ADV_BASE +
ull_adv_lll_handle_get(lll)),
ticks_at_event)) {
radio_isr_set(isr_abort, lll);
@ -854,10 +854,10 @@ static int prepare_cb(struct lll_prepare_param *p)
#if defined(CONFIG_BT_PERIPHERAL)
static int resume_prepare_cb(struct lll_prepare_param *p)
{
struct evt_hdr *evt;
struct ull_hdr *ull;
evt = HDR_LLL2EVT(p->param);
p->ticks_at_expire = ticker_ticks_now_get() - lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(p->param);
p->ticks_at_expire = ticker_ticks_now_get() - lll_event_offset_get(ull);
p->remainder = 0;
p->lazy = 0;

8
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_adv_aux.c
View file

@ -188,7 +188,7 @@ static int prepare_cb(struct lll_prepare_param *p)
struct pdu_adv_ext_hdr *pri_hdr;
struct lll_adv_aux *lll;
struct lll_adv *lll_adv;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t remainder;
uint32_t start_us;
uint8_t *pri_dptr;
@ -293,8 +293,8 @@ static int prepare_cb(struct lll_prepare_param *p)
}
ticks_at_event = p->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -316,7 +316,7 @@ static int prepare_cb(struct lll_prepare_param *p)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_ADV_AUX_BASE +
if (lll_preempt_calc(ull, (TICKER_ID_ADV_AUX_BASE +
ull_adv_aux_lll_handle_get(lll)),
ticks_at_event)) {
radio_isr_set(lll_isr_abort, lll);

8
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_adv_sync.c
View file

@ -108,7 +108,7 @@ static int prepare_cb(struct lll_prepare_param *p)
uint16_t event_counter;
uint8_t data_chan_use;
struct pdu_adv *pdu;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t remainder;
uint32_t start_us;
void *extra_data;
@ -186,8 +186,8 @@ static int prepare_cb(struct lll_prepare_param *p)
}
ticks_at_event = p->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -207,7 +207,7 @@ static int prepare_cb(struct lll_prepare_param *p)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_ADV_SYNC_BASE +
if (lll_preempt_calc(ull, (TICKER_ID_ADV_SYNC_BASE +
ull_adv_sync_lll_handle_get(lll)),
ticks_at_event)) {
radio_isr_set(lll_isr_abort, lll);

6
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_internal.h
View file

@ -10,10 +10,12 @@ bool lll_is_done(void *param);
int lll_is_abort_cb(void *next, void *curr, lll_prepare_cb_t *resume_cb);
void lll_abort_cb(struct lll_prepare_param *prepare_param, void *param);
uint32_t lll_evt_offset_get(struct evt_hdr *evt);
uint32_t lll_preempt_calc(struct evt_hdr *evt, uint8_t ticker_id,
uint32_t lll_event_offset_get(struct ull_hdr *ull);
uint32_t lll_preempt_calc(struct ull_hdr *ull, uint8_t ticker_id,
uint32_t ticks_at_event);
void lll_chan_set(uint32_t chan);
void lll_isr_tx_status_reset(void);
void lll_isr_rx_status_reset(void);
void lll_isr_status_reset(void);

8
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_master.c
View file

@ -101,7 +101,7 @@ static int prepare_cb(struct lll_prepare_param *p)
uint32_t remainder_us;
uint8_t data_chan_use;
struct lll_conn *lll;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t remainder;
DEBUG_RADIO_START_M(1);
@ -183,8 +183,8 @@ static int prepare_cb(struct lll_prepare_param *p)
#endif /* !CONFIG_BT_CTLR_PHY */
ticks_at_event = p->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -215,7 +215,7 @@ static int prepare_cb(struct lll_prepare_param *p)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_CONN_BASE + lll->handle),
if (lll_preempt_calc(ull, (TICKER_ID_CONN_BASE + lll->handle),
ticks_at_event)) {
radio_isr_set(lll_isr_abort, lll);
radio_disable();

20
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_scan.c
View file

@ -128,7 +128,7 @@ static int prepare_cb(struct lll_prepare_param *p)
struct node_rx_pdu *node_rx;
uint32_t remainder_us;
struct lll_scan *lll;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t remainder;
uint32_t aa;
@ -218,8 +218,8 @@ static int prepare_cb(struct lll_prepare_param *p)
}
ticks_at_event = p->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -248,7 +248,7 @@ static int prepare_cb(struct lll_prepare_param *p)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_SCAN_BASE +
if (lll_preempt_calc(ull, (TICKER_ID_SCAN_BASE +
ull_scan_lll_handle_get(lll)),
ticks_at_event)) {
radio_isr_set(isr_abort, lll);
@ -305,10 +305,10 @@ static int prepare_cb(struct lll_prepare_param *p)
static int resume_prepare_cb(struct lll_prepare_param *p)
{
struct evt_hdr *evt;
struct ull_hdr *ull;
evt = HDR_LLL2EVT(p->param);
p->ticks_at_expire = ticker_ticks_now_get() - lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(p->param);
p->ticks_at_expire = ticker_ticks_now_get() - lll_event_offset_get(ull);
p->remainder = 0;
p->lazy = 0;
@ -783,7 +783,7 @@ static inline int isr_rx_pdu(struct lll_scan *lll, struct pdu_adv *pdu_adv_rx,
uint32_t conn_interval_us;
uint32_t conn_offset_us;
uint32_t conn_space_us;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t pdu_end_us;
#if defined(CONFIG_BT_CTLR_PRIVACY)
bt_addr_t *lrpa;
@ -807,8 +807,8 @@ static inline int isr_rx_pdu(struct lll_scan *lll, struct pdu_adv *pdu_adv_rx,
scan_interval_us = lll->interval * SCAN_INT_UNIT_US;
pdu_end_us %= scan_interval_us;
}
evt = HDR_LLL2EVT(lll);
if (pdu_end_us > (HAL_TICKER_TICKS_TO_US(evt->ticks_slot) -
ull = HDR_LLL2ULL(lll);
if (pdu_end_us > (HAL_TICKER_TICKS_TO_US(ull->ticks_slot) -
EVENT_IFS_US - 352 - EVENT_OVERHEAD_START_US -
EVENT_TICKER_RES_MARGIN_US)) {
return -ETIME;

8
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_scan_aux.c
View file

@ -92,7 +92,7 @@ static int prepare_cb(struct lll_prepare_param *p)
struct lll_scan_aux *lll;
uint32_t ticks_at_event;
uint32_t ticks_at_start;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t remainder_us;
uint32_t remainder;
uint32_t hcto;
@ -139,8 +139,8 @@ static int prepare_cb(struct lll_prepare_param *p)
/* Calculate event timings, coarse and fine */
ticks_at_event = p->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -173,7 +173,7 @@ static int prepare_cb(struct lll_prepare_param *p)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_SCAN_AUX_BASE +
if (lll_preempt_calc(ull, (TICKER_ID_SCAN_AUX_BASE +
ull_scan_aux_lll_handle_get(lll)),
ticks_at_event)) {
radio_isr_set(isr_done, lll);

8
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_slave.c
View file

@ -108,7 +108,7 @@ static int prepare_cb(struct lll_prepare_param *p)
uint32_t remainder_us;
uint8_t data_chan_use;
struct lll_conn *lll;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t remainder;
uint32_t hcto;
@ -202,8 +202,8 @@ static int prepare_cb(struct lll_prepare_param *p)
#endif /* !CONFIG_BT_CTLR_PHY */
ticks_at_event = p->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -257,7 +257,7 @@ static int prepare_cb(struct lll_prepare_param *p)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_CONN_BASE + lll->handle),
if (lll_preempt_calc(ull, (TICKER_ID_CONN_BASE + lll->handle),
ticks_at_event)) {
radio_isr_set(lll_isr_abort, lll);
radio_disable();

8
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_sync.c
View file

@ -108,7 +108,7 @@ static int prepare_cb(struct lll_prepare_param *p)
uint32_t remainder_us;
uint8_t data_chan_use;
struct lll_sync *lll;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t remainder;
uint32_t hcto;
@ -172,8 +172,8 @@ static int prepare_cb(struct lll_prepare_param *p)
radio_switch_complete_and_disable();
ticks_at_event = p->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -206,7 +206,7 @@ static int prepare_cb(struct lll_prepare_param *p)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_SCAN_SYNC_BASE +
if (lll_preempt_calc(ull, (TICKER_ID_SCAN_SYNC_BASE +
ull_sync_lll_handle_get(lll)),
ticks_at_event)) {
radio_isr_set(lll_isr_abort, lll);

28
subsys/bluetooth/controller/ll_sw/openisa/lll/lll.c
View file

@ -256,7 +256,7 @@ int lll_done(void *param)
event.curr.param = NULL;
if (param) {
ull = HDR_ULL(((struct lll_hdr *)param)->parent);
ull = HDR_LLL2ULL(param);
}
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT) &&
@ -268,7 +268,7 @@ int lll_done(void *param)
DEBUG_RADIO_CLOSE(0);
} else {
ull = HDR_ULL(((struct lll_hdr *)param)->parent);
ull = HDR_LLL2ULL(param);
}
/* Let ULL know about LLL event done */
@ -331,21 +331,21 @@ int lll_clk_off(void)
return err;
}
uint32_t lll_evt_offset_get(struct evt_hdr *evt)
uint32_t lll_event_offset_get(struct ull_hdr *ull)
{
if (0) {
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
} else if (evt->ticks_xtal_to_start & XON_BITMASK) {
return MAX(evt->ticks_active_to_start,
evt->ticks_preempt_to_start);
} else if (ull->ticks_prepare_to_start & XON_BITMASK) {
return MAX(ull->ticks_active_to_start,
ull->ticks_preempt_to_start);
#endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */
} else {
return MAX(evt->ticks_active_to_start,
evt->ticks_xtal_to_start);
return MAX(ull->ticks_active_to_start,
ull->ticks_prepare_to_start);
}
}
uint32_t lll_preempt_calc(struct evt_hdr *evt, uint8_t ticker_id,
uint32_t lll_preempt_calc(struct ull_hdr *ull, uint8_t ticker_id,
uint32_t ticks_at_event)
{
uint32_t ticks_now = ticker_ticks_now_get();
@ -532,16 +532,16 @@ static void ticker_start_op_cb(uint32_t status, void *param)
static void preempt_ticker_start(struct lll_prepare_param *prepare_param)
{
uint32_t preempt_anchor;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t preempt_to;
int ret;
/* Calc the preempt timeout */
evt = HDR_LLL2EVT(prepare_param->param);
ull = HDR_LLL2ULL(prepare_param->param);
preempt_anchor = prepare_param->ticks_at_expire;
preempt_to = MAX(evt->ticks_active_to_start,
evt->ticks_xtal_to_start) -
evt->ticks_preempt_to_start;
preempt_to = MAX(ull->ticks_active_to_start,
ull->ticks_prepare_to_start) -
ull->ticks_preempt_to_start;
/* Setup pre empt timeout */
ret = ticker_start(TICKER_INSTANCE_ID_CTLR,

12
subsys/bluetooth/controller/ll_sw/openisa/lll/lll_adv.c
View file

@ -319,8 +319,8 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
struct lll_adv *lll = prepare_param->param;
uint32_t aa = sys_cpu_to_le32(PDU_AC_ACCESS_ADDR);
uint32_t ticks_at_event, ticks_at_start;
struct evt_hdr *evt;
uint32_t remainder_us;
struct ull_hdr *ull;
uint32_t remainder;
DEBUG_RADIO_START_A(1);
@ -390,8 +390,8 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
}
ticks_at_event = prepare_param->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -414,7 +414,7 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_ADV_BASE +
if (lll_preempt_calc(ull, (TICKER_ID_ADV_BASE +
ull_adv_lll_handle_get(lll)),
ticks_at_event)) {
radio_isr_set(isr_abort, lll);
@ -436,9 +436,9 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
#if defined(CONFIG_BT_PERIPHERAL)
static int resume_prepare_cb(struct lll_prepare_param *p)
{
struct evt_hdr *evt = HDR_LLL2EVT(p->param);
struct ull_hdr *ull = HDR_LLL2ULL(p->param);
p->ticks_at_expire = ticker_ticks_now_get() - lll_evt_offset_get(evt);
p->ticks_at_expire = ticker_ticks_now_get() - lll_event_offset_get(ull);
p->remainder = 0;
p->lazy = 0;

4
subsys/bluetooth/controller/ll_sw/openisa/lll/lll_internal.h
View file

@ -13,7 +13,7 @@ void lll_abort_cb(struct lll_prepare_param *prepare_param, void *param);
int lll_clk_on(void);
int lll_clk_on_wait(void);
int lll_clk_off(void);
uint32_t lll_evt_offset_get(struct evt_hdr *evt);
uint32_t lll_preempt_calc(struct evt_hdr *evt, uint8_t ticker_id,
uint32_t lll_event_offset_get(struct ull_hdr *ull);
uint32_t lll_preempt_calc(struct ull_hdr *ull, uint8_t ticker_id,
uint32_t ticks_at_event);
void lll_chan_set(uint32_t chan);

8
subsys/bluetooth/controller/ll_sw/openisa/lll/lll_master.c
View file

@ -90,10 +90,10 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
struct lll_conn *lll = prepare_param->param;
uint32_t ticks_at_event, ticks_at_start;
struct pdu_data *pdu_data_tx;
struct evt_hdr *evt;
uint16_t event_counter;
uint32_t remainder_us;
uint8_t data_chan_use;
struct ull_hdr *ull;
uint32_t remainder;
DEBUG_RADIO_START_M(1);
@ -160,8 +160,8 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
#endif /* !CONFIG_BT_CTLR_PHY */
ticks_at_event = prepare_param->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -192,7 +192,7 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_CONN_BASE + lll->handle),
if (lll_preempt_calc(ull, (TICKER_ID_CONN_BASE + lll->handle),
ticks_at_event)) {
radio_isr_set(lll_conn_isr_abort, lll);
radio_disable();

18
subsys/bluetooth/controller/ll_sw/openisa/lll/lll_scan.c
View file

@ -123,8 +123,8 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
uint32_t aa = sys_cpu_to_le32(PDU_AC_ACCESS_ADDR);
uint32_t ticks_at_event, ticks_at_start;
struct node_rx_pdu *node_rx;
struct evt_hdr *evt;
uint32_t remainder_us;
struct ull_hdr *ull;
uint32_t remainder;
DEBUG_RADIO_START_O(1);
@ -200,8 +200,8 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
}
ticks_at_event = prepare_param->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -229,7 +229,7 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_SCAN_BASE +
if (lll_preempt_calc(ull, (TICKER_ID_SCAN_BASE +
ull_scan_lll_handle_get(lll)),
ticks_at_event)) {
radio_isr_set(isr_abort, lll);
@ -266,9 +266,9 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
static int resume_prepare_cb(struct lll_prepare_param *p)
{
struct evt_hdr *evt = HDR_LLL2EVT(p->param);
struct ull_hdr *ull = HDR_LLL2ULL(p->param);
p->ticks_at_expire = ticker_ticks_now_get() - lll_evt_offset_get(evt);
p->ticks_at_expire = ticker_ticks_now_get() - lll_event_offset_get(ull);
p->remainder = 0;
p->lazy = 0;
@ -682,7 +682,7 @@ static inline uint32_t isr_rx_pdu(struct lll_scan *lll, uint8_t devmatch_ok,
uint32_t conn_interval_us;
uint32_t conn_offset_us;
uint32_t conn_space_us;
struct evt_hdr *evt;
struct ull_hdr *ull;
uint32_t pdu_end_us;
#if defined(CONFIG_BT_CTLR_PRIVACY)
bt_addr_t *lrpa;
@ -706,8 +706,8 @@ static inline uint32_t isr_rx_pdu(struct lll_scan *lll, uint8_t devmatch_ok,
scan_interval_us = lll->interval * SCAN_INT_UNIT_US;
pdu_end_us %= scan_interval_us;
}
evt = HDR_LLL2EVT(lll);
if (pdu_end_us > (HAL_TICKER_TICKS_TO_US(evt->ticks_slot) -
ull = HDR_LLL2ULL(lll);
if (pdu_end_us > (HAL_TICKER_TICKS_TO_US(ull->ticks_slot) -
EVENT_IFS_US - 352 - EVENT_OVERHEAD_START_US -
EVENT_TICKER_RES_MARGIN_US)) {
return -ETIME;

8
subsys/bluetooth/controller/ll_sw/openisa/lll/lll_slave.c
View file

@ -98,10 +98,10 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
{
struct lll_conn *lll = prepare_param->param;
uint32_t ticks_at_event, ticks_at_start;
struct evt_hdr *evt;
uint16_t event_counter;
uint32_t remainder_us;
uint8_t data_chan_use;
struct ull_hdr *ull;
uint32_t remainder;
uint32_t hcto;
@ -181,8 +181,8 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
#endif /* !CONFIG_BT_CTLR_PHY */
ticks_at_event = prepare_param->ticks_at_expire;
evt = HDR_LLL2EVT(lll);
ticks_at_event += lll_evt_offset_get(evt);
ull = HDR_LLL2ULL(lll);
ticks_at_event += lll_event_offset_get(ull);
ticks_at_start = ticks_at_event;
ticks_at_start += HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US);
@ -235,7 +235,7 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED) && \
(EVENT_OVERHEAD_PREEMPT_US <= EVENT_OVERHEAD_PREEMPT_MIN_US)
/* check if preempt to start has changed */
if (lll_preempt_calc(evt, (TICKER_ID_CONN_BASE + lll->handle),
if (lll_preempt_calc(ull, (TICKER_ID_CONN_BASE + lll->handle),
ticks_at_event)) {
radio_isr_set(lll_conn_isr_abort, lll);
radio_disable();

29
subsys/bluetooth/controller/ll_sw/ull.c
View file

@ -855,7 +855,7 @@ void ll_rx_dequeue(void)
if (lll_aux) {
struct ll_adv_aux_set *aux;
aux = (void *)HDR_LLL2EVT(lll_aux);
aux = HDR_LLL2ULL(lll_aux);
aux->is_started = 0U;
}
@ -877,7 +877,7 @@ void ll_rx_dequeue(void)
lll_conn->link_tx_free = link;
struct ll_conn *conn = (void *)HDR_LLL2EVT(lll_conn);
struct ll_conn *conn = HDR_LLL2ULL(lll_conn);
ll_conn_release(conn);
adv->lll.conn = NULL;
@ -905,8 +905,12 @@ void ll_rx_dequeue(void)
#if defined(CONFIG_BT_PERIPHERAL)
} else if ((cc->status == BT_HCI_ERR_ADV_TIMEOUT) || cc->role) {
struct lll_adv *lll = ftr->param;
struct ll_adv_set *adv = (void *)HDR_LLL2EVT(lll);
struct ll_adv_set *adv;
struct lll_adv *lll;
/* Get reference to ULL context */
lll = ftr->param;
adv = HDR_LLL2ULL(lll);
if (cc->status == BT_HCI_ERR_ADV_TIMEOUT) {
struct lll_conn *conn_lll;
@ -923,7 +927,7 @@ void ll_rx_dequeue(void)
LL_ASSERT(link);
conn_lll->link_tx_free = link;
conn = (void *)HDR_LLL2EVT(conn_lll);
conn = HDR_LLL2ULL(conn_lll);
ll_conn_release(conn);
} else {
/* Release un-utilized node rx */
@ -941,7 +945,7 @@ void ll_rx_dequeue(void)
if (lll->aux) {
struct ll_adv_aux_set *aux;
aux = (void *)HDR_LLL2EVT(lll->aux);
aux = HDR_LLL2ULL(lll->aux);
aux->is_started = 0U;
}
#endif /* CONFIG_BT_CTLR_ADV_EXT */
@ -952,8 +956,7 @@ void ll_rx_dequeue(void)
#endif /* !CONFIG_BT_PERIPHERAL */
} else if (IS_ENABLED(CONFIG_BT_CENTRAL)) {
struct lll_scan *lll = ftr->param;
struct ll_scan_set *scan = (void *)HDR_LLL2EVT(lll);
struct ll_scan_set *scan = HDR_LLL2ULL(ftr->param);
scan->is_enabled = 0U;
} else {
@ -1510,9 +1513,9 @@ int ull_disable(void *lll)
struct k_sem sem;
uint32_t ret;
hdr = HDR_ULL(((struct lll_hdr *)lll)->parent);
if (!hdr) {
return ULL_STATUS_SUCCESS;
hdr = HDR_LLL2ULL(lll);
if (!hdr || !ull_ref_get(hdr)) {
return 0;
}
k_sem_init(&sem, 0, 1);
@ -1520,10 +1523,6 @@ int ull_disable(void *lll)
hdr->disabled_param = &sem;
hdr->disabled_cb = disabled_cb;
if (!ull_ref_get(hdr)) {
return ULL_STATUS_SUCCESS;
}
mfy.param = lll;
ret = mayfly_enqueue(TICKER_USER_ID_THREAD, TICKER_USER_ID_LLL, 0,
&mfy);

42
subsys/bluetooth/controller/ll_sw/ull_adv.c
View file

@ -320,7 +320,7 @@ uint8_t ll_adv_params_set(uint16_t interval, uint8_t adv_type,
if (adv->lll.sync) {
struct ll_adv_sync_set *sync;
sync = (void *)HDR_LLL2EVT(adv->lll.sync);
sync = HDR_LLL2ULL(adv->lll.sync);
adv->lll.sync = NULL;
ull_adv_sync_release(sync);
@ -328,7 +328,7 @@ uint8_t ll_adv_params_set(uint16_t interval, uint8_t adv_type,
#endif /* CONFIG_BT_CTLR_ADV_PERIODIC */
/* Release auxiliary channel set */
aux = (void *)HDR_LLL2EVT(lll_aux);
aux = HDR_LLL2ULL(lll_aux);
adv->lll.aux = NULL;
ull_adv_aux_release(aux);
@ -1123,15 +1123,15 @@ uint8_t ll_adv_enable(uint8_t enable)
lll_hdr_init(lll, adv);
/* TODO: active_to_start feature port */
adv->evt.ticks_active_to_start = 0;
adv->evt.ticks_xtal_to_start =
adv->ull.ticks_active_to_start = 0;
adv->ull.ticks_prepare_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US);
adv->evt.ticks_preempt_to_start =
adv->ull.ticks_preempt_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_PREEMPT_MIN_US);
adv->evt.ticks_slot = HAL_TICKER_US_TO_TICKS(slot_us);
adv->ull.ticks_slot = HAL_TICKER_US_TO_TICKS(slot_us);
ticks_slot_offset = MAX(adv->evt.ticks_active_to_start,
adv->evt.ticks_xtal_to_start);
ticks_slot_offset = MAX(adv->ull.ticks_active_to_start,
adv->ull.ticks_prepare_to_start);
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = ticks_slot_offset;
@ -1156,9 +1156,9 @@ uint8_t ll_adv_enable(uint8_t enable)
TICKER_USER_ID_THREAD,
(TICKER_ID_ADV_BASE + handle),
ticks_anchor, 0,
(adv->evt.ticks_slot + ticks_slot_overhead),
(adv->ull.ticks_slot + ticks_slot_overhead),
TICKER_NULL_REMAINDER, TICKER_NULL_LAZY,
(adv->evt.ticks_slot + ticks_slot_overhead),
(adv->ull.ticks_slot + ticks_slot_overhead),
ticker_cb, adv,
ull_ticker_status_give, (void *)&ret_cb);
ret = ull_ticker_status_take(ret, &ret_cb);
@ -1179,7 +1179,7 @@ uint8_t ll_adv_enable(uint8_t enable)
} else
#endif /* CONFIG_BT_PERIPHERAL */
{
const uint32_t ticks_slot = adv->evt.ticks_slot +
const uint32_t ticks_slot = adv->ull.ticks_slot +
ticks_slot_overhead;
#if (CONFIG_BT_CTLR_ADV_AUX_SET > 0)
#if defined(CONFIG_BT_CTLR_ADV_PERIODIC)
@ -1187,7 +1187,7 @@ uint8_t ll_adv_enable(uint8_t enable)
/* Add sync_info into auxiliary PDU */
if (lll->sync) {
sync = (void *)HDR_LLL2EVT(lll->sync);
sync = HDR_LLL2ULL(lll->sync);
if (sync->is_enabled && !sync->is_started) {
uint8_t err;
@ -1209,7 +1209,7 @@ uint8_t ll_adv_enable(uint8_t enable)
uint32_t ticks_slot_overhead_aux;
uint32_t ticks_anchor_aux;
aux = (void *)HDR_LLL2EVT(lll_aux);
aux = HDR_LLL2ULL(lll_aux);
/* schedule auxiliary PDU after primary channel PDUs */
ticks_anchor_aux =
@ -1224,7 +1224,7 @@ uint8_t ll_adv_enable(uint8_t enable)
*/
if (sync) {
const uint32_t ticks_slot_aux =
aux->evt.ticks_slot +
aux->ull.ticks_slot +
ticks_slot_overhead_aux;
uint32_t ticks_anchor_sync =
ticks_anchor_aux +
@ -1463,7 +1463,7 @@ inline uint16_t ull_adv_handle_get(struct ll_adv_set *adv)
uint16_t ull_adv_lll_handle_get(struct lll_adv *lll)
{
return ull_adv_handle_get((void *)HDR_LLL2EVT(lll));
return ull_adv_handle_get(HDR_LLL2ULL(lll));
}
inline struct ll_adv_set *ull_adv_is_enabled_get(uint8_t handle)
@ -1591,13 +1591,17 @@ uint8_t ull_scan_rsp_set(struct ll_adv_set *adv, uint8_t len,
#if defined(CONFIG_BT_CTLR_ADV_EXT)
void ull_adv_done(struct node_rx_event_done *done)
{
struct lll_adv *lll = (void *)HDR_ULL2LLL(done->param);
struct ll_adv_set *adv = (void *)HDR_LLL2EVT(lll);
struct lll_adv_aux *lll_aux;
struct node_rx_hdr *rx_hdr;
struct ll_adv_set *adv;
struct lll_adv *lll;
uint8_t handle;
uint32_t ret;
/* Get reference to ULL context */
adv = CONTAINER_OF(done->param, struct ll_adv_set, ull);
lll = &adv->lll;
if (adv->max_events && (adv->event_counter >= adv->max_events)) {
adv->max_events = 0;
@ -1628,7 +1632,7 @@ void ull_adv_done(struct node_rx_event_done *done)
struct ll_adv_aux_set *aux;
uint8_t aux_handle;
aux = (void *)HDR_LLL2EVT(lll_aux);
aux = HDR_LLL2ULL(lll_aux);
aux_handle = ull_adv_aux_handle_get(aux);
ret = ticker_stop(TICKER_INSTANCE_ID_CTLR,
TICKER_USER_ID_ULL_HIGH,
@ -2064,7 +2068,7 @@ static inline uint8_t disable(uint8_t handle)
struct ll_adv_aux_set *aux;
uint8_t err;
aux = (void *)HDR_LLL2EVT(lll_aux);
aux = HDR_LLL2ULL(lll_aux);
err = ull_adv_aux_stop(aux);
if (err) {

28
subsys/bluetooth/controller/ll_sw/ull_adv_aux.c
View file

@ -136,7 +136,7 @@ uint8_t ll_adv_aux_ad_data_set(uint8_t handle, uint8_t op, uint8_t frag_pref, ui
if (adv->is_enabled) {
struct ll_adv_aux_set *aux;
aux = (void *)HDR_LLL2EVT(adv->lll.aux);
aux = HDR_LLL2ULL(adv->lll.aux);
if (!aux->is_started) {
uint32_t ticks_slot_overhead;
uint32_t ticks_anchor;
@ -351,7 +351,7 @@ uint8_t ll_adv_aux_set_remove(uint8_t handle)
if (lll->sync) {
struct ll_adv_sync_set *sync;
sync = (void *)HDR_LLL2EVT(lll->sync);
sync = HDR_LLL2ULL(lll->sync);
if (sync->is_enabled) {
return BT_HCI_ERR_CMD_DISALLOWED;
@ -377,7 +377,7 @@ uint8_t ll_adv_aux_set_remove(uint8_t handle)
if (lll->aux) {
struct ll_adv_aux_set *aux;
aux = (void *)HDR_LLL2EVT(lll->aux);
aux = HDR_LLL2ULL(lll->aux);
lll->aux = NULL;
ull_adv_aux_release(aux);
@ -837,16 +837,16 @@ uint32_t ull_adv_aux_evt_init(struct ll_adv_aux_set *aux)
slot_us += 1000;
/* TODO: active_to_start feature port */
aux->evt.ticks_active_to_start = 0;
aux->evt.ticks_xtal_to_start =
aux->ull.ticks_active_to_start = 0;
aux->ull.ticks_prepare_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US);
aux->evt.ticks_preempt_to_start =
aux->ull.ticks_preempt_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_PREEMPT_MIN_US);
aux->evt.ticks_slot = HAL_TICKER_US_TO_TICKS(slot_us);
aux->ull.ticks_slot = HAL_TICKER_US_TO_TICKS(slot_us);
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = MAX(aux->evt.ticks_active_to_start,
aux->evt.ticks_xtal_to_start);
ticks_slot_overhead = MAX(aux->ull.ticks_active_to_start,
aux->ull.ticks_prepare_to_start);
} else {
ticks_slot_overhead = 0;
}
@ -871,7 +871,7 @@ uint32_t ull_adv_aux_start(struct ll_adv_aux_set *aux, uint32_t ticks_anchor,
HAL_TICKER_US_TO_TICKS((uint64_t)aux->interval *
ADV_INT_UNIT_US),
TICKER_NULL_REMAINDER, TICKER_NULL_LAZY,
(aux->evt.ticks_slot + ticks_slot_overhead),
(aux->ull.ticks_slot + ticks_slot_overhead),
ticker_cb, aux,
ull_ticker_status_give, (void *)&ret_cb);
ret = ull_ticker_status_take(ret, &ret_cb);
@ -1025,7 +1025,7 @@ static inline void sync_info_fill(struct lll_adv_sync *lll_sync,
si->offs_adjust = 0U;
si->offs = 0U;
sync = (void *)HDR_LLL2EVT(lll_sync);
sync = HDR_LLL2ULL(lll_sync);
si->interval = sys_cpu_to_le16(sync->interval);
memcpy(si->sca_chm, lll_sync->data_chan_map,
sizeof(si->sca_chm));
@ -1049,7 +1049,7 @@ static void mfy_aux_offset_get(void *param)
uint8_t retry;
uint8_t id;
aux = (void *)HDR_LLL2EVT(adv->lll.aux);
aux = HDR_LLL2ULL(adv->lll.aux);
ticker_id = TICKER_ID_ADV_AUX_BASE + ull_adv_aux_handle_get(aux);
id = TICKER_NULL;
@ -1136,11 +1136,11 @@ static void ticker_cb(uint32_t ticks_at_expire, uint32_t remainder,
#if defined(CONFIG_BT_CTLR_ADV_PERIODIC)
struct ll_adv_set *adv;
adv = (void *)HDR_LLL2EVT(lll->adv);
adv = HDR_LLL2ULL(lll->adv);
if (adv->lll.sync) {
struct ll_adv_sync_set *sync;
sync = (void *)HDR_LLL2EVT(adv->lll.sync);
sync = HDR_LLL2ULL(adv->lll.sync);
if (sync->is_started) {
ull_adv_sync_offset_get(adv);
}

14
subsys/bluetooth/controller/ll_sw/ull_adv_iso.c
View file

@ -324,16 +324,16 @@ static uint32_t ull_adv_iso_start(struct ll_adv_iso *adv_iso,
slot_us = EVENT_OVERHEAD_START_US + EVENT_OVERHEAD_END_US;
slot_us += 1000;
adv_iso->evt.ticks_active_to_start = 0;
adv_iso->evt.ticks_xtal_to_start =
adv_iso->ull.ticks_active_to_start = 0;
adv_iso->ull.ticks_prepare_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US);
adv_iso->evt.ticks_preempt_to_start =
adv_iso->ull.ticks_preempt_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_PREEMPT_MIN_US);
adv_iso->evt.ticks_slot = HAL_TICKER_US_TO_TICKS(slot_us);
adv_iso->ull.ticks_slot = HAL_TICKER_US_TO_TICKS(slot_us);
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = MAX(adv_iso->evt.ticks_active_to_start,
adv_iso->evt.ticks_xtal_to_start);
ticks_slot_overhead = MAX(adv_iso->ull.ticks_active_to_start,
adv_iso->ull.ticks_prepare_to_start);
} else {
ticks_slot_overhead = 0;
}
@ -351,7 +351,7 @@ static uint32_t ull_adv_iso_start(struct ll_adv_iso *adv_iso,
HAL_TICKER_US_TO_TICKS(iso_interval_us),
HAL_TICKER_REMAINDER(iso_interval_us),
TICKER_NULL_LAZY,
(ll_adv_iso->evt.ticks_slot + ticks_slot_overhead),
(ll_adv_iso->ull.ticks_slot + ticks_slot_overhead),
ticker_cb, ll_adv_iso,
ull_ticker_status_give, (void *)&ret_cb);
ret = ull_ticker_status_take(ret, &ret_cb);

24
subsys/bluetooth/controller/ll_sw/ull_adv_sync.c
View file

@ -156,7 +156,7 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
ter_pdu->len = ter_len;
} else {
sync = (void *)HDR_LLL2EVT(lll_sync);
sync = HDR_LLL2ULL(lll_sync);
}
sync->interval = interval;
@ -232,7 +232,7 @@ uint8_t ll_adv_sync_enable(uint8_t handle, uint8_t enable)
return BT_HCI_ERR_UNKNOWN_ADV_IDENTIFIER;
}
sync = (void *)HDR_LLL2EVT(lll_sync);
sync = HDR_LLL2ULL(lll_sync);
if (!enable) {
if (!sync->is_enabled) {
@ -290,12 +290,12 @@ uint8_t ll_adv_sync_enable(uint8_t handle, uint8_t enable)
aux = NULL;
} else {
lll_aux = adv->lll.aux;
aux = (void *)HDR_LLL2EVT(lll_aux);
aux = HDR_LLL2ULL(lll_aux);
ticks_anchor_aux = ticker_ticks_now_get();
ticks_slot_overhead_aux = ull_adv_aux_evt_init(aux);
ticks_anchor_sync =
ticks_anchor_aux + ticks_slot_overhead_aux +
aux->evt.ticks_slot +
aux->ull.ticks_slot +
HAL_TICKER_US_TO_TICKS(EVENT_MAFS_US);
}
@ -395,16 +395,16 @@ uint32_t ull_adv_sync_start(struct ll_adv_set *adv,
#endif /* CONFIG_BT_CTLR_DF_ADV_CTE_TX */
/* TODO: active_to_start feature port */
sync->evt.ticks_active_to_start = 0;
sync->evt.ticks_xtal_to_start =
sync->ull.ticks_active_to_start = 0;
sync->ull.ticks_prepare_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US);
sync->evt.ticks_preempt_to_start =
sync->ull.ticks_preempt_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_PREEMPT_MIN_US);
sync->evt.ticks_slot = HAL_TICKER_US_TO_TICKS(slot_us);
sync->ull.ticks_slot = HAL_TICKER_US_TO_TICKS(slot_us);
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = MAX(sync->evt.ticks_active_to_start,
sync->evt.ticks_xtal_to_start);
ticks_slot_overhead = MAX(sync->ull.ticks_active_to_start,
sync->ull.ticks_prepare_to_start);
} else {
ticks_slot_overhead = 0;
}
@ -419,7 +419,7 @@ uint32_t ull_adv_sync_start(struct ll_adv_set *adv,
ticks_anchor, 0,
HAL_TICKER_US_TO_TICKS(interval_us),
HAL_TICKER_REMAINDER(interval_us), TICKER_NULL_LAZY,
(sync->evt.ticks_slot + ticks_slot_overhead),
(sync->ull.ticks_slot + ticks_slot_overhead),
ticker_cb, sync,
ull_ticker_status_give, (void *)&ret_cb);
ret = ull_ticker_status_take(ret, &ret_cb);
@ -896,7 +896,7 @@ static void mfy_sync_offset_get(void *param)
uint8_t id;
lll_sync = adv->lll.sync;
sync = (void *)HDR_LLL2EVT(lll_sync);
sync = HDR_LLL2ULL(lll_sync);
ticker_id = TICKER_ID_ADV_SYNC_BASE + sync_handle_get(sync);
id = TICKER_NULL;

4
subsys/bluetooth/controller/ll_sw/ull_adv_types.h
View file

@ -9,7 +9,6 @@ struct lll_df_adv_cfg;
#endif /* CONFIG_BT_CTLR_DF_ADV_CTE_TX */
struct ll_adv_set {
struct evt_hdr evt;
struct ull_hdr ull;
struct lll_adv lll;
@ -52,7 +51,6 @@ struct ll_adv_set {
#if defined(CONFIG_BT_CTLR_ADV_EXT)
struct ll_adv_aux_set {
struct evt_hdr evt;
struct ull_hdr ull;
struct lll_adv_aux lll;
@ -62,7 +60,6 @@ struct ll_adv_aux_set {
};
struct ll_adv_sync_set {
struct evt_hdr evt;
struct ull_hdr ull;
struct lll_adv_sync lll;
@ -73,7 +70,6 @@ struct ll_adv_sync_set {
};
struct ll_adv_iso {
struct evt_hdr evt;
struct ull_hdr ull;
struct lll_adv_iso lll;

51
subsys/bluetooth/controller/ll_sw/ull_conn.c
View file

@ -1152,16 +1152,20 @@ int ull_conn_llcp(struct ll_conn *conn, uint32_t ticks_at_expire, uint16_t lazy)
void ull_conn_done(struct node_rx_event_done *done)
{
struct lll_conn *lll = (void *)HDR_ULL2LLL(done->param);
struct ll_conn *conn = (void *)HDR_LLL2EVT(lll);
uint32_t ticks_drift_minus;
uint32_t ticks_drift_plus;
uint16_t latency_event;
uint16_t elapsed_event;
struct lll_conn *lll;
struct ll_conn *conn;
uint8_t reason_final;
uint16_t lazy;
uint8_t force;
/* Get reference to ULL context */
conn = CONTAINER_OF(done->param, struct ll_conn, ull);
lll = &conn->lll;
/* Skip if connection terminated by local host */
if (unlikely(lll->handle == 0xFFFF)) {
return;
@ -1988,12 +1992,17 @@ static void disabled_cb(void *param)
static void tx_lll_flush(void *param)
{
struct ll_conn *conn = (void *)HDR_LLL2EVT(param);
uint16_t handle = ll_conn_handle_get(conn);
struct lll_conn *lll = param;
struct node_rx_pdu *rx;
struct lll_conn *lll;
struct ll_conn *conn;
struct node_tx *tx;
memq_link_t *link;
uint16_t handle;
/* Get reference to ULL context */
lll = param;
conn = HDR_LLL2ULL(lll);
handle = ll_conn_handle_get(conn);
lll_conn_flush(handle, lll);
@ -2370,13 +2379,13 @@ static inline void event_conn_upd_init(struct ll_conn *conn,
conn->llcp.conn_upd.ticks_anchor = ticks_at_expire;
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
if (conn->evt.ticks_xtal_to_start & XON_BITMASK) {
if (conn->ull.ticks_prepare_to_start & XON_BITMASK) {
uint32_t ticks_prepare_to_start =
MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_preempt_to_start);
MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_preempt_to_start);
conn->llcp.conn_upd.ticks_anchor -=
(conn->evt.ticks_xtal_to_start &
(conn->ull.ticks_prepare_to_start &
~XON_BITMASK) - ticks_prepare_to_start;
}
#endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */
@ -2597,13 +2606,13 @@ static inline int event_conn_upd_prep(struct ll_conn *conn, uint16_t lazy,
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
/* restore to normal prepare */
if (conn->evt.ticks_xtal_to_start & XON_BITMASK) {
if (conn->ull.ticks_prepare_to_start & XON_BITMASK) {
uint32_t ticks_prepare_to_start =
MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_preempt_to_start);
MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_preempt_to_start);
conn->evt.ticks_xtal_to_start &= ~XON_BITMASK;
ticks_at_expire -= (conn->evt.ticks_xtal_to_start -
conn->ull.ticks_prepare_to_start &= ~XON_BITMASK;
ticks_at_expire -= (conn->ull.ticks_prepare_to_start -
ticks_prepare_to_start);
}
#endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */
@ -2627,8 +2636,8 @@ static inline int event_conn_upd_prep(struct ll_conn *conn, uint16_t lazy,
/* calculate the offset */
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead =
MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_xtal_to_start);
MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_prepare_to_start);
} else {
ticks_slot_overhead = 0U;
@ -2752,7 +2761,7 @@ static inline int event_conn_upd_prep(struct ll_conn *conn, uint16_t lazy,
TICKER_LAZY_MUST_EXPIRE_KEEP,
#endif /* CONFIG_BT_TICKER_LOW_LAT */
(ticks_slot_overhead +
conn->evt.ticks_slot),
conn->ull.ticks_slot),
#if defined(CONFIG_BT_PERIPHERAL) && defined(CONFIG_BT_CENTRAL)
lll->role ? ull_slave_ticker_cb :
ull_master_ticker_cb,
@ -3258,13 +3267,13 @@ static inline void event_conn_param_req(struct ll_conn *conn,
conn->llcp_conn_param.ticks_ref = ticks_at_expire;
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
if (conn->evt.ticks_xtal_to_start & XON_BITMASK) {
if (conn->ull.ticks_prepare_to_start & XON_BITMASK) {
uint32_t ticks_prepare_to_start =
MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_preempt_to_start);
MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_preempt_to_start);
conn->llcp_conn_param.ticks_ref -=
(conn->evt.ticks_xtal_to_start &
(conn->ull.ticks_prepare_to_start &
~XON_BITMASK) - ticks_prepare_to_start;
}
#endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */

8
subsys/bluetooth/controller/ll_sw/ull_conn_iso.c
View file

@ -181,11 +181,15 @@ void ull_conn_iso_cis_established(struct ll_conn_iso_stream *cis)
void ull_conn_iso_done(struct node_rx_event_done *done)
{
struct lll_conn_iso_group *lll = (void *)HDR_ULL2LLL(done->param);
struct ll_conn_iso_group *cig = (void *)HDR_LLL2EVT(lll);
struct lll_conn_iso_group *lll;
struct ll_conn_iso_group *cig;
uint32_t ticks_drift_minus;
uint32_t ticks_drift_plus;
/* Get reference to ULL context */
cig = CONTAINER_OF(done->param, struct ll_conn_iso_group, ull);
lll = &cig->lll;
/* Skip if CIG terminated by local host */
if (unlikely(lll->handle == 0xFFFF)) {
return;

1
subsys/bluetooth/controller/ll_sw/ull_conn_iso_types.h
View file

@ -24,7 +24,6 @@ struct ll_conn_iso_stream {
};
struct ll_conn_iso_group {
struct evt_hdr evt;
struct ull_hdr ull;
struct lll_conn_iso_group lll;

1
subsys/bluetooth/controller/ll_sw/ull_conn_types.h
View file

@ -31,7 +31,6 @@ enum llcp {
};
struct ll_conn {
struct evt_hdr evt;
struct ull_hdr ull;
struct lll_conn lll;

2
subsys/bluetooth/controller/ll_sw/ull_df.c
View file

@ -228,7 +228,7 @@ uint8_t ll_df_set_cl_cte_tx_enable(uint8_t adv_handle, uint8_t cte_enable)
return BT_HCI_ERR_CMD_DISALLOWED;
}
sync = (void *)HDR_LLL2EVT(lll_sync);
sync = HDR_LLL2ULL(lll_sync);
/* If df_cfg is NULL, then the HCI_LE_Set_Connectionless_CTE_Transmit_-
* Parameters command was not issued before.

29
subsys/bluetooth/controller/ll_sw/ull_master.c
View file

@ -313,12 +313,12 @@ uint8_t ll_create_connection(uint16_t scan_interval, uint16_t scan_window,
#endif
/* TODO: active_to_start feature port */
conn->evt.ticks_active_to_start = 0U;
conn->evt.ticks_xtal_to_start =
conn->ull.ticks_active_to_start = 0U;
conn->ull.ticks_prepare_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US);
conn->evt.ticks_preempt_to_start =
conn->ull.ticks_preempt_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_PREEMPT_MIN_US);
conn->evt.ticks_slot =
conn->ull.ticks_slot =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US +
ready_delay_us +
328 + EVENT_IFS_US + 328);
@ -466,11 +466,12 @@ uint8_t ll_connect_disable(void **rx)
}
if (!err) {
struct ll_conn *conn = (void *)HDR_LLL2EVT(conn_lll);
struct node_rx_pdu *node_rx;
struct node_rx_cc *cc;
struct ll_conn *conn;
memq_link_t *link;
conn = HDR_LLL2ULL(conn_lll);
node_rx = (void *)&conn->llcp_terminate.node_rx;
link = node_rx->hdr.link;
LL_ASSERT(link);
@ -613,10 +614,8 @@ uint8_t ll_enc_req_send(uint16_t handle, uint8_t const *const rand,
void ull_master_cleanup(struct node_rx_hdr *rx_free)
{
struct node_rx_ftr *ftr = &rx_free->rx_ftr;
struct ll_scan_set *scan =
(void *)HDR_LLL2EVT(ftr->param);
struct lll_conn *conn_lll;
struct ll_scan_set *scan;
struct ll_conn *conn;
memq_link_t *link;
@ -625,6 +624,7 @@ void ull_master_cleanup(struct node_rx_hdr *rx_free)
* coded PHY scanning context, hence releasing only this one
* connection context.
*/
scan = HDR_LLL2ULL(rx_free->rx_ftr.param);
conn_lll = scan->lll.conn;
LL_ASSERT(conn_lll);
scan->lll.conn = NULL;
@ -635,7 +635,7 @@ void ull_master_cleanup(struct node_rx_hdr *rx_free)
LL_ASSERT(link);
conn_lll->link_tx_free = link;
conn = (void *)HDR_LLL2EVT(conn_lll);
conn = HDR_LLL2ULL(conn_lll);
ll_conn_release(conn);
/* 1M PHY is disabled here if both 1M and coded PHY was enabled for
@ -770,8 +770,8 @@ void ull_master_setup(memq_link_t *link, struct node_rx_hdr *rx,
ll_rx_put(link, rx);
ll_rx_sched();
ticks_slot_offset = MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_xtal_to_start);
ticks_slot_offset = MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_prepare_to_start);
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = ticks_slot_offset;
@ -824,7 +824,7 @@ void ull_master_setup(memq_link_t *link, struct node_rx_hdr *rx,
HAL_TICKER_US_TO_TICKS(conn_interval_us),
HAL_TICKER_REMAINDER(conn_interval_us),
TICKER_NULL_LAZY,
(conn->evt.ticks_slot +
(conn->ull.ticks_slot +
ticks_slot_overhead),
ull_master_ticker_cb, conn, ticker_op_cb,
(void *)__LINE__);
@ -924,17 +924,18 @@ static void ticker_op_cb(uint32_t status, void *params)
static inline void conn_release(struct ll_scan_set *scan)
{
struct lll_conn *lll = scan->lll.conn;
struct node_rx_pdu *cc;
struct lll_conn *lll;
struct ll_conn *conn;
memq_link_t *link;
lll = scan->lll.conn;
LL_ASSERT(!lll->link_tx_free);
link = memq_deinit(&lll->memq_tx.head, &lll->memq_tx.tail);
LL_ASSERT(link);
lll->link_tx_free = link;
conn = (void *)HDR_LLL2EVT(lll);
conn = HDR_LLL2ULL(lll);
cc = (void *)&conn->llcp_terminate.node_rx;
link = cc->hdr.link;

28
subsys/bluetooth/controller/ll_sw/ull_scan.c
View file

@ -365,23 +365,23 @@ uint8_t ull_scan_enable(struct ll_scan_set *scan)
SCAN_INT_UNIT_US);
/* TODO: active_to_start feature port */
scan->evt.ticks_active_to_start = 0U;
scan->evt.ticks_xtal_to_start =
scan->ull.ticks_active_to_start = 0U;
scan->ull.ticks_prepare_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US);
scan->evt.ticks_preempt_to_start =
scan->ull.ticks_preempt_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_PREEMPT_MIN_US);
if ((lll->ticks_window +
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US)) <
(ticks_interval -
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US))) {
scan->evt.ticks_slot =
scan->ull.ticks_slot =
(lll->ticks_window +
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US));
} else {
if (IS_ENABLED(CONFIG_BT_CTLR_SCAN_UNRESERVED)) {
scan->evt.ticks_slot = 0U;
scan->ull.ticks_slot = 0U;
} else {
scan->evt.ticks_slot = ticks_interval -
scan->ull.ticks_slot = ticks_interval -
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US);
}
@ -389,8 +389,8 @@ uint8_t ull_scan_enable(struct ll_scan_set *scan)
}
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = MAX(scan->evt.ticks_active_to_start,
scan->evt.ticks_xtal_to_start);
ticks_slot_overhead = MAX(scan->ull.ticks_active_to_start,
scan->ull.ticks_prepare_to_start);
} else {
ticks_slot_overhead = 0U;
}
@ -403,7 +403,7 @@ uint8_t ull_scan_enable(struct ll_scan_set *scan)
uint32_t offset_us = 0U;
ull_sched_after_mstr_slot_get(TICKER_USER_ID_THREAD,
(scan->evt.ticks_slot +
(scan->ull.ticks_slot +
ticks_slot_overhead),
&ticks_ref, &offset_us);
@ -427,7 +427,7 @@ uint8_t ull_scan_enable(struct ll_scan_set *scan)
HAL_TICKER_REMAINDER((uint64_t)lll->interval *
SCAN_INT_UNIT_US),
TICKER_NULL_LAZY,
(scan->evt.ticks_slot + ticks_slot_overhead),
(scan->ull.ticks_slot + ticks_slot_overhead),
ticker_cb, scan,
ull_ticker_status_give, (void *)&ret_cb);
ret = ull_ticker_status_take(ret, &ret_cb);
@ -472,8 +472,10 @@ void ull_scan_done(struct node_rx_event_done *done)
uint8_t handle;
uint32_t ret;
lll = (void *)HDR_ULL2LLL(done->param);
scan = (void *)HDR_LLL2EVT(lll);
/* Get reference to ULL context */
scan = CONTAINER_OF(done->param, struct ll_scan_set, ull);
lll = &scan->lll;
if (likely(scan->duration_lazy || !lll->duration_reload ||
lll->duration_expire)) {
return;
@ -883,7 +885,7 @@ static void ext_disabled_cb(void *param)
* node_rx is already utilized to send terminate event on connection
*/
lll = (void *)param;
scan = (void *)HDR_LLL2EVT(lll);
scan = HDR_LLL2ULL(lll);
rx_hdr = (void *)scan->node_rx_scan_term;
if (!rx_hdr) {
return;

32
subsys/bluetooth/controller/ll_sw/ull_scan_aux.c
View file

@ -105,21 +105,21 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx)
case NODE_RX_TYPE_EXT_1M_REPORT:
lll = NULL;
aux = NULL;
scan = (void *)HDR_LLL2EVT(ftr->param);
scan = HDR_LLL2ULL(ftr->param);
sync = sync_create_get(scan);
phy = BT_HCI_LE_EXT_SCAN_PHY_1M;
break;
case NODE_RX_TYPE_EXT_CODED_REPORT:
lll = NULL;
aux = NULL;
scan = (void *)HDR_LLL2EVT(ftr->param);
scan = HDR_LLL2ULL(ftr->param);
sync = sync_create_get(scan);
phy = BT_HCI_LE_EXT_SCAN_PHY_CODED;
break;
case NODE_RX_TYPE_EXT_AUX_REPORT:
lll = ftr->param;
aux = (void *)HDR_LLL2EVT(lll);
scan = (void *)HDR_LLL2EVT(aux->rx_head->rx_ftr.param);
aux = HDR_LLL2ULL(lll);
scan = HDR_LLL2ULL(aux->rx_head->rx_ftr.param);
sync = (void *)scan;
scan = ull_scan_is_valid_get(scan);
phy = lll->phy;
@ -164,7 +164,7 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx)
* passed in the node rx footer field.
*/
lll_sync = ftr->param;
ull_sync = (void *)HDR_LLL2EVT(lll_sync);
ull_sync = HDR_LLL2ULL(lll_sync);
rx->handle = ull_sync_handle_get(ull_sync);
lll = NULL;
@ -291,20 +291,20 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx)
aux_offset_us -= window_widening_us;
/* TODO: active_to_start feature port */
aux->evt.ticks_active_to_start = 0;
aux->evt.ticks_xtal_to_start =
aux->ull.ticks_active_to_start = 0;
aux->ull.ticks_prepare_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US);
aux->evt.ticks_preempt_to_start =
aux->ull.ticks_preempt_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_PREEMPT_MIN_US);
aux->evt.ticks_slot =
aux->ull.ticks_slot =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US +
ready_delay_us +
PKT_AC_US(PDU_AC_EXT_PAYLOAD_SIZE_MAX,
0, lll->phy) +
EVENT_OVERHEAD_END_US);
ticks_slot_offset = MAX(aux->evt.ticks_active_to_start,
aux->evt.ticks_xtal_to_start);
ticks_slot_offset = MAX(aux->ull.ticks_active_to_start,
aux->ull.ticks_prepare_to_start);
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = ticks_slot_offset;
@ -324,7 +324,7 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx)
TICKER_NULL_PERIOD,
TICKER_NULL_REMAINDER,
TICKER_NULL_LAZY,
(aux->evt.ticks_slot +
(aux->ull.ticks_slot +
ticks_slot_overhead),
ticker_cb, aux, ticker_op_cb, aux);
LL_ASSERT((ticker_status == TICKER_STATUS_SUCCESS) ||
@ -358,10 +358,12 @@ ull_scan_aux_rx_flush:
void ull_scan_aux_done(struct node_rx_event_done *done)
{
struct lll_scan_aux *lll = (void *)HDR_ULL2LLL(done->param);
struct ll_scan_aux_set *aux = (void *)HDR_LLL2EVT(lll);
struct ll_scan_aux_set *aux;
struct ull_hdr *hdr;
/* Get reference to ULL context */
aux = CONTAINER_OF(done->param, struct ll_scan_aux_set, ull);
/* Setup the disabled callback to flush the auxiliary PDUs */
hdr = &aux->ull;
LL_ASSERT(!hdr->disabled_cb);
@ -416,7 +418,7 @@ static void last_disabled_cb(void *param)
struct node_rx_hdr *rx;
rx = param;
aux = (void *)HDR_LLL2EVT(rx->rx_ftr.param);
aux = HDR_LLL2ULL(rx->rx_ftr.param);
flush(aux, rx);
}

2
subsys/bluetooth/controller/ll_sw/ull_scan_types.h
View file

@ -5,7 +5,6 @@
*/
struct ll_scan_set {
struct evt_hdr evt;
struct ull_hdr ull;
struct lll_scan lll;
@ -39,7 +38,6 @@ struct ll_scan_set {
};
struct ll_scan_aux_set {
struct evt_hdr evt;
struct ull_hdr ull;
struct lll_scan_aux lll;

57
subsys/bluetooth/controller/ll_sw/ull_sched.c
View file

@ -96,13 +96,13 @@ void ull_sched_after_mstr_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
uint32_t ticks_slot_abs_curr = 0;
#if defined(CONFIG_BT_CTLR_LOW_LAT)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
if (conn->evt.ticks_xtal_to_start & XON_BITMASK) {
if (conn->ull.ticks_prepare_to_start & XON_BITMASK) {
uint32_t ticks_prepare_to_start =
MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_preempt_to_start);
MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_preempt_to_start);
ticks_slot_abs_curr =
conn->evt.ticks_xtal_to_start &
conn->ull.ticks_prepare_to_start &
~XON_BITMASK;
ticks_to_expire_normal -=
ticks_slot_abs_curr -
@ -111,14 +111,14 @@ void ull_sched_after_mstr_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
#endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */
{
uint32_t ticks_prepare_to_start =
MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_xtal_to_start);
MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_prepare_to_start);
ticks_slot_abs_curr = ticks_prepare_to_start;
}
#endif
ticks_slot_abs_curr += conn->evt.ticks_slot;
ticks_slot_abs_curr += conn->ull.ticks_slot;
if ((ticker_id_prev != 0xff) &&
(ticker_ticks_diff_get(ticks_to_expire_normal,
@ -145,18 +145,19 @@ void ull_sched_mfy_after_mstr_offset_get(void *param)
{
struct lll_prepare_param *p = param;
struct lll_scan *lll = p->param;
struct evt_hdr *conn_evt = HDR_LLL2EVT(lll->conn);
uint32_t ticks_slot_overhead;
struct ll_conn *conn;
conn = HDR_LLL2ULL(lll->conn);
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = MAX(conn_evt->ticks_active_to_start,
conn_evt->ticks_xtal_to_start);
ticks_slot_overhead = MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_prepare_to_start);
} else {
ticks_slot_overhead = 0U;
}
after_mstr_offset_get(lll->conn->interval,
(ticks_slot_overhead + conn_evt->ticks_slot),
(ticks_slot_overhead + conn->ull.ticks_slot),
p->ticks_at_expire, &lll->conn_win_offset_us);
}
#endif /* CONFIG_BT_CENTRAL */
@ -168,14 +169,14 @@ void ull_sched_mfy_win_offset_use(void *param)
uint16_t win_offset;
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_xtal_to_start);
ticks_slot_overhead = MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_prepare_to_start);
} else {
ticks_slot_overhead = 0U;
}
after_mstr_offset_get(conn->lll.interval,
(ticks_slot_overhead + conn->evt.ticks_slot),
(ticks_slot_overhead + conn->ull.ticks_slot),
conn->llcp.conn_upd.ticks_anchor,
&conn->llcp_cu.win_offset_us);
@ -318,26 +319,26 @@ static void win_offset_calc(struct ll_conn *conn_curr, uint8_t is_select,
#if defined(CONFIG_BT_CTLR_LOW_LAT)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
if (conn_curr->evt.ticks_xtal_to_start & XON_BITMASK) {
if (conn_curr->ull.ticks_prepare_to_start & XON_BITMASK) {
uint32_t ticks_prepare_to_start =
MAX(conn_curr->evt.ticks_active_to_start,
conn_curr->evt.ticks_preempt_to_start);
MAX(conn_curr->ull.ticks_active_to_start,
conn_curr->ull.ticks_preempt_to_start);
ticks_slot_abs = conn_curr->evt.ticks_xtal_to_start &
ticks_slot_abs = conn_curr->ull.ticks_prepare_to_start &
~XON_BITMASK;
ticks_prepare_reduced = ticks_slot_abs - ticks_prepare_to_start;
} else
#endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */
{
uint32_t ticks_prepare_to_start =
MAX(conn_curr->evt.ticks_active_to_start,
conn_curr->evt.ticks_xtal_to_start);
MAX(conn_curr->ull.ticks_active_to_start,
conn_curr->ull.ticks_prepare_to_start);
ticks_slot_abs = ticks_prepare_to_start;
}
#endif
ticks_slot_abs += conn_curr->evt.ticks_slot;
ticks_slot_abs += conn_curr->ull.ticks_slot;
if (conn_curr->lll.role) {
ticks_slot_abs += HAL_TICKER_US_TO_TICKS(EVENT_TIES_US);
@ -417,13 +418,13 @@ static void win_offset_calc(struct ll_conn *conn_curr, uint8_t is_select,
uint32_t ticks_slot_abs_curr = 0U;
#if defined(CONFIG_BT_CTLR_LOW_LAT)
#if defined(CONFIG_BT_CTLR_XTAL_ADVANCED)
if (conn->evt.ticks_xtal_to_start & XON_BITMASK) {
if (conn->ull.ticks_prepare_to_start & XON_BITMASK) {
uint32_t ticks_prepare_to_start =
MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_preempt_to_start);
MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_preempt_to_start);
ticks_slot_abs_curr =
conn->evt.ticks_xtal_to_start &
conn->ull.ticks_prepare_to_start &
~XON_BITMASK;
ticks_to_expire_normal -=
ticks_slot_abs_curr -
@ -432,14 +433,14 @@ static void win_offset_calc(struct ll_conn *conn_curr, uint8_t is_select,
#endif /* CONFIG_BT_CTLR_XTAL_ADVANCED */
{
uint32_t ticks_prepare_to_start =
MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_xtal_to_start);
MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_prepare_to_start);
ticks_slot_abs_curr = ticks_prepare_to_start;
}
#endif
ticks_slot_abs_curr += conn->evt.ticks_slot +
ticks_slot_abs_curr += conn->ull.ticks_slot +
HAL_TICKER_US_TO_TICKS(CONN_INT_UNIT_US);
if (conn->lll.role) {

16
subsys/bluetooth/controller/ll_sw/ull_slave.c
View file

@ -328,18 +328,18 @@ void ull_slave_setup(memq_link_t *link, struct node_rx_hdr *rx,
#endif
/* TODO: active_to_start feature port */
conn->evt.ticks_active_to_start = 0U;
conn->evt.ticks_xtal_to_start =
conn->ull.ticks_active_to_start = 0U;
conn->ull.ticks_prepare_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US);
conn->evt.ticks_preempt_to_start =
conn->ull.ticks_preempt_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_PREEMPT_MIN_US);
conn->evt.ticks_slot =
conn->ull.ticks_slot =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US +
ready_delay_us +
328 + EVENT_IFS_US + 328);
ticks_slot_offset = MAX(conn->evt.ticks_active_to_start,
conn->evt.ticks_xtal_to_start);
ticks_slot_offset = MAX(conn->ull.ticks_active_to_start,
conn->ull.ticks_prepare_to_start);
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = ticks_slot_offset;
@ -370,7 +370,7 @@ void ull_slave_setup(memq_link_t *link, struct node_rx_hdr *rx,
if (lll_aux) {
struct ll_adv_aux_set *aux;
aux = (void *)HDR_LLL2EVT(lll_aux);
aux = HDR_LLL2ULL(lll_aux);
ticker_id_adv = TICKER_ID_ADV_AUX_BASE +
ull_adv_aux_handle_get(aux);
@ -411,7 +411,7 @@ void ull_slave_setup(memq_link_t *link, struct node_rx_hdr *rx,
HAL_TICKER_US_TO_TICKS(conn_interval_us),
HAL_TICKER_REMAINDER(conn_interval_us),
TICKER_NULL_LAZY,
(conn->evt.ticks_slot +
(conn->ull.ticks_slot +
ticks_slot_overhead),
ull_slave_ticker_cb, conn, ticker_op_cb,
(void *)__LINE__);

24
subsys/bluetooth/controller/ll_sw/ull_sync.c
View file

@ -323,7 +323,7 @@ uint16_t ull_sync_handle_get(struct ll_sync_set *sync)
uint16_t ull_sync_lll_handle_get(struct lll_sync *lll)
{
return ull_sync_handle_get((void *)HDR_LLL2EVT(lll));
return ull_sync_handle_get(HDR_LLL2ULL(lll));
}
void ull_sync_release(struct ll_sync_set *sync)
@ -430,20 +430,20 @@ void ull_sync_setup(struct ll_scan_set *scan, struct ll_scan_aux_set *aux,
interval_us -= lll->window_widening_periodic_us;
/* TODO: active_to_start feature port */
sync->evt.ticks_active_to_start = 0U;
sync->evt.ticks_xtal_to_start =
sync->ull.ticks_active_to_start = 0U;
sync->ull.ticks_prepare_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_XTAL_US);
sync->evt.ticks_preempt_to_start =
sync->ull.ticks_preempt_to_start =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_PREEMPT_MIN_US);
sync->evt.ticks_slot =
sync->ull.ticks_slot =
HAL_TICKER_US_TO_TICKS(EVENT_OVERHEAD_START_US +
ready_delay_us +
PKT_AC_US(PDU_AC_EXT_PAYLOAD_SIZE_MAX,
0, lll->phy) +
EVENT_OVERHEAD_END_US);
ticks_slot_offset = MAX(sync->evt.ticks_active_to_start,
sync->evt.ticks_xtal_to_start);
ticks_slot_offset = MAX(sync->ull.ticks_active_to_start,
sync->ull.ticks_prepare_to_start);
if (IS_ENABLED(CONFIG_BT_CTLR_LOW_LAT)) {
ticks_slot_overhead = ticks_slot_offset;
@ -458,7 +458,7 @@ void ull_sync_setup(struct ll_scan_set *scan, struct ll_scan_aux_set *aux,
HAL_TICKER_US_TO_TICKS(interval_us),
HAL_TICKER_REMAINDER(interval_us),
TICKER_NULL_LAZY,
(sync->evt.ticks_slot + ticks_slot_overhead),
(sync->ull.ticks_slot + ticks_slot_overhead),
ticker_cb, sync, ticker_op_cb, (void *)__LINE__);
LL_ASSERT((ret == TICKER_STATUS_SUCCESS) ||
(ret == TICKER_STATUS_BUSY));
@ -466,15 +466,19 @@ void ull_sync_setup(struct ll_scan_set *scan, struct ll_scan_aux_set *aux,
void ull_sync_done(struct node_rx_event_done *done)
{
struct lll_sync *lll = (void *)HDR_ULL2LLL(done->param);
struct ll_sync_set *sync = (void *)HDR_LLL2EVT(lll);
uint32_t ticks_drift_minus;
uint32_t ticks_drift_plus;
struct ll_sync_set *sync;
uint16_t elapsed_event;
struct lll_sync *lll;
uint16_t skip_event;
uint16_t lazy;
uint8_t force;
/* Get reference to ULL context */
sync = CONTAINER_OF(done->param, struct ll_sync_set, ull);
lll = &sync->lll;
/* Events elapsed used in timeout checks below */
skip_event = lll->skip_event;
elapsed_event = skip_event + 1;

2
subsys/bluetooth/controller/ll_sw/ull_sync_iso.c
View file

@ -223,7 +223,7 @@ uint8_t ull_sync_iso_handle_get(struct ll_sync_iso *sync)
uint8_t ull_sync_iso_lll_handle_get(struct lll_sync_iso *lll)
{
return ull_sync_handle_get((void *)HDR_LLL2EVT(lll));
return ull_sync_handle_get(HDR_LLL2ULL(lll));
}
void ull_sync_iso_release(struct ll_sync_iso *sync_iso)

2
subsys/bluetooth/controller/ll_sw/ull_sync_types.h
View file

@ -13,7 +13,6 @@ struct ll_sync_iso;
#endif /* CONFIG_BT_CTLR_SYNC_ISO */
struct ll_sync_set {
struct evt_hdr evt;
struct ull_hdr ull;
struct lll_sync lll;
@ -56,7 +55,6 @@ struct node_rx_sync {
#if defined(CONFIG_BT_CTLR_SYNC_ISO)
struct ll_sync_iso {
struct evt_hdr evt;
struct ull_hdr ull;
struct lll_sync_iso lll;