michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Bluetooth: controller: split: Review rework use defines

Browse source 
Review rework updates, use defines in place of magic values.

Signed-off-by: Vinayak Kariappa Chettimada <vich@nordicsemi.no>
This commit is contained in:
Vinayak Kariappa Chettimada 2020-05-12 18:36:05 +05:30 • committed by Carles Cufí
commit 130d63a1c2
10 changed files with 146 additions and 116 deletions
Download patch file Download diff file Expand all files Collapse all files

37
subsys/bluetooth/controller/hci/hci.c
View file

@ -3111,10 +3111,29 @@ static void le_ext_adv_legacy_report(struct pdu_data *pdu_data,
struct node_rx_pdu *node_rx,
struct net_buf *buf)
{
const uint8_t c_adv_type[] = { 0x13, 0x15, 0x10, 0xff,
0x1a, /* SCAN_RSP to an ADV_SCAN_IND */
0x1b, /* SCAN_RSP to an ADV_IND */
0x12 };
/* Lookup event type based on pdu_adv_type set by LLL */
const uint8_t evt_type_lookup[] = {
(BT_HCI_LE_ADV_EVT_TYPE_LEGACY | BT_HCI_LE_ADV_EVT_TYPE_SCAN |
BT_HCI_LE_ADV_EVT_TYPE_CONN), /* ADV_IND */
(BT_HCI_LE_ADV_EVT_TYPE_LEGACY | BT_HCI_LE_ADV_EVT_TYPE_DIRECT |
BT_HCI_LE_ADV_EVT_TYPE_CONN), /* DIRECT_IND */
(BT_HCI_LE_ADV_EVT_TYPE_LEGACY), /* NONCONN_IND */
0xff, /* Invalid index lookup */
(BT_HCI_LE_ADV_EVT_TYPE_LEGACY |
BT_HCI_LE_ADV_EVT_TYPE_SCAN_RSP |
BT_HCI_LE_ADV_EVT_TYPE_SCAN), /* SCAN_RSP to an ADV_SCAN_IND
*/
(BT_HCI_LE_ADV_EVT_TYPE_LEGACY |
BT_HCI_LE_ADV_EVT_TYPE_SCAN_RSP |
BT_HCI_LE_ADV_EVT_TYPE_SCAN |
BT_HCI_LE_ADV_EVT_TYPE_CONN), /* SCAN_RSP to an ADV_IND,
* NOTE: LLL explicitly sets
* adv_type to
* PDU_ADV_TYPE_ADV_IND_SCAN_RSP
*/
(BT_HCI_LE_ADV_EVT_TYPE_LEGACY |
BT_HCI_LE_ADV_EVT_TYPE_SCAN) /* SCAN_IND */
};
struct bt_hci_evt_le_ext_advertising_info *adv_info;
struct bt_hci_evt_le_ext_advertising_report *sep;
struct pdu_adv *adv = (void *)pdu_data;
@ -3172,7 +3191,7 @@ static void le_ext_adv_legacy_report(struct pdu_data *pdu_data,
sep->num_reports = 1U;
adv_info = (void *)(((uint8_t *)sep) + sizeof(*sep));
adv_info->evt_type = c_adv_type[adv->type];
adv_info->evt_type = evt_type_lookup[adv->type];
#if defined(CONFIG_BT_CTLR_PRIVACY)
if (rl_idx < ll_rl_size_get()) {
@ -3220,7 +3239,7 @@ static void le_ext_adv_report(struct pdu_data *pdu_data,
struct pdu_adv *adv = (void *)pdu_data;
struct node_rx_pdu *node_rx_curr;
struct node_rx_pdu *node_rx_next;
struct ext_adv_adi *adi = NULL;
struct pdu_adv_adi *adi = NULL;
uint8_t direct_addr_type = 0U;
uint8_t *direct_addr = NULL;
uint8_t total_data_len = 0U;
@ -3247,7 +3266,7 @@ static void le_ext_adv_report(struct pdu_data *pdu_data,
node_rx_curr = node_rx;
node_rx_next = node_rx_curr->hdr.rx_ftr.extra;
do {
struct ext_adv_adi *adi_curr = NULL;
struct pdu_adv_adi *adi_curr = NULL;
uint8_t direct_addr_type_curr = 0U;
struct pdu_adv_com_ext_adv *p;
uint8_t *direct_addr_curr = NULL;
@ -3255,7 +3274,7 @@ static void le_ext_adv_report(struct pdu_data *pdu_data,
uint8_t *adv_addr_curr = NULL;
uint8_t data_len_curr = 0U;
uint8_t *data_curr = NULL;
struct ext_adv_hdr *h;
struct pdu_adv_hdr *h;
uint8_t sec_phy_curr = 0U;
uint8_t evt_type_curr;
uint8_t *ptr;
@ -3320,7 +3339,7 @@ static void le_ext_adv_report(struct pdu_data *pdu_data,
}
if (h->aux_ptr) {
struct ext_adv_aux_ptr *aux;
struct pdu_adv_aux_ptr *aux;
uint8_t aux_phy;
aux = (void *)ptr;

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

@ -504,7 +504,7 @@ static void isr_done(void *param)
#if defined(CONFIG_BT_CTLR_ADV_EXT) && defined(BT_CTLR_ADV_EXT_PBACK)
} else {
struct pdu_adv_com_ext_adv *p;
struct ext_adv_hdr *h;
struct pdu_adv_hdr *h;
struct pdu_adv *pdu;
pdu = lll_adv_data_curr_get(lll);

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

@ -90,10 +90,10 @@ 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 pdu_adv_com_ext_adv *p;
struct ext_adv_aux_ptr *aux;
struct pdu_adv_aux_ptr *aux;
struct pdu_adv *pri, *sec;
struct lll_adv *lll_adv;
struct ext_adv_hdr *h;
struct pdu_adv_hdr *h;
struct evt_hdr *evt;
uint32_t remainder;
uint32_t start_us;
@ -123,7 +123,7 @@ static int prepare_cb(struct lll_prepare_param *prepare_param)
/* traverse through adi, if present */
if (h->adi) {
ptr += sizeof(struct ext_adv_adi);
ptr += sizeof(struct pdu_adv_adi);
}
aux = (void *)ptr;

2
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_adv_aux.h
View file

@ -9,6 +9,6 @@ int lll_adv_aux_reset(void);
void lll_adv_aux_prepare(void *param);
extern uint8_t ull_adv_aux_lll_handle_get(struct lll_adv_aux *lll);
extern struct ext_adv_aux_ptr *
extern struct pdu_adv_aux_ptr *
ull_adv_aux_lll_offset_fill(uint32_t ticks_offset, uint32_t start_us,
struct pdu_adv *pdu);

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

@ -89,8 +89,8 @@ void lll_adv_sync_offset_fill(uint32_t ticks_offset, uint32_t start_us,
struct pdu_adv *pdu)
{
struct pdu_adv_com_ext_adv *p;
struct ext_adv_sync_info *si;
struct ext_adv_hdr *h;
struct pdu_adv_sync_info *si;
struct pdu_adv_hdr *h;
uint8_t *ptr;
p = (void *)&pdu->adv_ext_ind;
@ -102,11 +102,11 @@ void lll_adv_sync_offset_fill(uint32_t ticks_offset, uint32_t start_us,
}
if (h->adi) {
ptr += sizeof(struct ext_adv_adi);
ptr += sizeof(struct pdu_adv_adi);
}
if (h->aux_ptr) {
ptr += sizeof(struct ext_adv_aux_ptr);
ptr += sizeof(struct pdu_adv_aux_ptr);
}
si = (void *)ptr;

22
subsys/bluetooth/controller/ll_sw/pdu.h
View file

@ -43,9 +43,9 @@
ADVA_SIZE + \
TARGETA_SIZE + \
CTE_INFO_SIZE + \
sizeof(struct ext_adv_adi) + \
sizeof(struct ext_adv_aux_ptr) + \
sizeof(struct ext_adv_sync_info) + \
sizeof(struct pdu_adv_adi) + \
sizeof(struct pdu_adv_aux_ptr) + \
sizeof(struct pdu_adv_sync_info) + \
TX_PWR_SIZE + \
ACAD_SIZE)
@ -216,13 +216,13 @@ struct pdu_adv_com_ext_adv {
uint8_t ext_hdr_adi_adv_data[254];
} __packed;
enum ext_adv_mode {
enum pdu_adv_mode {
EXT_ADV_MODE_NON_CONN_NON_SCAN = 0x00,
EXT_ADV_MODE_CONN_NON_SCAN = 0x01,
EXT_ADV_MODE_NON_CONN_SCAN = 0x02,
};
struct ext_adv_hdr {
struct pdu_adv_hdr {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
uint8_t adv_addr:1;
uint8_t tgt_addr:1;
@ -246,7 +246,7 @@ struct ext_adv_hdr {
#endif
} __packed;
struct ext_adv_adi {
struct pdu_adv_adi {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
uint16_t did:12;
uint16_t sid:4;
@ -258,7 +258,7 @@ struct ext_adv_adi {
#endif
} __packed;
struct ext_adv_aux_ptr {
struct pdu_adv_aux_ptr {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
uint8_t chan_idx:6;
uint8_t ca:1;
@ -276,23 +276,23 @@ struct ext_adv_aux_ptr {
#endif
} __packed;
enum ext_adv_aux_ptr_ca {
enum pdu_adv_aux_ptr_ca {
EXT_ADV_AUX_PTR_CA_500_PPM = 0x00,
EXT_ADV_AUX_PTR_CA_50_PPM = 0x01,
};
enum ext_adv_offs_units {
enum pdu_adv_offs_units {
EXT_ADV_AUX_PTR_OFFS_UNITS_30 = 0x00,
EXT_ADV_AUX_PTR_OFFS_UNITS_300 = 0x01,
};
enum ext_adv_aux_phy {
enum pdu_adv_aux_phy {
EXT_ADV_AUX_PHY_LE_1M = 0x00,
EXT_ADV_AUX_PHY_LE_2M = 0x01,
EXT_ADV_AUX_PHY_LE_COD = 0x02,
};
struct ext_adv_sync_info {
struct pdu_adv_sync_info {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
uint16_t offs:13;
uint16_t offs_units:1;

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

@ -125,23 +125,32 @@ uint8_t ll_adv_params_set(uint16_t interval, uint8_t adv_type,
/* extended adv param set */
if (adv_type == PDU_ADV_TYPE_EXT_IND) {
/* legacy */
if (evt_prop & BIT(4)) {
uint8_t const leg_adv_type[] = { 0x03, 0x04, 0x02, 0x00};
if (evt_prop & BT_HCI_LE_ADV_PROP_LEGACY) {
/* lookup evt_prop to PDU type in pdu_adv_type[] */
uint8_t const leg_adv_type[] = {
0x03, /* PDU_ADV_TYPE_NONCONN_IND */
0x04, /* PDU_ADV_TYPE_DIRECT_IND */
0x02, /* PDU_ADV_TYPE_SCAN_IND */
0x00 /* PDU_ADV_TYPE_ADV_IND */
};
adv_type = leg_adv_type[evt_prop & 0x03];
/* high duty cycle directed */
if (evt_prop & BIT(3)) {
adv_type = 0x01;
if (evt_prop & BT_HCI_LE_ADV_PROP_HI_DC_CONN) {
adv_type = 0x01; /* PDU_ADV_TYPE_DIRECT_IND */
}
adv->lll.phy_p = BIT(0);
adv->lll.phy_p = PHY_1M;
} else {
/* - Connectable and scannable not allowed;
* - High duty cycle directed connectable not allowed
*/
if (((evt_prop & 0x03) == 0x03) ||
((evt_prop & 0x0C) == 0x0C)) {
if (((evt_prop & (BT_HCI_LE_ADV_PROP_CONN |
BT_HCI_LE_ADV_PROP_SCAN)) ==
(BT_HCI_LE_ADV_PROP_CONN |
BT_HCI_LE_ADV_PROP_SCAN)) ||
(evt_prop & BT_HCI_LE_ADV_PROP_HI_DC_CONN)) {
return BT_HCI_ERR_INVALID_PARAM;
}
@ -155,7 +164,7 @@ uint8_t ll_adv_params_set(uint16_t interval, uint8_t adv_type,
adv->is_created = ULL_ADV_CREATED_BITMASK_CREATED |
ULL_ADV_CREATED_BITMASK_EXTENDED;
} else {
adv->lll.phy_p = BIT(0);
adv->lll.phy_p = PHY_1M;
/* Mark the adv set as created by legacy advertising cmd */
adv->is_created = ULL_ADV_CREATED_BITMASK_CREATED;
@ -249,7 +258,7 @@ uint8_t ll_adv_params_set(uint16_t interval, uint8_t adv_type,
#if defined(CONFIG_BT_CTLR_ADV_EXT)
} else if (pdu->type == PDU_ADV_TYPE_EXT_IND) {
struct pdu_adv_com_ext_adv *p;
struct ext_adv_hdr *h, _h;
struct pdu_adv_hdr *h, _h;
uint8_t *_ptr, *ptr;
uint8_t len;
@ -275,7 +284,8 @@ uint8_t ll_adv_params_set(uint16_t interval, uint8_t adv_type,
}
if (!p->adv_mode &&
(!_h.aux_ptr ||
(!(evt_prop & BIT(5)) && (phy_p != BIT(2))))) {
(!(evt_prop & BT_HCI_LE_ADV_PROP_ANON) &&
(phy_p != PHY_CODED)))) {
/* TODO: optional on 1M with Aux Ptr */
h->adv_addr = 1;
@ -295,14 +305,14 @@ uint8_t ll_adv_params_set(uint16_t interval, uint8_t adv_type,
/* ADI flag */
if (_h.adi) {
h->adi = 1;
ptr += sizeof(struct ext_adv_adi);
ptr += sizeof(struct pdu_adv_adi);
}
#if (CONFIG_BT_CTLR_ADV_AUX_SET > 0)
/* AuxPtr flag */
if (_h.aux_ptr) {
h->aux_ptr = 1;
ptr += sizeof(struct ext_adv_aux_ptr);
ptr += sizeof(struct pdu_adv_aux_ptr);
}
#endif /* (CONFIG_BT_CTLR_ADV_AUX_SET > 0) */
@ -312,8 +322,8 @@ uint8_t ll_adv_params_set(uint16_t interval, uint8_t adv_type,
/* C1, Tx Power is optional on the LE 1M PHY, and reserved for
* for future use on the LE Coded PHY.
*/
if (evt_prop & BIT(6) &&
(!_h.aux_ptr || (phy_p != BIT(2)))) {
if ((evt_prop & BT_HCI_LE_ADV_PROP_TX_POWER) &&
(!_h.aux_ptr || (phy_p != PHY_CODED))) {
h->tx_pwr = 1;
ptr++;
}
@ -359,9 +369,9 @@ uint8_t ll_adv_params_set(uint16_t interval, uint8_t adv_type,
#if (CONFIG_BT_CTLR_ADV_AUX_SET > 0)
/* AuxPtr */
if (h->aux_ptr) {
struct ext_adv_aux_ptr *aux;
struct pdu_adv_aux_ptr *aux;
ptr -= sizeof(struct ext_adv_aux_ptr);
ptr -= sizeof(struct pdu_adv_aux_ptr);
/* NOTE: Channel Index, CA, Offset Units and AUX Offset
* will be set in Advertiser Event.
@ -377,12 +387,12 @@ uint8_t ll_adv_params_set(uint16_t interval, uint8_t adv_type,
/* ADI */
if (h->adi) {
struct ext_adv_adi *adi;
struct pdu_adv_adi *adi;
ptr -= sizeof(struct ext_adv_adi);
ptr -= sizeof(struct pdu_adv_adi);
/* NOTE: memcpy shall handle overlapping buffers */
memcpy(ptr, _ptr, sizeof(struct ext_adv_adi));
memcpy(ptr, _ptr, sizeof(struct pdu_adv_adi));
adi = (void *)ptr;
adi->sid = sid;
@ -510,7 +520,7 @@ uint8_t ll_adv_enable(uint8_t enable)
#if defined(CONFIG_BT_CTLR_ADV_EXT)
} else if (pdu_adv->type == PDU_ADV_TYPE_EXT_IND) {
struct pdu_adv_com_ext_adv *p;
struct ext_adv_hdr *h;
struct pdu_adv_hdr *h;
uint8_t *ptr;
p = (void *)&pdu_adv->adv_ext_ind;
@ -534,7 +544,7 @@ uint8_t ll_adv_enable(uint8_t enable)
} else if (h->aux_ptr) {
struct pdu_adv_com_ext_adv *s;
struct pdu_adv *pdu_aux;
struct ext_adv_hdr *hs;
struct pdu_adv_hdr *hs;
uint8_t *ps;
pdu_aux = lll_adv_aux_data_peek(lll->aux);
@ -1220,9 +1230,10 @@ uint32_t ull_adv_is_enabled(uint8_t handle)
}
#if defined(CONFIG_BT_CTLR_ADV_EXT)
return BIT(0) | ((uint32_t)adv->is_created << 1);
return ULL_ADV_ENABLED_BITMASK_ENABLED |
((uint32_t)adv->is_created << 1);
#else /* !CONFIG_BT_CTLR_ADV_EXT */
return BIT(0);
return ULL_ADV_ENABLED_BITMASK_ENABLED;
#endif /* !CONFIG_BT_CTLR_ADV_EXT */
}

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

@ -86,7 +86,7 @@ uint8_t ll_adv_aux_ad_data_set(uint8_t handle, uint8_t op, uint8_t frag_pref, ui
struct pdu_adv_com_ext_adv *p, *_p, *s, *_s;
uint8_t pri_len, _pri_len, sec_len, _sec_len;
struct pdu_adv *_pri, *pri, *_sec, *sec;
struct ext_adv_hdr *hp, _hp, *hs, _hs;
struct pdu_adv_hdr *hp, _hp, *hs, _hs;
struct lll_adv_aux *lll_aux;
struct ll_adv_aux_set *aux;
uint8_t *_pp, *pp, *ps, *_ps;
@ -221,36 +221,36 @@ uint8_t ll_adv_aux_ad_data_set(uint8_t handle, uint8_t op, uint8_t frag_pref, ui
/* ADI flag */
if (_hp.adi) {
_pp += sizeof(struct ext_adv_adi);
_pp += sizeof(struct pdu_adv_adi);
}
hp->adi = 1;
pp += sizeof(struct ext_adv_adi);
pp += sizeof(struct pdu_adv_adi);
if (_hs.adi) {
_ps += sizeof(struct ext_adv_adi);
_ps += sizeof(struct pdu_adv_adi);
}
hs->adi = 1;
ps += sizeof(struct ext_adv_adi);
ps += sizeof(struct pdu_adv_adi);
/* AuxPtr flag */
if (_hp.aux_ptr) {
_pp += sizeof(struct ext_adv_aux_ptr);
_pp += sizeof(struct pdu_adv_aux_ptr);
}
hp->aux_ptr = 1;
pp += sizeof(struct ext_adv_aux_ptr);
pp += sizeof(struct pdu_adv_aux_ptr);
if (_hs.aux_ptr) {
_ps += sizeof(struct ext_adv_aux_ptr);
_ps += sizeof(struct pdu_adv_aux_ptr);
hs->aux_ptr = 1;
ps += sizeof(struct ext_adv_aux_ptr);
ps += sizeof(struct pdu_adv_aux_ptr);
}
/* No SyncInfo flag in primary channel PDU */
/* SyncInfo flag in secondary channel PDU */
if (_hs.sync_info) {
_ps += sizeof(struct ext_adv_sync_info);
_ps += sizeof(struct pdu_adv_sync_info);
hs->sync_info = 1;
ps += sizeof(struct ext_adv_sync_info);
ps += sizeof(struct pdu_adv_sync_info);
}
/* Tx Power flag */
@ -260,7 +260,7 @@ uint8_t ll_adv_aux_ad_data_set(uint8_t handle, uint8_t op, uint8_t frag_pref, ui
/* C1, Tx Power is optional on the LE 1M PHY, and reserved for
* for future use on the LE Coded PHY.
*/
if (lll->phy_p != BIT(2)) {
if (lll->phy_p != PHY_CODED) {
hp->tx_pwr = 1;
pp++;
} else {
@ -318,20 +318,20 @@ uint8_t ll_adv_aux_ad_data_set(uint8_t handle, uint8_t op, uint8_t frag_pref, ui
/* No SyncInfo in primary channel PDU */
/* SyncInfo in secondary channel PDU */
if (hs->sync_info) {
_ps -= sizeof(struct ext_adv_sync_info);
ps -= sizeof(struct ext_adv_sync_info);
_ps -= sizeof(struct pdu_adv_sync_info);
ps -= sizeof(struct pdu_adv_sync_info);
memcpy(ps, _ps, sizeof(struct ext_adv_sync_info));
memcpy(ps, _ps, sizeof(struct pdu_adv_sync_info));
}
/* AuxPtr */
if (_hp.aux_ptr) {
_pp -= sizeof(struct ext_adv_aux_ptr);
_pp -= sizeof(struct pdu_adv_aux_ptr);
}
{
struct ext_adv_aux_ptr *aux;
struct pdu_adv_aux_ptr *aux;
pp -= sizeof(struct ext_adv_aux_ptr);
pp -= sizeof(struct pdu_adv_aux_ptr);
/* NOTE: Aux Offset will be set in advertiser LLL event */
aux = (void *)pp;
@ -341,10 +341,10 @@ uint8_t ll_adv_aux_ad_data_set(uint8_t handle, uint8_t op, uint8_t frag_pref, ui
aux->phy = find_lsb_set(lll->phy_s) - 1;
}
if (_hs.aux_ptr) {
struct ext_adv_aux_ptr *aux;
struct pdu_adv_aux_ptr *aux;
_ps -= sizeof(struct ext_adv_aux_ptr);
ps -= sizeof(struct ext_adv_aux_ptr);
_ps -= sizeof(struct pdu_adv_aux_ptr);
ps -= sizeof(struct pdu_adv_aux_ptr);
/* NOTE: Aux Offset will be set in advertiser LLL event */
aux = (void *)ps;
@ -356,24 +356,24 @@ uint8_t ll_adv_aux_ad_data_set(uint8_t handle, uint8_t op, uint8_t frag_pref, ui
/* ADI */
{
struct ext_adv_adi *ap, *as;
struct pdu_adv_adi *ap, *as;
uint16_t did = UINT16_MAX;
pp -= sizeof(struct ext_adv_adi);
ps -= sizeof(struct ext_adv_adi);
pp -= sizeof(struct pdu_adv_adi);
ps -= sizeof(struct pdu_adv_adi);
ap = (void *)pp;
as = (void *)ps;
if (_hp.adi) {
struct ext_adv_adi *_adi;
struct pdu_adv_adi *_adi;
_pp -= sizeof(struct ext_adv_adi);
_ps -= sizeof(struct ext_adv_adi);
_pp -= sizeof(struct pdu_adv_adi);
_ps -= sizeof(struct pdu_adv_adi);
/* NOTE: memcpy shall handle overlapping buffers */
memcpy(pp, _pp, sizeof(struct ext_adv_adi));
memcpy(ps, _ps, sizeof(struct ext_adv_adi));
memcpy(pp, _pp, sizeof(struct pdu_adv_adi));
memcpy(ps, _ps, sizeof(struct pdu_adv_adi));
_adi = (void *)_pp;
did = sys_le16_to_cpu(_adi->did);
@ -640,13 +640,13 @@ void ull_adv_aux_offset_get(struct ll_adv_set *adv)
LL_ASSERT(!ret);
}
struct ext_adv_aux_ptr *ull_adv_aux_lll_offset_fill(uint32_t ticks_offset,
struct pdu_adv_aux_ptr *ull_adv_aux_lll_offset_fill(uint32_t ticks_offset,
uint32_t start_us,
struct pdu_adv *pdu)
{
struct pdu_adv_com_ext_adv *p;
struct ext_adv_aux_ptr *aux;
struct ext_adv_hdr *h;
struct pdu_adv_aux_ptr *aux;
struct pdu_adv_hdr *h;
uint8_t *ptr;
p = (void *)&pdu->adv_ext_ind;
@ -658,7 +658,7 @@ struct ext_adv_aux_ptr *ull_adv_aux_lll_offset_fill(uint32_t ticks_offset,
}
if (h->adi) {
ptr += sizeof(struct ext_adv_adi);
ptr += sizeof(struct pdu_adv_adi);
}
aux = (void *)ptr;

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

@ -55,7 +55,7 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
struct lll_adv_sync *lll_sync;
struct pdu_adv_com_ext_adv *t;
struct ll_adv_sync_set *sync;
struct ext_adv_hdr *ht, _ht;
struct pdu_adv_hdr *ht, _ht;
struct ll_adv_set *adv;
struct pdu_adv *pdu;
uint8_t *_pt, *pt;
@ -71,8 +71,8 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
struct pdu_adv_com_ext_adv *p, *_p, *s, *_s;
uint8_t pri_len, _pri_len, sec_len, _sec_len;
struct pdu_adv *_pri, *pri, *_sec, *sec;
struct ext_adv_hdr *hp, _hp, *hs, _hs;
struct ext_adv_sync_info *si;
struct pdu_adv_hdr *hp, _hp, *hs, _hs;
struct pdu_adv_sync_info *si;
struct lll_adv_aux *lll_aux;
uint8_t *_pp, *pp, *ps, *_ps;
uint8_t ip, is, ad_len;
@ -184,27 +184,27 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
/* ADI flag */
if (_hp.adi) {
_pp += sizeof(struct ext_adv_adi);
_pp += sizeof(struct pdu_adv_adi);
}
hp->adi = 1;
pp += sizeof(struct ext_adv_adi);
pp += sizeof(struct pdu_adv_adi);
if (_hs.adi) {
_ps += sizeof(struct ext_adv_adi);
_ps += sizeof(struct pdu_adv_adi);
}
hs->adi = 1;
ps += sizeof(struct ext_adv_adi);
ps += sizeof(struct pdu_adv_adi);
/* AuxPtr flag */
if (_hp.aux_ptr) {
_pp += sizeof(struct ext_adv_aux_ptr);
_pp += sizeof(struct pdu_adv_aux_ptr);
}
hp->aux_ptr = 1;
pp += sizeof(struct ext_adv_aux_ptr);
pp += sizeof(struct pdu_adv_aux_ptr);
if (_hs.aux_ptr) {
_ps += sizeof(struct ext_adv_aux_ptr);
_ps += sizeof(struct pdu_adv_aux_ptr);
hs->aux_ptr = 1;
ps += sizeof(struct ext_adv_aux_ptr);
ps += sizeof(struct pdu_adv_aux_ptr);
}
/* No SyncInfo flag in primary channel PDU */
@ -219,7 +219,7 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
/* C1, Tx Power is optional on the LE 1M PHY, and
* reserved for future use on the LE Coded PHY.
*/
if (adv->lll.phy_p != BIT(2)) {
if (adv->lll.phy_p != PHY_CODED) {
hp->tx_pwr = 1;
pp++;
} else {
@ -290,12 +290,12 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
/* AuxPtr */
if (_hp.aux_ptr) {
_pp -= sizeof(struct ext_adv_aux_ptr);
_pp -= sizeof(struct pdu_adv_aux_ptr);
}
{
struct ext_adv_aux_ptr *aux;
struct pdu_adv_aux_ptr *aux;
pp -= sizeof(struct ext_adv_aux_ptr);
pp -= sizeof(struct pdu_adv_aux_ptr);
/* NOTE: Aux Offset will be set in advertiser LLL event
*/
@ -310,10 +310,10 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
* primary PDU
*/
if (_hs.aux_ptr) {
struct ext_adv_aux_ptr *aux;
struct pdu_adv_aux_ptr *aux;
_ps -= sizeof(struct ext_adv_aux_ptr);
ps -= sizeof(struct ext_adv_aux_ptr);
_ps -= sizeof(struct pdu_adv_aux_ptr);
ps -= sizeof(struct pdu_adv_aux_ptr);
/* NOTE: Aux Offset will be set in advertiser LLL event
*/
@ -326,25 +326,25 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
/* ADI */
{
struct ext_adv_adi *ap, *as;
struct pdu_adv_adi *ap, *as;
uint16_t did = UINT16_MAX;
pp -= sizeof(struct ext_adv_adi);
ps -= sizeof(struct ext_adv_adi);
pp -= sizeof(struct pdu_adv_adi);
ps -= sizeof(struct pdu_adv_adi);
ap = (void *)pp;
as = (void *)ps;
if (_hp.adi) {
struct ext_adv_adi *_adi;
struct pdu_adv_adi *_adi;
_pp -= sizeof(struct ext_adv_adi);
_ps -= sizeof(struct ext_adv_adi);
_pp -= sizeof(struct pdu_adv_adi);
_ps -= sizeof(struct pdu_adv_adi);
/* NOTE: memcpy shall handle overlapping buffers
*/
memcpy(pp, _pp, sizeof(struct ext_adv_adi));
memcpy(ps, _ps, sizeof(struct ext_adv_adi));
memcpy(pp, _pp, sizeof(struct pdu_adv_adi));
memcpy(ps, _ps, sizeof(struct pdu_adv_adi));
_adi = (void *)_pp;
did = sys_le16_to_cpu(_adi->did);
@ -421,7 +421,7 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
/* No SyncInfo */
/* TODO: TxPower */
if (flags & BIT(6)) {
if (flags & BT_HCI_LE_ADV_PROP_TX_POWER) {
/* TODO: add/remove Tx Power in AUX_SYNC_IND PDU */
return BT_HCI_ERR_CMD_DISALLOWED;
}
@ -430,7 +430,7 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
/* TODO: AdvData */
/* Calc primary PDU len */
/* Calc tertiary PDU len */
ter_len = pt - (uint8_t *)t;
if (ter_len >
(offsetof(struct pdu_adv_com_ext_adv, ext_hdr_adi_adv_data) +

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

@ -72,7 +72,7 @@ int ull_scan_aux_reset(void)
void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx, uint8_t phy)
{
struct ext_adv_aux_ptr *aux_ptr;
struct pdu_adv_aux_ptr *aux_ptr;
struct pdu_adv_com_ext_adv *p;
struct ll_scan_aux_set *aux;
uint32_t ticks_slot_overhead;
@ -80,7 +80,7 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx, uint8_t phy)
struct lll_scan_aux *lll;
struct node_rx_ftr *ftr;
uint32_t ticks_slot_offset;
struct ext_adv_hdr *h;
struct pdu_adv_hdr *h;
uint32_t ready_delay_us;
struct pdu_adv *pdu;
uint32_t aux_offset_us;
@ -123,7 +123,7 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx, uint8_t phy)
}
if (h->adi) {
struct ext_adv_adi *adi;
struct pdu_adv_adi *adi;
adi = (void *)ptr;
ptr += sizeof(*adi);