bartoszek/zephyr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Bluetooth: controller: Extended Scanning Coded PHY duration and period

Browse Source 
Added implementation to support simultaneous 1M and Coded
PHY Extended Scanning duration and period. Also, added
implementation to support update to duration and period of
an active scanning instance.

Signed-off-by: Vinayak Kariappa Chettimada <vich@nordicsemi.no>
This commit is contained in:
Vinayak Kariappa Chettimada 2020-10-16 10:06:43 +05:30 committed by Carles Cufí
parent a5be61dede
commit 0cef1e43c9
4 changed files with 301 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_scan.c
View File

@ -314,17 +314,22 @@ static int is_abort_cb(void *next, int prio, void *curr,
/* TODO: check prio */
if (next != curr) {
int err;
#if defined(CONFIG_BT_CTLR_ADV_EXT)
if (unlikely(!lll->duration_reload || lll->duration_expire))
#endif /* CONFIG_BT_CTLR_ADV_EXT */
{
int err;
/* wrap back after the pre-empter */
*resume_cb = resume_prepare_cb;
*resume_prio = 0; /* TODO: */
/* wrap back after the pre-empter */
*resume_cb = resume_prepare_cb;
*resume_prio = 0; /* TODO: */
/* Retain HF clock */
err = lll_hfclock_on();
LL_ASSERT(err >= 0);
/* Retain HF clock */
err = lll_hfclock_on();
LL_ASSERT(err >= 0);
return -EAGAIN;
return -EAGAIN;
}
}
#if defined(CONFIG_BT_CTLR_ADV_EXT)

6
subsys/bluetooth/controller/ll_sw/ull.c
View File

@ -637,11 +637,7 @@ void ll_rx_dequeue(void)
case NODE_RX_TYPE_EXT_SCAN_TERMINATE:
{
struct ll_scan_set *scan;
scan = ull_scan_set_get(rx->handle);
scan->is_enabled = 0U;
ull_scan_term_dequeue(rx->handle);
}
break;
#endif /* CONFIG_BT_OBSERVER */

373
subsys/bluetooth/controller/ll_sw/ull_scan.c
View File

@ -51,6 +51,14 @@ static void ticker_cb(uint32_t ticks_at_expire, uint32_t remainder, uint16_t laz
static uint8_t disable(uint8_t handle);
#if defined(CONFIG_BT_CTLR_ADV_EXT)
static uint8_t is_scan_update(uint8_t handle, uint16_t duration,
uint16_t period, struct ll_scan_set **scan,
struct node_rx_pdu **node_rx_scan_term);
static uint8_t duration_period_setup(struct ll_scan_set *scan,
uint16_t duration, uint16_t period,
struct node_rx_pdu **node_rx_scan_term);
static uint8_t duration_period_update(struct ll_scan_set *scan,
uint8_t is_update);
static void ticker_op_ext_stop_cb(uint32_t status, void *param);
static void ext_disabled_cb(void *param);
#endif /* CONFIG_BT_CTLR_ADV_EXT */
@ -114,11 +122,13 @@ uint8_t ll_scan_enable(uint8_t enable, uint16_t duration, uint16_t period)
uint8_t ll_scan_enable(uint8_t enable)
#endif /* !CONFIG_BT_CTLR_ADV_EXT */
{
struct node_rx_pdu *node_rx_scan_term = NULL;
struct ll_scan_set *scan_coded = NULL;
struct ll_scan_set *scan;
uint8_t is_update_coded = 0U;
uint8_t own_addr_type = 0U;
uint8_t is_coded_phy = 0U;
struct lll_scan *lll;
uint8_t is_update_1m = 0U;
struct ll_scan_set *scan;
uint8_t err;
if (!enable) {
@ -139,13 +149,28 @@ uint8_t ll_scan_enable(uint8_t enable)
scan = ull_scan_is_disabled_get(SCAN_HANDLE_1M);
if (!scan) {
return BT_HCI_ERR_CMD_DISALLOWED;
#if defined(CONFIG_BT_CTLR_ADV_EXT)
is_update_1m = is_scan_update(SCAN_HANDLE_1M, duration, period,
&scan, &node_rx_scan_term);
if (!is_update_1m)
#endif /* CONFIG_BT_CTLR_ADV_EXT */
{
return BT_HCI_ERR_CMD_DISALLOWED;
}
}
#if defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_CTLR_PHY_CODED)
scan_coded = ull_scan_is_disabled_get(SCAN_HANDLE_PHY_CODED);
if (!scan_coded) {
return BT_HCI_ERR_CMD_DISALLOWED;
#if defined(CONFIG_BT_CTLR_ADV_EXT)
is_update_coded = is_scan_update(SCAN_HANDLE_PHY_CODED,
duration, period, &scan_coded,
&node_rx_scan_term);
if (!is_update_coded)
#endif /* CONFIG_BT_CTLR_ADV_EXT */
{
return BT_HCI_ERR_CMD_DISALLOWED;
}
}
own_addr_type = scan_coded->own_addr_type;
@ -153,68 +178,38 @@ uint8_t ll_scan_enable(uint8_t enable)
BT_HCI_LE_EXT_SCAN_PHY_CODED);
#endif /* CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_CTLR_PHY_CODED */
if (IS_ENABLED(CONFIG_BT_CTLR_ADV_EXT) && is_coded_phy &&
((own_addr_type & 0x1) ||
(scan->own_addr_type & 0x1))) {
if ((is_coded_phy && (own_addr_type & 0x1)) ||
(!is_coded_phy && (scan->own_addr_type & 0x1))) {
if (!mem_nz(ll_addr_get(1, NULL), BDADDR_SIZE)) {
return BT_HCI_ERR_INVALID_PARAM;
}
}
#if defined(CONFIG_BT_CTLR_ADV_EXT)
lll = &scan->lll;
if (duration) {
lll->duration_reload = ((uint32_t)duration *
EXT_SCAN_DURATION_UNIT_US /
SCAN_INTERVAL_UNIT_US) /
scan->lll.interval;
if (period) {
if (IS_ENABLED(CONFIG_BT_CTLR_PARAM_CHECK) &&
(duration >= ((uint32_t)period *
EXT_SCAN_PERIOD_UNIT_US/
EXT_SCAN_DURATION_UNIT_US))) {
return BT_HCI_ERR_INVALID_PARAM;
}
scan->duration_lazy = ((uint32_t)period *
EXT_SCAN_PERIOD_UNIT_US /
SCAN_INTERVAL_UNIT_US) /
scan->lll.interval;
scan->duration_lazy -= lll->duration_reload;
scan->node_rx_scan_term = NULL;
} else {
struct node_rx_pdu *node_rx_scan_term;
void *link_scan_term;
scan->duration_lazy = 0U;
/* The alloc here used for ext scan termination event */
link_scan_term = ll_rx_link_alloc();
if (!link_scan_term) {
return BT_HCI_ERR_MEM_CAPACITY_EXCEEDED;
}
node_rx_scan_term = ll_rx_alloc();
if (!node_rx_scan_term) {
ll_rx_link_release(link_scan_term);
return BT_HCI_ERR_MEM_CAPACITY_EXCEEDED;
}
node_rx_scan_term->hdr.link = (void *)link_scan_term;
scan->node_rx_scan_term = (void *)node_rx_scan_term;
#if defined(CONFIG_BT_CTLR_PHY_CODED)
if (!is_coded_phy || (scan->lll.phy & BT_HCI_LE_EXT_SCAN_PHY_1M))
#endif /* CONFIG_BT_CTLR_PHY_CODED */
{
err = duration_period_setup(scan, duration, period,
&node_rx_scan_term);
if (err) {
return err;
}
} else {
lll->duration_reload = 0U;
scan->duration_lazy = 0U;
scan->node_rx_scan_term = NULL;
}
lll->duration_expire = lll->duration_reload;
#else /* !CONFIG_BT_CTLR_ADV_EXT */
ARG_UNUSED(lll);
#endif /* !CONFIG_BT_CTLR_ADV_EXT */
if (IS_ENABLED(CONFIG_BT_CTLR_PHY_CODED) &&
is_coded_phy) {
err = duration_period_setup(scan_coded, duration, period,
&node_rx_scan_term);
if (err) {
return err;
}
}
#endif /* CONFIG_BT_CTLR_ADV_EXT */
#if defined(CONFIG_BT_CTLR_PRIVACY)
struct lll_scan *lll;
if (IS_ENABLED(CONFIG_BT_CTLR_ADV_EXT) && is_coded_phy) {
lll = &scan_coded->lll;
@ -236,13 +231,35 @@ uint8_t ll_scan_enable(uint8_t enable)
ull_filter_rpa_update(false);
lll->rpa_gen = 1;
}
#else /* !CONFIG_BT_CTLR_PRIVACY */
ARG_UNUSED(lll);
#endif /* !CONFIG_BT_CTLR_PRIVACY */
#endif /* CONFIG_BT_CTLR_PRIVACY */
#if defined(CONFIG_BT_CTLR_ADV_EXT) && defined(CONFIG_BT_CTLR_PHY_CODED)
#if defined(CONFIG_BT_CTLR_ADV_EXT)
#if defined(CONFIG_BT_CTLR_PHY_CODED)
if (!is_coded_phy || (scan->lll.phy & BT_HCI_LE_EXT_SCAN_PHY_1M))
#endif /* CONFIG_BT_CTLR_ADV_EXT && CONFIG_BT_CTLR_PHY_CODED */
#endif /* CONFIG_BT_CTLR_PHY_CODED */
{
err = duration_period_update(scan, is_update_1m);
if (err) {
return err;
} else if (is_update_1m) {
return 0;
}
}
if (IS_ENABLED(CONFIG_BT_CTLR_PHY_CODED) &&
is_coded_phy) {
err = duration_period_update(scan_coded, is_update_coded);
if (err) {
return err;
} else if (is_update_coded) {
return 0;
}
}
#if defined(CONFIG_BT_CTLR_PHY_CODED)
if (!is_coded_phy || (scan->lll.phy & BT_HCI_LE_EXT_SCAN_PHY_1M))
#endif /* CONFIG_BT_CTLR_PHY_CODED */
#endif /* CONFIG_BT_CTLR_ADV_EXT */
{
err = ull_scan_enable(scan);
if (err) {
@ -251,6 +268,7 @@ uint8_t ll_scan_enable(uint8_t enable)
}
if (IS_ENABLED(CONFIG_BT_CTLR_ADV_EXT) &&
IS_ENABLED(CONFIG_BT_CTLR_PHY_CODED) &&
is_coded_phy) {
err = ull_scan_enable(scan_coded);
if (err) {
@ -460,6 +478,92 @@ uint8_t ull_scan_disable(uint8_t handle, struct ll_scan_set *scan)
return 0;
}
#if defined(CONFIG_BT_CTLR_ADV_EXT)
void ull_scan_done(struct node_rx_event_done *done)
{
struct node_rx_hdr *rx_hdr;
struct ll_scan_set *scan;
struct lll_scan *lll;
uint8_t handle;
uint32_t ret;
lll = (void *)HDR_ULL2LLL(done->param);
scan = (void *)HDR_LLL2EVT(lll);
if (likely(scan->duration_lazy || !lll->duration_reload ||
lll->duration_expire)) {
return;
}
rx_hdr = (void *)scan->node_rx_scan_term;
if (!rx_hdr) {
/* Prevent generation if another scan instance already did so.
*/
return;
}
handle = ull_scan_handle_get(scan);
LL_ASSERT(handle < BT_CTLR_SCAN_SET);
#if defined(CONFIG_BT_CTLR_PHY_CODED)
/* Reset the singular node rx buffer, so that it does not get used if
* ull_scan_done get called by the other scan instance.
*/
struct ll_scan_set *scan_other;
if (handle == SCAN_HANDLE_1M) {
scan_other = ull_scan_set_get(SCAN_HANDLE_PHY_CODED);
} else {
scan_other = ull_scan_set_get(SCAN_HANDLE_1M);
}
scan_other->node_rx_scan_term = NULL;
#endif /* CONFIG_BT_CTLR_PHY_CODED */
rx_hdr->type = NODE_RX_TYPE_EXT_SCAN_TERMINATE;
rx_hdr->handle = handle;
ret = ticker_stop(TICKER_INSTANCE_ID_CTLR, TICKER_USER_ID_ULL_HIGH,
(TICKER_ID_SCAN_BASE + handle), ticker_op_ext_stop_cb,
scan);
LL_ASSERT((ret == TICKER_STATUS_SUCCESS) ||
(ret == TICKER_STATUS_BUSY));
}
void ull_scan_term_dequeue(uint8_t handle)
{
struct ll_scan_set *scan;
scan = ull_scan_set_get(handle);
LL_ASSERT(scan);
scan->is_enabled = 0U;
#if defined(CONFIG_BT_CTLR_PHY_CODED)
if (handle == SCAN_HANDLE_1M) {
struct ll_scan_set *scan_coded;
scan_coded = ull_scan_set_get(SCAN_HANDLE_PHY_CODED);
if (scan_coded->lll.phy & BT_HCI_LE_EXT_SCAN_PHY_CODED) {
uint8_t err;
err = disable(SCAN_HANDLE_PHY_CODED);
LL_ASSERT(!err);
}
} else {
struct ll_scan_set *scan_1m;
scan_1m = ull_scan_set_get(SCAN_HANDLE_1M);
if (scan_1m->lll.phy & BT_HCI_LE_EXT_SCAN_PHY_1M) {
uint8_t err;
err = disable(SCAN_HANDLE_1M);
LL_ASSERT(!err);
}
}
#endif /* CONFIG_BT_CTLR_PHY_CODED */
}
#endif /* CONFIG_BT_CTLR_ADV_EXT */
struct ll_scan_set *ull_scan_set_get(uint8_t handle)
{
if (handle >= BT_CTLR_SCAN_SET) {
@ -590,12 +694,16 @@ static void ticker_cb(uint32_t ticks_at_expire, uint32_t remainder,
lll->duration_expire = 0U;
}
} else if (lll->duration_reload) {
} else if (lll->duration_reload && lazy) {
uint8_t handle;
handle = ull_scan_handle_get(scan);
LL_ASSERT(handle < BT_CTLR_SCAN_SET);
lll->duration_expire = lll->duration_reload;
ret = ticker_update(TICKER_INSTANCE_ID_CTLR,
TICKER_USER_ID_ULL_HIGH,
(TICKER_ID_SCAN_BASE +
ull_scan_handle_get(scan)),
(TICKER_ID_SCAN_BASE + handle),
0, 0, 0, 0, 1, 1, NULL, NULL);
LL_ASSERT((ret == TICKER_STATUS_SUCCESS) ||
(ret == TICKER_STATUS_BUSY));
@ -622,34 +730,108 @@ static void ticker_cb(uint32_t ticks_at_expire, uint32_t remainder,
}
#if defined(CONFIG_BT_CTLR_ADV_EXT)
void ull_scan_done(struct node_rx_event_done *done)
static uint8_t is_scan_update(uint8_t handle, uint16_t duration,
uint16_t period, struct ll_scan_set **scan,
struct node_rx_pdu **node_rx_scan_term)
{
struct node_rx_hdr *rx_hdr;
struct ll_scan_set *scan;
struct lll_scan *lll;
uint8_t handle;
uint32_t ret;
*scan = ull_scan_set_get(handle);
*node_rx_scan_term = (void *)(*scan)->node_rx_scan_term;
return duration && period && (*scan)->lll.duration_reload &&
(*scan)->duration_lazy;
}
lll = (void *)HDR_ULL2LLL(done->param);
scan = (void *)HDR_LLL2EVT(lll);
if (likely(scan->duration_lazy || !lll->duration_reload ||
lll->duration_expire)) {
return;
static uint8_t duration_period_setup(struct ll_scan_set *scan,
uint16_t duration, uint16_t period,
struct node_rx_pdu **node_rx_scan_term)
{
struct lll_scan *lll;
lll = &scan->lll;
if (duration) {
lll->duration_reload = ((uint32_t)duration *
EXT_SCAN_DURATION_UNIT_US /
SCAN_INTERVAL_UNIT_US) /
scan->lll.interval;
if (period) {
if (IS_ENABLED(CONFIG_BT_CTLR_PARAM_CHECK) &&
(duration >= ((uint32_t)period *
EXT_SCAN_PERIOD_UNIT_US/
EXT_SCAN_DURATION_UNIT_US))) {
return BT_HCI_ERR_INVALID_PARAM;
}
scan->duration_lazy = ((uint32_t)period *
EXT_SCAN_PERIOD_UNIT_US /
SCAN_INTERVAL_UNIT_US) /
scan->lll.interval;
scan->duration_lazy -= lll->duration_reload;
scan->node_rx_scan_term = NULL;
} else {
struct node_rx_pdu *node_rx;
void *link_scan_term;
scan->duration_lazy = 0U;
if (*node_rx_scan_term) {
scan->node_rx_scan_term =
(void *)*node_rx_scan_term;
return 0;
}
/* The alloc here used for ext scan termination event */
link_scan_term = ll_rx_link_alloc();
if (!link_scan_term) {
return BT_HCI_ERR_MEM_CAPACITY_EXCEEDED;
}
node_rx = ll_rx_alloc();
if (!node_rx) {
ll_rx_link_release(link_scan_term);
return BT_HCI_ERR_MEM_CAPACITY_EXCEEDED;
}
node_rx->hdr.link = (void *)link_scan_term;
scan->node_rx_scan_term = (void *)node_rx;
*node_rx_scan_term = node_rx;
}
} else {
lll->duration_reload = 0U;
scan->duration_lazy = 0U;
scan->node_rx_scan_term = NULL;
}
handle = ull_scan_handle_get(scan);
LL_ASSERT(handle < BT_CTLR_SCAN_SET);
return 0;
}
rx_hdr = (void *)scan->node_rx_scan_term;
rx_hdr->type = NODE_RX_TYPE_EXT_SCAN_TERMINATE;
rx_hdr->handle = handle;
static uint8_t duration_period_update(struct ll_scan_set *scan,
uint8_t is_update)
{
if (is_update) {
uint32_t volatile ret_cb;
uint32_t ret;
ret = ticker_stop(TICKER_INSTANCE_ID_CTLR, TICKER_USER_ID_ULL_HIGH,
(TICKER_ID_SCAN_BASE + handle), ticker_op_ext_stop_cb,
scan);
scan->lll.duration_expire = 0U;
LL_ASSERT((ret == TICKER_STATUS_SUCCESS) ||
(ret == TICKER_STATUS_BUSY));
ret_cb = TICKER_STATUS_BUSY;
ret = ticker_update(TICKER_INSTANCE_ID_CTLR,
TICKER_USER_ID_THREAD,
(TICKER_ID_SCAN_BASE +
ull_scan_handle_get(scan)),
0, 0, 0, 0, 1, 1,
ull_ticker_status_give, (void *)&ret_cb);
ret = ull_ticker_status_take(ret, &ret_cb);
if (ret != TICKER_STATUS_SUCCESS) {
return BT_HCI_ERR_CMD_DISALLOWED;
}
return 0;
} else {
scan->lll.duration_expire = scan->lll.duration_reload;
}
return 0;
}
static void ticker_op_ext_stop_cb(uint32_t status, void *param)
@ -657,6 +839,7 @@ static void ticker_op_ext_stop_cb(uint32_t status, void *param)
static memq_link_t link;
static struct mayfly mfy = {0, 0, &link, NULL, NULL};
struct ll_scan_set *scan;
struct ull_hdr *hdr;
uint32_t ret;
/* Ignore if race between thread and ULL */
@ -667,11 +850,23 @@ static void ticker_op_ext_stop_cb(uint32_t status, void *param)
}
scan = param;
mfy.fp = ext_disabled_cb;
hdr = &scan->ull;
mfy.param = &scan->lll;
ret = mayfly_enqueue(TICKER_USER_ID_ULL_LOW, TICKER_USER_ID_ULL_HIGH, 0,
&mfy);
LL_ASSERT(!ret);
if (ull_ref_get(hdr)) {
LL_ASSERT(!hdr->disabled_cb);
hdr->disabled_param = mfy.param;
hdr->disabled_cb = ext_disabled_cb;
mfy.fp = lll_disable;
ret = mayfly_enqueue(TICKER_USER_ID_ULL_LOW,
TICKER_USER_ID_LLL, 0, &mfy);
LL_ASSERT(!ret);
} else {
mfy.fp = ext_disabled_cb;
ret = mayfly_enqueue(TICKER_USER_ID_ULL_LOW,
TICKER_USER_ID_ULL_HIGH, 0, &mfy);
LL_ASSERT(!ret);
}
}
static void ext_disabled_cb(void *param)

3
subsys/bluetooth/controller/ll_sw/ull_scan_internal.h
View File

@ -26,6 +26,9 @@ uint8_t ull_scan_enable(struct ll_scan_set *scan);
/* Disable scanning/initiating role */
uint8_t ull_scan_disable(uint8_t handle, struct ll_scan_set *scan);
/* Helper function to dequeue scan timeout event */
void ull_scan_term_dequeue(uint8_t handle);
/* Return ll_scan_set context (unconditional) */
struct ll_scan_set *ull_scan_set_get(uint8_t handle);