You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by ma...@apache.org on 2016/11/22 20:06:55 UTC
[41/59] [abbrv] [partial] incubator-mynewt-core git commit: Remove
non-Apache-compatible Nordic SDK files.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/a1481cb2/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/pstorage/config/pstorage_platform.h
----------------------------------------------------------------------
diff --git a/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/pstorage/config/pstorage_platform.h b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/pstorage/config/pstorage_platform.h
deleted file mode 100644
index 5dd217a..0000000
--- a/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/pstorage/config/pstorage_platform.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/* Copyright (c) 2013 Nordic Semiconductor. All Rights Reserved.
- *
- * The information contained herein is property of Nordic Semiconductor ASA.
- * Terms and conditions of usage are described in detail in NORDIC
- * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
- *
- * Licensees are granted free, non-transferable use of the information. NO
- * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
- * the file.
- *
- */
-
- /** @cond To make doxygen skip this file */
-
-/** @file
- * This header contains defines with respect persistent storage that are specific to
- * persistent storage implementation and application use case.
- */
-#ifndef PSTORAGE_PL_H__
-#define PSTORAGE_PL_H__
-
-#include <stdint.h>
-#include "nrf.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static __INLINE uint16_t pstorage_flash_page_size()
-{
- return (uint16_t)NRF_FICR->CODEPAGESIZE;
-}
-
-#define PSTORAGE_FLASH_PAGE_SIZE pstorage_flash_page_size() /**< Size of one flash page. */
-#define PSTORAGE_FLASH_EMPTY_MASK 0xFFFFFFFF /**< Bit mask that defines an empty address in flash. */
-
-static __INLINE uint32_t pstorage_flash_page_end()
-{
- uint32_t bootloader_addr = NRF_UICR->NRFFW[0];
-
- return ((bootloader_addr != PSTORAGE_FLASH_EMPTY_MASK) ?
- (bootloader_addr/ PSTORAGE_FLASH_PAGE_SIZE) : NRF_FICR->CODESIZE);
-}
-
-#define PSTORAGE_FLASH_PAGE_END pstorage_flash_page_end()
-
-#define PSTORAGE_NUM_OF_PAGES 1 /**< Number of flash pages allocated for the pstorage module excluding the swap page, configurable based on system requirements. */
-#define PSTORAGE_MIN_BLOCK_SIZE 0x0010 /**< Minimum size of block that can be registered with the module. Should be configured based on system requirements, recommendation is not have this value to be at least size of word. */
-
-#define PSTORAGE_DATA_START_ADDR ((PSTORAGE_FLASH_PAGE_END - PSTORAGE_NUM_OF_PAGES - 1) \
- * PSTORAGE_FLASH_PAGE_SIZE) /**< Start address for persistent data, configurable according to system requirements. */
-#define PSTORAGE_DATA_END_ADDR ((PSTORAGE_FLASH_PAGE_END - 1) * PSTORAGE_FLASH_PAGE_SIZE) /**< End address for persistent data, configurable according to system requirements. */
-#define PSTORAGE_SWAP_ADDR PSTORAGE_DATA_END_ADDR /**< Top-most page is used as swap area for clear and update. */
-
-#define PSTORAGE_MAX_BLOCK_SIZE PSTORAGE_FLASH_PAGE_SIZE /**< Maximum size of block that can be registered with the module. Should be configured based on system requirements. And should be greater than or equal to the minimum size. */
-#define PSTORAGE_CMD_QUEUE_SIZE 10 /**< Maximum number of flash access commands that can be maintained by the module for all applications. Configurable. */
-
-
-/** Abstracts persistently memory block identifier. */
-typedef uint32_t pstorage_block_t;
-
-typedef struct
-{
- uint32_t module_id; /**< Module ID.*/
- pstorage_block_t block_id; /**< Block ID.*/
-} pstorage_handle_t;
-
-typedef uint16_t pstorage_size_t; /** Size of length and offset fields. */
-
-/**@brief Handles Flash Access Result Events. To be called in the system event dispatcher of the application. */
-void pstorage_sys_event_handler (uint32_t sys_evt);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // PSTORAGE_PL_H__
-
-/** @} */
-/** @endcond */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/a1481cb2/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/pstorage/pstorage.c
----------------------------------------------------------------------
diff --git a/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/pstorage/pstorage.c b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/pstorage/pstorage.c
deleted file mode 100644
index 7d64e11..0000000
--- a/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/pstorage/pstorage.c
+++ /dev/null
@@ -1,1572 +0,0 @@
-/* Copyright (c) 2013 Nordic Semiconductor. All Rights Reserved.
- *
- * The information contained herein is property of Nordic Semiconductor ASA.
- * Terms and conditions of usage are described in detail in NORDIC
- * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
- *
- * Licensees are granted free, non-transferable use of the information. NO
- * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
- * the file.
- *
- */
-
-#include "pstorage.h"
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include "nordic_common.h"
-#include "nrf_error.h"
-#include "nrf_assert.h"
-#include "nrf.h"
-#include "nrf_soc.h"
-#include "app_util.h"
-#include "app_error.h"
-
-#define INVALID_OPCODE 0x00 /**< Invalid op code identifier. */
-#define SOC_MAX_WRITE_SIZE PSTORAGE_FLASH_PAGE_SIZE /**< Maximum write size allowed for a single call to \ref sd_flash_write as specified in the SoC API. */
-#define RAW_MODE_APP_ID (PSTORAGE_NUM_OF_PAGES + 1) /**< Application id for raw mode. */
-
-#if defined(NRF52)
-#define SD_CMD_MAX_TRIES 1000 /**< Number of times to try a softdevice flash operatoion, specific for nRF52 to account for longest time of flash page erase*/
-#else
-#define SD_CMD_MAX_TRIES 3 /**< Number of times to try a softdevice flash operation when the @ref NRF_EVT_FLASH_OPERATION_ERROR sys_evt is received. */
-#endif /* defined(NRF52) */
-
-#define MASK_TAIL_SWAP_DONE (1 << 0) /**< Flag for checking if the tail restore area has been written to swap page. */
-#define MASK_SINGLE_PAGE_OPERATION (1 << 1) /**< Flag for checking if command is a single flash page operation. */
-#define MASK_MODULE_INITIALIZED (1 << 2) /**< Flag for checking if the module has been initialized. */
-#define MASK_FLASH_API_ERR_BUSY (1 << 3) /**< Flag for checking if flash API returned NRF_ERROR_BUSY. */
-
-/**
- * @defgroup api_param_check API Parameters check macros.
- *
- * @details Macros that verify parameters passed to the module in the APIs. These macros
- * could be mapped to nothing in final code versions to save execution and size.
- *
- * @{
- */
-
-/**@brief Check if the input pointer is NULL, if so it returns NRF_ERROR_NULL.
- */
-#define NULL_PARAM_CHECK(PARAM) \
- if ((PARAM) == NULL) \
- { \
- return NRF_ERROR_NULL; \
- }
-
-/**@brief Verifies that the module identifier supplied by the application is within permissible
- * range.
- */
-#define MODULE_ID_RANGE_CHECK(ID) \
- if ((((ID)->module_id) >= PSTORAGE_NUM_OF_PAGES) || \
- (m_app_table[(ID)->module_id].cb == NULL)) \
- { \
- return NRF_ERROR_INVALID_PARAM; \
- }
-
-/**@brief Verifies that the block identifier supplied by the application is within the permissible
- * range.
- */
-#define BLOCK_ID_RANGE_CHECK(ID) \
- if (((ID)->block_id) >= (m_app_table[(ID)->module_id].base_id + \
- (m_app_table[(ID)->module_id].block_count * MODULE_BLOCK_SIZE(ID)))) \
- { \
- return NRF_ERROR_INVALID_PARAM; \
- }
-
-/**@brief Verifies that the block size requested by the application can be supported by the module.
- */
-#define BLOCK_SIZE_CHECK(X) \
- if (((X) > PSTORAGE_MAX_BLOCK_SIZE) || ((X) < PSTORAGE_MIN_BLOCK_SIZE)) \
- { \
- return NRF_ERROR_INVALID_PARAM; \
- }
-
-/**@brief Verifies the block size requested by the application in registration API.
- */
-#define BLOCK_COUNT_CHECK(COUNT, SIZE) \
- if (((COUNT) == 0) || \
- ((m_next_page_addr + ((COUNT) *(SIZE)) > PSTORAGE_SWAP_ADDR))) \
- { \
- return NRF_ERROR_INVALID_PARAM; \
- }
-
-/**@brief Verifies the size parameter provided by the application in API.
- */
-#define SIZE_CHECK(ID, SIZE) \
- if(((SIZE) == 0) || ((SIZE) > MODULE_BLOCK_SIZE(ID))) \
- { \
- return NRF_ERROR_INVALID_PARAM; \
- }
-
-/**@brief Verifies the offset parameter provided by the application in API.
- */
-#define OFFSET_CHECK(ID, OFFSET, SIZE) \
- if(((SIZE) + (OFFSET)) > MODULE_BLOCK_SIZE(ID)) \
- { \
- return NRF_ERROR_INVALID_PARAM; \
- }
-
-#ifdef PSTORAGE_RAW_MODE_ENABLE
-
-/**@brief Verifies the module identifier supplied by the application.
- */
-#define MODULE_RAW_HANDLE_CHECK(ID) \
- if ((((ID)->module_id) != RAW_MODE_APP_ID)) \
- { \
- return NRF_ERROR_INVALID_PARAM; \
- }
-
-#endif // PSTORAGE_RAW_MODE_ENABLE
-
-/**@} */
-
-
-/**@brief Verify module's initialization status.
- *
- * @details Verify module's initialization status. Returns NRF_ERROR_INVALID_STATE when a
- * module API is called without initializing the module.
- */
-#define VERIFY_MODULE_INITIALIZED() \
- do \
- { \
- if (!(m_flags & MASK_MODULE_INITIALIZED)) \
- { \
- return NRF_ERROR_INVALID_STATE; \
- } \
- } while(0)
-
-/**@brief Macro to fetch the block size registered for the module. */
-#define MODULE_BLOCK_SIZE(ID) (m_app_table[(ID)->module_id].block_size)
-
-/**@brief Main state machine of the component. */
-typedef enum
-{
- STATE_IDLE, /**< State for being idle (no command execution in progress). */
- STATE_STORE, /**< State for storing data when using store/update API. */
- STATE_DATA_ERASE_WITH_SWAP, /**< State for erasing the data page when using update/clear API when use of swap page is required. */
- STATE_DATA_ERASE, /**< State for erasing the data page when using update/clear API without the need to use the swap page. */
- STATE_ERROR /**< State entered when command processing is terminated abnormally. */
-} pstorage_state_t;
-
-/**@brief Sub state machine contained by @ref STATE_DATA_ERASE_WITH_SWAP super state machine. */
-typedef enum
-{
- STATE_ERASE_SWAP, /**< State for erasing the swap page when using the update/clear API. */
- STATE_WRITE_DATA_TO_SWAP, /**< State for writing the data page into the swap page when using update/clear API. */
- STATE_ERASE_DATA_PAGE, /**< State for erasing data page when using update/clear API. */
- STATE_RESTORE_TAIL, /**< State for restoring tail (end) of backed up data from swap to data page when using update/clear API. */
- STATE_RESTORE_HEAD, /**< State for restoring head (beginning) of backed up data from swap to data page when using update/clear API. */
- SWAP_SUB_STATE_MAX /**< Enumeration upper bound. */
-} flash_swap_sub_state_t;
-
-/**@brief Application registration information.
- *
- * @details Defines application specific information that the application needs to maintain to be able
- * to process requests from each one of them.
- */
-typedef struct
-{
- pstorage_ntf_cb_t cb; /**< Callback registered with the module to be notified of result of flash access. */
- pstorage_block_t base_id; /**< Base block ID assigned to the module. */
- pstorage_size_t block_size; /**< Size of block for the module. */
- pstorage_size_t block_count; /**< Number of blocks requested by the application. */
-} pstorage_module_table_t;
-
-
-#ifdef PSTORAGE_RAW_MODE_ENABLE
-/**@brief Application registration information.
- *
- * @details Defines application specific information that the application registered for raw mode.
- */
-typedef struct
-{
- pstorage_ntf_cb_t cb; /**< Callback registered with the module to be notified of the result of flash access. */
-} pstorage_raw_module_table_t;
-#endif // PSTORAGE_RAW_MODE_ENABLE
-
-
-/**@brief Defines command queue element.
- *
- * @details Defines command queue element. Each element encapsulates needed information to process
- * a flash access command.
- */
-typedef struct
-{
- uint8_t op_code; /**< Identifies the flash access operation being queued. Element is free if op-code is INVALID_OPCODE. */
- pstorage_size_t size; /**< Identifies the size in bytes requested for the operation. */
- pstorage_size_t offset; /**< Offset requested by the application for the access operation. */
- pstorage_handle_t storage_addr; /**< Address/Identifier for persistent memory. */
- uint8_t * p_data_addr; /**< Address/Identifier for data memory. This is assumed to be resident memory. */
-} cmd_queue_element_t;
-
-
-/**@brief Defines command queue, an element is free if the op_code field is not invalid.
- *
- * @details Defines commands enqueued for flash access. At any point in time, this queue has one or
- * more flash access operations pending if the count field is not zero. When the queue is
- * not empty, the rp (read pointer) field points to the flash access command in progress
- * or, if none is in progress, the command to be requested next. The queue implements a
- * simple first in first out algorithm. Data addresses are assumed to be resident.
- */
-typedef struct
-{
- uint8_t rp; /**< Read pointer, pointing to flash access that is ongoing or to be requested next. */
- uint8_t count; /**< Number of elements in the queue. */
- cmd_queue_element_t cmd[PSTORAGE_CMD_QUEUE_SIZE]; /**< Array to maintain flash access operation details. */
-} cmd_queue_t;
-
-static cmd_queue_t m_cmd_queue; /**< Flash operation request queue. */
-static pstorage_size_t m_next_app_instance; /**< Points to the application module instance that can be allocated next. */
-static uint32_t m_next_page_addr; /**< Points to the flash address that can be allocated to a module next. This is needed as blocks of a module that can span across flash pages. */
-static pstorage_state_t m_state; /**< Main state tracking variable. */
-static flash_swap_sub_state_t m_swap_sub_state; /**< Flash swap erase when swap used state tracking variable. */
-static uint32_t m_head_word_size; /**< Head restore area size in words. */
-static uint32_t m_tail_word_size; /**< Tail restore area size in words. */
-static uint32_t m_current_page_id; /**< Variable for tracking the flash page being processed. */
-static uint32_t m_num_of_command_retries; /**< Variable for tracking flash operation retries upon flash operation failures. */
-static pstorage_module_table_t m_app_table[PSTORAGE_NUM_OF_PAGES]; /**< Registered application information table. */
-static uint32_t m_num_of_bytes_written; /**< Variable for tracking the number of bytes written by the store operation. */
-static uint32_t m_app_data_size; /**< Variable for storing the application command size parameter internally. */
-static uint32_t m_flags = 0; /**< Storage for boolean flags for state tracking. */
-
-#ifdef PSTORAGE_RAW_MODE_ENABLE
-static pstorage_raw_module_table_t m_raw_app_table; /**< Registered application information table for raw mode. */
-#endif // PSTORAGE_RAW_MODE_ENABLE
-
-// Required forward declarations.
-static void cmd_process(void);
-static void store_operation_execute(void);
-static void app_notify(uint32_t result, cmd_queue_element_t * p_elem);
-static void cmd_queue_element_init(uint32_t index);
-static void cmd_queue_dequeue(void);
-static void sm_state_change(pstorage_state_t new_state);
-static void swap_sub_state_state_change(flash_swap_sub_state_t new_state);
-
-/**@brief Function for consuming a command queue element.
- *
- * @details Function for consuming a command queue element, which has been fully processed.
- */
-static void command_queue_element_consume(void)
-{
- // Initialize/free the element as it is now processed.
- cmd_queue_element_init(m_cmd_queue.rp);
-
- // Adjust command queue state tracking variables.
- --(m_cmd_queue.count);
- if (++(m_cmd_queue.rp) == PSTORAGE_CMD_QUEUE_SIZE)
- {
- m_cmd_queue.rp = 0;
- }
-}
-
-
-/**@brief Function for executing the finalization procedure for the command executed.
- *
- * @details Function for executing the finalization procedure for command executed, which includes
- * notifying the application of command completion, consuming the command queue element,
- * and changing the internal state.
- */
-static void command_end_procedure_run(void)
-{
- app_notify(NRF_SUCCESS, &m_cmd_queue.cmd[m_cmd_queue.rp]);
-
- command_queue_element_consume();
-
- sm_state_change(STATE_IDLE);
-}
-
-
-/**@brief Function for idle state entry actions.
- *
- * @details Function for idle state entry actions, which include resetting relevant state data and
- * scheduling any possible queued flash access operation.
- */
-static void state_idle_entry_run(void)
-{
- m_num_of_command_retries = 0;
- m_num_of_bytes_written = 0;
-
- // Schedule any possible queued flash access operation.
- cmd_queue_dequeue();
-}
-
-
-/**@brief Function for notifying an application of command completion and transitioning to an error
- * state.
- *
- * @param[in] result Result code of the operation for the application.
- */
-static void app_notify_error_state_transit(uint32_t result)
-{
- app_notify(result, &m_cmd_queue.cmd[m_cmd_queue.rp]);
- sm_state_change(STATE_ERROR);
-}
-
-
-/**@brief Function for processing flash API error code.
- *
- * @param[in] err_code Error code from the flash API.
- */
-static void flash_api_err_code_process(uint32_t err_code)
-{
- switch (err_code)
- {
- case NRF_SUCCESS:
- break;
-
- case NRF_ERROR_BUSY:
- // Flash access operation was not accepted and must be reissued upon flash operation
- // complete event.
- m_flags |= MASK_FLASH_API_ERR_BUSY;
- break;
-
- default:
- // Complete the operation with appropriate result code and transit to an error state.
- app_notify_error_state_transit(err_code);
- break;
- }
-}
-
-/**@brief Function for writing data to flash.
- *
- * @param[in] p_dst Pointer to start of flash location to be written.
- * @param[in] p_src Pointer to buffer with data to be written.
- * @param[in] size_in_words Number of 32-bit words to write.
- */
-static void flash_write(uint32_t * const p_dst,
- uint32_t const * const p_src,
- uint32_t size_in_words)
-{
- flash_api_err_code_process(sd_flash_write(p_dst, p_src, size_in_words));
-}
-
-
-/**@brief Function for writing data to flash upon store command.
- *
- * @details Function for writing data to flash upon executing store command. Data is written to
- * flash in reverse order, meaning starting at the end. If the data that is to be written
- * is greater than the flash page size, it will be fragmented to fit the flash page size.
- */
-static void store_cmd_flash_write_execute(void)
-{
- const cmd_queue_element_t * p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
-
- if (p_cmd->size > SOC_MAX_WRITE_SIZE)
- {
- const uint32_t offset = p_cmd->size - PSTORAGE_FLASH_PAGE_SIZE;
- flash_write((uint32_t *)(p_cmd->storage_addr.block_id + p_cmd->offset + offset),
- (uint32_t *)(p_cmd->p_data_addr + offset),
- PSTORAGE_FLASH_PAGE_SIZE / sizeof(uint32_t));
-
- m_num_of_bytes_written = PSTORAGE_FLASH_PAGE_SIZE;
- }
- else
- {
- flash_write((uint32_t *)(p_cmd->storage_addr.block_id + p_cmd->offset),
- (uint32_t *)(p_cmd->p_data_addr),
- p_cmd->size / sizeof(uint32_t));
-
- m_num_of_bytes_written = p_cmd->size;
- }
-}
-
-
-/**@brief Function for store state entry action.
- *
- * @details Function for store state entry action, which includes writing data to a flash page.
- */
-static void state_store_entry_run(void)
-{
- store_cmd_flash_write_execute();
-}
-
-
-/**@brief Function for data erase with swap state entry actions.
- *
- * @details Function for data erase with swap state entry actions. This includes adjusting relevant
- * state and data variables and transitioning to the correct sub state.
- */
-static void state_data_erase_swap_entry_run(void)
-{
- m_flags &= ~MASK_TAIL_SWAP_DONE;
-
- const cmd_queue_element_t * p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
- const pstorage_block_t cmd_block_id = p_cmd->storage_addr.block_id;
-
- const uint32_t clear_start_page_id = cmd_block_id / PSTORAGE_FLASH_PAGE_SIZE;
- m_current_page_id = clear_start_page_id;
-
- // @note: No need to include p_cmd->offset when calculating clear_end_page_id as:
- // - clear API does not include offset parameter
- // - update and store APIs are limited to operate on single block boundary thus the boolean
- // clause ((m_head_word_size == 0) && is_more_than_one_page) below in this function will never
- // evaluate as true as if is_more_than_one_page == true m_head_word_size is always != 0
- const uint32_t clear_end_page_id = (cmd_block_id + p_cmd->size - 1u) /
- PSTORAGE_FLASH_PAGE_SIZE;
-
- if (clear_start_page_id == clear_end_page_id)
- {
- m_flags |= MASK_SINGLE_PAGE_OPERATION;
- }
- else
- {
- m_flags &= ~MASK_SINGLE_PAGE_OPERATION;
- }
-
- if ((m_head_word_size == 0) && !(m_flags & MASK_SINGLE_PAGE_OPERATION))
- {
- // No head restore required and clear/update area is shared by multiple flash pages, which
- // means the current flash page does not have any tail area to restore. You can proceed with
- // data page erase directly as no swap is needed for the current flash page.
- swap_sub_state_state_change(STATE_ERASE_DATA_PAGE);
- }
- else
- {
- swap_sub_state_state_change(STATE_ERASE_SWAP);
- }
-}
-
-
-/**@brief Function for erasing flash page.
- *
- * @param[in] page_number Page number of the page to be erased.
- */
-static void flash_page_erase(uint32_t page_number)
-{
- flash_api_err_code_process(sd_flash_page_erase(page_number));
-}
-
-
-/**@brief Function for data erase state entry action.
- *
- * @details Function for data erase state entry action, which includes erasing the data flash page.
- */
-static void state_data_erase_entry_run(void)
-{
- flash_page_erase(m_current_page_id);
-}
-
-
-/**@brief Function for dispatching the correct application main state entry action.
- */
-static void state_entry_action_run(void)
-{
- switch (m_state)
- {
- case STATE_IDLE:
- state_idle_entry_run();
- break;
-
- case STATE_STORE:
- state_store_entry_run();
- break;
-
- case STATE_DATA_ERASE_WITH_SWAP:
- state_data_erase_swap_entry_run();
- break;
-
- case STATE_DATA_ERASE:
- state_data_erase_entry_run();
- break;
-
- default:
- // No action needed.
- break;
- }
-}
-
-
-/**@brief Function for changing application main state and dispatching state entry action.
- *
- * @param[in] new_state New application main state to transit to.
- */
-static void sm_state_change(pstorage_state_t new_state)
-{
- m_state = new_state;
- state_entry_action_run();
-}
-
-
-/**@brief Function for swap erase state entry action.
- *
- * @details Function for swap erase state entry action, which includes erasing swap flash
- * page.
- */
-static void state_swap_erase_entry_run(void)
-{
- flash_page_erase(PSTORAGE_SWAP_ADDR / PSTORAGE_FLASH_PAGE_SIZE);
-}
-
-
-/**@brief Function for write data to the swap state entry action.
- *
- * @details Function for write data to the swap state entry action, which includes writing the
- * current data page to the swap flash page.
- */
-static void state_write_data_swap_entry_run(void)
-{
- // @note: There is room for further optimization here as there is only need to write the
- // whole flash page to swap area if there is both head and tail area to be restored. In any
- // other case we can omit some data from the head or end of the page as that is the clear area.
- flash_write((uint32_t *)(PSTORAGE_SWAP_ADDR),
- (uint32_t *)(m_current_page_id * PSTORAGE_FLASH_PAGE_SIZE),
- PSTORAGE_FLASH_PAGE_SIZE / sizeof(uint32_t));
-}
-
-
-/**@brief Function for erase data page state entry action.
- *
- * @details Function for erase data page state entry action, which includes erasing the data flash
- * page.
- */
-static void state_erase_data_page_entry_run(void)
-{
- flash_page_erase(m_current_page_id);
-}
-
-
-/**@brief Function for restore tail state entry action.
- *
- * @details Function for restore tail state entry action, which includes writing the tail section
- * back from swap to the data page.
- */
-static void state_restore_tail_entry_run(void)
-{
- const cmd_queue_element_t * p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
- const pstorage_block_t cmd_block_id = p_cmd->storage_addr.block_id;
-
- const uint32_t tail_offset = (cmd_block_id + p_cmd->size + p_cmd->offset) %
- PSTORAGE_FLASH_PAGE_SIZE;
-
- flash_write((uint32_t *)(cmd_block_id + p_cmd->size + p_cmd->offset),
- (uint32_t *)(PSTORAGE_SWAP_ADDR + tail_offset),
- m_tail_word_size);
-}
-
-
-/**@brief Function for restore head state entry action.
- *
- * @details Function for restore head state entry action, which includes writing the head section
- * back from swap to the data page.
- */
-static void state_restore_head_entry_run(void)
-{
- flash_write((uint32_t *)((m_current_page_id - 1u) * PSTORAGE_FLASH_PAGE_SIZE),
- (uint32_t *)PSTORAGE_SWAP_ADDR,
- m_head_word_size);
-}
-
-
-/**@brief Function for dispatching the correct swap sub state entry action.
- */
-static void swap_sub_state_entry_action_run(void)
-{
- static void (* const swap_sub_state_sm_lut[SWAP_SUB_STATE_MAX])(void) =
- {
- state_swap_erase_entry_run,
- state_write_data_swap_entry_run,
- state_erase_data_page_entry_run,
- state_restore_tail_entry_run,
- state_restore_head_entry_run
- };
-
- swap_sub_state_sm_lut[m_swap_sub_state]();
-}
-
-
-/**@brief Function for changing the swap sub state and dispatching state entry action.
- *
- * @param[in] new_state New swap sub state to transit to.
- */
-static void swap_sub_state_state_change(flash_swap_sub_state_t new_state)
-{
- m_swap_sub_state = new_state;
- swap_sub_state_entry_action_run();
-}
-
-
-/**@brief Function for initializing the command queue element.
- *
- * @param[in] index Index of the element to be initialized.
- */
-static void cmd_queue_element_init(uint32_t index)
-{
- // Internal function and checks on range of index can be avoided.
- m_cmd_queue.cmd[index].op_code = INVALID_OPCODE;
- m_cmd_queue.cmd[index].size = 0;
- m_cmd_queue.cmd[index].storage_addr.module_id = PSTORAGE_NUM_OF_PAGES;
- m_cmd_queue.cmd[index].storage_addr.block_id = 0;
- m_cmd_queue.cmd[index].p_data_addr = NULL;
- m_cmd_queue.cmd[index].offset = 0;
-}
-
-
-/**@brief Function for initializing the command queue.
- */
-static void cmd_queue_init(void)
-{
- m_cmd_queue.rp = 0;
- m_cmd_queue.count = 0;
-
- for (uint32_t cmd_index = 0; cmd_index < PSTORAGE_CMD_QUEUE_SIZE; ++cmd_index)
- {
- cmd_queue_element_init(cmd_index);
- }
-}
-
-
-/**@brief Function for enqueuing, and possibly dispatching, a flash access operation.
- *
- * @param[in] opcode Identifies the operation requested to be enqueued.
- * @param[in] p_storage_addr Identifies the module and flash address on which the operation is
- * requested.
- * @param[in] p_data_addr Identifies the data address for flash access.
- * @param[in] size Size in bytes of data requested for the access operation.
- * @param[in] offset Offset within the flash memory block at which operation is requested.
- *
- * @retval NRF_SUCCESS Upon success.
- * @retval NRF_ERROR_NO_MEM Upon failure, when no space is available in the command queue.
- */
-static uint32_t cmd_queue_enqueue(uint8_t opcode,
- pstorage_handle_t * p_storage_addr,
- uint8_t * p_data_addr,
- pstorage_size_t size,
- pstorage_size_t offset)
-{
- uint32_t err_code;
-
- if (m_cmd_queue.count != PSTORAGE_CMD_QUEUE_SIZE)
- {
- // Enqueue the command if it the queue is not full.
- uint32_t write_index = m_cmd_queue.rp + m_cmd_queue.count;
-
- if (write_index >= PSTORAGE_CMD_QUEUE_SIZE)
- {
- write_index -= PSTORAGE_CMD_QUEUE_SIZE;
- }
-
- m_cmd_queue.cmd[write_index].op_code = opcode;
- m_cmd_queue.cmd[write_index].p_data_addr = p_data_addr;
- m_cmd_queue.cmd[write_index].storage_addr = (*p_storage_addr);
- m_cmd_queue.cmd[write_index].size = size;
- m_cmd_queue.cmd[write_index].offset = offset;
-
- m_cmd_queue.count++;
-
- if (m_state == STATE_IDLE)
- {
- cmd_process();
- }
-
- err_code = NRF_SUCCESS;
- }
- else
- {
- err_code = NRF_ERROR_NO_MEM;
- }
-
- return err_code;
-}
-
-
-/**@brief Function for dequeing a possible pending flash access operation.
- */
-static void cmd_queue_dequeue(void)
-{
- if ((m_cmd_queue.count != 0))
- {
- cmd_process();
- }
-}
-
-
-/**@brief Function for notifying an application of command completion.
- *
- * @param[in] result Result code of the operation for the application.
- * @param[in] p_elem Pointer to the command queue element for which this result was received.
- */
-static void app_notify(uint32_t result, cmd_queue_element_t * p_elem)
-{
- pstorage_ntf_cb_t ntf_cb;
- const uint8_t op_code = p_elem->op_code;
-
-#ifdef PSTORAGE_RAW_MODE_ENABLE
- if (p_elem->storage_addr.module_id == RAW_MODE_APP_ID)
- {
- ntf_cb = m_raw_app_table.cb;
- }
- else
-#endif // PSTORAGE_RAW_MODE_ENABLE
- {
- ntf_cb = m_app_table[p_elem->storage_addr.module_id].cb;
- }
-
- ntf_cb(&p_elem->storage_addr, op_code, result, p_elem->p_data_addr, m_app_data_size);
-}
-
-
-/**@brief Function for evaluating if a data page swap is required for the tail section on the
- * current page.
- *
- * @retval true If data page swap is required.
- * @retval false If data page swap is not required.
- */
-static bool is_tail_data_page_swap_required(void)
-{
- bool ret_value;
-
- // Extract id of the last page command is executed upon.
- const cmd_queue_element_t * p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
- const pstorage_block_t cmd_block_id = p_cmd->storage_addr.block_id;
- const uint32_t last_page_id = (cmd_block_id + p_cmd->size + p_cmd->offset - 1u) /
- PSTORAGE_FLASH_PAGE_SIZE;
-
- // If tail section area exists and the current page is the last page then tail data page swap is
- // required.
- if ((m_tail_word_size != 0) && (m_current_page_id == last_page_id))
- {
- ret_value = true;
- }
- else
- {
- ret_value = false;
- }
-
- return ret_value;
-}
-
-
-/**@brief Function for performing post processing for the update and clear commands.
- *
- * @details Function for performing post processing for the update and clear commands, which implies
- * executing the correct execution path depending on the command.
- */
-static void clear_post_processing_run(void)
-{
- const cmd_queue_element_t * p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
-
- if (p_cmd->op_code != PSTORAGE_UPDATE_OP_CODE)
- {
- command_end_procedure_run();
- }
- else
- {
- store_operation_execute();
- }
-}
-
-
-/**@brief Function for doing swap sub state exit action.
- */
-static void swap_sub_sm_exit_action_run(void)
-{
- clear_post_processing_run();
-}
-
-
-/**@brief Function for evaluating if the page erase operation is required for the current page.
- *
- * @retval true If page erase is required.
- * @retval false If page erase is not required.
- */
-static bool is_page_erase_required(void)
-{
- bool ret;
-
- const cmd_queue_element_t * p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
- const pstorage_block_t cmd_block_id = p_cmd->storage_addr.block_id;
- const uint32_t id_last_page_to_be_cleared = (cmd_block_id + p_cmd->size +
- p_cmd->offset - 1u) /
- PSTORAGE_FLASH_PAGE_SIZE;
-
- // True if:
- // - current page is not the last page OR
- // - current page is the last page AND no tail exists
- if ((m_current_page_id < id_last_page_to_be_cleared) ||
- ((m_current_page_id == id_last_page_to_be_cleared) && (m_tail_word_size == 0)))
- {
- ret = true;
- }
- else
- {
- ret = false;
- }
-
- return ret;
-}
-
-
-/**@brief Function for reissuing the last flash operation request, which was rejected by the flash
- * API, in swap sub sate.
- */
-static void swap_sub_state_err_busy_process(void)
-{
- // Reissue the request by doing a self transition to the current state.
- m_flags &= ~MASK_FLASH_API_ERR_BUSY;
- swap_sub_state_state_change(m_swap_sub_state);
-}
-
-
-/**@brief Function for doing restore head state action upon flash operation success event.
- *
- * @details Function for doing restore head state action upon flash operation success event, which
- * includes making a state transition depending on the current state.
- */
-static void head_restore_state_run(void)
-{
- if (!(m_flags & MASK_FLASH_API_ERR_BUSY))
- {
- if (is_tail_data_page_swap_required())
- {
- // Additional data page needs to be swapped for tail section as we are clearing a block,
- // which is shared between 2 flash pages.
-
- // Adjust variables to ensure correct state transition path is taken after the tail
- // section swap has completed.
- m_head_word_size = 0;
- m_flags |= MASK_TAIL_SWAP_DONE;
-
- swap_sub_state_state_change(STATE_ERASE_SWAP);
- }
- else if (is_page_erase_required())
- {
- // Additional page erase operation is required.
-
- // Adjust variable to ensure correct state transition path is taken after the additional
- // page erase operation has completed.
- m_head_word_size = 0;
- swap_sub_state_state_change(STATE_ERASE_DATA_PAGE);
- }
- else if (m_tail_word_size != 0)
- {
- // Proceed with restoring tail from swap to data page.
- swap_sub_state_state_change(STATE_RESTORE_TAIL);
- }
- else
- {
- // Swap statemachine execution end reached.
- swap_sub_sm_exit_action_run();
- }
- }
- else
- {
- // As operation request was rejected by the flash API reissue the request.
- swap_sub_state_err_busy_process();
- }
-}
-
-
-/**@brief Function for doing restore tail state action upon flash operation success event.
- */
-static void tail_restore_state_run(void)
-{
- if (!(m_flags & MASK_FLASH_API_ERR_BUSY))
- {
- swap_sub_sm_exit_action_run();
- }
- else
- {
- // As operation request was rejected by the flash API reissue the request.
- swap_sub_state_err_busy_process();
- }
-}
-
-
-/**@brief Function for doing data page erase state action upon a flash operation success event.
- *
- * @details Function for doing data page erase state action upon a flash operation success event,
- * which includes making a state transit to a new state depending on the current state.
- */
-static void data_page_erase_state_run(void)
-{
- if (!(m_flags & MASK_FLASH_API_ERR_BUSY))
- {
- ++m_current_page_id;
-
- if (m_head_word_size != 0)
- {
- swap_sub_state_state_change(STATE_RESTORE_HEAD);
- }
- else if (is_page_erase_required())
- {
- // Additional page erase operation is required.
- swap_sub_state_state_change(STATE_ERASE_DATA_PAGE);
- }
- else if (m_tail_word_size != 0)
- {
- if (!(m_flags & MASK_TAIL_SWAP_DONE))
- {
- // Tail area restore is required and we have not yet written the relevant data page
- // to swap area. Start the process of writing the data page to swap.
- m_flags |= MASK_TAIL_SWAP_DONE;
-
- swap_sub_state_state_change(STATE_ERASE_SWAP);
- }
- else
- {
- // Tail area restore is required and we have already written the relevant data page
- // to swap area. Proceed by restoring the tail area.
- swap_sub_state_state_change(STATE_RESTORE_TAIL);
- }
- }
- else
- {
- swap_sub_sm_exit_action_run();
- }
- }
- else
- {
- // As operation request was rejected by the flash API reissue the request.
- swap_sub_state_err_busy_process();
- }
-}
-
-
-/**@brief Function for doing data to swap write state action upon flash operation success event.
- */
-static void data_to_swap_write_state_run(void)
-{
- if (!(m_flags & MASK_FLASH_API_ERR_BUSY))
- {
- // If the operation is executed only on 1 single flash page it automatically means that tail
- // area is written to the swap, which we store to flags.
- if (m_flags & MASK_SINGLE_PAGE_OPERATION)
- {
- m_flags |= MASK_TAIL_SWAP_DONE;
- }
-
- swap_sub_state_state_change(STATE_ERASE_DATA_PAGE);
- }
- else
- {
- // As operation request was rejected by the flash API reissue the request.
- swap_sub_state_err_busy_process();
- }
-}
-
-
-/**@brief Function for doing swap erase state action upon flash operation success event.
- */
-static void swap_erase_state_run(void)
-{
- if (!(m_flags & MASK_FLASH_API_ERR_BUSY))
- {
- swap_sub_state_state_change(STATE_WRITE_DATA_TO_SWAP);
- }
- else
- {
- // As operation request was rejected by the flash API reissue the request.
- swap_sub_state_err_busy_process();
- }
-}
-
-
-/**@brief Function for dispatching the correct state action for data erase with a swap composite
-* state upon a flash operation success event.
- */
-static void swap_sub_state_sm_run(void)
-{
- static void (* const swap_sub_state_sm_lut[SWAP_SUB_STATE_MAX])(void) =
- {
- swap_erase_state_run,
- data_to_swap_write_state_run,
- data_page_erase_state_run,
- tail_restore_state_run,
- head_restore_state_run
- };
-
- swap_sub_state_sm_lut[m_swap_sub_state]();
-}
-
-
-/**@brief Function for reissuing the last flash operation request, which was rejected by the flash
- * API, in main sate.
- */
-static void main_state_err_busy_process(void)
-{
- // Reissue the request by doing a self transition to the current state.
- m_flags &= ~MASK_FLASH_API_ERR_BUSY;
- sm_state_change(m_state);
-}
-
-
-/**@brief Function for doing erase state action upon flash operation success event.
- *
- * @details Function for doing erase state action upon flash operation success event, which includes
- * making a state transition depending on the current state.
- */
-static void erase_sub_state_sm_run(void)
-{
- if (!(m_flags & MASK_FLASH_API_ERR_BUSY))
- {
- // Clear operation request has succeeded.
- ++m_current_page_id;
-
- if (!is_page_erase_required())
- {
- clear_post_processing_run();
- }
- else
- {
- // All required flash pages have not yet been erased, issue erase by doing a self
- // transit.
- sm_state_change(m_state);
- }
- }
- else
- {
- // As operation request was rejected by the flash API reissue the request.
- main_state_err_busy_process();
- }
-}
-
-
-/**@brief Function for doing store state action upon flash operation success event.
- */
-static void store_sub_state_sm_run(void)
-{
- if (!(m_flags & MASK_FLASH_API_ERR_BUSY))
- {
- // As write operation request has succeeded, adjust the size tracking state information
- // accordingly.
- cmd_queue_element_t * p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
- p_cmd->size -= m_num_of_bytes_written;
-
- if (p_cmd->size == 0)
- {
- command_end_procedure_run();
- }
- else
- {
- store_cmd_flash_write_execute();
- }
- }
- else
- {
- // As operation request was rejected by the flash API reissue the request.
- main_state_err_busy_process();
- }
-}
-
-
-/**@brief Function for doing action upon flash operation success event.
- */
-static void flash_operation_success_run(void)
-{
- switch (m_state)
- {
- case STATE_STORE:
- store_sub_state_sm_run();
- break;
-
- case STATE_DATA_ERASE:
- erase_sub_state_sm_run();
- break;
-
- case STATE_DATA_ERASE_WITH_SWAP:
- swap_sub_state_sm_run();
- break;
-
- default:
- // No implementation needed.
- break;
- }
-}
-
-
-/**@brief Function for doing action upon flash operation failure event.
- *
- * @details Function for doing action upon flash operation failure event, which includes retrying
- * the last operation or if retry count has been reached completing the operation with
- * appropriate result code and transitioning to an error state.
- *
- * @note The command is not removed from the command queue, which will result to stalling of the
- * command pipeline and the appropriate application recovery procedure for this is to reset
- * the system by issuing @ref pstorage_init which will also result to flushing of the
- * command queue.
- */
-static void flash_operation_failure_run(void)
-{
- if (++m_num_of_command_retries != SD_CMD_MAX_TRIES)
- {
- // Retry the last operation by doing a self transition to the current state.
-
- if (m_state != STATE_DATA_ERASE_WITH_SWAP)
- {
- sm_state_change(m_state);
- }
- else
- {
- swap_sub_state_state_change(m_swap_sub_state);
- }
- }
- else
- {
- // Complete the operation with appropriate result code and transit to an error state.
- app_notify_error_state_transit(NRF_ERROR_TIMEOUT);
- }
-}
-
-
-/**@brief Function for handling flash access result events.
- *
- * @param[in] sys_evt System event to be handled.
- */
-void pstorage_sys_event_handler(uint32_t sys_evt)
-{
- if (m_state != STATE_IDLE && m_state != STATE_ERROR)
- {
- switch (sys_evt)
- {
- case NRF_EVT_FLASH_OPERATION_SUCCESS:
- flash_operation_success_run();
- break;
-
- case NRF_EVT_FLASH_OPERATION_ERROR:
- if (!(m_flags & MASK_FLASH_API_ERR_BUSY))
- {
- flash_operation_failure_run();
- }
- else
- {
- // As our last flash operation request was rejected by the flash API reissue the
- // request by doing same code execution path as for flash operation sucess
- // event. This will promote code reuse in the implementation.
- flash_operation_success_run();
- }
- break;
-
- default:
- // No implementation needed.
- break;
- }
-
- }
-}
-
-
-/**@brief Function for calculating the tail area size in number of 32-bit words.
- *
- * @param[in] cmd_end_of_storage_address End of storage area within the scope of the command.
- * @param[in] end_of_storage_address End of allocated storage area for the application.
- */
-static void tail_word_size_calculate(pstorage_size_t cmd_end_of_storage_address,
- pstorage_size_t end_of_storage_address)
-{
- // Two different cases to resolve when calculating correct size for restore tail section:
- // 1) End of storage area and command end area are in the same page.
- // 2) End of storage area and command end area are not in the same page.
-
- const uint32_t end_of_storage_area_page = end_of_storage_address /
- PSTORAGE_FLASH_PAGE_SIZE;
- const uint32_t command_end_of_storage_area_page = cmd_end_of_storage_address /
- PSTORAGE_FLASH_PAGE_SIZE;
-
- if (end_of_storage_area_page == command_end_of_storage_area_page)
- {
- //lint -e{573} suppress "Signed-unsigned mix with divide".
- m_tail_word_size = (end_of_storage_address - cmd_end_of_storage_address) / sizeof(uint32_t);
- }
- else
- {
- //lint -e{573} suppress "Signed-unsigned mix with divide".
- m_tail_word_size = (PSTORAGE_FLASH_PAGE_SIZE -
- (cmd_end_of_storage_address % PSTORAGE_FLASH_PAGE_SIZE)) /
- sizeof(uint32_t);
- }
-}
-
-
-/**@brief Function for executing the clear operation.
- */
-static void clear_operation_execute(void)
-{
- const cmd_queue_element_t * p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
- const pstorage_block_t cmd_block_id = p_cmd->storage_addr.block_id;
-
- const pstorage_size_t block_size = m_app_table[p_cmd->storage_addr.module_id].block_size;
- const pstorage_size_t block_count = m_app_table[p_cmd->storage_addr.module_id].block_count;
- const pstorage_block_t block_base_id = m_app_table[p_cmd->storage_addr.module_id].base_id;
-
- const bool is_start_address_page_aligned = (cmd_block_id % PSTORAGE_FLASH_PAGE_SIZE) == 0;
-
- // Calculate the end (1 beyond allocated area) for complete storage area and to the area only
- // within scope of this command.
- const pstorage_block_t end_of_storage_address = block_base_id + (block_size * block_count);
- const pstorage_block_t cmd_end_of_storage_address = cmd_block_id + p_cmd->size + p_cmd->offset;
-
- // Zero tail to make sure no extra erase is done erroneously.
- m_tail_word_size = 0;
-
- // If the following is true no swap access is needed:
- // - 1st logical test covers the case of: clear/update 1 complete single page.
- // - 2nd logical test covers the case of:
- // 1) Clear/update last allocated page and page is not full (page can't be shared between
- // multiple clients so the end of the page is unused area).
- // 2) Clear/update all allocated storage.
- if ((is_start_address_page_aligned && (p_cmd->size == PSTORAGE_FLASH_PAGE_SIZE)) ||
- (is_start_address_page_aligned && (cmd_end_of_storage_address == end_of_storage_address) &&
- (p_cmd->offset == 0)) || (p_cmd->storage_addr.module_id == RAW_MODE_APP_ID))
- {
- // Nothing to put to the swap and we can just erase the pages(s).
-
- m_current_page_id = cmd_block_id / PSTORAGE_FLASH_PAGE_SIZE;
-
- sm_state_change(STATE_DATA_ERASE);
- }
- else
- {
- // Not all the blocks for the module can be cleared, we need to use swap page for storing
- // data temporarily.
-
- m_head_word_size = ((cmd_block_id + p_cmd->offset) % PSTORAGE_FLASH_PAGE_SIZE) /
- sizeof(uint32_t);
-
- const bool is_cmd_end_address_page_aligned = ((cmd_end_of_storage_address %
- PSTORAGE_FLASH_PAGE_SIZE) == 0);
- if ((cmd_end_of_storage_address != end_of_storage_address) &&
- !is_cmd_end_address_page_aligned)
- {
- // When command area is not equal to end of the storage allocation area and not ending
- // to page boundary there is a need to restore the tail area.
- tail_word_size_calculate(cmd_end_of_storage_address, end_of_storage_address);
- }
-
- sm_state_change(STATE_DATA_ERASE_WITH_SWAP);
- }
-}
-
-
-/**@brief Function for executing the store operation.
- */
-static void store_operation_execute(void)
-{
- sm_state_change(STATE_STORE);
-}
-
-
-/**@brief Function for executing the update operation.
- */
-static void update_operation_execute(void)
-{
- clear_operation_execute();
-}
-
-
-/**@brief Function for dispatching the flash access operation.
- */
-static void cmd_process(void)
-{
- const cmd_queue_element_t * p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
- m_app_data_size = p_cmd->size;
-
- switch (p_cmd->op_code)
- {
- case PSTORAGE_STORE_OP_CODE:
- store_operation_execute();
- break;
-
- case PSTORAGE_CLEAR_OP_CODE:
- clear_operation_execute();
- break;
-
- case PSTORAGE_UPDATE_OP_CODE:
- update_operation_execute();
- break;
-
- default:
- // No action required.
- break;
- }
-}
-
-
-uint32_t pstorage_init(void)
-{
- cmd_queue_init();
-
- m_next_app_instance = 0;
- m_next_page_addr = PSTORAGE_DATA_START_ADDR;
- m_current_page_id = 0;
-
- for (uint32_t index = 0; index < PSTORAGE_NUM_OF_PAGES; index++)
- {
- m_app_table[index].cb = NULL;
- m_app_table[index].block_size = 0;
- m_app_table[index].block_count = 0;
- }
-
-#ifdef PSTORAGE_RAW_MODE_ENABLE
- m_raw_app_table.cb = NULL;
-#endif //PSTORAGE_RAW_MODE_ENABLE
-
- m_state = STATE_IDLE;
- m_num_of_command_retries = 0;
- m_flags = 0;
- m_num_of_bytes_written = 0;
- m_flags |= MASK_MODULE_INITIALIZED;
-
- return NRF_SUCCESS;
-}
-
-
-uint32_t pstorage_register(pstorage_module_param_t * p_module_param,
- pstorage_handle_t * p_block_id)
-{
- VERIFY_MODULE_INITIALIZED();
- NULL_PARAM_CHECK(p_module_param);
- NULL_PARAM_CHECK(p_block_id);
- NULL_PARAM_CHECK(p_module_param->cb);
- BLOCK_SIZE_CHECK(p_module_param->block_size);
- BLOCK_COUNT_CHECK(p_module_param->block_count, p_module_param->block_size);
-
- if (!((p_module_param->block_size % sizeof(uint32_t)) == 0))
- {
- return NRF_ERROR_INVALID_PARAM;
- }
-
- if (m_next_app_instance == PSTORAGE_NUM_OF_PAGES)
- {
- return NRF_ERROR_NO_MEM;
- }
-
- p_block_id->module_id = m_next_app_instance;
- p_block_id->block_id = m_next_page_addr;
-
- m_app_table[m_next_app_instance].base_id = p_block_id->block_id;
- m_app_table[m_next_app_instance].cb = p_module_param->cb;
- m_app_table[m_next_app_instance].block_size = p_module_param->block_size;
- m_app_table[m_next_app_instance].block_count = p_module_param->block_count;
-
- // Calculate number of flash pages allocated for the device and adjust next free page address.
- /*lint -save -e666 */
- const uint32_t page_count = CEIL_DIV((p_module_param->block_size * p_module_param->block_count),
- PSTORAGE_FLASH_PAGE_SIZE);
- /*lint -restore */
- m_next_page_addr += page_count * PSTORAGE_FLASH_PAGE_SIZE;
-
- ++m_next_app_instance;
-
- return NRF_SUCCESS;
-}
-
-
-uint32_t pstorage_block_identifier_get(pstorage_handle_t * p_base_id,
- pstorage_size_t block_num,
- pstorage_handle_t * p_block_id)
-{
- pstorage_handle_t temp_id;
-
- VERIFY_MODULE_INITIALIZED();
- NULL_PARAM_CHECK(p_base_id);
- NULL_PARAM_CHECK(p_block_id);
- MODULE_ID_RANGE_CHECK(p_base_id);
-
- temp_id = (*p_base_id);
- temp_id.block_id += (block_num * MODULE_BLOCK_SIZE(p_base_id));
-
- BLOCK_ID_RANGE_CHECK(&temp_id);
-
- (*p_block_id) = temp_id;
-
- return NRF_SUCCESS;
-}
-
-
-uint32_t pstorage_store(pstorage_handle_t * p_dest,
- uint8_t * p_src,
- pstorage_size_t size,
- pstorage_size_t offset)
-{
- VERIFY_MODULE_INITIALIZED();
- NULL_PARAM_CHECK(p_src);
- NULL_PARAM_CHECK(p_dest);
- MODULE_ID_RANGE_CHECK(p_dest);
- BLOCK_ID_RANGE_CHECK(p_dest);
- SIZE_CHECK(p_dest, size);
- OFFSET_CHECK(p_dest, offset, size);
-
- if ((!is_word_aligned(p_src)) ||
- (!is_word_aligned((void *)(uint32_t)offset)) ||
- (!is_word_aligned((uint32_t *)p_dest->block_id)))
- {
- return NRF_ERROR_INVALID_ADDR;
- }
-
- return cmd_queue_enqueue(PSTORAGE_STORE_OP_CODE, p_dest, p_src, size, offset);
-}
-
-
-uint32_t pstorage_update(pstorage_handle_t * p_dest,
- uint8_t * p_src,
- pstorage_size_t size,
- pstorage_size_t offset)
-{
- VERIFY_MODULE_INITIALIZED();
- NULL_PARAM_CHECK(p_src);
- NULL_PARAM_CHECK(p_dest);
- MODULE_ID_RANGE_CHECK(p_dest);
- BLOCK_ID_RANGE_CHECK(p_dest);
- SIZE_CHECK(p_dest, size);
- OFFSET_CHECK(p_dest, offset, size);
-
- if ((!is_word_aligned(p_src)) ||
- (!is_word_aligned((void *)(uint32_t)offset)) ||
- (!is_word_aligned((uint32_t *)p_dest->block_id)))
- {
- return NRF_ERROR_INVALID_ADDR;
- }
-
- return cmd_queue_enqueue(PSTORAGE_UPDATE_OP_CODE, p_dest, p_src, size, offset);
-}
-
-
-uint32_t pstorage_load(uint8_t * p_dest,
- pstorage_handle_t * p_src,
- pstorage_size_t size,
- pstorage_size_t offset)
-{
- VERIFY_MODULE_INITIALIZED();
- NULL_PARAM_CHECK(p_src);
- NULL_PARAM_CHECK(p_dest);
- MODULE_ID_RANGE_CHECK(p_src);
- BLOCK_ID_RANGE_CHECK(p_src);
- SIZE_CHECK(p_src, size);
- OFFSET_CHECK(p_src, offset, size);
-
- if ((!is_word_aligned(p_dest)) ||
- (!is_word_aligned((void *)(uint32_t)offset)) ||
- (!is_word_aligned((uint32_t *)p_src->block_id)))
- {
- return NRF_ERROR_INVALID_ADDR;
- }
-
- memcpy(p_dest, (((uint8_t *)p_src->block_id) + offset), size);
-
- m_app_table[p_src->module_id].cb(p_src, PSTORAGE_LOAD_OP_CODE, NRF_SUCCESS, p_dest, size);
-
- return NRF_SUCCESS;
-}
-
-
-uint32_t pstorage_clear(pstorage_handle_t * p_dest, pstorage_size_t size)
-{
- VERIFY_MODULE_INITIALIZED();
- NULL_PARAM_CHECK(p_dest);
- MODULE_ID_RANGE_CHECK(p_dest);
- BLOCK_ID_RANGE_CHECK(p_dest);
-
- if ((!is_word_aligned((uint32_t *)p_dest->block_id)))
- {
- return NRF_ERROR_INVALID_ADDR;
- }
-
- // Check is the area starting from block_id multiple of block_size.
- if (
- !(
- ((p_dest->block_id - m_app_table[p_dest->module_id].base_id) %
- m_app_table[p_dest->module_id].block_size) == 0
- )
- )
- {
- return NRF_ERROR_INVALID_PARAM;
- }
-
- // Check is requested size multiple of registered block size or 0.
- if (((size % m_app_table[p_dest->module_id].block_size) != 0) || (size == 0))
- {
- return NRF_ERROR_INVALID_PARAM;
- }
-
- const uint32_t registered_allocation_size = m_app_table[p_dest->module_id].block_size *
- m_app_table[p_dest->module_id].block_count;
-
- const pstorage_block_t clear_request_end_address = p_dest->block_id + size;
- const pstorage_block_t allocation_end_address = m_app_table[p_dest->module_id].base_id +
- registered_allocation_size;
- // Check if request would lead to a buffer overrun.
- if (clear_request_end_address > allocation_end_address)
- {
- return NRF_ERROR_INVALID_PARAM;
- }
-
- return cmd_queue_enqueue(PSTORAGE_CLEAR_OP_CODE, p_dest, NULL, size, 0);
-}
-
-
-uint32_t pstorage_access_status_get(uint32_t * p_count)
-{
- VERIFY_MODULE_INITIALIZED();
- NULL_PARAM_CHECK(p_count);
-
- (*p_count) = m_cmd_queue.count;
-
- return NRF_SUCCESS;
-}
-
-#ifdef PSTORAGE_RAW_MODE_ENABLE
-
-uint32_t pstorage_raw_register(pstorage_module_param_t * p_module_param,
- pstorage_handle_t * p_block_id)
-{
- VERIFY_MODULE_INITIALIZED();
- NULL_PARAM_CHECK(p_module_param);
- NULL_PARAM_CHECK(p_block_id);
- NULL_PARAM_CHECK(p_module_param->cb);
-
- if (m_raw_app_table.cb != NULL)
- {
- return NRF_ERROR_NO_MEM;
- }
-
- p_block_id->module_id = RAW_MODE_APP_ID;
- m_raw_app_table.cb = p_module_param->cb;
-
- return NRF_SUCCESS;
-}
-
-
-uint32_t pstorage_raw_store(pstorage_handle_t * p_dest,
- uint8_t * p_src,
- pstorage_size_t size,
- pstorage_size_t offset)
-{
- VERIFY_MODULE_INITIALIZED();
- NULL_PARAM_CHECK(p_src);
- NULL_PARAM_CHECK(p_dest);
- MODULE_RAW_HANDLE_CHECK(p_dest);
-
- if (size == 0)
- {
- return NRF_ERROR_INVALID_PARAM;
- }
-
- // Verify word alignment.
- if ((!is_word_aligned(p_src)) ||
- (!is_word_aligned((void *)(uint32_t)size)) ||
- (!is_word_aligned((void *)(uint32_t)offset)) ||
- (!is_word_aligned((void *)(p_dest->block_id))))
- {
- return NRF_ERROR_INVALID_ADDR;
- }
-
- return cmd_queue_enqueue(PSTORAGE_STORE_OP_CODE, p_dest, p_src, size, offset);
-}
-
-
-uint32_t pstorage_raw_clear(pstorage_handle_t * p_dest, pstorage_size_t size)
-{
- VERIFY_MODULE_INITIALIZED();
- NULL_PARAM_CHECK(p_dest);
- MODULE_RAW_HANDLE_CHECK(p_dest);
-
- if ((!is_word_aligned((uint32_t *)p_dest->block_id)))
- {
- return NRF_ERROR_INVALID_ADDR;
- }
-
- return cmd_queue_enqueue(PSTORAGE_CLEAR_OP_CODE, p_dest, NULL, size, 0);
-}
-
-#endif // PSTORAGE_RAW_MODE_ENABLE