diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/eddystone/es_flash.c')
| -rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/eddystone/es_flash.c | 340 |
1 files changed, 340 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/eddystone/es_flash.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/eddystone/es_flash.c new file mode 100644 index 0000000..2e408bb --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/eddystone/es_flash.c @@ -0,0 +1,340 @@ +/** + * Copyright (c) 2016 - 2018, Nordic Semiconductor ASA + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * 3. Neither the name of Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#include <string.h> +#include "es_flash.h" +#include "es_util.h" +#include "app_scheduler.h" +#include "ble_hci.h" +#include "fds.h" +#include "nrf_nvic.h" + +#define SIZE_OF_PRIV_KEY ESCS_ECDH_KEY_SIZE //!< Size of ECDH private key. +#define SIZE_OF_PUB_KEY ESCS_ECDH_KEY_SIZE //!< Size of ECDH public key. +#define SIZE_OF_LOCK_KEY ESCS_AES_KEY_SIZE //!< Size of lock key. +#define FILE_ID_ES_FLASH 0x1337 //!< File ID used for all flash access EXCEPT lock code. +#define FILE_ID_ES_FLASH_LOCK_KEY 0x1338 //!< File ID used for lock code flash access. +#define RECORD_KEY_FLAGS 0x1 //!< File record for flash flags. +#define RECORD_KEY_PRIV_KEY 0x2 //!< File record for private key. +#define RECORD_KEY_PUB_KEY 0x3 //!< File record for public key. +#define RECORD_KEY_LOCK_KEY 0x4 //!< File record for lock key. +#define RECORD_KEY_BEACON_CONFIG 0x5 //!< File record for lock key. + +static uint16_t RECORD_KEY_SLOTS[5] = {0x6, 0x7, 0x8, 0x9, 0xa}; //!< File record for slots. + +/**@brief Structure used for invoking flash access function. */ +typedef struct +{ + uint16_t record_key; + uint16_t file_id; + uint8_t * p_data_buf; + uint8_t * p_data; + uint16_t size_bytes; + es_flash_access_t access_type; +} flash_access_params_t; + +static volatile uint32_t m_num_pending_ops; //!< Current number of outstanding FDS operations. +static volatile bool m_factory_reset; //!< Should factory reset be performed. +static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; //!< Current connection handle. + + +#if APP_MAX_ADV_SLOTS > 32 +#error "APP_MAX_ADV_SLOTS must be <= 32" +#endif + +#define SLOT_DECL(i, _) __ALIGN(4) static uint8_t slot## i ##_buf[sizeof(es_slot_t)]; +EVAL(REPEAT(APP_MAX_ADV_SLOTS, SLOT_DECL, ~)) + +__ALIGN(4) static uint8_t lock_key_buf[SIZE_OF_LOCK_KEY]; //!< Buffer for lock key flash access. + +#define SLOT(i, _) slot## i ##_buf, +static uint8_t * slots_buf_p[APP_MAX_ADV_SLOTS] = { + EVAL(REPEAT(APP_MAX_ADV_SLOTS, SLOT, ~)) +}; + +__ALIGN(4) static uint8_t flash_flags_buf[sizeof(es_flash_flags_t)]; //!< Buffer for flash flags flash access. +__ALIGN(4) static uint8_t beacon_config_buf[sizeof(es_flash_beacon_config_t)]; //!< Buffer for beacon config flash access. + +/**@brief Function handling scheduled FDS garbage collection. */ +static void fds_gc_event(void * p_event_data, uint16_t event_size) +{ + ret_code_t fds_err_code; + + fds_err_code = fds_gc(); + if (fds_err_code != FDS_SUCCESS) + APP_ERROR_CHECK_BOOL(NRF_ERROR_INTERNAL); + m_num_pending_ops++; +} + + +/**@brief Function handling FDS events. + * + * @param[in] p_evt FDS event. + */ +static void fds_cb(fds_evt_t const * const p_evt) +{ + ret_code_t err_code; + + switch (p_evt->id) + { + case FDS_EVT_INIT: + m_num_pending_ops = 0; + break; + + case FDS_EVT_DEL_FILE: + case FDS_EVT_DEL_RECORD: + // Schedule garbage collection + err_code = app_sched_event_put(NULL, 0, fds_gc_event); + APP_ERROR_CHECK(err_code); + break; + + case FDS_EVT_GC: + if (m_factory_reset && m_conn_handle != BLE_CONN_HANDLE_INVALID) + { + err_code = + sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); + APP_ERROR_CHECK(err_code); + } + + // Fall through: + case FDS_EVT_UPDATE: + case FDS_EVT_WRITE: + if (m_num_pending_ops > 0) + { + m_num_pending_ops--; + } + break; + } +} + + +/**@brief Function performing flash access (read/write/clear). + * + * @param[in] p_params Flash access parameters. + */ +static ret_code_t access_flash_data(const flash_access_params_t * p_params) +{ + ret_code_t err_code; + fds_flash_record_t record = {0}; + fds_record_desc_t desc = {0}; + fds_find_token_t ft = {0}; + fds_record_t record_to_write = + { + .data.p_data = p_params->p_data_buf, + .file_id = p_params->file_id + }; + + err_code = fds_record_find_by_key(p_params->record_key, &desc, &ft); + + // If its a read or clear, we can not accept errors on lookup + if (p_params->access_type == ES_FLASH_ACCESS_READ) + { + RETURN_IF_ERROR(err_code); + } + + if (p_params->access_type == ES_FLASH_ACCESS_CLEAR && err_code == FDS_ERR_NOT_FOUND) + { + return NRF_SUCCESS; + } + + switch (p_params->access_type) + { + case ES_FLASH_ACCESS_READ: + err_code = fds_record_open(&desc, &record); + RETURN_IF_ERROR(err_code); + + memcpy(p_params->p_data, record.p_data, p_params->size_bytes); + + err_code = fds_record_close(&desc); + RETURN_IF_ERROR(err_code); + + break; + + case ES_FLASH_ACCESS_WRITE: + memcpy(p_params->p_data_buf, p_params->p_data, p_params->size_bytes); + + record_to_write.data.length_words = (p_params->size_bytes +3) / 4; + record_to_write.key = p_params->record_key; + + if (err_code == FDS_ERR_NOT_FOUND) + { + err_code = fds_record_write(&desc, &record_to_write); + } + + else + { + err_code = fds_record_update(&desc, &record_to_write); + } + + RETURN_IF_ERROR(err_code); + m_num_pending_ops++; + break; + + case ES_FLASH_ACCESS_CLEAR: + err_code = fds_record_delete(&desc); + RETURN_IF_ERROR(err_code); + m_num_pending_ops++; + break; + + default: + break; + } + return NRF_SUCCESS; +} + + +ret_code_t es_flash_access_lock_key(uint8_t * p_lock_key, es_flash_access_t access_type) +{ + flash_access_params_t params = {.record_key = RECORD_KEY_LOCK_KEY, + .file_id = FILE_ID_ES_FLASH_LOCK_KEY, + .p_data_buf = lock_key_buf, + .p_data = (uint8_t *)p_lock_key, + .size_bytes = SIZE_OF_LOCK_KEY, + .access_type = access_type}; + + return access_flash_data(¶ms); +} + + +ret_code_t es_flash_access_beacon_config(es_flash_beacon_config_t * p_config, + es_flash_access_t access_type) +{ + ret_code_t err_code; + + flash_access_params_t params = {.record_key = RECORD_KEY_BEACON_CONFIG, + .file_id = FILE_ID_ES_FLASH, + .p_data_buf = beacon_config_buf, + .p_data = (uint8_t *)p_config, + .size_bytes = sizeof(es_flash_beacon_config_t), + .access_type = access_type}; + + err_code = access_flash_data(¶ms); + + return err_code; +} + + +ret_code_t es_flash_access_slot_configs(uint8_t slot_no, + es_slot_t * p_slot, + es_flash_access_t access_type) +{ + if (slot_no >= APP_MAX_ADV_SLOTS) + { + return NRF_ERROR_INVALID_PARAM; + } + + flash_access_params_t params = {.record_key = RECORD_KEY_SLOTS[slot_no], + .file_id = FILE_ID_ES_FLASH, + .p_data_buf = slots_buf_p[slot_no], + .p_data = (uint8_t *)p_slot, + .size_bytes = sizeof(es_slot_t), + .access_type = access_type}; + + return access_flash_data(¶ms); +} + + +ret_code_t es_flash_access_flags(es_flash_flags_t * p_flags, es_flash_access_t access_type) +{ + flash_access_params_t params = {.record_key = RECORD_KEY_FLAGS, + .file_id = FILE_ID_ES_FLASH, + .p_data_buf = flash_flags_buf, + .p_data = (uint8_t *)p_flags, + .size_bytes = sizeof(es_flash_flags_t), + .access_type = access_type}; + + return access_flash_data(¶ms); +} + + +ret_code_t es_flash_factory_reset(void) +{ + // Delete everything except the lock key: + ret_code_t ret_code = fds_file_delete(FILE_ID_ES_FLASH); + + if (ret_code == FDS_SUCCESS) + m_factory_reset = true; + return ret_code; +} + + +uint32_t es_flash_num_pending_ops(void) +{ + return m_num_pending_ops; +} + + +void es_flash_on_ble_evt(ble_evt_t const * p_evt) +{ + switch (p_evt->header.evt_id) + { + case BLE_GAP_EVT_CONNECTED: + m_conn_handle = p_evt->evt.common_evt.conn_handle; + break; + + case BLE_GAP_EVT_DISCONNECTED: + m_conn_handle = BLE_CONN_HANDLE_INVALID; + if (m_factory_reset) + { + (void)sd_nvic_SystemReset(); + } + break; + } +} + + +ret_code_t es_flash_init(void) +{ + ret_code_t err_code; + + m_num_pending_ops = 1; // Will be set to 0 when getting FDS_EVT_INIT event + + m_conn_handle = BLE_CONN_HANDLE_INVALID; + + m_factory_reset = false; + + err_code = fds_register(fds_cb); + RETURN_IF_ERROR(err_code); + + err_code = fds_init(); + RETURN_IF_ERROR(err_code); + + return NRF_SUCCESS; +} + |