/*
 * Copyright (C) 2017 C-SKY Microsystems Co., Ltd. All rights reserved.
 *
 * 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.
 */
/******************************************************************************
 * @file     ck_eflash.c
 * @brief    CSI Source File for Embedded Flash Driver
 * @version  V1.0
 * @date     02. June 2017
 ******************************************************************************/

#include <stdio.h>
#include <string.h>
#include "csi_core.h"
#include "drv_eflash.h"
#include "ck_eflash.h"


#define ERR_EFLASH(errno) (CSI_DRV_ERRNO_EFLASH_BASE | errno)
#define EFLASH_NULL_PARAM_CHK(para)                         \
    do {                                        \
        if (para == NULL) {                     \
            return ERR_EFLASH(EDRV_PARAMETER);   \
        }                                       \
    } while (0)

typedef struct {
    uint32_t base;
    eflash_info_t eflashinfo;
    eflash_event_cb_t cb;
    eflash_status_t status;
} ck_eflash_priv_t;

extern int32_t target_get_eflash_count(void);
extern int32_t target_get_eflash(int32_t idx, uint32_t *base, eflash_info_t *info);

static ck_eflash_priv_t eflash_handle[CONFIG_EFLASH_NUM];
/* Driver Capabilities */
static const eflash_capabilities_t driver_capabilities = {
    .event_ready = 1, /* event_ready */
    .data_width = 2, /* data_width = 0:8-bit, 1:16-bit, 2:32-bit */
    .erase_chip = 0  /* erase_chip */
};

//
// Functions
//

static int32_t eflash_program_word(eflash_handle_t handle, uint32_t dstaddr, uint32_t *srcbuf, uint32_t len)
{
    ck_eflash_priv_t *eflash_priv = handle;
    uint32_t fbase = eflash_priv->base;
    uint32_t i;

    for (i = 0; i < len; i++) {
        *(volatile uint32_t *)(fbase + 0x04) = dstaddr;
        *(volatile uint32_t *)(fbase + 0x1c) = *srcbuf;
        *(volatile uint32_t *)(fbase + 0x18) = 1;
        srcbuf++;
        dstaddr += 4;
    }

    return (i << 2);
}


#ifdef CONFIG_CHIP_CH2201
static uint32_t context[EFLASH_SECTOR_SIZE >> 2] = {0x0};
static int32_t eflash_verify(eflash_handle_t handle, uint32_t addr, const void *data, uint32_t cnt)
{
    uint32_t i;
    uint8_t error_flag = 1;

    uint8_t *block_addr = (uint8_t *)(addr & ~(EFLASH_SECTOR_SIZE - 1));
    uint32_t pre_offset = addr - (uint32_t)block_addr;
    uint32_t pre_count = (cnt > (EFLASH_SECTOR_SIZE - pre_offset)) ? (EFLASH_SECTOR_SIZE - pre_offset) : cnt;

    uint8_t *p = NULL;
    uint8_t *dst = NULL;

    p = (uint8_t *)data;
    dst = (uint8_t *)addr;
    uint32_t len = cnt;
    volatile uint8_t verify_count = 100;

    while (error_flag) {
        for (i = 0; i < pre_count; i++) {
            if (*((uint8_t *)dst + i) != *((uint8_t *)p + i)) {
                *(volatile uint32_t *) 0x50004000 = 'E';        /* for debug */
                *(volatile uint32_t *) 0x50004000 = 'E';
                *(volatile uint32_t *) 0x50004000 = 'E';
                *(volatile uint32_t *) 0x50004000 = 'E';
                *(volatile uint32_t *) 0x50004000 = '\n';
                memcpy(context, block_addr, EFLASH_SECTOR_SIZE);
                memcpy((uint8_t *)context + pre_offset, p, pre_count);
                csi_eflash_erase_sector(handle, (uint32_t)dst);
                eflash_program_word(handle, (uint32_t)block_addr, context, EFLASH_SECTOR_SIZE >> 2);
                break;
            }
        }

        if (i == pre_count || !(verify_count--)) {
            error_flag = 0;
        }
    }

    if (!verify_count) {
        return ERR_EFLASH(EDRV_TIMEOUT);
    }
    verify_count = 100;

    error_flag = 1;
    p += pre_count;
    dst += pre_count;
    len -= pre_count;

    while (len >= EFLASH_SECTOR_SIZE) {
        while (error_flag) {
            for (i = 0; i < EFLASH_SECTOR_SIZE; i++) {
                if (*((uint8_t *)dst + i) != *((uint8_t *)p + i)) {
                    *(volatile uint32_t *) 0x50004000 = 'E';        /* for debug */
                    *(volatile uint32_t *) 0x50004000 = 'E';
                    *(volatile uint32_t *) 0x50004000 = 'E';
                    *(volatile uint32_t *) 0x50004000 = 'E';
                    *(volatile uint32_t *) 0x50004000 = '\n';
                    memcpy((uint8_t *)context, p, EFLASH_SECTOR_SIZE);
                    csi_eflash_erase_sector(handle, (uint32_t)dst);
                    eflash_program_word(handle, (uint32_t)dst, context, EFLASH_SECTOR_SIZE >> 2);
                    break;
                }
            }

            if (i == EFLASH_SECTOR_SIZE || !(verify_count--)) {
                error_flag = 0;
            }
        }

        if (!verify_count) {
            return ERR_EFLASH(EDRV_TIMEOUT);
        }

        verify_count = 100;

        error_flag = 1;
        dst += EFLASH_SECTOR_SIZE;
        p += EFLASH_SECTOR_SIZE;
        len -= EFLASH_SECTOR_SIZE;
    }

    if (len > 0) {
        while (error_flag) {
            for (i = 0; i < len; i++) {
                if (*((uint8_t *)dst + i) != *((uint8_t *)p + i)) {
                    *(volatile uint32_t *) 0x50004000 = 'E';        /* for debug */
                    *(volatile uint32_t *) 0x50004000 = 'E';
                    *(volatile uint32_t *) 0x50004000 = 'E';
                    *(volatile uint32_t *) 0x50004000 = 'E';
                    *(volatile uint32_t *) 0x50004000 = '\n';
                    memcpy(context, dst, EFLASH_SECTOR_SIZE);
                    memcpy((uint8_t *)context + i, p + i, len - i);
                    csi_eflash_erase_sector(handle, (uint32_t)dst);
                    eflash_program_word(handle, (uint32_t)dst, context, EFLASH_SECTOR_SIZE >> 2);
                    break;
                }
            }

            if (i == len || !(verify_count--)) {
                error_flag = 0;
            }
        }

        if (!verify_count) {
            return ERR_EFLASH(EDRV_TIMEOUT);
        }

        verify_count = 100;
    }

    return 0;
}
#endif

