diff --git a/applications/firmware_loader/ble_mcumgr/src/main.c b/applications/firmware_loader/ble_mcumgr/src/main.c index ff0a87b5be..9887f1fd89 100644 --- a/applications/firmware_loader/ble_mcumgr/src/main.c +++ b/applications/firmware_loader/ble_mcumgr/src/main.c @@ -176,6 +176,7 @@ static int ble_change_address(void) int main(void) { int err; + uint32_t nrf_err; struct ble_adv_config ble_adv_cfg = { .conn_cfg_tag = CONFIG_NRF_SDH_BLE_CONN_TAG, .evt_handler = ble_adv_evt_handler, @@ -231,17 +232,15 @@ int main(void) ble_adv_cfg.sr_data.uuid_lists.complete.uuid = &adv_uuid_list[0]; ble_adv_cfg.sr_data.uuid_lists.complete.len = ARRAY_SIZE(adv_uuid_list); - err = ble_adv_init(&ble_adv, &ble_adv_cfg); - - if (err) { - LOG_ERR("Failed to initialize advertising, err %d", err); + nrf_err = ble_adv_init(&ble_adv, &ble_adv_cfg); + if (nrf_err) { + LOG_ERR("Failed to initialize advertising, nrf_error %#x", nrf_err); return 0; } - err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); - - if (err) { - LOG_ERR("Failed to start advertising, err %d", err); + nrf_err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); + if (nrf_err) { + LOG_ERR("Failed to start advertising, nrf_error %#x", err); return 0; } diff --git a/doc/nrf-bm/release_notes/release_notes_changelog.rst b/doc/nrf-bm/release_notes/release_notes_changelog.rst index e45bfb731e..8e2158a3c2 100644 --- a/doc/nrf-bm/release_notes/release_notes_changelog.rst +++ b/doc/nrf-bm/release_notes/release_notes_changelog.rst @@ -68,6 +68,10 @@ No changes since the latest nRF Connect SDK Bare Metal release. Libraries ========= +* Updated the following libraries to return ``nrf_errors`` instead of ``errnos``: + + * BLE Advertising library. + * :ref:`lib_ble_conn_params` library: * Added missing Kconfig dependencies. diff --git a/include/bm/bluetooth/ble_adv.h b/include/bm/bluetooth/ble_adv.h index 3319d38d77..a32c648388 100644 --- a/include/bm/bluetooth/ble_adv.h +++ b/include/bm/bluetooth/ble_adv.h @@ -136,7 +136,7 @@ struct ble_adv_evt { union { /** @ref BLE_ADV_EVT_ERROR event data. */ struct { - int reason; + uint32_t reason; } error; }; }; @@ -256,11 +256,11 @@ void ble_adv_on_ble_evt(const ble_evt_t *ble_evt, void *ble_adv); * @param[in] ble_adv BLE advertising instance. * @param[in] ble_adv_config Initialization configuration. * - * @retval 0 On success. - * @retval -FAULT If @p ble_adv or @p ble_adv_config are @c NULL. - * @retval -EINVAL If the configuration @p ble_adv_config is invalid. + * @retval NRF_SUCCESS On success. + * @retval NRF_ERROR_NULL If @p ble_adv or @p ble_adv_config are @c NULL. + * @retval NRF_ERROR_INVALID_PARAM If the configuration @p ble_adv_config is invalid. */ -int ble_adv_init(struct ble_adv *ble_adv, struct ble_adv_config *ble_adv_config); +uint32_t ble_adv_init(struct ble_adv *ble_adv, struct ble_adv_config *ble_adv_config); /** * @brief Set the connection configuration tag used for connections. @@ -268,7 +268,7 @@ int ble_adv_init(struct ble_adv *ble_adv, struct ble_adv_config *ble_adv_config) * @param[in] ble_adv BLE advertising instance. * @param[in] ble_cfg_tag Connection configuration tag. */ -int ble_adv_conn_cfg_tag_set(struct ble_adv *ble_adv, uint8_t ble_cfg_tag); +uint32_t ble_adv_conn_cfg_tag_set(struct ble_adv *ble_adv, uint8_t ble_cfg_tag); /** * @brief Start advertising in given mode. @@ -279,12 +279,12 @@ int ble_adv_conn_cfg_tag_set(struct ble_adv *ble_adv, uint8_t ble_cfg_tag); * @param[in] ble_adv BLE advertising instance. * @param[in] mode Desired advertising mode. * - * @retval 0 On success. - * @retval -EPERM Library is not initialized. - * @retval -EFAULT @p ble_adv is @c NULL. - * @retval -EINVAL Invalid parameters. + * @retval NRF_SUCCESS On success. + * @retval NRF_ERROR_INVALID_STATE Library is not initialized. + * @retval NRF_ERROR_NULL @p ble_adv is @c NULL. + * @retval NRF_ERROR_INVALID_PARAM Invalid parameters. */ -int ble_adv_start(struct ble_adv *ble_adv, enum ble_adv_mode mode); +uint32_t ble_adv_start(struct ble_adv *ble_adv, enum ble_adv_mode mode); /** * @brief Set the peer address for directed advertising. @@ -296,12 +296,12 @@ int ble_adv_start(struct ble_adv *ble_adv, enum ble_adv_mode mode); * @param[in] p_advertising Advertising Module instance. * @param[in] p_peer_addr Pointer to a peer address. * - * @retval 0 On success. - * @retval -EPERM Library is not initialized. - * @retval -EFAULT @p ble_adv is @c NULL. - * @retval -EINVAL Invalid parameters. + * @retval NRF_SUCCESS On success. + * @retval NRF_ERROR_INVALID_STATE Library is not initialized. + * @retval NRF_ERROR_NULL @p ble_adv is @c NULL. + * @retval NRF_ERROR_INVALID_PARAM Invalid parameters. */ -int ble_adv_peer_addr_reply(struct ble_adv *ble_adv, const ble_gap_addr_t *peer_addr); +uint32_t ble_adv_peer_addr_reply(struct ble_adv *ble_adv, const ble_gap_addr_t *peer_addr); /** * @brief Set a whitelist for fast and slow advertising. @@ -315,14 +315,14 @@ int ble_adv_peer_addr_reply(struct ble_adv *ble_adv, const ble_gap_addr_t *peer_ * @param[in] gap_irks The list of peer IRK to whitelist. * @param[in] irk_cnt The number of peer IRK to whitelist. * - * @retval 0 On success. - * @retval -EPERM Library is not initialized. - * @retval -EFAULT @p ble_adv is @c NULL. - * @retval -EINVAL Invalid parameters. + * @retval NRF_SUCCESS On success. + * @retval NRF_ERROR_INVALID_STATE Library is not initialized. + * @retval NRF_ERROR_NULL @p ble_adv is @c NULL. + * @retval NRF_ERROR_INVALID_PARAM Invalid parameters. */ -int ble_adv_whitelist_reply(struct ble_adv *ble_adv, - const ble_gap_addr_t *gap_addrs, uint32_t addr_cnt, - const ble_gap_irk_t *gap_irks, uint32_t irk_cnt); +uint32_t ble_adv_whitelist_reply(struct ble_adv *ble_adv, + const ble_gap_addr_t *gap_addrs, uint32_t addr_cnt, + const ble_gap_irk_t *gap_irks, uint32_t irk_cnt); /** * @brief Restart advertising without whitelist. @@ -332,11 +332,12 @@ int ble_adv_whitelist_reply(struct ble_adv *ble_adv, * * @param[in] ble_adv Advertising Module instance. * - * @retval 0 On success. - * @retval -EPERM Library is not initialized. - * @retval -EFAULT @p ble_adv is @c NULL. + * @retval NRF_SUCCESS On success. + * @retval NRF_ERROR_INVALID_STATE Library is not initialized. + * @retval NRF_ERROR_NULL @p ble_adv is @c NULL. + * @retval NRF_ERROR_INVALID_PARAM Invalid advertising parameters. */ -int ble_adv_restart_without_whitelist(struct ble_adv *ble_adv); +uint32_t ble_adv_restart_without_whitelist(struct ble_adv *ble_adv); /**@brief Function for updating advertising data. * @@ -355,9 +356,9 @@ int ble_adv_restart_without_whitelist(struct ble_adv *ble_adv); * @retval @ref NRF_SUCCESS or any error from @ref ble_advdata_encode or * @ref sd_ble_gap_adv_set_configure(). */ -int ble_adv_data_update(struct ble_adv *ble_adv, - const struct ble_adv_data *adv, - const struct ble_adv_data *sr); +uint32_t ble_adv_data_update(struct ble_adv *ble_adv, + const struct ble_adv_data *adv, + const struct ble_adv_data *sr); #ifdef __cplusplus } diff --git a/include/bm/bluetooth/ble_adv_data.h b/include/bm/bluetooth/ble_adv_data.h index db9705ebcb..4841d36889 100644 --- a/include/bm/bluetooth/ble_adv_data.h +++ b/include/bm/bluetooth/ble_adv_data.h @@ -185,9 +185,11 @@ struct ble_adv_data { * @param[out] buf Output buffer. * @param[in,out] len Size of @p buf on input, length of encoded data on output. * - * @retval 0 If the operation was successful. - * @retval -EINVAL Invalid parameter. - * @retval -E2BIG Buffer is too small to encode all data. + * @retval NRF_SUCCESS If the operation was successful. + * @retval NRF_ERROR_INVALID_ADDR Invalid address. + * @retval NRF_ERROR_INVALID_PARAM Invalid parameter provided in the adverising data context. + * @retval NRF_ERROR_NULL @p ble_adv_data, @p buf or @p len is NULL. + * @retval NRF_ERROR_DATA_SIZE Buffer is too small to encode all data. * * @warning This API may override the application's request to use the long name and use a short * name instead. This truncation will occur in case the long name does not fit the provided buffer @@ -199,7 +201,7 @@ struct ble_adv_data { * application can specify, and if the preference is too large to fit in the provided buffer, the * name can be truncated further. */ -int ble_adv_data_encode(const struct ble_adv_data *ble_adv_data, uint8_t *buf, uint16_t *len); +uint32_t ble_adv_data_encode(const struct ble_adv_data *ble_adv_data, uint8_t *buf, uint16_t *len); /** * @brief Search Advertising or Scan Response data for specific data types. diff --git a/lib/bluetooth/ble_adv/ble_adv.c b/lib/bluetooth/ble_adv/ble_adv.c index a7bb09dac5..67856f5320 100644 --- a/lib/bluetooth/ble_adv/ble_adv.c +++ b/lib/bluetooth/ble_adv/ble_adv.c @@ -3,7 +3,7 @@ * * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause */ -#include +#include #include "zephyr/toolchain.h" #include #include @@ -72,17 +72,17 @@ static void on_connected(struct ble_adv *ble_adv, ble_evt_t const *ble_evt) static void on_disconnected(struct ble_adv *ble_adv, ble_evt_t const *ble_evt) { - int err; + uint32_t nrf_err; struct ble_adv_evt adv_evt; ble_adv->whitelist_temporarily_disabled = false; if (IS_ENABLED(CONFIG_BLE_ADV_RESTART_ON_DISCONNECT)) { if (ble_evt->evt.gap_evt.conn_handle == ble_adv->conn_handle) { - err = ble_adv_start(ble_adv, BLE_ADV_MODE_DIRECTED_HIGH_DUTY); - if (err) { + nrf_err = ble_adv_start(ble_adv, BLE_ADV_MODE_DIRECTED_HIGH_DUTY); + if (nrf_err != NRF_SUCCESS) { adv_evt.evt_type = BLE_ADV_EVT_ERROR; - adv_evt.error.reason = err; + adv_evt.error.reason = nrf_err; ble_adv->evt_handler(ble_adv, &adv_evt); } } @@ -91,7 +91,7 @@ static void on_disconnected(struct ble_adv *ble_adv, ble_evt_t const *ble_evt) static void on_terminated(struct ble_adv *ble_adv, ble_evt_t const *ble_evt) { - int err; + uint32_t nrf_err; const uint8_t reason = ble_evt->evt.gap_evt.params.adv_set_terminated.reason; struct ble_adv_evt adv_evt; @@ -99,18 +99,18 @@ static void on_terminated(struct ble_adv *ble_adv, ble_evt_t const *ble_evt) if (reason == BLE_GAP_EVT_ADV_SET_TERMINATED_REASON_TIMEOUT || reason == BLE_GAP_EVT_ADV_SET_TERMINATED_REASON_LIMIT_REACHED) { LOG_DBG("Advertising timeout"); - err = ble_adv_start(ble_adv, adv_mode_next(ble_adv->mode_current)); - if (err) { - adv_evt.error.reason = err; + nrf_err = ble_adv_start(ble_adv, adv_mode_next(ble_adv->mode_current)); + if (nrf_err != NRF_SUCCESS) { + adv_evt.error.reason = nrf_err; adv_evt.evt_type = BLE_ADV_EVT_ERROR; ble_adv->evt_handler(ble_adv, &adv_evt); } } } -static int flags_set(struct ble_adv *ble_adv, uint8_t flags) +static uint32_t flags_set(struct ble_adv *ble_adv, uint8_t flags) { - int err; + uint32_t nrf_err; uint8_t *parsed_flags; parsed_flags = ble_adv_data_parse(ble_adv->adv_data.adv_data.p_data, @@ -118,22 +118,22 @@ static int flags_set(struct ble_adv *ble_adv, uint8_t flags) if (!parsed_flags) { LOG_WRN("Unable to find flags in current advertising data"); - return -EINVAL; + return NRF_ERROR_INVALID_PARAM; } *parsed_flags = flags; - err = sd_ble_gap_adv_set_configure(&ble_adv->adv_handle, &ble_adv->adv_data, + nrf_err = sd_ble_gap_adv_set_configure(&ble_adv->adv_handle, &ble_adv->adv_data, &ble_adv->adv_params); - if (err) { - LOG_ERR("Failed to set advertising flags, nrf_error %#x", err); - return -EINVAL; + if (nrf_err != NRF_SUCCESS) { + LOG_ERR("Failed to set advertising flags, nrf_error %#x", nrf_err); + return NRF_ERROR_INVALID_PARAM; } - return 0; + return NRF_SUCCESS; } -static int set_adv_mode_directed_high_duty(struct ble_adv *ble_adv, +static uint32_t set_adv_mode_directed_high_duty(struct ble_adv *ble_adv, ble_gap_adv_params_t *adv_params) { #if CONFIG_BLE_ADV_DIRECTED_ADVERTISING_HIGH_DUTY @@ -143,10 +143,10 @@ static int set_adv_mode_directed_high_duty(struct ble_adv *ble_adv, adv_params->duration = BLE_GAP_ADV_TIMEOUT_HIGH_DUTY_MAX; adv_params->interval = 0; #endif - return 0; + return NRF_SUCCESS; } -static int set_adv_mode_directed(struct ble_adv *ble_adv, ble_gap_adv_params_t *adv_params) +static uint32_t set_adv_mode_directed(struct ble_adv *ble_adv, ble_gap_adv_params_t *adv_params) { #if CONFIG_BLE_ADV_DIRECTED_ADVERTISING #if defined(BLE_GAP_ADV_TYPE_EXTENDED_CONNECTABLE_NONSCANNABLE_DIRECTED) @@ -163,13 +163,13 @@ static int set_adv_mode_directed(struct ble_adv *ble_adv, ble_gap_adv_params_t * adv_params->duration = CONFIG_BLE_ADV_DIRECTED_ADVERTISING_TIMEOUT; adv_params->interval = CONFIG_BLE_ADV_DIRECTED_ADVERTISING_INTERVAL; #endif - return 0; + return NRF_SUCCESS; } -static int set_adv_mode_fast(struct ble_adv *ble_adv, ble_gap_adv_params_t *adv_params) +static uint32_t set_adv_mode_fast(struct ble_adv *ble_adv, ble_gap_adv_params_t *adv_params) { #if CONFIG_BLE_ADV_FAST_ADVERTISING - int err; + uint32_t nrf_err; #if defined(BLE_GAP_ADV_TYPE_EXTENDED_CONNECTABLE_NONSCANNABLE_UNDIRECTED) if (IS_ENABLED(CONFIG_BLE_ADV_EXTENDED_ADVERTISING)) { @@ -188,19 +188,19 @@ static int set_adv_mode_fast(struct ble_adv *ble_adv, ble_gap_adv_params_t *adv_ if (use_whitelist(ble_adv)) { /* Set filter policy and advertising flags */ adv_params->filter_policy = BLE_GAP_ADV_FP_FILTER_CONNREQ; - err = flags_set(ble_adv, BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED); - if (err) { - return err; + nrf_err = flags_set(ble_adv, BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED); + if (nrf_err != NRF_SUCCESS) { + return nrf_err; } } #endif - return 0; + return NRF_SUCCESS; } -static int set_adv_mode_slow(struct ble_adv *ble_adv, ble_gap_adv_params_t *adv_params) +static uint32_t set_adv_mode_slow(struct ble_adv *ble_adv, ble_gap_adv_params_t *adv_params) { #if CONFIG_BLE_ADV_SLOW_ADVERTISING - int err; + uint32_t nrf_err; #if defined(BLE_GAP_ADV_TYPE_EXTENDED_CONNECTABLE_NONSCANNABLE_UNDIRECTED) if (IS_ENABLED(CONFIG_BLE_ADV_EXTENDED_ADVERTISING)) { @@ -220,13 +220,13 @@ static int set_adv_mode_slow(struct ble_adv *ble_adv, ble_gap_adv_params_t *adv_ if (use_whitelist(ble_adv)) { /* Set filter policy and advertising flags */ adv_params->filter_policy = BLE_GAP_ADV_FP_FILTER_CONNREQ; - err = flags_set(ble_adv, BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED); - if (err) { - return err; + nrf_err = flags_set(ble_adv, BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED); + if (nrf_err != NRF_SUCCESS) { + return nrf_err; } } #endif - return 0; + return NRF_SUCCESS; } static uint16_t adv_data_size_max_get(void) @@ -242,27 +242,24 @@ static uint16_t adv_data_size_max_get(void) #endif } -int ble_adv_conn_cfg_tag_set(struct ble_adv *ble_adv, uint8_t ble_cfg_tag) +uint32_t ble_adv_conn_cfg_tag_set(struct ble_adv *ble_adv, uint8_t ble_cfg_tag) { if (!ble_adv) { - return -EFAULT; + return NRF_ERROR_NULL; } ble_adv->conn_cfg_tag = ble_cfg_tag; - return 0; + return NRF_SUCCESS; } -int ble_adv_init(struct ble_adv *ble_adv, struct ble_adv_config *ble_adv_config) +uint32_t ble_adv_init(struct ble_adv *ble_adv, struct ble_adv_config *ble_adv_config) { - int err; + uint32_t nrf_err; ble_gap_conn_sec_mode_t sec_mode = {0}; - if (!ble_adv || !ble_adv_config) { - return -EFAULT; - } - if (!ble_adv_config->evt_handler) { - return -EFAULT; + if (!ble_adv || !ble_adv_config || !ble_adv_config->evt_handler) { + return NRF_ERROR_NULL; } ble_adv->mode_current = BLE_ADV_MODE_IDLE; @@ -274,29 +271,30 @@ int ble_adv_init(struct ble_adv *ble_adv, struct ble_adv_config *ble_adv_config) memset(&ble_adv->peer_address, 0x00, sizeof(ble_adv->peer_address)); BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode); - err = sd_ble_gap_device_name_set(&sec_mode, CONFIG_BLE_ADV_NAME, + nrf_err = sd_ble_gap_device_name_set(&sec_mode, CONFIG_BLE_ADV_NAME, strlen(CONFIG_BLE_ADV_NAME)); - if (err) { - LOG_ERR("Failed to set advertising name, nrf_error %#x", err); - return -EINVAL; + if (nrf_err != NRF_SUCCESS) { + LOG_ERR("Failed to set advertising name, nrf_error %#x", nrf_err); + return NRF_ERROR_INVALID_PARAM; } ble_adv->adv_data.adv_data.p_data = ble_adv->enc_adv_data[0]; ble_adv->adv_data.adv_data.len = adv_data_size_max_get(); - err = ble_adv_data_encode(&ble_adv_config->adv_data, ble_adv->enc_adv_data[0], + nrf_err = ble_adv_data_encode(&ble_adv_config->adv_data, ble_adv->enc_adv_data[0], &ble_adv->adv_data.adv_data.len); - if (err) { - return err; + if (nrf_err != NRF_SUCCESS) { + return nrf_err; } ble_adv->adv_data.scan_rsp_data.p_data = ble_adv->enc_scan_rsp_data[0]; ble_adv->adv_data.scan_rsp_data.len = adv_data_size_max_get(); - err = ble_adv_data_encode(&ble_adv_config->sr_data, ble_adv->adv_data.scan_rsp_data.p_data, - &ble_adv->adv_data.scan_rsp_data.len); - if (err) { - return err; + nrf_err = ble_adv_data_encode(&ble_adv_config->sr_data, + ble_adv->adv_data.scan_rsp_data.p_data, + &ble_adv->adv_data.scan_rsp_data.len); + if (nrf_err != NRF_SUCCESS) { + return nrf_err; } /* Configure a initial advertising configuration. The advertising data and parameters @@ -309,26 +307,26 @@ int ble_adv_init(struct ble_adv *ble_adv, struct ble_adv_config *ble_adv_config) ble_adv->adv_params.filter_policy = BLE_GAP_ADV_FP_ANY; ble_adv->adv_params.primary_phy = BLE_GAP_PHY_AUTO; - err = sd_ble_gap_adv_set_configure(&ble_adv->adv_handle, NULL, &ble_adv->adv_params); - if (err) { - LOG_ERR("Failed to set GAP advertising parameters, nrf_error %#x", err); - return -EINVAL; + nrf_err = sd_ble_gap_adv_set_configure(&ble_adv->adv_handle, NULL, &ble_adv->adv_params); + if (nrf_err != NRF_SUCCESS) { + LOG_ERR("Failed to set GAP advertising parameters, nrf_error %#x", nrf_err); + return NRF_ERROR_INVALID_PARAM; } ble_adv->is_initialized = true; - return 0; + return NRF_SUCCESS; } -int ble_adv_start(struct ble_adv *ble_adv, enum ble_adv_mode mode) +uint32_t ble_adv_start(struct ble_adv *ble_adv, enum ble_adv_mode mode) { - int err; + uint32_t nrf_err; struct ble_adv_evt adv_evt; if (!ble_adv) { - return -EFAULT; + return NRF_ERROR_NULL; } if (!ble_adv->is_initialized) { - return -EPERM; + return NRF_ERROR_INVALID_STATE; } ble_adv->whitelist_in_use = false; @@ -373,7 +371,7 @@ int ble_adv_start(struct ble_adv *ble_adv, enum ble_adv_mode mode) LOG_INF("Directed advertising (high duty)"); mode = BLE_ADV_MODE_DIRECTED_HIGH_DUTY; adv_evt.evt_type = BLE_ADV_EVT_DIRECTED_HIGH_DUTY; - err = set_adv_mode_directed_high_duty(ble_adv, &ble_adv->adv_params); + nrf_err = set_adv_mode_directed_high_duty(ble_adv, &ble_adv->adv_params); break; } __fallthrough; @@ -382,7 +380,7 @@ int ble_adv_start(struct ble_adv *ble_adv, enum ble_adv_mode mode) LOG_INF("Directed advertising"); mode = BLE_ADV_MODE_DIRECTED; adv_evt.evt_type = BLE_ADV_EVT_DIRECTED; - err = set_adv_mode_directed(ble_adv, &ble_adv->adv_params); + nrf_err = set_adv_mode_directed(ble_adv, &ble_adv->adv_params); break; } __fallthrough; @@ -391,10 +389,11 @@ int ble_adv_start(struct ble_adv *ble_adv, enum ble_adv_mode mode) LOG_INF("Fast advertising"); mode = BLE_ADV_MODE_FAST; adv_evt.evt_type = BLE_ADV_EVT_FAST; - err = set_adv_mode_fast(ble_adv, &ble_adv->adv_params); - if (err) { - LOG_ERR("Failed to set fast advertising params, error: %d", err); - return -EINVAL; + nrf_err = set_adv_mode_fast(ble_adv, &ble_adv->adv_params); + if (nrf_err != NRF_SUCCESS) { + LOG_ERR("Failed to set fast advertising params, error: %d", + nrf_err); + return NRF_ERROR_INVALID_PARAM; } break; } __fallthrough; @@ -404,10 +403,11 @@ int ble_adv_start(struct ble_adv *ble_adv, enum ble_adv_mode mode) LOG_INF("Slow advertising"); mode = BLE_ADV_MODE_SLOW; adv_evt.evt_type = BLE_ADV_EVT_SLOW; - err = set_adv_mode_slow(ble_adv, &ble_adv->adv_params); - if (err) { - LOG_ERR("Failed to set slow advertising params, error: %d", err); - return -EINVAL; + nrf_err = set_adv_mode_slow(ble_adv, &ble_adv->adv_params); + if (nrf_err != NRF_SUCCESS) { + LOG_ERR("Failed to set slow advertising params, error: %d", + nrf_err); + return NRF_ERROR_INVALID_PARAM; } break; } __fallthrough; @@ -421,23 +421,23 @@ int ble_adv_start(struct ble_adv *ble_adv, enum ble_adv_mode mode) } if (mode != BLE_ADV_MODE_IDLE) { - err = sd_ble_gap_adv_set_configure(&ble_adv->adv_handle, &ble_adv->adv_data, + nrf_err = sd_ble_gap_adv_set_configure(&ble_adv->adv_handle, &ble_adv->adv_data, &ble_adv->adv_params); - if (err) { - LOG_ERR("Failed to set advertising data, nrf_error %#x", err); - return -EINVAL; + if (nrf_err != NRF_SUCCESS) { + LOG_ERR("Failed to set advertising data, nrf_error %#x", nrf_err); + return NRF_ERROR_INVALID_PARAM; } - err = sd_ble_gap_adv_start(ble_adv->adv_handle, ble_adv->conn_cfg_tag); - if (err) { - LOG_ERR("Failed to start advertising, nrf_error %#x", err); - return -EINVAL; + nrf_err = sd_ble_gap_adv_start(ble_adv->adv_handle, ble_adv->conn_cfg_tag); + if (nrf_err != NRF_SUCCESS) { + LOG_ERR("Failed to start advertising, nrf_error %#x", nrf_err); + return NRF_ERROR_INVALID_PARAM; } } ble_adv->mode_current = mode; ble_adv->evt_handler(ble_adv, &adv_evt); - return 0; + return NRF_SUCCESS; } void ble_adv_on_ble_evt(const ble_evt_t *ble_evt, void *instance) @@ -462,44 +462,44 @@ void ble_adv_on_ble_evt(const ble_evt_t *ble_evt, void *instance) } } -int ble_adv_peer_addr_reply(struct ble_adv *ble_adv, const ble_gap_addr_t *peer_addr) +uint32_t ble_adv_peer_addr_reply(struct ble_adv *ble_adv, const ble_gap_addr_t *peer_addr) { if (!ble_adv || !peer_addr) { - return -EFAULT; + return NRF_ERROR_NULL; } if (!ble_adv->peer_addr_reply_expected) { - return -EPERM; + return NRF_ERROR_INVALID_STATE; } if (!peer_addr_is_valid(peer_addr)) { - return -EINVAL; + return NRF_ERROR_INVALID_PARAM; } ble_adv->peer_addr_reply_expected = false; memcpy(&ble_adv->peer_address, peer_addr, sizeof(ble_adv->peer_address)); - return 0; + return NRF_SUCCESS; } -int ble_adv_whitelist_reply(struct ble_adv *ble_adv, - const ble_gap_addr_t *addrs, uint32_t addr_cnt, - const ble_gap_irk_t *irks, uint32_t irk_cnt) +uint32_t ble_adv_whitelist_reply(struct ble_adv *ble_adv, + const ble_gap_addr_t *addrs, uint32_t addr_cnt, + const ble_gap_irk_t *irks, uint32_t irk_cnt) { if (!ble_adv) { - return -EFAULT; + return NRF_ERROR_NULL; } if (!ble_adv->whitelist_reply_expected) { - return -EPERM; + return NRF_ERROR_INVALID_STATE; } ble_adv->whitelist_reply_expected = false; ble_adv->whitelist_in_use = (addr_cnt > 0 || irk_cnt > 0); - return 0; + return NRF_SUCCESS; } -int ble_adv_restart_without_whitelist(struct ble_adv *ble_adv) +uint32_t ble_adv_restart_without_whitelist(struct ble_adv *ble_adv) { - int err; + uint32_t nrf_err; (void)sd_ble_gap_adv_stop(ble_adv->adv_handle); @@ -507,30 +507,30 @@ int ble_adv_restart_without_whitelist(struct ble_adv *ble_adv) ble_adv->adv_params.filter_policy = BLE_GAP_ADV_FP_ANY; /* Set correct flags */ - err = flags_set(ble_adv, BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE); - if (err) { - return err; + nrf_err = flags_set(ble_adv, BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE); + if (nrf_err != NRF_SUCCESS) { + return nrf_err; } - err = ble_adv_start(ble_adv, ble_adv->mode_current); - if (err) { - return err; + nrf_err = ble_adv_start(ble_adv, ble_adv->mode_current); + if (nrf_err != NRF_SUCCESS) { + return nrf_err; } - return 0; + return NRF_SUCCESS; } -int ble_adv_data_update(struct ble_adv *ble_adv, const struct ble_adv_data *adv_data, +uint32_t ble_adv_data_update(struct ble_adv *ble_adv, const struct ble_adv_data *adv_data, const struct ble_adv_data *sr_data) { - int err; + uint32_t nrf_err; ble_gap_adv_data_t new_adv_data = {0}; if (!ble_adv || (adv_data == NULL && sr_data == NULL)) { - return -EFAULT; + return NRF_ERROR_NULL; } if (!ble_adv->is_initialized) { - return -EPERM; + return NRF_ERROR_INVALID_STATE; } if (adv_data) { @@ -541,10 +541,10 @@ int ble_adv_data_update(struct ble_adv *ble_adv, const struct ble_adv_data *adv_ new_adv_data.adv_data.len = adv_data_size_max_get(); - err = ble_adv_data_encode(adv_data, new_adv_data.adv_data.p_data, + nrf_err = ble_adv_data_encode(adv_data, new_adv_data.adv_data.p_data, &new_adv_data.adv_data.len); - if (err) { - return err; + if (nrf_err != NRF_SUCCESS) { + return nrf_err; } } @@ -556,20 +556,20 @@ int ble_adv_data_update(struct ble_adv *ble_adv, const struct ble_adv_data *adv_ new_adv_data.scan_rsp_data.len = adv_data_size_max_get(); - err = ble_adv_data_encode(sr_data, new_adv_data.scan_rsp_data.p_data, + nrf_err = ble_adv_data_encode(sr_data, new_adv_data.scan_rsp_data.p_data, &new_adv_data.scan_rsp_data.len); - if (err) { - return err; + if (nrf_err != NRF_SUCCESS) { + return nrf_err; } } memcpy(&ble_adv->adv_data, &new_adv_data, sizeof(ble_adv->adv_data)); - err = sd_ble_gap_adv_set_configure(&ble_adv->adv_handle, &ble_adv->adv_data, NULL); - if (err) { - LOG_ERR("Failed to set GAP advertising data, nrf_error %#x", err); - return -EINVAL; + nrf_err = sd_ble_gap_adv_set_configure(&ble_adv->adv_handle, &ble_adv->adv_data, NULL); + if (nrf_err != NRF_SUCCESS) { + LOG_ERR("Failed to set GAP advertising data, nrf_error %#x", nrf_err); + return NRF_ERROR_INVALID_PARAM; } - return 0; + return NRF_SUCCESS; } diff --git a/lib/bluetooth/ble_adv/ble_adv_data.c b/lib/bluetooth/ble_adv/ble_adv_data.c index d1e1a8e15a..3d98f62d4b 100644 --- a/lib/bluetooth/ble_adv/ble_adv_data.c +++ b/lib/bluetooth/ble_adv/ble_adv_data.c @@ -4,7 +4,7 @@ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause */ -#include +#include #include #include #include @@ -59,21 +59,21 @@ LOG_MODULE_REGISTER(ble_adv_data); -static int device_addr_encode(uint8_t *buf, uint16_t *offset, uint16_t max_size) +static uint32_t device_addr_encode(uint8_t *buf, uint16_t *offset, uint16_t max_size) { - int err; + uint32_t nrf_err; ble_gap_addr_t device_addr; /* Check for buffer overflow */ if (*offset + AD_TYPE_BLE_DEVICE_ADDR_SIZE > max_size) { - return -E2BIG; + return NRF_ERROR_DATA_SIZE; } /* Get BLE address */ - err = sd_ble_gap_addr_get(&device_addr); - if (err) { - LOG_ERR("Failed to get device GAP address, nrf_error %#x", err); - return -EINVAL; + nrf_err = sd_ble_gap_addr_get(&device_addr); + if (nrf_err) { + LOG_ERR("Failed to get device GAP address, nrf_error %#x", nrf_err); + return NRF_ERROR_INVALID_ADDR; } /* Encode BLE device address */ @@ -96,10 +96,10 @@ static int device_addr_encode(uint8_t *buf, uint16_t *offset, uint16_t max_size) return 0; } -static int device_name_encode(const struct ble_adv_data *ble_adv_data, uint8_t *data, - uint16_t *offset, uint16_t max_size) +static uint32_t device_name_encode(const struct ble_adv_data *ble_adv_data, uint8_t *data, + uint16_t *offset, uint16_t max_size) { - int err; + uint32_t nrf_err; uint16_t rem_adv_data_len; uint16_t actual_length; uint8_t adv_data_format; @@ -107,24 +107,24 @@ static int device_name_encode(const struct ble_adv_data *ble_adv_data, uint8_t * /* Validate parameters */ if ((ble_adv_data->name_type == BLE_ADV_DATA_SHORT_NAME) && (ble_adv_data->short_name_len == 0)) { - return -EINVAL; + return NRF_ERROR_INVALID_PARAM; } /* Check for buffer overflow */ if ((*offset + AD_DATA_OFFSET > max_size) || ((ble_adv_data->name_type == BLE_ADV_DATA_SHORT_NAME) && ((*offset + AD_DATA_OFFSET + ble_adv_data->short_name_len) > max_size))) { - return -E2BIG; + return NRF_ERROR_DATA_SIZE; } rem_adv_data_len = max_size - *offset - AD_DATA_OFFSET; actual_length = rem_adv_data_len; /* Get GAP device name and length */ - err = sd_ble_gap_device_name_get(&data[*offset + AD_DATA_OFFSET], &actual_length); - if (err) { - LOG_ERR("Failed to get device GAP name, nrf_error %#x", err); - return -EINVAL; + nrf_err = sd_ble_gap_device_name_get(&data[*offset + AD_DATA_OFFSET], &actual_length); + if (nrf_err) { + LOG_ERR("Failed to get device GAP name, nrf_error %#x", nrf_err); + return NRF_ERROR_INVALID_PARAM; } /* Check if device intend to use short name and it can fit available data size. @@ -157,7 +157,7 @@ static int device_name_encode(const struct ble_adv_data *ble_adv_data, uint8_t * * (actual_length + AD_TYPE_FIELD_SIZE) */ if (actual_length > (0x00FF - AD_TYPE_FIELD_SIZE)) { - return -E2BIG; + return NRF_ERROR_DATA_SIZE; } /* Complete name field in encoded data. */ @@ -171,21 +171,21 @@ static int device_name_encode(const struct ble_adv_data *ble_adv_data, uint8_t * return 0; } -static int appearance_encode(uint8_t *buf, uint16_t *offset, uint16_t max_size) +static uint32_t appearance_encode(uint8_t *buf, uint16_t *offset, uint16_t max_size) { - int err; + uint32_t nrf_err; uint16_t appearance; /* Check for buffer overflow */ if (*offset + AD_TYPE_APPEARANCE_SIZE > max_size) { - return -E2BIG; + return NRF_ERROR_DATA_SIZE; } /* Get GAP appearance field */ - err = sd_ble_gap_appearance_get(&appearance); - if (err) { - LOG_ERR("Failed to get GAP appearance, nrf_error %#x", err); - return -EINVAL; + nrf_err = sd_ble_gap_appearance_get(&appearance); + if (nrf_err) { + LOG_ERR("Failed to get GAP appearance, nrf_error %#x", nrf_err); + return NRF_ERROR_INVALID_ADDR; } /* Encode Length, AD Type and Appearance */ @@ -201,11 +201,11 @@ static int appearance_encode(uint8_t *buf, uint16_t *offset, uint16_t max_size) return 0; } -static int flags_encode(int8_t flags, uint8_t *buf, uint16_t *offset, uint16_t max_size) +static uint32_t flags_encode(int8_t flags, uint8_t *buf, uint16_t *offset, uint16_t max_size) { /* Check for buffer overflow */ if (*offset + AD_TYPE_FLAGS_SIZE > max_size) { - return -E2BIG; + return NRF_ERROR_DATA_SIZE; } /* Encode flags */ @@ -221,12 +221,12 @@ static int flags_encode(int8_t flags, uint8_t *buf, uint16_t *offset, uint16_t m return 0; } -static int tx_power_level_encode(int8_t tx_power_level, uint8_t *buf, uint16_t *offset, - uint16_t max_size) +static uint32_t tx_power_level_encode(int8_t tx_power_level, uint8_t *buf, uint16_t *offset, + uint16_t max_size) { /* Check for buffer overflow */ if (*offset + AD_TYPE_TX_POWER_LEVEL_SIZE > max_size) { - return -E2BIG; + return NRF_ERROR_DATA_SIZE; } /* Encode TX Power Level */ @@ -242,11 +242,11 @@ static int tx_power_level_encode(int8_t tx_power_level, uint8_t *buf, uint16_t * return 0; } -static int uuid_list_sized_encode(const struct ble_adv_data_uuid_list *list, uint8_t adv_type, - uint8_t uuid_size, uint8_t *buf, uint16_t *offset, - uint16_t max_size) +static uint32_t uuid_list_sized_encode(const struct ble_adv_data_uuid_list *list, uint8_t adv_type, + uint8_t uuid_size, uint8_t *buf, uint16_t *offset, + uint16_t max_size) { - int err; + uint32_t nrf_err; bool is_heading_written = false; uint16_t start_pos = *offset; uint16_t length; @@ -256,10 +256,10 @@ static int uuid_list_sized_encode(const struct ble_adv_data_uuid_list *list, uin ble_uuid_t uuid = list->uuid[i]; /* Find encoded uuid size */ - err = sd_ble_uuid_encode(&uuid, &encoded_size, NULL); - if (err) { - LOG_ERR("Failed to encode UUID, nrf_error %#x", err); - return -EINVAL; + nrf_err = sd_ble_uuid_encode(&uuid, &encoded_size, NULL); + if (nrf_err) { + LOG_ERR("Failed to encode UUID, nrf_error %#x", nrf_err); + return nrf_err; } /* Check size */ @@ -268,7 +268,7 @@ static int uuid_list_sized_encode(const struct ble_adv_data_uuid_list *list, uin /* Check for buffer overflow */ if ((*offset + encoded_size + heading_bytes) > max_size) { - return -E2BIG; + return NRF_ERROR_DATA_SIZE; } if (!is_heading_written) { @@ -280,10 +280,10 @@ static int uuid_list_sized_encode(const struct ble_adv_data_uuid_list *list, uin } /* Write UUID */ - err = sd_ble_uuid_encode(&uuid, &encoded_size, &buf[*offset]); - if (err) { - LOG_ERR("Failed to encode UUID, nrf_error %#x", err); - return -EINVAL; + nrf_err = sd_ble_uuid_encode(&uuid, &encoded_size, &buf[*offset]); + if (nrf_err) { + LOG_ERR("Failed to encode UUID, nrf_error %#x", nrf_err); + return nrf_err; } *offset += encoded_size; @@ -294,7 +294,7 @@ static int uuid_list_sized_encode(const struct ble_adv_data_uuid_list *list, uin /* The length field does not count itself. */ length = *offset - (start_pos + AD_LENGTH_FIELD_SIZE); if (length > 0x00FF) { - return -E2BIG; + return NRF_ERROR_DATA_SIZE; } buf[start_pos] = (uint8_t)length; } @@ -302,56 +302,57 @@ static int uuid_list_sized_encode(const struct ble_adv_data_uuid_list *list, uin return 0; } -static int uuid_list_encode(const struct ble_adv_data_uuid_list *list, uint8_t adv_type_16, - uint8_t adv_type_128, uint8_t *buf, uint16_t *offset, uint16_t max_size) +static uint32_t uuid_list_encode(const struct ble_adv_data_uuid_list *list, uint8_t adv_type_16, + uint8_t adv_type_128, uint8_t *buf, uint16_t *offset, + uint16_t max_size) { - int err; + uint32_t nrf_err; /* Encode 16 bit UUIDs */ - err = uuid_list_sized_encode(list, adv_type_16, UUID16_SIZE, buf, offset, max_size); - if (err) { - return err; + nrf_err = uuid_list_sized_encode(list, adv_type_16, UUID16_SIZE, buf, offset, max_size); + if (nrf_err) { + return nrf_err; } /* Encode 128 bit UUIDs */ - err = uuid_list_sized_encode(list, adv_type_128, UUID128_SIZE, buf, offset, max_size); - if (err) { - return err; + nrf_err = uuid_list_sized_encode(list, adv_type_128, UUID128_SIZE, buf, offset, max_size); + if (nrf_err) { + return nrf_err; } return 0; } -static int conn_int_check(const struct ble_adv_data_conn_int *conn_interval) +static uint32_t conn_int_check(const struct ble_adv_data_conn_int *conn_interval) { /* Check Minimum Connection Interval */ if ((conn_interval->min_conn_interval < 0x0006) || ((conn_interval->min_conn_interval > 0x0c80) && (conn_interval->min_conn_interval != 0xffff))) { - return -EINVAL; + return NRF_ERROR_INVALID_PARAM; } /* Check Maximum Connection Interval */ if ((conn_interval->max_conn_interval < 0x0006) || ((conn_interval->max_conn_interval > 0x0c80) && (conn_interval->max_conn_interval != 0xffff))) { - return -EINVAL; + return NRF_ERROR_INVALID_PARAM; } /* Check Minimum Connection Interval is smaller than Maximum Connection Interval */ if ((conn_interval->min_conn_interval != 0xffff) && (conn_interval->max_conn_interval != 0xffff) && (conn_interval->min_conn_interval > conn_interval->max_conn_interval)) { - return -EINVAL; + return NRF_ERROR_INVALID_PARAM; } return 0; } -static int conn_int_encode(const struct ble_adv_data_conn_int *conn_int, uint8_t *buf, - uint16_t *offset, uint16_t max_size) +static uint32_t conn_int_encode(const struct ble_adv_data_conn_int *conn_int, uint8_t *buf, + uint16_t *offset, uint16_t max_size) { - int err; + uint32_t nrf_err; /* Check for buffer overflow */ if (*offset + AD_TYPE_CONN_INT_SIZE > max_size) { @@ -359,9 +360,9 @@ static int conn_int_encode(const struct ble_adv_data_conn_int *conn_int, uint8_t } /* Check parameter */ - err = conn_int_check(conn_int); - if (err) { - return err; + nrf_err = conn_int_check(conn_int); + if (nrf_err) { + return nrf_err; } /* Encode Length and AD Type */ @@ -380,19 +381,19 @@ static int conn_int_encode(const struct ble_adv_data_conn_int *conn_int, uint8_t return 0; } -static int manuf_specific_data_encode(const struct ble_adv_data_manufacturer *manuf_data, uint8_t *buf, - uint16_t *offset, uint16_t max_size) +static uint32_t manuf_specific_data_encode(const struct ble_adv_data_manufacturer *manuf_data, + uint8_t *buf, uint16_t *offset, uint16_t max_size) { uint32_t data_size = AD_TYPE_MANUF_SPEC_DATA_ID_SIZE + manuf_data->len; /* Check for buffer overflow */ if ((*offset + AD_DATA_OFFSET + data_size) > max_size) { - return -E2BIG; + return NRF_ERROR_DATA_SIZE; } /* There is only 1 byte intended to encode length which is (data_size + AD_TYPE_FIELD_SIZE) */ if (data_size > (0x00FF - AD_TYPE_FIELD_SIZE)) { - return -E2BIG; + return NRF_ERROR_DATA_SIZE; } /* Encode Length and AD Type */ @@ -407,8 +408,8 @@ static int manuf_specific_data_encode(const struct ble_adv_data_manufacturer *ma /* Encode additional manufacturer specific data */ if (manuf_data->len > 0) { - if (manuf_data->data == NULL) { - return -EINVAL; + if (!manuf_data->data) { + return NRF_ERROR_NULL; } memcpy(&buf[*offset], manuf_data->data, manuf_data->len); *offset += manuf_data->len; @@ -418,15 +419,15 @@ static int manuf_specific_data_encode(const struct ble_adv_data_manufacturer *ma } /* Implemented only for 16-bit UUIDs */ -static int service_data_encode(const struct ble_adv_data *ble_adv_data, uint8_t *buf, - uint16_t *offset, uint16_t max_size) +static uint32_t service_data_encode(const struct ble_adv_data *ble_adv_data, uint8_t *buf, + uint16_t *offset, uint16_t max_size) { uint32_t data_size; struct ble_adv_data_service *service_data; /* Check parameter consistency */ - if (ble_adv_data->srv_list.service == NULL) { - return -EFAULT; + if (!ble_adv_data->srv_list.service) { + return NRF_ERROR_NULL; } for (uint8_t i = 0; i < ble_adv_data->srv_list.len; i++) { @@ -454,8 +455,8 @@ static int service_data_encode(const struct ble_adv_data *ble_adv_data, uint8_t /* Encode additional service data */ if (service_data->len > 0) { - if (service_data->data == NULL) { - return -EINVAL; + if (!service_data->data) { + return NRF_ERROR_NULL; } memcpy(&buf[*offset], service_data->data, service_data->len); *offset += service_data->len; @@ -465,103 +466,107 @@ static int service_data_encode(const struct ble_adv_data *ble_adv_data, uint8_t return 0; } -int ble_adv_data_encode(const struct ble_adv_data *ble_adv_data, uint8_t *buf, uint16_t *len) +uint32_t ble_adv_data_encode(const struct ble_adv_data *ble_adv_data, uint8_t *buf, uint16_t *len) { - int err; + uint32_t nrf_err; uint16_t max_size; - err = 0; + nrf_err = NRF_SUCCESS; max_size = *len; *len = 0; + if (!ble_adv_data || !buf || !len) { + return NRF_ERROR_NULL; + } + /* Encode LE Bluetooth Device Address */ if (ble_adv_data->include_ble_device_addr) { - err = device_addr_encode(buf, len, max_size); - if (err) { - return err; + nrf_err = device_addr_encode(buf, len, max_size); + if (nrf_err) { + return nrf_err; } } /* Encode appearance */ if (ble_adv_data->include_appearance) { - err = appearance_encode(buf, len, max_size); - if (err) { - return err; + nrf_err = appearance_encode(buf, len, max_size); + if (nrf_err) { + return nrf_err; } } /* Encode Flag */ if (ble_adv_data->flags != 0) { - err = flags_encode(ble_adv_data->flags, buf, len, max_size); - if (err) { - return err; + nrf_err = flags_encode(ble_adv_data->flags, buf, len, max_size); + if (nrf_err) { + return nrf_err; } } /* Encode TX power level */ if (ble_adv_data->tx_power_level != NULL) { - err = tx_power_level_encode(*ble_adv_data->tx_power_level, buf, len, max_size); - if (err) { - return err; + nrf_err = tx_power_level_encode(*ble_adv_data->tx_power_level, buf, len, max_size); + if (nrf_err) { + return nrf_err; } } /* Encode 'more available' uuid list */ if (ble_adv_data->uuid_lists.more_available.len > 0) { - err = uuid_list_encode(&ble_adv_data->uuid_lists.more_available, + nrf_err = uuid_list_encode(&ble_adv_data->uuid_lists.more_available, BLE_GAP_AD_TYPE_16BIT_SERVICE_UUID_MORE_AVAILABLE, BLE_GAP_AD_TYPE_128BIT_SERVICE_UUID_MORE_AVAILABLE, buf, len, max_size); - if (err) { - return err; + if (nrf_err) { + return nrf_err; } } /* Encode 'complete' uuid list */ if (ble_adv_data->uuid_lists.complete.len > 0) { - err = uuid_list_encode( + nrf_err = uuid_list_encode( &ble_adv_data->uuid_lists.complete, BLE_GAP_AD_TYPE_16BIT_SERVICE_UUID_COMPLETE, BLE_GAP_AD_TYPE_128BIT_SERVICE_UUID_COMPLETE, buf, len, max_size); - if (err) { - return err; + if (nrf_err) { + return nrf_err; } } /* Encode 'solicited service' uuid list */ if (ble_adv_data->uuid_lists.solicited.len > 0) { - err = uuid_list_encode(&ble_adv_data->uuid_lists.solicited, + nrf_err = uuid_list_encode(&ble_adv_data->uuid_lists.solicited, BLE_GAP_AD_TYPE_SOLICITED_SERVICE_UUIDS_16BIT, BLE_GAP_AD_TYPE_SOLICITED_SERVICE_UUIDS_128BIT, buf, len, max_size); - if (err) { - return err; + if (nrf_err) { + return nrf_err; } } /* Encode Slave Connection Interval Range */ if (ble_adv_data->slave_conn_int != NULL) { - err = conn_int_encode(ble_adv_data->slave_conn_int, buf, len, max_size); - if (err) { - return err; + nrf_err = conn_int_encode(ble_adv_data->slave_conn_int, buf, len, max_size); + if (nrf_err) { + return nrf_err; } } /* Encode Manufacturer Specific Data */ if (ble_adv_data->manufacturer_data != NULL) { - err = manuf_specific_data_encode(ble_adv_data->manufacturer_data, buf, len, + nrf_err = manuf_specific_data_encode(ble_adv_data->manufacturer_data, buf, len, max_size); - if (err) { - return err; + if (nrf_err) { + return nrf_err; } } /* Encode Service Data */ if (ble_adv_data->srv_list.len > 0) { - err = service_data_encode(ble_adv_data, buf, len, max_size); - if (err) { - return err; + nrf_err = service_data_encode(ble_adv_data, buf, len, max_size); + if (nrf_err) { + return nrf_err; } } /* Encode name. It is encoded last on purpose since too long device name is truncated */ if (ble_adv_data->name_type != BLE_ADV_DATA_NO_NAME) { - err = device_name_encode(ble_adv_data, buf, len, max_size); - if (err) { - return err; + nrf_err = device_name_encode(ble_adv_data, buf, len, max_size); + if (nrf_err) { + return nrf_err; } } - return err; + return nrf_err; } uint16_t ble_adv_data_search(const uint8_t *data, uint16_t data_len, uint16_t *offset, @@ -668,7 +673,7 @@ bool ble_adv_data_short_name_find(const uint8_t *data, uint16_t data_len, const bool ble_adv_data_uuid_find(const uint8_t *data, uint16_t data_len, const ble_uuid_t *uuid) { - int err; + uint32_t nrf_err; uint16_t data_offset; uint8_t raw_uuid_len; uint16_t parsed_uuid_len = data_len; @@ -679,8 +684,8 @@ bool ble_adv_data_uuid_find(const uint8_t *data, uint16_t data_len, const ble_uu return false; } - err = sd_ble_uuid_encode(uuid, &raw_uuid_len, raw_uuid); - if (err) { + nrf_err = sd_ble_uuid_encode(uuid, &raw_uuid_len, raw_uuid); + if (nrf_err != NRF_SUCCESS) { /* Invalid encoded data or target UUID */ return false; } diff --git a/samples/bluetooth/ble_cgms/src/main.c b/samples/bluetooth/ble_cgms/src/main.c index e1c2b7d692..2f68099199 100644 --- a/samples/bluetooth/ble_cgms/src/main.c +++ b/samples/bluetooth/ble_cgms/src/main.c @@ -521,8 +521,8 @@ static void ble_adv_evt_handler(struct ble_adv *adv, const struct ble_adv_evt *a { switch (adv_evt->evt_type) { case BLE_ADV_EVT_ERROR: - LOG_ERR("BLE advertising error, %d", adv_evt->error.reason); - __ASSERT(false, "BLE advertising error %d", adv_evt->error.reason); + LOG_ERR("BLE advertising error, %#x", adv_evt->error.reason); + __ASSERT(false, "BLE advertising error %#x", adv_evt->error.reason); break; case BLE_ADV_EVT_DIRECTED_HIGH_DUTY: led_indication_set(LED_INDICATE_ADVERTISING_DIRECTED); @@ -614,9 +614,9 @@ static void button_handler(uint8_t pin, uint8_t action) } /** @brief Function for initializing the Advertising functionality. */ -static int advertising_init(void) +static uint32_t advertising_init(void) { - int err; + uint32_t err; uint8_t adv_flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE; ble_uuid_t adv_uuid_list[] = { { .uuid = BLE_UUID_CGM_SERVICE, .type = BLE_UUID_TYPE_BLE }, @@ -637,8 +637,8 @@ static int advertising_init(void) }; err = ble_adv_init(&ble_adv, &config); - if (err) { - LOG_ERR("BLE advertising init failed, err %d", err); + if (err != NRF_SUCCESS) { + LOG_ERR("BLE advertising init failed, nrf_error %#x", err); return err; } @@ -713,6 +713,7 @@ static int buttons_leds_init(bool *erase_bonds) int main(void) { int err; + uint32_t nrf_err; bool erase_bonds; err = timers_init(); @@ -731,8 +732,8 @@ int main(void) if (err) { goto idle; } - err = advertising_init(); - if (err) { + nrf_err = advertising_init(); + if (nrf_err) { goto idle; } err = services_init(); @@ -753,9 +754,9 @@ int main(void) goto idle; } - err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); - if (err) { - LOG_ERR("Failed to start advertising, err %d", err); + nrf_err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); + if (nrf_err) { + LOG_ERR("Failed to start advertising, nrf_error %#x", nrf_err); goto idle; } diff --git a/samples/bluetooth/ble_hids_keyboard/src/main.c b/samples/bluetooth/ble_hids_keyboard/src/main.c index d6e34e9e69..2fea29a243 100644 --- a/samples/bluetooth/ble_hids_keyboard/src/main.c +++ b/samples/bluetooth/ble_hids_keyboard/src/main.c @@ -246,7 +246,7 @@ NRF_SDH_BLE_OBSERVER(sdh_ble, on_ble_evt, NULL, 0); static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_evt *evt) { - uint32_t err; + uint32_t nrf_err; ble_gap_addr_t *peer_addr; ble_gap_addr_t whitelist_addrs[BLE_GAP_WHITELIST_ADDR_MAX_COUNT]; ble_gap_irk_t whitelist_irks[BLE_GAP_WHITELIST_ADDR_MAX_COUNT]; @@ -255,7 +255,7 @@ static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_ev switch (evt->evt_type) { case BLE_ADV_EVT_ERROR: - LOG_ERR("Advertising error %d", evt->error.reason); + LOG_ERR("Advertising error %#x", evt->error.reason); break; case BLE_ADV_EVT_DIRECTED_HIGH_DUTY: case BLE_ADV_EVT_DIRECTED: @@ -269,10 +269,10 @@ static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_ev nrf_gpio_pin_write(BOARD_PIN_LED_0, !BOARD_LED_ACTIVE_STATE); break; case BLE_ADV_EVT_WHITELIST_REQUEST: - err = pm_whitelist_get(whitelist_addrs, &addr_cnt, + nrf_err = pm_whitelist_get(whitelist_addrs, &addr_cnt, whitelist_irks, &irk_cnt); - if (err) { - LOG_ERR("Failed to get whitelist, nrf_error %#x", err); + if (nrf_err) { + LOG_ERR("Failed to get whitelist, nrf_error %#x", nrf_err); } LOG_DBG("pm_whitelist_get returns %d addr in whitelist and %d irk whitelist", addr_cnt, irk_cnt); @@ -282,10 +282,10 @@ static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_ev */ identities_set(PM_PEER_ID_LIST_SKIP_NO_IRK); - err = ble_adv_whitelist_reply(ble_adv, whitelist_addrs, addr_cnt, whitelist_irks, - irk_cnt); - if (err) { - LOG_ERR("Failed to set whitelist, nrf_error %#x", err); + nrf_err = ble_adv_whitelist_reply(ble_adv, whitelist_addrs, addr_cnt, + whitelist_irks, irk_cnt); + if (nrf_err) { + LOG_ERR("Failed to set whitelist, nrf_error %#x", nrf_err); } break; @@ -294,10 +294,11 @@ static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_ev /* Only Give peer address if we have a handle to the bonded peer. */ if (peer_id != PM_PEER_ID_INVALID) { - err = pm_peer_data_bonding_load(peer_id, &peer_bonding_data); - if (err != NRF_ERROR_NOT_FOUND) { - if (err) { - LOG_ERR("Failed to load bonding data, nrf_error %#x", err); + nrf_err = pm_peer_data_bonding_load(peer_id, &peer_bonding_data); + if (nrf_err != NRF_ERROR_NOT_FOUND) { + if (nrf_err) { + LOG_ERR("Failed to load bonding data, nrf_error %#x", + nrf_err); } /* Manipulate identities to exclude peers with no @@ -306,9 +307,10 @@ static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_ev identities_set(PM_PEER_ID_LIST_SKIP_ALL); peer_addr = &(peer_bonding_data.peer_ble_id.id_addr_info); - err = ble_adv_peer_addr_reply(ble_adv, peer_addr); - if (err) { - LOG_ERR("Failed to reply peer address, nrf_error %#x", err); + nrf_err = ble_adv_peer_addr_reply(ble_adv, peer_addr); + if (nrf_err) { + LOG_ERR("Failed to reply peer address, nrf_error %#x", + nrf_err); } } } @@ -714,20 +716,20 @@ static void delete_bonds(void) static int advertising_start(bool erase_bonds) { - int err = 0; + uint32_t nrf_err = 0; if (erase_bonds) { delete_bonds(); } else { whitelist_set(PM_PEER_ID_LIST_SKIP_NO_ID_ADDR); - err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); - if (err) { - LOG_ERR("Failed to start advertising, err %d", err); + nrf_err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); + if (nrf_err) { + LOG_ERR("Failed to start advertising, nrf_error %#x", nrf_err); } } - return err; + return nrf_err; } static void pm_evt_handler(pm_evt_t const *evt) @@ -980,9 +982,9 @@ int main(void) goto idle; } - err = ble_adv_init(&ble_adv, &ble_adv_cfg); - if (err) { - LOG_ERR("Failed to initialize BLE advertising, err %d", err); + nrf_err = ble_adv_init(&ble_adv, &ble_adv_cfg); + if (nrf_err) { + LOG_ERR("Failed to initialize BLE advertising, nrf_error %#x", nrf_err); goto idle; } diff --git a/samples/bluetooth/ble_hids_mouse/src/main.c b/samples/bluetooth/ble_hids_mouse/src/main.c index ec0f086d2d..e5f3ec96fb 100644 --- a/samples/bluetooth/ble_hids_mouse/src/main.c +++ b/samples/bluetooth/ble_hids_mouse/src/main.c @@ -171,7 +171,7 @@ NRF_SDH_BLE_OBSERVER(sdh_ble, on_ble_evt, NULL, 0); static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_evt *evt) { - uint32_t err; + uint32_t nrf_err; ble_gap_addr_t *peer_addr; pm_peer_data_bonding_t peer_bonding_data; ble_gap_addr_t whitelist_addrs[BLE_GAP_WHITELIST_ADDR_MAX_COUNT]; @@ -181,7 +181,7 @@ static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_ev switch (evt->evt_type) { case BLE_ADV_EVT_ERROR: - LOG_ERR("Advertising error %d", evt->error.reason); + LOG_ERR("Advertising error %#x", evt->error.reason); break; case BLE_ADV_EVT_DIRECTED_HIGH_DUTY: case BLE_ADV_EVT_DIRECTED: @@ -195,9 +195,9 @@ static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_ev nrf_gpio_pin_write(BOARD_PIN_LED_0, !BOARD_LED_ACTIVE_STATE); break; case BLE_ADV_EVT_WHITELIST_REQUEST: - err = pm_whitelist_get(whitelist_addrs, &addr_cnt, whitelist_irks, &irk_cnt); - if (err) { - LOG_ERR("Failed to get whitelist, nrf_error %#x", err); + nrf_err = pm_whitelist_get(whitelist_addrs, &addr_cnt, whitelist_irks, &irk_cnt); + if (nrf_err) { + LOG_ERR("Failed to get whitelist, nrf_error %#x", nrf_err); } LOG_DBG("pm_whitelist_get returns %d addr in whitelist and %d irk whitelist", addr_cnt, irk_cnt); @@ -207,20 +207,21 @@ static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_ev */ identities_set(PM_PEER_ID_LIST_SKIP_NO_IRK); - err = ble_adv_whitelist_reply(ble_adv, whitelist_addrs, addr_cnt, whitelist_irks, - irk_cnt); - if (err) { - LOG_ERR("Failed to set whitelist, nrf_error %#x", err); + nrf_err = ble_adv_whitelist_reply(ble_adv, whitelist_addrs, addr_cnt, + whitelist_irks, irk_cnt); + if (nrf_err) { + LOG_ERR("Failed to set whitelist, nrf_error %#x", nrf_err); } break; case BLE_ADV_EVT_PEER_ADDR_REQUEST: /* Only Give peer address if we have a handle to the bonded peer. */ if (peer_id != PM_PEER_ID_INVALID) { - err = pm_peer_data_bonding_load(peer_id, &peer_bonding_data); - if (err != NRF_ERROR_NOT_FOUND) { - if (err) { - LOG_ERR("Failed to load bonding data, nrf_error %#x", err); + nrf_err = pm_peer_data_bonding_load(peer_id, &peer_bonding_data); + if (nrf_err != NRF_ERROR_NOT_FOUND) { + if (nrf_err) { + LOG_ERR("Failed to load bonding data, nrf_error %#x", + nrf_err); } /* Manipulate identities to exclude peers with no @@ -229,9 +230,10 @@ static void ble_adv_evt_handler(struct ble_adv *ble_adv, const struct ble_adv_ev identities_set(PM_PEER_ID_LIST_SKIP_ALL); peer_addr = &(peer_bonding_data.peer_ble_id.id_addr_info); - err = ble_adv_peer_addr_reply(ble_adv, peer_addr); - if (err) { - LOG_ERR("Failed to reply peer address, nrf_error %#x", err); + nrf_err = ble_adv_peer_addr_reply(ble_adv, peer_addr); + if (nrf_err) { + LOG_ERR("Failed to reply peer address, nrf_error %#x", + nrf_err); } } } @@ -565,20 +567,20 @@ static void delete_bonds(void) static uint32_t advertising_start(bool erase_bonds) { - int err = NRF_SUCCESS; + int nrf_err = NRF_SUCCESS; if (erase_bonds) { delete_bonds(); } else { whitelist_set(PM_PEER_ID_LIST_SKIP_NO_ID_ADDR); - err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); - if (err) { - LOG_ERR("Failed to start advertising, err %d", err); + nrf_err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); + if (nrf_err) { + LOG_ERR("Failed to start advertising, nrf_error %#x", nrf_err); } } - return err; + return nrf_err; } static void pm_evt_handler(pm_evt_t const *evt) @@ -822,9 +824,9 @@ int main(void) LOG_INF("HIDS initialized"); - err = ble_adv_init(&ble_adv, &ble_adv_cfg); - if (err) { - LOG_ERR("Failed to initialize BLE advertising, err %d", err); + nrf_err = ble_adv_init(&ble_adv, &ble_adv_cfg); + if (nrf_err) { + LOG_ERR("Failed to initialize BLE advertising, nrf_error %#x", nrf_err); goto idle; } diff --git a/samples/bluetooth/ble_hrs/src/main.c b/samples/bluetooth/ble_hrs/src/main.c index f73d0293d0..c5b00ce998 100644 --- a/samples/bluetooth/ble_hrs/src/main.c +++ b/samples/bluetooth/ble_hrs/src/main.c @@ -282,7 +282,7 @@ static void ble_adv_evt_handler(struct ble_adv *adv, const struct ble_adv_evt *a { switch (adv_evt->evt_type) { case BLE_ADV_EVT_ERROR: - LOG_ERR("Advertising error %d", adv_evt->error.reason); + LOG_ERR("Advertising error %#x", adv_evt->error.reason); break; default: break; @@ -364,14 +364,14 @@ static void delete_bonds(void) static void advertising_start(bool erase_bonds) { - int err; + int nrf_err; if (erase_bonds) { delete_bonds(); } else { - err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); - if (err) { - LOG_ERR("Failed to start advertising, err %d", err); + nrf_err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); + if (nrf_err) { + LOG_ERR("Failed to start advertising, nrf_error %#x", nrf_err); } else { LOG_INF("Advertising as %s", CONFIG_BLE_ADV_NAME); } @@ -439,6 +439,7 @@ static int peer_manager_init(void) int main(void) { int err; + uint32_t nrf_err; bool erase_bonds = false; uint8_t body_sensor_location = BLE_HRS_BODY_SENSOR_LOCATION_FINGER; ble_uuid_t adv_uuid_list[] = { @@ -533,9 +534,9 @@ int main(void) goto idle; } - err = ble_adv_init(&ble_adv, &ble_adv_cfg); - if (err) { - LOG_ERR("Failed to initialize advertising, err %d", err); + nrf_err = ble_adv_init(&ble_adv, &ble_adv_cfg); + if (nrf_err) { + LOG_ERR("Failed to initialize advertising, nrf_error %#x", nrf_err); goto idle; } diff --git a/samples/bluetooth/ble_lbs/src/main.c b/samples/bluetooth/ble_lbs/src/main.c index 6a8a7cfc4b..9cb19d8c57 100644 --- a/samples/bluetooth/ble_lbs/src/main.c +++ b/samples/bluetooth/ble_lbs/src/main.c @@ -78,7 +78,7 @@ static void ble_adv_evt_handler(struct ble_adv *adv, const struct ble_adv_evt *a { switch (adv_evt->evt_type) { case BLE_ADV_EVT_ERROR: - LOG_ERR("Advertising error %d", adv_evt->error.reason); + LOG_ERR("Advertising error %#x", adv_evt->error.reason); break; default: break; @@ -127,6 +127,7 @@ static void lbs_evt_handler(struct ble_lbs *lbs, const struct ble_lbs_evt *lbs_e int main(void) { int err; + uint32_t nrf_err; struct ble_adv_config ble_adv_config = { .conn_cfg_tag = CONFIG_NRF_SDH_BLE_CONN_TAG, .evt_handler = ble_adv_evt_handler, @@ -200,15 +201,15 @@ int main(void) LOG_INF("Services initialized"); - err = ble_adv_init(&ble_adv, &ble_adv_config); - if (err) { - LOG_ERR("Failed to initialize BLE advertising, err %d", err); + nrf_err = ble_adv_init(&ble_adv, &ble_adv_config); + if (nrf_err) { + LOG_ERR("Failed to initialize BLE advertising, nrf_err %#x", nrf_err); goto idle; } - err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); - if (err) { - LOG_ERR("Failed to start advertising, err %d", err); + nrf_err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); + if (nrf_err) { + LOG_ERR("Failed to start advertising, nrf_error %#x", nrf_err); goto idle; } diff --git a/samples/bluetooth/ble_nus/src/main.c b/samples/bluetooth/ble_nus/src/main.c index ce2166c2f9..5f2f4f3aaa 100644 --- a/samples/bluetooth/ble_nus/src/main.c +++ b/samples/bluetooth/ble_nus/src/main.c @@ -284,7 +284,7 @@ static void ble_adv_evt_handler(struct ble_adv *adv, const struct ble_adv_evt *a { switch (adv_evt->evt_type) { case BLE_ADV_EVT_ERROR: - LOG_ERR("Advertising error %d", adv_evt->error.reason); + LOG_ERR("Advertising error %#x", adv_evt->error.reason); break; default: break; @@ -418,6 +418,7 @@ static int uarte_init(void) int main(void) { int err; + uint32_t nrf_err; struct ble_adv_config ble_adv_cfg = { .conn_cfg_tag = CONFIG_NRF_SDH_BLE_CONN_TAG, .evt_handler = ble_adv_evt_handler, @@ -486,9 +487,9 @@ int main(void) goto idle; } - err = ble_adv_init(&ble_adv, &ble_adv_cfg); - if (err) { - LOG_ERR("Failed to initialize advertising, err %d", err); + nrf_err = ble_adv_init(&ble_adv, &ble_adv_cfg); + if (nrf_err) { + LOG_ERR("Failed to initialize advertising, nrf_error %#x", nrf_err); goto idle; } @@ -512,9 +513,9 @@ int main(void) } #endif - err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); - if (err) { - LOG_ERR("Failed to start advertising, err %d", err); + nrf_err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); + if (nrf_err) { + LOG_ERR("Failed to start advertising, nrf_error %#x", nrf_err); goto idle; } diff --git a/samples/boot/mcuboot_recovery_entry/src/main.c b/samples/boot/mcuboot_recovery_entry/src/main.c index 3aae267f42..41beec99ac 100644 --- a/samples/boot/mcuboot_recovery_entry/src/main.c +++ b/samples/boot/mcuboot_recovery_entry/src/main.c @@ -125,7 +125,7 @@ static void ble_adv_evt_handler(struct ble_adv *adv, const struct ble_adv_evt *a { switch (adv_evt->evt_type) { case BLE_ADV_EVT_ERROR: - LOG_ERR("Advertising error: %d", adv_evt->error.reason); + LOG_ERR("Advertising error: %#x", adv_evt->error.reason); break; default: break; @@ -152,6 +152,7 @@ static enum mgmt_cb_return os_mgmt_reboot_hook(uint32_t event, enum mgmt_cb_retu int main(void) { int err; + uint32_t nrf_err; struct ble_adv_config ble_adv_cfg = { .conn_cfg_tag = CONFIG_NRF_SDH_BLE_CONN_TAG, .evt_handler = ble_adv_evt_handler, @@ -196,17 +197,17 @@ int main(void) ble_adv_cfg.sr_data.uuid_lists.complete.uuid = &adv_uuid_list[0]; ble_adv_cfg.sr_data.uuid_lists.complete.len = ARRAY_SIZE(adv_uuid_list); - err = ble_adv_init(&ble_adv, &ble_adv_cfg); + nrf_err = ble_adv_init(&ble_adv, &ble_adv_cfg); - if (err) { - LOG_ERR("Failed to initialize advertising: %d", err); + if (nrf_err) { + LOG_ERR("Failed to initialize advertising, nrf_error %#x", nrf_err); return 0; } - err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); + nrf_err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST); - if (err) { - LOG_ERR("Failed to start advertising: %d", err); + if (nrf_err) { + LOG_ERR("Failed to start advertising, nrf_error %#x", nrf_err); return 0; } diff --git a/tests/lib/bluetooth/ble_adv/src/unity_test.c b/tests/lib/bluetooth/ble_adv/src/unity_test.c index 39c0748fc5..ca9cd795a9 100644 --- a/tests/lib/bluetooth/ble_adv/src/unity_test.c +++ b/tests/lib/bluetooth/ble_adv/src/unity_test.c @@ -4,7 +4,7 @@ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause */ -#include +#include #include #include #include @@ -30,7 +30,7 @@ void test_ble_adv_conn_cfg_tag_set(void) int ret; ret = ble_adv_conn_cfg_tag_set(NULL, conn_cfg_tag); - TEST_ASSERT_EQUAL(-EFAULT, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_NULL, ret); ret = ble_adv_conn_cfg_tag_set(&ble_adv, conn_cfg_tag); TEST_ASSERT_EQUAL(0, ret); @@ -38,7 +38,7 @@ void test_ble_adv_conn_cfg_tag_set(void) TEST_ASSERT_EQUAL(conn_cfg_tag, ble_adv.conn_cfg_tag); } -void test_ble_adv_init_efault(void) +void test_ble_adv_init_error_null(void) { struct ble_adv ble_adv; struct ble_adv_config config = { @@ -48,15 +48,15 @@ void test_ble_adv_init_efault(void) int ret; ret = ble_adv_init(NULL, &config); - TEST_ASSERT_EQUAL(-EFAULT, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_NULL, ret); ret = ble_adv_init(&ble_adv, NULL); - TEST_ASSERT_EQUAL(-EFAULT, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_NULL, ret); config.evt_handler = NULL; ret = ble_adv_init(&ble_adv, &config); - TEST_ASSERT_EQUAL(-EFAULT, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_NULL, ret); } -void test_ble_adv_init_einval(void) +void test_ble_adv_init_error_invalid_param(void) { struct ble_adv ble_adv = { .adv_handle = BLE_GAP_ADV_SET_HANDLE_NOT_SET, @@ -74,7 +74,7 @@ void test_ble_adv_init_einval(void) __cmock_sd_ble_gap_device_name_set_ExpectAndReturn(&sec_mode, CONFIG_BLE_ADV_NAME, strlen(CONFIG_BLE_ADV_NAME), NRF_ERROR_INVALID_ADDR); ret = ble_adv_init(&ble_adv, &config); - TEST_ASSERT_EQUAL(-EINVAL, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_INVALID_PARAM, ret); /* Simulate an error in setting the adv config */ __cmock_sd_ble_gap_device_name_set_ExpectAndReturn(&sec_mode, CONFIG_BLE_ADV_NAME, @@ -82,7 +82,7 @@ void test_ble_adv_init_einval(void) __cmock_sd_ble_gap_adv_set_configure_ExpectAndReturn(&ble_adv.adv_handle, NULL, &ble_adv.adv_params, NRF_ERROR_INVALID_ADDR); ret = ble_adv_init(&ble_adv, &config); - TEST_ASSERT_EQUAL(-EINVAL, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_INVALID_PARAM, ret); } void test_ble_adv_init(void) @@ -126,13 +126,13 @@ void test_ble_adv_peer_addr_reply(void) int ret; ret = ble_adv_peer_addr_reply(NULL, &peer_addr); - TEST_ASSERT_EQUAL(-EFAULT, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_NULL, ret); ret = ble_adv_peer_addr_reply(&ble_adv, NULL); - TEST_ASSERT_EQUAL(-EFAULT, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_NULL, ret); ret = ble_adv_peer_addr_reply(&ble_adv, &peer_addr); - TEST_ASSERT_EQUAL(-EINVAL, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_INVALID_PARAM, ret); peer_addr = (ble_gap_addr_t){ .addr_id_peer = 0, @@ -157,14 +157,14 @@ void test_ble_adv_whitelist_reply(void) const ble_gap_irk_t irks = {0}; ret = ble_adv_whitelist_reply(NULL, &addrs, 0, &irks, 0); - TEST_ASSERT_EQUAL(-EFAULT, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_NULL, ret); ret = ble_adv_whitelist_reply(&ble_adv_config, &addrs, 0, &irks, 0); - TEST_ASSERT_EQUAL(-EPERM, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_INVALID_STATE, ret); ble_adv_config.whitelist_reply_expected = NULL; ret = ble_adv_whitelist_reply(&ble_adv_config, NULL, 0, NULL, 0); - TEST_ASSERT_EQUAL(-EPERM, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_INVALID_STATE, ret); ble_adv_config.whitelist_reply_expected = true; ret = ble_adv_whitelist_reply(&ble_adv_config, &addrs, 0, &irks, 0); @@ -259,12 +259,12 @@ void test_ble_adv_start_einval(void) __cmock_sd_ble_gap_adv_set_configure_IgnoreAndReturn(NRF_ERROR_INVALID_PARAM); ret = ble_adv_start(&ble_adv, BLE_ADV_MODE_SLOW); - TEST_ASSERT_EQUAL(-EINVAL, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_INVALID_PARAM, ret); __cmock_sd_ble_gap_adv_set_configure_IgnoreAndReturn(NRF_SUCCESS); __cmock_sd_ble_gap_adv_start_IgnoreAndReturn(NRF_ERROR_INVALID_STATE); ret = ble_adv_start(&ble_adv, BLE_ADV_MODE_SLOW); - TEST_ASSERT_EQUAL(-EINVAL, ret); + TEST_ASSERT_EQUAL(NRF_ERROR_INVALID_PARAM, ret); } void setUp(void)