/*
 * Copyright (c) 2019-2025 Beijing Hanwei Innovation Technology Ltd. Co. and
 * its subsidiaries and affiliates (collectly called MKSEMI).
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into an MKSEMI
 *    integrated circuit in a product or a software update for such product,
 *    must reproduce the above copyright notice, this list of conditions and
 *    the following disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * 3. Neither the name of MKSEMI nor the names of its contributors may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    MKSEMI integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be
 *    reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY MKSEMI "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL MKSEMI OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "mk_nvm.h"
#include "mk_trace.h"
#include "crc.h"

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

/*! The size of flash space for NVM is 8K */
#define PAL_NVM_SIZE (0x2000)

/*! NVM start address is 0x0407E000, 126th sector */
#define PAL_NVM_ADDR (0x0407E000)

/*! defragmentation area size. */
#define NVM_DEFRAGMENT_SIZE (0x400)

/*! defragmentation area start address */
#define NVM_DEFRAGMENT_START_ADDR (PAL_NVM_SIZE - NVM_DEFRAGMENT_SIZE)

/*! NVM data offset. */
#define NVM_DATA_OFFSET 0x0000

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

/* Unused (erased) filecode. */
#define NVM_UNUSED_REC_TYPE ((uint16_t)0xFFFF)

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

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

#define pal_flash_read(pBuf, size, srcAddr) flash_read(FLASH_ID0, PAL_NVM_ADDR + srcAddr, (uint8_t *)pBuf, size)

#if FLASH_WRITE_EN
#define pal_flash_write(pBuf, size, dstAddr) flash_write_nbytes(FLASH_ID0, PAL_NVM_ADDR + dstAddr, pBuf, size)
#else
#define pal_flash_write(pBuf, size, dstAddr) (void)0
#endif

/**************************************************************************************************
  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. */
} rec_hdr_t;

/*************************************************************************************************/
/*!
 *  \brief  Erase sector.
 *
 *  \param[in] numOfSectors       Number of sectors to be erased.
 *  \param[in] startAddr          Sector aligned start address.
 */
/*************************************************************************************************/
static void pal_flash_erase_sectors(uint32_t numOfSectors, uint32_t startAddr)
{
#if FLASH_WRITE_EN
    uint32_t start_idx = (PAL_NVM_ADDR + startAddr - FLASH_BASE) / FLASH_SECTOR_SIZE;

    ASSERT((PAL_NVM_ADDR + startAddr) % FLASH_SECTOR_SIZE == 0, "Address is not aligned to sector size: %d", PAL_NVM_ADDR + startAddr);
    ASSERT(numOfSectors <= (PAL_NVM_SIZE / FLASH_SECTOR_SIZE), "Number of sectors exceeds limit: %d", numOfSectors);
    ASSERT(start_idx + numOfSectors <= (FLASH_SIZE / FLASH_SECTOR_SIZE), "End index exceeds limit: %d", start_idx + numOfSectors);

    for (uint32_t i = 0; i < numOfSectors; i++)
    {
        flash_sector_erase(FLASH_ID0, i + start_idx);
    }
#endif
}

#define NVM_REC_FREE (1U)
#define NVM_REC_RUIN (2U)
#define NVM_REC_HITS (3U)
#define NVM_REC_ENDS (4U)

static uint16_t _seek_record(rec_hdr_t *header, uint32_t *storageAddr, uint16_t id)
{
    do
    {
        pal_flash_read(header, sizeof(rec_hdr_t), *storageAddr);
        if (header->id == NVM_UNUSED_REC_TYPE)
        {
            return NVM_REC_FREE;
        }
        else if (header->id == NVM_OBSOLETED_REC_TYPE)
        {
            if ((header->headerCrc != 0) || (header->dataCrc != 0))
            {
                return NVM_REC_RUIN;
            }
        }
        else
        {
            uint16_t headerCrc = crc16((uint8_t *)header, sizeof(header->id) + sizeof(header->len));
            if (headerCrc != header->headerCrc)
            {
                return NVM_REC_RUIN;
            }
            else if (header->id == id)
            {
                return NVM_REC_HITS;
            }
        }

        *storageAddr += NVM_WORD_ALIGN(header->len) + sizeof(rec_hdr_t);
    } while ((*storageAddr - NVM_DATA_OFFSET) < PAL_NVM_SIZE);

    return NVM_REC_ENDS;
}

void mk_nvm_init(void)
{
    flash_open(FLASH_ID0, NULL);

    rec_hdr_t header;
    uint32_t storageAddr = NVM_DATA_OFFSET;
    uint16_t ret = _seek_record(&header, &storageAddr, NVM_UNUSED_REC_TYPE);

    if (ret == NVM_REC_RUIN)
    {
        mk_nvm_erase_all();
    }
}

bool mk_nvm_read(uint16_t id, uint8_t *pData, uint16_t len)
{
    rec_hdr_t header;
    uint16_t dataCrc;
    uint32_t storageAddr = NVM_DATA_OFFSET;

    ASSERT((id != NVM_UNUSED_REC_TYPE) && (id != NVM_OBSOLETED_REC_TYPE), "Invalid ID: %d", id);

    uint16_t ret = _seek_record(&header, &storageAddr, id);
    if (ret == NVM_REC_HITS)
    {
        if (header.len == len)
        {
            pal_flash_read(pData, header.len, storageAddr + sizeof(rec_hdr_t));
            dataCrc = crc16(pData, header.len);
            if (dataCrc == header.dataCrc)
            {
                return true;
            }
        }
    }

    return false;
}

