michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Bluetooth: hci: Align terms with the Bluetooth v5.3 spec

Browse source 
The new inclusive naming terminology changes in v5.3 of the Bluetooth
specification affect the HCI layer, so apply all relevant changes to
align with it.

Signed-off-by: Carles Cufi <carles.cufi@nordicsemi.no>
This commit is contained in:
Carles Cufi 2021-09-16 10:43:02 +02:00 • committed by Carles Cufí
commit 1325edff48
14 changed files with 242 additions and 211 deletions
Download patch file Download diff file Expand all files Collapse all files

29
doc/releases/release-notes-2.7.rst
View file

@ -50,6 +50,35 @@ Deprecated in this release
:c:func:`bt_le_filter_accept_list_remove`
:c:func:`bt_le_filter_accept_list_clear`
Modified in this release
* The following Bluetooth macros and structures in :file:`hci.h` have been
modified to align with the inclusive naming in the v5.3 specification:
* ``BT_LE_FEAT_BIT_SLAVE_FEAT_REQ`` is now ``BT_LE_FEAT_BIT_PER_INIT_FEAT_XCHG``
* ``BT_LE_FEAT_BIT_CIS_MASTER`` is now ``BT_LE_FEAT_BIT_CIS_CENTRAL``
* ``BT_LE_FEAT_BIT_CIS_SLAVE`` is now ``BT_LE_FEAT_BIT_CIS_PERIPHERAL``
* ``BT_FEAT_LE_SLAVE_FEATURE_XCHG`` is now ``BT_FEAT_LE_PER_INIT_FEAT_XCHG``
* ``BT_FEAT_LE_CIS_MASTER`` is now ``BT_FEAT_LE_CIS_CENTRAL``
* ``BT_FEAT_LE_CIS_SLAVE`` is now ``BT_FEAT_LE_CIS_PERIPHERAL``
* ``BT_LE_STATES_SLAVE_CONN_ADV`` is now ``BT_LE_STATES_PER_CONN_ADV``
* ``BT_HCI_OP_LE_READ_WL_SIZE`` is now ``BT_HCI_OP_LE_READ_FAL_SIZE``
* ``bt_hci_rp_le_read_wl_size`` is now ``bt_hci_rp_le_read_fal_size``
* ``bt_hci_rp_le_read_wl_size::wl_size`` is now ``bt_hci_rp_le_read_fal_size::fal_size``
* ``BT_HCI_OP_LE_CLEAR_WL`` is now ``BT_HCI_OP_LE_CLEAR_FAL``
* ``BT_HCI_OP_LE_ADD_DEV_TO_WL`` is now ``BT_HCI_OP_LE_REM_DEV_FROM_FAL``
* ``bt_hci_cp_le_add_dev_to_wl`` is now ``bt_hci_cp_le_add_dev_to_fal``
* ``BT_HCI_OP_LE_REM_DEV_FROM_WL`` is now ``BT_HCI_OP_LE_REM_DEV_FROM_FAL``
* ``bt_hci_cp_le_rem_dev_from_wl`` is now ``bt_hci_cp_le_rem_dev_from_fal``
* ``BT_HCI_ROLE_MASTER`` is now ``BT_HCI_ROLE_CENTRAL``
* ``BT_HCI_ROLE_SLAVE`` is now ``BT_HCI_ROLE_PERIPHERAL``
* ``BT_EVT_MASK_CL_SLAVE_BC_RX`` is now ``BT_EVT_MASK_CL_PER_BC_RX``
* ``BT_EVT_MASK_CL_SLAVE_BC_TIMEOUT`` is now ``BT_EVT_MASK_CL_PER_BC_TIMEOUT``
* ``BT_EVT_MASK_SLAVE_PAGE_RSP_TIMEOUT`` is now ``BT_EVT_MASK_PER_PAGE_RSP_TIMEOUT``
* ``BT_EVT_MASK_CL_SLAVE_BC_CH_MAP_CHANGE`` is now ``BT_EVT_MASK_CL_PER_BC_CH_MAP_CHANGE``
* ``m_*`` structure members are now ``c_*``
* ``s_*`` structure members are now ``p_*``
Changes in this release
==========================

134
include/bluetooth/hci.h
View file

