#include "stdio.h"
#include "string.h"
#include "cmsis.h"
#ifdef RTOS
#include "cmsis_os.h"
#else
#include "hal_timer.h"
#endif
#include "pmu.h"
#include "hal_sleep.h"
#include "hal_trace.h"
#include "hal_norflash.h"
#include "norflash_api.h"

#if 0
#define NORFLASH_API_TRACE(str,...) TRACE(str, ##__VA_ARGS__)
#else
#define NORFLASH_API_TRACE(str,...)
#endif

#define API_IS_ALIGN(v,size)  (((v/size)*size) == v)

static NORFLASH_API_INFO norflash_api_info = {false,};
static OPERA_INFO_LIST opera_info_list[NORFLASH_API_OPRA_LIST_LEN];
static DATA_LIST      data_list[NORFLASH_API_WRITE_BUFF_LEN];
static int suspend_number = 0;

static void* _norflash_api_malloc(uint32_t size)
{
    uint32_t i;

    if(size == sizeof(OPRA_INFO))
    {
        for(i = 0; i < NORFLASH_API_OPRA_LIST_LEN; i++)
        {
            if(opera_info_list[i].is_used == false)
            {
                opera_info_list[i].is_used = true;
                return (void*)&opera_info_list[i].opera_info;
            }
        }
        return NULL;
    }
    else if(size == NORFLASH_API_SECTOR_SIZE)
    {
        for(i = 0; i < NORFLASH_API_WRITE_BUFF_LEN; i++)
        {
            if(data_list[i].is_used == false)
            {
                data_list[i].is_used = true;
                return (void*)data_list[i].buffer;
            }
        }
        return NULL;
    }
    else
    {
        ASSERT(0,"%s: size(0x%x) error!", __func__, size);
    }
}

static void _norflash_api_free(void *p)
{
    uint32_t i;

    for(i = 0; i < NORFLASH_API_OPRA_LIST_LEN; i++)
    {
        if((uint8_t*)&opera_info_list[i].opera_info == p)
        {
            opera_info_list[i].is_used = false;
            return;
        }
    }

    for(i = 0; i < NORFLASH_API_WRITE_BUFF_LEN; i++)
    {
        if(data_list[i].buffer == p)
        {
            data_list[i].is_used = false;
            return;
        }
    }

    ASSERT(0,"%s: p(%p) error!", __func__, p);
}

static MODULE_INFO* _get_module_info(enum NORFLASH_API_MODULE_ID_T mod_id)
{
    return &norflash_api_info.mod_info[mod_id];
}

static OPRA_INFO* _get_tail(MODULE_INFO *mod_info,bool is_remove)
{
    OPRA_INFO *opera_node = NULL;
    OPRA_INFO *pre_node = NULL;
    OPRA_INFO *tmp;

    pre_node = mod_info->opera_info;
    tmp = mod_info->opera_info;
    while(tmp)
    {
        opera_node = tmp;
        tmp = opera_node->next;
        if(tmp)
        {
            pre_node = opera_node;
        }
    }
    if(is_remove)
    {
        if(pre_node)
        {
            pre_node->next = NULL;
        }
    }
    if(opera_node)
    {
        opera_node->lock = true;
    }
    return opera_node;
}

static void _opera_del(MODULE_INFO *mod_info,OPRA_INFO *node)
{
    OPRA_INFO *opera_node = NULL;
    OPRA_INFO *pre_node = NULL;
    OPRA_INFO *tmp;

    pre_node = mod_info->opera_info;
    tmp = mod_info->opera_info;
    while(tmp)
    {
        opera_node = tmp;
        if(opera_node == node)
        {
            if(mod_info->opera_info == opera_node)
            {
                mod_info->opera_info = NULL;
            }
            else
            {
                pre_node->next = NULL;
            }
            if(node->buff)
            {
                _norflash_api_free(node->buff);
            }
            _norflash_api_free(node);
            break;
        }
        tmp = opera_node->next;
        if(tmp)
        {
            pre_node = opera_node;
        }
    }
}

static uint32_t _get_ew_count(MODULE_INFO *mod_info)
{
    OPRA_INFO *opera_node = NULL;
    OPRA_INFO *tmp;
    uint32_t count = 0;

    tmp = mod_info->opera_info;
    while(tmp)
    {
        opera_node = tmp;
        count ++;
        tmp = opera_node->next;
    }
    return count;
}

static uint32_t _get_w_count(MODULE_INFO *mod_info)
{
    OPRA_INFO *opera_node = NULL;
    OPRA_INFO *tmp;
    uint32_t count = 0;

    tmp = mod_info->opera_info;
    while(tmp)
    {
        opera_node = tmp;
        if(opera_node->type == NORFLASH_API_WRITTING)
        {
            count ++;
        }
        tmp = opera_node->next;
    }
    return count;
}

static uint32_t _get_e_count(MODULE_INFO *mod_info)
{
    OPRA_INFO *opera_node = NULL;
    OPRA_INFO *tmp;
    uint32_t count = 0;

    tmp = mod_info->opera_info;
    while(tmp)
    {
        opera_node = tmp;
        if(opera_node->type == NORFLASH_API_ERASING)
        {
            count ++;
        }
        tmp = opera_node->next;
    }
    return count;
}

static MODULE_INFO* _get_cur_mod(void)
{
    uint32_t i;
    MODULE_INFO *mod_info = NULL;
    uint32_t tmp_mod_id = NORFLASH_API_MODULE_ID_COUNT;

    if(norflash_api_info.cur_mod)
    {
        return norflash_api_info.cur_mod;
    }

    tmp_mod_id = norflash_api_info.cur_mod_id;
    for(i = 0; i < NORFLASH_API_MODULE_ID_COUNT; i++)
    {
        tmp_mod_id =  tmp_mod_id + 1 >= NORFLASH_API_MODULE_ID_COUNT ? 0 : tmp_mod_id + 1;
        mod_info = _get_module_info((enum NORFLASH_API_MODULE_ID_T)tmp_mod_id);
        if(mod_info->is_inited)
        {
            if(_get_ew_count(mod_info) > 0)
            {
                return mod_info;
            }
        }
    }
    return NULL;
}

static enum NORFLASH_API_MODULE_ID_T _get_mod_id(MODULE_INFO *mod_info)
{
    uint32_t i;
    enum NORFLASH_API_MODULE_ID_T mod_id = NORFLASH_API_MODULE_ID_COUNT;
    MODULE_INFO *tmp_mod_info = NULL;

    for(i = 0; i < NORFLASH_API_MODULE_ID_COUNT; i++)
    {
        tmp_mod_info = _get_module_info((enum NORFLASH_API_MODULE_ID_T)i);
        if(tmp_mod_info == mod_info)
        {
            mod_id = (enum NORFLASH_API_MODULE_ID_T)i;
            break;
        }
    }
    return mod_id;
}

