/***************************************************************************
 *
 * Copyright 2015-2019 BES.
 * All rights reserved. All unpublished rights reserved.
 *
 * No part of this work may be used or reproduced in any form or by any
 * means, or stored in a database or retrieval system, without prior written
 * permission of BES.
 *
 * Use of this work is governed by a license granted by BES.
 * This work contains confidential and proprietary information of
 * BES. which is protected by copyright, trade secret,
 * trademark and other intellectual property rights.
 *
 ****************************************************************************/
#if 0
#include "cmsis.h"
#include "crash_dump_section.h"

#if defined(CRASH_DUMP_SECTION_SIZE) && (CRASH_DUMP_SECTION_SIZE > 0)

#include "hal_bootmode.h"
#include "hal_norflash.h"
#include "hal_trace.h"
#include "hal_timer.h"
#include "heap_api.h"
#include "pmu.h"
#include "stdio.h"
#include "string.h"

extern uint32_t __crash_dump_start[];
extern uint32_t __crash_dump_end[];

extern const char sys_build_info[];

#define DUMPED_MSP_BYTES	32
#define DUMPED_PSP_BYTES	32

// #undef CRASH_DUMP_SECTION_SIZE

#define CRASH_DUMP_FRAME_NUM  (((uint32_t)__crash_dump_end - (uint32_t)__crash_dump_start)/CRASH_DUMP_FRAME_SIZE)

#ifdef TRACE_CRLF
#define NEW_LINE_STR                    "\r\n"
#else
#define NEW_LINE_STR                    "\n"
#endif

static struct CRASH_OUTPUT_BUF_T *crash_dump_section_p = NULL;
static struct CRASH_OUTPUT_BUF_T *crash_output_p = NULL;
static bool crash_dump_init = false;

static uint8_t isCrashHappened = false;
static uint8_t isCrashDumpExisting = false;

static void crashdump_dump_output(const unsigned char *buf, unsigned int buf_len)
{
    if (crash_dump_init){
        if ((crash_output_p->hdr.bufpos+buf_len) <= OFFSETOF(struct CRASH_OUTPUT_BUF_T, buf)){
            memcpy(crash_output_p->buf+crash_output_p->hdr.bufpos, buf, buf_len);
            crash_output_p->hdr.bufpos += buf_len;
        }else{
            memcpy(crash_output_p->buf+crash_output_p->hdr.bufpos, buf, OFFSETOF(struct CRASH_OUTPUT_BUF_T, buf)-crash_output_p->hdr.bufpos);
            crash_output_p->hdr.bufpos += OFFSETOF(struct CRASH_OUTPUT_BUF_T, buf)-crash_output_p->hdr.bufpos;
        }
    }
}

int crashdump_get_empty_section(uint32_t *seqnum, struct CRASH_OUTPUT_BUF_T **crash_dump_addr)
{
    struct CRASH_OUTPUT_BUF_T *p;
    int32_t lastWrittenIndex = -1, index = 0;
    int32_t max = -1;

    for (p = (struct CRASH_OUTPUT_BUF_T *)__crash_dump_start; p < (struct CRASH_OUTPUT_BUF_T *)__crash_dump_end; p++){
        // TRACE(2,"magic code is 0x%x seqnum is 0x%x", p->magicCode, (uint32_t)(p->seqnum));

        if ((CRASH_DUMP_MAGIC_CODE == p->hdr.magicCode) && (0xffffffff != (uint32_t)(p->hdr.seqnum)))
        {
            if (max < p->hdr.seqnum){
                max = p->hdr.seqnum;
                lastWrittenIndex = index;
            }
        }

        index++;
    }

    if (-1 != lastWrittenIndex)
    {
        crashdump_set_existing_flag(true);
        TRACE(1,"The last written dump log is at index %d", lastWrittenIndex);
        lastWrittenIndex++;
        if (lastWrittenIndex == (((uint32_t)__crash_dump_end-(uint32_t)__crash_dump_start)/sizeof(struct CRASH_OUTPUT_BUF_T)))
        {
            lastWrittenIndex = 0;
        }

        *crash_dump_addr = (struct CRASH_OUTPUT_BUF_T *)((uint32_t)__crash_dump_start +
            lastWrittenIndex*sizeof(struct CRASH_OUTPUT_BUF_T));
        *seqnum = max+1;
    }
    else
    {
        crashdump_set_existing_flag(false);
        TRACE(0,"No dump log saved yet!");
        *seqnum = 0;
        *crash_dump_addr = (struct CRASH_OUTPUT_BUF_T *)__crash_dump_start;
    }


    TRACE(1,"Next crash dump addr 0x%x", *crash_dump_addr);
    return 0;
}

