rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pinebuds/services/norflash_api/norflash_api.cpp
Ben V. Brown 75381150fd Formatting 
Formatting Pass 1

Lots of fixups to adding stdint and stdbool all over the place

Formatting Pass 2
Formatting Pass 3
Formatting Pass 4

Update app_bt_stream.cpp
2023-02-02 07:56:49 +11:00

1391 lines
42 KiB
C++
Raw Blame History

#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);
}
Reference in a new issue View git blame Copy permalink