/**
  \brief       Initialize EFLASH Interface. 1. Initializes the resources needed for the EFLASH interface 2.registers event callback function
  \param[in]   idx device id
  \param[in]   cb_event  Pointer to \ref eflash_event_cb_t
  \return      pointer to eflash handle
*/
eflash_handle_t csi_eflash_initialize(int32_t idx, eflash_event_cb_t cb_event)
{
    if (idx < 0 || idx >= CONFIG_EFLASH_NUM) {
        return NULL;
    }

    /* obtain the eflash information */
    uint32_t base = 0u;
    eflash_info_t info;
    int32_t real_idx = target_get_eflash(idx, &base, &info);

    if (real_idx != idx) {
        return NULL;
    }

    ck_eflash_priv_t *eflash_priv = &eflash_handle[idx];

    eflash_priv->base = base;
    eflash_priv->eflashinfo.start = info.start;
    eflash_priv->eflashinfo.end = info.end;
    eflash_priv->eflashinfo.sector_count = info.sector_count;

    /* initialize the eflash context */
    eflash_priv->cb = cb_event;
    eflash_priv->status.busy = 0;
    eflash_priv->status.error = 0U;
    eflash_priv->eflashinfo.sector_size = EFLASH_SECTOR_SIZE;
    eflash_priv->eflashinfo.page_size = EFLASH_PAGE_SIZE;
    eflash_priv->eflashinfo.program_unit = EFLASH_PROGRAM_UINT;
    eflash_priv->eflashinfo.erased_value = EFLASH_ERASED_VALUE;

    return (eflash_handle_t)eflash_priv;
}

/**
  \brief       De-initialize EFLASH Interface. stops operation and releases the software resources used by the interface
  \param[in]   handle  eflash handle to operate.
  \return      error code
*/
int32_t csi_eflash_uninitialize(eflash_handle_t handle)
{
    EFLASH_NULL_PARAM_CHK(handle);

    ck_eflash_priv_t *eflash_priv = handle;
    eflash_priv->cb = NULL;

    return 0;
}

/**
  \brief       Get driver capabilities.
  \param[in]   idx device id
  \return      \ref eflash_capabilities_t
*/
eflash_capabilities_t csi_eflash_get_capabilities(eflash_handle_t handle)
{
    return driver_capabilities;
}

/**
  \brief       Read data from Flash.
  \param[in]   handle  eflash handle to operate.
  \param[in]   addr  Data address.
  \param[out]  data  Pointer to a buffer storing the data read from Flash.
  \param[in]   cnt   Number of data items to read.
  \return      number of data items read or error code
*/
int32_t csi_eflash_read(eflash_handle_t handle, uint32_t addr, void *data, uint32_t cnt)
{
    EFLASH_NULL_PARAM_CHK(handle);
    EFLASH_NULL_PARAM_CHK(data);
    EFLASH_NULL_PARAM_CHK(cnt);

    volatile uint8_t *src_addr = (uint8_t *)addr;
    ck_eflash_priv_t *eflash_priv = handle;

    if (eflash_priv->eflashinfo.start > addr || eflash_priv->eflashinfo.end < addr || eflash_priv->eflashinfo.start > (addr + cnt - 1) || eflash_priv->eflashinfo.end < (addr + cnt - 1)) {
        return ERR_EFLASH(EDRV_PARAMETER);
    }

    if (eflash_priv->status.busy) {
        return ERR_EFLASH(EDRV_BUSY);
    }

    eflash_priv->status.error = 0U;

    int i;

    for (i = 0; i < cnt; i++) {
        *((uint8_t *)data + i) = *(src_addr + i);
    }

    return i;
}

