/*************************************************************************************************/
/*!
 *  \file   wsf_nvm.c
 *
 *  \brief  NVM service.
 *
 *  Copyright (c) 2019 Arm Ltd. All Rights Reserved.
 *
 *  Copyright (c) 2019-2020 Packetcraft, Inc.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/*************************************************************************************************/

#include "wsf_types.h"
#include "wsf_nvm.h"
#include "wsf_assert.h"
#include "pal_flash.h"
#include "crc.h"

/**************************************************************************************************
  Macros
**************************************************************************************************/

/*! NVM data start address. */
#define WSF_NVM_START_ADDR 0x0000

/*! Reserved filecode. */
#define WSF_NVM_RESERVED_FILECODE ((uint16_t)0)

/* Unused (erased) filecode. */
/* TODO: May depend on flash type */
#define WSF_NVM_UNUSED_FILECODE ((uint16_t)0xFFFF)

/*! Flash word size. */
#define WSF_FLASH_WORD_SIZE 1U

/*! Align value to word boundary. */
#define WSF_NVM_WORD_ALIGN(x) (((x) + (WSF_FLASH_WORD_SIZE - 1)) & ~(WSF_FLASH_WORD_SIZE - 1))

#define WSF_NVM_CRC_INIT_VALUE 0xFEDCBA98

/**************************************************************************************************
  Data Types
**************************************************************************************************/

/*! \brief      Header. */
typedef struct
{
    uint16_t id;        /*!< Stored data ID. */
    uint16_t len;       /*!< Stored data length. */
    uint16_t headerCrc; /*!< CRC of this header. */
    uint16_t dataCrc;   /*!< CRC of subsequent data. */
} WsfNvmHeader_t;

static struct
{
    uint32_t availAddr;  /*!< Next available address for NVM write. */
    uint32_t sectorSize; /*!< Size of erase sector. */
    uint32_t totalSize;  /*!< Total size of NVM storage. */
} wsfNvmCb;

/**************************************************************************************************
  Global Functions
**************************************************************************************************/

/*************************************************************************************************/
/*!
 *  \brief  Initialize the WSF NVM.
 */
/*************************************************************************************************/
void WsfNvmInit(void)
{
    PalFlashInit(NULL);
    wsfNvmCb.totalSize = PalNvmGetTotalSize();
    wsfNvmCb.sectorSize = PalNvmGetSectorSize();

    WsfNvmHeader_t header;
    uint32_t storageAddr = WSF_NVM_START_ADDR;
    uint16_t headerCrc;
    bool_t corruptData = FALSE;

    do
    {
        /* Read header. */
        PalFlashRead(&header, sizeof(header), storageAddr);

        if (header.id == WSF_NVM_UNUSED_FILECODE)
        {
            /* Found unused entry at end of used storage. */
            break;
        }

        /* Iterate through stored data headers, looking for existing matching stored data header. */
        if (header.id != WSF_NVM_RESERVED_FILECODE)
        {
            /* Calculate CRC of header itself. */
            headerCrc = crc16((uint8_t *)&header, sizeof(header.id) + sizeof(header.len));

            if (headerCrc != header.headerCrc)
            {
                /* Corrupt header. */
                corruptData = TRUE;
                break;
            }
        }
        else
        {
            if ((header.headerCrc != 0) || (header.dataCrc != 0))
            {
                /* Corrupt header. */
                corruptData = TRUE;
                break;
            }
        }

        /* Move to next stored data block and read header. */
        storageAddr += WSF_NVM_WORD_ALIGN(header.len) + sizeof(header);
        WSF_ASSERT((storageAddr - WSF_NVM_START_ADDR) < wsfNvmCb.totalSize);

    } while ((storageAddr - WSF_NVM_START_ADDR) < wsfNvmCb.totalSize);

    wsfNvmCb.availAddr = storageAddr;

    /* Check for corrupt data. */
    if (corruptData == TRUE)
    {
        /* Search for the first available location */
        while ((storageAddr - WSF_NVM_START_ADDR) < wsfNvmCb.totalSize)
        {
            PalFlashRead(&header.id, sizeof(header.id), storageAddr);

            if (header.id == WSF_NVM_UNUSED_FILECODE)
            {
                break;
            }

            storageAddr += sizeof(header.id);
        }

        /* Update the address of the first available location. align to sector boundary. */
        wsfNvmCb.availAddr = (storageAddr + wsfNvmCb.sectorSize - 1) & ~(wsfNvmCb.sectorSize - 1);

        /* Erase all data. */
        WsfNvmEraseDataAll(NULL);
    }
}