void crashdump_flush_buffer(void)
{
    uint32_t sent_cnt;
    uint32_t send_frame_size;
    const uint32_t max_frame_size = 256;

    sent_cnt = 0;
    while (sent_cnt < crash_output_p->hdr.bufpos) {
        send_frame_size = crash_output_p->hdr.bufpos - sent_cnt;
        if (send_frame_size > max_frame_size) {
            send_frame_size = max_frame_size;
        }

        TRACE_FLUSH();
        TRACE_OUTPUT(crash_output_p->buf + sent_cnt, send_frame_size);
        TRACE_FLUSH();
        sent_cnt += send_frame_size;
    }
}

int crashdump_init(void)
{
    const char separate_line[] = NEW_LINE_STR "----------------------------------------" NEW_LINE_STR;
    uint32_t dump_section_idx;
    int len;
    char crash_buf[100];

    if (crash_dump_init)
        return 0;

    crash_dump_init = true;

    hal_sw_bootmode_set(HAL_SW_BOOTMODE_REBOOT_FLASH_FLUSH);

    crashdump_get_empty_section(&dump_section_idx, &crash_dump_section_p);

    syspool_init();
    syspool_get_buff((uint8_t **)&crash_output_p, sizeof(struct CRASH_OUTPUT_BUF_T));
    crash_output_p->hdr.bufpos = 0;

    crash_output_p->hdr.magicCode = CRASH_DUMP_MAGIC_CODE;
    crash_output_p->hdr.seqnum = dump_section_idx;
    crash_output_p->hdr.partnum = CRASH_DUMP_FRAME_NUM;
    crashdump_dump_output((unsigned char *)separate_line, sizeof(separate_line) - 1);
    len = snprintf(crash_buf, sizeof(crash_buf), "%08lX/%08lX" NEW_LINE_STR, crash_output_p->hdr.seqnum, crash_output_p->hdr.partnum);
    crashdump_dump_output((unsigned char *)crash_buf, len);
    crashdump_dump_output((unsigned char *)sys_build_info, strlen(sys_build_info));
    crashdump_dump_output((unsigned char *)separate_line, sizeof(separate_line) - 1);

#if defined(TRACE_DUMP2FLASH)
    {
        const unsigned char *e1 = NULL, *e2 = NULL;
        unsigned int len1 = 0, len2 = 0;

        hal_trace_get_history_buffer(&e1, &len1, &e2, &len2);
        if (e1 && len1) {
            crashdump_dump_output(e1, len1);
        }
        if (e2 && len2) {
            crashdump_dump_output(e2, len2);
        }
    }
#endif
    crashdump_dump_output((unsigned char *)separate_line, sizeof(separate_line) - 1);

    crashdump_dumptoflash();
    return 0;
}

#if defined(CRASH_DUMP_SECTION_SIZE) && (CRASH_DUMP_SECTION_SIZE > 0)
static void crashdump_state_handler(enum HAL_TRACE_STATE_T state)
{
    if (state == HAL_TRACE_STATE_CRASH_START) {
        crashdump_init();
    }
}
#endif

bool crashdump_is_crash_happened(void)
{
    return isCrashHappened;
}

bool crashdump_is_crash_dump_existing(void)
{
    return isCrashDumpExisting;
}

void crashdump_set_existing_flag(uint8_t isExisting)
{
    isCrashDumpExisting = isExisting;
}

int32_t crashdump_get_latest_flash_offset(void)
{
    if (crashdump_is_crash_dump_existing())
    {
        if ((uint32_t)__crash_dump_start == (uint32_t)crash_dump_section_p)
        {
            return ((uint32_t)__crash_dump_end - sizeof(struct CRASH_OUTPUT_BUF_T))&0x3FFFFF;
        }
        else
        {
            return ((uint32_t)crash_dump_section_p - sizeof(struct CRASH_OUTPUT_BUF_T))&0x3FFFFF;
        }
    }
    else
    {
        return -1;
    }
}

