1392 lines
42 KiB
C++
1392 lines
42 KiB
C++
#include "cmsis.h"
|
|
#include "stdio.h"
|
|
#include "string.h"
|
|
#ifdef RTOS
|
|
#include "cmsis_os.h"
|
|
#else
|
|
#include "hal_timer.h"
|
|
#endif
|
|
#include "hal_norflash.h"
|
|
#include "hal_sleep.h"
|
|
#include "hal_trace.h"
|
|
#include "norflash_api.h"
|
|
#include "pmu.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);
|
|
}
|