#ifdef FLASH_REMAP
static void _flash_remap_start(enum HAL_NORFLASH_ID_T id,uint32_t addr, uint32_t len)
{
    uint32_t remap_addr;
    uint32_t remap_len;
    uint32_t remap_offset;
    enum HAL_NORFLASH_RET_T ret;

    remap_addr = OTA_CODE_OFFSET;
    remap_len = OTA_REMAP_OFFSET - OTA_CODE_OFFSET;
    remap_offset = OTA_REMAP_OFFSET;

    // NORFLASH_API_TRACE(3,"%s: id = %d,addr = 0x%x,len = 0x%x.", __func__,id,addr,len);
    if((addr & 0x3ffffff) + len <= (remap_addr & 0x3ffffff) ||
       (addr & 0x3ffffff) >= (remap_addr & 0x3ffffff) + remap_len)
    {
        // NORFLASH_API_TRACE(3,"%s: Not in the remap area.",__func__);
        return;
    }

    if(((addr & 0x3ffffff)  < (remap_addr & 0x3ffffff) &&
       (addr & 0x3ffffff) + len > (remap_addr & 0x3ffffff)) ||
       ((addr & 0x3ffffff)  < (remap_addr & 0x3ffffff) + remap_len  &&
       (addr & 0x3ffffff) + len > (remap_addr & 0x3ffffff) + remap_len))
    {
        ASSERT(0,"%s: Address ranges bad!addr = 0x%x, len=0x%x,remap_addr=0x%x,remap_len=0x%x",
            __func__, addr, len, remap_addr, remap_len);
    }

    if(!hal_norflash_get_remap_status(id))
    {
        // NORFLASH_API_TRACE(3,"%s: Unremap to enable remap.",__func__);
        ret = hal_norflash_enable_remap(id, remap_addr, remap_len, remap_offset);
        ASSERT(ret == HAL_NORFLASH_OK, "%s: Failed to enable remap(0x%x,0x%x,0x%x), ret = %d",
            __func__, remap_addr, remap_len, remap_offset, ret);
    }
    else
    {
        // NORFLASH_API_TRACE(3,"%s: Remaped to disable remap.",__func__);
        ret = hal_norflash_disable_remap(id);
        ASSERT(ret == HAL_NORFLASH_OK, "%s: Failed to disable remap, ret = %d",
            __func__, ret);
    }
}

static void _flash_remap_done(enum HAL_NORFLASH_ID_T id,uint32_t addr, uint32_t len)
{
    uint32_t remap_addr;
    uint32_t remap_len;
    uint32_t remap_offset;
    enum HAL_NORFLASH_RET_T ret;

    remap_addr = OTA_CODE_OFFSET;
    remap_len = OTA_REMAP_OFFSET - OTA_CODE_OFFSET;
    remap_offset = OTA_REMAP_OFFSET;

    // NORFLASH_API_TRACE(3, "%s: id = %d,addr = 0x%x,len = 0x%x.", __func__,id,addr,len);
    if((addr & 0x3ffffff) + len <= (remap_addr & 0x3ffffff) ||
       (addr & 0x3ffffff) >= (remap_addr & 0x3ffffff) + remap_len)
    {
        // NORFLASH_API_TRACE(3,"%s: Not in the remap area.",__func__);
        return;
    }

    if(((addr & 0x3ffffff)  < (remap_addr & 0x3ffffff) &&
       (addr & 0x3ffffff) + len > (remap_addr & 0x3ffffff)) ||
       ((addr & 0x3ffffff)  < (remap_addr & 0x3ffffff) + remap_len  &&
       (addr & 0x3ffffff) + len > (remap_addr & 0x3ffffff) + remap_len))
    {
        ASSERT(0,"%s: Address ranges bad!addr = 0x%x, len=0x%x,remap_addr=0x%x,remap_len=0x%x",
            __func__, addr, len, remap_addr, remap_len);
    }

    if(!hal_norflash_get_remap_status(id))
    {
        // NORFLASH_API_TRACE(3, "%s: Unremap to enable remap.",__func__);
        ret = hal_norflash_enable_remap(id, remap_addr, remap_len, remap_offset);
        ASSERT(ret == HAL_NORFLASH_OK, "%s: Failed to enable remap(0x%x,0x%x,0x%x), ret = %d",
            __func__, remap_addr, remap_len, remap_offset, ret);
    }
    else
    {
        // NORFLASH_API_TRACE(3, "%s: Remaped to disable remap.",__func__);
        ret = hal_norflash_disable_remap(id);
        ASSERT(ret == HAL_NORFLASH_OK, "%s: Failed to disable remap, ret = %d",
            __func__, ret);
    }
}


#define FLASH_REMAP_START _flash_remap_start
#define FLASH_REMAP_DONE _flash_remap_done
#else
#define FLASH_REMAP_START(...)
#define FLASH_REMAP_DONE(...)
#endif

static int32_t _opera_read(MODULE_INFO *mod_info,
               uint32_t addr,
               uint8_t *buff,
               uint32_t len)
{
    OPRA_INFO *opera_node = NULL;
    OPRA_INFO *e_node = NULL;
    OPRA_INFO *w_node = NULL;
    OPRA_INFO *tmp;
    uint32_t r_offs;
    uint32_t sec_start;
    uint32_t sec_len;

    sec_len = mod_info->mod_sector_len;
    sec_start = (addr/sec_len)*sec_len;
    tmp = mod_info->opera_info;
    while(tmp)
    {
        opera_node = tmp;
        tmp = opera_node->next;
        if(opera_node->addr == sec_start)
        {
            if(opera_node->type == NORFLASH_API_WRITTING)
            {
                w_node = opera_node;
                break;
            }
            else
            {
                e_node = opera_node;
                break;
            }
        }
    }

    if(w_node)
    {
        r_offs = addr - sec_start;
        memcpy(buff,w_node->buff + r_offs,len);
    }
    else
    {
        if(e_node)
        {
            memset(buff,0xff,len);
        }
        else
        {
            FLASH_REMAP_START(mod_info->dev_id,addr,len);
            memcpy(buff,(uint8_t*)addr,len);
            FLASH_REMAP_DONE(mod_info->dev_id,addr,len);
            /*
            HAL_NORFLASH_RET_T result;
            result = hal_norflash_read(mod_info->dev_id,addr,buff,len);
            if(result != HAL_NORFLASH_OK)
            {
                NORFLASH_API_TRACE(2,"%s: hal_norflash_read failed,result = %d.",
                        __func__,result);
                return result;
            }
            */
        }
    }
    return 0;
}