void crashdump_test_flash_access(void)
{
    TRACE(1,"Did crash just happen: %d", crashdump_is_crash_happened());

    TRACE(1,"Did crash ever happen: %d", crashdump_is_crash_dump_existing());

    int32_t latestCrashDumpFlashOffset = crashdump_get_latest_flash_offset();
    if (latestCrashDumpFlashOffset > 0)
    {
        TRACE(2,"The latest crash dump flash offset 0x%x flash logic addr 0x%x",
        latestCrashDumpFlashOffset,
        latestCrashDumpFlashOffset + FLASH_NC_BASE);

        struct CRASH_OUTPUT_BUF_T* pBuf =
            (struct CRASH_OUTPUT_BUF_T *)(latestCrashDumpFlashOffset + FLASH_NC_BASE);
        TRACE(1,"Valid content size of the dump log is %d", pBuf->hdr.bufpos);
        TRACE(1,"Logic address of the trace buffer is 0x%x", pBuf->buf);
        TRACE(1,"Up to %d logs can be saved in the flash", pBuf->hdr.partnum);
        TRACE(1,"Log seq number is %d", pBuf->hdr.seqnum);

        for (int i = 0; i < pBuf->hdr.bufpos;i++)
        {
            TRACE_NOCRLF(1,"%c", pBuf->buf[i]);
        }
    }
    else
    {
        TRACE(0,"No crash dump log in flash.");
    }

    TRACE(0,"=========================================");
}

#endif // (CRASH_DUMP_SECTION_SIZE > 0)

void crashdump_set_crash_happened_flag(uint8_t isHappened)
{
#if defined(CRASH_DUMP_SECTION_SIZE) && (CRASH_DUMP_SECTION_SIZE > 0)
    isCrashHappened = isHappened;
#endif
}

void crashdump_dumptoflash(void)
{
#if defined(CRASH_DUMP_SECTION_SIZE) && (CRASH_DUMP_SECTION_SIZE > 0)
    uint32_t lock;
    uint32_t dump_section_idx;

    crashdump_get_empty_section(&dump_section_idx, &crash_dump_section_p);
    lock = int_lock_global();
    pmu_flash_write_config();
    hal_norflash_erase(HAL_NORFLASH_ID_0,(uint32_t)crash_dump_section_p,sizeof(struct CRASH_OUTPUT_BUF_T));
    hal_norflash_write(HAL_NORFLASH_ID_0,(uint32_t)crash_dump_section_p,(uint8_t *)crash_output_p, sizeof(struct CRASH_OUTPUT_BUF_T));
    pmu_flash_read_config();
    int_unlock_global(lock);
#endif
}

void crashdump_init_section_info(void)
{
#if defined(CRASH_DUMP_SECTION_SIZE) && (CRASH_DUMP_SECTION_SIZE > 0)
    uint32_t dump_section_idx;
    crashdump_get_empty_section(&dump_section_idx, &crash_dump_section_p);

    hal_trace_app_register(crashdump_state_handler, crashdump_dump_output);
#endif
}
#else
#include <stdio.h>
#include <string.h>
#include "crash_dump_section.h"
#include <string.h>
#include "hal_timer.h"
#include "hal_norflash.h"
#include "norflash_api.h"
#include "cmsis.h"
#include "hal_cache.h"
#include "hal_sleep.h"
#include "pmu.h"
#include "heap_api.h"

extern uint32_t __crash_dump_start;
extern uint32_t __crash_dump_end;
extern void syspool_init_specific_size(uint32_t size);

static const uint32_t crash_dump_flash_start_addr = (uint32_t)&__crash_dump_start;
static const uint32_t crash_dump_flash_end_addr =  (uint32_t)&__crash_dump_end;
static uint32_t crash_dump_flash_len;
static CRASH_DATA_BUFFER crash_data_buffer;
static uint32_t crash_dump_w_seqnum = 0;
static uint32_t crash_dump_flash_offs = 0;
static uint32_t crash_dump_cur_dump_seqnum;
static uint32_t crash_dump_total_len = 0;
static bool crash_dump_is_init = false;
static uint8_t crash_dump_is_happend = 0;
static uint32_t crash_dump_type;
HAL_TRACE_APP_NOTIFY_T crash_dump_notify_cb = NULL;
HAL_TRACE_APP_OUTPUT_T crash_dump_output_cb = NULL;
HAL_TRACE_APP_OUTPUT_T crash_dump_fault_cb = NULL;
static enum NORFLASH_API_RET_T _flash_api_read(uint32_t addr, uint8_t* buffer, uint32_t len)
{