/*************************************************************************************************/
/*!
 *  \brief  Read data.
 *
 *  \param  id         Stored data ID.
 *  \param  pData      Buffer to read to.
 *  \param  len        Data length to read.
 *  \param  compCback  Read callback.
 *
 *  \return TRUE if NVM operation is successful, FALSE otherwise.
 */
/*************************************************************************************************/
bool_t WsfNvmReadData(uint16_t id, uint8_t *pData, uint16_t len, WsfNvmCompEvent_t compCback)
{
    WsfNvmHeader_t header;
    uint16_t headerCrc, dataCrc;
    uint32_t storageAddr = WSF_NVM_START_ADDR;
    bool_t findId = FALSE;

    WSF_ASSERT(!((id == WSF_NVM_RESERVED_FILECODE) || (id == WSF_NVM_UNUSED_FILECODE)));

    /* Read first header. */
    PalFlashRead(&header, sizeof(header), storageAddr);

    do
    {
        if (header.id == WSF_NVM_UNUSED_FILECODE)
        {
            /* Found unused entry at end of used storage. */
            break;
        }

        /* Iterate through stored data headers, looking for existing matching stored data header. */
        if (header.id != WSF_NVM_RESERVED_FILECODE)
        {
            /* Calculate CRC of header itself. */
            headerCrc = crc16((uint8_t *)&header, sizeof(header.id) + sizeof(header.len));

            if (headerCrc != header.headerCrc)
            {
                /* Corrupt header. */
                /* TODO: Catastrophic failure? */
                break;
            }
            else if ((header.id == id) && (header.len == len))
            {
                /* Valid header and matching ID - read data after header. */
                storageAddr += sizeof(header);
                PalFlashRead(pData, header.len, storageAddr);
                dataCrc = crc16(pData, header.len);
                if (dataCrc == header.dataCrc)
                {
                    findId = TRUE;
                }
                break;
            }
        }

        /* Move to next stored data block and read header. */
        storageAddr += WSF_NVM_WORD_ALIGN(header.len) + sizeof(header);
        PalFlashRead(&header, sizeof(header), storageAddr);
    } while (1);

    if (compCback)
    {
        compCback(findId);
    }
    return findId;
}

/*************************************************************************************************/
/*!
 *  \brief  Write data.
 *
 *  \param  id         Stored data ID.
 *  \param  pData      Buffer to write.
 *  \param  len        Data length to write.
 *  \param  compCback  Write callback.
 *
 *  \return TRUE if NVM operation is successful, FALSE otherwise.
 */