static int32_t _e_opera_add(MODULE_INFO *mod_info,
               uint32_t addr,
               uint32_t len
               )
{
    OPRA_INFO *opera_node = NULL;
    OPRA_INFO *pre_node = NULL;
    OPRA_INFO *tmp;
    int32_t ret = 0;

    // delete opera nodes with the same address when add the erase opera node.
    pre_node = mod_info->opera_info;
    tmp = mod_info->opera_info;
    while(tmp)
    {
        opera_node = tmp;
        tmp = opera_node->next;

        if(opera_node->addr == addr)
        {
            if(opera_node->lock == false)
            {
                if(opera_node == mod_info->opera_info)
                {
                    mod_info->opera_info = tmp;
                }
                else
                {
                    pre_node->next = tmp;
                }
                if(opera_node->type == NORFLASH_API_WRITTING)
                {
                    if(opera_node->buff)
                    {
                        _norflash_api_free(opera_node->buff);
                    }
                }
                _norflash_api_free(opera_node);
            }
            else
            {
                if(opera_node->type == NORFLASH_API_ERASING)
                {
                    NORFLASH_API_TRACE(3,"%s: erase is merged! addr = 0x%x,len = 0x%x.",
                        __func__,
                        opera_node->addr,
                        opera_node->len);
                    ret = 0;
                    goto _func_end;
                }
            }
        }

        if(tmp)
        {
            pre_node = opera_node;
        }
    }

    // add new node to header.
    opera_node = (OPRA_INFO*)_norflash_api_malloc(sizeof(OPRA_INFO));
    if(opera_node == NULL)
    {
        NORFLASH_API_TRACE(3,"%s:%d,_norflash_api_malloc failed! size = %d.",
                __func__,__LINE__,sizeof(OPRA_INFO));
        ret = 1;
        goto _func_end;
    }
    opera_node->type = NORFLASH_API_ERASING;
    opera_node->addr = addr;
    opera_node->len = len;
    opera_node->w_offs = 0;
    opera_node->w_len = 0;
    opera_node->buff = NULL;
    opera_node->lock = false;
    opera_node->next = mod_info->opera_info;
    mod_info->opera_info = opera_node;
    ret = 0;
_func_end:

    return ret;
}

static int32_t _w_opera_add(MODULE_INFO *mod_info,
               uint32_t addr,
               uint32_t len,
               uint8_t *buff)
{
    OPRA_INFO *opera_node = NULL;
    OPRA_INFO *e_node = NULL;
    OPRA_INFO *w_node = NULL;
    OPRA_INFO *tmp;
    uint32_t w_offs;
    uint32_t w_len;
    uint32_t sec_start;
    uint32_t sec_len;
    uint32_t w_end1;
    uint32_t w_end2;
    uint32_t w_start;
    uint32_t w_end;
    uint32_t w_len_new;
    int32_t ret = 0;

    sec_len = mod_info->mod_sector_len;
    sec_start = (addr/sec_len)*sec_len;
    w_offs = addr - sec_start;
    w_len = len;
    tmp = mod_info->opera_info;
    while(tmp)
    {
        opera_node = tmp;
        tmp = opera_node->next;

        if(opera_node->addr == sec_start)
        {
            if(opera_node->type == NORFLASH_API_WRITTING)
            {
                if(!opera_node->lock)
                {
                    // select the first w_node in the list.
                    w_node = opera_node;
                    break;
                }
            }
            else
            {
                e_node = opera_node;
                break;
            }
        }
    }

    if(w_node)
    {
        memcpy(w_node->buff + w_offs,buff,w_len);
        w_start = w_node->w_offs <= w_offs ? w_node->w_offs:w_offs;
        w_end1 = w_node->w_offs + w_node->w_len;
        w_end2 = w_offs + w_len;
        w_end = w_end1 >= w_end2 ? w_end1 : w_end2;
        w_len_new = w_end - w_start;
        w_node->w_offs = w_start;
        w_node->w_len = w_len_new;
        opera_node = w_node;
        ret = 0;
    }
    else
    {
        opera_node = (OPRA_INFO*)_norflash_api_malloc(sizeof(OPRA_INFO));
        if(opera_node == NULL)
        {
            NORFLASH_API_TRACE(3,"%s:%d,_norflash_api_malloc failed! size = %d.",
                    __func__,__LINE__,sizeof(OPRA_INFO));
             ret = 1;
             goto _func_end;
        }
        opera_node->type = NORFLASH_API_WRITTING;
        opera_node->addr = sec_start;
        opera_node->len = sec_len;
        opera_node->w_offs = w_offs;
        opera_node->w_len = w_len;
        opera_node->buff = (uint8_t*)_norflash_api_malloc(opera_node->len);
        if(opera_node->buff == NULL)
        {
            _norflash_api_free(opera_node);
            NORFLASH_API_TRACE(3,"%s:%d,_norflash_api_malloc failed! size = %d.",
                    __func__,__LINE__,opera_node->len);
             ret = 1;
             goto _func_end;
        }
        if(e_node)
        {
            memset(opera_node->buff,0xff,opera_node->len);
        }
        else
        {
            memcpy(opera_node->buff,(uint8_t*)opera_node->addr,opera_node->len);
        }
        memcpy(opera_node->buff + w_offs,buff,w_len);
        opera_node->lock = false;
        opera_node->next = mod_info->opera_info;
        mod_info->opera_info = opera_node;
        ret = 0;
    }

_func_end:
    return ret;
}