    return norflash_sync_read(NORFLASH_API_MODULE_ID_CRASH_DUMP,
                addr,
                buffer,
                len);
}


static int32_t _crash_dump_get_seqnum(uint32_t * dump_seqnum, uint32_t *sector_seqnum)
{
    uint32_t i;
    uint32_t count;
    static enum NORFLASH_API_RET_T result;
    CRASH_DUMP_HEADER_T crash_dump_header;
    uint32_t max_dump_seqnum = 0;
    uint32_t max_sector_seqnum = 0;
    bool is_existed = false;

    count = (crash_dump_flash_end_addr-crash_dump_flash_start_addr)/CRASH_DUMP_BUFFER_LEN;
    for(i = 0; i < count; i++)
    {
        result = _flash_api_read(
                    crash_dump_flash_start_addr + i*CRASH_DUMP_BUFFER_LEN,
                    (uint8_t*)&crash_dump_header,
                    sizeof(CRASH_DUMP_HEADER_T));
        if(result == NORFLASH_API_OK)
        {
            if(crash_dump_header.magic == CRASH_DUMP_MAGIC_CODE
               && crash_dump_header.version == CRASH_DUMP_VERSION
              )
            {
                is_existed = true;
                if(crash_dump_header.seqnum > max_dump_seqnum)
                {
                    max_dump_seqnum = crash_dump_header.seqnum;
                    max_sector_seqnum = i;
                }
            }
        }
        else
        {
            ASSERT(0,"_crash_dump_get_seqnum: _flash_api_read failed!result = %d.",result);
        }
    }
    if(is_existed)
    {
        *dump_seqnum = max_dump_seqnum + 1;
        *sector_seqnum = max_sector_seqnum + 1 >= count ? 0: max_sector_seqnum + 1;
    }
    else
    {
        *dump_seqnum = 0;
        *sector_seqnum = 0;
    }
    return 0;
}
static void _crash_dump_notify(enum HAL_TRACE_STATE_T state)
{
    uint32_t lock;
    CRASH_DATA_BUFFER *data_buff = NULL;

    if(!crash_dump_is_init)
    {
        return;
    }
    if(state == HAL_TRACE_STATE_CRASH_ASSERT_START)
    {
        crash_dump_type = CRASH_DUMP_ASSERT_CODE;
    }
    else if(state == HAL_TRACE_STATE_CRASH_FAULT_START)
    {
        crash_dump_type = CRASH_DUMP_EXCEPTION_CODE;
    }
    CRASH_DUMP_TRACE(2,"__CRASH_DUMP:%s: state = %d.",__func__,state);
    CRASH_DUMP_TRACE(3,"__CRASH_DUMP:%s: start_addr = 0x%x,end_addr = 0x%x.",
                __func__,crash_dump_flash_start_addr,crash_dump_flash_end_addr);
    CRASH_DUMP_TRACE(3,"__CRASH_DUMP:%s: dump_seqnum = 0x%x,flash_offset = 0x%x.",
                __func__,crash_dump_cur_dump_seqnum,crash_dump_flash_offs);

    if(HAL_TRACE_STATE_CRASH_END == state)
    {
        lock = int_lock_global();
        data_buff = &crash_data_buffer;
        crash_dump_write(crash_dump_flash_start_addr + crash_dump_flash_offs,
                                 data_buff->buffer,data_buff->offset);
        int_unlock_global(lock);
    }
}

