@mchp-mcc/dspic33a-flash 1.0.1

package/output/flash-a-core-ftl/flash_nonblocking.c.ftl

@@ -0,0 +1,367 @@
+<#assign headerFiles = interfaceApi.interfaceApi.headerFiles>
+/**
+ * ${moduleNameUpperCase} Generated Driver Source File
+ *
+ * @file      ${moduleNameLowerCase}.c
+ *
+ * @ingroup   ${moduleNameLowerCase}driver
+ *
+ * @brief     This is the generated driver source file for ${moduleNameUpperCase} driver
+ *
+ * @skipline @version   Firmware Driver Version 1.0.0
+<#if generatePLIBVersion == true>
+ *
+ * @skipline @version   PLIB Version ${PLIBVersion}
+</#if>
+ *
+ * @skipline  Device : ${selectedDevice}
+*/
+
+${disclaimer}
+
+#include <stddef.h>
+#include "../flash_nonblocking.h"
+
+enum FLASH_PROGRAM_ERASE_ERROR_CODE {
+    ERROR_INVALID_OP = 1,
+    ERROR_SECURITY_ACCESS_VIOLATION,
+    ERROR_FLASH_PANEL_CONTROL_LOGIC,
+    ERROR_ROW_OP_SYSTEM_BUS,
+    ERROR_ROW_OP_WARM_RESET
+};
+
+<#if interruptDriven == true>
+// User callback and context handles.
+static void (*userCallbackHandler)(void *) = NULL;
+static void *userContext = NULL;
+</#if>
+static bool lock = false;
+
+<#if generateInterfaceContent == true>
+
+// Section: Driver Interface
+const struct ${moduleNameUpperCase}_INTERFACE flash = {
+    <#if generateBlockingAPI == true>
+    .PageErase = FLASH_PageErase,
+    .Read = FLASH_Read,
+    .Write = FLASH_WordWrite,
+    <#if flashHasRowProgramming == 1>
+    .RowWrite = FLASH_RowWrite,
+    <#else>
+    .RowWrite = NULL,
+    </#if>
+    </#if>
+    .PageAddressGet = FLASH_ErasePageAddressGet,
+    .PageOffsetGet = FLASH_ErasePageOffsetGet,
+    <#if interruptDriven == true>
+    .NonBlockingPageErase = FLASH_NonBlockingPageErase,
+    .NonBlockingBulkErase = NULL,
+    .NonBlockingRead = FLASH_NonBlockingRead,
+    .NonBlockingWordWrite = FLASH_NonBlockingWordWrite,
+    <#if flashHasRowProgramming == 1>
+    .NonBlockingRowWrite = FLASH_NonBlockingRowWrite,
+    <#else>
+    .NonBlockingRowWrite = NULL,
+    </#if>
+    .NonBlockingPolledPageErase = NULL,
+    .NonBlockingPolledBulkErase = NULL,
+    .NonBlockingPolledRead = NULL,
+    .NonBlockingPolledWordWrite = NULL,
+    .NonBlockingPolledRowWrite = NULL,
+    <#else>
+    .NonBlockingPageErase = NULL,
+    .NonBlockingBulkErase = NULL,
+    .NonBlockingRead = NULL,
+    .NonBlockingWordWrite = NULL,
+    .NonBlockingRowWrite = NULL,
+    .NonBlockingPolledPageErase = FLASH_NonBlockingPolledPageErase,
+    .NonBlockingPolledBulkErase = NULL,
+    .NonBlockingPolledRead = FLASH_NonBlockingPolledRead,
+    .NonBlockingPolledWordWrite = FLASH_NonBlockingPolledWordWrite,
+    <#if flashHasRowProgramming == 1>
+    .NonBlockingPolledRowWrite = FLASH_NonBlockingPolledRowWrite,
+    <#else>
+    .NonBlockingPolledRowWrite = NULL,
+    </#if>
+    </#if>
+    .OperationStatusGet = FLASH_OperationStatusGet
+
+};
+</#if>
+
+<#if interruptDriven == true>
+void FLASH_Initialize(void)
+{
+    // Flash Interrupt
+    ${flashInterruptFlag} = 0U;
+    ${flashInterruptEnable} = 1U;
+}
+</#if>
+
+<#if interruptDriven == true>
+<#if isFlashContextSupported>
+void __attribute__ ( ( interrupt, no_auto_psv, context ) ) ${flashIsrHandlerName}(void)
+<#else>
+void __attribute__ ( ( interrupt, no_auto_psv ) ) ${flashIsrHandlerName}(void)
+</#if>
+{
+    ${flashInterruptFlag} = 0U;
+
+    //Interrupt means operation completion, release the lock
+    lock = false;
+
+    if (NULL != userCallbackHandler) {
+        (*userCallbackHandler)(userContext);
+    }
+}
+</#if>
+
+
+enum FLASH_RETURN_STATUS FLASH_OperationStatusGet(void)
+{
+    enum FLASH_RETURN_STATUS flashReturnStatus = FLASH_NO_ERROR;
+    if(1U == ${nvmControlRegister}bits.WR)
+    {
+        flashReturnStatus = FLASH_OP_BUSY;
+    }
+    else
+    {
+        if(1U == ${nvmControlRegister}bits.WRERR)
+        {
+            flashReturnStatus =  FLASH_WRITE_ERROR;
+        }
+        else if(ERROR_INVALID_OP == ${nvmControlRegister}bits.WREC)
+        {
+            flashReturnStatus = FLASH_INVALID_OEPRATION;
+        }
+        else if(ERROR_SECURITY_ACCESS_VIOLATION == ${nvmControlRegister}bits.WREC)
+        {
+            flashReturnStatus = FLASH_SECURITY_ACCESS_CONTROL_ERROR;
+        }
+        else if(ERROR_FLASH_PANEL_CONTROL_LOGIC == ${nvmControlRegister}bits.WREC)
+        {
+            flashReturnStatus = FLASH_PANEL_CONTROL_LOGIC_ERROR;
+        }
+        else if(ERROR_ROW_OP_SYSTEM_BUS == ${nvmControlRegister}bits.WREC)
+        {
+            flashReturnStatus = FLASH_ROW_OP_SYSTEM_BUS_ERROR;
+        }
+        else if(ERROR_ROW_OP_WARM_RESET == ${nvmControlRegister}bits.WREC)
+        {
+            flashReturnStatus = FLASH_ROW_OP_WARM_RESET_ERROR;
+        }
+        else
+        {
+            flashReturnStatus = FLASH_NO_ERROR;
+        }
+        lock = false;
+    }
+    return flashReturnStatus;
+}
+
+
+<#if interruptDriven == true>
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPageErase(flash_adr_t flashAddress, flash_key_t unlockKey, FLASH_CALLBACK callbackHandler, void* context)
+<#else>
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPolledPageErase(flash_adr_t flashAddress, flash_key_t unlockKey)
+</#if>
+{
+    enum FLASH_RETURN_STATUS flashReturnStatus = FLASH_OP_IN_PROGRESS;
+    if(false == lock)
+    {
+        if(unlockKey != (flash_key_t)FLASH_UNLOCK_KEY)
+        {
+            flashReturnStatus = FLASH_INVALID_KEY;
+        }
+        if (0U != (flashAddress & ~FLASH_ERASE_PAGE_MASK))
+        {
+            flashReturnStatus = FLASH_INVALID_ADDRESS;
+        }
+        <#if interruptDriven == true>
+        else if(NULL == callbackHandler)
+        {
+            flashReturnStatus  = FLASH_INVALID_CALLBACK_HANDLER;
+        }
+        </#if>
+        else if(0U != ${nvmControlRegister}bits.WR)
+        {
+            flashReturnStatus = FLASH_OP_BUSY;
+        }
+        else
+        {
+            <#if interruptDriven == true>
+            userCallbackHandler = callbackHandler;
+            userContext = context;
+            </#if>
+            lock = true;
+            ${nvmAddressRegister} = flashAddress;
+            ${nvmControlRegister} = FLASH_PAGE_ERASE_OPCODE;
+            ${nvmControlRegister}bits.WR = 1U;
+            lock = false;
+        }
+    }
+    return flashReturnStatus;
+}
+
+
+<#if interruptDriven == true>
+enum FLASH_RETURN_STATUS FLASH_NonBlockingWordWrite(flash_adr_t flashAddress, flash_data_t *data, flash_key_t unlockKey, FLASH_CALLBACK callbackHandler, void* context)
+<#else>
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPolledWordWrite(flash_adr_t flashAddress, flash_data_t *data, flash_key_t unlockKey)
+</#if>
+{
+    enum FLASH_RETURN_STATUS flashReturnStatus = FLASH_OP_IN_PROGRESS;
+    if(false == lock)
+    {
+        if (NULL == data)
+        {
+            flashReturnStatus = FLASH_INVALID_DATA;
+        }
+        else if(unlockKey != (flash_key_t)FLASH_UNLOCK_KEY)
+        {
+            flashReturnStatus = FLASH_INVALID_KEY;
+        }
+        else if (0U != (flashAddress % FLASH_ADDRESS_MASK))
+        {
+            flashReturnStatus = FLASH_INVALID_ADDRESS;
+        }
+        <#if interruptDriven == true>
+        else if(NULL == callbackHandler)
+        {
+            flashReturnStatus = FLASH_INVALID_CALLBACK_HANDLER;
+        }
+        </#if>
+        else if(0U != ${nvmControlRegister}bits.WR)
+        {
+            flashReturnStatus = FLASH_OP_BUSY;
+        }
+        else
+        {
+            <#if interruptDriven == true>
+            // Save the handler and context to call for completion of this operation.
+            userCallbackHandler = callbackHandler;
+            userContext = context;
+            </#if>
+            lock = true;
+            ${nvmDataRegister0} = *data;
+            ${nvmDataRegister1} = *(data + 1U);
+            ${nvmDataRegister2} = *(data + 2U);
+            ${nvmDataRegister3} = *(data + 3U);
+
+            ${nvmAddressRegister} = flashAddress;
+            ${nvmControlRegister} = FLASH_WORD_WRITE_OPCODE;
+
+            ${nvmControlRegister}bits.WR = 1U;
+            lock = false;
+
+        }
+    }
+    return flashReturnStatus;
+}
+
+<#if properties.FLASH_HAS_ROW_PROGRAMMING.value  == "TRUE">
+<#if interruptDriven == true>
+enum FLASH_RETURN_STATUS FLASH_NonBlockingRowWrite(flash_adr_t flashAddress, flash_data_t *data, flash_key_t unlockKey, FLASH_CALLBACK callbackHandler, void* context)
+<#else>
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPolledRowWrite(flash_adr_t flashAddress, flash_data_t *data, flash_key_t unlockKey)
+</#if>
+{
+    enum FLASH_RETURN_STATUS flashReturnStatus = FLASH_OP_IN_PROGRESS;
+    if(false == lock)
+    {
+        if (NULL == data)
+        {
+            flashReturnStatus = FLASH_INVALID_DATA;
+        }
+        else if(unlockKey != (flash_key_t)FLASH_UNLOCK_KEY)
+        {
+            flashReturnStatus = FLASH_INVALID_KEY;
+        }
+        else if (0U != (flashAddress % FLASH_ADDRESS_MASK))
+        {
+            flashReturnStatus = FLASH_INVALID_ADDRESS;
+        }
+        <#if interruptDriven == true>
+        else if(NULL == callbackHandler)
+        {
+            flashReturnStatus = FLASH_INVALID_CALLBACK_HANDLER;
+        }
+        </#if>
+        else if(0U != ${nvmControlRegister}bits.WR)
+        {
+            flashReturnStatus = FLASH_OP_BUSY;
+        }
+        else
+        {
+            <#if interruptDriven == true>
+            // Save the handler and context to call for completion of this operation.
+            userCallbackHandler = callbackHandler;
+            userContext = context;
+            </#if>
+            lock = true;
+            ${nvmSrcAddressRegister} = (uint32_t)data;
+            ${nvmAddressRegister} = flashAddress;
+            ${nvmControlRegister} = FLASH_ROW_WRITE_OPCODE;
+
+            ${nvmControlRegister}bits.WR = 1U;
+            lock = false;
+        }
+    }
+    return flashReturnStatus;
+}
+</#if>
+
+
+<#if interruptDriven == true>
+enum FLASH_RETURN_STATUS FLASH_NonBlockingRead(flash_adr_t flashAddress, size_t count, flash_data_t *data)
+<#else>
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPolledRead(flash_adr_t flashAddress, size_t count, flash_data_t *data)
+</#if>
+{
+    flash_adr_t *flashReadAddress = (flash_adr_t *)flashAddress;
+    enum FLASH_RETURN_STATUS flashReturnStatus = FLASH_OP_BUSY;
+
+    if(false == lock)
+    {
+        if ((NULL == data) || (0U == count))
+        {
+            flashReturnStatus = FLASH_INVALID_DATA;
+        }
+        else if (0U != (flashAddress % FLASH_ADDRESS_MASK))
+        {
+            flashReturnStatus = FLASH_INVALID_ADDRESS;
+        }
+        else if(0U != ${nvmControlRegister}bits.WR)
+        {
+            flashReturnStatus = FLASH_OP_BUSY;
+        }
+        else
+        {
+            uint32_t index;
+            lock = true;
+            for(index = 0; index < count ; index++)
+            {
+                *data = *(flashReadAddress+index);
+                data++;
+            }
+
+            flashReturnStatus = FLASH_NO_ERROR;
+
+            // Now that the read is done, the lock can be cleared.
+            lock = false;
+        }
+    }
+    return flashReturnStatus;
+}
+
+<#if generateBlockingAPI == false>
+uint16_t ${moduleNameUpperCase}_ErasePageOffsetGet(flash_adr_t address)
+{
+    return ((~FLASH_ERASE_PAGE_MASK) & address);
+}
+
+uint32_t ${moduleNameUpperCase}_ErasePageAddressGet(flash_adr_t address)
+{
+    return (FLASH_ERASE_PAGE_MASK & address);
+}
+</#if>