bool _opera_flush(MODULE_INFO *mod_info,bool nosuspend)
{
    OPRA_INFO *cur_opera_info = NULL;
    enum HAL_NORFLASH_RET_T result;
    bool opera_is_completed = false;
    NORFLASH_API_OPERA_RESULT opera_result;
    bool ret = false;
    bool suspend;

#if defined(FLASH_SUSPEND)
    suspend = true;
#else
    suspend = false;
#endif
    suspend = nosuspend == true ? false: suspend;

    if(!mod_info->cur_opera_info)
    {
        mod_info->cur_opera_info = _get_tail(mod_info, false);
    }

    if(!mod_info->cur_opera_info)
    {
        return false;
    }

    ret = true;
    cur_opera_info = mod_info->cur_opera_info;
    if(cur_opera_info->type == NORFLASH_API_WRITTING)
    {
        if(mod_info->state == NORFLASH_API_STATE_IDLE)
        {
            suspend_number = 0;
            if(cur_opera_info->w_len > 0)
            {
                NORFLASH_API_TRACE(5,"%s: %d,hal_norflash_write_suspend,addr = 0x%x,len = 0x%x,suspend = %d.",
                                __func__,__LINE__,
                                cur_opera_info->addr + cur_opera_info->w_offs,
                                cur_opera_info->w_len,
                                suspend);

                FLASH_REMAP_START(mod_info->dev_id,cur_opera_info->addr + cur_opera_info->w_offs,cur_opera_info->w_len);
                pmu_flash_write_config();
                result = hal_norflash_write_suspend(mod_info->dev_id,
                             cur_opera_info->addr + cur_opera_info->w_offs,
                             cur_opera_info->buff + cur_opera_info->w_offs,
                             cur_opera_info->w_len,
                             suspend);
                pmu_flash_read_config();
                FLASH_REMAP_DONE(mod_info->dev_id,cur_opera_info->addr + cur_opera_info->w_offs,cur_opera_info->w_len);
            }
            else
            {
                result = HAL_NORFLASH_OK;
            }

            if(result == HAL_NORFLASH_OK)
            {
                opera_is_completed = true;
                goto __opera_is_completed;
            }
            else if(result == HAL_NORFLASH_SUSPENDED)
            {
                mod_info->state = NORFLASH_API_STATE_WRITTING_SUSPEND;
            }
            else
            {
                ASSERT(0, "%s: %d, hal_norflash_write_suspend failed,result = %d",__func__,__LINE__,result);
            }
        }
        else if(mod_info->state == NORFLASH_API_STATE_WRITTING_SUSPEND)
        {
            suspend_number ++;
            FLASH_REMAP_START(mod_info->dev_id,cur_opera_info->addr + cur_opera_info->w_offs,cur_opera_info->w_len);
            pmu_flash_write_config();
            result = hal_norflash_write_resume(mod_info->dev_id,
                         suspend);
            pmu_flash_read_config();
            FLASH_REMAP_DONE(mod_info->dev_id,cur_opera_info->addr + cur_opera_info->w_offs,cur_opera_info->w_len);
            if(result == HAL_NORFLASH_OK)
            {
                opera_is_completed = true;
                goto __opera_is_completed;
            }
            else if(result == HAL_NORFLASH_SUSPENDED)
            {
                mod_info->state = NORFLASH_API_STATE_WRITTING_SUSPEND;
            }
            else
            {
                ASSERT(0, "%s: %d, hal_norflash_write_resume failed,result = %d",__func__,__LINE__,result);
            }
        }
        else
        {
            ASSERT(0, "%s: %d, mod_info->state error,state = %d",__func__,__LINE__,mod_info->state);
        }
    }
    else
    {
        if(mod_info->state == NORFLASH_API_STATE_IDLE)
        {
            suspend_number = 0;
            NORFLASH_API_TRACE(5,"%s: %d,hal_norflash_erase_suspend,addr = 0x%x,len = 0x%x,suspend = %d.",
                                __func__,__LINE__,
                                cur_opera_info->addr,
                                cur_opera_info->len,
                                suspend);
            FLASH_REMAP_START(mod_info->dev_id, cur_opera_info->addr, cur_opera_info->len);
            pmu_flash_write_config();
            result = hal_norflash_erase_suspend(mod_info->dev_id,
                         cur_opera_info->addr,
                         cur_opera_info->len,
                         suspend);
            pmu_flash_read_config();
            FLASH_REMAP_DONE(mod_info->dev_id, cur_opera_info->addr, cur_opera_info->len);
            if(result == HAL_NORFLASH_OK)
            {
                opera_is_completed = true;
                goto __opera_is_completed;
            }
            else if(result == HAL_NORFLASH_SUSPENDED)
            {
                mod_info->state = NORFLASH_API_STATE_ERASE_SUSPEND;
            }
            else
            {
                ASSERT(0, "%s: %d, hal_norflash_erase_suspend failed,result = %d",__func__,__LINE__,result);
            }
        }
        else if(mod_info->state == NORFLASH_API_STATE_ERASE_SUSPEND)
        {
            suspend_number ++;
            FLASH_REMAP_START(mod_info->dev_id, cur_opera_info->addr, cur_opera_info->len);
            pmu_flash_write_config();
            result = hal_norflash_erase_resume(mod_info->dev_id,
                         suspend);
            pmu_flash_read_config();
            FLASH_REMAP_DONE(mod_info->dev_id, cur_opera_info->addr, cur_opera_info->len);
            if(result == HAL_NORFLASH_OK)
            {
                opera_is_completed = true;
                goto __opera_is_completed;
            }
            else if(result == HAL_NORFLASH_SUSPENDED)
            {
                mod_info->state = NORFLASH_API_STATE_ERASE_SUSPEND;
            }
            else
            {
                ASSERT(0, "%s: %d, hal_norflash_write_resume failed,result = %d",
                       __func__,__LINE__,result);
            }
        }
        else
        {
            ASSERT(0, "%s: %d, mod_info->state error,state = %d",
                __func__,__LINE__,mod_info->state);
        }
    }

__opera_is_completed:

    if(opera_is_completed)
    {
        mod_info->state = NORFLASH_API_STATE_IDLE;
        if(!nosuspend
           && mod_info->cb_func
           && ((cur_opera_info->w_len > 0 && cur_opera_info->type == NORFLASH_API_WRITTING)
               || (cur_opera_info->len > 0 && cur_opera_info->type == NORFLASH_API_ERASING))
           )
        {
            NORFLASH_API_TRACE(6,"%s: w/e done.type = %d,addr = 0x%x,w_len = 0x%x,len = 0x%x,suspend_num = %d.",
                __func__,
                cur_opera_info->type,
                cur_opera_info->addr + cur_opera_info->w_offs,
                cur_opera_info->w_len,
                cur_opera_info->len,
                suspend_number);
            if(cur_opera_info->type == NORFLASH_API_WRITTING)
            {
                opera_result.addr = cur_opera_info->addr + cur_opera_info->w_offs;
                opera_result.len = cur_opera_info->w_len;
            }
            else
            {
                opera_result.addr = cur_opera_info->addr;
                opera_result.len = cur_opera_info->len;
            }
            opera_result.type = cur_opera_info->type;
            opera_result.result = NORFLASH_API_OK;
            opera_result.remain_num = _get_ew_count(mod_info) - 1;
            mod_info->cb_func(&opera_result);
        }
        _opera_del(mod_info,cur_opera_info);
        mod_info->cur_opera_info = NULL;
    }

    return ret;
}

void _flush_disable(enum NORFLASH_API_USER user_id,uint32_t cb)
{
    norflash_api_info.allowed_cb[user_id] = (NOFLASH_API_FLUSH_ALLOWED_CB)cb;
}

void _flush_enable(enum NORFLASH_API_USER user_id)
{
    norflash_api_info.allowed_cb[user_id] = NULL;
}

bool _flush_is_allowed(void)
{
    bool ret = true;
    uint32_t user_id;

    for(user_id = NORFLASH_API_USER_CP; user_id < NORFLASH_API_USER_COUNTS; user_id ++)
    {
        if(norflash_api_info.allowed_cb[user_id])
        {
            if(!norflash_api_info.allowed_cb[user_id]())
            {
                ret = false;
            }
            else
            {
                norflash_api_info.allowed_cb[user_id] = NULL;
            }
        }
    }
    return ret;
}

//-------------------------------------------------------------------
// APIS Function.
//-------------------------------------------------------------------
enum NORFLASH_API_RET_T norflash_api_init(void)
{
    uint32_t i;