@ -132,7 +132,7 @@ struct bt_hci_cmd_hdr {
#define BT_LE_FEAT_BIT_ENC 0
#define BT_LE_FEAT_BIT_CONN_PARAM_REQ 1
#define BT_LE_FEAT_BIT_EXT_REJ_IND 2
#define BT_LE_FEAT_BIT_SLAVE_FEAT_REQ 3
#define BT_LE_FEAT_BIT_PER_INIT_FEAT_XCHG 3
#define BT_LE_FEAT_BIT_PING 4
#define BT_LE_FEAT_BIT_DLE 5
#define BT_LE_FEAT_BIT_PRIVACY 6
@ -157,8 +157,8 @@ struct bt_hci_cmd_hdr {
#define BT_LE_FEAT_BIT_PAST_RECV 25
#define BT_LE_FEAT_BIT_SCA_UPDATE 26
#define BT_LE_FEAT_BIT_REMOTE_PUB_KEY_VALIDATE 27
#define BT_LE_FEAT_BIT_CIS_MASTER 28
#define BT_LE_FEAT_BIT_CIS_SLAVE 29
#define BT_LE_FEAT_BIT_CIS_CENTRAL 28
#define BT_LE_FEAT_BIT_CIS_PERIPHERAL 29
#define BT_LE_FEAT_BIT_ISO_BROADCASTER 30
#define BT_LE_FEAT_BIT_SYNC_RECEIVER 31
#define BT_LE_FEAT_BIT_ISO_CHANNELS 32
@ -173,8 +173,8 @@ struct bt_hci_cmd_hdr {
BT_LE_FEAT_BIT_ENC)
#define BT_FEAT_LE_CONN_PARAM_REQ_PROC(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_CONN_PARAM_REQ)
#define BT_FEAT_LE_SLAVE_FEATURE_XCHG(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_SLAVE_FEAT_REQ)
#define BT_FEAT_LE_PER_INIT_FEAT_XCHG(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_PER_INIT_FEAT_XCHG)
#define BT_FEAT_LE_DLE(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_DLE)
#define BT_FEAT_LE_PHY_2M(feat) BT_LE_FEAT_TEST(feat, \
@ -205,10 +205,10 @@ struct bt_hci_cmd_hdr {
BT_LE_FEAT_BIT_PAST_SEND)
#define BT_FEAT_LE_PAST_RECV(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_PAST_RECV)
#define BT_FEAT_LE_CIS_MASTER(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_CIS_MASTER)
#define BT_FEAT_LE_CIS_SLAVE(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_CIS_SLAVE)
#define BT_FEAT_LE_CIS_CENTRAL(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_CIS_CENTRAL)
#define BT_FEAT_LE_CIS_PERIPHERAL(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_CIS_PERIPHERAL)
#define BT_FEAT_LE_ISO_BROADCASTER(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_ISO_BROADCASTER)
#define BT_FEAT_LE_SYNC_RECEIVER(feat) BT_LE_FEAT_TEST(feat, \
@ -216,15 +216,15 @@ struct bt_hci_cmd_hdr {
#define BT_FEAT_LE_ISO_CHANNELS(feat) BT_LE_FEAT_TEST(feat, \
BT_LE_FEAT_BIT_ISO_CHANNELS)
#define BT_FEAT_LE_CIS(feat) (BT_FEAT_LE_CIS_MASTER(feat) | \
BT_FEAT_LE_CIS_SLAVE(feat))
#define BT_FEAT_LE_CIS(feat) (BT_FEAT_LE_CIS_CENTRAL(feat) | \
BT_FEAT_LE_CIS_PERIPHERAL(feat))
#define BT_FEAT_LE_BIS(feat) (BT_FEAT_LE_ISO_BROADCASTER(feat) | \
BT_FEAT_LE_SYNC_RECEIVER(feat))
#define BT_FEAT_LE_ISO(feat) (BT_FEAT_LE_CIS(feat) | \
BT_FEAT_LE_BIS(feat))
/* LE States */
#define BT_LE_STATES_SLAVE_CONN_ADV(states) (states & 0x0000004000000000)
#define BT_LE_STATES_PER_CONN_ADV(states) (states & 0x0000004000000000)
/* Bonding/authentication types */
#define BT_HCI_NO_BONDING 0x00
@ -843,10 +843,10 @@ struct bt_hci_cp_le_set_random_address {
#define BT_LE_ADV_CHAN_MAP_CHAN_39 0x04
#define BT_LE_ADV_CHAN_MAP_ALL 0x07
#define BT_LE_ADV_FP_NO_WHITELIST 0x00
#define BT_LE_ADV_FP_WHITELIST_SCAN_REQ 0x01
#define BT_LE_ADV_FP_WHITELIST_CONN_IND 0x02
#define BT_LE_ADV_FP_WHITELIST_BOTH 0x03
#define BT_LE_ADV_FP_NO_FILTER 0x00
#define BT_LE_ADV_FP_FILTER_SCAN_REQ 0x01
#define BT_LE_ADV_FP_FILTER_CONN_IND 0x02
#define BT_LE_ADV_FP_FILTER_BOTH 0x03
#define BT_HCI_OP_LE_SET_ADV_PARAM BT_OP(BT_OGF_LE, 0x0006)
struct bt_hci_cp_le_set_adv_param {
@ -890,8 +890,10 @@ struct bt_hci_cp_le_set_adv_enable {
#define BT_HCI_LE_SCAN_PASSIVE 0x00
#define BT_HCI_LE_SCAN_ACTIVE 0x01
#define BT_HCI_LE_SCAN_FP_NO_WHITELIST 0x00
#define BT_HCI_LE_SCAN_FP_USE_WHITELIST 0x01
#define BT_HCI_LE_SCAN_FP_BASIC_NO_FILTER 0x00
#define BT_HCI_LE_SCAN_FP_BASIC_FILTER 0x01
#define BT_HCI_LE_SCAN_FP_EXT_NO_FILTER 0x02
#define BT_HCI_LE_SCAN_FP_EXT_FILTER 0x03
struct bt_hci_cp_le_set_scan_param {
uint8_t scan_type;
@ -916,8 +918,8 @@ struct bt_hci_cp_le_set_scan_enable {
#define BT_HCI_OP_LE_CREATE_CONN BT_OP(BT_OGF_LE, 0x000d)
#define BT_HCI_LE_CREATE_CONN_FP_DIRECT 0x00
#define BT_HCI_LE_CREATE_CONN_FP_WHITELIST 0x01
#define BT_HCI_LE_CREATE_CONN_FP_NO_FILTER 0x00
#define BT_HCI_LE_CREATE_CONN_FP_FILTER 0x01
struct bt_hci_cp_le_create_conn {
uint16_t scan_interval;
@ -935,21 +937,21 @@ struct bt_hci_cp_le_create_conn {
#define BT_HCI_OP_LE_CREATE_CONN_CANCEL BT_OP(BT_OGF_LE, 0x000e)
#define BT_HCI_OP_LE_READ_WL_SIZE BT_OP(BT_OGF_LE, 0x000f)
struct bt_hci_rp_le_read_wl_size {
#define BT_HCI_OP_LE_READ_FAL_SIZE BT_OP(BT_OGF_LE, 0x000f)
struct bt_hci_rp_le_read_fal_size {
uint8_t status;
uint8_t wl_size;
uint8_t fal_size;
} __packed;
#define BT_HCI_OP_LE_CLEAR_WL BT_OP(BT_OGF_LE, 0x0010)
#define BT_HCI_OP_LE_CLEAR_FAL BT_OP(BT_OGF_LE, 0x0010)
#define BT_HCI_OP_LE_ADD_DEV_TO_WL BT_OP(BT_OGF_LE, 0x0011)
struct bt_hci_cp_le_add_dev_to_wl {
#define BT_HCI_OP_LE_ADD_DEV_TO_FAL BT_OP(BT_OGF_LE, 0x0011)
struct bt_hci_cp_le_add_dev_to_fal {
bt_addr_le_t addr;
} __packed;
#define BT_HCI_OP_LE_REM_DEV_FROM_WL BT_OP(BT_OGF_LE, 0x0012)
struct bt_hci_cp_le_rem_dev_from_wl {
#define BT_HCI_OP_LE_REM_DEV_FROM_FAL BT_OP(BT_OGF_LE, 0x0012)
struct bt_hci_cp_le_rem_dev_from_fal {
bt_addr_le_t addr;
} __packed;
@ -1729,23 +1731,23 @@ struct bt_hci_rp_le_read_iso_tx_sync {
#define BT_HCI_OP_LE_SET_CIG_PARAMS BT_OP(BT_OGF_LE, 0x0062)
struct bt_hci_cis_params {
uint8_t cis_id;
uint16_t m_sdu;
uint16_t s_sdu;
uint8_t m_phy;
uint8_t s_phy;
uint8_t m_rtn;
uint8_t s_rtn;
uint16_t c_sdu;
uint16_t p_sdu;
uint8_t c_phy;
uint8_t p_phy;
uint8_t c_rtn;
uint8_t p_rtn;
} __packed;
struct bt_hci_cp_le_set_cig_params {
uint8_t cig_id;
uint8_t m_interval[3];
uint8_t s_interval[3];
uint8_t c_interval[3];
uint8_t p_interval[3];
uint8_t sca;
uint8_t packing;
uint8_t framing;
uint16_t m_latency;
uint16_t s_latency;
uint16_t c_latency;
uint16_t p_latency;
uint8_t num_cis;
struct bt_hci_cis_params cis[0];
} __packed;
@ -1761,22 +1763,22 @@ struct bt_hci_rp_le_set_cig_params {
struct bt_hci_cis_params_test {
uint8_t cis_id;
uint8_t nse;
uint16_t m_sdu;
uint16_t s_sdu;
uint16_t m_pdu;
uint16_t s_pdu;
uint8_t m_phy;
uint8_t s_phy;
uint8_t m_bn;
uint8_t s_bn;
uint16_t c_sdu;
uint16_t p_sdu;
uint16_t c_pdu;
uint16_t p_pdu;
uint8_t c_phy;
uint8_t p_phy;
uint8_t c_bn;
uint8_t p_bn;
} __packed;
struct bt_hci_cp_le_set_cig_params_test {
uint8_t cig_id;
uint8_t m_interval[3];
uint8_t s_interval[3];
uint8_t m_ft;
uint8_t s_ft;
uint8_t c_interval[3];
uint8_t p_interval[3];
uint8_t c_ft;
uint8_t p_ft;
uint16_t iso_interval;
uint8_t sca;
uint8_t packing;
@ -2237,8 +2239,8 @@ struct bt_hci_evt_auth_payload_timeout_exp {
uint16_t handle;
} __packed;
#define BT_HCI_ROLE_MASTER 0x00
#define BT_HCI_ROLE_SLAVE 0x01
#define BT_HCI_ROLE_CENTRAL 0x00
#define BT_HCI_ROLE_PERIPHERAL 0x01
#define BT_HCI_EVT_LE_CONN_COMPLETE 0x01
struct bt_hci_evt_le_conn_complete {
@ -2505,17 +2507,17 @@ struct bt_hci_evt_le_cis_established {
uint16_t conn_handle;
uint8_t cig_sync_delay[3];
uint8_t cis_sync_delay[3];
uint8_t m_latency[3];
uint8_t s_latency[3];
uint8_t m_phy;
uint8_t s_phy;
uint8_t c_latency[3];
uint8_t p_latency[3];
uint8_t c_phy;
uint8_t p_phy;
uint8_t nse;
uint8_t m_bn;
uint8_t s_bn;
uint8_t m_ft;
uint8_t s_ft;
uint16_t m_max_pdu;
uint16_t s_max_pdu;
uint8_t c_bn;
uint8_t p_bn;
uint8_t c_ft;
uint8_t p_ft;
uint16_t c_max_pdu;
uint16_t p_max_pdu;
uint16_t interval;
} __packed;
@ -2632,11 +2634,11 @@ struct bt_hci_evt_le_biginfo_adv_report {
#define BT_EVT_MASK_TRIGG_CLOCK_CAPTURE BT_EVT_BIT(14)
#define BT_EVT_MASK_SYNCH_TRAIN_COMPLETE BT_EVT_BIT(15)
#define BT_EVT_MASK_SYNCH_TRAIN_RX BT_EVT_BIT(16)
#define BT_EVT_MASK_CL_SLAVE_BC_RX BT_EVT_BIT(17)
#define BT_EVT_MASK_CL_SLAVE_BC_TIMEOUT BT_EVT_BIT(18)
#define BT_EVT_MASK_CL_PER_BC_RX BT_EVT_BIT(17)
#define BT_EVT_MASK_CL_PER_BC_TIMEOUT BT_EVT_BIT(18)
#define BT_EVT_MASK_TRUNC_PAGE_COMPLETE BT_EVT_BIT(19)
#define BT_EVT_MASK_SLAVE_PAGE_RSP_TIMEOUT BT_EVT_BIT(20)
#define BT_EVT_MASK_CL_SLAVE_BC_CH_MAP_CHANGE BT_EVT_BIT(21)
#define BT_EVT_MASK_PER_PAGE_RSP_TIMEOUT BT_EVT_BIT(20)
#define BT_EVT_MASK_CL_PER_BC_CH_MAP_CHANGE BT_EVT_BIT(21)
#define BT_EVT_MASK_INQUIRY_RSP_NOT BT_EVT_BIT(22)
#define BT_EVT_MASK_AUTH_PAYLOAD_TIMEOUT_EXP BT_EVT_BIT(23)
#define BT_EVT_MASK_SAM_STATUS_CHANGE BT_EVT_BIT(24)

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

@ -1232,12 +1232,12 @@ static void le_set_random_address(struct net_buf *buf, struct net_buf **evt)
#if defined(CONFIG_BT_CTLR_FILTER)
static void le_read_wl_size(struct net_buf *buf, struct net_buf **evt)
{
struct bt_hci_rp_le_read_wl_size *rp;
struct bt_hci_rp_le_read_fal_size *rp;
rp = hci_cmd_complete(evt, sizeof(*rp));
rp->status = 0x00;
rp->wl_size = ll_wl_size_get();
rp->fal_size = ll_wl_size_get();
}
static void le_clear_wl(struct net_buf *buf, struct net_buf **evt)
@ -1251,7 +1251,7 @@ static void le_clear_wl(struct net_buf *buf, struct net_buf **evt)
static void le_add_dev_to_wl(struct net_buf *buf, struct net_buf **evt)
{
struct bt_hci_cp_le_add_dev_to_wl *cmd = (void *)buf->data;
struct bt_hci_cp_le_add_dev_to_fal *cmd = (void *)buf->data;
uint8_t status;
status = ll_wl_add(&cmd->addr);
@ -1261,7 +1261,7 @@ static void le_add_dev_to_wl(struct net_buf *buf, struct net_buf **evt)
static void le_rem_dev_from_wl(struct net_buf *buf, struct net_buf **evt)
{
struct bt_hci_cp_le_rem_dev_from_wl *cmd = (void *)buf->data;
struct bt_hci_cp_le_rem_dev_from_fal *cmd = (void *)buf->data;
uint8_t status;
status = ll_wl_remove(&cmd->addr);
@ -1769,22 +1769,22 @@ static void le_set_cig_parameters(struct net_buf *buf, struct net_buf **evt)
{
struct bt_hci_cp_le_set_cig_params *cmd = (void *)buf->data;
struct bt_hci_rp_le_set_cig_params *rp;
uint32_t m_interval;
uint32_t s_interval;
uint16_t m_latency;
uint16_t s_latency;
uint32_t c_interval;
uint32_t p_interval;
uint16_t c_latency;
uint16_t p_latency;
uint8_t status;
uint8_t i;
m_interval = sys_get_le24(cmd->m_interval);
s_interval = sys_get_le24(cmd->s_interval);
m_latency = sys_le16_to_cpu(cmd->m_latency);
s_latency = sys_le16_to_cpu(cmd->s_latency);
c_interval = sys_get_le24(cmd->c_interval);
p_interval = sys_get_le24(cmd->p_interval);
c_latency = sys_le16_to_cpu(cmd->c_latency);
p_latency = sys_le16_to_cpu(cmd->p_latency);
/* Create CIG or start modifying existing CIG */
status = ll_cig_parameters_open(cmd->cig_id, m_interval, s_interval,
status = ll_cig_parameters_open(cmd->cig_id, c_interval, p_interval,
cmd->sca, cmd->packing, cmd->framing,
m_latency, s_latency, cmd->num_cis);
c_latency, p_latency, cmd->num_cis);
rp = hci_cmd_complete(evt, sizeof(*rp) +
cmd->num_cis * sizeof(uint16_t));
@ -1795,15 +1795,15 @@ static void le_set_cig_parameters(struct net_buf *buf, struct net_buf **evt)
for (i = 0; !status && i < cmd->num_cis; i++) {
struct bt_hci_cis_params *params = cmd->cis;
uint16_t handle;
uint16_t m_sdu;
uint16_t s_sdu;
uint16_t c_sdu;
uint16_t p_sdu;
m_sdu = sys_le16_to_cpu(params->m_sdu);
s_sdu = sys_le16_to_cpu(params->s_sdu);
c_sdu = sys_le16_to_cpu(params->c_sdu);
p_sdu = sys_le16_to_cpu(params->p_sdu);
status = ll_cis_parameters_set(params->cis_id, m_sdu, s_sdu,
params->m_phy, params->s_phy,
params->m_rtn, params->s_rtn,
status = ll_cis_parameters_set(params->cis_id, c_sdu, p_sdu,
params->c_phy, params->p_phy,
params->c_rtn, params->p_rtn,
&handle);
rp->handle[i] = sys_cpu_to_le16(handle);
}
@ -1821,20 +1821,20 @@ static void le_set_cig_params_test(struct net_buf *buf, struct net_buf **evt)
struct bt_hci_cp_le_set_cig_params_test *cmd = (void *)buf->data;
struct bt_hci_rp_le_set_cig_params_test *rp;
uint32_t m_interval;
uint32_t s_interval;
uint32_t c_interval;
uint32_t p_interval;
uint16_t iso_interval;
uint8_t status;
uint8_t i;
m_interval = sys_get_le24(cmd->m_interval);
s_interval = sys_get_le24(cmd->s_interval);
c_interval = sys_get_le24(cmd->c_interval);
p_interval = sys_get_le24(cmd->p_interval);
iso_interval = sys_le16_to_cpu(cmd->iso_interval);
/* Create CIG or start modifying existing CIG */
status = ll_cig_parameters_test_open(cmd->cig_id, m_interval,
s_interval, cmd->m_ft,
cmd->s_ft, iso_interval,
status = ll_cig_parameters_test_open(cmd->cig_id, c_interval,
p_interval, cmd->c_ft,
cmd->p_ft, iso_interval,
cmd->sca, cmd->packing,
cmd->framing,
cmd->num_cis);
@ -1848,23 +1848,23 @@ static void le_set_cig_params_test(struct net_buf *buf, struct net_buf **evt)
for (i = 0; !status && i < cmd->num_cis; i++) {
struct bt_hci_cis_params_test *params = cmd->cis;
uint16_t handle;
uint16_t m_sdu;
uint16_t s_sdu;
uint16_t m_pdu;
uint16_t s_pdu;
uint16_t c_sdu;
uint16_t p_sdu;
uint16_t c_pdu;
uint16_t p_pdu;
m_sdu = sys_le16_to_cpu(params->m_sdu);
s_sdu = sys_le16_to_cpu(params->s_sdu);
m_pdu = sys_le16_to_cpu(params->m_pdu);
s_pdu = sys_le16_to_cpu(params->s_pdu);
c_sdu = sys_le16_to_cpu(params->c_sdu);
p_sdu = sys_le16_to_cpu(params->p_sdu);
c_pdu = sys_le16_to_cpu(params->c_pdu);
p_pdu = sys_le16_to_cpu(params->p_pdu);
status = ll_cis_parameters_test_set(params->cis_id,
m_sdu, s_sdu,
m_pdu, s_pdu,
params->m_phy,
params->s_phy,
params->m_bn,
params->s_bn,
c_sdu, p_sdu,
c_pdu, p_pdu,
params->c_phy,
params->p_phy,
params->c_bn,
params->p_bn,
&handle);
rp->handle[i] = sys_cpu_to_le16(handle);
}
@ -3507,17 +3507,17 @@ static void le_cis_established(struct pdu_data *pdu_data,
sep->conn_handle = sys_cpu_to_le16(est->cis_handle);
sys_put_le24(cig->sync_delay, sep->cig_sync_delay);
sys_put_le24(cis->sync_delay, sep->cis_sync_delay);
sys_put_le24(cig->c_latency, sep->m_latency);
sys_put_le24(cig->p_latency, sep->s_latency);
sep->m_phy = lll_cis_c->phy;
sep->s_phy = lll_cis_p->phy;
sys_put_le24(cig->c_latency, sep->c_latency);
sys_put_le24(cig->p_latency, sep->p_latency);
sep->c_phy = lll_cis_c->phy;
sep->p_phy = lll_cis_p->phy;
sep->nse = lll_cis->num_subevents;
sep->m_bn = lll_cis_c->burst_number;
sep->s_bn = lll_cis_p->burst_number;
sep->m_ft = lll_cis_c->flush_timeout;
sep->s_ft = lll_cis_p->flush_timeout;
sep->m_max_pdu = sys_cpu_to_le16(lll_cis_c->max_octets);
sep->s_max_pdu = sys_cpu_to_le16(lll_cis_p->max_octets);
sep->c_bn = lll_cis_c->burst_number;
sep->p_bn = lll_cis_p->burst_number;
sep->c_ft = lll_cis_c->flush_timeout;
sep->p_ft = lll_cis_p->flush_timeout;
sep->c_max_pdu = sys_cpu_to_le16(lll_cis_c->max_octets);
sep->p_max_pdu = sys_cpu_to_le16(lll_cis_p->max_octets);
sep->interval = sys_cpu_to_le16(cig->iso_interval);
#if defined(CONFIG_BT_CTLR_CENTRAL_ISO)
@ -3555,19 +3555,19 @@ static int controller_cmd_handle(uint16_t ocf, struct net_buf *cmd,
break;
#if defined(CONFIG_BT_CTLR_FILTER)
case BT_OCF(BT_HCI_OP_LE_READ_WL_SIZE):
case BT_OCF(BT_HCI_OP_LE_READ_FAL_SIZE):
le_read_wl_size(cmd, evt);
break;
case BT_OCF(BT_HCI_OP_LE_CLEAR_WL):
case BT_OCF(BT_HCI_OP_LE_CLEAR_FAL):
le_clear_wl(cmd, evt);
break;
case BT_OCF(BT_HCI_OP_LE_ADD_DEV_TO_WL):
case BT_OCF(BT_HCI_OP_LE_ADD_DEV_TO_FAL):
le_add_dev_to_wl(cmd, evt);
break;
case BT_OCF(BT_HCI_OP_LE_REM_DEV_FROM_WL):
case BT_OCF(BT_HCI_OP_LE_REM_DEV_FROM_FAL):
le_rem_dev_from_wl(cmd, evt);
break;
#endif /* CONFIG_BT_CTLR_FILTER */

6
subsys/bluetooth/controller/include/ll_feat.h
View file

@ -26,7 +26,7 @@
#endif /* !CONFIG_BT_CTLR_EXT_REJ_IND */
#if defined(CONFIG_BT_CTLR_SLAVE_FEAT_REQ)
#define LL_FEAT_BIT_SLAVE_FEAT_REQ BIT64(BT_LE_FEAT_BIT_SLAVE_FEAT_REQ)
#define LL_FEAT_BIT_SLAVE_FEAT_REQ BIT64(BT_LE_FEAT_BIT_PER_INIT_FEAT_XCHG)
#else /* !CONFIG_BT_CTLR_SLAVE_FEAT_REQ */
#define LL_FEAT_BIT_SLAVE_FEAT_REQ 0
#endif /* !CONFIG_BT_CTLR_SLAVE_FEAT_REQ */
@ -162,13 +162,13 @@
#endif /* !CONFIG_BT_CTLR_DF && !CONFIG_BT_CTLR_DF_CTE_RX */
#if defined(CONFIG_BT_CTLR_CENTRAL_ISO)
#define LL_FEAT_BIT_CIS_CENTRAL BIT64(BT_LE_FEAT_BIT_CIS_MASTER)
#define LL_FEAT_BIT_CIS_CENTRAL BIT64(BT_LE_FEAT_BIT_CIS_CENTRAL)
#else /* !CONFIG_BT_CTLR_CENTRAL_ISO */
#define LL_FEAT_BIT_CIS_CENTRAL 0
#endif /* !CONFIG_BT_CTLR_CENTRAL_ISO */
#if defined(CONFIG_BT_CTLR_PERIPHERAL_ISO)
#define LL_FEAT_BIT_CIS_PERIPHERAL BIT64(BT_LE_FEAT_BIT_CIS_SLAVE)
#define LL_FEAT_BIT_CIS_PERIPHERAL BIT64(BT_LE_FEAT_BIT_CIS_PERIPHERAL)
#else /* !CONFIG_BT_CTLR_PERIPHERAL_ISO */
#define LL_FEAT_BIT_CIS_PERIPHERAL 0
#endif /* !CONFIG_BT_CTLR_PERIPHERAL_ISO */

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

@ -2772,7 +2772,7 @@ static void init_set(struct ll_adv_set *adv)
adv->own_addr_type = BT_ADDR_LE_PUBLIC;
#endif /* CONFIG_BT_CTLR_PRIVACY */
adv->lll.chan_map = BT_LE_ADV_CHAN_MAP_ALL;
adv->lll.filter_policy = BT_LE_ADV_FP_NO_WHITELIST;
adv->lll.filter_policy = BT_LE_ADV_FP_NO_FILTER;
#if defined(CONFIG_BT_CTLR_JIT_SCHEDULING)
adv->delay_remain = ULL_ADV_RANDOM_DELAY;
#endif /* ONFIG_BT_CTLR_JIT_SCHEDULING */

10
subsys/bluetooth/host/adv.c
View file

@ -695,16 +695,16 @@ int bt_le_adv_update_data(const struct bt_data *ad, size_t ad_len,
static uint8_t get_filter_policy(uint32_t options)
{
if (!IS_ENABLED(CONFIG_BT_FILTER_ACCEPT_LIST)) {
return BT_LE_ADV_FP_NO_WHITELIST;
return BT_LE_ADV_FP_NO_FILTER;
} else if ((options & BT_LE_ADV_OPT_FILTER_SCAN_REQ) &&
(options & BT_LE_ADV_OPT_FILTER_CONN)) {
return BT_LE_ADV_FP_WHITELIST_BOTH;
return BT_LE_ADV_FP_FILTER_BOTH;
} else if (options & BT_LE_ADV_OPT_FILTER_SCAN_REQ) {
return BT_LE_ADV_FP_WHITELIST_SCAN_REQ;
return BT_LE_ADV_FP_FILTER_SCAN_REQ;
} else if (options & BT_LE_ADV_OPT_FILTER_CONN) {
return BT_LE_ADV_FP_WHITELIST_CONN_IND;
return BT_LE_ADV_FP_FILTER_CONN_IND;
} else {
return BT_LE_ADV_FP_NO_WHITELIST;
return BT_LE_ADV_FP_NO_FILTER;
}
}

6
subsys/bluetooth/host/br.c
View file

@ -89,7 +89,7 @@ static int accept_conn(const bt_addr_t *bdaddr)
cp = net_buf_add(buf, sizeof(*cp));
bt_addr_copy(&cp->bdaddr, bdaddr);
cp->role = BT_HCI_ROLE_SLAVE;
cp->role = BT_HCI_ROLE_PERIPHERAL;
err = bt_hci_cmd_send_sync(BT_HCI_OP_ACCEPT_CONN_REQ, buf, NULL);
if (err) {
@ -117,7 +117,7 @@ static void bt_esco_conn_req(struct bt_hci_evt_conn_request *evt)
return;
}
sco_conn->role = BT_HCI_ROLE_SLAVE;
sco_conn->role = BT_HCI_ROLE_PERIPHERAL;
bt_conn_set_state(sco_conn, BT_CONN_CONNECT);
bt_conn_unref(sco_conn);
}
@ -142,7 +142,7 @@ void bt_hci_conn_req(struct net_buf *buf)
}
accept_conn(&evt->bdaddr);
conn->role = BT_HCI_ROLE_SLAVE;
conn->role = BT_HCI_ROLE_PERIPHERAL;
bt_conn_set_state(conn, BT_CONN_CONNECT);
bt_conn_unref(conn);
}

8
subsys/bluetooth/host/conn.c
View file

@ -1443,7 +1443,7 @@ static int send_conn_le_param_update(struct bt_conn *conn,
if ((BT_FEAT_LE_CONN_PARAM_REQ_PROC(bt_dev.le.features) &&
BT_FEAT_LE_CONN_PARAM_REQ_PROC(conn->le.features) &&
!atomic_test_bit(conn->flags, BT_CONN_SLAVE_PARAM_L2CAP)) ||
(conn->role == BT_HCI_ROLE_MASTER)) {
(conn->role == BT_HCI_ROLE_CENTRAL)) {
int rc;
rc = bt_conn_le_conn_update(conn, param);
@ -1840,7 +1840,7 @@ void bt_conn_identity_resolved(struct bt_conn *conn)
const bt_addr_le_t *rpa;
struct bt_conn_cb *cb;
if (conn->role == BT_HCI_ROLE_MASTER) {
if (conn->role == BT_HCI_ROLE_CENTRAL) {
rpa = &conn->le.resp_addr;
} else {
rpa = &conn->le.init_addr;
@ -2099,7 +2099,7 @@ bool bt_conn_is_peer_addr_le(const struct bt_conn *conn, uint8_t id,
}
/* Check against initial connection address */
if (conn->role == BT_HCI_ROLE_MASTER) {
if (conn->role == BT_HCI_ROLE_CENTRAL) {
return bt_addr_le_cmp(peer, &conn->le.resp_addr) == 0;
}
@ -2181,7 +2181,7 @@ int bt_conn_get_info(const struct bt_conn *conn, struct bt_conn_info *info)
case BT_CONN_TYPE_LE:
info->le.dst = &conn->le.dst;
info->le.src = &bt_dev.id_addr[conn->id];
if (conn->role == BT_HCI_ROLE_MASTER) {
if (conn->role == BT_HCI_ROLE_CENTRAL) {
info->le.local = &conn->le.init_addr;
info->le.remote = &conn->le.resp_addr;
} else {

2
subsys/bluetooth/host/gatt.c
View file

@ -4877,7 +4877,7 @@ void bt_gatt_connected(struct bt_conn *conn)
* enabling encryption will fail.
*/
if (IS_ENABLED(CONFIG_BT_SMP) &&
(conn->role == BT_HCI_ROLE_MASTER ||
(conn->role == BT_HCI_ROLE_CENTRAL ||
IS_ENABLED(CONFIG_BT_GATT_AUTO_SEC_REQ)) &&
bt_conn_get_security(conn) < data.sec) {
int err = bt_conn_set_security(conn, data.sec);

54
subsys/bluetooth/host/hci_core.c
View file

@ -523,7 +523,7 @@ int bt_le_create_conn_ext(const struct bt_conn *conn)
if (use_filter) {
/* User Initiated procedure use fast scan parameters. */
bt_addr_le_copy(&cp->peer_addr, BT_ADDR_LE_ANY);
cp->filter_policy = BT_HCI_LE_CREATE_CONN_FP_WHITELIST;
cp->filter_policy = BT_HCI_LE_CREATE_CONN_FP_FILTER;
} else {
const bt_addr_le_t *peer_addr = &conn->le.dst;
@ -535,7 +535,7 @@ int bt_le_create_conn_ext(const struct bt_conn *conn)
}
#endif
bt_addr_le_copy(&cp->peer_addr, peer_addr);
cp->filter_policy = BT_HCI_LE_CREATE_CONN_FP_DIRECT;
cp->filter_policy = BT_HCI_LE_CREATE_CONN_FP_NO_FILTER;
}
cp->own_addr_type = own_addr_type;
@ -597,7 +597,7 @@ int bt_le_create_conn_legacy(const struct bt_conn *conn)
if (use_filter) {
/* User Initiated procedure use fast scan parameters. */
bt_addr_le_copy(&cp->peer_addr, BT_ADDR_LE_ANY);
cp->filter_policy = BT_HCI_LE_CREATE_CONN_FP_WHITELIST;
cp->filter_policy = BT_HCI_LE_CREATE_CONN_FP_FILTER;
} else {
const bt_addr_le_t *peer_addr = &conn->le.dst;
@ -609,7 +609,7 @@ int bt_le_create_conn_legacy(const struct bt_conn *conn)
}
#endif
bt_addr_le_copy(&cp->peer_addr, peer_addr);
cp->filter_policy = BT_HCI_LE_CREATE_CONN_FP_DIRECT;
cp->filter_policy = BT_HCI_LE_CREATE_CONN_FP_NO_FILTER;
}
cp->scan_interval = sys_cpu_to_le16(bt_dev.create_param.interval);
@ -897,7 +897,7 @@ static struct bt_conn *find_pending_connect(uint8_t role, bt_addr_le_t *peer_add
* Make lookup to check if there's a connection object in
* CONNECT or CONNECT_AUTO state associated with passed peer LE address.
*/
if (IS_ENABLED(CONFIG_BT_CENTRAL) && role == BT_HCI_ROLE_MASTER) {
if (IS_ENABLED(CONFIG_BT_CENTRAL) && role == BT_HCI_ROLE_CENTRAL) {
conn = bt_conn_lookup_state_le(BT_ID_DEFAULT, peer_addr,
BT_CONN_CONNECT);
if (IS_ENABLED(CONFIG_BT_FILTER_ACCEPT_LIST) && !conn) {
@ -909,7 +909,7 @@ static struct bt_conn *find_pending_connect(uint8_t role, bt_addr_le_t *peer_add
return conn;
}
if (IS_ENABLED(CONFIG_BT_PERIPHERAL) && role == BT_HCI_ROLE_SLAVE) {
if (IS_ENABLED(CONFIG_BT_PERIPHERAL) && role == BT_HCI_ROLE_PERIPHERAL) {
conn = bt_conn_lookup_state_le(bt_dev.adv_conn_id, peer_addr,
BT_CONN_CONNECT_DIR_ADV);
if (!conn) {
@ -937,8 +937,8 @@ static void conn_auto_initiate(struct bt_conn *conn)
}
if (!atomic_test_bit(conn->flags, BT_CONN_AUTO_FEATURE_EXCH) &&
((conn->role == BT_HCI_ROLE_MASTER) ||
BT_FEAT_LE_SLAVE_FEATURE_XCHG(bt_dev.le.features))) {
((conn->role == BT_HCI_ROLE_CENTRAL) ||
BT_FEAT_LE_PER_INIT_FEAT_XCHG(bt_dev.le.features))) {
err = hci_le_read_remote_features(conn);
if (!err) {
return;
@ -997,7 +997,7 @@ static void le_conn_complete_cancel(void)
* There is no need to check ID address as only one
* connection in master role can be in pending state.
*/
conn = find_pending_connect(BT_HCI_ROLE_MASTER, NULL);
conn = find_pending_connect(BT_HCI_ROLE_CENTRAL, NULL);
if (!conn) {
BT_ERR("No pending master connection");
return;
@ -1054,7 +1054,7 @@ static void le_conn_complete_adv_timeout(void)
/* There is no need to check ID address as only one
* connection in slave role can be in pending state.
*/
conn = find_pending_connect(BT_HCI_ROLE_SLAVE, NULL);
conn = find_pending_connect(BT_HCI_ROLE_PERIPHERAL, NULL);
if (!conn) {
BT_ERR("No pending slave connection");
return;
@ -1071,7 +1071,7 @@ static void enh_conn_complete(struct bt_hci_evt_le_enh_conn_complete *evt)
{
#if (CONFIG_BT_ID_MAX > 1) && (CONFIG_BT_EXT_ADV_MAX_ADV_SET > 1)
if (IS_ENABLED(CONFIG_BT_PERIPHERAL) &&
evt->role == BT_HCI_ROLE_SLAVE &&
evt->role == BT_HCI_ROLE_PERIPHERAL &&
evt->status == BT_HCI_ERR_SUCCESS &&
(IS_ENABLED(CONFIG_BT_EXT_ADV) &&
BT_FEAT_LE_EXT_ADV(bt_dev.le.features))) {
@ -1142,7 +1142,7 @@ void bt_hci_le_enh_conn_complete(struct bt_hci_evt_le_enh_conn_complete *evt)
bt_addr_copy(&peer_addr.a, &evt->peer_rpa);
peer_addr.type = BT_ADDR_LE_RANDOM;
} else {
uint8_t id = evt->role == BT_HCI_ROLE_SLAVE ? bt_dev.adv_conn_id :
uint8_t id = evt->role == BT_HCI_ROLE_PERIPHERAL ? bt_dev.adv_conn_id :
BT_ID_DEFAULT;
bt_addr_le_copy(&id_addr,
@ -1153,7 +1153,7 @@ void bt_hci_le_enh_conn_complete(struct bt_hci_evt_le_enh_conn_complete *evt)
conn = find_pending_connect(evt->role, &id_addr);
if (IS_ENABLED(CONFIG_BT_PERIPHERAL) &&
evt->role == BT_HCI_ROLE_SLAVE &&
evt->role == BT_HCI_ROLE_PERIPHERAL &&
!(IS_ENABLED(CONFIG_BT_EXT_ADV) &&
BT_DEV_FEAT_LE_EXT_ADV(bt_dev.le.features))) {
struct bt_le_ext_adv *adv = bt_le_adv_lookup_legacy();
@ -1165,7 +1165,7 @@ void bt_hci_le_enh_conn_complete(struct bt_hci_evt_le_enh_conn_complete *evt)
}
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
evt->role == BT_HCI_ROLE_MASTER) {
evt->role == BT_HCI_ROLE_CENTRAL) {
/* Clear initiating even if we are not able to add connection
* object to keep the host in sync with controller state.
*/
@ -1204,7 +1204,7 @@ void bt_hci_le_enh_conn_complete(struct bt_hci_evt_le_enh_conn_complete *evt)
* was set during outgoing connection creation.
*/
if (IS_ENABLED(CONFIG_BT_PERIPHERAL) &&
conn->role == BT_HCI_ROLE_SLAVE) {
conn->role == BT_HCI_ROLE_PERIPHERAL) {
bt_addr_le_copy(&conn->le.init_addr, &peer_addr);
if (!(IS_ENABLED(CONFIG_BT_EXT_ADV) &&
@ -1238,7 +1238,7 @@ void bt_hci_le_enh_conn_complete(struct bt_hci_evt_le_enh_conn_complete *evt)
* check for connectable advertising state is sufficient as
* this is how this le connection complete for slave occurred.
*/
if (BT_LE_STATES_SLAVE_CONN_ADV(bt_dev.le.states)) {
if (BT_LE_STATES_PER_CONN_ADV(bt_dev.le.states)) {
bt_le_adv_resume();
}
@ -1255,7 +1255,7 @@ void bt_hci_le_enh_conn_complete(struct bt_hci_evt_le_enh_conn_complete *evt)
}
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
conn->role == BT_HCI_ROLE_MASTER) {
conn->role == BT_HCI_ROLE_CENTRAL) {
bt_addr_le_copy(&conn->le.resp_addr, &peer_addr);
if (IS_ENABLED(CONFIG_BT_PRIVACY)) {
@ -1311,7 +1311,7 @@ void bt_hci_le_enh_conn_complete(struct bt_hci_evt_le_enh_conn_complete *evt)
bt_conn_unref(conn);
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
conn->role == BT_HCI_ROLE_MASTER) {
conn->role == BT_HCI_ROLE_CENTRAL) {
bt_le_scan_update(false);
}
}
@ -1566,7 +1566,7 @@ static void le_conn_update_complete(struct net_buf *buf)
conn->le.timeout = sys_le16_to_cpu(evt->supv_timeout);
notify_le_param_updated(conn);
} else if (evt->status == BT_HCI_ERR_UNSUPP_REMOTE_FEATURE &&
conn->role == BT_HCI_ROLE_SLAVE &&
conn->role == BT_HCI_ROLE_PERIPHERAL &&
!atomic_test_and_set_bit(conn->flags,
BT_CONN_SLAVE_PARAM_L2CAP)) {
/* CPR not supported, let's try L2CAP CPUP instead */
@ -2758,7 +2758,7 @@ static int le_set_event_mask(void)
if (IS_ENABLED(CONFIG_BT_ISO) &&
BT_FEAT_LE_CIS(bt_dev.le.features)) {
mask |= BT_EVT_MASK_LE_CIS_ESTABLISHED;
if (BT_FEAT_LE_CIS_SLAVE(bt_dev.le.features)) {
if (BT_FEAT_LE_CIS_PERIPHERAL(bt_dev.le.features)) {
mask |= BT_EVT_MASK_LE_CIS_REQ;
}
}
@ -3663,7 +3663,7 @@ bool bt_addr_le_is_bonded(uint8_t id, const bt_addr_le_t *addr)
#if defined(CONFIG_BT_FILTER_ACCEPT_LIST)
int bt_le_filter_accept_list_add(const bt_addr_le_t *addr)
{
struct bt_hci_cp_le_add_dev_to_wl *cp;
struct bt_hci_cp_le_add_dev_to_fal *cp;
struct net_buf *buf;
int err;
@ -3671,7 +3671,7 @@ int bt_le_filter_accept_list_add(const bt_addr_le_t *addr)
return -EAGAIN;
}
buf = bt_hci_cmd_create(BT_HCI_OP_LE_ADD_DEV_TO_WL, sizeof(*cp));
buf = bt_hci_cmd_create(BT_HCI_OP_LE_ADD_DEV_TO_FAL, sizeof(*cp));
if (!buf) {
return -ENOBUFS;
}
@ -3679,7 +3679,7 @@ int bt_le_filter_accept_list_add(const bt_addr_le_t *addr)
cp = net_buf_add(buf, sizeof(*cp));
bt_addr_le_copy(&cp->addr, addr);
err = bt_hci_cmd_send_sync(BT_HCI_OP_LE_ADD_DEV_TO_WL, buf, NULL);
err = bt_hci_cmd_send_sync(BT_HCI_OP_LE_ADD_DEV_TO_FAL, buf, NULL);
if (err) {
BT_ERR("Failed to add device to whitelist");
@ -3691,7 +3691,7 @@ int bt_le_filter_accept_list_add(const bt_addr_le_t *addr)
int bt_le_filter_accept_list_remove(const bt_addr_le_t *addr)
{
struct bt_hci_cp_le_rem_dev_from_wl *cp;
struct bt_hci_cp_le_rem_dev_from_fal *cp;
struct net_buf *buf;
int err;
@ -3699,7 +3699,7 @@ int bt_le_filter_accept_list_remove(const bt_addr_le_t *addr)
return -EAGAIN;
}
buf = bt_hci_cmd_create(BT_HCI_OP_LE_REM_DEV_FROM_WL, sizeof(*cp));
buf = bt_hci_cmd_create(BT_HCI_OP_LE_REM_DEV_FROM_FAL, sizeof(*cp));
if (!buf) {
return -ENOBUFS;
}
@ -3707,7 +3707,7 @@ int bt_le_filter_accept_list_remove(const bt_addr_le_t *addr)
cp = net_buf_add(buf, sizeof(*cp));
bt_addr_le_copy(&cp->addr, addr);
err = bt_hci_cmd_send_sync(BT_HCI_OP_LE_REM_DEV_FROM_WL, buf, NULL);
err = bt_hci_cmd_send_sync(BT_HCI_OP_LE_REM_DEV_FROM_FAL, buf, NULL);
if (err) {
BT_ERR("Failed to remove device from whitelist");
return err;
@ -3724,7 +3724,7 @@ int bt_le_filter_accept_list_clear(void)
return -EAGAIN;
}
err = bt_hci_cmd_send_sync(BT_HCI_OP_LE_CLEAR_WL, NULL, NULL);
err = bt_hci_cmd_send_sync(BT_HCI_OP_LE_CLEAR_FAL, NULL, NULL);
if (err) {
BT_ERR("Failed to clear whitelist");
return err;

32
subsys/bluetooth/host/iso.c
View file

@ -407,7 +407,7 @@ static void bt_iso_chan_disconnected(struct bt_iso_chan *chan, uint8_t reason)
if (IS_ENABLED(CONFIG_BT_ISO_UNICAST) && !chan->iso->iso.is_bis) {
bt_iso_cleanup_acl(chan->iso);
if (chan->iso->role == BT_HCI_ROLE_SLAVE) {
if (chan->iso->role == BT_HCI_ROLE_PERIPHERAL) {
bt_conn_unref(chan->iso);
chan->iso = NULL;
} else {
@ -856,7 +856,7 @@ void hci_le_cis_req(struct net_buf *buf)
}
iso->handle = cis_handle;
iso->role = BT_HCI_ROLE_SLAVE;
iso->role = BT_HCI_ROLE_PERIPHERAL;
bt_conn_set_state(iso, BT_CONN_CONNECT);
err = hci_le_accept_cis(cis_handle);
@ -921,10 +921,10 @@ static struct net_buf *hci_le_set_cig_params(const struct bt_iso_cig *cig,
memset(req, 0, sizeof(*req));
req->cig_id = cig->id;
req->m_latency = sys_cpu_to_le16(param->latency);
req->s_latency = sys_cpu_to_le16(param->latency);
sys_put_le24(param->interval, req->m_interval);
sys_put_le24(param->interval, req->s_interval);
req->c_latency = sys_cpu_to_le16(param->latency);
req->p_latency = sys_cpu_to_le16(param->latency);
sys_put_le24(param->interval, req->c_interval);
sys_put_le24(param->interval, req->p_interval);
req->sca = param->sca;
req->packing = param->packing;
@ -952,22 +952,22 @@ static struct net_buf *hci_le_set_cig_params(const struct bt_iso_cig *cig,
/* Use RX PHY if TX is not set (disabled)
* to avoid setting invalid values
*/
cis_param->m_phy = qos->rx->phy;
cis_param->c_phy = qos->rx->phy;
} else {
cis_param->m_sdu = sys_cpu_to_le16(qos->tx->sdu);
cis_param->m_phy = qos->tx->phy;
cis_param->m_rtn = qos->tx->rtn;
cis_param->c_sdu = sys_cpu_to_le16(qos->tx->sdu);
cis_param->c_phy = qos->tx->phy;
cis_param->c_rtn = qos->tx->rtn;
}
if (!qos->rx) {
/* Use TX PHY if RX is not set (disabled)
* to avoid setting invalid values
*/
cis_param->s_phy = qos->tx->phy;
cis_param->p_phy = qos->tx->phy;
} else {
cis_param->s_sdu = sys_cpu_to_le16(qos->rx->sdu);
cis_param->s_phy = qos->rx->phy;
cis_param->s_rtn = qos->rx->rtn;
cis_param->p_sdu = sys_cpu_to_le16(qos->rx->sdu);
cis_param->p_phy = qos->rx->phy;
cis_param->p_rtn = qos->rx->rtn;
}
}
@ -1062,7 +1062,7 @@ int bt_iso_cig_create(const struct bt_iso_cig_create_param *param,
*out_cig = NULL;
/* Check if controller is ISO capable as a central */
if (!BT_FEAT_LE_CIS_MASTER(bt_dev.le.features)) {
if (!BT_FEAT_LE_CIS_CENTRAL(bt_dev.le.features)) {
return -ENOTSUP;
}
@ -1346,7 +1346,7 @@ int bt_iso_server_register(struct bt_iso_server *server)
}
/* Check if controller is ISO capable */
if (!BT_FEAT_LE_CIS_SLAVE(bt_dev.le.features)) {
if (!BT_FEAT_LE_CIS_PERIPHERAL(bt_dev.le.features)) {
return -ENOTSUP;
}

2
subsys/bluetooth/host/l2cap.c
View file

@ -661,7 +661,7 @@ static void le_conn_param_update_req(struct bt_l2cap *l2cap, uint8_t ident,
return;
}
if (conn->role != BT_HCI_ROLE_MASTER) {
if (conn->role != BT_HCI_ROLE_CENTRAL) {
l2cap_send_reject(conn, ident, BT_L2CAP_REJ_NOT_UNDERSTOOD,
NULL, 0);
return;

8
subsys/bluetooth/host/scan.c
View file

@ -162,9 +162,9 @@ static int start_le_scan_ext(struct bt_hci_ext_scan_phy *phy_1m,
if (IS_ENABLED(CONFIG_BT_FILTER_ACCEPT_LIST) &&
atomic_test_bit(bt_dev.flags, BT_DEV_SCAN_WL)) {
set_param->filter_policy = BT_HCI_LE_SCAN_FP_USE_WHITELIST;
set_param->filter_policy = BT_HCI_LE_SCAN_FP_BASIC_FILTER;
} else {
set_param->filter_policy = BT_HCI_LE_SCAN_FP_NO_WHITELIST;
set_param->filter_policy = BT_HCI_LE_SCAN_FP_BASIC_NO_FILTER;
}
if (phy_1m) {
@ -211,9 +211,9 @@ static int start_le_scan_legacy(uint8_t scan_type, uint16_t interval, uint16_t w
if (IS_ENABLED(CONFIG_BT_FILTER_ACCEPT_LIST) &&
atomic_test_bit(bt_dev.flags, BT_DEV_SCAN_WL)) {
set_param.filter_policy = BT_HCI_LE_SCAN_FP_USE_WHITELIST;
set_param.filter_policy = BT_HCI_LE_SCAN_FP_BASIC_FILTER;
} else {
set_param.filter_policy = BT_HCI_LE_SCAN_FP_NO_WHITELIST;
set_param.filter_policy = BT_HCI_LE_SCAN_FP_BASIC_NO_FILTER;
}
active_scan = scan_type == BT_HCI_LE_SCAN_ACTIVE;

48
subsys/bluetooth/host/smp.c
View file

@ -1811,7 +1811,7 @@ static void smp_reset(struct bt_smp *smp)
atomic_set(smp->allowed_cmds, 0);
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
conn->role == BT_HCI_ROLE_MASTER) {
conn->role == BT_HCI_ROLE_CENTRAL) {
atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_SECURITY_REQUEST);
return;
}
@ -2324,7 +2324,7 @@ static uint8_t legacy_get_pair_method(struct bt_smp *smp, uint8_t remote_io)
* and responder inputs
*/
if (method == PASSKEY_ROLE) {
if (smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
if (smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
method = PASSKEY_DISPLAY;
} else {
method = PASSKEY_INPUT;
@ -2480,7 +2480,7 @@ static uint8_t legacy_pairing_random(struct bt_smp *smp)
}
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
conn->role == BT_HCI_ROLE_MASTER) {
conn->role == BT_HCI_ROLE_CENTRAL) {
uint8_t ediv[2], rand[8];
/* No need to store master STK */
@ -2539,7 +2539,7 @@ static uint8_t legacy_pairing_confirm(struct bt_smp *smp)
BT_DBG("");
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_CONFIRM);
return legacy_send_pairing_confirm(smp);
}
@ -2570,7 +2570,7 @@ static void legacy_user_tk_entry(struct bt_smp *smp)
}
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_CONFIRM);
return;
}
@ -2643,7 +2643,7 @@ static uint8_t smp_master_ident(struct bt_smp *smp, struct net_buf *buf)
}
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
conn->role == BT_HCI_ROLE_MASTER && !smp->remote_dist) {
conn->role == BT_HCI_ROLE_CENTRAL && !smp->remote_dist) {
err = bt_smp_distribute_keys(smp);
if (err) {
return err;
@ -3324,7 +3324,7 @@ static uint8_t smp_pairing_confirm(struct bt_smp *smp, struct net_buf *buf)
memcpy(smp->pcnf, req->val, sizeof(smp->pcnf));
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RANDOM);
return smp_send_pairing_random(smp);
}
@ -3540,7 +3540,7 @@ static uint8_t smp_dhkey_ready(struct bt_smp *smp, const uint8_t *dhkey)
if (atomic_test_bit(smp->flags, SMP_FLAG_DHKEY_SEND)) {
#if defined(CONFIG_BT_CENTRAL)
if (smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
if (smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
return compute_and_send_master_dhcheck(smp);
}
@ -3657,7 +3657,7 @@ static void le_sc_oob_config_set(struct bt_smp *smp,
int oob_config = BT_CONN_OOB_NO_DATA;
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
oob_config = req_oob_present ? BT_CONN_OOB_REMOTE_ONLY :
BT_CONN_OOB_NO_DATA;
@ -3697,7 +3697,7 @@ static uint8_t smp_pairing_random(struct bt_smp *smp, struct net_buf *buf)
#endif /* !CONFIG_BT_SMP_SC_PAIR_ONLY */
#if defined(CONFIG_BT_CENTRAL)
if (smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
if (smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
err = sc_smp_check_confirm(smp);
if (err) {
return err;
@ -3911,7 +3911,7 @@ static uint8_t smp_ident_addr_info(struct bt_smp *smp, struct net_buf *buf)
* are cleared on re-pairing we wouldn't store IRK distributed
* in new pairing.
*/
if (conn->role == BT_HCI_ROLE_MASTER) {
if (conn->role == BT_HCI_ROLE_CENTRAL) {
dst = &conn->le.resp_addr;
} else {
dst = &conn->le.init_addr;
@ -3945,7 +3945,7 @@ static uint8_t smp_ident_addr_info(struct bt_smp *smp, struct net_buf *buf)
}
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
conn->role == BT_HCI_ROLE_MASTER && !smp->remote_dist) {
conn->role == BT_HCI_ROLE_CENTRAL && !smp->remote_dist) {
err = bt_smp_distribute_keys(smp);
if (err) {
return err;
@ -3987,7 +3987,7 @@ static uint8_t smp_signing_info(struct bt_smp *smp, struct net_buf *buf)
smp->remote_dist &= ~BT_SMP_DIST_SIGN;
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
conn->role == BT_HCI_ROLE_MASTER && !smp->remote_dist) {
conn->role == BT_HCI_ROLE_CENTRAL && !smp->remote_dist) {
err = bt_smp_distribute_keys(smp);
if (err) {
return err;
@ -4237,7 +4237,7 @@ static uint8_t smp_public_key(struct bt_smp *smp, struct net_buf *buf)
}
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
if (!atomic_test_bit(smp->flags, SMP_FLAG_SC_DEBUG_KEY) &&
memcmp(smp->pkey, sc_public_key, BT_PUB_KEY_COORD_LEN) == 0) {
/* Deny public key with identitcal X coordinate unless
@ -4333,7 +4333,7 @@ static uint8_t smp_dhkey_check(struct bt_smp *smp, struct net_buf *buf)
BT_DBG("");
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
uint8_t e[16], r[16], enc_size;
uint8_t ediv[2], rand[8];
@ -4395,7 +4395,7 @@ static uint8_t smp_dhkey_check(struct bt_smp *smp, struct net_buf *buf)
}
#if defined(CONFIG_BT_PERIPHERAL)
if (smp->chan.chan.conn->role == BT_HCI_ROLE_SLAVE) {
if (smp->chan.chan.conn->role == BT_HCI_ROLE_PERIPHERAL) {
atomic_clear_bit(smp->flags, SMP_FLAG_DHCHECK_WAIT);
memcpy(smp->e, req->e, sizeof(smp->e));
@ -4539,7 +4539,7 @@ static void bt_smp_pkey_ready(const uint8_t *pkey)
}
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
err = sc_send_public_key(smp);
if (err) {
smp_error(smp, err);
@ -4687,7 +4687,7 @@ static void bt_smp_encrypt_change(struct bt_l2cap_chan *chan,
/* Slave distributes it's keys first */
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
conn->role == BT_HCI_ROLE_MASTER && smp->remote_dist) {
conn->role == BT_HCI_ROLE_CENTRAL && smp->remote_dist) {
return;
}
@ -5279,7 +5279,7 @@ int bt_smp_auth_passkey_entry(struct bt_conn *conn, unsigned int passkey)
smp->passkey = sys_cpu_to_le32(passkey);
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_CONFIRM);
err = smp_send_pairing_confirm(smp);
if (err) {
@ -5331,7 +5331,7 @@ int bt_smp_auth_passkey_confirm(struct bt_conn *conn)
uint8_t err;
#if defined(CONFIG_BT_CENTRAL)
if (smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
if (smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
err = compute_and_send_master_dhcheck(smp);
if (err) {
smp_error(smp, err);
@ -5428,7 +5428,7 @@ static bool le_sc_oob_data_check(struct bt_smp *smp, bool oobd_local_present,
bool rsp_oob_present = le_sc_oob_data_rsp_check(smp);
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
if ((req_oob_present != oobd_remote_present) &&
(rsp_oob_present != oobd_local_present)) {
return false;
@ -5463,7 +5463,7 @@ static int le_sc_oob_pairing_continue(struct bt_smp *smp)
}
if (IS_ENABLED(CONFIG_BT_CENTRAL) &&
smp->chan.chan.conn->role == BT_HCI_ROLE_MASTER) {
smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) {
atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RANDOM);
} else if (IS_ENABLED(CONFIG_BT_PERIPHERAL)) {
atomic_set_bit(smp->allowed_cmds, BT_SMP_DHKEY_CHECK);
@ -5633,7 +5633,7 @@ int bt_smp_start_security(struct bt_conn *conn)
{
switch (conn->role) {
#if defined(CONFIG_BT_CENTRAL)
case BT_HCI_ROLE_MASTER:
case BT_HCI_ROLE_CENTRAL:
{
int err;
struct bt_smp *smp;
@ -5673,7 +5673,7 @@ int bt_smp_start_security(struct bt_conn *conn)
}
#endif /* CONFIG_BT_CENTRAL && CONFIG_BT_SMP */
#if defined(CONFIG_BT_PERIPHERAL)
case BT_HCI_ROLE_SLAVE:
case BT_HCI_ROLE_PERIPHERAL:
return smp_send_security_req(conn);
#endif /* CONFIG_BT_PERIPHERAL && CONFIG_BT_SMP */
default: