Nordic Semiconductor
Nordic nrf51 sdk sources. Mirrored from https://github.com/ARMmbed/nrf51-sdk.
Diff: source/nordic_sdk/components/drivers_nrf/pstorage/pstorage.c
- Revision:
- 19:47192cb9def7
- Parent:
- 10:233fefd8162b
- Child:
- 20:a90c48eb1d30
--- a/source/nordic_sdk/components/drivers_nrf/pstorage/pstorage.c Thu Apr 07 17:37:35 2016 +0100
+++ b/source/nordic_sdk/components/drivers_nrf/pstorage/pstorage.c Thu Apr 07 17:37:40 2016 +0100
@@ -1,33 +1,13 @@
-/*
- * 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.
- *
+/* 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"
@@ -40,23 +20,27 @@
#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 1024 /**< 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_MAX_APPLICATIONS + 1) /**< Application id for raw mode. */
-#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. */
+#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. */
+#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. */
+#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 versions of code to save execution and size.
+ * could be mapped to nothing in final code versions to save execution and size.
*
* @{
*/
-/**
- * @brief Check if the input pointer is NULL, if it is returns NRF_ERROR_NULL.
+/**@brief Check if the input pointer is NULL, if so it returns NRF_ERROR_NULL.
*/
#define NULL_PARAM_CHECK(PARAM) \
if ((PARAM) == NULL) \
@@ -64,19 +48,17 @@
return NRF_ERROR_NULL; \
}
-/**
- * @brief Verifies the module identifier supplied by the application is within permissible
+/**@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_MAX_APPLICATIONS) || \
+ if ((((ID)->module_id) >= PSTORAGE_NUM_OF_PAGES) || \
(m_app_table[(ID)->module_id].cb == NULL)) \
{ \
return NRF_ERROR_INVALID_PARAM; \
}
-/**
- * @brief Verifies the block identifier supplied by the application is within the permissible
+/**@brief Verifies that the block identifier supplied by the application is within the permissible
* range.
*/
#define BLOCK_ID_RANGE_CHECK(ID) \
@@ -86,8 +68,7 @@
return NRF_ERROR_INVALID_PARAM; \
}
-/**
- * @brief Verifies the block size requested by the application can be supported by the module.
+/**@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)) \
@@ -95,19 +76,16 @@
return NRF_ERROR_INVALID_PARAM; \
}
-/**
- * @brief Verifies block size requested by Application in registration API.
+/**@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)) || \
- ((((COUNT) * (SIZE)) > PSTORAGE_FLASH_PAGE_SIZE) && (PSTORAGE_FLASH_PAGE_SIZE % (SIZE)))) \
+ ((m_next_page_addr + ((COUNT) *(SIZE)) > PSTORAGE_SWAP_ADDR))) \
{ \
return NRF_ERROR_INVALID_PARAM; \
- }
+ }
-/**
- * @brief Verifies size parameter provided by application in API.
+/**@brief Verifies the size parameter provided by the application in API.
*/
#define SIZE_CHECK(ID, SIZE) \
if(((SIZE) == 0) || ((SIZE) > MODULE_BLOCK_SIZE(ID))) \
@@ -115,8 +93,7 @@
return NRF_ERROR_INVALID_PARAM; \
}
-/**
- * @brief Verifies offset parameter provided by application in API.
+/**@brief Verifies the offset parameter provided by the application in API.
*/
#define OFFSET_CHECK(ID, OFFSET, SIZE) \
if(((SIZE) + (OFFSET)) > MODULE_BLOCK_SIZE(ID)) \
@@ -126,12 +103,10 @@
#ifdef PSTORAGE_RAW_MODE_ENABLE
-/**
- * @brief Verifies the module identifier supplied by the application is registered for raw mode.
+/**@brief Verifies the module identifier supplied by the application.
*/
-#define MODULE_RAW_ID_RANGE_CHECK(ID) \
- if ((PSTORAGE_MAX_APPLICATIONS+1 != ((ID)->module_id)) || \
- (m_raw_app_table.cb == NULL)) \
+#define MODULE_RAW_HANDLE_CHECK(ID) \
+ if ((((ID)->module_id) != RAW_MODE_APP_ID)) \
{ \
return NRF_ERROR_INVALID_PARAM; \
}
@@ -141,15 +116,15 @@
/**@} */
-/**@brief Verify module's initialization status.
+/**@brief Verify module's initialization status.
*
- * @details Verify module's initialization status. Returns NRF_ERROR_INVALID_STATE in case a
- * module API is called without initializing the module.
+ * @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_module_initialized) \
+ if (!(m_flags & MASK_MODULE_INITIALIZED)) \
{ \
return NRF_ERROR_INVALID_STATE; \
} \
@@ -158,178 +133,494 @@
/**@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 States for the Update/Clear swap backup state machine. */
+/**@brief Main state machine of the component. */
typedef enum
{
- STATE_INIT, /**< State for indicating that swap can be used when using update/clear API. */
- STATE_DATA_TO_SWAP_WRITE, /**< State for doing backup of data page into the swap page when using update/clear API. */
- STATE_DATA_ERASE, /**< State for erasing data page when using update/clear API. */
- STATE_HEAD_RESTORE, /**< State for restoring head (beginning) of backed up data from swap to data page when using update/clear API. */
- STATE_TAIL_RESTORE, /**< State for restoring tail (end) of backed up data from swap to data page when using update/clear API. */
- STATE_NEW_BODY_WRITE, /**< State for writing body (middle) data to the data page when using update/clear API. */
- STATE_SWAP_ERASE, /**< State for erasing the swap page when using the update/clear API. */
- STATE_COMPLETE, /**< State for indicating that update/clear sequence is completed internal in the module when using the update/clear API. */
- STATE_SWAP_DIRTY /**< State for initializing the swap region on module initialization. */
-} swap_backup_state_t;
+ 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.
+/**@brief Application registration information.
*
- * @details Define application specific information that application needs to maintain to be able
+ * @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 block requested by application. */
- pstorage_size_t num_of_pages; /**< Variable to remember how many pages have been allocated for this module. This information is used for clearing of block, so that application does not need to have knowledge of number of pages its using. */
+ 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.
+/**@brief Application registration information.
*
- * @details Define application specific information that application registered for raw mode.
+ * @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 result of flash access. */
- uint16_t num_of_pages; /**< Variable to remember how many pages have been allocated for this module. This information is used for clearing of block, so that application does not need to have knowledge of number of pages its using. */
+ 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.
+/**@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 flash access operation being queued. Element is free if op-code is INVALID_OPCODE. */
- uint8_t n_tries; /**< Number of times this command has been retried after failing. */
- pstorage_size_t size; /**< Identifies size in bytes requested for the operation. */
- pstorage_size_t offset; /**< Offset requested by the application for 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. */
+ 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 op_code field is not invalid.
+/**@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 of time, this queue has one or
- * more flash access operation 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 to requested next. The queue implements a simple first in first out algorithm.
- * Data addresses are assumed to be resident.
+ * @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. */
- bool flash_access; /**< Flag to ensure an flash event received is for an request issued by the module. */
- cmd_queue_element_t cmd[PSTORAGE_CMD_QUEUE_SIZE]; /**< Array to maintain flash access operation details. */
+ 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 can span across flash pages. */
-static pstorage_size_t m_round_val; /**< Round value for multiple round operations. For erase operations, the round value will contain current round counter which is identical to number of pages erased. For store operations, the round value contains current round of operation * SOC_MAX_WRITE_SIZE to ensure each store to the SoC Flash API is within the SoC limit. */
-static bool m_module_initialized = false; /**< Flag for checking if module has been initialized. */
-static swap_backup_state_t m_swap_state; /**< Swap page state. */
-
-
-static pstorage_module_table_t m_app_table[PSTORAGE_MAX_APPLICATIONS]; /**< Registered application information table. */
+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 Routine called to actually issue the flash access request to the SoftDevice.
+/**@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.
*
- * @retval NRF_SUCCESS on success, else an error code indicating reason for failure.
+ * @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 uint32_t cmd_process(void);
+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 Routine to notify application of any errors.
+/**@brief Function for data erase with swap state entry actions.
*
- * @param[in] result Result of event being notified.
+ * @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 app_notify(uint32_t result, cmd_queue_element_t * p_elem);
+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;
+ }
+}
-/**
- * @defgroup utility_functions Utility internal functions.
- * @{
- * @details Utility functions needed for interfacing with flash through SoC APIs.
- * SoC APIs are non blocking and provide the result of flash access through an event.
+/**@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.
*
- * @note Only one flash access operation is permitted at a time by SoC. Hence a queue is
- * maintained by this module.
+ * @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 Initializes command queue element.
+/**@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.
*
- * @param[in] index Element index being initialized.
+ * @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_MAX_APPLICATIONS;
+ 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 Initializes command queue.
+/**@brief Function for initializing the command queue.
*/
static void cmd_queue_init(void)
{
- uint32_t cmd_index;
+ m_cmd_queue.rp = 0;
+ m_cmd_queue.count = 0;
- m_round_val = 0;
- m_swap_state = STATE_INIT;
- m_cmd_queue.rp = 0;
- m_cmd_queue.count = 0;
- m_cmd_queue.flash_access = false;
-
- for (cmd_index = 0; cmd_index < PSTORAGE_CMD_QUEUE_SIZE; cmd_index++)
+ for (uint32_t cmd_index = 0; cmd_index < PSTORAGE_CMD_QUEUE_SIZE; ++cmd_index)
{
cmd_queue_element_init(cmd_index);
}
}
-/**
- * @brief Routine to enqueue a flash access operation.
+/**@brief Function for enqueuing, and possibly dispatching, a flash access operation.
*
- * @param[in] opcode Identifies operation requested to be enqueued.
- * @param[in] p_storage_addr Identiifes module and flash address on which operation is requested.
- * @param[in] p_data_addr Identifies data address for flash access.
+ * @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 on success, else an error code indicating reason for failure.
- *
- * @note All paramater check should be performed before requesting in an enqueue.
+ * @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,
@@ -337,90 +628,62 @@
pstorage_size_t size,
pstorage_size_t offset)
{
- uint32_t retval;
- uint8_t write_index = 0;
+ uint32_t err_code;
if (m_cmd_queue.count != PSTORAGE_CMD_QUEUE_SIZE)
{
- // Enqueue the command if it is queue is not full.
- write_index = m_cmd_queue.rp + m_cmd_queue.count;
+ // 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)
+ 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].n_tries = 0;
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;
- retval = NRF_SUCCESS;
- if (m_cmd_queue.flash_access == false)
+
+ m_cmd_queue.count++;
+
+ if (m_state == STATE_IDLE)
{
- retval = cmd_process();
- if (retval == NRF_ERROR_BUSY)
- {
- // In case of busy error code, it is possible to attempt to access flash.
- retval = NRF_SUCCESS;
- }
- }
- m_cmd_queue.count++;
+ cmd_process();
+ }
+
+ err_code = NRF_SUCCESS;
}
else
{
- retval = NRF_ERROR_NO_MEM;
+ err_code = NRF_ERROR_NO_MEM;
}
- return retval;
+ return err_code;
}
-/**
- * @brief Dequeues a command element.
- *
- * @retval NRF_SUCCESS on success, else an error code indicating reason for failure.
+/**@brief Function for dequeing a possible pending flash access operation.
*/
-static uint32_t cmd_queue_dequeue(void)
+static void cmd_queue_dequeue(void)
{
- uint32_t retval;
- retval = NRF_SUCCESS;
-
- // If any flash operation is enqueued, schedule.
- if ((m_cmd_queue.count > 0) && (m_cmd_queue.flash_access == false))
+ if ((m_cmd_queue.count != 0))
{
- retval = cmd_process();
- if (retval != NRF_SUCCESS)
- {
- // Flash could be accessed by modules other than Bond Manager, hence a busy error is
- // acceptable, but any other error needs to be indicated to the bond manager.
- if (retval == NRF_ERROR_BUSY)
- {
- // In case of busy error code, it is possible to attempt to access flash.
- retval = NRF_SUCCESS;
- }
- }
+ cmd_process();
}
- else
- {
- // No flash access request pending.
- }
-
- return retval;
}
-/**
- * @brief Routine to notify application of any errors.
+/**@brief Function for notifying an application of command completion.
*
- * @param[in] result Result of event being notified.
- * @param[in] p_elem Pointer to the element for which this result was received.
+ * @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;
- uint8_t op_code = p_elem->op_code;
+ 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)
@@ -433,478 +696,618 @@
ntf_cb = m_app_table[p_elem->storage_addr.module_id].cb;
}
- // Indicate result to client.
- // For PSTORAGE_CLEAR_OP_CODE no size is returned as the size field is used only internally
- // for clients registering multiple pages.
- ntf_cb(&p_elem->storage_addr,
- op_code,
- result,
- p_elem->p_data_addr,
- p_elem->size);
+ 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 Handles Flash Access Result Events declared in pstorage_platform.h.
- *
- * @param[in] sys_evt System event to be handled.
+/**@brief Function for reissuing the last flash operation request, which was rejected by the flash
+ * API, in swap sub sate.
*/
-void pstorage_sys_event_handler(uint32_t sys_evt)
+static void swap_sub_state_err_busy_process(void)
{
- uint32_t retval = NRF_SUCCESS;
+ // 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);
+}
+
- // Its possible the flash access was not initiated by bond manager, hence
- // event is processed only if the event triggered was for an operation requested by the
- // bond manager.
- if (m_cmd_queue.flash_access == true)
+/**@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
{
- cmd_queue_element_t * p_cmd;
+ // As operation request was rejected by the flash API reissue the request.
+ swap_sub_state_err_busy_process();
+ }
+}
- m_cmd_queue.flash_access = false;
+
+/**@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();
+ }
+}
+
- if (m_swap_state == STATE_SWAP_DIRTY)
+/**@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())
{
- if (sys_evt == NRF_EVT_FLASH_OPERATION_SUCCESS)
+ // 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))
{
- m_swap_state = STATE_INIT;
+ // 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
{
- // If clearing the swap fails, set the application back to un-initialized, to give
- // the application a chance for a retry.
- m_module_initialized = false;
+ // 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();
+ }
+}
- // Schedule any queued flash access operations.
- retval = cmd_queue_dequeue();
- if (retval != NRF_SUCCESS)
- {
- app_notify(retval, &m_cmd_queue.cmd[m_cmd_queue.rp]);
- }
- return;
+
+/**@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;
}
- switch (sys_evt)
- {
- case NRF_EVT_FLASH_OPERATION_SUCCESS:
- {
- p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
- m_round_val++;
-
- const bool store_finished =
- ((p_cmd->op_code == PSTORAGE_STORE_OP_CODE) &&
- ((m_round_val * SOC_MAX_WRITE_SIZE) >= p_cmd->size));
-
- const bool update_finished =
- ((p_cmd->op_code == PSTORAGE_UPDATE_OP_CODE) &&
- (m_swap_state == STATE_COMPLETE));
-
- const bool clear_block_finished =
- ((p_cmd->op_code == PSTORAGE_CLEAR_OP_CODE) &&
- (m_swap_state == STATE_COMPLETE));
+ 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();
+ }
+}
- const bool clear_all_finished =
- ((p_cmd->op_code == PSTORAGE_CLEAR_OP_CODE) &&
- ((m_round_val * SOC_MAX_WRITE_SIZE) >= p_cmd->size) &&
- (m_swap_state == STATE_INIT));
-
- if (update_finished ||
- clear_block_finished ||
- clear_all_finished ||
- store_finished)
- {
- uint8_t queue_rp = m_cmd_queue.rp;
-
- m_swap_state = STATE_INIT;
-
- m_round_val = 0;
- m_cmd_queue.count--;
- m_cmd_queue.rp++;
-
- if (m_cmd_queue.rp >= PSTORAGE_CMD_QUEUE_SIZE)
- {
- m_cmd_queue.rp -= PSTORAGE_CMD_QUEUE_SIZE;
- }
- app_notify(retval, &m_cmd_queue.cmd[queue_rp]);
-
- // Initialize/free the element as it is now processed.
- cmd_queue_element_init(queue_rp);
- }
- // Schedule any queued flash access operations.
- retval = cmd_queue_dequeue();
-
- if (retval != NRF_SUCCESS)
- {
- app_notify(retval, &m_cmd_queue.cmd[m_cmd_queue.rp]);
- }
- }
- break;
-
- case NRF_EVT_FLASH_OPERATION_ERROR:
- // Current command timed out and was not started in SoftDevice.
- p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
-
- ASSERT(p_cmd->n_tries < SD_CMD_MAX_TRIES);
- if (++p_cmd->n_tries == SD_CMD_MAX_TRIES)
- {
- // If we have already attempted SD_CMD_MAX_TRIES times, give up.
- app_notify(NRF_ERROR_TIMEOUT, &m_cmd_queue.cmd[m_cmd_queue.rp]);
- }
- else
- {
- // Retry operation
- retval = cmd_process();
- if (retval != NRF_SUCCESS && retval != NRF_ERROR_BUSY)
- {
- app_notify(retval, p_cmd);
- }
- }
- break;
-
- default:
- // No implementation needed.
- break;
-
- }
+/**@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 handling flash accesses when using swap.
+/**@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.
*
- * __________________________________________________________
- * | Page |
- * |________________________________________________________|
- * | head | affected body (to be updated or cleared) | tail |
- * |______|__________________________________________|______|
- *
- * @param[in] p_cmd Queue element being processed.
- * @param[in] page_number The affected page number.
- * @param[in] head_word_size Size of the head in number of words.
- * @param[in] tail_word_size Size of the tail in number of words.
- *
- * @retval NRF_SUCCESS on success, else an error code indicating reason for failure.
+ * @details Function for doing erase state action upon flash operation success event, which includes
+ * making a state transition depending on the current state.
*/
-static uint32_t swap_state_process(cmd_queue_element_t * p_cmd,
- uint32_t page_number,
- uint32_t head_word_size,
- uint32_t tail_word_size)
+static void erase_sub_state_sm_run(void)
{
- uint32_t retval = NRF_ERROR_INTERNAL;
+ 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();
+ }
+}
- // Adjust entry point to state machine if needed. When we update has no head or tail its
- // no need for using the swap.
- if (m_swap_state == STATE_INIT)
- {
- if ((head_word_size == 0) && (tail_word_size == 0))
+
+/**@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)
{
- // Only skip swap usage if the new data fills a whole flash page.
- m_swap_state = STATE_DATA_ERASE;
+ command_end_procedure_run();
}
else
{
- // Else start backing up application data to swap.
- m_swap_state = STATE_DATA_TO_SWAP_WRITE;
+ store_cmd_flash_write_execute();
}
}
-
- switch (m_swap_state)
+ else
{
- case STATE_DATA_TO_SWAP_WRITE:
- // Backup previous content into swap page.
- retval = sd_flash_write((uint32_t *)(PSTORAGE_SWAP_ADDR),
- (uint32_t *)(page_number * PSTORAGE_FLASH_PAGE_SIZE),
- PSTORAGE_FLASH_PAGE_SIZE / sizeof(uint32_t));
- if (retval == NRF_SUCCESS)
- {
- m_swap_state = STATE_DATA_ERASE;
- }
+ // 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:
- // Clear the application data page.
- retval = sd_flash_page_erase(page_number);
- if (retval == NRF_SUCCESS)
- {
- if (head_word_size == 0)
- {
- if (tail_word_size == 0)
- {
- if (p_cmd->op_code == PSTORAGE_CLEAR_OP_CODE)
- {
- m_swap_state = STATE_COMPLETE;
- }
- else
- {
- m_swap_state = STATE_NEW_BODY_WRITE;
- }
- }
- else
- {
- m_swap_state = STATE_TAIL_RESTORE;
- }
- }
- else
- {
- m_swap_state = STATE_HEAD_RESTORE;
- }
- }
+ erase_sub_state_sm_run();
break;
+
+ case STATE_DATA_ERASE_WITH_SWAP:
+ swap_sub_state_sm_run();
+ break;
+
+ default:
+ // No implementation needed.
+ break;
+ }
+}
+
- case STATE_HEAD_RESTORE:
- // Restore head from swap to application data page.
- retval = sd_flash_write((uint32_t *)(page_number * PSTORAGE_FLASH_PAGE_SIZE),
- (uint32_t *)PSTORAGE_SWAP_ADDR,
- head_word_size);
- if (retval == NRF_SUCCESS)
- {
- if (tail_word_size == 0)
- {
- if (p_cmd->op_code == PSTORAGE_CLEAR_OP_CODE)
- {
- m_swap_state = STATE_SWAP_ERASE;
- }
- else
- {
- m_swap_state = STATE_NEW_BODY_WRITE;
- }
- }
- else
- {
- m_swap_state = STATE_TAIL_RESTORE;
- }
- }
- 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);
+ }
+}
- case STATE_TAIL_RESTORE:
- // Restore tail from swap to application data page.
- retval = sd_flash_write((uint32_t *)((page_number * PSTORAGE_FLASH_PAGE_SIZE) +
- (head_word_size * sizeof(uint32_t)) +
- p_cmd->size),
- (uint32_t *)(PSTORAGE_SWAP_ADDR +
- (head_word_size * sizeof(uint32_t)) +
- p_cmd->size),
- tail_word_size);
- if (retval == NRF_SUCCESS)
- {
- if (p_cmd->op_code == PSTORAGE_CLEAR_OP_CODE)
- {
- m_swap_state = STATE_SWAP_ERASE;
- }
- else
+
+/**@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))
{
- m_swap_state = STATE_NEW_BODY_WRITE;
- }
- }
- break;
-
- case STATE_NEW_BODY_WRITE:
- // Write new data (body) to application data page.
- retval = sd_flash_write((uint32_t *)((page_number * PSTORAGE_FLASH_PAGE_SIZE) +
- (head_word_size * sizeof(uint32_t))),
- (uint32_t *)p_cmd->p_data_addr,
- p_cmd->size / sizeof(uint32_t));
- if (retval == NRF_SUCCESS)
- {
- if ((head_word_size == 0) && (tail_word_size == 0))
- {
- m_swap_state = STATE_COMPLETE;
+ flash_operation_failure_run();
}
else
{
- m_swap_state = STATE_SWAP_ERASE;
- }
- }
- break;
+ // 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;
+ }
+
+ }
+}
+
- case STATE_SWAP_ERASE:
- // Clear the swap page for subsequent use.
- retval = sd_flash_page_erase(PSTORAGE_SWAP_ADDR / PSTORAGE_FLASH_PAGE_SIZE);
- if (retval == NRF_SUCCESS)
- {
- m_swap_state = STATE_COMPLETE;
- }
- 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;
- default:
- break;
+ 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);
}
-
- return retval;
+ 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 Routine called to actually issue the flash access request to the SoftDevice.
- *
- * @retval NRF_SUCCESS on success, else an error code indicating reason for failure.
+/**@brief Function for executing the clear operation.
*/
-static uint32_t cmd_process(void)
+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)
{
- uint32_t retval;
- uint32_t storage_addr;
- cmd_queue_element_t * p_cmd;
+ clear_operation_execute();
+}
+
- retval = NRF_ERROR_FORBIDDEN;
-
- p_cmd = &m_cmd_queue.cmd[m_cmd_queue.rp];
-
- storage_addr = p_cmd->storage_addr.block_id;
+/**@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:
- {
- uint32_t size;
- uint32_t offset;
- uint8_t * p_data_addr = p_cmd->p_data_addr;
-
- offset = (m_round_val * SOC_MAX_WRITE_SIZE);
- size = p_cmd->size - offset;
- p_data_addr += offset;
- storage_addr += (p_cmd->offset + offset);
-
- if (size < SOC_MAX_WRITE_SIZE)
- {
- retval = sd_flash_write(((uint32_t *)storage_addr),
- (uint32_t *)p_data_addr,
- size / sizeof(uint32_t));
- }
- else
- {
- retval = sd_flash_write(((uint32_t *)storage_addr),
- (uint32_t *)p_data_addr,
- SOC_MAX_WRITE_SIZE / sizeof(uint32_t));
- }
- }
- break;
+ case PSTORAGE_STORE_OP_CODE:
+ store_operation_execute();
+ break;
case PSTORAGE_CLEAR_OP_CODE:
- {
- // Calculate page number before clearing.
- uint32_t page_number;
-
- pstorage_size_t block_size =
- m_app_table[p_cmd->storage_addr.module_id].block_size;
-
- pstorage_size_t block_count =
- m_app_table[p_cmd->storage_addr.module_id].block_count;
-
- pstorage_block_t base_address =
- m_app_table[p_cmd->storage_addr.module_id].base_id;
-
- // If the whole module should be cleared.
- if (((base_address == storage_addr) && (block_size * block_count == p_cmd->size)) ||
- (p_cmd->storage_addr.module_id == RAW_MODE_APP_ID))
- {
- page_number = ((storage_addr / PSTORAGE_FLASH_PAGE_SIZE) + m_round_val);
-
- retval = sd_flash_page_erase(page_number);
- }
- // If one block is to be erased.
- else
- {
- page_number = (storage_addr / PSTORAGE_FLASH_PAGE_SIZE);
-
- uint32_t head_word_size = (
- storage_addr -
- (page_number * PSTORAGE_FLASH_PAGE_SIZE)
- ) / sizeof(uint32_t);
-
- uint32_t tail_word_size = (
- ((page_number + 1) * PSTORAGE_FLASH_PAGE_SIZE) -
- (storage_addr + p_cmd->size)
- ) / sizeof(uint32_t);
-
- retval = swap_state_process(p_cmd,
- page_number,
- head_word_size,
- tail_word_size);
- }
- }
- break;
+ clear_operation_execute();
+ break;
case PSTORAGE_UPDATE_OP_CODE:
- {
- uint32_t page_number = (storage_addr / PSTORAGE_FLASH_PAGE_SIZE);
-
- uint32_t head_word_size = (
- storage_addr + p_cmd->offset -
- (page_number * PSTORAGE_FLASH_PAGE_SIZE)
- ) / sizeof(uint32_t);
-
- uint32_t tail_word_size = (
- ((page_number + 1) * PSTORAGE_FLASH_PAGE_SIZE) -
- (storage_addr + p_cmd->offset + p_cmd->size)
- ) / sizeof(uint32_t);
-
- retval = swap_state_process(p_cmd, page_number, head_word_size, tail_word_size);
- }
- break;
+ update_operation_execute();
+ break;
default:
- // Should never reach here.
+ // No action required.
break;
}
-
- if (retval == NRF_SUCCESS)
- {
- m_cmd_queue.flash_access = true;
- }
-
- return retval;
}
-/** @} */
uint32_t pstorage_init(void)
{
- uint32_t retval;
-
cmd_queue_init();
m_next_app_instance = 0;
m_next_page_addr = PSTORAGE_DATA_START_ADDR;
- m_round_val = 0;
-
- for (uint32_t index = 0; index < PSTORAGE_MAX_APPLICATIONS; index++)
+ 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].num_of_pages = 0;
m_app_table[index].block_count = 0;
}
#ifdef PSTORAGE_RAW_MODE_ENABLE
m_raw_app_table.cb = NULL;
- m_raw_app_table.num_of_pages = 0;
- m_module_initialized = true;
- m_swap_state = STATE_INIT;
-
- retval = NRF_SUCCESS;
-#else
- m_swap_state = STATE_SWAP_DIRTY;
-
- // Erase swap region in case it is dirty.
- retval = sd_flash_page_erase(PSTORAGE_SWAP_ADDR / PSTORAGE_FLASH_PAGE_SIZE);
- if (retval == NRF_SUCCESS)
- {
- m_cmd_queue.flash_access = true;
- m_module_initialized = true;
- }
#endif //PSTORAGE_RAW_MODE_ENABLE
- return retval;
+ 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)
{
- uint16_t page_count;
- uint32_t total_size;
-
VERIFY_MODULE_INITIALIZED();
NULL_PARAM_CHECK(p_module_param);
NULL_PARAM_CHECK(p_block_id);
@@ -912,13 +1315,12 @@
BLOCK_SIZE_CHECK(p_module_param->block_size);
BLOCK_COUNT_CHECK(p_module_param->block_count, p_module_param->block_size);
- // Block size should be a multiple of word size.
if (!((p_module_param->block_size % sizeof(uint32_t)) == 0))
{
return NRF_ERROR_INVALID_PARAM;
}
-
- if (m_next_app_instance == PSTORAGE_MAX_APPLICATIONS)
+
+ if (m_next_app_instance == PSTORAGE_NUM_OF_PAGES)
{
return NRF_ERROR_NO_MEM;
}
@@ -931,26 +1333,12 @@
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.
- page_count = 0;
- total_size = p_module_param->block_size * p_module_param->block_count;
- do
- {
- page_count++;
- if (total_size > PSTORAGE_FLASH_PAGE_SIZE)
- {
- total_size -= PSTORAGE_FLASH_PAGE_SIZE;
- }
- else
- {
- total_size = 0;
- }
- m_next_page_addr += PSTORAGE_FLASH_PAGE_SIZE;
- }
- while (total_size > 0);
-
- m_app_table[m_next_app_instance].num_of_pages = page_count;
- m_next_app_instance++;
+ // Calculate number of flash pages allocated for the device and adjust next free page address.
+ const uint32_t page_count = CEIL_DIV((p_module_param->block_size * p_module_param->block_count),
+ PSTORAGE_FLASH_PAGE_SIZE);
+ m_next_page_addr += page_count * PSTORAGE_FLASH_PAGE_SIZE;
+
+ ++m_next_app_instance;
return NRF_SUCCESS;
}
@@ -988,16 +1376,12 @@
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);
-
- // Verify word alignment.
- if ((!is_word_aligned(p_src)) || (!is_word_aligned((void *)(uint32_t)offset)))
- {
- return NRF_ERROR_INVALID_ADDR;
- }
-
- if ((!is_word_aligned((uint32_t *)p_dest->block_id)))
+ 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;
}
@@ -1019,13 +1403,9 @@
SIZE_CHECK(p_dest, size);
OFFSET_CHECK(p_dest, offset, size);
- // Verify word alignment.
- if ((!is_word_aligned(p_src)) || (!is_word_aligned((void *)(uint32_t)offset)))
- {
- return NRF_ERROR_INVALID_ADDR;
- }
-
- if ((!is_word_aligned((uint32_t *)p_dest->block_id)))
+ 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;
}
@@ -1047,13 +1427,9 @@
SIZE_CHECK(p_src, size);
OFFSET_CHECK(p_src, offset, size);
- // Verify word alignment.
- if ((!is_word_aligned(p_dest)) || (!is_word_aligned((void *)(uint32_t)offset)))
- {
- return NRF_ERROR_INVALID_ADDR;
- }
-
- if ((!is_word_aligned((uint32_t *)p_src->block_id)))
+ 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;
}
@@ -1068,8 +1444,6 @@
uint32_t pstorage_clear(pstorage_handle_t * p_dest, pstorage_size_t size)
{
- uint32_t retval;
-
VERIFY_MODULE_INITIALIZED();
NULL_PARAM_CHECK(p_dest);
MODULE_ID_RANGE_CHECK(p_dest);
@@ -1080,6 +1454,7 @@
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) %
@@ -1090,9 +1465,25 @@
return NRF_ERROR_INVALID_PARAM;
}
- retval = cmd_queue_enqueue(PSTORAGE_CLEAR_OP_CODE, p_dest, NULL, size, 0);
+ // 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;
+ }
- return retval;
+ 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);
}
@@ -1108,7 +1499,6 @@
#ifdef PSTORAGE_RAW_MODE_ENABLE
-
uint32_t pstorage_raw_register(pstorage_module_param_t * p_module_param,
pstorage_handle_t * p_block_id)
{
@@ -1137,29 +1527,38 @@
VERIFY_MODULE_INITIALIZED();
NULL_PARAM_CHECK(p_src);
NULL_PARAM_CHECK(p_dest);
- MODULE_RAW_ID_RANGE_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)offset)))
+ 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)
{
- uint32_t retval;
-
VERIFY_MODULE_INITIALIZED();
NULL_PARAM_CHECK(p_dest);
- MODULE_RAW_ID_RANGE_CHECK(p_dest);
+ MODULE_RAW_HANDLE_CHECK(p_dest);
+
+ if ((!is_word_aligned((uint32_t *)p_dest->block_id)))
+ {
+ return NRF_ERROR_INVALID_ADDR;
+ }
- retval = cmd_queue_enqueue(PSTORAGE_CLEAR_OP_CODE, p_dest, NULL, size, 0);
-
- return retval;
+ return cmd_queue_enqueue(PSTORAGE_CLEAR_OP_CODE, p_dest, NULL, size, 0);
}
#endif // PSTORAGE_RAW_MODE_ENABLE
\ No newline at end of file