    memset((void*)&norflash_api_info,0,sizeof(NORFLASH_API_INFO));
    norflash_api_info.cur_mod_id = NORFLASH_API_MODULE_ID_COUNT;
    norflash_api_info.is_inited = true;
    norflash_api_info.cur_mod = NULL;
    for(i = 0; i < NORFLASH_API_MODULE_ID_COUNT; i++)
    {
        norflash_api_info.mod_info[i].state = NORFLASH_API_STATE_UNINITED;
    }

#if !defined(FLASH_API_SIMPLE)
#if defined(FLASH_SUSPEND)
    hal_sleep_set_sleep_hook(HAL_SLEEP_HOOK_NORFLASH_API, norflash_api_flush);
#else
    hal_sleep_set_deep_sleep_hook(HAL_DEEP_SLEEP_HOOK_NORFLASH_API, norflash_api_flush);
#endif
#endif

    return NORFLASH_API_OK;
}

enum NORFLASH_API_RET_T norflash_api_register(
                enum NORFLASH_API_MODULE_ID_T mod_id,
                enum HAL_NORFLASH_ID_T dev_id,
                uint32_t mod_base_addr,
                uint32_t mod_len,
                uint32_t mod_block_len,
                uint32_t mod_sector_len,
                uint32_t mod_page_len,
                uint32_t buffer_len,
                NORFLASH_API_OPERA_CB cb_func
                )
{
    MODULE_INFO *mod_info = NULL;

    NORFLASH_API_TRACE(5,"%s: mod_id = %d,dev_id = %d,mod_base_addr = 0x%x,mod_len = 0x%x,",
            __func__,mod_id,dev_id,mod_base_addr,mod_len);
    NORFLASH_API_TRACE(4,"mod_block_len = 0x%x,mod_sector_len = 0x%x,mod_page_len = 0x%x,buffer_len = 0x%x.",
            mod_block_len,mod_sector_len,mod_page_len,buffer_len);
    if(!norflash_api_info.is_inited)
    {
        NORFLASH_API_TRACE(2,"%s: %d, norflash_api uninit!",__func__,__LINE__);
        return NORFLASH_API_ERR_UNINIT;
    }

    if(mod_id >= NORFLASH_API_MODULE_ID_COUNT)
    {
        NORFLASH_API_TRACE(2,"%s : mod_id error! mod_id = %d.",__func__, mod_id);
        return NORFLASH_API_BAD_MOD_ID;
    }

    if(dev_id >= HAL_NORFLASH_ID_NUM)
    {
        NORFLASH_API_TRACE(2,"%s : dev_id error! mod_id = %d.",__func__,dev_id);
        return NORFLASH_API_BAD_DEV_ID;
    }

    if(buffer_len < mod_sector_len || !API_IS_ALIGN(buffer_len,mod_sector_len))
    {
        NORFLASH_API_TRACE(2,"%s : buffer_len error buffer_len = %d.",__func__, buffer_len);
        return NORFLASH_API_BAD_BUFF_LEN;
    }
    mod_info = _get_module_info(mod_id);
    if(mod_info->is_inited)
    {
        // NORFLASH_API_TRACE(3,"%s: %d, norflash_async[%d] has registered!",__func__,__LINE__,mod_id);
        return NORFLASH_API_OK; //NORFLASH_API_ERR_HASINIT;
    }
    mod_info->dev_id = dev_id;
    mod_info->mod_id = mod_id;
    mod_info->mod_base_addr = mod_base_addr;
    mod_info->mod_len = mod_len;
    mod_info->mod_block_len = mod_block_len;
    mod_info->mod_sector_len = mod_sector_len;
    mod_info->mod_page_len = mod_page_len;
    mod_info->buff_len = buffer_len;
    mod_info->cb_func = cb_func;
    mod_info->opera_info = NULL;
    mod_info->cur_opera_info = NULL;
    mod_info->state = NORFLASH_API_STATE_IDLE;
    mod_info->is_inited = true;
    return NORFLASH_API_OK;
}

enum NORFLASH_API_RET_T norflash_api_read(
                enum NORFLASH_API_MODULE_ID_T mod_id,
                uint32_t start_addr,
                uint8_t *buffer,
                uint32_t len
                )
{
    MODULE_INFO *mod_info = NULL;
    int32_t result;
    enum NORFLASH_API_RET_T ret;
    uint32_t lock;

    NORFLASH_API_TRACE(4,"%s:mod_id = %d,start_addr = 0x%x,len = 0x%x",
                __func__,mod_id, start_addr, len);
    ASSERT(buffer,"%s:buffer is null! ",
                __func__);
    if(!norflash_api_info.is_inited)
    {
        NORFLASH_API_TRACE(1,"%s: norflash_api uninit!",__func__);
        return NORFLASH_API_ERR_UNINIT;
    }
    if(mod_id >= NORFLASH_API_MODULE_ID_COUNT)
    {
        NORFLASH_API_TRACE(2,"%s : mod_id error! mod_id = %d.",__func__, mod_id);
        return NORFLASH_API_BAD_MOD_ID;
    }

    mod_info = _get_module_info(mod_id);
    if(!mod_info->is_inited)
    {
        NORFLASH_API_TRACE(2,"%s : module unregistered! mod_id = %d.",__func__, mod_id);
        return NORFLASH_API_ERR_UNINIT;
    }

    if(start_addr < mod_info->mod_base_addr
       || start_addr + len > mod_info->mod_base_addr + mod_info->mod_len)
    {
        NORFLASH_API_TRACE(3,"%s : reading out of range! start_address = 0x%x,len = 0x%x.",
                    __func__, start_addr, len);
        return NORFLASH_API_BAD_ADDR;
    }

    if(len == 0)
    {
        NORFLASH_API_TRACE(2,"%s : len error! len = %d.",
                   __func__, len);
        return NORFLASH_API_BAD_LEN;
    }
    lock = int_lock_global();
    result = _opera_read(mod_info,start_addr,(uint8_t*)buffer,len);

    if(result)
    {
        ret =  NORFLASH_API_ERR;
    }
    else
    {
        ret = NORFLASH_API_OK;
    }
    int_unlock_global(lock);
    NORFLASH_API_TRACE(2,"%s: done. ret = %d.",__func__,ret);
    return ret;
}