static void _crash_dump_output(const unsigned char *buf, unsigned int buf_len)
{
    //uint32_t len,len1;
    uint32_t uint_len;
    uint32_t written_len;
    uint32_t remain_len;
    CRASH_DUMP_HEADER_T log_header;
    CRASH_DATA_BUFFER *data_buff = NULL;

    if(!crash_dump_is_init)
    {
        return;
    }

    if(strstr((char*)buf,CRASH_DUMP_PREFIX) != NULL)
    {
        return;
    }

    data_buff = &crash_data_buffer;
    remain_len = buf_len;
    written_len = 0;
    do{
        if(data_buff->offset ==  0)
        {
            CRASH_DUMP_TRACE(4,"__CRASH_DUMP:%s:%d offset = 0.w_seqnum = %d,dump_seqnum = %d.",
                __func__,__LINE__,crash_dump_w_seqnum,crash_dump_cur_dump_seqnum);
            memset((uint8_t*)&log_header,0,sizeof(log_header));
            log_header.magic = CRASH_DUMP_MAGIC_CODE;
            log_header.version = CRASH_DUMP_VERSION;
            log_header.seqnum = crash_dump_cur_dump_seqnum;
            log_header.reseved[0] = '\0';
            log_header.reseved[1] = '\0';
            log_header.reseved[2] = '\0';
            log_header.reseved[3] = '\n';
            memcpy(data_buff->buffer + data_buff->offset,
                    (uint8_t*)&log_header,
                    sizeof(log_header));

            data_buff->offset += sizeof(log_header);
            crash_dump_cur_dump_seqnum ++;
        }

        if(data_buff->offset + remain_len > CRASH_DUMP_SECTOR_SIZE)
        {
            uint_len = (CRASH_DUMP_SECTOR_SIZE - data_buff->offset);
        }
        else
        {
            uint_len = remain_len;
        }
        if(uint_len > 0)
        {
            memcpy(data_buff->buffer + data_buff->offset,
                    buf + written_len,
                    uint_len);
            data_buff->offset += uint_len;
            written_len += uint_len;
            crash_dump_total_len += uint_len;
        }

        if(data_buff->offset == CRASH_DUMP_SECTOR_SIZE)
        {
            crash_dump_write(crash_dump_flash_start_addr + crash_dump_flash_offs,
                             data_buff->buffer,data_buff->offset);

            crash_dump_flash_offs = crash_dump_flash_offs + data_buff->offset >= crash_dump_flash_len ?\
                                    0 : crash_dump_flash_offs + data_buff->offset;
            data_buff->offset = 0;
        }
        remain_len -= uint_len;
    }while(remain_len > 0);
}

static void _crash_dump_fault(const unsigned char *buf, unsigned int buf_len)
{
    _crash_dump_output(buf,buf_len);
}

void crash_dump_init(void)
{
    uint32_t block_size = 0;
    uint32_t sector_size = 0;
    uint32_t page_size = 0;
    uint32_t buffer_len = 0;
    uint32_t dump_seqnum = 0;
    uint32_t sector_seqnum = 0;
    enum NORFLASH_API_RET_T result;

    hal_norflash_get_size(HAL_NORFLASH_ID_0,NULL, &block_size, &sector_size, &page_size);
    buffer_len = CRASH_DUMP_NORFALSH_BUFFER_LEN;
    CRASH_DUMP_TRACE(4,"__CRASH_DUMP:%s: crash_dump_start = 0x%x, crash_dump_end = 0x%x, buff_len = 0x%x.",
                    __func__,
                    crash_dump_flash_start_addr,
                    crash_dump_flash_end_addr,
                    buffer_len);

    result = norflash_api_register(
                    NORFLASH_API_MODULE_ID_CRASH_DUMP,
                    HAL_NORFLASH_ID_0,
                    crash_dump_flash_start_addr,
                    crash_dump_flash_end_addr - crash_dump_flash_start_addr,
                    block_size,
                    sector_size,
                    page_size,
                    buffer_len,
                    NULL
                    );

    if(result == NORFLASH_API_OK)
    {
        CRASH_DUMP_TRACE(1,"__CRASH_DUMP:%s: norflash_api_register ok.", __func__);
    }
    else
    {
        CRASH_DUMP_TRACE(2,"__CRASH_DUMP:%s: norflash_api_register failed,result = %d", __func__, result);
        return;
    }

    crash_dump_notify_cb = _crash_dump_notify;
    crash_dump_output_cb = _crash_dump_output;
    crash_dump_fault_cb = _crash_dump_fault;

    hal_trace_app_custom_register(crash_dump_notify_handler,crash_dump_output_handler,crash_dump_fault_handler);
    _crash_dump_get_seqnum(&dump_seqnum,&sector_seqnum);
    crash_dump_cur_dump_seqnum = dump_seqnum;
    crash_dump_flash_len = crash_dump_flash_end_addr - crash_dump_flash_start_addr;
    crash_dump_flash_offs = sector_seqnum*CRASH_DUMP_BUFFER_LEN;
    crash_data_buffer.offset = 0;
    crash_data_buffer.buffer = NULL;
    crash_dump_w_seqnum = 0;
    crash_dump_total_len = 0;
    crash_dump_is_init = true;
}