static void _obsolete_record(rec_hdr_t *header, uint32_t storageAddr)
{
    header->id = NVM_OBSOLETED_REC_TYPE;
    header->headerCrc = 0;
    header->dataCrc = 0;
    pal_flash_write((const uint8_t *)header, sizeof(rec_hdr_t), storageAddr);
}

static void __copy_record(uint32_t srcAddr, uint32_t dstAddr, uint16_t len)
{
    uint8_t buf[8];
    uint16_t remain = len;
    while (remain > 0)
    {
        uint16_t copyLen = (remain > sizeof(buf)) ? sizeof(buf) : remain;
        pal_flash_read(buf, copyLen, srcAddr);
        pal_flash_write(buf, copyLen, dstAddr);
        srcAddr += copyLen;
        dstAddr += copyLen;
        remain -= copyLen;
    }
}

static void __copy_valid_records(uint32_t srcAddr, uint32_t dstAddr, uint32_t endAddr)
{
    rec_hdr_t header;

    while (srcAddr < endAddr)
    {
        pal_flash_read(&header, sizeof(rec_hdr_t), srcAddr);
        if (header.id == NVM_UNUSED_REC_TYPE)
        {
            break;
        }
        else if (header.id == NVM_OBSOLETED_REC_TYPE)
        {
        }
        else
        {
            __copy_record(srcAddr, dstAddr, NVM_WORD_ALIGN(header.len) + sizeof(rec_hdr_t));
            dstAddr += NVM_WORD_ALIGN(header.len) + sizeof(rec_hdr_t);
        }

        srcAddr += NVM_WORD_ALIGN(header.len) + sizeof(rec_hdr_t);
    }
}

static void _defragment(void)
{
    /* copy valid records to the defragmentation area */
    __copy_valid_records(NVM_DATA_OFFSET, NVM_DEFRAGMENT_START_ADDR, NVM_DEFRAGMENT_START_ADDR);

    /* erase the fist sector of the NVM */
    pal_flash_erase_sectors(1, NVM_DATA_OFFSET);

    /* copy valid records back to the fisrt sector of the NVM */
    __copy_valid_records(NVM_DEFRAGMENT_START_ADDR, NVM_DATA_OFFSET, PAL_NVM_SIZE);

    /* erase all sectors of the NVM except the first one */
    pal_flash_erase_sectors(PAL_NVM_SIZE / FLASH_SECTOR_SIZE - 1, NVM_DATA_OFFSET + FLASH_SECTOR_SIZE);
}

bool mk_nvm_write(uint16_t id, const uint8_t *pData, uint16_t len)
{
    rec_hdr_t header;
    uint16_t dataCrc;
    uint32_t storageAddr = NVM_DATA_OFFSET;

    ASSERT((id != NVM_OBSOLETED_REC_TYPE) && (id != NVM_UNUSED_REC_TYPE), "Invalid ID: %d", id);

    uint16_t ret = _seek_record(&header, &storageAddr, id);
    if (ret == NVM_REC_HITS)
    {
        dataCrc = crc16(pData, len);
        if (dataCrc == header.dataCrc)
        {
            return true;
        }
        else
        {
            _obsolete_record(&header, storageAddr);
        }
    }

    ret = _seek_record(&header, &storageAddr, NVM_UNUSED_REC_TYPE);
    if (storageAddr + NVM_DEFRAGMENT_SIZE + NVM_WORD_ALIGN(len) >= PAL_NVM_SIZE)
    {
        _defragment();
        storageAddr = NVM_DATA_OFFSET;
        ret = _seek_record(&header, &storageAddr, NVM_UNUSED_REC_TYPE);
    }

    if (ret == NVM_REC_FREE)
    {
        header.id = id;
        header.len = len;
        header.headerCrc = crc16((uint8_t *)&header, sizeof(header.id) + sizeof(header.len));
        header.dataCrc = crc16(pData, len);

        pal_flash_write((const uint8_t *)&header, sizeof(rec_hdr_t), storageAddr);
        pal_flash_write(pData, len, storageAddr + sizeof(rec_hdr_t));
        return true;
    }

    return false;
}

bool mk_nvm_erase(uint16_t id)
{
    rec_hdr_t header;
    uint32_t storageAddr = NVM_DATA_OFFSET;

    ASSERT((id != NVM_OBSOLETED_REC_TYPE) && (id != NVM_UNUSED_REC_TYPE), "Invalid ID: %d", id);

    uint16_t ret = _seek_record(&header, &storageAddr, id);
    if (ret == NVM_REC_HITS)
    {
        _obsolete_record(&header, storageAddr);
        return true;
    }

    return false;
}

void mk_nvm_erase_all(void)
{
    pal_flash_erase_sectors(PAL_NVM_SIZE / FLASH_SECTOR_SIZE, NVM_DATA_OFFSET);
}