enum NORFLASH_API_RET_T norflash_sync_read(
                enum NORFLASH_API_MODULE_ID_T mod_id,
                uint32_t start_addr,
                uint8_t *buffer,
                uint32_t len
                )
{
    MODULE_INFO *mod_info = NULL;
    uint32_t lock;

    NORFLASH_API_TRACE(4,"%s:mod_id = %d,start_addr = 0x%x,len = 0x%x",
                __func__,mod_id,start_addr,len);
    ASSERT(buffer,"%s:%d,buffer is null! ",
                __func__,__LINE__);
    if(!norflash_api_info.is_inited)
    {
        NORFLASH_API_TRACE(1,"%s: norflash_api uninit!", __func__);
        return NORFLASH_API_ERR_UNINIT;
    }
    if(mod_id >= NORFLASH_API_MODULE_ID_COUNT)
    {
        NORFLASH_API_TRACE(2,"%s : mod_id error! mod_id = %d.", __func__, mod_id);
        return NORFLASH_API_BAD_MOD_ID;
    }

    mod_info = _get_module_info(mod_id);
    if(!mod_info->is_inited)
    {
        NORFLASH_API_TRACE(2,"%s : module unregistered! mod_id = %d.",__func__, mod_id);
        return NORFLASH_API_ERR_UNINIT;
    }

    if(start_addr < mod_info->mod_base_addr
       || start_addr + len > mod_info->mod_base_addr + mod_info->mod_len)
    {
        NORFLASH_API_TRACE(3,"%s : reading out of range! start_address = 0x%x,len = 0x%x.",
                    __func__, start_addr, len);
        return NORFLASH_API_BAD_ADDR;
    }

    if(len == 0)
    {
        NORFLASH_API_TRACE(2,"%s : len error! len = %d.",
                   __func__, len);
        return NORFLASH_API_BAD_LEN;
    }

    lock = int_lock_global();
    FLASH_REMAP_START(mod_info->dev_id,start_addr, len);
    memcpy(buffer,(uint8_t*)start_addr,len);
    FLASH_REMAP_DONE(mod_info->dev_id,start_addr, len);
    NORFLASH_API_TRACE(1,"%s: done.",__func__);
    int_unlock_global(lock);

    return NORFLASH_API_OK;
}

enum NORFLASH_API_RET_T norflash_api_erase(
                enum NORFLASH_API_MODULE_ID_T mod_id,
                uint32_t start_addr,
                uint32_t len,
                bool async
                )
{
    MODULE_INFO *mod_info = NULL;
    MODULE_INFO *cur_mod_info = NULL;
    uint32_t lock;
    int32_t result;
    bool bresult = false;
    enum NORFLASH_API_RET_T ret;

    NORFLASH_API_TRACE(5,"%s: mod_id = %d,start_addr = 0x%x,len = 0x%x,async = %d.",
                __func__,mod_id,start_addr,len,async);
    if(!norflash_api_info.is_inited)
    {
        NORFLASH_API_TRACE(1,"%s: norflash_api uninit!",__func__);
        return NORFLASH_API_ERR_UNINIT;
    }
    if(mod_id >= NORFLASH_API_MODULE_ID_COUNT)
    {
        NORFLASH_API_TRACE(2,"%s : invalid mod_id! mod_id = %d.",__func__, mod_id);
        return NORFLASH_API_BAD_MOD_ID;
    }

    mod_info = _get_module_info(mod_id);
    if(!mod_info->is_inited)
    {
        NORFLASH_API_TRACE(2,"%s : module unregistered! mod_id = %d.",__func__, mod_id);
        return NORFLASH_API_ERR_UNINIT;
    }

    if(start_addr < mod_info->mod_base_addr
       || start_addr + len > mod_info->mod_base_addr + mod_info->mod_len)
    {
        NORFLASH_API_TRACE(3,"%s : erase out of range! start_address = 0x%x,len = 0x%x.",
                    __func__,start_addr,len);
        return NORFLASH_API_BAD_ADDR;
    }

    if(!API_IS_ALIGN(start_addr,mod_info->mod_sector_len))
    {
        NORFLASH_API_TRACE(2,"%s : start_address no alignment! start_address = %d.",
                   __func__, start_addr);
        return NORFLASH_API_BAD_ADDR;
    }

    if(
#ifdef PUYA_FLASH_ERASE_PAGE_ENABLE
       len != mod_info->mod_page_len &&
#endif
       len != mod_info->mod_sector_len &&
       len != mod_info->mod_block_len)
    {
        NORFLASH_API_TRACE(2,"%s : len error. len = %d!",
                   __func__, len);
        return NORFLASH_API_BAD_LEN;
    }

#if defined(FLASH_API_SIMPLE)
    async = false;
#endif
    if(async)
    {
        lock = int_lock_global();

        // add to opera_info chain header.
        result = _e_opera_add(mod_info,start_addr,len);
        if(result == 0)
        {
            ret = NORFLASH_API_OK;
        }
        else
        {
            ret = NORFLASH_API_BUFFER_FULL;
        }
        int_unlock_global(lock);
        NORFLASH_API_TRACE(4,"%s: _e_opera_add done. start_addr = 0x%x,len = 0x%x,ret = %d.",
                __func__,start_addr,len,ret);
    }
    else
    {
        lock = int_lock_global();
        // Handle the suspend operation.
        if(norflash_api_info.cur_mod != NULL
           && mod_info != norflash_api_info.cur_mod)
        {
            cur_mod_info = norflash_api_info.cur_mod;
            while(cur_mod_info->state != NORFLASH_API_STATE_IDLE)
            {
                if(!_flush_is_allowed())
                {
                    continue;
                }
                bresult = _opera_flush(cur_mod_info,true);
                if(!bresult)
                {
                    norflash_api_info.cur_mod = NULL;
                }
            }
        }

        // flush all of cur module opera.
        // norflash_api_info.cur_mod_id = mod_id;
        do{
            if(!_flush_is_allowed())
            {
                continue;
            }
            bresult = _opera_flush(mod_info,true);
        }while(bresult);
        FLASH_REMAP_START(mod_info->dev_id,start_addr,len);
        pmu_flash_write_config();
        result = hal_norflash_erase(mod_info->dev_id,start_addr, len);
        pmu_flash_read_config();
        FLASH_REMAP_DONE(mod_info->dev_id,start_addr,len);
        if(result == HAL_NORFLASH_OK)
        {
            ret = NORFLASH_API_OK;
        }
        else if(result == HAL_NORFLASH_BAD_ADDR)
        {
            ret = NORFLASH_API_BAD_ADDR;
        }
        else if(result == HAL_NORFLASH_BAD_LEN)
        {
            ret = NORFLASH_API_BAD_LEN;
        }
        else
        {
            ret = NORFLASH_API_ERR;
        }
        int_unlock_global(lock);
        NORFLASH_API_TRACE(4,"%s: hal_norflash_erase done. start_addr = 0x%x,len = 0x%x,ret = %d.",
                __func__,start_addr,len,ret);
    }
    //NORFLASH_API_TRACE(2,"%s: done.ret = %d.",__func__, ret);
    return ret;
}