void crash_dump_init_buffer(void)
{
    crash_data_buffer.offset = 0;
    syspool_init_specific_size(CRASH_DUMP_BUFFER_LEN);
    syspool_get_buff(&(crash_data_buffer.buffer), CRASH_DUMP_BUFFER_LEN);
}

int32_t crash_dump_read(uint32_t addr,uint8_t* ptr,uint32_t len)
{
    enum NORFLASH_API_RET_T ret;

    ret = norflash_sync_read(NORFLASH_API_MODULE_ID_CRASH_DUMP,
                addr,
                ptr,
                len);
    if(ret != NORFLASH_API_OK)
    {
        CRASH_DUMP_TRACE(4,"__CRASH_DUMP:%s: norflash_sync_read,addr = 0x%x,len = 0x%x,ret = %d.",
                        __func__,addr,len,ret);
        return ret;
    }
    return 0;
}

int32_t crash_dump_write(uint32_t addr,uint8_t* ptr,uint32_t len)
{
    enum NORFLASH_API_RET_T ret;

    if(CRASH_LOG_ALIGN(addr,CRASH_DUMP_SECTOR_SIZE) != addr)
    {
        CRASH_DUMP_TRACE(2,"__CRASH_DUMP:%s: addr not aligned! addr = 0x%x.",__func__,addr);
        return (int32_t)NORFLASH_API_BAD_ADDR;
    }
    ret = norflash_api_erase(NORFLASH_API_MODULE_ID_CRASH_DUMP,
                        addr,
                        CRASH_DUMP_SECTOR_SIZE,
                        false);
    if(ret != NORFLASH_API_OK)
    {
        CRASH_DUMP_TRACE(3,"__CRASH_DUMP:%s: norflash_api_erase failed! addr = 0x%x,ret = %d.",
                        __func__,addr,ret);
        return (int32_t)ret;
    }
    ret = norflash_api_write(NORFLASH_API_MODULE_ID_CRASH_DUMP,
                addr,
                ptr,
                len,
                false);
    if(ret != NORFLASH_API_OK)
    {
        CRASH_DUMP_TRACE(4,"__CRASH_DUMP:%s: norflash_api_write,addr = 0x%x,len = 0x%x,ret = %d.",
                        __func__,addr,len,ret);
        return (int32_t)ret;
    }
    return 0;
}

void crash_dump_notify_handler(enum HAL_TRACE_STATE_T state)
{
    if ((state == HAL_TRACE_STATE_CRASH_ASSERT_START)
            || (state == HAL_TRACE_STATE_CRASH_FAULT_START)) {
        norflash_api_flush_enable_all();
        crash_dump_init_buffer();
    }

    if(crash_dump_notify_cb)
    {
        crash_dump_notify_cb(state);
    }
}

void crash_dump_output_handler(const unsigned char *buf, unsigned int buf_len)
{
    if(crash_dump_output_cb)
    {
        crash_dump_output_cb(buf,buf_len);
    }
}

void crash_dump_fault_handler(const unsigned char *buf, unsigned int buf_len)
{
    if(crash_dump_fault_cb)
    {
        crash_dump_fault_cb(buf,buf_len);
    }
}

void crash_dump_set_flag(uint8_t is_happend)
{
    crash_dump_is_happend = is_happend;
}

void crash_dump_register(HAL_TRACE_APP_NOTIFY_T notify_cb,HAL_TRACE_APP_OUTPUT_T crash_output_cb,HAL_TRACE_APP_OUTPUT_T crash_fault_cb)
{
    crash_dump_notify_cb = notify_cb;
    crash_dump_output_cb = crash_output_cb;
    crash_dump_fault_cb = crash_fault_cb;
}

CRASH_DATA_BUFFER* crash_dump_get_buffer(void)
{
    return &crash_data_buffer;
}

uint32_t crash_dump_get_type(void)
{
    return crash_dump_type;
}


#endif