/*************************************************************************************************/
bool_t WsfNvmWriteData(uint16_t id, const uint8_t *pData, uint16_t len, WsfNvmCompEvent_t compCback)
{
    WsfNvmHeader_t header;
    uint16_t headerCrc, dataCrc;
    uint32_t storageAddr = WSF_NVM_START_ADDR;

    WSF_ASSERT(!((id == WSF_NVM_RESERVED_FILECODE) || (id == WSF_NVM_UNUSED_FILECODE)));
    WSF_ASSERT((wsfNvmCb.availAddr - WSF_NVM_START_ADDR) <= wsfNvmCb.totalSize);

    /* Read first header. */
    PalFlashRead(&header, sizeof(header), storageAddr);

    do
    {
        if (header.id == WSF_NVM_UNUSED_FILECODE)
        {
            /* Found unused entry at end of used storage. */
            break;
        }

        /* Iterate through stored data headers, looking for existing matching stored data header. */
        if (header.id != WSF_NVM_RESERVED_FILECODE)
        {
            /* Calculate CRC of header itself. */
            headerCrc = crc16((uint8_t *)&header, sizeof(header.id) + sizeof(header.len));

            if (headerCrc != header.headerCrc)
            {
                /* Corrupt header. */
                /* TODO: Catastrophic failure? */
                break;
            }
            else if (header.id == id)
            {
                dataCrc = crc16(pData, len);
                if (dataCrc == header.dataCrc)
                {
                    if (compCback)
                    {
                        compCback(TRUE);
                    }
                    return TRUE;
                }
                else
                {
                    /* Valid header and matching ID - scratch header out. */
                    header.id = WSF_NVM_RESERVED_FILECODE;
                    header.headerCrc = 0;
                    header.dataCrc = 0;
                    PalFlashWrite((const uint8_t *)&header, sizeof(header), storageAddr);
                }
            }
        }

        /* Move to next stored data block and read header. */
        storageAddr += WSF_NVM_WORD_ALIGN(header.len) + sizeof(header);
        PalFlashRead(&header, sizeof(header), storageAddr);
    } while (1);

    /* After cycling through all headers, create a new stored data header and store data */
    header.id = id;
    header.len = len;
    header.headerCrc = crc16((uint8_t *)&header, sizeof(header.id) + sizeof(header.len));
    header.dataCrc = crc16(pData, len);

    PalFlashWrite((const uint8_t *)&header, sizeof(header), storageAddr);
    PalFlashWrite(pData, len, storageAddr + sizeof(header));

    /* Move to next empty flash. */
    storageAddr += WSF_NVM_WORD_ALIGN(header.len) + sizeof(header);
    wsfNvmCb.availAddr = storageAddr;

    if (compCback)
    {
        compCback((wsfNvmCb.availAddr - WSF_NVM_START_ADDR) <= wsfNvmCb.totalSize);
    }

    return TRUE;
}

/*************************************************************************************************/
/*!
 *  \brief  Erase data.
 *
 *  \param  id         Erase ID.
 *  \param  compCback  Write callback.
 *
 *  \return TRUE if NVM operation is successful, FALSE otherwise.
 */
/*************************************************************************************************/
bool_t WsfNvmEraseData(uint64_t id, WsfNvmCompEvent_t compCback)
{
    WsfNvmHeader_t header;
    uint32_t headerCrc;
    uint32_t storageAddr = WSF_NVM_START_ADDR;
    bool_t erased = FALSE;

    WSF_ASSERT(!((id == WSF_NVM_RESERVED_FILECODE) || (id == WSF_NVM_UNUSED_FILECODE)));

    /* Read first header. */
    PalFlashRead(&header, sizeof(header), storageAddr);

    do
    {
        if (header.id == WSF_NVM_UNUSED_FILECODE)
        {
            /* Found unused entry at end of used storage. */
            break;
        }

        /* Iterate through stored data headers, looking for existing matching stored data header. */
        if (header.id != WSF_NVM_RESERVED_FILECODE)
        {
            headerCrc = crc16((uint8_t *)&header, sizeof(header.id) + sizeof(header.len));

            if (headerCrc != header.headerCrc)
            {
                /* Corrupt header. */
                /* TODO: Catastrophic failure? */
                break;
            }
            else if (header.id == id)
            {
                header.id = WSF_NVM_RESERVED_FILECODE;
                header.headerCrc = 0;
                header.dataCrc = 0;
                PalFlashWrite((const uint8_t *)&header, sizeof(header), storageAddr);
                erased = TRUE;
            }
        }

        /* Move to next stored data block and read header. */
        storageAddr += WSF_NVM_WORD_ALIGN(header.len) + sizeof(header);
        PalFlashRead(&header, sizeof(header), storageAddr);
    } while (1);

    if (compCback)
    {
        compCback(erased);
    }
    return erased;
}

/*************************************************************************************************/
/*!
 *  \brief  Erase all data located in NVM storage.
 *
 *  \param  compCback          Erase callback.
 *
 *  \note   Security Risk Warning. NVM storage could be shared by multiple Apps.
 */
/*************************************************************************************************/
void WsfNvmEraseDataAll(WsfNvmCompEvent_t compCback)
{
    for (uint32_t eraseAddr = WSF_NVM_START_ADDR; eraseAddr < wsfNvmCb.availAddr; eraseAddr += wsfNvmCb.sectorSize)
    {
        PalFlashEraseSector(1, eraseAddr);
    }
    wsfNvmCb.availAddr = WSF_NVM_START_ADDR;

    if (compCback)
    {
        compCback(TRUE);
    }
}