xiaozhengsheng/HL-PDJ-1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始版本

Browse Source
This commit is contained in:
xiaozhengsheng
2025-08-19 09:49:41 +08:00
parent 10f1ddf1c1
commit 6df0f7d96e
2974 changed files with 1712873 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

323
components/ble/ble_services/ble_dfu/ble_dfu.c Normal file
View File

@@ -0,0 +1,323 @@
/**
* Copyright (c) 2017 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/* Attention!
* To maintain compliance with Nordic Semiconductor ASA's Bluetooth profile
* qualification listings, this section of source code must not be modified.
*/
#include "ble_dfu.h"
#include <string.h>
#include "ble_hci.h"
#include "sdk_macros.h"
#include "ble_srv_common.h"
#include "nrf_nvic.h"
#include "nrf_sdm.h"
#include "nrf_soc.h"
#include "nrf_log.h"
#include "nrf_dfu_ble_svci_bond_sharing.h"
#include "nrf_bootloader_info.h"
#include "nrf_svci_async_function.h"
#include "nrf_pwr_mgmt.h"
#include "peer_manager.h"
#include "gatts_cache_manager.h"
#include "peer_id.h"
#define MAX_CTRL_POINT_RESP_PARAM_LEN 3 /**< Max length of the responses. */
#define BLE_DFU_SERVICE_UUID 0xFE59 /**< The 16-bit UUID of the Secure DFU Service. */
static ble_dfu_buttonless_t m_dfu; /**< Structure holding information about the Buttonless Secure DFU Service. */
NRF_SDH_BLE_OBSERVER(m_dfus_obs, BLE_DFU_BLE_OBSERVER_PRIO, ble_dfu_buttonless_on_ble_evt, &m_dfu);
/**@brief Function that is called if no event handler is provided.
*/
static void dummy_evt_handler(ble_dfu_buttonless_evt_type_t evt)
{
NRF_LOG_DEBUG("Dummy event handler received event 0x%x", evt);
}
/**@brief Function for handling write events to the Buttonless Secure DFU Service Service Control Point characteristic.
*
* @param[in] p_evt_write Write event received from the BLE stack.
*/
static void on_ctrlpt_write(ble_gatts_evt_write_t const * p_evt_write)
{
uint32_t err_code;
ble_gatts_rw_authorize_reply_params_t write_authorize_reply;
memset(&write_authorize_reply, 0, sizeof(write_authorize_reply));
write_authorize_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE;
uint8_t cccd_val[2];
ble_gatts_value_t value = {.p_value = cccd_val, .len = 2, .offset = 0};
err_code = sd_ble_gatts_value_get(m_dfu.conn_handle, m_dfu.control_point_char.cccd_handle, &value);
if (err_code == NRF_SUCCESS && ble_srv_is_indication_enabled(cccd_val))
{
write_authorize_reply.params.write.update = 1;
write_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_SUCCESS;
}
else
{
write_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_ATTERR_CPS_CCCD_CONFIG_ERROR;
}
// Authorize the write request
do {
err_code = sd_ble_gatts_rw_authorize_reply(m_dfu.conn_handle, &write_authorize_reply);
} while (err_code == NRF_ERROR_BUSY);
if (write_authorize_reply.params.write.gatt_status != BLE_GATT_STATUS_SUCCESS)
{
return;
}
// Forward the write event to the Buttonless DFU module.
ble_dfu_buttonless_on_ctrl_pt_write(p_evt_write);
}
/**@brief Write authorization request event handler.
*
* @details The write authorization request event handler is called when writing to the control point.
*
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_rw_authorize_req(ble_evt_t const * p_ble_evt)
{
if (p_ble_evt->evt.gatts_evt.conn_handle != m_dfu.conn_handle)
{
return;
}
const ble_gatts_evt_rw_authorize_request_t * p_auth_req =
&p_ble_evt->evt.gatts_evt.params.authorize_request;
if (
(p_auth_req->type == BLE_GATTS_AUTHORIZE_TYPE_WRITE) &&
(p_auth_req->request.write.handle == m_dfu.control_point_char.value_handle) &&
(p_auth_req->request.write.op != BLE_GATTS_OP_PREP_WRITE_REQ) &&
(p_auth_req->request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) &&
(p_auth_req->request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL)
)
{
on_ctrlpt_write(&p_auth_req->request.write);
}
}
/**@brief Connect event handler.
*
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_connect(ble_evt_t const * p_ble_evt)
{
m_dfu.conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
}
/**@brief Disconnect event handler.
*
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_disconnect(ble_evt_t const * p_ble_evt)
{
if (m_dfu.conn_handle != p_ble_evt->evt.gap_evt.conn_handle)
{
return;
}
m_dfu.conn_handle = BLE_CONN_HANDLE_INVALID;
}
/**@brief Function for handling the HVC events.
*
* @details Handles HVC events from the BLE stack.
*
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_hvc(ble_evt_t const * p_ble_evt)
{
uint32_t err_code;
ble_gatts_evt_hvc_t const * p_hvc = &p_ble_evt->evt.gatts_evt.params.hvc;
if (p_hvc->handle == m_dfu.control_point_char.value_handle)
{
// Enter bootloader if we were waiting for reset after hvc indication confimation.
if (m_dfu.is_waiting_for_reset)
{
err_code = ble_dfu_buttonless_bootloader_start_prepare();
if (err_code != NRF_SUCCESS)
{
m_dfu.evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
}
}
void ble_dfu_buttonless_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context)
{
VERIFY_PARAM_NOT_NULL_VOID(p_ble_evt);
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_ble_evt);
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
on_rw_authorize_req(p_ble_evt);
break;
case BLE_GATTS_EVT_HVC:
on_hvc(p_ble_evt);
break;
default:
// no implementation
break;
}
}
uint32_t ble_dfu_buttonless_resp_send(ble_dfu_buttonless_op_code_t op_code, ble_dfu_buttonless_rsp_code_t rsp_code)
{
// Send indication
uint32_t err_code;
const uint16_t len = MAX_CTRL_POINT_RESP_PARAM_LEN;
uint16_t hvx_len;
uint8_t hvx_data[MAX_CTRL_POINT_RESP_PARAM_LEN];
ble_gatts_hvx_params_t hvx_params;
memset(&hvx_params, 0, sizeof(hvx_params));
hvx_len = len;
hvx_data[0] = DFU_OP_RESPONSE_CODE;
hvx_data[1] = (uint8_t)op_code;
hvx_data[2] = (uint8_t)rsp_code;
hvx_params.handle = m_dfu.control_point_char.value_handle;
hvx_params.type = BLE_GATT_HVX_INDICATION;
hvx_params.offset = 0;
hvx_params.p_len = &hvx_len;
hvx_params.p_data = hvx_data;
err_code = sd_ble_gatts_hvx(m_dfu.conn_handle, &hvx_params);
if ((err_code == NRF_SUCCESS) && (hvx_len != len))
{
err_code = NRF_ERROR_DATA_SIZE;
}
return err_code;
}
uint32_t ble_dfu_buttonless_bootloader_start_finalize(void)
{
uint32_t err_code;
NRF_LOG_DEBUG("In ble_dfu_buttonless_bootloader_start_finalize\r\n");
err_code = sd_power_gpregret_clr(0, 0xffffffff);
VERIFY_SUCCESS(err_code);
err_code = sd_power_gpregret_set(0, BOOTLOADER_DFU_START);
VERIFY_SUCCESS(err_code);
// Indicate that the Secure DFU bootloader will be entered
m_dfu.evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER);
// Signal that DFU mode is to be enter to the power management module
nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_DFU);
return NRF_SUCCESS;
}
uint32_t ble_dfu_buttonless_init(const ble_dfu_buttonless_init_t * p_dfu_init)
{
uint32_t err_code;
ble_uuid_t service_uuid;
ble_uuid128_t nordic_base_uuid = BLE_NORDIC_VENDOR_BASE_UUID;
VERIFY_PARAM_NOT_NULL(p_dfu_init);
// Initialize the service structure.
m_dfu.conn_handle = BLE_CONN_HANDLE_INVALID;
m_dfu.evt_handler = p_dfu_init->evt_handler;
m_dfu.is_waiting_for_reset = false;
if (m_dfu.evt_handler == NULL)
{
m_dfu.evt_handler = dummy_evt_handler;
}
err_code = ble_dfu_buttonless_backend_init(&m_dfu);
VERIFY_SUCCESS(err_code);
BLE_UUID_BLE_ASSIGN(service_uuid, BLE_DFU_SERVICE_UUID);
// Add the DFU service declaration.
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&service_uuid,
&(m_dfu.service_handle));
VERIFY_SUCCESS(err_code);
// Add vendor specific base UUID to use with the Buttonless DFU characteristic.
err_code = sd_ble_uuid_vs_add(&nordic_base_uuid, &m_dfu.uuid_type);
VERIFY_SUCCESS(err_code);
// Add the Buttonless DFU Characteristic (with bonds/without bonds).
err_code = ble_dfu_buttonless_char_add(&m_dfu);
VERIFY_SUCCESS(err_code);
return NRF_SUCCESS;
}

249
components/ble/ble_services/ble_dfu/ble_dfu.h Normal file
View File

@@ -0,0 +1,249 @@
/**
* Copyright (c) 2012 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/** @file
*
* @defgroup ble_dfu Buttonless DFU Service
* @{
* @ingroup ble_sdk_srv
* @brief Buttonless DFU Service module.
*
* @details This module implements a proprietary Buttonless Secure DFU Service. The service can
* be configured to support bonds or not. The bond support configuration must correspond to the
* requirement of Secure DFU bootloader.
*
* @note Attention!
* To maintain compliance with Nordic Semiconductor ASA Bluetooth profile
* qualification listings, this section of source code must not be modified.
*/
#ifndef BLE_DFU_H__
#define BLE_DFU_H__
#include <stdint.h>
#include "ble_srv_common.h"
#include "nrf_sdh_ble.h"
#ifdef __cplusplus
extern "C" {
#endif
/**@brief SoC observer priority.
* @details Priority of this module's SoC event handler.
*/
#define BLE_DFU_SOC_OBSERVER_PRIO 1
#define BLE_DFU_BUTTONLESS_CHAR_UUID (0x0003) /**< Value combined with vendor-specific base to create Unbonded Buttonless characteristic UUID. */
#define BLE_DFU_BUTTONLESS_BONDED_CHAR_UUID (0x0004) /**< Value combined with vendor-specific base to create Bonded Buttonless characteristic UUID. */
/**@brief Nordic vendor-specific base UUID.
*/
#define BLE_NORDIC_VENDOR_BASE_UUID \
{{ \
0x50, 0xEA, 0xDA, 0x30, 0x88, 0x83, 0xB8, 0x9F, \
0x60, 0x4F, 0x15, 0xF3, 0x00, 0x00, 0xC9, 0x8E \
}}
/**@brief Nordic Buttonless DFU Service event type .
*/
typedef enum
{
BLE_DFU_EVT_BOOTLOADER_ENTER_PREPARE, /**< Event indicating that the device is preparing to enter bootloader.*/
BLE_DFU_EVT_BOOTLOADER_ENTER, /**< Event indicating that the bootloader will be entered after return of this event.*/
BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED, /**< Failure to enter bootloader mode.*/
BLE_DFU_EVT_RESPONSE_SEND_ERROR, /**< Failure to send response.*/
} ble_dfu_buttonless_evt_type_t;
/**@brief Nordic Buttonless DFU Service event handler type.
*/
typedef void (*ble_dfu_buttonless_evt_handler_t) (ble_dfu_buttonless_evt_type_t p_evt);
/**@brief Enumeration of Bootloader DFU response codes.
*/
typedef enum
{
DFU_RSP_INVALID = 0x00, /**< Invalid op code. */
DFU_RSP_SUCCESS = 0x01, /**< Success. */
DFU_RSP_OP_CODE_NOT_SUPPORTED = 0x02, /**< Op code not supported. */
DFU_RSP_OPERATION_FAILED = 0x04, /**< Operation failed. */
DFU_RSP_ADV_NAME_INVALID = 0x05, /**< Requested advertisement name is too short or too long. */
DFU_RSP_BUSY = 0x06, /**< Ongoing async operation. */
DFU_RSP_NOT_BONDED = 0x07, /**< Buttonless unavailable due to device not bonded. */
} ble_dfu_buttonless_rsp_code_t;
/**@brief Enumeration of Bootloader DFU Operation codes.
*/
typedef enum
{
DFU_OP_RESERVED = 0x00, /**< Reserved for future use. */
DFU_OP_ENTER_BOOTLOADER = 0x01, /**< Enter bootloader. */
DFU_OP_SET_ADV_NAME = 0x02, /**< Set advertisement name to use in DFU mode. */
DFU_OP_RESPONSE_CODE = 0x20 /**< Response code. */
} ble_dfu_buttonless_op_code_t;
/**@brief Type holding memory used by Secure DFU Buttonless Service.
*/
typedef struct
{
uint8_t uuid_type; /**< UUID type for DFU UUID. */
uint16_t service_handle; /**< Service Handle of DFU (as provided by the SoftDevice). */
uint16_t conn_handle; /**< Connection handle for the current peer. */
ble_gatts_char_handles_t control_point_char; /**< Handles related to the DFU Control Point characteristic. */
uint32_t peers_count; /**< Counter to see how many persistently stored peers must be updated for Service Changed indication. This value will be counted down when comparing write requests. */
ble_dfu_buttonless_evt_handler_t evt_handler; /**< Event handler that is called upon Buttonless DFU events. See @ref ble_dfu_buttonless_evt_type_t. */
bool is_waiting_for_reset; /**< Flag indicating that the device will enter bootloader. */
bool is_waiting_for_svci; /**< Flag indicating that the device is waiting for async SVCI operation */
} ble_dfu_buttonless_t;
/**@brief Type used to initialize the Secure DFU Buttonless Service.
*/
typedef struct
{
ble_dfu_buttonless_evt_handler_t evt_handler; /**< Bootloader event handler. */
} ble_dfu_buttonless_init_t;
/**@brief Function for initializing the Device Firmware Update module.
*
* @param[in] p_dfu_init Structure containing the values of characteristics needed by the
* service.
* @retval NRF_SUCCESS on successful initialization of the service.
*/
uint32_t ble_dfu_buttonless_init(const ble_dfu_buttonless_init_t * p_dfu_init);
/**@brief Function for initializing the async SVCI interface.
*
* @warning Ensure that no interrupts are triggered when calling this functions as
* interrupts and exceptions are forwarded to the bootloader for the period
* of the call and may be lost.
*
* @details This configures the async interface for calling to the
* bootloader through SVCI interface.
*
* @retval NRF_SUCCESS on success, otherwise an error code.
*/
uint32_t ble_dfu_buttonless_async_svci_init(void);
/**@brief Function to initialize the backend Secure DFU Buttonless service which is either
* supports bonds or not.
*
* @note Do not call this function directly. It is called internally by @ref ble_dfu_buttonless_init.
*
* @param[in] p_dfu Nordic DFU Service structure.
*
* @return NRF_SUCCESS On sucessfully initializing, otherwise an error code.
*/
uint32_t ble_dfu_buttonless_backend_init(ble_dfu_buttonless_t * p_dfu);
/**@brief Function for adding the buttonless characteristic.
*
* @note This will be implemented differently on bonded/unbonded Buttonless DFU service.
*
* @param[in] p_dfu Nordic DFU Service structure.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
uint32_t ble_dfu_buttonless_char_add(ble_dfu_buttonless_t * p_dfu);
/**@brief Function for sending a response back to the client.
*
* @param[in] op_code Operation code to send the response for.
* @param[in] rsp_code Response code for the operation.
*
* @retval NRF_SUCCESS on success, otherwise an error code.
*/
uint32_t ble_dfu_buttonless_resp_send(ble_dfu_buttonless_op_code_t op_code, ble_dfu_buttonless_rsp_code_t rsp_code);
/**@brief Function for handling the application's BLE stack events.
*
* @details Handles all events from the BLE stack of interest to the DFU buttonless service.
*
* @param[in] p_ble_evt Event received from the BLE stack.
* @param[in] p_context BLE context structure.
*/
void ble_dfu_buttonless_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context);
/**@brief Function for handling control point write requests.
*
* @details Handles write requests to the control point in
* DFU with bonds or without bonds.
*
* @param[in] p_evt_write GATTS write event.
*/
void ble_dfu_buttonless_on_ctrl_pt_write(ble_gatts_evt_write_t const * p_evt_write);
/**@brief Function for preparing to enter the bootloader.
*
* @warning This function is called directly. (It is called internally).
*
* @retval Any error code from calling @ref sd_ble_gap_disconnect.
*/
uint32_t ble_dfu_buttonless_bootloader_start_prepare(void);
/**@brief Function for finalizing entering the bootloader.
*
* @warning This function is not to be called. (It is called internally).
*
* @retval NRF_SUCCESS Finalize was started correctly.
*/
uint32_t ble_dfu_buttonless_bootloader_start_finalize(void);
#ifdef __cplusplus
}
#endif
#endif // BLE_DIS_H__
/** @} */

