michaelh/zephyr
1
0
Fork 0
Code Releases Activity

bluetooth: fixes shadow variables

Browse source 
Massaging code to fix shadow variables found by -Wshadow.

Signed-off-by: Daniel Leung <daniel.leung@intel.com>
This commit is contained in:
Daniel Leung 2023-08-09 12:55:53 -07:00 • committed by Carles Cufí
commit e3ecca5784
47 changed files with 729 additions and 765 deletions
Download patch file Download diff file Expand all files Collapse all files

12
drivers/bluetooth/hci/spi.c
View file

@ -152,14 +152,14 @@ static inline int bt_spi_transceive(void *tx, uint32_t tx_len,
return spi_transceive_dt(&bus, &spi_tx, &spi_rx);
}
static inline uint16_t bt_spi_get_cmd(uint8_t *txmsg)
static inline uint16_t bt_spi_get_cmd(uint8_t *msg)
{
return (txmsg[CMD_OCF] << 8) | txmsg[CMD_OGF];
return (msg[CMD_OCF] << 8) | msg[CMD_OGF];
}
static inline uint16_t bt_spi_get_evt(uint8_t *rxmsg)
static inline uint16_t bt_spi_get_evt(uint8_t *msg)
{
return (rxmsg[EVT_VENDOR_CODE_MSB] << 8) | rxmsg[EVT_VENDOR_CODE_LSB];
return (msg[EVT_VENDOR_CODE_MSB] << 8) | msg[EVT_VENDOR_CODE_LSB];
}
static void bt_to_inactive_isr(const struct device *unused1,
@ -187,11 +187,11 @@ static void bt_to_active_isr(const struct device *unused1,
k_sem_give(&sem_request);
}
static bool bt_spi_handle_vendor_evt(uint8_t *rxmsg)
static bool bt_spi_handle_vendor_evt(uint8_t *msg)
{
bool handled = false;
switch (bt_spi_get_evt(rxmsg)) {
switch (bt_spi_get_evt(msg)) {
case EVT_BLUE_INITIALIZED:
k_sem_give(&sem_initialised);
#if defined(CONFIG_BT_BLUENRG_ACI)

1
subsys/bluetooth/audio/ascs.c
View file

@ -151,7 +151,6 @@ static void ase_status_changed(struct bt_ascs_ase *ase, uint8_t state)
const uint8_t att_ntf_header_size = 3; /* opcode (1) + handle (2) */
const uint16_t max_ntf_size = bt_gatt_get_mtu(conn) - att_ntf_header_size;
uint16_t ntf_size;
int err;
err = k_sem_take(&ase_buf_sem, ASE_BUF_SEM_TIMEOUT);
if (err != 0) {

6
subsys/bluetooth/audio/bap_broadcast_source.c
View file

@ -759,9 +759,9 @@ int bt_bap_broadcast_source_create(struct bt_bap_broadcast_source_create_param *
stream_param->data,
stream_param->data_count * sizeof(*stream_param->data));
source->stream_data[stream_count].data_count = stream_param->data_count;
for (uint8_t i = 0U; i < stream_param->data_count; i++) {
source->stream_data[stream_count].data[i].data.data =
source->stream_data[stream_count].data[i].value;
for (uint8_t k = 0U; k < stream_param->data_count; k++) {
source->stream_data[stream_count].data[k].data.data =
source->stream_data[stream_count].data[k].value;
}
sys_slist_append(&subgroup->streams, &stream->_node);

12
subsys/bluetooth/audio/bap_scan_delegator.c
View file

@ -249,7 +249,7 @@ static void scan_delegator_security_changed(struct bt_conn *conn,
/* Notify all receive states after a bonded device reconnects */
for (int i = 0; i < ARRAY_SIZE(scan_delegator.recv_states); i++) {
struct bass_recv_state_internal *internal_state = &scan_delegator.recv_states[i];
int err;
int gatt_err;
if (!internal_state->active) {
continue;
@ -257,12 +257,12 @@ static void scan_delegator_security_changed(struct bt_conn *conn,
net_buf_put_recv_state(internal_state);
err = bt_gatt_notify_uuid(conn, BT_UUID_BASS_RECV_STATE,
internal_state->attr, read_buf.data,
read_buf.len);
if (err != 0) {
gatt_err = bt_gatt_notify_uuid(conn, BT_UUID_BASS_RECV_STATE,
internal_state->attr, read_buf.data,
read_buf.len);
if (gatt_err != 0) {
LOG_WRN("Could not notify receive state[%d] to reconnecting assistant: %d",
i, err);
i, gatt_err);
}
}
}

4
subsys/bluetooth/audio/mcc.c
View file

@ -135,7 +135,7 @@ struct mcs_instance_t {
#endif /* CONFIG_BT_MCC_OTS */
};
static struct mcs_instance_t mcs_inst;
static struct mcs_instance_t mcs_instance;
static struct bt_uuid_16 uuid = BT_UUID_INIT_16(0);
static struct bt_mcc_cb *mcc_cb;
@ -168,7 +168,7 @@ static struct mcs_instance_t *lookup_inst_by_conn(struct bt_conn *conn)
}
/* TODO: Expand when supporting more instances */
return &mcs_inst;
return &mcs_instance;
}
static void mcc_player_name_cb(struct bt_conn *conn, uint8_t err, const void *data, uint16_t length)

893
subsys/bluetooth/audio/mpl.c
View file

File diff suppressed because it is too large Load diff

10
subsys/bluetooth/audio/shell/bap.c
View file

@ -970,7 +970,7 @@ static int cmd_discover(const struct shell *sh, size_t argc, char *argv[])
}
if (!cbs_registered) {
int err = bt_bap_unicast_client_register_cb(&unicast_client_cbs);
err = bt_bap_unicast_client_register_cb(&unicast_client_cbs);
if (err != 0) {
shell_error(sh, "Failed to register unicast client callbacks: %d", err);
@ -1981,12 +1981,13 @@ static void stream_released_cb(struct bt_bap_stream *stream)
bool group_can_be_deleted = true;
for (size_t i = 0U; i < ARRAY_SIZE(unicast_streams); i++) {
const struct bt_bap_stream *stream = &unicast_streams[i].stream.bap_stream;
const struct bt_bap_stream *bap_stream =
&unicast_streams[i].stream.bap_stream;
if (stream->ep != NULL) {
if (bap_stream->ep != NULL) {
struct bt_bap_ep_info ep_info;
bt_bap_ep_get_info(stream->ep, &ep_info);
bt_bap_ep_get_info(bap_stream->ep, &ep_info);
if (ep_info.state != BT_BAP_EP_STATE_CODEC_CONFIGURED &&
ep_info.state != BT_BAP_EP_STATE_IDLE) {
@ -2285,7 +2286,6 @@ static int cmd_sync_broadcast(const struct shell *sh, size_t argc, char *argv[])
stream_cnt = 0U;
for (int i = 1; i < argc; i++) {
unsigned long val;
int err = 0;
val = shell_strtoul(argv[i], 0, &err);
if (err != 0) {

20
subsys/bluetooth/audio/shell/cap_initiator.c
View file

@ -234,17 +234,17 @@ static int cmd_cap_initiator_unicast_start(const struct shell *sh, size_t argc,
#if CONFIG_BT_BAP_UNICAST_CLIENT_ASE_SNK_COUNT > 0
conn_snk_cnt = sink_cnt;
for (size_t i = 0U; i < sink_cnt; i++) {
for (size_t j = 0U; j < sink_cnt; j++) {
struct bt_cap_stream *stream =
&unicast_streams[start_param.count].stream;
struct shell_stream *uni_stream =
CONTAINER_OF(stream, struct shell_stream, stream);
struct bt_bap_ep *snk_ep = snks[bt_conn_index(conn)][i];
struct bt_bap_ep *snk_ep = snks[bt_conn_index(conn)][j];
if (snk_ep == NULL) {
shell_info(sh, "Could only setup %zu/%zu sink endpoints",
i, sink_cnt);
conn_snk_cnt = i;
j, sink_cnt);
conn_snk_cnt = j;
break;
}
@ -259,7 +259,7 @@ static int cmd_cap_initiator_unicast_start(const struct shell *sh, size_t argc,
stream_param[start_param.count].qos;
group_stream_params[start_param.count].stream =
&stream_param[start_param.count].stream->bap_stream;
pair_params[pair_cnt + i].tx_param =
pair_params[pair_cnt + j].tx_param =
&group_stream_params[start_param.count];
start_param.count++;
@ -268,17 +268,17 @@ static int cmd_cap_initiator_unicast_start(const struct shell *sh, size_t argc,
#if CONFIG_BT_BAP_UNICAST_CLIENT_ASE_SRC_COUNT > 0
conn_src_cnt = source_cnt;
for (size_t i = 0U; i < source_cnt; i++) {
for (size_t j = 0U; j < source_cnt; j++) {
struct bt_cap_stream *stream =
&unicast_streams[start_param.count].stream;
struct shell_stream *uni_stream =
CONTAINER_OF(stream, struct shell_stream, stream);
struct bt_bap_ep *src_ep = srcs[bt_conn_index(conn)][i];
struct bt_bap_ep *src_ep = srcs[bt_conn_index(conn)][j];
if (src_ep == NULL) {
shell_info(sh, "Could only setup %zu/%zu source endpoints",
i, source_cnt);
conn_src_cnt = i;
j, source_cnt);
conn_src_cnt = j;
break;
}
@ -293,7 +293,7 @@ static int cmd_cap_initiator_unicast_start(const struct shell *sh, size_t argc,
stream_param[start_param.count].qos;
group_stream_params[start_param.count].stream =
&stream_param[start_param.count].stream->bap_stream;
pair_params[pair_cnt + i].rx_param =
pair_params[pair_cnt + j].rx_param =
&group_stream_params[start_param.count];
start_param.count++;

4
subsys/bluetooth/audio/shell/csip_set_member.c
View file

@ -24,7 +24,7 @@ struct bt_csip_set_member_svc_inst *svc_inst;
static uint8_t sirk_read_rsp = BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT;
static void locked_cb(struct bt_conn *conn,
struct bt_csip_set_member_svc_inst *svc_inst,
struct bt_csip_set_member_svc_inst *inst,
bool locked)
{
if (conn == NULL) {
@ -41,7 +41,7 @@ static void locked_cb(struct bt_conn *conn,
}
static uint8_t sirk_read_req_cb(struct bt_conn *conn,
struct bt_csip_set_member_svc_inst *svc_inst)
struct bt_csip_set_member_svc_inst *inst)
{
char addr[BT_ADDR_LE_STR_LEN];
static const char *const rsp_strings[] = {

36
subsys/bluetooth/audio/shell/micp_mic_ctlr.c
View file

@ -16,7 +16,7 @@
#include "shell/bt.h"
static struct bt_micp_mic_ctlr *mic_ctlr;
static struct bt_micp_mic_ctlr *micp_mic_ctlr;
#if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
static struct bt_micp_included micp_included;
#endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
@ -233,7 +233,7 @@ static int cmd_micp_mic_ctlr_discover(const struct shell *sh, size_t argc,
return -ENOTCONN;
}
result = bt_micp_mic_ctlr_discover(default_conn, &mic_ctlr);
result = bt_micp_mic_ctlr_discover(default_conn, &micp_mic_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}
@ -246,11 +246,11 @@ static int cmd_micp_mic_ctlr_mute_get(const struct shell *sh, size_t argc,
{
int result;
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
result = bt_micp_mic_ctlr_mute_get(mic_ctlr);
result = bt_micp_mic_ctlr_mute_get(micp_mic_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
@ -264,11 +264,11 @@ static int cmd_micp_mic_ctlr_mute(const struct shell *sh, size_t argc,
{
int result;
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
result = bt_micp_mic_ctlr_mute(mic_ctlr);
result = bt_micp_mic_ctlr_mute(micp_mic_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
@ -282,11 +282,11 @@ static int cmd_micp_mic_ctlr_unmute(const struct shell *sh, size_t argc,
{
int result;
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
result = bt_micp_mic_ctlr_unmute(mic_ctlr);
result = bt_micp_mic_ctlr_unmute(micp_mic_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
@ -316,7 +316,7 @@ static int cmd_micp_mic_ctlr_aics_input_state_get(const struct shell *sh,
return -ENOEXEC;
}
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
@ -348,7 +348,7 @@ static int cmd_micp_mic_ctlr_aics_gain_setting_get(const struct shell *sh,
return -ENOEXEC;
}
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
@ -380,7 +380,7 @@ static int cmd_micp_mic_ctlr_aics_input_type_get(const struct shell *sh,
return -ENOEXEC;
}
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
@ -412,7 +412,7 @@ static int cmd_micp_mic_ctlr_aics_input_status_get(const struct shell *sh,
return -ENOEXEC;
}
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
@ -472,7 +472,7 @@ static int cmd_micp_mic_ctlr_aics_input_mute(const struct shell *sh,
return -ENOEXEC;
}
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
@ -504,7 +504,7 @@ static int cmd_micp_mic_ctlr_aics_manual_input_gain_set(const struct shell *sh,
return -ENOEXEC;
}
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
@ -537,7 +537,7 @@ static int cmd_micp_mic_ctlr_aics_automatic_input_gain_set(const struct shell *s
return -ENOEXEC;
}
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
@ -584,7 +584,7 @@ static int cmd_micp_mic_ctlr_aics_gain_set(const struct shell *sh, size_t argc,
return -ENOEXEC;
}
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
@ -616,7 +616,7 @@ static int cmd_micp_mic_ctlr_aics_input_description_get(const struct shell *sh,
return -ENOEXEC;
}
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}
@ -648,7 +648,7 @@ static int cmd_micp_mic_ctlr_aics_input_description_set(const struct shell *sh,
return -ENOEXEC;
}
if (mic_ctlr == NULL) {
if (micp_mic_ctlr == NULL) {
return -ENOENT;
}

22
subsys/bluetooth/audio/shell/vcp_vol_ctlr.c
View file

@ -15,7 +15,7 @@
#include "shell/bt.h"
static struct bt_vcp_vol_ctlr *vol_ctlr;
static struct bt_vcp_vol_ctlr *vcp_vol_ctlr;
static struct bt_vcp_included vcp_included;
static void vcs_discover_cb(struct bt_vcp_vol_ctlr *vol_ctlr, int err,
@ -343,7 +343,7 @@ static int cmd_vcp_vol_ctlr_discover(const struct shell *sh, size_t argc,
return -ENOEXEC;
}
result = bt_vcp_vol_ctlr_discover(default_conn, &vol_ctlr);
result = bt_vcp_vol_ctlr_discover(default_conn, &vcp_vol_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}
@ -361,7 +361,7 @@ static int cmd_vcp_vol_ctlr_state_get(const struct shell *sh, size_t argc,
return -ENOEXEC;
}
result = bt_vcp_vol_ctlr_read_state(vol_ctlr);
result = bt_vcp_vol_ctlr_read_state(vcp_vol_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}
@ -379,7 +379,7 @@ static int cmd_vcp_vol_ctlr_flags_get(const struct shell *sh, size_t argc,
return -ENOEXEC;
}
result = bt_vcp_vol_ctlr_read_flags(vol_ctlr);
result = bt_vcp_vol_ctlr_read_flags(vcp_vol_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}
@ -397,7 +397,7 @@ static int cmd_vcp_vol_ctlr_volume_down(const struct shell *sh, size_t argc,
return -ENOEXEC;
}
result = bt_vcp_vol_ctlr_vol_down(vol_ctlr);
result = bt_vcp_vol_ctlr_vol_down(vcp_vol_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}
@ -416,7 +416,7 @@ static int cmd_vcp_vol_ctlr_volume_up(const struct shell *sh, size_t argc,
return -ENOEXEC;
}
result = bt_vcp_vol_ctlr_vol_up(vol_ctlr);
result = bt_vcp_vol_ctlr_vol_up(vcp_vol_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}
@ -434,7 +434,7 @@ static int cmd_vcp_vol_ctlr_unmute_volume_down(const struct shell *sh,
return -ENOEXEC;
}
result = bt_vcp_vol_ctlr_unmute_vol_down(vol_ctlr);
result = bt_vcp_vol_ctlr_unmute_vol_down(vcp_vol_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}
@ -452,7 +452,7 @@ static int cmd_vcp_vol_ctlr_unmute_volume_up(const struct shell *sh,
return -ENOEXEC;
}
result = bt_vcp_vol_ctlr_unmute_vol_up(vol_ctlr);
result = bt_vcp_vol_ctlr_unmute_vol_up(vcp_vol_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}
@ -485,7 +485,7 @@ static int cmd_vcp_vol_ctlr_volume_set(const struct shell *sh, size_t argc,
return -ENOEXEC;
}
result = bt_vcp_vol_ctlr_set_vol(vol_ctlr, volume);
result = bt_vcp_vol_ctlr_set_vol(vcp_vol_ctlr, volume);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}
@ -504,7 +504,7 @@ static int cmd_vcp_vol_ctlr_unmute(const struct shell *sh, size_t argc,
return -ENOEXEC;
}
result = bt_vcp_vol_ctlr_unmute(vol_ctlr);
result = bt_vcp_vol_ctlr_unmute(vcp_vol_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}
@ -522,7 +522,7 @@ static int cmd_vcp_vol_ctlr_mute(const struct shell *sh, size_t argc,
return -ENOEXEC;
}
result = bt_vcp_vol_ctlr_mute(vol_ctlr);
result = bt_vcp_vol_ctlr_mute(vcp_vol_ctlr);
if (result != 0) {
shell_print(sh, "Fail: %d", result);
}

2
subsys/bluetooth/audio/vcp_vol_ctlr.c
View file

@ -467,8 +467,6 @@ static uint8_t vcs_discover_func(struct bt_conn *conn,
}
if (sub_params != NULL) {
int err;
sub_params->value = BT_GATT_CCC_NOTIFY;
sub_params->value_handle = chrc->value_handle;
sub_params->ccc_handle = 0;

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

@ -2032,8 +2032,8 @@ static void le_set_cig_parameters(struct net_buf *buf, struct net_buf **evt)
status = ll_cig_parameters_commit(cig_id, handles);
if (status == BT_HCI_ERR_SUCCESS) {
for (uint8_t i = 0; i < cis_count; i++) {
rp->handle[i] = sys_cpu_to_le16(handles[i]);
for (uint8_t j = 0; j < cis_count; j++) {
rp->handle[j] = sys_cpu_to_le16(handles[j]);
}
}
}
@ -2104,8 +2104,8 @@ static void le_set_cig_params_test(struct net_buf *buf, struct net_buf **evt)
status = ll_cig_parameters_commit(cig_id, handles);
if (status == BT_HCI_ERR_SUCCESS) {
for (uint8_t i = 0; i < cis_count; i++) {
rp->handle[i] = sys_cpu_to_le16(handles[i]);
for (uint8_t j = 0; j < cis_count; j++) {
rp->handle[j] = sys_cpu_to_le16(handles[j]);
}
}
}

22
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_central_iso.c
View file

@ -577,7 +577,7 @@ static void isr_tx(void *param)
/* Schedule next subevent */
if (se_curr < cis_lll->nse) {
const struct lll_conn *conn_lll;
const struct lll_conn *evt_conn_lll;
uint16_t data_chan_id;
uint32_t subevent_us;
uint32_t start_us;
@ -590,13 +590,13 @@ static void isr_tx(void *param)
LL_ASSERT(start_us == (subevent_us + 1U));
/* Get reference to ACL context */
conn_lll = ull_conn_lll_get(cis_lll->acl_handle);
evt_conn_lll = ull_conn_lll_get(cis_lll->acl_handle);
/* Calculate the radio channel to use for next subevent */
data_chan_id = lll_chan_id(cis_lll->access_addr);
next_chan_use = lll_chan_iso_subevent(data_chan_id,
conn_lll->data_chan_map,
conn_lll->data_chan_count,
evt_conn_lll->data_chan_map,
evt_conn_lll->data_chan_count,
&data_chan_prn_s,
&data_chan_remap_idx);
} else {
@ -938,21 +938,21 @@ isr_rx_next_subevent:
bn = cis_lll->rx.bn_curr;
while (bn <= cis_lll->rx.bn) {
struct node_rx_iso_meta *iso_meta;
struct node_rx_pdu *node_rx;
struct node_rx_pdu *status_node_rx;
/* Ensure there is always one free for reception
* of ISO PDU by the radio h/w DMA, hence peek
* for two available ISO PDU when using one for
* generating invalid ISO data.
*/
node_rx = ull_iso_pdu_rx_alloc_peek(2U);
if (!node_rx) {
status_node_rx = ull_iso_pdu_rx_alloc_peek(2U);
if (!status_node_rx) {
break;
}
node_rx->hdr.type = NODE_RX_TYPE_ISO_PDU;
node_rx->hdr.handle = cis_lll->handle;
iso_meta = &node_rx->hdr.rx_iso_meta;
status_node_rx->hdr.type = NODE_RX_TYPE_ISO_PDU;
status_node_rx->hdr.handle = cis_lll->handle;
iso_meta = &status_node_rx->hdr.rx_iso_meta;
iso_meta->payload_number = (cis_lll->event_count *
cis_lll->rx.bn) + (bn - 1U);
iso_meta->timestamp =
@ -963,7 +963,7 @@ isr_rx_next_subevent:
iso_meta->status = 1U;
ull_iso_pdu_rx_alloc();
iso_rx_put(node_rx->hdr.link, node_rx);
iso_rx_put(status_node_rx->hdr.link, status_node_rx);
bn++;
}

4
subsys/bluetooth/controller/ll_sw/nordic/lll/lll_conn.c
View file

@ -814,12 +814,12 @@ void lll_conn_pdu_tx_prep(struct lll_conn *lll, struct pdu_data **pdu_data_tx)
}
#if defined(CONFIG_BT_CTLR_FORCE_MD_AUTO)
uint8_t lll_conn_force_md_cnt_set(uint8_t force_md_cnt)
uint8_t lll_conn_force_md_cnt_set(uint8_t reload_cnt)
{
uint8_t previous;
previous = force_md_cnt_reload;
force_md_cnt_reload = force_md_cnt;
force_md_cnt_reload = reload_cnt;
return previous;
}

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

@ -257,12 +257,12 @@ static int prepare_cb(struct lll_prepare_param *p)
#if defined(CONFIG_BT_CTLR_LE_ENC)
} else if (conn_lll->enc_rx) {
uint64_t payload_count;
uint64_t payload_cnt;
uint8_t pkt_flags;
payload_count = (cis_lll->event_count * cis_lll->rx.bn) +
(cis_lll->rx.bn_curr - 1U);
cis_lll->rx.ccm.counter = payload_count;
payload_cnt = (cis_lll->event_count * cis_lll->rx.bn) +
(cis_lll->rx.bn_curr - 1U);
cis_lll->rx.ccm.counter = payload_cnt;
pkt_flags = RADIO_PKT_CONF_FLAGS(RADIO_PKT_CONF_PDU_TYPE_DC,
phy,

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

@ -1083,18 +1083,18 @@ static void isr_done_cleanup(void *param)
}
if (lll->is_aux_sched) {
struct node_rx_pdu *node_rx;
struct node_rx_pdu *node_rx2;
lll->is_aux_sched = 0U;
node_rx = ull_pdu_rx_alloc();
LL_ASSERT(node_rx);
node_rx2 = ull_pdu_rx_alloc();
LL_ASSERT(node_rx2);
node_rx->hdr.type = NODE_RX_TYPE_EXT_AUX_RELEASE;
node_rx2->hdr.type = NODE_RX_TYPE_EXT_AUX_RELEASE;
node_rx->hdr.rx_ftr.param = lll;
node_rx2->hdr.rx_ftr.param = lll;
ull_rx_put_sched(node_rx->hdr.link, node_rx);
ull_rx_put_sched(node_rx2->hdr.link, node_rx2);
}
#endif /* CONFIG_BT_CTLR_ADV_EXT */

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

@ -846,12 +846,12 @@ isr_rx_do_close:
} else {
/* Send message to flush Auxiliary PDU list */
if (lll->is_aux_sched && err != -ECANCELED) {
struct node_rx_pdu *node_rx;
struct node_rx_pdu *node_rx2;
node_rx = ull_pdu_rx_alloc();
LL_ASSERT(node_rx);
node_rx2 = ull_pdu_rx_alloc();
LL_ASSERT(node_rx2);
node_rx->hdr.type = NODE_RX_TYPE_EXT_AUX_RELEASE;
node_rx2->hdr.type = NODE_RX_TYPE_EXT_AUX_RELEASE;
/* Use LLL scan context pointer which will be resolved
* to LLL aux context in the `ull_scan_aux_release`
@ -862,9 +862,9 @@ isr_rx_do_close:
* under race, if ULL execution did assign one, it will
* free it.
*/
node_rx->hdr.rx_ftr.param = lll;
node_rx2->hdr.rx_ftr.param = lll;
ull_rx_put_sched(node_rx->hdr.link, node_rx);
ull_rx_put_sched(node_rx2->hdr.link, node_rx2);
}
/* Check if LLL scheduled auxiliary PDU reception by scan
@ -902,7 +902,6 @@ static int isr_rx_pdu(struct lll_scan *lll, struct lll_scan_aux *lll_aux,
lll_scan_ext_tgta_check(lll, false, true, pdu,
rl_idx, NULL)) {
struct lll_scan_aux *lll_aux_to_use;
struct node_rx_ftr *ftr;
struct node_rx_pdu *rx;
struct pdu_adv *pdu_tx;
uint32_t conn_space_us;

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

@ -301,8 +301,6 @@ static int create_prepare_cb(struct lll_prepare_param *p)
if (false) {
#if defined(CONFIG_BT_CTLR_DF_SCAN_CTE_RX)
} else if (cfg->is_enabled) {
int err;
/* In case of call in create_prepare_cb, new sync event starts hence discard
* previous incomplete state.
*/
@ -312,8 +310,8 @@ static int create_prepare_cb(struct lll_prepare_param *p)
err = lll_df_iq_report_no_resources_prepare(lll);
if (!err) {
err = lll_df_conf_cte_rx_enable(cfg->slot_durations, cfg->ant_sw_len,
cfg->ant_ids, chan_idx, CTE_INFO_IN_PAYLOAD,
lll->phy);
cfg->ant_ids, chan_idx,
CTE_INFO_IN_PAYLOAD, lll->phy);
if (err) {
lll->is_cte_incomplete = true;
}
@ -388,8 +386,6 @@ static int prepare_cb(struct lll_prepare_param *p)
cfg = lll_df_sync_cfg_latest_get(&lll->df_cfg, NULL);
if (cfg->is_enabled) {
int err;
/* In case of call in prepare, new sync event starts hence discard previous
* incomplete state.
*/
@ -399,8 +395,8 @@ static int prepare_cb(struct lll_prepare_param *p)
err = lll_df_iq_report_no_resources_prepare(lll);
if (!err) {
err = lll_df_conf_cte_rx_enable(cfg->slot_durations, cfg->ant_sw_len,
cfg->ant_ids, chan_idx, CTE_INFO_IN_PAYLOAD,
lll->phy);
cfg->ant_ids, chan_idx,
CTE_INFO_IN_PAYLOAD, lll->phy);
if (err) {
lll->is_cte_incomplete = true;
}

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

@ -529,14 +529,14 @@ static void isr_rx(void *param)
/* Save the AA captured for the first anchor point sync */
if (!radio_tmr_aa_restore()) {
const struct lll_sync_iso_stream *stream;
const struct lll_sync_iso_stream *sync_stream;
uint32_t se_offset_us;
uint8_t se;
crc_ok_anchor = crc_ok;
stream = ull_sync_iso_lll_stream_get(lll->stream_handle[0]);
se = ((lll->bis_curr - stream->bis_index) *
sync_stream = ull_sync_iso_lll_stream_get(lll->stream_handle[0]);
se = ((lll->bis_curr - sync_stream->bis_index) *
((lll->bn * lll->irc) + lll->ptc)) +
((lll->irc_curr - 1U) * lll->bn) + (lll->bn_curr - 1U) +
lll->ptc_curr + lll->ctrl;
@ -553,7 +553,7 @@ static void isr_rx(void *param)
/* Check CRC and generate ISO Data PDU */
if (crc_ok) {
struct lll_sync_iso_stream *stream;
struct lll_sync_iso_stream *sync_stream;
uint16_t stream_handle;
struct pdu_bis *pdu;
@ -600,10 +600,10 @@ static void isr_rx(void *param)
}
stream_handle = lll->stream_handle[lll->stream_curr];
stream = ull_sync_iso_lll_stream_get(stream_handle);
sync_stream = ull_sync_iso_lll_stream_get(stream_handle);
/* store the received PDU */
if ((lll->bis_curr == stream->bis_index) && pdu->len &&
if ((lll->bis_curr == sync_stream->bis_index) && pdu->len &&
!lll->payload[bis_idx][payload_index] &&
((payload_index >= lll->payload_tail) ||
(payload_index < lll->payload_head))) {
@ -723,18 +723,18 @@ isr_rx_find_subevent:
/* Next BIS */
if (lll->bis_curr < lll->num_bis) {
const uint8_t stream_curr = lll->stream_curr + 1U;
struct lll_sync_iso_stream *stream;
struct lll_sync_iso_stream *sync_stream;
uint16_t stream_handle;
/* Next selected stream */
if (stream_curr < lll->stream_count) {
lll->stream_curr = stream_curr;
stream_handle = lll->stream_handle[lll->stream_curr];
stream = ull_sync_iso_lll_stream_get(stream_handle);
if (stream->bis_index <= lll->num_bis) {
sync_stream = ull_sync_iso_lll_stream_get(stream_handle);
if (sync_stream->bis_index <= lll->num_bis) {
uint8_t bis_idx_new;
lll->bis_curr = stream->bis_index;
lll->bis_curr = sync_stream->bis_index;
lll->ptc_curr = 0U;
lll->irc_curr = 1U;
lll->bn_curr = 1U;

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

@ -661,7 +661,7 @@ static void ticker_start_next_op_cb(uint32_t status, void *param)
LL_ASSERT(status == TICKER_STATUS_SUCCESS);
}
static uint32_t preempt_ticker_start(struct lll_event *event,
static uint32_t preempt_ticker_start(struct lll_event *evt,
ticker_op_func op_cb)
{
struct lll_prepare_param *p;
@ -671,7 +671,7 @@ static uint32_t preempt_ticker_start(struct lll_event *event,
uint32_t ret;
/* Calc the preempt timeout */
p = &event->prepare_param;
p = &evt->prepare_param;
ull = HDR_LLL2ULL(p->param);
preempt_anchor = p->ticks_at_expire;
preempt_to = MAX(ull->ticks_active_to_start,
@ -688,8 +688,8 @@ static uint32_t preempt_ticker_start(struct lll_event *event,
TICKER_NULL_REMAINDER,
TICKER_NULL_LAZY,
TICKER_NULL_SLOT,
preempt_ticker_cb, event,
op_cb, event);
preempt_ticker_cb, evt,
op_cb, evt);
return ret;
}

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

@ -1100,11 +1100,11 @@ void ll_rx_dequeue(void)
LL_ASSERT(!lll_conn->link_tx_free);
memq_link_t *link = memq_deinit(&lll_conn->memq_tx.head,
&lll_conn->memq_tx.tail);
LL_ASSERT(link);
memq_link_t *memq_link = memq_deinit(&lll_conn->memq_tx.head,
&lll_conn->memq_tx.tail);
LL_ASSERT(memq_link);
lll_conn->link_tx_free = link;
lll_conn->link_tx_free = memq_link;
struct ll_conn *conn = HDR_LLL2ULL(lll_conn);
@ -1144,17 +1144,17 @@ void ll_rx_dequeue(void)
if (cc->status == BT_HCI_ERR_ADV_TIMEOUT) {
struct lll_conn *conn_lll;
struct ll_conn *conn;
memq_link_t *link;
memq_link_t *memq_link;
conn_lll = lll->conn;
LL_ASSERT(conn_lll);
lll->conn = NULL;
LL_ASSERT(!conn_lll->link_tx_free);
link = memq_deinit(&conn_lll->memq_tx.head,
&conn_lll->memq_tx.tail);
LL_ASSERT(link);
conn_lll->link_tx_free = link;
memq_link = memq_deinit(&conn_lll->memq_tx.head,
&conn_lll->memq_tx.tail);
LL_ASSERT(memq_link);
conn_lll->link_tx_free = memq_link;
conn = HDR_LLL2ULL(conn_lll);
ll_conn_release(conn);

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

@ -1392,7 +1392,7 @@ uint8_t ll_adv_enable(uint8_t enable)
* started.
*/
if (sync) {
uint32_t ticks_slot_overhead;
uint32_t ticks_slot_overhead2;
uint32_t ticks_slot_aux;
#if defined(CONFIG_BT_CTLR_ADV_RESERVE_MAX)
@ -1436,10 +1436,10 @@ uint8_t ll_adv_enable(uint8_t enable)
#endif /* CONFIG_BT_CTLR_ADV_AUX_SYNC_OFFSET */
ticks_slot_overhead = ull_adv_sync_evt_init(adv, sync, NULL);
ticks_slot_overhead2 = ull_adv_sync_evt_init(adv, sync, NULL);
ret = ull_adv_sync_start(adv, sync,
ticks_anchor_sync,
ticks_slot_overhead);
ticks_slot_overhead2);
if (ret) {
goto failure_cleanup;
}

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

@ -582,7 +582,7 @@ uint8_t ll_adv_aux_ad_data_set(uint8_t handle, uint8_t op, uint8_t frag_pref,
if (adv->is_enabled) {
struct ll_adv_aux_set *aux;
struct pdu_adv *pdu;
struct pdu_adv *chan_res_pdu;
uint8_t tmp_idx;
aux = HDR_LLL2ULL(adv->lll.aux);
@ -634,8 +634,8 @@ uint8_t ll_adv_aux_ad_data_set(uint8_t handle, uint8_t op, uint8_t frag_pref,
}
/* Update primary channel reservation */
pdu = lll_adv_data_alloc(&adv->lll, &tmp_idx);
err = ull_adv_time_update(adv, pdu, NULL);
chan_res_pdu = lll_adv_data_alloc(&adv->lll, &tmp_idx);
err = ull_adv_time_update(adv, chan_res_pdu, NULL);
if (err) {
return err;
}
@ -3053,7 +3053,6 @@ void ull_adv_aux_lll_auxptr_fill(struct pdu_adv *pdu, struct lll_adv *adv)
offset_us = HAL_TICKER_TICKS_TO_US(lll_aux->ticks_pri_pdu_offset) +
lll_aux->us_pri_pdu_offset;
if ((offset_us/OFFS_UNIT_30_US)*OFFS_UNIT_30_US < EVENT_MAFS_US + pdu_us) {
struct ll_adv_aux_set *aux = HDR_LLL2ULL(lll_aux);
uint32_t interval_us;
/* Offset too small, point to next aux packet instead */

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

@ -1383,20 +1383,20 @@ static void tx_lll_flush(void *param)
struct lll_adv_iso_stream *stream;
struct node_tx_iso *tx;
uint16_t stream_handle;
memq_link_t *link;
memq_link_t *link2;
uint16_t handle;
stream_handle = lll->stream_handle[num_bis];
handle = LL_BIS_ADV_HANDLE_FROM_IDX(stream_handle);
stream = ull_adv_iso_stream_get(stream_handle);
link = memq_dequeue(stream->memq_tx.tail, &stream->memq_tx.head,
(void **)&tx);
while (link) {
tx->next = link;
link2 = memq_dequeue(stream->memq_tx.tail, &stream->memq_tx.head,
(void **)&tx);
while (link2) {
tx->next = link2;
ull_iso_lll_ack_enqueue(handle, tx);
link = memq_dequeue(stream->memq_tx.tail,
link2 = memq_dequeue(stream->memq_tx.tail,
&stream->memq_tx.head,
(void **)&tx);
}

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

@ -99,8 +99,6 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
}
if (IS_ENABLED(CONFIG_BT_CTLR_PARAM_CHECK)) {
uint8_t err;
err = adv_type_check(adv);
if (err) {
return err;
@ -112,7 +110,6 @@ uint8_t ll_adv_sync_param_set(uint8_t handle, uint16_t interval, uint16_t flags)
struct pdu_adv *ter_pdu;
struct lll_adv *lll;
uint8_t chm_last;
int err;
sync = sync_acquire();
if (!sync) {
@ -268,8 +265,6 @@ uint8_t ll_adv_sync_ad_data_set(uint8_t handle, uint8_t op, uint8_t len,
/* Check for advertising set type */
if (IS_ENABLED(CONFIG_BT_CTLR_PARAM_CHECK)) {
uint8_t err;
err = adv_type_check(adv);
if (err) {
return err;
@ -757,8 +752,6 @@ uint8_t ll_adv_sync_enable(uint8_t handle, uint8_t enable)
/* Check for advertising set type */
if (IS_ENABLED(CONFIG_BT_CTLR_PARAM_CHECK)) {
uint8_t err;
err = adv_type_check(adv);
if (err) {
return BT_HCI_ERR_CMD_DISALLOWED;

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

@ -1237,7 +1237,7 @@ void ull_conn_done(struct node_rx_event_done *done)
ticks_slot_plus || ticks_slot_minus ||
lazy || force) {
uint8_t ticker_id = TICKER_ID_CONN_BASE + lll->handle;
struct ll_conn *conn = lll->hdr.parent;
struct ll_conn *conn_ll = lll->hdr.parent;
uint32_t ticker_status;
/* Call to ticker_update can fail under the race
@ -1253,10 +1253,10 @@ void ull_conn_done(struct node_rx_event_done *done)
ticks_slot_plus, ticks_slot_minus,
lazy, force,
ticker_update_conn_op_cb,
conn);
conn_ll);
LL_ASSERT((ticker_status == TICKER_STATUS_SUCCESS) ||
(ticker_status == TICKER_STATUS_BUSY) ||
((void *)conn == ull_disable_mark_get()));
((void *)conn_ll == ull_disable_mark_get()));
}
}

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

@ -341,11 +341,11 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx)
}
if (IS_ENABLED(CONFIG_BT_CTLR_SYNC_PERIODIC) && sync_lll) {
struct ll_sync_set *sync;
struct ll_sync_set *sync_set;
sync = HDR_LLL2ULL(sync_lll);
ftr->aux_data_len = sync->data_len + data_len;
sync->data_len = 0U;
sync_set = HDR_LLL2ULL(sync_lll);
ftr->aux_data_len = sync_set->data_len + data_len;
sync_set->data_len = 0U;
} else if (aux) {
aux->data_len += data_len;
ftr->aux_data_len = aux->data_len;
@ -469,11 +469,11 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx)
(!IS_ENABLED(CONFIG_BT_CTLR_PHY_CODED) &&
PDU_ADV_AUX_PTR_PHY_GET(aux_ptr) == EXT_ADV_AUX_PHY_LE_CODED)) {
if (IS_ENABLED(CONFIG_BT_CTLR_SYNC_PERIODIC) && sync_lll) {
struct ll_sync_set *sync;
struct ll_sync_set *sync_set;
sync = HDR_LLL2ULL(sync_lll);
ftr->aux_data_len = sync->data_len + data_len;
sync->data_len = 0U;
sync_set = HDR_LLL2ULL(sync_lll);
ftr->aux_data_len = sync_set->data_len + data_len;
sync_set->data_len = 0U;
} else if (aux) {
aux->data_len += data_len;
ftr->aux_data_len = aux->data_len;
@ -509,11 +509,11 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx)
if (IS_ENABLED(CONFIG_BT_CTLR_SYNC_PERIODIC) &&
sync_lll) {
struct ll_sync_set *sync;
struct ll_sync_set *sync_set;
sync = HDR_LLL2ULL(sync_lll);
ftr->aux_data_len = sync->data_len + data_len;
sync->data_len = 0U;
sync_set = HDR_LLL2ULL(sync_lll);
ftr->aux_data_len = sync_set->data_len + data_len;
sync_set->data_len = 0U;
}
@ -547,11 +547,11 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx)
* enqueue rx in aux context and will flush them after scan is complete.
*/
if (IS_ENABLED(CONFIG_BT_CTLR_SYNC_PERIODIC) && sync_lll) {
struct ll_sync_set *sync;
struct ll_sync_set *sync_set;
sync = HDR_LLL2ULL(sync_lll);
sync->data_len += data_len;
ftr->aux_data_len = sync->data_len;
sync_set = HDR_LLL2ULL(sync_lll);
sync_set->data_len += data_len;
ftr->aux_data_len = sync_set->data_len;
} else {
if (aux->rx_last) {
aux->rx_last->rx_ftr.extra = rx;
@ -607,14 +607,14 @@ void ull_scan_aux_setup(memq_link_t *link, struct node_rx_hdr *rx)
*/
lll->lll_aux = NULL;
} else {
struct ll_sync_set *sync;
struct ll_sync_set *sync_set;
LL_ASSERT(sync_lll &&
(!sync_lll->lll_aux || sync_lll->lll_aux == lll_aux));
/* Do not ULL schedule if sync terminate requested */
sync = HDR_LLL2ULL(sync_lll);
if (unlikely(sync->is_stop)) {
sync_set = HDR_LLL2ULL(sync_lll);
if (unlikely(sync_set->is_stop)) {
goto ull_scan_aux_rx_flush;
}
@ -758,14 +758,14 @@ ull_scan_aux_rx_flush:
aux->rx_last->rx_ftr.extra = rx;
aux->rx_last = rx;
} else {
const struct ll_sync_set *sync;
const struct ll_sync_set *sync_set;
LL_ASSERT(sync_lll);
ll_rx_put_sched(link, rx);
sync = HDR_LLL2ULL(sync_lll);
if (unlikely(sync->is_stop && sync_lll->lll_aux)) {
sync_set = HDR_LLL2ULL(sync_lll);
if (unlikely(sync_set->is_stop && sync_lll->lll_aux)) {
return;
}
}
@ -853,12 +853,12 @@ void *ull_scan_aux_lll_parent_get(struct lll_scan_aux *lll,
if (is_lll_scan) {
struct ll_scan_set *scan;
struct lll_scan *lll;
struct lll_scan *lllscan;
lll = aux->parent;
LL_ASSERT(lll);
lllscan = aux->parent;
LL_ASSERT(lllscan);
scan = HDR_LLL2ULL(lll);
scan = HDR_LLL2ULL(lllscan);
*is_lll_scan = !!ull_scan_is_valid_get(scan);
}

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

@ -68,7 +68,7 @@ typedef struct ull_hdr *(*ull_hdr_get_func)(uint8_t ticker_id,
uint32_t *ticks_slot);
static uint8_t after_match_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
ticker_op_match_func ticker_match_op_cb,
ull_hdr_get_func ull_hdr_get_cb,
ull_hdr_get_func ull_hdr_get_cb_fn,
uint32_t *ticks_anchor,
uint32_t *ticks_to_expire_match,
uint32_t *remainder_match,
@ -413,7 +413,7 @@ static int group_free_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
static uint8_t after_match_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
ticker_op_match_func ticker_match_op_cb,
ull_hdr_get_func ull_hdr_get_cb,
ull_hdr_get_func ull_hdr_get_cb_fn,
uint32_t *ticks_anchor,
uint32_t *ticks_to_expire_match,
uint32_t *remainder_match,
@ -518,7 +518,7 @@ static uint8_t after_match_slot_get(uint8_t user_id, uint32_t ticks_slot_abs,
}
#endif /* CONFIG_BT_TICKER_NEXT_SLOT_GET_MATCH */
hdr = ull_hdr_get_cb(ticker_id, &ticks_slot);
hdr = ull_hdr_get_cb_fn(ticker_id, &ticks_slot);
if (!hdr) {
continue;
}

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

@ -609,7 +609,6 @@ static int hci_set_adv_ext_fragmented(struct bt_le_ext_adv *adv, uint16_t hci_op
struct net_buf *buf;
const size_t data_len = MIN(BT_HCI_LE_EXT_ADV_FRAG_MAX_LEN, stream.remaining_size);
const size_t cmd_size = sizeof(*set_data) + data_len;
int err;
buf = bt_hci_cmd_create(hci_op, cmd_size);
if (!buf) {
@ -717,7 +716,6 @@ static int hci_set_per_adv_data(const struct bt_le_ext_adv *adv,
struct net_buf *buf;
const size_t data_len = MIN(BT_HCI_LE_PER_ADV_FRAG_MAX_LEN, stream.remaining_size);
const size_t cmd_size = sizeof(*set_data) + data_len;
int err;
buf = bt_hci_cmd_create(BT_HCI_OP_LE_SET_PER_ADV_DATA, cmd_size);
if (!buf) {

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

@ -303,8 +303,6 @@ static int chan_send(struct bt_att_chan *chan, struct net_buf *buf)
}
if (hdr->code == BT_ATT_OP_SIGNED_WRITE_CMD) {
int err;
err = bt_smp_sign(chan->att->conn, buf);
if (err) {
LOG_ERR("Error signing data");

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

@ -598,11 +598,11 @@ void bt_hci_remote_name_request_complete(struct net_buf *buf)
check_names:
/* if still waiting for names */
for (i = 0; i < discovery_results_count; i++) {
struct discovery_priv *priv;
struct discovery_priv *dpriv;
priv = (struct discovery_priv *)&discovery_results[i]._priv;
dpriv = (struct discovery_priv *)&discovery_results[i]._priv;
if (priv->resolving) {
if (dpriv->resolving) {
return;
}
}

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

@ -1522,9 +1522,7 @@ int bt_conn_disconnect(struct bt_conn *conn, uint8_t reason)
static void notify_connected(struct bt_conn *conn)
{
struct bt_conn_cb *cb;
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (cb->connected) {
cb->connected(conn, conn->err);
}
@ -1539,9 +1537,7 @@ static void notify_connected(struct bt_conn *conn)
static void notify_disconnected(struct bt_conn *conn)
{
struct bt_conn_cb *cb;
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (cb->disconnected) {
cb->disconnected(conn, conn->err);
}
@ -1558,7 +1554,6 @@ static void notify_disconnected(struct bt_conn *conn)
void notify_remote_info(struct bt_conn *conn)
{
struct bt_conn_remote_info remote_info;
struct bt_conn_cb *cb;
int err;
err = bt_conn_get_remote_info(conn, &remote_info);
@ -1567,7 +1562,7 @@ void notify_remote_info(struct bt_conn *conn)
return;
}
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (cb->remote_info_available) {
cb->remote_info_available(conn, &remote_info);
}
@ -1583,8 +1578,6 @@ void notify_remote_info(struct bt_conn *conn)
void notify_le_param_updated(struct bt_conn *conn)
{
struct bt_conn_cb *cb;
/* If new connection parameters meet requirement of pending
* parameters don't send peripheral conn param request anymore on timeout
*/
@ -1596,7 +1589,7 @@ void notify_le_param_updated(struct bt_conn *conn)
atomic_clear_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_SET);
}
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (cb->le_param_updated) {
cb->le_param_updated(conn, conn->le.interval,
conn->le.latency,
@ -1616,9 +1609,7 @@ void notify_le_param_updated(struct bt_conn *conn)
#if defined(CONFIG_BT_USER_DATA_LEN_UPDATE)
void notify_le_data_len_updated(struct bt_conn *conn)
{
struct bt_conn_cb *cb;
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (cb->le_data_len_updated) {
cb->le_data_len_updated(conn, &conn->le.data_len);
}
@ -1635,9 +1626,7 @@ void notify_le_data_len_updated(struct bt_conn *conn)
#if defined(CONFIG_BT_USER_PHY_UPDATE)
void notify_le_phy_updated(struct bt_conn *conn)
{
struct bt_conn_cb *cb;
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (cb->le_phy_updated) {
cb->le_phy_updated(conn, &conn->le.phy);
}
@ -1653,13 +1642,11 @@ void notify_le_phy_updated(struct bt_conn *conn)
bool le_param_req(struct bt_conn *conn, struct bt_le_conn_param *param)
{
struct bt_conn_cb *cb;
if (!bt_le_conn_params_valid(param)) {
return false;
}
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (!cb->le_param_req) {
continue;
}
@ -2149,7 +2136,6 @@ bool bt_conn_ltk_present(const struct bt_conn *conn)
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_CENTRAL) {
rpa = &conn->le.resp_addr;
@ -2157,7 +2143,7 @@ void bt_conn_identity_resolved(struct bt_conn *conn)
rpa = &conn->le.init_addr;
}
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (cb->identity_resolved) {
cb->identity_resolved(conn, rpa, &conn->le.dst);
}
@ -2261,15 +2247,13 @@ static void reset_pairing(struct bt_conn *conn)
void bt_conn_security_changed(struct bt_conn *conn, uint8_t hci_err,
enum bt_security_err err)
{
struct bt_conn_cb *cb;
reset_pairing(conn);
bt_l2cap_security_changed(conn, hci_err);
if (IS_ENABLED(CONFIG_BT_ISO_CENTRAL)) {
bt_iso_security_changed(conn, hci_err);
}
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (cb->security_changed) {
cb->security_changed(conn, conn->sec_level, err);
}
@ -3366,7 +3350,6 @@ void bt_hci_le_df_connection_iq_report_common(uint8_t event, struct net_buf *buf
{
struct bt_df_conn_iq_samples_report iq_report;
struct bt_conn *conn;
struct bt_conn_cb *cb;
int err;
if (event == BT_HCI_EVT_LE_CONNECTION_IQ_REPORT) {
@ -3387,7 +3370,7 @@ void bt_hci_le_df_connection_iq_report_common(uint8_t event, struct net_buf *buf
return;
}
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (cb->cte_report_cb) {
cb->cte_report_cb(conn, &iq_report);
}
@ -3421,7 +3404,6 @@ void bt_hci_le_df_cte_req_failed(struct net_buf *buf)
{
struct bt_df_conn_iq_samples_report iq_report;
struct bt_conn *conn;
struct bt_conn_cb *cb;
int err;
err = hci_df_prepare_conn_cte_req_failed(buf, &iq_report, &conn);
@ -3430,7 +3412,7 @@ void bt_hci_le_df_cte_req_failed(struct net_buf *buf)
return;
}
for (cb = callback_list; cb; cb = cb->_next) {
for (struct bt_conn_cb *cb = callback_list; cb; cb = cb->_next) {
if (cb->cte_report_cb) {
cb->cte_report_cb(conn, &iq_report);
}

4
subsys/bluetooth/host/ecc.c
View file

@ -34,9 +34,9 @@ static const uint8_t debug_public_key[BT_PUB_KEY_LEN] = {
0x6d, 0xeb, 0x2a, 0x65, 0x49, 0x9c, 0x80, 0xdc
};
bool bt_pub_key_is_debug(uint8_t *pub_key)
bool bt_pub_key_is_debug(uint8_t *cmp_pub_key)
{
return memcmp(pub_key, debug_public_key, BT_PUB_KEY_LEN) == 0;
return memcmp(cmp_pub_key, debug_public_key, BT_PUB_KEY_LEN) == 0;
}
int bt_pub_key_gen(struct bt_pub_key_cb *new_cb)

4
subsys/bluetooth/host/ecc.h
View file

@ -38,11 +38,11 @@ struct bt_pub_key_cb {
* Compare the Public key to the Bluetooth specification defined debug public
* key.
*
* @param pub_key The public key to compare.
* @param cmp_pub_key The public key to compare.
*
* @return True if the public key is the debug public key.
*/
bool bt_pub_key_is_debug(uint8_t *pub_key);
bool bt_pub_key_is_debug(uint8_t *cmp_pub_key);
/* @brief Generate a new Public Key.
*

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

@ -3190,10 +3190,10 @@ static void sc_restore_rsp(struct bt_conn *conn,
#endif /* CONFIG_BT_GATT_CACHING */
if (!err && IS_ENABLED(CONFIG_BT_GATT_SERVICE_CHANGED)) {
struct gatt_sc_cfg *sc_cfg = find_sc_cfg(conn->id, &conn->le.dst);
struct gatt_sc_cfg *gsc_cfg = find_sc_cfg(conn->id, &conn->le.dst);
if (sc_cfg) {
sc_reset(sc_cfg);
if (gsc_cfg) {
sc_reset(gsc_cfg);
}
}
}

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

@ -378,7 +378,6 @@ void bt_iso_connected(struct bt_conn *iso)
} else if (iso->iso.info.type == BT_ISO_CHAN_TYPE_BROADCASTER ||
iso->iso.info.type == BT_ISO_CHAN_TYPE_SYNC_RECEIVER) {
struct bt_iso_big *big;
int err;
big = lookup_big_by_handle(iso->iso.big_handle);
@ -2031,13 +2030,13 @@ int bt_iso_cig_reconfigure(struct bt_iso_cig *cig,
return -EINVAL;
}
for (uint8_t i = 0; i < param->num_cis; i++) {
struct bt_iso_chan *cis = param->cis_channels[i];
for (uint8_t j = 0; j < param->num_cis; j++) {
struct bt_iso_chan *param_cis = param->cis_channels[j];
if (cis->iso != NULL && !cis_is_in_cig(cig, cis)) {
if (param_cis->iso != NULL && !cis_is_in_cig(cig, param_cis)) {
LOG_DBG("Cannot reconfigure other CIG's (id 0x%02X) CIS "
"with this CIG (id 0x%02X)",
cis->iso->iso.cig_id, cig->id);
param_cis->iso->iso.cig_id, cig->id);
return -EINVAL;
}
}
@ -3175,24 +3174,24 @@ int bt_iso_big_sync(struct bt_le_per_adv_sync *sync, struct bt_iso_big_sync_para
}
for (uint8_t i = 0; i < param->num_bis; i++) {
struct bt_iso_chan *bis = param->bis_channels[i];
struct bt_iso_chan *param_bis = param->bis_channels[i];
CHECKIF(bis == NULL) {
CHECKIF(param_bis == NULL) {
LOG_DBG("bis_channels[%u]: NULL channel", i);
return -EINVAL;
}
if (bis->iso) {
if (param_bis->iso) {
LOG_DBG("bis_channels[%u]: already allocated", i);
return -EALREADY;
}
CHECKIF(bis->qos == NULL) {
CHECKIF(param_bis->qos == NULL) {
LOG_DBG("bis_channels[%u]: qos is NULL", i);
return -EINVAL;
}
CHECKIF(bis->qos->rx == NULL) {
CHECKIF(param_bis->qos->rx == NULL) {
LOG_DBG("bis_channels[%u]: qos->rx is NULL", i);
return -EINVAL;
}

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

@ -4894,14 +4894,14 @@ static const uint8_t M[] = {
0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
};
static int aes_test(const char *prefix, const uint8_t *key, const uint8_t *m,
static int aes_test(const char *prefix, const uint8_t *in_key, const uint8_t *m,
uint16_t len, const uint8_t *mac)
{
uint8_t out[16];
LOG_DBG("%s: AES CMAC of message with len %u", prefix, len);
bt_crypto_aes_cmac(key, m, len, out);
bt_crypto_aes_cmac(in_key, m, len, out);
if (!memcmp(out, mac, 16)) {
LOG_DBG("%s: Success", prefix);
} else {
@ -4955,7 +4955,7 @@ static int smp_aes_cmac_test(void)
return 0;
}
static int sign_test(const char *prefix, const uint8_t *key, const uint8_t *m,
static int sign_test(const char *prefix, const uint8_t *sign_key, const uint8_t *m,
uint16_t len, const uint8_t *sig)
{
uint8_t msg[len + sizeof(uint32_t) + 8];
@ -4971,7 +4971,7 @@ static int sign_test(const char *prefix, const uint8_t *key, const uint8_t *m,
memcpy(orig, msg, sizeof(msg));
err = smp_sign_buf(key, msg, len);
err = smp_sign_buf(sign_key, msg, len);
if (err) {
return err;
}

3
subsys/bluetooth/mesh/cfg_cli.c
View file

@ -670,8 +670,7 @@ static int mod_app_list_handle(struct bt_mesh_msg_ctx *ctx, struct net_buf_simpl
if (param->member_cnt && param->members) {
int err =
bt_mesh_key_idx_unpack_list(buf, param->members, param->member_cnt);
err = bt_mesh_key_idx_unpack_list(buf, param->members, param->member_cnt);
if (err) {
LOG_ERR("The message size for the application opcode is "

17
subsys/bluetooth/mesh/crypto_tc.c
View file

@ -31,7 +31,7 @@ static struct {
bool is_ready;
uint8_t private_key_be[PRIV_KEY_SIZE];
uint8_t public_key_be[PUB_KEY_SIZE];
} key;
} dh_pair;
int bt_mesh_encrypt(const struct bt_mesh_key *key, const uint8_t plaintext[16],
uint8_t enc_data[16])
@ -110,22 +110,24 @@ int bt_mesh_sha256_hmac_raw_key(const uint8_t key[32], struct bt_mesh_sg *sg, si
int bt_mesh_pub_key_gen(void)
{
int rc = uECC_make_key(key.public_key_be, key.private_key_be, &curve_secp256r1);
int rc = uECC_make_key(dh_pair.public_key_be,
dh_pair.private_key_be,
&curve_secp256r1);
if (rc == TC_CRYPTO_FAIL) {
key.is_ready = false;
dh_pair.is_ready = false;
LOG_ERR("Failed to create public/private pair");
return -EIO;
}
key.is_ready = true;
dh_pair.is_ready = true;
return 0;
}
const uint8_t *bt_mesh_pub_key_get(void)
{
return key.is_ready ? key.public_key_be : NULL;
return dh_pair.is_ready ? dh_pair.public_key_be : NULL;
}
int bt_mesh_dhkey_gen(const uint8_t *pub_key, const uint8_t *priv_key, uint8_t *dhkey)
@ -133,8 +135,9 @@ int bt_mesh_dhkey_gen(const uint8_t *pub_key, const uint8_t *priv_key, uint8_t *
if (uECC_valid_public_key(pub_key, &curve_secp256r1)) {
LOG_ERR("Public key is not valid");
return -EIO;
} else if (uECC_shared_secret(pub_key, priv_key ? priv_key : key.private_key_be, dhkey,
&curve_secp256r1) != TC_CRYPTO_SUCCESS) {
} else if (uECC_shared_secret(pub_key, priv_key ? priv_key :
dh_pair.private_key_be,
dhkey, &curve_secp256r1) != TC_CRYPTO_SUCCESS) {
LOG_ERR("DHKey generation failed");
return -EIO;
}

14
subsys/bluetooth/mesh/dfu_cli.c
View file

@ -66,7 +66,7 @@ enum {
STATE_SUSPENDED,
};
static int32_t timeout = (10 * MSEC_PER_SEC);
static int32_t dfu_cli_timeout = (10 * MSEC_PER_SEC);
static struct bt_mesh_dfu_target *target_get(struct bt_mesh_dfu_cli *cli,
uint16_t addr)
@ -1079,7 +1079,7 @@ int bt_mesh_dfu_cli_cancel(struct bt_mesh_dfu_cli *cli,
return err;
}
return req_wait(cli, K_MSEC(timeout));
return req_wait(cli, K_MSEC(dfu_cli_timeout));
}
if (cli->xfer.state == STATE_IDLE) {
@ -1168,7 +1168,7 @@ int bt_mesh_dfu_cli_imgs_get(struct bt_mesh_dfu_cli *cli,
return err;
}
err = req_wait(cli, K_MSEC(timeout));
err = req_wait(cli, K_MSEC(dfu_cli_timeout));
cli->req.img_cb = NULL;
@ -1206,7 +1206,7 @@ int bt_mesh_dfu_cli_metadata_check(struct bt_mesh_dfu_cli *cli,
return err;
}
return req_wait(cli, K_MSEC(timeout));
return req_wait(cli, K_MSEC(dfu_cli_timeout));
}
int bt_mesh_dfu_cli_status_get(struct bt_mesh_dfu_cli *cli,
@ -1229,15 +1229,15 @@ int bt_mesh_dfu_cli_status_get(struct bt_mesh_dfu_cli *cli,
return err;
}
return req_wait(cli, K_MSEC(timeout));
return req_wait(cli, K_MSEC(dfu_cli_timeout));
}
int32_t bt_mesh_dfu_cli_timeout_get(void)
{
return timeout;
return dfu_cli_timeout;
}
void bt_mesh_dfu_cli_timeout_set(int32_t t)
{
timeout = t;
dfu_cli_timeout = t;
}

2
subsys/bluetooth/mesh/friend.c
View file

@ -171,7 +171,7 @@ static void friend_clear(struct bt_mesh_friend *frnd)
/* If cancelling the timer fails, we'll exit early in the work handler. */
(void)k_work_cancel_delayable(&frnd->timer);
for (int i = 0; i < ARRAY_SIZE(frnd->cred); i++) {
for (i = 0; i < ARRAY_SIZE(frnd->cred); i++) {
if (frnd->subnet->keys[i].valid) {
bt_mesh_friend_cred_destroy(&frnd->cred[i]);
}

42
subsys/bluetooth/mesh/heartbeat.c
View file

@ -164,7 +164,7 @@ static void hb_publish(struct k_work *work)
.start = hb_publish_start_cb,
.end = hb_publish_end_cb,
};
struct bt_mesh_subnet *sub;
struct bt_mesh_subnet *subnet;
int err;
LOG_DBG("hb_pub.count: %u", pub.count);
@ -174,8 +174,8 @@ static void hb_publish(struct k_work *work)
return;
}
sub = bt_mesh_subnet_get(pub.net_idx);
if (!sub) {
subnet = bt_mesh_subnet_get(pub.net_idx);
if (!subnet) {
LOG_ERR("No matching subnet for idx 0x%02x", pub.net_idx);
pub.dst = BT_MESH_ADDR_UNASSIGNED;
return;
@ -412,7 +412,7 @@ void bt_mesh_hb_resume(void)
static int hb_pub_set(const char *name, size_t len_rd,
settings_read_cb read_cb, void *cb_arg)
{
struct bt_mesh_hb_pub pub;
struct bt_mesh_hb_pub hb_pub;
struct hb_pub_val hb_val;
int err;
@ -422,19 +422,19 @@ static int hb_pub_set(const char *name, size_t len_rd,
return err;
}
pub.dst = hb_val.dst;
pub.period = bt_mesh_hb_pwr2(hb_val.period);
pub.ttl = hb_val.ttl;
pub.feat = hb_val.feat;
pub.net_idx = hb_val.net_idx;
hb_pub.dst = hb_val.dst;
hb_pub.period = bt_mesh_hb_pwr2(hb_val.period);
hb_pub.ttl = hb_val.ttl;
hb_pub.feat = hb_val.feat;
hb_pub.net_idx = hb_val.net_idx;
if (hb_val.indefinite) {
pub.count = 0xffff;
hb_pub.count = 0xffff;
} else {
pub.count = 0U;
hb_pub.count = 0U;
}
(void)bt_mesh_hb_pub_set(&pub);
(void)bt_mesh_hb_pub_set(&hb_pub);
LOG_DBG("Restored heartbeat publication");
@ -445,20 +445,20 @@ BT_MESH_SETTINGS_DEFINE(pub, "HBPub", hb_pub_set);
void bt_mesh_hb_pub_pending_store(void)
{
struct bt_mesh_hb_pub pub;
struct bt_mesh_hb_pub hb_pub;
struct hb_pub_val val;
int err;
bt_mesh_hb_pub_get(&pub);
if (pub.dst == BT_MESH_ADDR_UNASSIGNED) {
bt_mesh_hb_pub_get(&hb_pub);
if (hb_pub.dst == BT_MESH_ADDR_UNASSIGNED) {
err = settings_delete("bt/mesh/HBPub");
} else {
val.indefinite = (pub.count == 0xffff);
val.dst = pub.dst;
val.period = bt_mesh_hb_log(pub.period);
val.ttl = pub.ttl;
val.feat = pub.feat;
val.net_idx = pub.net_idx;
val.indefinite = (hb_pub.count == 0xffff);
val.dst = hb_pub.dst;
val.period = bt_mesh_hb_log(hb_pub.period);
val.ttl = hb_pub.ttl;
val.feat = hb_pub.feat;
val.net_idx = hb_pub.net_idx;
err = settings_save_one("bt/mesh/HBPub", &val, sizeof(val));
}

6
subsys/bluetooth/mesh/sar_cfg_cli.c
View file

@ -113,11 +113,11 @@ static int bt_mesh_sar_cfg_cli_init(struct bt_mesh_model *model)
static void bt_mesh_sar_cfg_cli_reset(struct bt_mesh_model *model)
{
struct bt_mesh_sar_cfg_cli *cli;
struct bt_mesh_sar_cfg_cli *model_cli;
cli = model->user_data;
model_cli = model->user_data;
bt_mesh_msg_ack_ctx_clear(&cli->ack_ctx);
bt_mesh_msg_ack_ctx_clear(&model_cli->ack_ctx);
}
const struct bt_mesh_model_cb _bt_mesh_sar_cfg_cli_cb = {

6
subsys/bluetooth/mesh/shell/shell.c
View file

@ -877,16 +877,16 @@ static int cmd_auth_method_set_output(const struct shell *sh, size_t argc, char
static int cmd_auth_method_set_static(const struct shell *sh, size_t argc, char *argv[])
{
size_t len;
uint8_t static_val[16];
uint8_t static_oob_auth[16];
int err = 0;
len = hex2bin(argv[1], strlen(argv[1]), static_val, sizeof(static_val));
len = hex2bin(argv[1], strlen(argv[1]), static_oob_auth, sizeof(static_oob_auth));
if (len < 1) {
shell_warn(sh, "Unable to parse input string argument");
return -EINVAL;
}
err = bt_mesh_auth_method_set_static(static_val, len);
err = bt_mesh_auth_method_set_static(static_oob_auth, len);
if (err) {
shell_error(sh, "Setting static OOB authentication failed (err %d)", err);
}

62
subsys/bluetooth/shell/bt.c
View file

@ -1515,11 +1515,11 @@ static int cmd_scan_filter_clear_addr(const struct shell *sh, size_t argc,
#if defined(CONFIG_BT_BROADCASTER)
static ssize_t ad_init(struct bt_data *data_array, const size_t data_array_size,
const atomic_t *adv_opt)
const atomic_t *adv_options)
{
const bool discoverable = atomic_test_bit(adv_opt, SHELL_ADV_OPT_DISCOVERABLE);
const bool appearance = atomic_test_bit(adv_opt, SHELL_ADV_OPT_APPEARANCE);
const bool adv_ext = atomic_test_bit(adv_opt, SHELL_ADV_OPT_EXT_ADV);
const bool discoverable = atomic_test_bit(adv_options, SHELL_ADV_OPT_DISCOVERABLE);
const bool appearance = atomic_test_bit(adv_options, SHELL_ADV_OPT_APPEARANCE);
const bool adv_ext = atomic_test_bit(adv_options, SHELL_ADV_OPT_EXT_ADV);
static uint8_t ad_flags;
size_t ad_len = 0;
@ -1548,11 +1548,11 @@ static ssize_t ad_init(struct bt_data *data_array, const size_t data_array_size,
}
if (appearance) {
const uint16_t appearance = bt_get_appearance();
static uint8_t appearance_data[sizeof(appearance)];
const uint16_t appearance2 = bt_get_appearance();
static uint8_t appearance_data[sizeof(appearance2)];
__ASSERT(data_array_size > ad_len, "No space for appearance");
sys_put_le16(appearance, appearance_data);
sys_put_le16(appearance2, appearance_data);
data_array[ad_len].type = BT_DATA_GAP_APPEARANCE;
data_array[ad_len].data_len = sizeof(appearance_data);
data_array[ad_len].data = appearance_data;
@ -1573,7 +1573,7 @@ static ssize_t ad_init(struct bt_data *data_array, const size_t data_array_size,
}
if (IS_ENABLED(CONFIG_BT_AUDIO) && IS_ENABLED(CONFIG_BT_EXT_ADV) && adv_ext) {
const bool connectable = atomic_test_bit(adv_opt, SHELL_ADV_OPT_CONNECTABLE);
const bool connectable = atomic_test_bit(adv_options, SHELL_ADV_OPT_CONNECTABLE);
ssize_t audio_ad_len;
audio_ad_len = audio_ad_data_add(&data_array[ad_len], data_array_size - ad_len,
@ -2332,30 +2332,30 @@ static int cmd_per_adv_sync_create(const struct shell *sh, size_t argc,
create_params.sid = strtol(argv[3], NULL, 16);
for (int i = 4; i < argc; i++) {
if (!strcmp(argv[i], "aoa")) {
for (int j = 4; j < argc; j++) {
if (!strcmp(argv[j], "aoa")) {
options |= BT_LE_PER_ADV_SYNC_OPT_DONT_SYNC_AOA;
} else if (!strcmp(argv[i], "aod_1us")) {
} else if (!strcmp(argv[j], "aod_1us")) {
options |= BT_LE_PER_ADV_SYNC_OPT_DONT_SYNC_AOD_1US;
} else if (!strcmp(argv[i], "aod_2us")) {
} else if (!strcmp(argv[j], "aod_2us")) {
options |= BT_LE_PER_ADV_SYNC_OPT_DONT_SYNC_AOD_2US;
} else if (!strcmp(argv[i], "only_cte")) {
} else if (!strcmp(argv[j], "only_cte")) {
options |=
BT_LE_PER_ADV_SYNC_OPT_SYNC_ONLY_CONST_TONE_EXT;
} else if (!strcmp(argv[i], "timeout")) {
if (++i == argc) {
} else if (!strcmp(argv[j], "timeout")) {
if (++j == argc) {
shell_help(sh);
return SHELL_CMD_HELP_PRINTED;
}
create_params.timeout = strtoul(argv[i], NULL, 16);
} else if (!strcmp(argv[i], "skip")) {
if (++i == argc) {
create_params.timeout = strtoul(argv[j], NULL, 16);
} else if (!strcmp(argv[j], "skip")) {
if (++j == argc) {
shell_help(sh);
return SHELL_CMD_HELP_PRINTED;
}
create_params.skip = strtoul(argv[i], NULL, 16);
create_params.skip = strtoul(argv[j], NULL, 16);
} else {
shell_help(sh);
return SHELL_CMD_HELP_PRINTED;
@ -2448,34 +2448,34 @@ static int cmd_past_subscribe(const struct shell *sh, size_t argc,
param.timeout = 1000; /* 10 seconds */
param.skip = 10;
for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i], "aoa")) {
for (int j = 1; j < argc; j++) {
if (!strcmp(argv[j], "aoa")) {
param.options |=
BT_LE_PER_ADV_SYNC_TRANSFER_OPT_SYNC_NO_AOA;
} else if (!strcmp(argv[i], "aod_1us")) {
} else if (!strcmp(argv[j], "aod_1us")) {
param.options |=
BT_LE_PER_ADV_SYNC_TRANSFER_OPT_SYNC_NO_AOD_1US;
} else if (!strcmp(argv[i], "aod_2us")) {
} else if (!strcmp(argv[j], "aod_2us")) {
param.options |=
BT_LE_PER_ADV_SYNC_TRANSFER_OPT_SYNC_NO_AOD_2US;
} else if (!strcmp(argv[i], "only_cte")) {
} else if (!strcmp(argv[j], "only_cte")) {
param.options |=
BT_LE_PER_ADV_SYNC_TRANSFER_OPT_SYNC_ONLY_CTE;
} else if (!strcmp(argv[i], "timeout")) {
if (++i == argc) {
} else if (!strcmp(argv[j], "timeout")) {
if (++j == argc) {
shell_help(sh);
return SHELL_CMD_HELP_PRINTED;
}
param.timeout = strtoul(argv[i], NULL, 16);
} else if (!strcmp(argv[i], "skip")) {
if (++i == argc) {
param.timeout = strtoul(argv[j], NULL, 16);
} else if (!strcmp(argv[j], "skip")) {
if (++j == argc) {
shell_help(sh);
return SHELL_CMD_HELP_PRINTED;
}
param.skip = strtoul(argv[i], NULL, 16);
} else if (!strcmp(argv[i], "conn")) {
param.skip = strtoul(argv[j], NULL, 16);
} else if (!strcmp(argv[j], "conn")) {
if (!default_conn) {
shell_print(sh, "Not connected");
return -EINVAL;

8
subsys/bluetooth/shell/gatt.c
View file

@ -718,7 +718,7 @@ static uint8_t print_attr(const struct bt_gatt_attr *attr, uint16_t handle,
static int cmd_show_db(const struct shell *sh, size_t argc, char *argv[])
{
struct bt_uuid_16 uuid;
struct bt_uuid_16 uuid16;
size_t total_len;
memset(&stats, 0, sizeof(stats));
@ -726,14 +726,14 @@ static int cmd_show_db(const struct shell *sh, size_t argc, char *argv[])
if (argc > 1) {
uint16_t num_matches = 0;
uuid.uuid.type = BT_UUID_TYPE_16;
uuid.val = strtoul(argv[1], NULL, 16);
uuid16.uuid.type = BT_UUID_TYPE_16;
uuid16.val = strtoul(argv[1], NULL, 16);
if (argc > 2) {
num_matches = strtoul(argv[2], NULL, 10);
}
bt_gatt_foreach_attr_type(0x0001, 0xffff, &uuid.uuid, NULL,
bt_gatt_foreach_attr_type(0x0001, 0xffff, &uuid16.uuid, NULL,
num_matches, print_attr,
(void *)sh);
return 0;