package/output/flash-a-core-ftl/flash_nonblocking.h.ftl

@@ -0,0 +1,342 @@
+<#assign functionHeaderExample = false>
+
+/**
+ * ${moduleNameUpperCase} Generated Driver Header File
+ *
+ * @file         ${moduleNameLowerCase}.h
+ *
+ * @ingroup      ${moduleNameLowerCase}driver
+ *
+ * @brief        ${moduleNameUpperCase} driver using dsPIC MCUs
+ *
+ * @skipline @version   Firmware Driver Version 1.0.0
+<#if generatePLIBVersion == true>
+ *
+ * @skipline @version   PLIB Version ${PLIBVersion}
+</#if>
+ *
+ * @skipline     Device : ${selectedDevice}
+*/
+
+${disclaimer}
+
+#ifndef FLASH_NONBLOCKING_H
+#define FLASH_NONBLOCKING_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include "xc.h"
+<#if generateBlockingAPI == true>
+#include "../flash/flash.h"
+</#if>
+
+<#if generateBlockingAPI == false && generateInterfaceContent == true>
+#include "${moduleNameLowerCase}_interface.h"
+
+// Section: Data Type Definitions
+
+/**
+ @ingroup   ${moduleNameLowerCase}driver
+ @brief     Structure object of type ${moduleNameUpperCase}_INTERFACE assigned with name
+            displayed in the Melody Driver User interface. A structure pointer can be used to achieve portability
+            across the ${moduleNameUpperCase} having same interface structure.
+*/
+
+extern const struct ${moduleNameUpperCase}_INTERFACE flash;
+</#if>
+
+// Section: Data Type Definitions
+
+/**
+ * @ingroup flashdriver
+ * @brief This function initializes the nvm controller.
+ * @return  void
+ */
+void FLASH_Initialize(void);
+
+/**
+ * @ingroup flashdriver
+ * @brief This function gets the status of nvm controller.
+ * @return  returns the status of the previous operation.
+ */
+enum FLASH_RETURN_STATUS FLASH_OperationStatusGet(void);
+
+<#if interruptDriven == true>
+/**
+ * @ingroup ${moduleNameLowerCase}driver
+ * @brief This function erases a page.
+ * @param[in]  flashAddress : Flash address
+ * @param[in]  unlockKey : Flash unlock key
+ * @param[in]  callbackHandler : Pointer to call back handler
+ * @param[in]  context : Optional pointer to context to handle user contexts
+ * @return  FLASH_RETURN_STATUS: returns FLASH_NO_ERROR if operation is successful, if the operation is in progress then it returns FLASH_OP_IN_PROGRESS,
+ *          if there is a previous operation in progress then it returns FLASH_OP_BUSY , in case of any unsuccessful operation  it returns errors like
+ *          FLASH_INVALID_ADDRESS, FLASH_INVALID_CALLBACK_HANDLER, FLASH_WRITE_ERROR
+<#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    FLASH_RETURN_STATUS status = FLASH_NonBlockingPageErase(flashAddress, unlockKey, callbackHandler, context);
+ * @endcode
+</#if>
+ */
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPageErase(flash_adr_t flashAddress, flash_key_t unlockKey, FLASH_CALLBACK callbackHandler, void* context);
+<#else>
+/**
+ * @ingroup ${moduleNameLowerCase}driver
+ * @brief This function erases a page.
+ * @param[in]  flashAddress : Flash address
+ * @param[in]  unlockKey : Flash unlock key
+ * @return  FLASH_RETURN_STATUS : returns FLASH_NO_ERROR if operation is successful, if the operation is in progress then it returns FLASH_OP_IN_PROGRESS,
+ *          if there is a previous operation in progress then it returns FLASH_OP_BUSY , in case of any unsuccessful operation  it returns errors like
+ *          FLASH_INVALID_ADDRESS, FLASH_WRITE_ERROR
+ * This function locks flash operations to prevent multiple access. Make sure to call FLASH_OperationStatusGet() after calling FLASH_NonBlockingPolledPageErase() to release the lock.
+<#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    FLASH_RETURN_STATUS status = FLASH_NonBlockingPolledPageErase(flashAddress, unlockKey);
+      while (FLASH_OperationStatusGet() == FLASH_OP_BUSY);
+ * @endcode
+</#if>
+ */
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPolledPageErase(flash_adr_t flashAddress, flash_key_t unlockKey);
+</#if>
+
+<#if interruptDriven == true>
+/**
+ * @ingroup flashdriver
+ * @brief This function erases a panel.
+ * @param[in]  panel : Flash panel to erase
+ * @param[in]  unlockKey : Flash unlock key
+ * @return  * @return  returns FLASH_NO_ERROR if operation is successful, if the operation is in progress then it returns FLASH_OP_IN_PROGRESS,
+ *          if there is a previous operation in progress then it returns FLASH_OP_BUSY , in case of any unsuccessful operation  it returns errors like
+ *          FLASH_INVALID_ADDRESS, FLASH_INVALID_CALLBACK_HANDLER, FLASH_WRITE_ERROR
+  <#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    FLASH_RETURN_STATUS status = FLASH_NonBlockingBulkErase(panel, unlockKey, callbackHandler, context);
+ * @endcode
+</#if>
+ */
+enum FLASH_RETURN_STATUS FLASH_NonBlockingBulkErase(enum FLASH_PANEL panel, flash_key_t unlockKey, FLASH_CALLBACK callbackHandler, void* context);
+<#else>
+/**
+ * @ingroup flashdriver
+ * @brief This function erases a panel.
+ * @param[in]  panel : Flash panel to erase
+ * @param[in]  unlockKey : Flash unlock key
+ * @return  * @return  returns FLASH_NO_ERROR if operation is successful, if the operation is in progress then it returns FLASH_OP_IN_PROGRESS,
+ *          if there is a previous operation in progress then it returns FLASH_OP_BUSY , in case of any unsuccessful operation  it returns errors like
+ *          FLASH_INVALID_ADDRESS, FLASH_WRITE_ERROR
+ * This function locks flash operations to prevent multiple access. This function locks flash operations to prevent multiple access. Make sure to call FLASH_OperationStatusGet() after calling FLASH_NonBlockingPolledPageErase() to release the lock.
+ <#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    FLASH_RETURN_STATUS status = FLASH_NonBlockingPolledBulkErase(panel, unlockKey);
+ * @endcode
+</#if>
+ */
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPolledBulkErase(enum FLASH_PANEL panel, flash_key_t unlockKey);
+</#if>
+
+
+<#if interruptDriven == true>
+/**
+ * @ingroup ${moduleNameLowerCase}driver
+ * @brief This function writes the specified data to the specified address.
+ * @param[in]  flashAddress : Flash address
+ * @param[in]  data : Pointer of the data to be written.
+ * @param[in]  unlockKey : Flash unlock Key.
+ * @param[in]  callbackHandler : pointer to call back handler
+ * @param[in]  context : Optional pointer to context to handle user contexts
+<#if properties.FLASH_WORD_WRITE_SIZE_IN_INSTRUCTIONS.value  == "2">
+ *                    This will write the TWO WORDS pointed to by the pointer.
+</#if>
+ * @return  FLASH_RETURN_STATUS: returns FLASH_NO_ERROR if operation is successful, if the operation is in progress then it returns FLASH_OP_IN_PROGRESS,
+ *          if there is a previous operation in progress then it returns FLASH_OP_BUSY , in case of any unsuccessful operation  it returns errors like
+ *          FLASH_INVALID_ADDRESS, FLASH_INVALID_CALLBACK_HANDLER, FLASH_WRITE_ERROR
+<#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    uint32_t data[10];
+ *    uint32_t index = 0;
+ *    for(index = 0; index < ROW_SIZE; index++)
+ *    {
+ *      data[index] = index;
+ *    }
+ *    FLASH_RETURN_STATUS status = FLASH_NonBlockingWordWrite(flashAddress, &data, unlockKey, callbackHandler, context);
+ * @endcode
+</#if>
+ */
+enum FLASH_RETURN_STATUS FLASH_NonBlockingWordWrite(flash_adr_t flashAddress, flash_data_t *data, flash_key_t unlockKey, FLASH_CALLBACK callbackHandler, void* context);
+<#else>
+/**
+ * @ingroup ${moduleNameLowerCase}driver
+ * @brief This function writes the specified data to the specified address.
+ * @param[in]  flashAddress : Flash address
+ * @param[in]  data : Pointer of the data to be written.
+ * @param[in]  unlockKey : Flash unlock Key.
+ * This function locks flash operations to prevent multiple access. Make sure to call FLASH_OperationStatusGet() after calling FLASH_NonBlockingPolledWordWrite() to release the lock.
+<#if properties.FLASH_WORD_WRITE_SIZE_IN_INSTRUCTIONS.value  == "2">
+ *                    This will write the TWO WORDS pointed to by the pointer.
+</#if>
+ * @return  FLASH_RETURN_STATUS: returns FLASH_NO_ERROR if operation is successful, if the operation is in progress then it returns FLASH_OP_IN_PROGRESS,
+ *          if there is a previous operation in progress then it returns FLASH_OP_BUSY , in case of any unsuccessful operation  it returns errors like
+ *          FLASH_INVALID_ADDRESS, FLASH_INVALID_DATA
+<#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    uint32_t data[10];
+ *    uint32_t index = 0;
+ *    for(index = 0; index < ROW_SIZE; index++)
+ *    {
+ *        data[index] = index;
+ *    }
+ *    FLASH_RETURN_STATUS status = FLASH_NonBlockingPolledWordWrite(flashAddress, &data, unlockKey);
+      while (FLASH_OperationStatusGet() == FLASH_OP_BUSY);
+ * @endcode
+</#if>
+ */
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPolledWordWrite(flash_adr_t flashAddress, flash_data_t *data, flash_key_t unlockKey);
+</#if>
+
+<#if properties.FLASH_HAS_ROW_PROGRAMMING.value  == "TRUE">
+<#if interruptDriven == true>
+/**
+ * @ingroup ${moduleNameLowerCase}driver
+ * @brief This function writes the specified data to the specified address.
+ * @param[in]  flashAddress : Flash address
+ * @param[in]  data : Pointer of the data to be written
+ * @param[in]  unlockKey : Flash unlock Key.
+ * @param[in]  callbackHandler : Pointer to call back handler
+ * @param[in]  context : Optional pointer to context to handle user contexts
+ * @return  FLASH_RETURN_STATUS: returns FLASH_NO_ERROR if operation is successful, if the operation is in progress then it returns FLASH_OP_IN_PROGRESS,
+ *          if there is a previous operation in progress then it returns FLASH_OP_BUSY , in case of any unsuccessful operation  it returns errors like
+ *          FLASH_INVALID_ADDRESS, FLASH_INVALID_CALLBACK_HANDLER, FLASH_WRITE_ERROR
+<#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    uint32_t data[FLASH_WRITE_INSTRUCTION_COUNT];
+ *    uint32_t index = 0;
+ *    for(index = 0; index < ROW_SIZE ;index++)
+ *    {
+ *        data[index] = index;
+ *    }
+ *    FLASH_RETURN_STATUS status = FLASH_NonBlockingRowWrite(flashAddress, &data, unlockKey, callback, context);
+ * @endcode
+</#if>
+ */
+enum FLASH_RETURN_STATUS FLASH_NonBlockingRowWrite(flash_adr_t flashAddress, flash_data_t *data, flash_key_t unlockKey, FLASH_CALLBACK callback, void* context);
+<#else>
+/**
+ * @ingroup ${moduleNameLowerCase}driver
+ * @brief This function writes the specified data to the specified address.
+ * @param[in]  flashAddress : Flash address
+ * @param[in]  data : Pointer of the data to be written
+ * @param[in]  unlockKey : Flash unlock Key.
+ * @return  FLASH_RETURN_STATUS: returns FLASH_NO_ERROR if operation is successful, if the operation is in progress then it returns FLASH_OP_IN_PROGRESS,
+ *          if there is a previous operation in progress then it returns FLASH_OP_BUSY , in case of any unsuccessful operation  it returns errors like
+ *          FLASH_INVALID_ADDRESS, FLASH_INVALID_DATA
+ * This function locks flash operations to prevent multiple access. Make sure to call FLASH_OperationStatusGet() after calling FLASH_NonBlockingPolledRowWrite() to release the lock.
+<#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    uint32_t data[FLASH_WRITE_INSTRUCTION_COUNT];
+ *    uint32_t index = 0;
+ *    for(index = 0; index < ROW_SIZE; index++)
+ *    {
+ *        data[index] = index;
+ *    }
+ *    FLASH_RETURN_STATUS status = FLASH_NonBlockingPolledRowWrite(flashAddress, &data, unlockKey);
+      while (FLASH_OperationStatusGet() == FLASH_OP_BUSY);
+ * @endcode
+</#if>
+ */
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPolledRowWrite(flash_adr_t flashAddress, flash_data_t *data, flash_key_t unlockKey);
+</#if>
+</#if>
+
+<#if interruptDriven == true>
+/**
+ * @ingroup ${moduleNameLowerCase}driver
+ * @brief This function reads the data from the specified address.
+ * @param[in]  flashAddress : Flash address of
+ * @param[out]  data : Pointer to read the data
+ * @return  FLASH_RETURN_STATUS: returns FLASH_NO_ERROR if operation is successful, if the operation is in progress then it returns FLASH_OP_IN_PROGRESS,
+ *          if there is a previous operation in progress then it returns FLASH_OP_BUSY , in case of any unsuccessful operation  it returns errors like
+ *          FLASH_INVALID_ADDRESS, FLASH_INVALID_DATA
+<#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    uint32_t data[2];
+ *    uint32_t count = 2;
+ *    FLASH_RETURN_STATUS status = FLASH_NonBlockingRead(flashAddress, count, &data);
+ * @endcode
+</#if>
+ */
+enum FLASH_RETURN_STATUS FLASH_NonBlockingRead(flash_adr_t flashAddress, size_t count, flash_data_t *data);
+<#else>
+/**
+ * @ingroup ${moduleNameLowerCase}driver
+ * @brief This function reads the data from the specified address.
+ * @param[in]  flashAddress : Flash address of
+ * @param[out]  data : Pointer to read the data
+ * @return  FLASH_RETURN_STATUS: returns FLASH_NO_ERROR if operation is successful, if the operation is in progress then it returns FLASH_OP_IN_PROGRESS,
+ *          if there is a previous operation in progress then it returns FLASH_OP_BUSY , in case of any unsuccessful operation  it returns errors like
+ *          FLASH_INVALID_ADDRESS, FLASH_INVALID_DATA
+ <#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    uint32_t data[2];
+ *    uint32_t count = 2;
+ *    FLASH_RETURN_STATUS status = FLASH_NonBlockingPolledRead(flashAddress, count,  &data);
+ * @endcode
+</#if>
+ */
+enum FLASH_RETURN_STATUS FLASH_NonBlockingPolledRead(flash_adr_t flashAddress, size_t count, flash_data_t *data);
+</#if>
+
+<#if generateBlockingAPI == false>
+/**
+ * @ingroup ${moduleNameLowerCase}driver
+ * @brief This function returns the offest from page start.
+ * @param[in]  flashAddress : Flash address
+ * @return  FLASH_RETURN_STATUS: returns the flash offset from page start address
+<#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    uint16_t offset = ${moduleNameUpperCase}_ErasePageOffsetGet(flashAddress);
+ * @endcode
+</#if>
+ */
+uint16_t ${moduleNameUpperCase}_ErasePageOffsetGet(flash_adr_t flashAddress);
+
+
+/**
+ * @ingroup ${moduleNameLowerCase}driver
+ * @brief This function returns the offest from page start.
+ * @param[in]  flashAddress : Flash address
+ * @return  FLASH_RETURN_STATUS: returns page start address for the given address
+<#if functionHeaderExample == true>
+ *
+ * @b Example:
+ * @code
+ *    uint32_t pageStartAddress = ${moduleNameUpperCase}_ErasePageAddressGet(flashAddress);
+ * @endcode
+</#if>
+ */
+uint32_t ${moduleNameUpperCase}_ErasePageAddressGet(flash_adr_t flashAddress);
+</#if>
+
+#endif    /* FLASH_NONBLOCKING_H */