658 lines
19 KiB
C
658 lines
19 KiB
C
#include <stdlib.h>
|
|
#include "cli.h"
|
|
#include "driver/flash.h"
|
|
#include <driver/flash_partition.h>
|
|
#include "sys_driver.h"
|
|
#include "flash_bypass.h"
|
|
#include "flash.h"
|
|
#include <driver/psram.h>
|
|
#include "bk_misc.h"
|
|
#include "driver/wdt.h"
|
|
#include "bk_wdt.h"
|
|
#include <driver/aon_rtc.h>
|
|
#include <common/bk_assert.h>
|
|
|
|
#define TICK_PER_US 26
|
|
beken_thread_t idle_read_flash_handle = NULL;
|
|
beken_thread_t idle_read_psram_handle = NULL;
|
|
|
|
static bk_err_t test_flash_write(volatile uint32_t start_addr, uint32_t len)
|
|
{
|
|
uint32_t i;
|
|
u8 buf[256];
|
|
uint32_t addr = start_addr;
|
|
uint32_t length = len;
|
|
uint32_t tmp = addr + length;
|
|
|
|
for (i = 0; i < 256; i++)
|
|
buf[i] = i;
|
|
|
|
for (; addr < tmp; addr += 256) {
|
|
int int_level = rtos_enter_critical();
|
|
BK_DUMP_OUT("write addr(size:256):%d\r\n", addr);
|
|
rtos_exit_critical(int_level);
|
|
bk_flash_write_bytes(addr, (uint8_t *)buf, 256);
|
|
}
|
|
|
|
return kNoErr;
|
|
}
|
|
|
|
static bk_err_t test_flash_erase(volatile uint32_t start_addr, uint32_t len)
|
|
{
|
|
uint32_t addr = start_addr;
|
|
uint32_t length = len;
|
|
uint32_t tmp = addr + length;
|
|
|
|
for (; addr < tmp; addr += 0x1000) {
|
|
int int_level = rtos_enter_critical();
|
|
BK_DUMP_OUT("erase addr:%d\r\n", addr);
|
|
rtos_exit_critical(int_level);
|
|
bk_flash_erase_sector(addr);
|
|
}
|
|
return kNoErr;
|
|
}
|
|
|
|
static bk_err_t test_flash_read(volatile uint32_t start_addr, uint32_t len)
|
|
{
|
|
uint32_t i, j, tmp;
|
|
u8 buf[256];
|
|
uint32_t addr = start_addr;
|
|
uint32_t length = len;
|
|
tmp = addr + length;
|
|
|
|
for (; addr < tmp; addr += 256) {
|
|
os_memset(buf, 0, 256);
|
|
bk_flash_read_bytes(addr, (uint8_t *)buf, 256);
|
|
int int_level = rtos_enter_critical();
|
|
BK_DUMP_OUT("read addr:%x\r\n", addr);
|
|
rtos_exit_critical(int_level);
|
|
for (i = 0; i < 16; i++) {
|
|
for (j = 0; j < 16; j++)
|
|
BK_DUMP_OUT("%02x ", buf[i * 16 + j]);
|
|
BK_DUMP_OUT("\r\n");
|
|
}
|
|
}
|
|
|
|
return kNoErr;
|
|
}
|
|
|
|
static bk_err_t test_flash_read_without_print(volatile uint32_t start_addr, uint32_t len)
|
|
{
|
|
uint32_t tmp;
|
|
u8 buf[256];
|
|
uint32_t addr = start_addr;
|
|
uint32_t length = len;
|
|
tmp = addr + length;
|
|
|
|
for (; addr < tmp; addr += 256) {
|
|
os_memset(buf, 0, 256);
|
|
bk_flash_read_bytes(addr, (uint8_t *)buf, 256);
|
|
}
|
|
|
|
return kNoErr;
|
|
}
|
|
|
|
static bk_err_t test_flash_read_time(volatile uint32_t start_addr, uint32_t len)
|
|
{
|
|
UINT32 time_start, time_end;
|
|
uint32_t tmp;
|
|
u8 buf[256];
|
|
uint32_t addr = start_addr;
|
|
uint32_t length = len;
|
|
|
|
tmp = addr + length;
|
|
beken_time_get_time((beken_time_t *)&time_start);
|
|
BK_DUMP_OUT("read time start:%d\r\n", time_start);
|
|
|
|
for (; addr < tmp; addr += 256) {
|
|
os_memset(buf, 0, 256);
|
|
bk_flash_read_bytes(addr, (uint8_t *)buf, 256);
|
|
}
|
|
beken_time_get_time((beken_time_t *)&time_end);
|
|
BK_DUMP_OUT("read time end:%d\r\n", time_end);
|
|
BK_DUMP_OUT("cost time:%d\r\n", time_end - time_start);
|
|
|
|
return kNoErr;
|
|
}
|
|
|
|
#if (CONFIG_SOC_BK7256XX)
|
|
static bk_err_t test_flash_count_time(volatile uint32_t start_addr, uint32_t len, uint32_t test_times)
|
|
{
|
|
uint32_t tmp;
|
|
u8 buf[256];
|
|
uint32_t addr = start_addr;
|
|
uint32_t length = len;
|
|
extern u64 riscv_get_mtimer(void);
|
|
uint64_t start_tick, end_tick, tick_cnt = 0;
|
|
uint32_t print_cnt = 100;
|
|
uint32_t int_level = 0;
|
|
|
|
bk_wdt_stop();
|
|
#if (CONFIG_TASK_WDT)
|
|
bk_task_wdt_stop();
|
|
#endif
|
|
|
|
tmp = addr + length;
|
|
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
|
|
|
|
BK_DUMP_OUT("----- FLASH COUNT TIME TEST BEGIN -----\r\n");
|
|
BK_DUMP_OUT("===============================\r\n");
|
|
|
|
for(int i = 0; i <= test_times; i++) {
|
|
|
|
start_tick = riscv_get_mtimer();
|
|
for (addr = start_addr; addr < tmp; addr += 256) {
|
|
os_memset(buf, 0, 256);
|
|
bk_flash_read_bytes(addr, (uint8_t *)buf, 256);
|
|
}
|
|
end_tick = riscv_get_mtimer();
|
|
tick_cnt = end_tick - start_tick;
|
|
if(i % print_cnt == 0) {
|
|
int_level = rtos_enter_critical();
|
|
BK_DUMP_OUT("[read %d time] >>>>> cost tick time: %d us.\r\n", i, (uint32_t) (tick_cnt / TICK_PER_US));
|
|
rtos_exit_critical(int_level);
|
|
}
|
|
|
|
start_tick = riscv_get_mtimer();
|
|
for (addr = start_addr; addr < tmp; addr += 0x1000) {
|
|
bk_flash_erase_sector(addr);
|
|
}
|
|
end_tick = riscv_get_mtimer();
|
|
tick_cnt = end_tick - start_tick;
|
|
if(i % print_cnt == 0) {
|
|
int_level = rtos_enter_critical();
|
|
BK_DUMP_OUT("[erase %d time] >>>>> cost tick time: %d us.\r\n", i, (uint32_t) (tick_cnt / TICK_PER_US));
|
|
rtos_exit_critical(int_level);
|
|
}
|
|
|
|
//check erase data valid
|
|
if(i % print_cnt == 0) {
|
|
for (addr = start_addr; addr < tmp; addr += 256) {
|
|
os_memset(buf, 0, 256);
|
|
bk_flash_read_bytes(addr, (uint8_t *)buf, 256);
|
|
for (int j = 0; j < 256; j++) {
|
|
if(buf[j] != 0xff)
|
|
BK_DUMP_OUT("[erase %d time ERROR]: addr = 0x%x.\r\n", i, addr + j);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int j = 0; j < 256; j++)
|
|
buf[j] = j;
|
|
start_tick = riscv_get_mtimer();
|
|
for (addr = start_addr; addr < tmp; addr += 256) {
|
|
bk_flash_write_bytes(addr, (uint8_t *)buf, 256);
|
|
}
|
|
end_tick = riscv_get_mtimer();
|
|
tick_cnt = end_tick - start_tick;
|
|
if(i % print_cnt == 0) {
|
|
int_level = rtos_enter_critical();
|
|
BK_DUMP_OUT("[write %d time] >>>>> cost tick time: %d us.\r\n", i, (uint32_t) (tick_cnt / TICK_PER_US));
|
|
rtos_exit_critical(int_level);
|
|
}
|
|
|
|
//check write data valid
|
|
if(i % print_cnt == 0) {
|
|
for (addr = start_addr; addr < tmp; addr += 256) {
|
|
os_memset(buf, 0, 256);
|
|
bk_flash_read_bytes(addr, (uint8_t *)buf, 256);
|
|
for (int j = 0; j < 256; j++) {
|
|
if(buf[j] != j)
|
|
BK_DUMP_OUT("[write %d time ERROR]: addr = 0x%x.\r\n", i, addr);
|
|
}
|
|
}
|
|
}
|
|
|
|
start_tick = riscv_get_mtimer();
|
|
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
|
|
end_tick = riscv_get_mtimer();
|
|
tick_cnt = end_tick - start_tick;
|
|
if(i % print_cnt == 0) {
|
|
int_level = rtos_enter_critical();
|
|
BK_DUMP_OUT("[enable security %d time] >>>>> cost tick time: %d us.\r\n", i, (uint32_t)(tick_cnt / TICK_PER_US));
|
|
BK_DUMP_OUT("===============================\r\n");
|
|
rtos_exit_critical(int_level);
|
|
}
|
|
}
|
|
|
|
start_tick = riscv_get_mtimer();
|
|
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
|
|
bk_flash_set_protect_type(FLASH_UNPROTECT_LAST_BLOCK);
|
|
end_tick = riscv_get_mtimer();
|
|
tick_cnt = end_tick - start_tick;
|
|
int_level = rtos_enter_critical();
|
|
BK_DUMP_OUT("[en/dis security 0 time] >>>>> cost tick time: %d us.\r\n", (uint32_t) ((tick_cnt / TICK_PER_US)));
|
|
|
|
BK_DUMP_OUT("----- FLASH COUNT TIME TEST END -----\r\n");
|
|
rtos_exit_critical(int_level);
|
|
|
|
bk_flash_set_protect_type(FLASH_UNPROTECT_LAST_BLOCK);
|
|
return kNoErr;
|
|
}
|
|
#else
|
|
static bk_err_t test_flash_count_time(volatile uint32_t start_addr, uint32_t len, uint32_t test_times)
|
|
{
|
|
uint32_t tmp;
|
|
u8 buf[256];
|
|
uint32_t addr = start_addr;
|
|
uint32_t length = len;
|
|
int32_t tick_cnt = 0;
|
|
uint32_t print_cnt = 100;
|
|
struct timeval rtc_start_time = {0, 0};
|
|
struct timeval rtc_end_time = {0, 0};
|
|
|
|
bk_wdt_stop();
|
|
#if (CONFIG_TASK_WDT)
|
|
bk_task_wdt_stop();
|
|
#endif
|
|
tmp = addr + length;
|
|
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
|
|
|
|
BK_DUMP_OUT("----- FLASH COUNT TIME TEST BEGIN -----\r\n");
|
|
BK_DUMP_OUT("===============================\r\n");
|
|
|
|
for(int i = 0; i <= test_times; i++) {
|
|
bk_rtc_gettimeofday(&rtc_start_time, 0);
|
|
for (addr = start_addr; addr < tmp; addr += 256) {
|
|
os_memset(buf, 0, 256);
|
|
bk_flash_read_bytes(addr, (uint8_t *)buf, 256);
|
|
}
|
|
bk_rtc_gettimeofday(&rtc_end_time, 0);
|
|
tick_cnt = 1000000 * (rtc_end_time.tv_sec - rtc_start_time.tv_sec) + rtc_end_time.tv_usec - rtc_start_time.tv_usec;
|
|
if(i % print_cnt == 0)
|
|
BK_DUMP_OUT("[read %d time] >>>>> cost time: %d us.\r\n", i, tick_cnt);
|
|
|
|
|
|
bk_rtc_gettimeofday(&rtc_start_time, 0);
|
|
for (addr = start_addr; addr < tmp; addr += 0x1000) {
|
|
bk_flash_erase_sector(addr);
|
|
}
|
|
bk_rtc_gettimeofday(&rtc_end_time, 0);
|
|
tick_cnt = 1000000 * (rtc_end_time.tv_sec - rtc_start_time.tv_sec) + rtc_end_time.tv_usec - rtc_start_time.tv_usec;
|
|
if(i % print_cnt == 0)
|
|
BK_DUMP_OUT("[erase %d time] >>>>> cost time: %d us.\r\n", i, tick_cnt);
|
|
|
|
//check erase data valid
|
|
if(i % print_cnt == 0) {
|
|
for (addr = start_addr; addr < tmp; addr += 256) {
|
|
os_memset(buf, 0, 256);
|
|
bk_flash_read_bytes(addr, (uint8_t *)buf, 256);
|
|
for (int j = 0; j < 256; j++) {
|
|
if(buf[j] != 0xff)
|
|
BK_DUMP_OUT("[erase %d time ERROR]: addr = 0x%x.\r\n", i, addr + j);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
for (int j = 0; j < 256; j++)
|
|
buf[j] = j;
|
|
|
|
bk_rtc_gettimeofday(&rtc_start_time, 0);
|
|
for (addr = start_addr; addr < tmp; addr += 256) {
|
|
bk_flash_write_bytes(addr, (uint8_t *)buf, 256);
|
|
}
|
|
bk_rtc_gettimeofday(&rtc_end_time, 0);
|
|
tick_cnt = 1000000 * (rtc_end_time.tv_sec - rtc_start_time.tv_sec) + rtc_end_time.tv_usec - rtc_start_time.tv_usec;
|
|
if(i % print_cnt == 0)
|
|
BK_DUMP_OUT("[write %d time] >>>>> cost time: %d us.\r\n", i, tick_cnt);
|
|
|
|
//check write data valid
|
|
if(i % print_cnt == 0) {
|
|
for (addr = start_addr; addr < tmp; addr += 256) {
|
|
os_memset(buf, 0, 256);
|
|
bk_flash_read_bytes(addr, (uint8_t *)buf, 256);
|
|
for (int j = 0; j < 256; j++) {
|
|
if(buf[j] != j)
|
|
BK_DUMP_OUT("[write %d time ERROR]: addr = 0x%x.\r\n", i, addr);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bk_rtc_gettimeofday(&rtc_start_time, 0);
|
|
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
|
|
bk_rtc_gettimeofday(&rtc_end_time, 0);
|
|
tick_cnt = 1000000 * (rtc_end_time.tv_sec - rtc_start_time.tv_sec) + rtc_end_time.tv_usec - rtc_start_time.tv_usec;
|
|
if(i % print_cnt == 0) {
|
|
BK_DUMP_OUT("[enable security %d time] >>>>> cost time: %d us.\r\n", i, tick_cnt);
|
|
BK_DUMP_OUT("===============================\r\n");
|
|
}
|
|
}
|
|
|
|
bk_rtc_gettimeofday(&rtc_start_time, 0);
|
|
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
|
|
bk_flash_set_protect_type(FLASH_UNPROTECT_LAST_BLOCK);
|
|
bk_rtc_gettimeofday(&rtc_end_time, 0);
|
|
tick_cnt = 1000000 * (rtc_end_time.tv_sec - rtc_start_time.tv_sec) + rtc_end_time.tv_usec - rtc_start_time.tv_usec;
|
|
BK_DUMP_OUT("[en/dis security 0 time] >>>>> cost time: %d us.\r\n", tick_cnt);
|
|
|
|
BK_DUMP_OUT("----- FLASH COUNT TIME TEST END -----\r\n");
|
|
|
|
bk_flash_set_protect_type(FLASH_UNPROTECT_LAST_BLOCK);
|
|
return kNoErr;
|
|
}
|
|
#endif
|
|
|
|
static void test_idle_read_flash(void *arg) {
|
|
while (1) {
|
|
test_flash_read_without_print(0x1000, 1000);
|
|
test_flash_read_without_print(0x100000, 1000);
|
|
test_flash_read_without_print(0x200000, 1000);
|
|
test_flash_read_without_print(0x300000, 0x1000);
|
|
}
|
|
rtos_delete_thread(&idle_read_flash_handle);
|
|
}
|
|
|
|
#define write_data(addr,val) *((volatile unsigned long *)(addr)) = val
|
|
#define read_data(addr,val) val = *((volatile unsigned long *)(addr))
|
|
#define get_addr_data(addr) *((volatile unsigned long *)(addr))
|
|
|
|
#if (CONFIG_PSRAM_AS_SYS_MEMORY)
|
|
bool s_is_cacheable = false;
|
|
bool s_task_stop = false;
|
|
#define PSRAM_DATA_ADDR 0x60000000
|
|
static void test_idle_read_psram(void *arg) {
|
|
uint32_t i, val = 0;
|
|
uint32_t buf_len = 512;
|
|
|
|
BK_DUMP_OUT("enter test_idle_read_psram\r\n");
|
|
|
|
uint32_t *test_data = (uint32_t *)psram_malloc(buf_len);
|
|
if (test_data == NULL) {
|
|
CLI_LOGE("test_data buffer malloc failed\r\n");
|
|
return;
|
|
}
|
|
|
|
while (1) {
|
|
if(s_is_cacheable == false) {
|
|
for(i=0;i<1024;i++){
|
|
write_data((PSRAM_DATA_ADDR+i*0x4),0x11+i);
|
|
write_data((PSRAM_DATA_ADDR + 0x1000 +i*0x4),0x22+i);
|
|
write_data((PSRAM_DATA_ADDR + 0x2000 +i*0x4),0x33+i);
|
|
write_data((PSRAM_DATA_ADDR + 0x3000 +i*0x4),0x44+i);
|
|
}
|
|
for(i=0;i<1024;i++){
|
|
write_data((PSRAM_DATA_ADDR + 0x4000 +i*0x4),0x55+i);
|
|
write_data((PSRAM_DATA_ADDR + 0x5000 +i*0x4),0x66+i);
|
|
write_data((PSRAM_DATA_ADDR + 0x6000 +i*0x4),0x77+i);
|
|
write_data((PSRAM_DATA_ADDR + 0x7000 +i*0x4),0x88+i);
|
|
}
|
|
for(i=0;i<4*1024;i++){
|
|
get_addr_data(PSRAM_DATA_ADDR+i*0x4);
|
|
}
|
|
for(i=0;i<4*1024;i++){
|
|
get_addr_data(PSRAM_DATA_ADDR + 0x4000 +i*0x4);
|
|
}
|
|
for(i=0;i<4*1024;i++){
|
|
get_addr_data(PSRAM_DATA_ADDR + i*0x4);
|
|
}
|
|
for(i=0;i<4*1024;i++){
|
|
get_addr_data(PSRAM_DATA_ADDR + 0x4000 +i*0x4);
|
|
}
|
|
|
|
if(s_task_stop == true) {
|
|
BK_DUMP_OUT("exit test_idle_read_psram non-cacheable.\r\n");
|
|
break;
|
|
}
|
|
} else {
|
|
for (i = 0; i < buf_len / 4; i++) {
|
|
test_data[i] = 0x11223344 + i;
|
|
}
|
|
for (i = 0; i < buf_len / 4; i++) {
|
|
val = test_data[i];
|
|
}
|
|
if(s_task_stop == true) {
|
|
BK_DUMP_OUT("exit test_idle_read_psram cacheable, val = 0x%x\r\n", val);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (test_data) {
|
|
os_free(test_data);
|
|
}
|
|
test_data = NULL;
|
|
|
|
if (idle_read_psram_handle) {
|
|
BK_DUMP_OUT("=====idle_read_psram task stop end========\n");
|
|
rtos_delete_thread(&idle_read_psram_handle);
|
|
idle_read_psram_handle = NULL;
|
|
}
|
|
}
|
|
#endif
|
|
static void flash_command_test(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
char *msg = NULL;
|
|
char cmd = 0;
|
|
uint32_t len = 0;
|
|
uint32_t addr = 0;
|
|
|
|
#if (CONFIG_SYSTEM_CTRL)
|
|
if (os_strcmp(argv[1], "config") == 0) {
|
|
uint32_t flash_src_clk = os_strtoul(argv[2], NULL, 10);
|
|
uint32_t flash_div_clk = os_strtoul(argv[3], NULL, 10);
|
|
uint32_t flash_line_mode = os_strtoul(argv[4], NULL, 10);
|
|
|
|
if (FLASH_CLK_XTAL == flash_src_clk) {
|
|
sys_drv_flash_cksel(flash_src_clk);
|
|
}
|
|
|
|
if((FLASH_CLK_XTAL != sys_drv_flash_get_clk_sel()) && (0 == flash_div_clk)) {
|
|
BK_DUMP_OUT("Config fail. Please set src clk as 26M, or set div larger than 0 firstly.\n");
|
|
return;
|
|
}
|
|
|
|
sys_drv_flash_set_clk_div(flash_div_clk);
|
|
sys_drv_flash_cksel(flash_src_clk);
|
|
bk_flash_set_line_mode(flash_line_mode);
|
|
BK_DUMP_OUT("flash_src_clk = %u. [0:/26M, 1:/480M, 2:/98M]\n", flash_src_clk);
|
|
BK_DUMP_OUT("flash_div_clk = %u. [0:/4, 1:/6, 2:/8, 3:/10]\n", flash_div_clk);
|
|
BK_DUMP_OUT("flash_line_mode = %u. \n", flash_line_mode);
|
|
|
|
return;
|
|
}
|
|
|
|
//used for set flash status in itcm, not used now
|
|
#if 0
|
|
if (os_strcmp(argv[1], "qe") == 0) {
|
|
uint32_t param = 0;
|
|
uint32_t quad_enable = os_strtoul(argv[2], NULL, 10);
|
|
uint32_t delay_cycle1 = os_strtoul(argv[3], NULL, 10);
|
|
uint32_t delay_cycle2 = os_strtoul(argv[4], NULL, 10);
|
|
|
|
for(int i = 0; i< 20; i++) {
|
|
bk_flash_set_line_mode(2);
|
|
flash_bypass_quad_test(quad_enable, delay_cycle1, delay_cycle2);
|
|
while (REG_READ(REG_FLASH_OPERATE_SW) & BUSY_SW);
|
|
param = bk_flash_read_status_reg();
|
|
if (quad_enable) {
|
|
if(param & 0x200){
|
|
break;
|
|
} else {
|
|
BK_DUMP_OUT("retry quad test, i = %d, flash status: 0x%x.\n", i, param);
|
|
}
|
|
} else {
|
|
if(param & 0x200){
|
|
BK_DUMP_OUT("retry quad test, i = %d, flash status: 0x%x.\n", i, param);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (quad_enable) {
|
|
if(param & 0x200){
|
|
BK_DUMP_OUT("flash quad enable success, flash status: 0x%x.\n", param);
|
|
} else {
|
|
BK_DUMP_OUT("flash quad enable fail, flash status: 0x%x.\n", param);
|
|
}
|
|
} else {
|
|
if(param & 0x200){
|
|
BK_DUMP_OUT("flash quad disable fail, flash status: 0x%x.\n", param);
|
|
} else {
|
|
BK_DUMP_OUT("flash quad disable success, flash status: 0x%x.\n", param);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
#endif
|
|
#endif
|
|
if (os_strcmp(argv[1], "idle_read_start") == 0) {
|
|
uint32_t task_prio = os_strtoul(argv[2], NULL, 10);
|
|
BK_DUMP_OUT("idle_read_flash task start: task_prio = %u.\n", task_prio);
|
|
rtos_create_thread(&idle_read_flash_handle, task_prio,
|
|
"idle_read_flash",
|
|
(beken_thread_function_t) test_idle_read_flash,
|
|
CONFIG_APP_MAIN_TASK_STACK_SIZE,
|
|
(beken_thread_arg_t)0);
|
|
|
|
return;
|
|
} else if (os_strcmp(argv[1], "idle_read_stop") == 0) {
|
|
if (idle_read_flash_handle) {
|
|
rtos_delete_thread(&idle_read_flash_handle);
|
|
idle_read_flash_handle = NULL;
|
|
BK_DUMP_OUT("idle_read_flash task stop\n");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#if (CONFIG_PSRAM_AS_SYS_MEMORY)
|
|
if (os_strcmp(argv[1], "idle_read_psram_start") == 0) {
|
|
s_task_stop = false;
|
|
uint32_t task_prio = os_strtoul(argv[2], NULL, 10);
|
|
BK_DUMP_OUT("idle_read_psram task start: task_prio = %u.\n", task_prio);
|
|
rtos_create_thread(&idle_read_psram_handle, task_prio,
|
|
"idle_read_psram",
|
|
(beken_thread_function_t) test_idle_read_psram,
|
|
CONFIG_APP_MAIN_TASK_STACK_SIZE,
|
|
(beken_thread_arg_t)0);
|
|
|
|
return;
|
|
} else if (os_strcmp(argv[1], "idle_read_psram_stop") == 0) {
|
|
s_task_stop = true;
|
|
BK_DUMP_OUT("=====idle_read_psram task stop begin========\n");
|
|
return;
|
|
} else if (os_strcmp(argv[1], "psram_cache") == 0) {
|
|
uint32_t psram_cache_flag = os_strtoul(argv[2], NULL, 10);
|
|
if(psram_cache_flag == 1){
|
|
s_is_cacheable = true;
|
|
BK_DUMP_OUT("idle_read_psram switch to cacheable.\n");
|
|
} else {
|
|
s_is_cacheable = false;
|
|
BK_DUMP_OUT("idle_read_psram switch to non-cacheable.\n");
|
|
}
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
if (os_strcmp(argv[1], "U") == 0) {
|
|
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
|
|
return;
|
|
} else if (os_strcmp(argv[1], "P") == 0) {
|
|
bk_flash_set_protect_type(FLASH_UNPROTECT_LAST_BLOCK);
|
|
return;
|
|
} else if (os_strcmp(argv[1], "RSR") == 0) {
|
|
#if (CONFIG_SYS_CPU0)
|
|
uint16_t sts_val = bk_flash_read_status_reg();
|
|
BK_DUMP_OUT("read sts_val = 0x%x\n", sts_val);
|
|
#else
|
|
BK_DUMP_OUT("notice: this is cpu0 cmd only\n");
|
|
#endif
|
|
return;
|
|
} else if (os_strcmp(argv[1], "WSR") == 0) {
|
|
#if (CONFIG_SYS_CPU0)
|
|
uint16_t sts_val = os_strtoul(argv[2], NULL, 16);
|
|
bk_flash_write_status_reg(sts_val);
|
|
#else
|
|
BK_DUMP_OUT("notice: this is cpu0 cmd only\n");
|
|
#endif
|
|
return;
|
|
} else if (os_strcmp(argv[1], "C") == 0) {
|
|
#if (CONFIG_SYS_CPU0)
|
|
addr = os_strtoul(argv[2], NULL, 16);
|
|
len = os_strtoul(argv[3], NULL, 16);
|
|
uint32_t test_times = os_strtoul(argv[4], NULL, 10);
|
|
test_flash_count_time(addr, len, test_times);
|
|
#else
|
|
BK_DUMP_OUT("notice: this is cpu0 cmd only\n");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (argc == 4) {
|
|
cmd = argv[1][0];
|
|
addr = os_strtoul(argv[2], NULL, 16);
|
|
len = os_strtoul(argv[3], NULL, 16);
|
|
|
|
switch (cmd) {
|
|
case 'E':
|
|
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
|
|
test_flash_erase(addr, len);
|
|
bk_flash_set_protect_type(FLASH_UNPROTECT_LAST_BLOCK);
|
|
msg = CLI_CMD_RSP_SUCCEED;
|
|
break;
|
|
|
|
case 'R':
|
|
test_flash_read(addr, len);
|
|
msg = CLI_CMD_RSP_SUCCEED;
|
|
break;
|
|
case 'W':
|
|
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
|
|
test_flash_write(addr, len);
|
|
bk_flash_set_protect_type(FLASH_UNPROTECT_LAST_BLOCK);
|
|
msg = CLI_CMD_RSP_SUCCEED;
|
|
break;
|
|
//to check whether protection mechanism can work
|
|
case 'N':
|
|
test_flash_erase(addr, len);
|
|
msg = CLI_CMD_RSP_SUCCEED;
|
|
break;
|
|
case 'M':
|
|
test_flash_write(addr, len);
|
|
msg = CLI_CMD_RSP_SUCCEED;
|
|
break;
|
|
case 'T':
|
|
test_flash_read_time(addr, len);
|
|
msg = CLI_CMD_RSP_SUCCEED;
|
|
break;
|
|
default:
|
|
BK_DUMP_OUT("flash_test <R/W/E/M/N/T> <start_addr> <len>\r\n");
|
|
msg = CLI_CMD_RSP_ERROR;
|
|
break;
|
|
}
|
|
} else {
|
|
BK_DUMP_OUT("flash_test <R/W/E/M/N/T> <start_addr> <len>\r\n");
|
|
msg = CLI_CMD_RSP_ERROR;
|
|
}
|
|
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
|
|
}
|
|
|
|
static void partShow_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
bk_partition_t i;
|
|
bk_logic_partition_t *partition;
|
|
|
|
for (i = BK_PARTITION_BOOTLOADER; i <= BK_PARTITION_MAX; i++) {
|
|
partition = bk_flash_partition_get_info(i);
|
|
if (partition == NULL)
|
|
continue;
|
|
|
|
BK_DUMP_OUT("%4d | %11s | Dev:%d | 0x%08lx | 0x%08lx |\r\n", i,
|
|
partition->partition_description, partition->partition_owner,
|
|
partition->partition_start_addr, partition->partition_length);
|
|
};
|
|
|
|
}
|
|
|
|
#define FLASH_CMD_CNT (sizeof(s_flash_commands) / sizeof(struct cli_command))
|
|
static const struct cli_command s_flash_commands[] = {
|
|
{"fmap_test", "flash_test memory map", partShow_Command},
|
|
{"flash_test", "flash_test <cmd(R/W/E/N)>", flash_command_test},
|
|
};
|
|
|
|
int cli_flash_test_init(void)
|
|
{
|
|
return cli_register_commands(s_flash_commands, FLASH_CMD_CNT);
|
|
}
|