367
components/ble/ble_services/ble_dfu/ble_dfu_bonded.c Normal file
View File

@@ -0,0 +1,367 @@
/**
* Copyright (c) 2017 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "nrf_dfu_ble_svci_bond_sharing.h"
#include "nordic_common.h"
#include "nrf_error.h"
#include "ble_dfu.h"
#include "nrf_log.h"
#include "peer_manager.h"
#include "gatts_cache_manager.h"
#include "peer_id.h"
#include "nrf_sdh_soc.h"
#include "nrf_strerror.h"
#if (NRF_DFU_BLE_BUTTONLESS_SUPPORTS_BONDS)
void ble_dfu_buttonless_on_sys_evt(uint32_t, void * );
uint32_t nrf_dfu_svci_vector_table_set(void);
uint32_t nrf_dfu_svci_vector_table_unset(void);
/**@brief Define function for async interface to set peer data. */
NRF_SVCI_ASYNC_FUNC_DEFINE(NRF_DFU_SVCI_SET_PEER_DATA, nrf_dfu_set_peer_data, nrf_dfu_peer_data_t);
// Register SoC observer for the Buttonless Secure DFU service
NRF_SDH_SOC_OBSERVER(m_dfu_buttonless_soc_obs, BLE_DFU_SOC_OBSERVER_PRIO, ble_dfu_buttonless_on_sys_evt, NULL);
ble_dfu_buttonless_t * mp_dfu;
static nrf_dfu_peer_data_t m_peer_data;
/**@brief Function for handling Peer Manager events.
*
* @param[in] p_evt Peer Manager event.
*/
static void pm_evt_handler(pm_evt_t const * p_evt)
{
uint32_t ret;
if (mp_dfu == NULL)
{
return;
}
// Only handle this when we are waiting to reset into DFU mode
if (!mp_dfu->is_waiting_for_reset)
{
return;
}
switch(p_evt->evt_id)
{
case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED:
if (p_evt->params.peer_data_update_succeeded.data_id == PM_PEER_DATA_ID_SERVICE_CHANGED_PENDING)
{
mp_dfu->peers_count--;
NRF_LOG_DEBUG("Updating Service Changed indication for peers, %d left", mp_dfu->peers_count);
if (mp_dfu->peers_count == 0)
{
NRF_LOG_DEBUG("Finished updating Service Changed indication for peers");
// We have updated Service Changed Indication for all devices.
ret = ble_dfu_buttonless_bootloader_start_finalize();
if (ret != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
}
break;
case PM_EVT_PEER_DATA_UPDATE_FAILED:
// Failure to update data. Service Changed cannot be sent but DFU mode is still possible
ret = ble_dfu_buttonless_bootloader_start_finalize();
if (ret != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
break;
default:
break;
}
}
static uint32_t retrieve_peer_data(void)
{
ret_code_t ret;
pm_peer_data_bonding_t bonding_data = {0};
pm_peer_id_t peer_id;
ret = pm_peer_id_get(mp_dfu->conn_handle, &peer_id);
VERIFY_SUCCESS(ret);
if (peer_id == PM_PEER_ID_INVALID)
{
return NRF_ERROR_FORBIDDEN;
}
ret = pm_peer_data_bonding_load(peer_id, &bonding_data);
VERIFY_SUCCESS(ret);
memcpy(&m_peer_data.ble_id, &bonding_data.peer_ble_id, sizeof(ble_gap_id_key_t));
memcpy(&m_peer_data.enc_key, &bonding_data.own_ltk, sizeof(ble_gap_enc_key_t));
uint16_t len = SYSTEM_SERVICE_ATT_SIZE;
ret = sd_ble_gatts_sys_attr_get(mp_dfu->conn_handle,
m_peer_data.sys_serv_attr,
&len,
BLE_GATTS_SYS_ATTR_FLAG_SYS_SRVCS);
NRF_LOG_DEBUG("system attribute table len: %d", len);
return ret;
}
/**@brief Function for entering the bootloader.
*
* @details This starts forwarding peer data to the Secure DFU bootloader.
*/
static uint32_t enter_bootloader(void)
{
uint32_t ret;
NRF_LOG_INFO("Writing peer data to the bootloader...");
if (mp_dfu->is_waiting_for_svci)
{
return ble_dfu_buttonless_resp_send(DFU_OP_ENTER_BOOTLOADER, DFU_RSP_BUSY);
}
// If retrieve_peer_data returns NRF_ERROR_FORBIDDEN, then the device was not bonded.
ret = retrieve_peer_data();
VERIFY_SUCCESS(ret);
ret = nrf_dfu_set_peer_data(&m_peer_data);
if (ret == NRF_SUCCESS)
{
// The request was accepted. Waiting for sys events to progress.
mp_dfu->is_waiting_for_svci = true;
}
else if (ret == NRF_ERROR_FORBIDDEN)
{
NRF_LOG_ERROR("The bootloader has write protected its settings page. This prohibits setting the peer data. "\
"The bootloader must be compiled with NRF_BL_SETTINGS_PAGE_PROTECT=0 to allow setting the peer data.");
}
return ret;
}
uint32_t ble_dfu_buttonless_backend_init(ble_dfu_buttonless_t * p_dfu)
{
VERIFY_PARAM_NOT_NULL(p_dfu);
// Set the memory used by the backend.
mp_dfu = p_dfu;
// Initialize the Peer manager handler.
return pm_register(pm_evt_handler);
}
uint32_t ble_dfu_buttonless_async_svci_init(void)
{
uint32_t ret;
// Set the vector table base address to the bootloader.
ret = nrf_dfu_svci_vector_table_set();
NRF_LOG_DEBUG("nrf_dfu_svci_vector_table_set() -> %s",
(ret == NRF_SUCCESS) ? "success" : nrf_strerror_get(ret));
VERIFY_SUCCESS(ret);
// Initialize the asynchronous SuperVisor interface to set peer data in Secure DFU bootloader.
ret = nrf_dfu_set_peer_data_init();
NRF_LOG_DEBUG("nrf_dfu_set_peer_data_init() -> %s",
(ret == NRF_SUCCESS) ? "success" : nrf_strerror_get(ret));
VERIFY_SUCCESS(ret);
// Set the vector table base address back to main application.
ret = nrf_dfu_svci_vector_table_unset();
NRF_LOG_DEBUG("nrf_dfu_svci_vector_table_unset() -> %s",
(ret == NRF_SUCCESS) ? "success" : nrf_strerror_get(ret));
return ret;
}
void ble_dfu_buttonless_on_sys_evt(uint32_t sys_evt, void * p_context)
{
uint32_t ret;
if (!nrf_dfu_set_peer_data_is_initialized())
{
return;
}
ret = nrf_dfu_set_peer_data_on_sys_evt(sys_evt);
if (ret == NRF_ERROR_INVALID_STATE)
{
// The system event is not from an operation started by buttonless DFU.
// No action is taken, and nothing is reported.
}
else if (ret == NRF_SUCCESS)
{
// Peer data was successfully forwarded to the Secure DFU bootloader.
// Set the flag indicating that we are waiting for indication response
// to activate the reset.
mp_dfu->is_waiting_for_reset = true;
mp_dfu->is_waiting_for_svci = false;
// Report back the positive response
ret = ble_dfu_buttonless_resp_send(DFU_OP_ENTER_BOOTLOADER, DFU_RSP_SUCCESS);
if (ret != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
mp_dfu->is_waiting_for_reset = false;
}
}
else
{
// Failed to set peer data. Report this.
mp_dfu->is_waiting_for_reset = false;
mp_dfu->is_waiting_for_svci = false;
ret = ble_dfu_buttonless_resp_send(DFU_OP_ENTER_BOOTLOADER, DFU_RSP_BUSY);
// Report the failure to send the response to the client
if (ret != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
// Report the failure to enter DFU mode
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
uint32_t ble_dfu_buttonless_char_add(ble_dfu_buttonless_t * p_dfu)
{
ble_add_char_params_t add_char_params;
memset(&add_char_params, 0, sizeof(add_char_params));
add_char_params.uuid = BLE_DFU_BUTTONLESS_BONDED_CHAR_UUID;
add_char_params.uuid_type = p_dfu->uuid_type;
add_char_params.char_props.indicate = 1;
add_char_params.char_props.write = 1;
add_char_params.is_defered_write = true;
add_char_params.is_var_len = true;
add_char_params.max_len = BLE_GATT_ATT_MTU_DEFAULT;
add_char_params.cccd_write_access = SEC_JUST_WORKS;
add_char_params.write_access = SEC_JUST_WORKS;
add_char_params.read_access = SEC_OPEN;
return characteristic_add(p_dfu->service_handle, &add_char_params, &p_dfu->control_point_char);
}
void ble_dfu_buttonless_on_ctrl_pt_write(ble_gatts_evt_write_t const * p_evt_write)
{
uint32_t ret;
ble_dfu_buttonless_rsp_code_t rsp_code = DFU_RSP_OPERATION_FAILED;
// Start executing the control point write action
switch (p_evt_write->data[0])
{
case DFU_OP_ENTER_BOOTLOADER:
ret = enter_bootloader();
if (ret == NRF_SUCCESS)
{
rsp_code = DFU_RSP_SUCCESS;
}
else if (ret == NRF_ERROR_BUSY)
{
rsp_code = DFU_RSP_BUSY;
}
else if (ret == NRF_ERROR_FORBIDDEN)
{
rsp_code = DFU_RSP_NOT_BONDED;
}
break;
default:
rsp_code = DFU_RSP_OP_CODE_NOT_SUPPORTED;
break;
}
// Report back in case of error
if (rsp_code != DFU_RSP_SUCCESS)
{
ret = ble_dfu_buttonless_resp_send((ble_dfu_buttonless_op_code_t)p_evt_write->data[0],
rsp_code);
if (ret != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
// Report the error to the main application
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
uint32_t ble_dfu_buttonless_bootloader_start_prepare(void)
{
NRF_LOG_DEBUG("In ble_dfu_buttonless_bootloader_start_prepare");
// Indicate to main app that DFU mode is starting.
// This event can be used to let the device take down any connection to
// bonded devices.
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_PREPARE);
// Store the number of peers for which Peer Manager is expected to successfully write events.
mp_dfu->peers_count = peer_id_n_ids();
// Set local database changed to get Service Changed indication for all bonded peers
// on next bootup (either because of a successful or aborted DFU).
gscm_local_database_has_changed();
return NRF_SUCCESS;
}
#endif // NRF_DFU_BLE_BUTTONLESS_SUPPORTS_BONDS

299
components/ble/ble_services/ble_dfu/ble_dfu_unbonded.c Normal file
View File

@@ -0,0 +1,299 @@
/**
* Copyright (c) 2017 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "nrf_dfu_ble_svci_bond_sharing.h"
#include "nordic_common.h"
#include "nrf_error.h"
#include "ble_dfu.h"
#include "nrf_log.h"
#include "nrf_sdh_soc.h"
#if (!NRF_DFU_BLE_BUTTONLESS_SUPPORTS_BONDS)
#define NRF_DFU_ADV_NAME_MAX_LENGTH (20)
void ble_dfu_buttonless_on_sys_evt(uint32_t, void * );
uint32_t nrf_dfu_svci_vector_table_set(void);
uint32_t nrf_dfu_svci_vector_table_unset(void);
/**@brief Define functions for async interface to set new advertisement name for DFU mode. */
NRF_SVCI_ASYNC_FUNC_DEFINE(NRF_DFU_SVCI_SET_ADV_NAME, nrf_dfu_set_adv_name, nrf_dfu_adv_name_t);
// Register SoC observer for the Buttonless Secure DFU service
NRF_SDH_SOC_OBSERVER(m_dfu_buttonless_soc_obs, BLE_DFU_SOC_OBSERVER_PRIO, ble_dfu_buttonless_on_sys_evt, NULL);
ble_dfu_buttonless_t * mp_dfu = NULL;
static nrf_dfu_adv_name_t m_adv_name;
/**@brief Function for setting an advertisement name.
*
* @param[in] adv_name The new advertisement name.
*
* @retval NRF_SUCCESS Advertisement name was successfully set.
* @retval DFU_RSP_BUSY Advertisement name was not set because of an ongoing operation.
* @retval Any other errors from the SVCI interface call.
*/
static uint32_t set_adv_name(nrf_dfu_adv_name_t * p_adv_name)
{
uint32_t err_code;
if (mp_dfu->is_waiting_for_svci)
{
return DFU_RSP_BUSY;
}
err_code = nrf_dfu_set_adv_name(p_adv_name);
if (err_code == NRF_SUCCESS)
{
// The request was accepted.
mp_dfu->is_waiting_for_svci = true;
}
else if (err_code == NRF_ERROR_FORBIDDEN)
{
NRF_LOG_ERROR("The bootloader has write protected its settings page. This prohibits setting the advertising name. "\
"The bootloader must be compiled with NRF_BL_SETTINGS_PAGE_PROTECT=0 to allow setting the advertising name.");
}
return err_code;
}
/**@brief Function for entering the bootloader.
*/
static uint32_t enter_bootloader()
{
uint32_t err_code;
if (mp_dfu->is_waiting_for_svci)
{
// We have an ongoing async operation. Entering bootloader mode is not possible at this time.
err_code = ble_dfu_buttonless_resp_send(DFU_OP_ENTER_BOOTLOADER, DFU_RSP_BUSY);
if (err_code != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
return NRF_SUCCESS;
}
// Set the flag indicating that we expect DFU mode.
// This will be handled on acknowledgement of the characteristic indication.
mp_dfu->is_waiting_for_reset = true;
err_code = ble_dfu_buttonless_resp_send(DFU_OP_ENTER_BOOTLOADER, DFU_RSP_SUCCESS);
if (err_code != NRF_SUCCESS)
{
mp_dfu->is_waiting_for_reset = false;
}
return err_code;
}
uint32_t ble_dfu_buttonless_backend_init(ble_dfu_buttonless_t * p_dfu)
{
VERIFY_PARAM_NOT_NULL(p_dfu);
mp_dfu = p_dfu;
return NRF_SUCCESS;
}
uint32_t ble_dfu_buttonless_async_svci_init(void)
{
uint32_t ret_val;
ret_val = nrf_dfu_svci_vector_table_set();
VERIFY_SUCCESS(ret_val);
ret_val = nrf_dfu_set_adv_name_init();
VERIFY_SUCCESS(ret_val);
ret_val = nrf_dfu_svci_vector_table_unset();
return ret_val;
}
void ble_dfu_buttonless_on_sys_evt(uint32_t sys_evt, void * p_context)
{
uint32_t err_code;
if (!nrf_dfu_set_adv_name_is_initialized())
{
return;
}
err_code = nrf_dfu_set_adv_name_on_sys_evt(sys_evt);
if (err_code == NRF_ERROR_INVALID_STATE)
{
// The system event is not from an operation started by buttonless DFU.
// No action is taken, and nothing is reported.
}
else if (err_code == NRF_SUCCESS)
{
// The async operation is finished.
// Set the flag indicating that we are waiting for indication response
// to activate the reset.
mp_dfu->is_waiting_for_svci = false;
// Report back the positive response
err_code = ble_dfu_buttonless_resp_send(DFU_OP_SET_ADV_NAME, DFU_RSP_SUCCESS);
if (err_code != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
}
else
{
// Invalid error code reported back.
mp_dfu->is_waiting_for_svci = false;
err_code = ble_dfu_buttonless_resp_send(DFU_OP_SET_ADV_NAME, DFU_RSP_BUSY);
if (err_code != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
// Report the failure to enter DFU mode
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
uint32_t ble_dfu_buttonless_char_add(ble_dfu_buttonless_t * p_dfu)
{
ble_add_char_params_t add_char_params;
memset(&add_char_params, 0, sizeof(add_char_params));
add_char_params.uuid = BLE_DFU_BUTTONLESS_CHAR_UUID;
add_char_params.uuid_type = p_dfu->uuid_type;
add_char_params.char_props.indicate = 1;
add_char_params.char_props.write = 1;
add_char_params.is_defered_write = true;
add_char_params.is_var_len = true;
add_char_params.max_len = BLE_GATT_ATT_MTU_DEFAULT;
add_char_params.cccd_write_access = SEC_OPEN;
add_char_params.write_access = SEC_OPEN;
add_char_params.read_access = SEC_OPEN;
return characteristic_add(p_dfu->service_handle, &add_char_params, &p_dfu->control_point_char);
}
void ble_dfu_buttonless_on_ctrl_pt_write(ble_gatts_evt_write_t const * p_evt_write)
{
uint32_t err_code;
ble_dfu_buttonless_rsp_code_t rsp_code = DFU_RSP_OPERATION_FAILED;
// Start executing the control point write operation
/*lint -e415 -e416 -save "Out of bounds access"*/
switch (p_evt_write->data[0])
{
case DFU_OP_ENTER_BOOTLOADER:
err_code = enter_bootloader();
if (err_code == NRF_SUCCESS)
{
rsp_code = DFU_RSP_SUCCESS;
}
else if (err_code == NRF_ERROR_BUSY)
{
rsp_code = DFU_RSP_BUSY;
}
break;
case DFU_OP_SET_ADV_NAME:
if( (p_evt_write->data[1] > NRF_DFU_ADV_NAME_MAX_LENGTH)
|| (p_evt_write->data[1] == 0))
{
// New advertisement name too short or too long.
rsp_code = DFU_RSP_ADV_NAME_INVALID;
}
else
{
memcpy(m_adv_name.name, &p_evt_write->data[2], p_evt_write->data[1]);
m_adv_name.len = p_evt_write->data[1];
err_code = set_adv_name(&m_adv_name);
if (err_code == NRF_SUCCESS)
{
rsp_code = DFU_RSP_SUCCESS;
}
}
break;
default:
rsp_code = DFU_RSP_OP_CODE_NOT_SUPPORTED;
break;
}
/*lint -restore*/
// Report back in case of error
if (rsp_code != DFU_RSP_SUCCESS)
{
err_code = ble_dfu_buttonless_resp_send((ble_dfu_buttonless_op_code_t)p_evt_write->data[0], rsp_code);
if (err_code != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
// Report the error to the main application
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
uint32_t ble_dfu_buttonless_bootloader_start_prepare(void)
{
uint32_t err_code;
// Indicate to main app that DFU mode is starting.
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_PREPARE);
err_code = ble_dfu_buttonless_bootloader_start_finalize();
return err_code;
}
#endif // NRF_DFU_BOTTONLESS_SUPPORT_BOND