/**
  \brief       Program data to Flash.
  \param[in]   handle  eflash handle to operate.
  \param[in]   addr  Data address.
  \param[in]   data  Pointer to a buffer containing the data to be programmed to Flash..
  \param[in]   cnt   Number of data items to program.
  \return      number of data items programmed or error code
*/
int32_t csi_eflash_program(eflash_handle_t handle, uint32_t addr, const void *data, uint32_t cnt)
{
    EFLASH_NULL_PARAM_CHK(handle);
    EFLASH_NULL_PARAM_CHK(data);
    EFLASH_NULL_PARAM_CHK(cnt);

    ck_eflash_priv_t *eflash_priv = handle;

    if (eflash_priv->eflashinfo.start > addr || eflash_priv->eflashinfo.end < addr || eflash_priv->eflashinfo.start > (addr + cnt - 1) || eflash_priv->eflashinfo.end < (addr + cnt - 1)) {
        return ERR_EFLASH(EDRV_PARAMETER);
    }

    uint32_t cur = 0;
    uint32_t pad_buf;

    if (addr & 0x3) {
        return ERR_EFLASH(EDRV_PARAMETER);
    }

    if (eflash_priv->status.busy) {
        return ERR_EFLASH(EDRV_BUSY);
    }

    eflash_priv->status.busy = 1U;
    eflash_priv->status.error = 0U;

    if (((uint32_t)data & 0x3) == 0) {
        cur = cnt - (cnt & 0x3);
        eflash_program_word(handle, addr, (uint32_t *)data, cur >> 2);
    } else {
        uint8_t *buffer_b = (uint8_t *)data;

        for (; cur < cnt - 3; cur += 4, buffer_b += 4) {
            pad_buf = buffer_b[0] | (buffer_b[1] << 8) | (buffer_b[2] << 16) | (buffer_b[3] << 24);
            eflash_program_word(handle, addr + cur, &pad_buf, 1);
        }
    }

    if (cur < cnt) {
        pad_buf = *((volatile uint32_t *)(addr + cur));
        uint8_t *pad = (uint8_t *)&pad_buf;
        uint8_t *buff = (uint8_t *)data;
        uint8_t i;

        for (i = 0; i < (cnt - cur); i++) {
            pad[i] = buff[cur + i];
        }

        eflash_program_word(handle, addr + cur, &pad_buf, 1);
    }


    eflash_priv->status.busy = 0U;
#ifdef CONFIG_CHIP_CH2201
    eflash_verify(handle, addr, data, cnt);
#endif

    return cnt;
}

/**
  \brief       Erase Flash Sector.
  \param[in]   handle  eflash handle to operate.
  \param[in]   addr  Sector address
  \return      error code
*/
int32_t csi_eflash_erase_sector(eflash_handle_t handle, uint32_t addr)
{
    EFLASH_NULL_PARAM_CHK(handle);

    ck_eflash_priv_t *eflash_priv = handle;

    if (eflash_priv->eflashinfo.start > addr || eflash_priv->eflashinfo.end < addr) {
        return ERR_EFLASH(EDRV_PARAMETER);
    }


    addr = addr & ~(EFLASH_SECTOR_SIZE - 1);
    uint32_t fbase = eflash_priv->base;

    if (eflash_priv->status.busy) {
        return ERR_EFLASH(EDRV_BUSY);
    }

    eflash_priv->status.busy = 1U;
    eflash_priv->status.error = 0U;
    *(volatile uint32_t *)(fbase + 0x4) = addr;
    *(volatile uint32_t *)(fbase + 0x10) = 0x1;
    eflash_priv->status.busy = 0U;

    return 0;
}

/**
  \brief       Erase complete Flash.
  \param[in]   handle  eflash handle to operate.
  \return      error code
*/
int32_t csi_eflash_erase_chip(eflash_handle_t handle)
{
    EFLASH_NULL_PARAM_CHK(handle);

    return ERR_EFLASH(EDRV_UNSUPPORTED);
}

/**
  \brief       Get Flash information.
  \param[in]   handle  eflash handle to operate.
  \return      Pointer to Flash information \ref eflash_info_t
*/
eflash_info_t *csi_eflash_get_info(eflash_handle_t handle)
{
    if (handle == NULL) {
        return NULL;
    }

    ck_eflash_priv_t *eflash_priv = handle;
    eflash_info_t *eflash_info = &(eflash_priv->eflashinfo);

    return eflash_info;
}

/**
  \brief       Get EFLASH status.
  \param[in]   handle  eflash handle to operate.
  \return      EFLASH status \ref eflash_status_t
*/
eflash_status_t csi_eflash_get_status(eflash_handle_t handle)
{
    if (handle == NULL) {
        eflash_status_t ret;
        memset(&ret, 0, sizeof(eflash_status_t));
        return ret;
    }

    ck_eflash_priv_t *eflash_priv = handle;

    return eflash_priv->status;
}