enum NORFLASH_API_RET_T norflash_api_write(
                enum NORFLASH_API_MODULE_ID_T mod_id,
                uint32_t start_addr,
                const uint8_t *buffer,
                uint32_t len,
                bool async
                )
{
    MODULE_INFO *mod_info = NULL;
    MODULE_INFO *cur_mod_info = NULL;
    uint32_t lock;
    int32_t result;
    bool bresult = false;
    enum NORFLASH_API_RET_T ret;

    NORFLASH_API_TRACE(4,"%s: mod_id = %d,start_addr = 0x%x,len = 0x%x.",
                __func__,mod_id,start_addr,len);

    if(!norflash_api_info.is_inited)
    {
        NORFLASH_API_TRACE(1,"%s: norflash_api uninit!",__func__);
        return NORFLASH_API_ERR_UNINIT;
    }

    if(mod_id > NORFLASH_API_MODULE_ID_COUNT)
    {
        NORFLASH_API_TRACE(2,"%s : mod_id error! mod_id = %d.",__func__, mod_id);
        return NORFLASH_API_BAD_MOD_ID;
    }

    mod_info = _get_module_info(mod_id);
    if(!mod_info->is_inited)
    {
        NORFLASH_API_TRACE(2,"%s :module unregistered! mod_id = %d.",__func__, mod_id);
        return NORFLASH_API_ERR_UNINIT;
    }


    if(start_addr < mod_info->mod_base_addr
       || start_addr + len > mod_info->mod_base_addr + mod_info->mod_len)
    {
        NORFLASH_API_TRACE(3,"%s : writting out of range! start_address = 0x%x,len = 0x%x.",
                    __func__,mod_info->mod_base_addr,mod_info->mod_len);
        return NORFLASH_API_BAD_ADDR;
    }

    if(len == 0)
    {
        NORFLASH_API_TRACE(2,"%s : len error! len = %d.",
                   __func__,len);
        return NORFLASH_API_BAD_LEN;
    }
#if defined(FLASH_API_SIMPLE)
    async = false;
#endif
    if(async)
    {
        // add to opera_info chain header.
        lock = int_lock_global();
        result = _w_opera_add(mod_info,start_addr,len,(uint8_t*)buffer);
        if(result == 0)
        {
            ret = NORFLASH_API_OK;
        }
        else
        {
            ret = NORFLASH_API_BUFFER_FULL;
        }
        int_unlock_global(lock);
        NORFLASH_API_TRACE(4,"%s: _w_opera_add done. start_addr = 0x%x,len = 0x%x,ret = %d.",
                __func__,start_addr,len,ret);
    }
    else
    {
        lock = int_lock_global();

        // flush the opera of currently being processed.
        if(norflash_api_info.cur_mod != NULL
            && mod_info != norflash_api_info.cur_mod)
        {
            cur_mod_info = norflash_api_info.cur_mod;
            while(cur_mod_info->state != NORFLASH_API_STATE_IDLE)
            {
                if(!_flush_is_allowed())
                {
                    continue;
                }
                bresult = _opera_flush(cur_mod_info,true);
                if(!bresult)
                {
                    norflash_api_info.cur_mod = NULL;
                }
            }
        }

        // flush all of cur module opera.
        do{
            if(!_flush_is_allowed())
            {
                continue;
            }
            bresult = _opera_flush(mod_info,true);
        }while(bresult);
        FLASH_REMAP_START(mod_info->dev_id,start_addr,len);
        pmu_flash_write_config();
        result = hal_norflash_write(mod_info->dev_id,start_addr, buffer, len);
        pmu_flash_read_config();
        FLASH_REMAP_DONE(mod_info->dev_id,start_addr,len);
        if(result == HAL_NORFLASH_OK)
        {
            ret = NORFLASH_API_OK;
        }
        else if(result == HAL_NORFLASH_BAD_ADDR)
        {
            ret = NORFLASH_API_BAD_ADDR;
        }
        else if(result == HAL_NORFLASH_BAD_LEN)
        {
            ret = NORFLASH_API_BAD_LEN;
        }
        else
        {
            ret = NORFLASH_API_ERR;
        }
        int_unlock_global(lock);
        NORFLASH_API_TRACE(4,"%s: hal_norflash_write done. start_addr = 0x%x,len = 0x%x,ret = %d.",
                __func__,start_addr,len,ret);
    }
    return ret;
}

// -1: error, 0:all pending flash op flushed, 1:still pending flash op to be flushed
int norflash_api_flush(void)
{
    enum NORFLASH_API_MODULE_ID_T mod_id = NORFLASH_API_MODULE_ID_COUNT;
    MODULE_INFO *mod_info = NULL;
    uint32_t lock;
    bool bret = false;

    lock = int_lock_global();
    if(!norflash_api_info.is_inited)
    {
        NORFLASH_API_TRACE(1,"%s: norflash_api uninit!",__func__);
        int_unlock_global(lock);
        return -1;
    }
#if defined(FLASH_API_SIMPLE)
    int_unlock_global(lock);
    return 0;
#endif

    if(!_flush_is_allowed())
    {
        int_unlock_global(lock);
        return 0;
    }

    mod_info = _get_cur_mod();
    if(!mod_info)
    {
        int_unlock_global(lock);
        return 0;
    }
    mod_id = _get_mod_id(mod_info);

    norflash_api_info.cur_mod_id = mod_id;
    norflash_api_info.cur_mod = mod_info;
    bret = _opera_flush(mod_info,false);
    if(!bret)
    {
        norflash_api_info.cur_mod = NULL;
    }
    int_unlock_global(lock);

    return 1;
}

bool norflash_api_buffer_is_free(
                enum NORFLASH_API_MODULE_ID_T mod_id)
{
    MODULE_INFO *mod_info = NULL;
    uint32_t count;

    if(mod_id >= NORFLASH_API_MODULE_ID_COUNT)
    {
        ASSERT(0,"%s : mod_id error! mod_id = %d.",__func__, mod_id);
    }

    mod_info = _get_module_info(mod_id);
    if(!mod_info->is_inited)
    {
        ASSERT(0,"%s : mod_id error! mod_id = %d.",__func__, mod_id);
    }

    count = _get_ew_count(mod_info);
    if(count > 0)
    {
        return false;
    }
    else
    {
        return true;
    }
}

uint32_t norflash_api_get_used_buffer_count(
                enum NORFLASH_API_MODULE_ID_T mod_id,
                enum NORFLASH_API_OPRATION_TYPE type
                )
{
    MODULE_INFO *mod_info = NULL;
    uint32_t count = 0;

    if(mod_id >= NORFLASH_API_MODULE_ID_COUNT)
    {
        ASSERT(0,"%s : mod_id error! mod_id = %d.",__func__, mod_id);
    }

    mod_info = _get_module_info(mod_id);
    if(!mod_info->is_inited)
    {
        ASSERT(0,"%s : mod_id error! mod_id = %d.",__func__, mod_id);
    }
    if(type & NORFLASH_API_WRITTING)
    {
        count = _get_w_count(mod_info);
    }

    if(type & NORFLASH_API_ERASING)
    {
        count += _get_e_count(mod_info);
    }
    return count;
}

