in on central repo.master
@ -0,0 +1,31 @@ | |||
/* | |||
* Copyright (c) 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 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 other | |||
* contributors to this software may be used to endorse or promote products | |||
* derived from this software without specific prior written permission. | |||
* | |||
* | |||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND | |||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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. | |||
* | |||
*/ |
@ -0,0 +1,6 @@ | |||
Many of the files in this module have been inherited from the Nordic SDK for | |||
nRF51822; they come with a BSD-like license offered by Nordic for use in mbed. | |||
Some other files come from the mbed SDK, and are licensed under Apache-2.0. | |||
Unless specifically indicated otherwise in a file, files are licensed | |||
under the Apache 2.0 license, as can be found in: apache-2.0.txt. | |||
The BSD-like Nordic license can be found in BSD-3clause-Nordic.txt |
@ -0,0 +1,41 @@ | |||
{ | |||
"name": "nrf51-sdk", | |||
"version": "0.0.0", | |||
"description": "Module to contain files provided by the nordic nRF51 SDK", | |||
"keywords": [ | |||
"nordic", | |||
"nrf51", | |||
"sdk" | |||
], | |||
"author": "", | |||
"license": "nordic", | |||
"targetDependencies": { | |||
"mbed-classic": { | |||
"mbed-classic": "~0.0.1" | |||
}, | |||
"mbed-os": { | |||
"mbed-drivers": "*" | |||
} | |||
}, | |||
"extraIncludes": [ | |||
"source/nordic_sdk/components", | |||
"source/nordic_sdk/components/libraries/util", | |||
"source/nordic_sdk/components/libraries/hci", | |||
"source/nordic_sdk/components/libraries/bootloader_dfu", | |||
"source/nordic_sdk/components/libraries/bootloader_dfu/hci_transport", | |||
"source/nordic_sdk/components/libraries/bootloader_dfu/experimental", | |||
"source/nordic_sdk/components/libraries/scheduler", | |||
"source/nordic_sdk/components/libraries/crc16", | |||
"source/nordic_sdk/components/softdevice/s130/include", | |||
"source/nordic_sdk/components/softdevice/common/softdevice_handler", | |||
"source/nordic_sdk/components/drivers_nrf/hal", | |||
"source/nordic_sdk/components/drivers_nrf/ble_flash", | |||
"source/nordic_sdk/components/drivers_nrf/pstorage", | |||
"source/nordic_sdk/components/drivers_nrf/pstorage/config", | |||
"source/nordic_sdk/components/ble/ble_radio_notification", | |||
"source/nordic_sdk/components/ble/ble_services/ble_dfu", | |||
"source/nordic_sdk/components/ble/common", | |||
"source/nordic_sdk/components/ble/device_manager", | |||
"source/nordic_sdk/components/ble/device_manager/config" | |||
] | |||
} |
@ -0,0 +1,80 @@ | |||
/* | |||
* Copyright (c) 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 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 other | |||
* contributors to this software may be used to endorse or promote products | |||
* derived from this software without specific prior written permission. | |||
* | |||
* | |||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND | |||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 "ble_radio_notification.h" | |||
#include <stdlib.h> | |||
static bool m_radio_active = false; /**< Current radio state. */ | |||
static ble_radio_notification_evt_handler_t m_evt_handler = NULL; /**< Application event handler for handling Radio Notification events. */ | |||
void SWI1_IRQHandler(void) | |||
{ | |||
m_radio_active = !m_radio_active; | |||
if (m_evt_handler != NULL) | |||
{ | |||
m_evt_handler(m_radio_active); | |||
} | |||
} | |||
uint32_t ble_radio_notification_init(nrf_app_irq_priority_t irq_priority, | |||
nrf_radio_notification_distance_t distance, | |||
ble_radio_notification_evt_handler_t evt_handler) | |||
{ | |||
uint32_t err_code; | |||
m_evt_handler = evt_handler; | |||
// Initialize Radio Notification software interrupt | |||
err_code = sd_nvic_ClearPendingIRQ(SWI1_IRQn); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
err_code = sd_nvic_SetPriority(SWI1_IRQn, irq_priority); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
err_code = sd_nvic_EnableIRQ(SWI1_IRQn); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
// Configure the event | |||
return sd_radio_notification_cfg_set(NRF_RADIO_NOTIFICATION_TYPE_INT_ON_BOTH, distance); | |||
} |
@ -0,0 +1,74 @@ | |||
/* | |||
* Copyright (c) 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 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 other | |||
* contributors to this software may be used to endorse or promote products | |||
* derived from this software without specific prior written permission. | |||
* | |||
* | |||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND | |||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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_radio_notification Radio Notification Event Handler | |||
* @{ | |||
* @ingroup ble_sdk_lib | |||
* @brief Module for propagating Radio Notification events to the application. | |||
*/ | |||
#ifndef BLE_RADIO_NOTIFICATION_H__ | |||
#define BLE_RADIO_NOTIFICATION_H__ | |||
#include <stdint.h> | |||
#include <stdbool.h> | |||
#include "nrf_soc.h" | |||
#ifdef __cplusplus | |||
extern "C" { | |||
#endif | |||
/**@brief Application radio notification event handler type. */ | |||
typedef void (*ble_radio_notification_evt_handler_t) (bool radio_active); | |||
/**@brief Function for initializing the Radio Notification module. | |||
* | |||
* @param[in] irq_priority Interrupt priority for the Radio Notification interrupt handler. | |||
* @param[in] distance The time from an Active event until the radio is activated. | |||
* @param[in] evt_handler Handler to be executed when a radio notification event has been | |||
* received. | |||
* | |||
* @return NRF_SUCCESS on successful initialization, otherwise an error code. | |||
*/ | |||
uint32_t ble_radio_notification_init(nrf_app_irq_priority_t irq_priority, | |||
nrf_radio_notification_distance_t distance, | |||
ble_radio_notification_evt_handler_t evt_handler); | |||
#ifdef __cplusplus | |||
} | |||
#endif | |||
#endif // BLE_RADIO_NOTIFICATION_H__ | |||
/** @} */ |
@ -0,0 +1,686 @@ | |||
/* | |||
* Copyright (c) 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 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 other | |||
* contributors to this software may be used to endorse or promote products | |||
* derived from this software without specific prior written permission. | |||
* | |||
* | |||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND | |||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 "ble_dfu.h" | |||
#include "nrf_error.h" | |||
#include "ble_types.h" | |||
#include "ble_gatts.h" | |||
#include "app_util.h" | |||
#include "ble_srv_common.h" | |||
#include "nordic_common.h" | |||
#include <stdint.h> | |||
#include <string.h> | |||
#include <stddef.h> | |||
#define MAX_DFU_PKT_LEN 20 /**< Maximum length (in bytes) of the DFU Packet characteristic. */ | |||
#define PKT_START_DFU_PARAM_LEN 2 /**< Length (in bytes) of the parameters for Packet Start DFU Request. */ | |||
#define PKT_INIT_DFU_PARAM_LEN 2 /**< Length (in bytes) of the parameters for Packet Init DFU Request. */ | |||
#define PKT_RCPT_NOTIF_REQ_LEN 3 /**< Length (in bytes) of the Packet Receipt Notification Request. */ | |||
#define MAX_PKTS_RCPT_NOTIF_LEN 6 /**< Maximum length (in bytes) of the Packets Receipt Notification. */ | |||
#define MAX_RESPONSE_LEN 7 /**< Maximum length (in bytes) of the response to a Control Point command. */ | |||
#define MAX_NOTIF_BUFFER_LEN MAX(MAX_PKTS_RCPT_NOTIF_LEN, MAX_RESPONSE_LEN) /**< Maximum length (in bytes) of the buffer needed by DFU Service while sending notifications to peer. */ | |||
enum | |||
{ | |||
OP_CODE_START_DFU = 1, /**< Value of the Op code field for 'Start DFU' command.*/ | |||
OP_CODE_RECEIVE_INIT = 2, /**< Value of the Op code field for 'Initialize DFU parameters' command.*/ | |||
OP_CODE_RECEIVE_FW = 3, /**< Value of the Op code field for 'Receive firmware image' command.*/ | |||
OP_CODE_VALIDATE = 4, /**< Value of the Op code field for 'Validate firmware' command.*/ | |||
OP_CODE_ACTIVATE_N_RESET = 5, /**< Value of the Op code field for 'Activate & Reset' command.*/ | |||
OP_CODE_SYS_RESET = 6, /**< Value of the Op code field for 'Reset System' command.*/ | |||
OP_CODE_IMAGE_SIZE_REQ = 7, /**< Value of the Op code field for 'Report received image size' command.*/ | |||
OP_CODE_PKT_RCPT_NOTIF_REQ = 8, /**< Value of the Op code field for 'Request packet receipt notification.*/ | |||
OP_CODE_RESPONSE = 16, /**< Value of the Op code field for 'Response.*/ | |||
OP_CODE_PKT_RCPT_NOTIF = 17 /**< Value of the Op code field for 'Packets Receipt Notification'.*/ | |||
}; | |||
static bool m_is_dfu_service_initialized = false; /**< Variable to check if the DFU service was initialized by the application.*/ | |||
static uint8_t m_notif_buffer[MAX_NOTIF_BUFFER_LEN]; /**< Buffer used for sending notifications to peer. */ | |||
/**@brief Function for adding DFU Packet characteristic to the BLE Stack. | |||
* | |||
* @param[in] p_dfu DFU Service structure. | |||
* | |||
* @return NRF_SUCCESS on success. Otherwise an error code. | |||
*/ | |||
static uint32_t dfu_pkt_char_add(ble_dfu_t * const p_dfu) | |||
{ | |||
ble_gatts_char_md_t char_md; | |||
ble_gatts_attr_t attr_char_value; | |||
ble_uuid_t char_uuid; | |||
ble_gatts_attr_md_t attr_md; | |||
memset(&char_md, 0, sizeof(char_md)); | |||
char_md.char_props.write_wo_resp = 1; | |||
char_md.p_char_user_desc = NULL; | |||
char_md.p_char_pf = NULL; | |||
char_md.p_user_desc_md = NULL; | |||
char_md.p_cccd_md = NULL; | |||
char_md.p_sccd_md = NULL; | |||
char_uuid.type = p_dfu->uuid_type; | |||
char_uuid.uuid = BLE_DFU_PKT_CHAR_UUID; | |||
memset(&attr_md, 0, sizeof(attr_md)); | |||
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.read_perm); | |||
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm); | |||
attr_md.vloc = BLE_GATTS_VLOC_STACK; | |||
attr_md.rd_auth = 0; | |||
attr_md.wr_auth = 0; | |||
attr_md.vlen = 1; | |||
memset(&attr_char_value, 0, sizeof(attr_char_value)); | |||
attr_char_value.p_uuid = &char_uuid; | |||
attr_char_value.p_attr_md = &attr_md; | |||
attr_char_value.init_len = 0; | |||
attr_char_value.init_offs = 0; | |||
attr_char_value.max_len = MAX_DFU_PKT_LEN; | |||
attr_char_value.p_value = NULL; | |||
return sd_ble_gatts_characteristic_add(p_dfu->service_handle, | |||
&char_md, | |||
&attr_char_value, | |||
&p_dfu->dfu_pkt_handles); | |||
} | |||
/**@brief Function for adding DFU Revision characteristic to the BLE Stack. | |||
* | |||
* @param[in] p_dfu DFU Service structure. | |||
* | |||
* @return NRF_SUCCESS on success. Otherwise an error code. | |||
*/ | |||
static uint32_t dfu_rev_char_add(ble_dfu_t * const p_dfu, ble_dfu_init_t const * const p_dfu_init) | |||
{ | |||
ble_gatts_char_md_t char_md; | |||
ble_gatts_attr_t attr_char_value; | |||
ble_uuid_t char_uuid; | |||
ble_gatts_attr_md_t attr_md; | |||
memset(&char_md, 0, sizeof(char_md)); | |||
char_md.char_props.read = 1; | |||
char_md.p_char_user_desc = NULL; | |||
char_md.p_char_pf = NULL; | |||
char_md.p_user_desc_md = NULL; | |||
char_md.p_cccd_md = NULL; | |||
char_md.p_sccd_md = NULL; | |||
char_uuid.type = p_dfu->uuid_type; | |||
char_uuid.uuid = BLE_DFU_REV_CHAR_UUID; | |||
memset(&attr_md, 0, sizeof(attr_md)); | |||
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm); | |||
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm); | |||
attr_md.vloc = BLE_GATTS_VLOC_STACK; | |||
attr_md.rd_auth = 0; | |||
attr_md.wr_auth = 0; | |||
attr_md.vlen = 1; | |||
memset(&attr_char_value, 0, sizeof(attr_char_value)); | |||
attr_char_value.p_uuid = &char_uuid; | |||
attr_char_value.p_attr_md = &attr_md; | |||
attr_char_value.init_len = sizeof(uint16_t); | |||
attr_char_value.init_offs = 0; | |||
attr_char_value.max_len = sizeof(uint16_t); | |||
attr_char_value.p_value = (uint8_t *)&p_dfu_init->revision; | |||
return sd_ble_gatts_characteristic_add(p_dfu->service_handle, | |||
&char_md, | |||
&attr_char_value, | |||
&p_dfu->dfu_rev_handles); | |||
} | |||
/**@brief Function for adding DFU Control Point characteristic to the BLE Stack. | |||
* | |||
* @param[in] p_dfu DFU Service structure. | |||
* | |||
* @return NRF_SUCCESS on success. Otherwise an error code. | |||
*/ | |||
static uint32_t dfu_ctrl_pt_add(ble_dfu_t * const p_dfu) | |||
{ | |||
ble_gatts_char_md_t char_md; | |||
ble_gatts_attr_t attr_char_value; | |||
ble_uuid_t char_uuid; | |||
ble_gatts_attr_md_t attr_md; | |||
memset(&char_md, 0, sizeof(char_md)); | |||
char_md.char_props.write = 1; | |||
char_md.char_props.notify = 1; | |||
char_md.p_char_user_desc = NULL; | |||
char_md.p_char_pf = NULL; | |||
char_md.p_user_desc_md = NULL; | |||
char_md.p_cccd_md = NULL; | |||
char_md.p_sccd_md = NULL; | |||
char_uuid.type = p_dfu->uuid_type; | |||
char_uuid.uuid = BLE_DFU_CTRL_PT_UUID; | |||
memset(&attr_md, 0, sizeof(attr_md)); | |||
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.read_perm); | |||
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm); | |||
attr_md.vloc = BLE_GATTS_VLOC_STACK; | |||
attr_md.rd_auth = 0; | |||
attr_md.wr_auth = 1; | |||
attr_md.vlen = 1; | |||
memset(&attr_char_value, 0, sizeof(attr_char_value)); | |||
attr_char_value.p_uuid = &char_uuid; | |||
attr_char_value.p_attr_md = &attr_md; | |||
attr_char_value.init_len = 0; | |||
attr_char_value.init_offs = 0; | |||
attr_char_value.max_len = BLE_L2CAP_MTU_DEF; | |||
attr_char_value.p_value = NULL; | |||
return sd_ble_gatts_characteristic_add(p_dfu->service_handle, | |||
&char_md, | |||
&attr_char_value, | |||
&p_dfu->dfu_ctrl_pt_handles); | |||
} | |||
/**@brief Function for handling the @ref BLE_GAP_EVT_CONNECTED event from the S110 SoftDevice. | |||
* | |||
* @param[in] p_dfu DFU Service Structure. | |||
* @param[in] p_ble_evt Pointer to the event received from BLE stack. | |||
*/ | |||
static void on_connect(ble_dfu_t * p_dfu, ble_evt_t * p_ble_evt) | |||
{ | |||
p_dfu->conn_handle = p_ble_evt->evt.gap_evt.conn_handle; | |||
} | |||
/**@brief Function for checking if the CCCD of DFU Control point is configured for Notification. | |||
* | |||
* @details This function checks if the CCCD of DFU Control Point characteristic is configured | |||
* for Notification by the DFU Controller. | |||
* | |||
* @param[in] p_dfu DFU Service structure. | |||
* | |||
* @return True if the CCCD of DFU Control Point characteristic is configured for Notification. | |||
* False otherwise. | |||
*/ | |||
static bool is_cccd_configured(ble_dfu_t * p_dfu) | |||
{ | |||
// Check if the CCCDs are configured. | |||
uint8_t cccd_val_buf[BLE_CCCD_VALUE_LEN]; | |||
ble_gatts_value_t gatts_value; | |||
// Initialize value struct. | |||
memset(&gatts_value, 0, sizeof(gatts_value)); | |||
gatts_value.len = BLE_CCCD_VALUE_LEN; | |||
gatts_value.offset = 0; | |||
gatts_value.p_value = cccd_val_buf; | |||
// Check the CCCD Value of DFU Control Point. | |||
uint32_t err_code = sd_ble_gatts_value_get(p_dfu->conn_handle, | |||
p_dfu->dfu_ctrl_pt_handles.cccd_handle, | |||
&gatts_value); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
if (p_dfu->error_handler != NULL) | |||
{ | |||
p_dfu->error_handler(err_code); | |||
} | |||
return false; | |||
} | |||
return ble_srv_is_notification_enabled(cccd_val_buf); | |||
} | |||
/**@brief Function for handling a Write event on the Control Point characteristic. | |||
* | |||
* @param[in] p_dfu DFU Service Structure. | |||
* @param[in] p_ble_write_evt Pointer to the write event received from BLE stack. | |||
* | |||
* @return NRF_SUCCESS on successful processing of control point write. Otherwise an error code. | |||
*/ | |||
static uint32_t on_ctrl_pt_write(ble_dfu_t * p_dfu, ble_gatts_evt_write_t * p_ble_write_evt) | |||
{ | |||
ble_gatts_rw_authorize_reply_params_t write_authorize_reply; | |||
write_authorize_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE; | |||
if (!is_cccd_configured(p_dfu)) | |||
{ | |||
// Send an error response to the peer indicating that the CCCD is improperly configured. | |||
write_authorize_reply.params.write.gatt_status = | |||
BLE_GATT_STATUS_ATTERR_CPS_CCCD_CONFIG_ERROR; | |||
return (sd_ble_gatts_rw_authorize_reply(p_dfu->conn_handle, &write_authorize_reply)); | |||
} | |||
else | |||
{ | |||
uint32_t err_code; | |||
write_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_SUCCESS; | |||
err_code = (sd_ble_gatts_rw_authorize_reply(p_dfu->conn_handle, &write_authorize_reply)); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
} | |||
ble_dfu_evt_t ble_dfu_evt; | |||
switch (p_ble_write_evt->data[0]) | |||
{ | |||
case OP_CODE_START_DFU: | |||
ble_dfu_evt.ble_dfu_evt_type = BLE_DFU_START; | |||
if (p_ble_write_evt->len < PKT_START_DFU_PARAM_LEN) | |||
{ | |||
return ble_dfu_response_send(p_dfu, | |||
(ble_dfu_procedure_t) p_ble_write_evt->data[0], | |||
BLE_DFU_RESP_VAL_OPER_FAILED); | |||
} | |||
ble_dfu_evt.evt.ble_dfu_pkt_write.len = 1; | |||
ble_dfu_evt.evt.ble_dfu_pkt_write.p_data = &(p_ble_write_evt->data[1]); | |||
p_dfu->evt_handler(p_dfu, &ble_dfu_evt); | |||
break; | |||
case OP_CODE_RECEIVE_INIT: | |||
ble_dfu_evt.ble_dfu_evt_type = BLE_DFU_RECEIVE_INIT_DATA; | |||
if (p_ble_write_evt->len < PKT_INIT_DFU_PARAM_LEN) | |||
{ | |||
return ble_dfu_response_send(p_dfu, | |||
(ble_dfu_procedure_t) p_ble_write_evt->data[0], | |||
BLE_DFU_RESP_VAL_OPER_FAILED); | |||
} | |||
ble_dfu_evt.evt.ble_dfu_pkt_write.len = 1; | |||
ble_dfu_evt.evt.ble_dfu_pkt_write.p_data = &(p_ble_write_evt->data[1]); | |||
p_dfu->evt_handler(p_dfu, &ble_dfu_evt); | |||
break; | |||
case OP_CODE_RECEIVE_FW: | |||
ble_dfu_evt.ble_dfu_evt_type = BLE_DFU_RECEIVE_APP_DATA; | |||
p_dfu->evt_handler(p_dfu, &ble_dfu_evt); | |||
break; | |||
case OP_CODE_VALIDATE: | |||
ble_dfu_evt.ble_dfu_evt_type = BLE_DFU_VALIDATE; | |||
p_dfu->evt_handler(p_dfu, &ble_dfu_evt); | |||
break; | |||
case OP_CODE_ACTIVATE_N_RESET: | |||
ble_dfu_evt.ble_dfu_evt_type = BLE_DFU_ACTIVATE_N_RESET; | |||
p_dfu->evt_handler(p_dfu, &ble_dfu_evt); | |||
break; | |||
case OP_CODE_SYS_RESET: | |||
ble_dfu_evt.ble_dfu_evt_type = BLE_DFU_SYS_RESET; | |||
p_dfu->evt_handler(p_dfu, &ble_dfu_evt); | |||
break; | |||
case OP_CODE_PKT_RCPT_NOTIF_REQ: | |||
if (p_ble_write_evt->len < PKT_RCPT_NOTIF_REQ_LEN) | |||
{ | |||
return (ble_dfu_response_send(p_dfu, | |||
BLE_DFU_PKT_RCPT_REQ_PROCEDURE, | |||
BLE_DFU_RESP_VAL_NOT_SUPPORTED)); | |||
} | |||
ble_dfu_evt.evt.pkt_rcpt_notif_req.num_of_pkts = | |||
uint16_decode(&(p_ble_write_evt->data[1])); | |||
if (ble_dfu_evt.evt.pkt_rcpt_notif_req.num_of_pkts == 0) | |||
{ | |||
ble_dfu_evt.ble_dfu_evt_type = BLE_DFU_PKT_RCPT_NOTIF_DISABLED; | |||
} | |||
else | |||
{ | |||
ble_dfu_evt.ble_dfu_evt_type = BLE_DFU_PKT_RCPT_NOTIF_ENABLED; | |||
} | |||
p_dfu->evt_handler(p_dfu, &ble_dfu_evt); | |||
break; | |||
case OP_CODE_IMAGE_SIZE_REQ: | |||
ble_dfu_evt.ble_dfu_evt_type = BLE_DFU_BYTES_RECEIVED_SEND; | |||
p_dfu->evt_handler(p_dfu, &ble_dfu_evt); | |||
break; | |||
default: | |||
// Unsupported op code. | |||
return ble_dfu_response_send(p_dfu, | |||
(ble_dfu_procedure_t) p_ble_write_evt->data[0], | |||
BLE_DFU_RESP_VAL_NOT_SUPPORTED); | |||
} | |||
return NRF_SUCCESS; | |||
} | |||
/**@brief Function for handling the @ref BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST event from the S110 | |||
* Stack. | |||
* | |||
* @param[in] p_dfu DFU Service Structure. | |||
* @param[in] p_ble_evt Pointer to the event received from BLE stack. | |||
*/ | |||
static void on_rw_authorize_req(ble_dfu_t * p_dfu, ble_evt_t * p_ble_evt) | |||
{ | |||
ble_gatts_evt_rw_authorize_request_t * p_authorize_request; | |||
p_authorize_request = &(p_ble_evt->evt.gatts_evt.params.authorize_request); | |||
if ( | |||
(p_authorize_request->type == BLE_GATTS_AUTHORIZE_TYPE_WRITE) | |||
&& | |||
(p_authorize_request->request.write.handle == p_dfu->dfu_ctrl_pt_handles.value_handle) | |||
&& | |||
(p_ble_evt->evt.gatts_evt.params.authorize_request.request.write.op != BLE_GATTS_OP_PREP_WRITE_REQ) | |||
&& | |||
(p_ble_evt->evt.gatts_evt.params.authorize_request.request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) | |||
&& | |||
(p_ble_evt->evt.gatts_evt.params.authorize_request.request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL) | |||
) | |||
{ | |||
uint32_t err_code; | |||
err_code = on_ctrl_pt_write(p_dfu, &(p_authorize_request->request.write)); | |||
if (err_code != NRF_SUCCESS && p_dfu->error_handler != NULL) | |||
{ | |||
p_dfu->error_handler(err_code); | |||
} | |||
} | |||
} | |||
/**@brief Function for handling the @ref BLE_GATTS_EVT_WRITE event from the S110 SoftDevice. | |||
* | |||
* @param[in] p_dfu DFU Service Structure. | |||
* @param[in] p_ble_evt Pointer to the event received from BLE stack. | |||
*/ | |||
static void on_write(ble_dfu_t * p_dfu, ble_evt_t * p_ble_evt) | |||
{ | |||
if (p_ble_evt->evt.gatts_evt.params.write.handle == p_dfu->dfu_pkt_handles.value_handle) | |||
{ | |||
// DFU Packet written | |||
ble_dfu_evt_t ble_dfu_evt; | |||
ble_dfu_evt.ble_dfu_evt_type = BLE_DFU_PACKET_WRITE; | |||
ble_dfu_evt.evt.ble_dfu_pkt_write.len = p_ble_evt->evt.gatts_evt.params.write.len; | |||
ble_dfu_evt.evt.ble_dfu_pkt_write.p_data = p_ble_evt->evt.gatts_evt.params.write.data; | |||
p_dfu->evt_handler(p_dfu, &ble_dfu_evt); | |||
} | |||
} | |||
/**@brief Function for handling the BLE_GAP_EVT_DISCONNECTED event from the S110 SoftDevice. | |||
* | |||
* @param[in] p_dfu DFU Service Structure. | |||
* @param[in] p_ble_evt Pointer to the event received from BLE stack. | |||
*/ | |||
static void on_disconnect(ble_dfu_t * p_dfu, ble_evt_t * p_ble_evt) | |||
{ | |||
p_dfu->conn_handle = BLE_CONN_HANDLE_INVALID; | |||
} | |||
uint32_t ble_dfu_init(ble_dfu_t * p_dfu, ble_dfu_init_t * p_dfu_init) | |||
{ | |||
if ((p_dfu == NULL) || (p_dfu_init == NULL) || (p_dfu_init->evt_handler == NULL)) | |||
{ | |||
return NRF_ERROR_NULL; | |||
} | |||
p_dfu->conn_handle = BLE_CONN_HANDLE_INVALID; | |||
ble_uuid_t service_uuid; | |||
uint32_t err_code; | |||
const ble_uuid128_t base_uuid128 = | |||
{ | |||
{ | |||
0x23, 0xD1, 0xBC, 0xEA, 0x5F, 0x78, 0x23, 0x15, | |||
0xDE, 0xEF, 0x12, 0x12, 0x00, 0x00, 0x00, 0x00 | |||
} | |||
}; | |||
service_uuid.uuid = BLE_DFU_SERVICE_UUID; | |||
err_code = sd_ble_uuid_vs_add(&base_uuid128, &(service_uuid.type)); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, | |||
&service_uuid, | |||
&(p_dfu->service_handle)); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
p_dfu->uuid_type = service_uuid.type; | |||
err_code = dfu_pkt_char_add(p_dfu); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
err_code = dfu_ctrl_pt_add(p_dfu); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
err_code = dfu_rev_char_add(p_dfu, p_dfu_init); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
p_dfu->evt_handler = p_dfu_init->evt_handler; | |||
if (p_dfu_init->error_handler != NULL) | |||
{ | |||
p_dfu->error_handler = p_dfu_init->error_handler; | |||
} | |||
m_is_dfu_service_initialized = true; | |||
return NRF_SUCCESS; | |||
} | |||
void ble_dfu_on_ble_evt(ble_dfu_t * p_dfu, ble_evt_t * p_ble_evt) | |||
{ | |||
if ((p_dfu == NULL) || (p_ble_evt == NULL)) | |||
{ | |||
return; | |||
} | |||
if (p_dfu->evt_handler != NULL) | |||
{ | |||
switch (p_ble_evt->header.evt_id) | |||
{ | |||
case BLE_GAP_EVT_CONNECTED: | |||
on_connect(p_dfu, p_ble_evt); | |||
break; | |||
case BLE_GATTS_EVT_WRITE: | |||
on_write(p_dfu, p_ble_evt); | |||
break; | |||
case BLE_GAP_EVT_DISCONNECTED: | |||
on_disconnect(p_dfu, p_ble_evt); | |||
break; | |||
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST: | |||
on_rw_authorize_req(p_dfu, p_ble_evt); | |||
break; | |||
default: | |||
// No implementation needed. | |||
break; | |||
} | |||
} | |||
} | |||
uint32_t ble_dfu_bytes_rcvd_report(ble_dfu_t * p_dfu, uint32_t num_of_firmware_bytes_rcvd) | |||
{ | |||
if (p_dfu == NULL) | |||
{ | |||
return NRF_ERROR_NULL; | |||
} | |||
if ((p_dfu->conn_handle == BLE_CONN_HANDLE_INVALID) || !m_is_dfu_service_initialized) | |||
{ | |||
return NRF_ERROR_INVALID_STATE; | |||
} | |||
ble_gatts_hvx_params_t hvx_params; | |||
uint16_t index = 0; | |||
// Encode the Op Code. | |||
m_notif_buffer[index++] = OP_CODE_RESPONSE; | |||
// Encode the Reqest Op Code. | |||
m_notif_buffer[index++] = OP_CODE_IMAGE_SIZE_REQ; | |||
// Encode the Response Value. | |||
m_notif_buffer[index++] = (uint8_t)BLE_DFU_RESP_VAL_SUCCESS; | |||
index += uint32_encode(num_of_firmware_bytes_rcvd, &m_notif_buffer[index]); | |||
memset(&hvx_params, 0, sizeof(hvx_params)); | |||
hvx_params.handle = p_dfu->dfu_ctrl_pt_handles.value_handle; | |||
hvx_params.type = BLE_GATT_HVX_NOTIFICATION; | |||
hvx_params.offset = 0; | |||
hvx_params.p_len = &index; | |||
hvx_params.p_data = m_notif_buffer; | |||
return sd_ble_gatts_hvx(p_dfu->conn_handle, &hvx_params); | |||
} | |||
uint32_t ble_dfu_pkts_rcpt_notify(ble_dfu_t * p_dfu, uint32_t num_of_firmware_bytes_rcvd) | |||
{ | |||
if (p_dfu == NULL) | |||
{ | |||
return NRF_ERROR_NULL; | |||
} | |||
if ((p_dfu->conn_handle == BLE_CONN_HANDLE_INVALID) || !m_is_dfu_service_initialized) | |||
{ | |||
return NRF_ERROR_INVALID_STATE; | |||
} | |||
ble_gatts_hvx_params_t hvx_params; | |||
uint16_t index = 0; | |||
m_notif_buffer[index++] = OP_CODE_PKT_RCPT_NOTIF; | |||
index += uint32_encode(num_of_firmware_bytes_rcvd, &m_notif_buffer[index]); | |||
memset(&hvx_params, 0, sizeof(hvx_params)); | |||
hvx_params.handle = p_dfu->dfu_ctrl_pt_handles.value_handle; | |||
hvx_params.type = BLE_GATT_HVX_NOTIFICATION; | |||
hvx_params.offset = 0; | |||
hvx_params.p_len = &index; | |||
hvx_params.p_data = m_notif_buffer; | |||
return sd_ble_gatts_hvx(p_dfu->conn_handle, &hvx_params); | |||
} | |||
uint32_t ble_dfu_response_send(ble_dfu_t * p_dfu, | |||
ble_dfu_procedure_t dfu_proc, | |||
ble_dfu_resp_val_t resp_val) | |||
{ | |||
if (p_dfu == NULL) | |||
{ | |||
return NRF_ERROR_NULL; | |||
} | |||
if ((p_dfu->conn_handle == BLE_CONN_HANDLE_INVALID) || !m_is_dfu_service_initialized) | |||
{ | |||
return NRF_ERROR_INVALID_STATE; | |||
} | |||
ble_gatts_hvx_params_t hvx_params; | |||
uint16_t index = 0; | |||
m_notif_buffer[index++] = OP_CODE_RESPONSE; | |||
// Encode the Request Op code | |||
m_notif_buffer[index++] = (uint8_t)dfu_proc; | |||
// Encode the Response Value. | |||
m_notif_buffer[index++] = (uint8_t)resp_val; | |||
memset(&hvx_params, 0, sizeof(hvx_params)); | |||
hvx_params.handle = p_dfu->dfu_ctrl_pt_handles.value_handle; | |||
hvx_params.type = BLE_GATT_HVX_NOTIFICATION; | |||
hvx_params.offset = 0; | |||
hvx_params.p_len = &index; | |||
hvx_params.p_data = m_notif_buffer; | |||
return sd_ble_gatts_hvx(p_dfu->conn_handle, &hvx_params); | |||
} |
@ -0,0 +1,259 @@ | |||
/* | |||
* Copyright (c) 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 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 other | |||
* contributors to this software may be used to endorse or promote products | |||
* derived from this software without specific prior written permission. | |||
* | |||
* | |||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND | |||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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_sdk_srv_dfu Device Firmware Update Service | |||
* @{ | |||
* @ingroup ble_sdk_srv | |||
* @brief Device Firmware Update Service | |||
* | |||
* @details The Device Firmware Update (DFU) service is a GATT based service that can be used for | |||
* performing firmware updates over BLE. Note that this implementation uses vendor | |||
* specific UUIDs for service and characteristics and is intended to demonstrate the | |||
* firmware updates over BLE. Refer @ref ota_spec_sec and @ref | |||
* ota_profile_section for more information on the service and profile respectively. | |||
*/ | |||
#ifndef BLE_DFU_H__ | |||
#define BLE_DFU_H__ | |||
#include <stdint.h> | |||
#include "ble_gatts.h" | |||
#include "ble_gap.h" | |||
#include "ble.h" | |||
#include "ble_srv_common.h" | |||
#define BLE_DFU_SERVICE_UUID 0x1530 /**< The UUID of the DFU Service. */ | |||
#define BLE_DFU_PKT_CHAR_UUID 0x1532 /**< The UUID of the DFU Packet Characteristic. */ | |||
#define BLE_DFU_CTRL_PT_UUID 0x1531 /**< The UUID of the DFU Control Point. */ | |||
#define BLE_DFU_STATUS_REP_UUID 0x1533 /**< The UUID of the DFU Status Report Characteristic. */ | |||
#define BLE_DFU_REV_CHAR_UUID 0x1534 /**< The UUID of the DFU Revision Characteristic. */ | |||
/**@brief DFU Event type. | |||
* | |||
* @details This enumeration contains the types of events that will be received from the DFU Service. | |||
*/ | |||
typedef enum | |||
{ | |||
BLE_DFU_START, /**< The event indicating that the peer wants the application to prepare for a new firmware update. */ | |||
BLE_DFU_RECEIVE_INIT_DATA, /**< The event indicating that the peer wants the application to prepare to receive init parameters. */ | |||
BLE_DFU_RECEIVE_APP_DATA, /**< The event indicating that the peer wants the application to prepare to receive the new firmware image. */ | |||
BLE_DFU_VALIDATE, /**< The event indicating that the peer wants the application to validate the newly received firmware image. */ | |||
BLE_DFU_ACTIVATE_N_RESET, /**< The event indicating that the peer wants the application to undergo activate new firmware and restart with new valid application */ | |||
BLE_DFU_SYS_RESET, /**< The event indicating that the peer wants the application to undergo a reset and start the currently valid application image.*/ | |||
BLE_DFU_PKT_RCPT_NOTIF_ENABLED, /**< The event indicating that the peer has enabled packet receipt notifications. It is the responsibility of the application to call @ref ble_dfu_pkts_rcpt_notify each time the number of packets indicated by num_of_pkts field in @ref ble_dfu_evt_t is received.*/ | |||
BLE_DFU_PKT_RCPT_NOTIF_DISABLED, /**< The event indicating that the peer has disabled the packet receipt notifications.*/ | |||
BLE_DFU_PACKET_WRITE, /**< The event indicating that the peer has written a value to the 'DFU Packet' characteristic. The data received from the peer will be present in the @ref BLE_DFU_PACKET_WRITE element contained within @ref ble_dfu_evt_t.*/ | |||
BLE_DFU_BYTES_RECEIVED_SEND /**< The event indicating that the peer is requesting for the number of bytes of firmware data last received by the application. It is the responsibility of the application to call @ref ble_dfu_pkts_rcpt_notify in response to this event. */ | |||
} ble_dfu_evt_type_t; | |||
/**@brief DFU Procedure type. | |||
* | |||
* @details This enumeration contains the types of DFU procedures. | |||
*/ | |||
typedef enum | |||
{ | |||
BLE_DFU_START_PROCEDURE = 1, /**< DFU Start procedure.*/ | |||
BLE_DFU_INIT_PROCEDURE = 2, /**< DFU Initialization procedure.*/ | |||
BLE_DFU_RECEIVE_APP_PROCEDURE = 3, /**< Firmware receiving procedure.*/ | |||
BLE_DFU_VALIDATE_PROCEDURE = 4, /**< Firmware image validation procedure .*/ | |||
BLE_DFU_PKT_RCPT_REQ_PROCEDURE = 8 /**< Packet receipt notification request procedure. */ | |||
} ble_dfu_procedure_t; | |||
/**@brief DFU Response value type. | |||
*/ | |||
typedef enum | |||
{ | |||
BLE_DFU_RESP_VAL_SUCCESS = 1, /**< Success.*/ | |||
BLE_DFU_RESP_VAL_INVALID_STATE, /**< Invalid state.*/ | |||
BLE_DFU_RESP_VAL_NOT_SUPPORTED, /**< Operation not supported.*/ | |||
BLE_DFU_RESP_VAL_DATA_SIZE, /**< Data size exceeds limit.*/ | |||
BLE_DFU_RESP_VAL_CRC_ERROR, /**< CRC Error.*/ | |||
BLE_DFU_RESP_VAL_OPER_FAILED /**< Operation failed.*/ | |||
} ble_dfu_resp_val_t; | |||
/**@brief DFU Packet structure. | |||
* | |||
* @details This structure contains the value of the DFU Packet characteristic as written by the | |||
* peer and the length of the value written. It will be filled by the DFU Service when the | |||
* peer writes to the DFU Packet characteristic. | |||
*/ | |||
typedef struct | |||
{ | |||
uint8_t len; /**< Length of the packet received. */ | |||
uint8_t * p_data; /**< Pointer to the received packet. This will point to a word aligned memory location.*/ | |||
} ble_dfu_pkt_write_t; | |||
/**@brief Packet receipt notification request structure. | |||
* | |||
* @details This structure contains the contents of the packet receipt notification request | |||
* sent by the DFU Controller. | |||
*/ | |||
typedef struct | |||
{ | |||
uint16_t num_of_pkts; /**< The number of packets of firmware data to be received by application before sending the next Packet Receipt Notification to the peer. */ | |||
} ble_pkt_rcpt_notif_req_t; | |||
/**@brief DFU Event structure. | |||
* | |||
* @details This structure contains the event generated by the DFU Service based on the data | |||
* received from the peer. | |||
*/ | |||
typedef struct | |||
{ | |||
ble_dfu_evt_type_t ble_dfu_evt_type; /**< Type of the event.*/ | |||
union | |||
{ | |||
ble_dfu_pkt_write_t ble_dfu_pkt_write; /**< The DFU packet received. This field is when the @ref ble_dfu_evt_type field is set to @ref BLE_DFU_PACKET_WRITE.*/ | |||
ble_pkt_rcpt_notif_req_t pkt_rcpt_notif_req; /**< Packet receipt notification request. This field is when the @ref ble_dfu_evt_type field is set to @ref BLE_DFU_PKT_RCPT_NOTIF_ENABLED.*/ | |||
} evt; | |||
} ble_dfu_evt_t; | |||
// Forward declaration of the ble_dfu_t type. | |||
typedef struct ble_dfu_s ble_dfu_t; | |||
/**@brief DFU Service event handler type. */ | |||
typedef void (*ble_dfu_evt_handler_t) (ble_dfu_t * p_dfu, ble_dfu_evt_t * p_evt); | |||
/**@brief DFU service structure. | |||
* | |||
* @details This structure contains status information related to the service. | |||
*/ | |||
struct ble_dfu_s | |||
{ | |||
uint16_t conn_handle; /**< Handle of the current connection (as provided by the S110 SoftDevice). This will be BLE_CONN_HANDLE_INVALID when not in a connection. */ | |||
uint16_t revision; /**< Handle of DFU Service (as provided by the S110 SoftDevice). */ | |||
uint16_t service_handle; /**< Handle of DFU Service (as provided by the S110 SoftDevice). */ | |||
uint8_t uuid_type; /**< UUID type assigned for DFU Service by the S110 SoftDevice. */ | |||
ble_gatts_char_handles_t dfu_pkt_handles; /**< Handles related to the DFU Packet characteristic. */ | |||
ble_gatts_char_handles_t dfu_ctrl_pt_handles; /**< Handles related to the DFU Control Point characteristic. */ | |||
ble_gatts_char_handles_t dfu_status_rep_handles; /**< Handles related to the DFU Status Report characteristic. */ | |||
ble_gatts_char_handles_t dfu_rev_handles; /**< Handles related to the DFU Revision characteristic. */ | |||
ble_dfu_evt_handler_t evt_handler; /**< The event handler to be called when an event is to be sent to the application.*/ | |||
ble_srv_error_handler_t error_handler; /**< Function to be called in case of an error. */ | |||
}; | |||
/**@brief DFU service initialization structure. | |||
* | |||
* @details This structure contains the initialization information for the DFU Service. The | |||
* application needs to fill this structure and pass it to the DFU Service using the | |||
* @ref ble_dfu_init function. | |||
*/ | |||
typedef struct | |||
{ | |||
uint16_t revision; /**< Revision number to be exposed by the DFU service. */ | |||
ble_dfu_evt_handler_t evt_handler; /**< Event handler to be called for handling events in the Device Firmware Update Service. */ | |||
ble_srv_error_handler_t error_handler; /**< Function to be called in case of an error. */ | |||
} ble_dfu_init_t; | |||
/**@brief Function for handling a BLE event. | |||
* | |||
* @details The DFU service expects the application to call this function each time an event | |||
* is received from the S110 SoftDevice. This function processes the event, if it is | |||
* relevant for the DFU service and calls the DFU event handler of the application if | |||
* necessary. | |||
* | |||
* @param[in] p_dfu Pointer to the DFU service structure. | |||
* @param[in] p_ble_evt Pointer to the event received from S110 SoftDevice. | |||
*/ | |||
void ble_dfu_on_ble_evt(ble_dfu_t * p_dfu, ble_evt_t * p_ble_evt); | |||
/**@brief Function for initializing the DFU service. | |||
* | |||
* @param[out] p_dfu Device Firmware Update service structure. This structure will have to be | |||
* supplied by the application. It will be initialized by this function, | |||
* and will later be used to identify the service instance. | |||
* @param[in] p_dfu_init Information needed to initialize the service. | |||
* | |||
* @return NRF_SUCCESS if the DFU service and its characteristics were successfully added to the | |||
* S110 SoftDevice. Otherwise an error code. | |||
* This function returns NRF_ERROR_NULL if the value of evt_handler in p_dfu_init | |||
* structure provided is NULL or if the pointers supplied as input are NULL. | |||
*/ | |||
uint32_t ble_dfu_init(ble_dfu_t * p_dfu, ble_dfu_init_t * p_dfu_init); | |||
/**@brief Function for sending response to a control point command. | |||
* | |||
* @details This function will encode a DFU Control Point response using the given input | |||
* parameters and will send a notification of the same to the peer. | |||
* | |||
* @param[in] p_dfu Pointer to the DFU service structure. | |||
* @param[in] dfu_proc Procedure for which this response is to be sent. | |||
* @param[in] resp_val Response value. | |||
* | |||
* @return NRF_SUCCESS if the DFU Service has successfully requested the S110 SoftDevice to | |||
* send the notification. Otherwise an error code. | |||
* This function returns NRF_ERROR_INVALID_STATE if the device is not connected to a | |||
* peer or if the DFU service is not initialized or if the notification of the DFU | |||
* Status Report characteristic was not enabled by the peer. It returns NRF_ERROR_NULL | |||
* if the pointer p_dfu is NULL. | |||
*/ | |||
uint32_t ble_dfu_response_send(ble_dfu_t * p_dfu, | |||
ble_dfu_procedure_t dfu_proc, | |||
ble_dfu_resp_val_t resp_val); | |||
/**@brief Function for notifying the peer about the number of bytes of firmware data received. | |||
* | |||
* @param[in] p_dfu Pointer to the DFU service structure. | |||
* @param[in] num_of_firmware_bytes_rcvd Number of bytes. | |||
* | |||
* @return NRF_SUCCESS if the DFU Service has successfully requested the S110 SoftDevice to send | |||
* the notification. Otherwise an error code. | |||
* This function returns NRF_ERROR_INVALID_STATE if the device is not connected to a | |||
* peer or if the DFU service is not initialized or if the notification of the DFU | |||
* Status Report characteristic was not enabled by the peer. It returns NRF_ERROR_NULL | |||
* if the pointer p_dfu is NULL. | |||
*/ | |||
uint32_t ble_dfu_bytes_rcvd_report(ble_dfu_t * p_dfu, uint32_t num_of_firmware_bytes_rcvd); | |||
/**@brief Function for sending Packet Receipt Notification to the peer. | |||
* | |||
* This function will encode the number of bytes received as input parameter into a | |||
* notification of the control point characteristic and send it to the peer. | |||
* | |||
* @param[in] p_dfu Pointer to the DFU service structure. | |||
* @param[in] num_of_firmware_bytes_rcvd Number of bytes of firmware image received. | |||
* | |||
* @return NRF_SUCCESS if the DFU Service has successfully requested the S110 SoftDevice to send | |||
* the notification. Otherwise an error code. | |||
* This function returns NRF_ERROR_INVALID_STATE if the device is not connected to a | |||
* peer or if the DFU service is not initialized or if the notification of the DFU | |||
* Status Report characteristic was not enabled by the peer. It returns NRF_ERROR_NULL | |||
* if the pointer p_dfu is NULL. | |||
*/ | |||
uint32_t ble_dfu_pkts_rcpt_notify(ble_dfu_t * p_dfu, uint32_t num_of_firmware_bytes_rcvd); | |||
#endif // BLE_DFU_H__ | |||
/** @} */ |
@ -0,0 +1,609 @@ | |||
/* | |||
* Copyright (c) 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 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 other | |||
* contributors to this software may be used to endorse or promote products | |||
* derived from this software without specific prior written permission. | |||
* | |||
* | |||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND | |||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 "ble_advdata.h" | |||
#include "nordic_common.h" | |||
#include "nrf_error.h" | |||
#include "ble_gap.h" | |||
#include "ble_srv_common.h" | |||
#include "app_util.h" | |||
// Offset from where advertisement data other than flags information can start. | |||
#define ADV_FLAG_OFFSET 2 | |||
// Offset for Advertising Data. | |||
// Offset is 2 as each Advertising Data contain 1 octet of Adveritising Data Type and | |||
// one octet Advertising Data Length. | |||
#define ADV_DATA_OFFSET 2 | |||
// NOTE: For now, Security Manager TK Value and Security Manager Out of Band Flags (OOB) are omitted | |||
// from the advertising data. | |||
static uint32_t name_encode(const ble_advdata_t * p_advdata, | |||
uint8_t * p_encoded_data, | |||
uint8_t * p_len) | |||
{ | |||
uint32_t err_code; | |||
uint16_t rem_adv_data_len; | |||
uint16_t actual_length; | |||
uint8_t adv_data_format; | |||
uint8_t adv_offset; | |||
adv_offset = *p_len; | |||
// Check for buffer overflow. | |||
if ((adv_offset + ADV_DATA_OFFSET > BLE_GAP_ADV_MAX_SIZE) || | |||
((p_advdata->short_name_len + ADV_DATA_OFFSET) > BLE_GAP_ADV_MAX_SIZE)) | |||
{ | |||
return NRF_ERROR_DATA_SIZE; | |||
} | |||
actual_length = rem_adv_data_len = (BLE_GAP_ADV_MAX_SIZE - adv_offset - ADV_FLAG_OFFSET); | |||
// Get GAP device name and length | |||
err_code = sd_ble_gap_device_name_get(&p_encoded_data[adv_offset + ADV_DATA_OFFSET], | |||
&actual_length); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
// Check if device internd to use short name and it can fit available data size. | |||
if ((p_advdata->name_type == BLE_ADVDATA_FULL_NAME) && (actual_length <= rem_adv_data_len)) | |||
{ | |||
// Complete device name can fit, setting Complete Name in Adv Data. | |||
adv_data_format = BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME; | |||
rem_adv_data_len = actual_length; | |||
} | |||
else | |||
{ | |||
// Else short name needs to be used. Or application has requested use of short name. | |||
adv_data_format = BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME; | |||
// If application has set a preference on the short name size, it needs to be considered, | |||
// else fit what can be fit. | |||
if ((p_advdata->short_name_len != 0) && (p_advdata->short_name_len <= rem_adv_data_len)) | |||
{ | |||
// Short name fits available size. | |||
rem_adv_data_len = p_advdata->short_name_len; | |||
} | |||
// Else whatever can fit the data buffer will be packed. | |||
else | |||
{ | |||
rem_adv_data_len = actual_length; | |||
} | |||
} | |||
// Complete name field in encoded data. | |||
p_encoded_data[adv_offset++] = rem_adv_data_len + 1; | |||
p_encoded_data[adv_offset++] = adv_data_format; | |||
(*p_len) += (rem_adv_data_len + ADV_DATA_OFFSET); | |||
return NRF_SUCCESS; | |||
} | |||
static uint32_t appearance_encode(uint8_t * p_encoded_data, uint8_t * p_len) | |||
{ | |||
uint32_t err_code; | |||
uint16_t appearance; | |||
// Check for buffer overflow. | |||
if ((*p_len) + 4 > BLE_GAP_ADV_MAX_SIZE) | |||
{ | |||
return NRF_ERROR_DATA_SIZE; | |||
} | |||
// Get GAP appearance field. | |||
err_code = sd_ble_gap_appearance_get(&appearance); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
// Encode Length, AD Type and Appearance. | |||
p_encoded_data[(*p_len)++] = 3; | |||
p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_APPEARANCE; | |||
(*p_len) += uint16_encode(appearance, &p_encoded_data[*p_len]); | |||
return NRF_SUCCESS; | |||
} | |||
static uint32_t tx_power_level_encode(int8_t tx_power_level, | |||
uint8_t * p_encoded_data, | |||
uint8_t * p_len) | |||
{ | |||
// Check for buffer overflow. | |||
if ((*p_len) + 3 > BLE_GAP_ADV_MAX_SIZE) | |||
{ | |||
return NRF_ERROR_DATA_SIZE; | |||
} | |||
// Encode TX Power Level. | |||
p_encoded_data[(*p_len)++] = 2; | |||
p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_TX_POWER_LEVEL; | |||
p_encoded_data[(*p_len)++] = (uint8_t)tx_power_level; | |||
return NRF_SUCCESS; | |||
} | |||
static uint32_t uuid_list_sized_encode(const ble_advdata_uuid_list_t * p_uuid_list, | |||
uint8_t adv_type, | |||
uint8_t uuid_size, | |||
uint8_t * p_encoded_data, | |||
uint8_t * p_len) | |||
{ | |||
int i; | |||
bool is_heading_written = false; | |||
uint8_t start_pos = *p_len; | |||
for (i = 0; i < p_uuid_list->uuid_cnt; i++) | |||
{ | |||
uint32_t err_code; | |||
uint8_t encoded_size; | |||
ble_uuid_t uuid = p_uuid_list->p_uuids[i]; | |||
// Find encoded uuid size. | |||
err_code = sd_ble_uuid_encode(&uuid, &encoded_size, NULL); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
// Check size. | |||
if (encoded_size == uuid_size) | |||
{ | |||
uint8_t heading_bytes = (is_heading_written) ? 0 : 2; | |||
// Check for buffer overflow | |||
if (*p_len + encoded_size + heading_bytes > BLE_GAP_ADV_MAX_SIZE) | |||
{ | |||
return NRF_ERROR_DATA_SIZE; | |||
} | |||
if (!is_heading_written) | |||
{ | |||
// Write AD structure heading. | |||
(*p_len)++; | |||
p_encoded_data[(*p_len)++] = adv_type; | |||
is_heading_written = true; | |||
} | |||
// Write UUID. | |||
err_code = sd_ble_uuid_encode(&uuid, &encoded_size, &p_encoded_data[*p_len]); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
(*p_len) += encoded_size; | |||
} | |||
} | |||
if (is_heading_written) | |||
{ | |||
// Write length. | |||
p_encoded_data[start_pos] = (*p_len) - (start_pos + 1); | |||
} | |||
return NRF_SUCCESS; | |||
} | |||
static uint32_t uuid_list_encode(const ble_advdata_uuid_list_t * p_uuid_list, | |||
uint8_t adv_type_16, | |||
uint8_t adv_type_128, | |||
uint8_t * p_encoded_data, | |||
uint8_t * p_len) | |||
{ | |||
uint32_t err_code; | |||
// Encode 16 bit UUIDs. | |||
err_code = uuid_list_sized_encode(p_uuid_list, | |||
adv_type_16, | |||
sizeof(uint16_le_t), | |||
p_encoded_data, | |||
p_len); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
// Encode 128 bit UUIDs. | |||
err_code = uuid_list_sized_encode(p_uuid_list, | |||
adv_type_128, | |||
sizeof(ble_uuid128_t), | |||
p_encoded_data, | |||
p_len); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
return NRF_SUCCESS; | |||
} | |||
static uint32_t conn_int_check(const ble_advdata_conn_int_t *p_conn_int) | |||
{ | |||
// Check Minimum Connection Interval. | |||
if ((p_conn_int->min_conn_interval < 0x0006) || | |||
( | |||
(p_conn_int->min_conn_interval > 0x0c80) && | |||
(p_conn_int->min_conn_interval != 0xffff) | |||
) | |||
) | |||
{ | |||
return NRF_ERROR_INVALID_PARAM; | |||
} | |||
// Check Maximum Connection Interval. | |||
if ((p_conn_int->max_conn_interval < 0x0006) || | |||
( | |||
(p_conn_int->max_conn_interval > 0x0c80) && | |||
(p_conn_int->max_conn_interval != 0xffff) | |||
) | |||
) | |||
{ | |||
return NRF_ERROR_INVALID_PARAM; | |||
} | |||
// Make sure Minimum Connection Interval is not bigger than Maximum Connection Interval. | |||
if ((p_conn_int->min_conn_interval != 0xffff) && | |||
(p_conn_int->max_conn_interval != 0xffff) && | |||
(p_conn_int->min_conn_interval > p_conn_int->max_conn_interval) | |||
) | |||
{ | |||
return NRF_ERROR_INVALID_PARAM; | |||
} | |||
return NRF_SUCCESS; | |||
} | |||
static uint32_t conn_int_encode(const ble_advdata_conn_int_t * p_conn_int, | |||
uint8_t * p_encoded_data, | |||
uint8_t * p_len) | |||
{ | |||
uint32_t err_code; | |||
// Check for buffer overflow. | |||
if ((*p_len) + ADV_DATA_OFFSET + 2 * sizeof(uint16_le_t) > BLE_GAP_ADV_MAX_SIZE) | |||
{ | |||
return NRF_ERROR_DATA_SIZE; | |||
} | |||
// Check parameters. | |||
err_code = conn_int_check(p_conn_int); | |||
if (err_code != NRF_SUCCESS) | |||
{ | |||
return err_code; | |||
} | |||
// Encode Length and AD Type. | |||
p_encoded_data[(*p_len)++] = 1 + 2 * sizeof(uint16_le_t); | |||
p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_SLAVE_CONNECTION_INTERVAL_RANGE; | |||
// Encode Minimum and Maximum Connection Intervals. | |||
(*p_len) += uint16_encode(p_conn_int->min_conn_interval, &p_encoded_data[*p_len]); | |||
(*p_len) += uint16_encode(p_conn_int->max_conn_interval, &p_encoded_data[*p_len]); | |||
return NRF_SUCCESS; | |||
} | |||
static uint32_t manuf_specific_data_encode(const ble_advdata_manuf_data_t * p_manuf_sp_data, | |||
uint8_t * p_encoded_data, | |||
uint8_t * p_len) | |||
{ | |||
uint8_t data_size = sizeof(uint16_le_t) + p_manuf_sp_data->data.size; | |||
// Check for buffer overflow. | |||
if ((*p_len) + ADV_DATA_OFFSET + data_size > BLE_GAP_ADV_MAX_SIZE) | |||
{ | |||
return NRF_ERROR_DATA_SIZE; | |||
} | |||
// Encode Length and AD Type. | |||
p_encoded_data[(*p_len)++] = 1 + data_size; | |||
p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_MANUFACTURER_SPECIFIC_DATA; | |||
// Encode Company Identifier. | |||
(*p_len) += uint16_encode(p_manuf_sp_data->company_identifier, &p_encoded_data[*p_len]); | |||
// Encode additional manufacturer specific data. | |||
if (p_manuf_sp_data->data.size > 0) | |||
{ | |||
if (p_manuf_sp_data->data.p_data == NULL) | |||
{ | |||
return NRF_ERROR_INVALID_PARAM; | |||
} | |||
memcpy(&p_encoded_data[*p_len], p_manuf_sp_data->data.p_data, p_manuf_sp_data->data.size); | |||
(*p_len) += p_manuf_sp_data->data.size; | |||
} | |||
return NRF_SUCCESS; | |||
} | |||
static uint32_t service_data_encode(const ble_advdata_t * p_advdata, | |||
uint8_t * p_encoded_data, | |||
uint8_t * p_len) | |||
{ | |||
uint8_t i; | |||
// Check parameter consistency. | |||
if (p_advdata->p_service_data_array == NULL) | |||
{ | |||
return NRF_ERROR_INVALID_PARAM; | |||
} | |||
for (i = 0; i < p_advdata->service_data_count; i++) | |||
{ | |||
ble_advdata_service_data_t * p_service_data; | |||
uint8_t data_size; | |||
p_service_data = &p_advdata->p_service_data_array[i]; | |||
data_size = sizeof(uint16_le_t) + p_service_data->data.size; | |||
// Encode Length and AD Type. | |||
p_encoded_data[(*p_len)++] = 1 + data_size; | |||
p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_SERVICE_DATA; | |||
// Encode service UUID. | |||
(*p_len) += uint16_encode(p_service_data->service_uuid, &p_encoded_data[*p_len]); | |||