Initial commit, centralising all required files from nordic sdk

in on central repo.

BSD-3clause-Nordic.txt

@@ -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.
+ *
+ */

LICENSE

@@ -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

module.json

@@ -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"
+  ]
+}

source/nordic_sdk/components/ble/ble_radio_notification/ble_radio_notification.c

@@ -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);
+}

source/nordic_sdk/components/ble/ble_radio_notification/ble_radio_notification.h

@@ -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__
+
+/** @} */

source/nordic_sdk/components/ble/ble_services/ble_dfu/ble_dfu.c

@@ -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);
+}

source/nordic_sdk/components/ble/ble_services/ble_dfu/ble_dfu.h

@@ -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__
+
+/** @} */

source/nordic_sdk/components/ble/common/ble_advdata.c

@@ -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]);