uint32_t norflash_api_get_free_buffer_count(
                enum NORFLASH_API_OPRATION_TYPE type
                )
{
    MODULE_INFO *mod_info = NULL;
    uint32_t i;
    uint32_t used_count = 0;
    uint32_t free_count = 0;

    if(type & NORFLASH_API_WRITTING)
    {
        for(i = NORFLASH_API_MODULE_ID_LOG_DUMP; i < NORFLASH_API_MODULE_ID_COUNT; i ++)
        {
            mod_info = _get_module_info((enum NORFLASH_API_MODULE_ID_T)i);
            if(mod_info->is_inited)
            {
                used_count += _get_w_count(mod_info);
            }
        }
        ASSERT(used_count <= NORFLASH_API_OPRA_LIST_LEN,"writting opra count error!");
        free_count += (NORFLASH_API_OPRA_LIST_LEN - used_count);
    }

    if(type & NORFLASH_API_ERASING)
    {
        for(i = NORFLASH_API_MODULE_ID_LOG_DUMP; i < NORFLASH_API_MODULE_ID_COUNT; i ++)
        {
            mod_info = _get_module_info((enum NORFLASH_API_MODULE_ID_T)i);
            if(mod_info->is_inited)
            {
                used_count += _get_e_count(mod_info);
            }
        }
        ASSERT(used_count <= NORFLASH_API_OPRA_LIST_LEN,"erase opra count error!");
        free_count += (NORFLASH_API_OPRA_LIST_LEN - used_count);
    }
    return free_count;
}


void norflash_api_flush_all(void)
{
    int ret;
    int cnt = 0;

    norflash_api_flush_enable_all();
    do
    {
        ret = norflash_api_flush();
        if(ret == 1)
        {
            cnt ++;
        }
    } while (1 == ret);

    NORFLASH_API_TRACE(2,"%s: done. cnt = %d.",__func__,cnt);
}

void norflash_api_flush_disable(enum NORFLASH_API_USER user_id,uint32_t cb)
{
    if(!norflash_api_info.is_inited)
    {
        return;
    }
    ASSERT(user_id < NORFLASH_API_USER_COUNTS, "%s: user_id(%d) error!", __func__, user_id);
    _flush_disable(user_id,cb);
}

void norflash_api_flush_enable(enum NORFLASH_API_USER user_id)
{
    if(!norflash_api_info.is_inited)
    {
        return;
    }
    ASSERT(user_id < NORFLASH_API_USER_COUNTS, "%s: user_id(%d) too large!", __func__, user_id);
    _flush_enable(user_id);
}

void norflash_api_flush_enable_all(void)
{
    uint32_t user_id;

    if(!norflash_api_info.is_inited)
    {
        return;
    }
    for(user_id = NORFLASH_API_USER_CP; user_id < NORFLASH_API_USER_COUNTS; user_id ++)
    {
        _flush_enable((enum NORFLASH_API_USER)user_id);
    }
}


enum NORFLASH_API_STATE norflash_api_get_state(enum NORFLASH_API_MODULE_ID_T mod_id)
{
    ASSERT(mod_id < NORFLASH_API_MODULE_ID_COUNT,"%s : mod_id error! mod_id = %d.",__func__, mod_id);
    return norflash_api_info.mod_info[mod_id].state;
}

void norflash_flush_all_pending_op(void)
{
    norflash_api_flush_all();
}

void app_flush_pending_flash_op(enum NORFLASH_API_MODULE_ID_T module,
    enum NORFLASH_API_OPRATION_TYPE type)
{
    hal_trace_pause();
    do
    {
        norflash_api_flush();
        if (NORFLASH_API_ALL != type)
        {
            if (0 == norflash_api_get_used_buffer_count(module, type))
            {
                break;
            }
        }
        else
        {
            if (norflash_api_buffer_is_free(module))
            {
                break;
            }
        }
        osDelay(10);
    } while (1);

    hal_trace_continue();
}

void app_flash_page_erase(enum NORFLASH_API_MODULE_ID_T module, uint32_t flashOffset)
{
    // check whether the flash has been erased
    bool isEmptyPage            = true;
    uint32_t *ptrStartFlashAddr = ( uint32_t * )(FLASH_NC_BASE + flashOffset);
    for (uint32_t index = 0; index < FLASH_SECTOR_SIZE / sizeof(uint32_t); index++)
    {
        if (0xFFFFFFFF != ptrStartFlashAddr[index])
        {
            isEmptyPage = false;
            break;
        }
    }

    if (isEmptyPage)
    {
        return;
    }

    uint32_t lock;
    enum NORFLASH_API_RET_T ret;

    flashOffset &= 0xFFFFFF;
    do
    {
        lock = int_lock_global();
        hal_trace_pause();
        ret = norflash_api_erase(module,
                                 (FLASH_NC_BASE + flashOffset),
                                 FLASH_SECTOR_SIZE,
                                 true);
        hal_trace_continue();
        int_unlock_global(lock);

        if (NORFLASH_API_OK == ret)
        {
            TRACE(1,"%s: norflash_api_erase ok!", __func__);
            break;
        }
        else if (NORFLASH_API_BUFFER_FULL == ret)
        {
            TRACE(0,"Flash async cache overflow! To flush it.");
            app_flush_pending_flash_op(module, NORFLASH_API_ERASING);
        }
        else
        {
            ASSERT(0, "%s: norflash_api_erase failed. ret = %d", __FUNCTION__, ret);
        }
    } while (1);
}

void app_flash_page_program(enum NORFLASH_API_MODULE_ID_T module,
                             uint32_t flashOffset,
                             uint8_t *ptr,
                             uint32_t len,
                             bool synWrite)
{
    uint32_t lock;
    enum NORFLASH_API_RET_T ret;
    bool is_async = false;

    flashOffset &= 0xFFFFFF;

    if (synWrite)
    {
        is_async = false;
    }
    else
    {
        is_async = true;
    }

    do
    {
        lock = int_lock_global();
        hal_trace_pause();

        ret = norflash_api_write(module,
                                 (FLASH_NC_BASE + flashOffset),
                                 ptr,
                                 len,
                                 is_async);

        hal_trace_continue();

        int_unlock_global(lock);

        if (NORFLASH_API_OK == ret)
        {
            TRACE(1,"%s: norflash_api_write ok!", __func__);
            break;
        }
        else if (NORFLASH_API_BUFFER_FULL == ret)
        {
            TRACE(0,"Flash async cache overflow! To flush it.");
            app_flush_pending_flash_op(module, NORFLASH_API_WRITTING);
        }
        else
        {
            ASSERT(0, "%s: norflash_api_write failed. ret = %d", __FUNCTION__, ret);
        }
    } while (1);
}