andy/kunlun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
69d9e5c33c0b9df454c67bd2709405ac2f1d9bc8
kunlun/dtest/flash_test/sfc_main.c

729 lines
27 KiB
C
Raw Normal View History

初始提交
2024-09-28 14:24:04 +08:00
/****************************************************************************
Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.
This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
be copied by any method or incorporated into another program without
the express written consent of Aerospace C.Power. This Information or any portion
thereof remains the property of Aerospace C.Power. The Information contained herein
is believed to be accurate and Aerospace C.Power assumes no responsibility or
liability for its use in any way and conveys no license or title under
any patent or copyright and makes no representation or warranty that this
Information is free from patent or copyright infringement.
****************************************************************************/
#include "chip_reg_base.h"
#include "hw_reg_api.h"
#include "iot_bitops.h"
#include "flash.h"
#include "os_lock.h"
#include "iot_config.h"
#include "ahb_rf.h"
#include "ahb.h"
#include "clk.h"
#include "sfc.h"
#include "sec_glb.h"
#if HW_PLATFORM > HW_PLATFORM_SIMU
#include "dbg_io.h"
#endif
#include "iot_io.h"
#define SFC_API_TEST 1
#if SFC_API_TEST == 1
#include "sfc.h"
#endif
#define FLASH_TEST_OFFSET (0x100000)
uint8_t rdata[0x100] = {0};
uint8_t wdata[0x100] = {1,2,3,4,5,6,7,8,9,0,255,254,253,252,251,250};
void sfc_rst() {
ahb_cache_disable();
sec_glb_enable(SEC_GLB_EMC);
}
void get_id_test()
{
uint8_t param[0x100] = {0};
iot_printf("[SFDP data]\n");
sfc_read_sfdp(param, 0x0, 0x4);
iot_printf("0x0: %x %x %x %x\n", param[0], param[1], param[2], param[3]);
sfc_read_sfdp(param, 0x10, 0x4);
iot_printf("0x0: %x %x %x %x\n", param[0], param[1], param[2], param[3]);
iot_printf("\n[SFC API TEST] start get id test\n");
//g_sfc_ctrl->get_dev_id(rdata);
iot_printf("Manufacturer ID:%x%x\r\n",rdata[1], rdata[0]);
sfc_qspi_get_id_mult(rdata, MOD_SFC_SERIAL);
iot_printf("Manufacturer ID:%x%x\r\n",rdata[1], rdata[0]);
sfc_qspi_get_id_mult(rdata, MOD_SFC_DUAL);
iot_printf("Manufacturer ID dual: %x%x\r\n",rdata[1], rdata[0]);
sfc_qspi_get_id_mult(rdata, MOD_SFC_QUAD);
iot_printf("Manufacturer ID quad: %x%x\r\n",rdata[1], rdata[0]);
iot_printf("[SFC API TEST] end get id test\n");
}
void get_sts_reg_test()
{
uint8_t data;
uint8_t reg = 0;
iot_printf("\n[SFC API TEST] start get status reg test\n");
g_sfc_ctrl->get_sts_reg(&data, reg);
iot_printf("get reg[%d]: %08x\n ", reg, data);
reg = 1;
g_sfc_ctrl->get_sts_reg(&data, reg);
iot_printf("get reg[%d]: %08x\n ", reg, data);
iot_printf("[SFC API TEST] end get status reg test\n");
}
void erase_test()
{
iot_printf("\n[SFC API TEST] start erase test\n");
g_sfc_ctrl->read(rdata, FLASH_TEST_OFFSET, sizeof(wdata), MOD_SFC_READ_SIG);
iot_printf("0x%8x: %02x %02x\n", FLASH_TEST_OFFSET, rdata[0], rdata[1]);
g_sfc_ctrl->erase_block(FLASH_TEST_OFFSET, MOD_SW_MODE_DIS);
g_sfc_ctrl->read(rdata, FLASH_TEST_OFFSET, sizeof(wdata), MOD_SFC_READ_SIG);
iot_printf("0x%8x: %02x %02x\n", FLASH_TEST_OFFSET, rdata[0], rdata[1]);
iot_printf("[SFC API TEST] end erase test\n");
}
void write_test()
{
iot_printf("\n[SFC API TEST] start write test\n");
g_sfc_ctrl->erase_sector(FLASH_TEST_OFFSET, MOD_SW_MODE_DIS);
wdata[10] = 0x5a;
rdata[10] = 0x0;
g_sfc_ctrl->write(wdata,FLASH_TEST_OFFSET, sizeof(wdata),
MOD_SFC_PROG_STAND, MOD_SW_MODE_DIS);
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,sizeof(wdata), MOD_SFC_READ_SIG);
if (wdata[10] != rdata[10]) {
iot_printf("qspi write, qspi read error\n");
} else {
iot_printf("qspi write, qspi read success\n");
}
iot_printf("quad write test\n");
g_sfc_ctrl->erase_sector(FLASH_TEST_OFFSET, MOD_SW_MODE_DIS);
wdata[10] = 0xa5;
rdata[10] = 0x0;
g_sfc_ctrl->write(wdata,FLASH_TEST_OFFSET,sizeof(wdata),
MOD_SFC_PROG_QUAD, MOD_SW_MODE_DIS);
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,sizeof(wdata), MOD_SFC_READ_SIG);
if (wdata[10] != rdata[10]) {
iot_printf("quad write, qspi read error\n");
} else {
iot_printf("quad write, qspi read success\n");
}
iot_printf("[SFC API TEST] end write test\n");
}
void read_test()
{
iot_printf("\n[SFC API TEST] start write test\n");
iot_printf("read test\n");
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,
sizeof(wdata), MOD_SFC_READ_SIG);
iot_printf("sig: rdata[10] = %02x\n", rdata[10]);
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,
sizeof(wdata), MOD_SFC_READ_HIGH_SPD);
iot_printf("high speed: rdata[10] = %02x\n", rdata[10]);
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,
sizeof(wdata), MOD_SFC_READ_DUAL_FAST);
iot_printf("dual fast: rdata[10] = %02x\n", rdata[10]);
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,
sizeof(wdata), MOD_SFC_READ_QUAD_FAST);
iot_printf("quad fast: rdata[10] = %02x\n", rdata[10]);
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,
sizeof(wdata), MOD_SFC_READ_DUAL_IO_FAST);
iot_printf("dual fast: rdata[10] = %02x\n", rdata[10]);
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,
sizeof(wdata), MOD_SFC_READ_QUAD_IO_FAST);
iot_printf("quad io fast: rdata[10] = %02x\n", rdata[10]);
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,
sizeof(wdata), MOD_SFC_READ_QUAD_IO_WORD_FAST);
iot_printf("quad io word fast: rdata[10] = %02x\n", rdata[10]);
iot_printf("[SFC API TEST] end read test\n");
}
uint8_t g_dump_data[0x1000] = {0};
void static flash_dump_fw_data(uint32_t addr, uint32_t size)
{
uint32_t i = 0;
uint32_t j = 0;
uint32_t n = 0;
n = size / 0x1000;
iot_printf("addr: %08x, size: %08x, n: %08x\n", addr, size, n);
for(i = 0; i < n; i++) {
flash_read(g_dump_data, addr, 0x1000, MOD_SFC_READ_QUAD_IO_FAST);
iot_printf("\naddr: 0x%08x:\n", addr);
for(j = 0; j < 0x1000; j++) {
if (j%4 == 0) {
iot_printf(" ");
if (j%16 == 0) {
iot_printf("\n");
}
}
iot_printf("%02x", g_dump_data[j]);
}
addr += 0x1000;
iot_printf("\n");
}
iot_printf("end...........\n");
}
void flash_1m_kunlun_dump()
{
#define F1_SP_ADDR 0x00000000
#define F1_SP_SIZE 0x8000
#define F1_SBL_ADDR 0x00008000
#define F1_SBL_SIZE 0x8000
#define F1_PARAM_ADDR 0X00010000
#define F1_PARAM_SIZE 0X1000
#define F1_OEM_ADDR 0x00011000
#define F1_OEM_SIZE 0x1000
#define F1_PIB_ADDR_1 0x00012000
#define F1_PIB_SIZE_1 0x7000
#define F1_PIB_ADDR_2 0x00019000
#define F1_PIB_SIZE_2 0x7000
#define F1_FW_ADDR_1 0x00020000
#define F1_FW_SIZE_1 0x68000
#define F1_RSV_ADDR 0x00088000
#define F1_RSC_SIZE 0x8000
#define F1_FW_ADDR_2 0x00090000
#define F1_FW_SIZE_2 0x68000
#define F1_CUS_ADDR 0x000F8000
#define F1_CUS_SIZE 0x7000
#define F1_CAL_ADDR 0x000FF000
#define F1_CAL_SIZE 0x1000
iot_printf("####start to dump 1m flash data####\n");
iot_printf("\nsp addr 0x%08x, size 0x%08x\n", F1_SP_ADDR, F1_SP_SIZE);
flash_dump_fw_data(F1_SP_ADDR, F1_SP_SIZE);
iot_printf("\nsbl addr 0x%08x, size 0x%08x\n", F1_SBL_ADDR, F1_SBL_SIZE);
flash_dump_fw_data(F1_SBL_ADDR, F1_SBL_SIZE);
iot_printf("\nparam addr 0x%08x, size 0x%08x\n", \
F1_PARAM_ADDR, F1_PARAM_SIZE);
flash_dump_fw_data(F1_PARAM_ADDR, F1_PARAM_SIZE);
iot_printf("\noem addr 0x%08x, size 0x%08x\n", F1_OEM_ADDR, F1_OEM_SIZE);
flash_dump_fw_data(F1_OEM_ADDR, F1_OEM_SIZE);
iot_printf("\npib_1 addr 0x%08x, size 0x%08x\n", \
F1_PIB_ADDR_1, F1_PIB_SIZE_1);
flash_dump_fw_data(F1_PIB_ADDR_1, F1_PIB_SIZE_1);
iot_printf("\npib_2 addr 0x%08x, size 0x%08x\n", \
F1_PIB_ADDR_2, F1_PIB_SIZE_2);
flash_dump_fw_data(F1_PIB_ADDR_2, F1_PIB_SIZE_2);
iot_printf("\nfw_1 addr 0x%08x, size 0x%08x\n", F1_FW_ADDR_1, F1_FW_SIZE_1);
flash_dump_fw_data(F1_FW_ADDR_1, F1_FW_SIZE_1);
iot_printf("\nrsv addr 0x%08x, size 0x%08x\n", F1_RSV_ADDR, F1_RSC_SIZE);
flash_dump_fw_data(F1_RSV_ADDR, F1_RSC_SIZE);
iot_printf("\nfw_2 addr 0x%08x, size 0x%08x\n", F1_FW_ADDR_2, F1_FW_SIZE_2);
flash_dump_fw_data(F1_FW_ADDR_2, F1_FW_SIZE_2);
iot_printf("\ncus addr 0x%08x, size 0x%08x\n", F1_CUS_ADDR, F1_CUS_SIZE);
flash_dump_fw_data(F1_CUS_ADDR, F1_CUS_SIZE);
iot_printf("\ncal addr 0x%08x, size 0x%08x\n", F1_CAL_ADDR, F1_CAL_SIZE);
flash_dump_fw_data(F1_CAL_ADDR, F1_CAL_SIZE);
iot_printf("####end to dump flash data####\n");
}
void flash_2m_kunlun_dump()
{
#define F2_SP_ADDR 0x00000000
#define F2_SP_SIZE 0x8000
#define F2_SBL_ADDR_1 0x00008000
#define F2_SBL_SIZE_1 0x8000
#define F2_PARAM_ADDR_1 0X00010000
#define F2_PARAM_SIZE_1 0X1000
#define F2_OEM_ADDR 0x00011000
#define F2_OEM_SIZE 0x1000
#define F2_PIB_ADDR_1 0x00012000
#define F2_PIB_SIZE_1 0x7000
#define F2_PIB_ADDR_2 0x00019000
#define F2_PIB_SIZE_2 0x7000
#define F2_FW_ADDR_1 0x00020000
#define F2_FW_SIZE_1 0xE0000
#define F2_FW_ADDR_2 0x00100000
#define F2_FW_SIZE_2 0xE0000
#define F2_SP_FW_ADDR_1 0x001E0000
#define F2_SP_FW_SIZE_1 0x8000
#define F2_SP_FW_ADDR_2 0x001E8000
#define F2_SP_FW_SIZE_2 0x8000
#define F2_SBL_ADDR_2 0x001F0000
#define F2_SBL_SIZE_2 0x8000
#define F2_PARAM_ADDR_2 0X001F8000
#define F2_PARAM_SIZE_2 0X1000
#define F2_CUS_ADDR 0x001F9000
#define F2_CUS_SIZE 0x6000
#define F2_CAL_ADDR 0x001FF000
#define F2_CAL_SIZE 0x1000
iot_printf("####start to dump 2m flash data####\n");
iot_printf("\nsp addr 0x%08x, size 0x%08x\n", F2_SP_ADDR, F2_SP_SIZE);
flash_dump_fw_data(F2_SP_ADDR, F2_SP_SIZE);
iot_printf("\nsbl_1 addr 0x%08x, size 0x%08x\n", \
F2_SBL_ADDR_1, F2_SBL_SIZE_1);
flash_dump_fw_data(F2_SBL_ADDR_1, F2_SBL_SIZE_1);
iot_printf("\nparam_1 addr 0x%08x, size 0x%08x\n", \
F2_PARAM_ADDR_1, F2_PARAM_SIZE_1);
flash_dump_fw_data(F2_PARAM_ADDR_1, F2_PARAM_SIZE_1);
iot_printf("\noem addr 0x%08x, size 0x%08x\n", F2_OEM_ADDR, F2_OEM_SIZE);
flash_dump_fw_data(F2_OEM_ADDR, F2_OEM_SIZE);
iot_printf("\npib_1 addr 0x%08x, size 0x%08x\n", \
F2_PIB_ADDR_1, F2_PIB_SIZE_1);
flash_dump_fw_data(F2_PIB_ADDR_1, F2_PIB_SIZE_1);
iot_printf("\npib_2 addr 0x%08x, size 0x%08x\n", \
F2_PIB_ADDR_2, F2_PIB_SIZE_2);
flash_dump_fw_data(F2_PIB_ADDR_2, F2_PIB_SIZE_2);
iot_printf("\nfw_1 addr 0x%08x, size 0x%08x\n", F2_FW_ADDR_1, F2_FW_SIZE_1);
flash_dump_fw_data(F2_FW_ADDR_1, F2_FW_SIZE_1);
iot_printf("\nfw_2 addr 0x%08x, size 0x%08x\n", F2_FW_ADDR_2, F2_FW_SIZE_2);
flash_dump_fw_data(F2_FW_ADDR_2, F2_FW_SIZE_2);
iot_printf("\nsp_fw_1 addr 0x%08x, size 0x%08x\n", \
F2_SP_FW_ADDR_1, F2_SP_FW_SIZE_1);
flash_dump_fw_data(F2_SP_FW_ADDR_1, F2_SP_FW_SIZE_1);
iot_printf("\nsp_fw_2 addr 0x%08x, size 0x%08x\n", \
F2_SP_FW_ADDR_2, F2_SP_FW_SIZE_2);
flash_dump_fw_data(F2_SP_FW_ADDR_2, F2_SP_FW_SIZE_2);
iot_printf("\nsbl_2 addr 0x%08x, size 0x%08x\n", \
F2_SBL_ADDR_2, F2_SBL_SIZE_2);
flash_dump_fw_data(F2_SBL_ADDR_2, F2_SBL_SIZE_2);
iot_printf("\nparam_2 addr 0x%08x, size 0x%08x\n", \
F2_PARAM_ADDR_2, F2_PARAM_SIZE_2);
flash_dump_fw_data(F2_PARAM_ADDR_2, F2_PARAM_SIZE_2);
iot_printf("\ncus addr 0x%08x, size 0x%08x\n", F2_CUS_ADDR, F2_CUS_SIZE);
flash_dump_fw_data(F2_CUS_ADDR, F2_CUS_SIZE);
iot_printf("\ncal addr 0x%08x, size 0x%08x\n", F2_CAL_ADDR, F2_CAL_SIZE);
flash_dump_fw_data(F2_CAL_ADDR, F2_CAL_SIZE);
iot_printf("####end to dump flash data####\n");
}
void flash_4m_kunlun_dump()
{
/* The common parts */
#define F4_SP_ADDR (0x00000000)
#define F4_SP_SIZE (0x00008000) /* 32K */
#define F4_SBL_ADDR (0x00008000)
#define F4_SBL_SIZE (0x00008000) /* 32K */
#define F4_PARAM_ADDR (0x00010000)
#define F4_PARAM_SIZE (0x00001000) /* 4K */
#define F4_OEM_ADDR (0x00011000)
#define F4_OEM_SIZE (0x00001000) /* 4K */
#define F4_PIB1_ADDR (0x00012000)
#define F4_PIB1_SIZE (0x00007000) /* 28K */
#define F4_PIB2_ADDR (0x00019000)
#define F4_PIB2_SIZE (0x00007000) /* 28K */
/* The special parts with psram */
#define F4_PSRAM_RUN_ADDR (0x00020000)
#define F4_PSRAM_RUN_SIZE (0x00160000) /* 1408K */
#define F4_PSRAM_FW1_ADDR (0x00180000)
#define F4_PSRAM_FW1_SIZE (0x000B0000) /* 704K */
#define F4_PSRAM_FW2_ADDR (0x00230000)
#define F4_PSRAM_FW2_SIZE (0x000B0000) /* 704K */
#define F4_SP_FW1_ADDR (0x002E0000)
#define F4_SP_FW1_SIZE (0x00010000) /* 64K */
#define F4_SP_FW2_ADDR (0x002F0000)
#define F4_SP_FW2_SIZE (0x00010000) /* 64K */
#define F4_CUS_ADDR (0x00300000)
#define F4_CUS_SIZE (0x000FF000) /* 1020K */
#define F4_CAL_ADDR (0x003FF000)
#define F4_CAL_SIZE (0x00001000) /* 4K */
iot_printf("####start to dump 4m flash data####\n");
iot_printf("\nsp addr 0x%08x, size 0x%08x\n", F4_SP_ADDR, F4_SP_SIZE);
flash_dump_fw_data(F4_SP_ADDR, F4_SP_SIZE);
iot_printf("\nsbl_1 addr 0x%08x, size 0x%08x\n", F4_SBL_ADDR, F4_SBL_SIZE);
flash_dump_fw_data(F4_SBL_ADDR, F4_SBL_SIZE);
iot_printf("\nparam_1 addr 0x%08x, size 0x%08x\n", \
F4_PARAM_ADDR, F4_PARAM_SIZE);
flash_dump_fw_data(F4_PARAM_ADDR, F4_PARAM_SIZE);
iot_printf("\noem addr 0x%08x, size 0x%08x\n", F4_OEM_ADDR, F4_OEM_SIZE);
flash_dump_fw_data(F4_OEM_ADDR, F4_OEM_SIZE);
iot_printf("\npib_1 addr 0x%08x, size 0x%08x\n", F4_PIB1_ADDR, F4_PIB1_SIZE);
flash_dump_fw_data(F4_PIB1_ADDR, F4_PIB1_SIZE);
iot_printf("\npib_2 addr 0x%08x, size 0x%08x\n", F4_PIB2_ADDR, F4_PIB2_SIZE);
flash_dump_fw_data(F4_PIB2_ADDR, F4_PIB2_SIZE);
iot_printf("\nrun addr 0x%08x, size 0x%08x\n", \
F4_PSRAM_RUN_ADDR, F4_PSRAM_RUN_SIZE);
flash_dump_fw_data(F4_PSRAM_RUN_ADDR, F4_PSRAM_RUN_SIZE);
iot_printf("\nfw_1 addr 0x%08x, size 0x%08x\n", \
F4_PSRAM_FW1_ADDR, F4_PSRAM_FW1_SIZE);
flash_dump_fw_data(F4_PSRAM_FW1_ADDR, F4_PSRAM_FW1_SIZE);
iot_printf("\nfw_2 addr 0x%08x, size 0x%08x\n", \
F4_PSRAM_FW2_ADDR, F4_PSRAM_FW2_SIZE);
flash_dump_fw_data(F4_PSRAM_FW2_ADDR, F4_PSRAM_FW2_SIZE);
iot_printf("\ncus addr 0x%08x, size 0x%08x\n", F4_CUS_ADDR, F4_CUS_SIZE);
flash_dump_fw_data(F4_CUS_ADDR, F4_CUS_SIZE);
iot_printf("\nsp_fw_1 addr 0x%08x, size 0x%08x\n", \
F4_SP_FW1_ADDR, F4_SP_FW1_SIZE);
flash_dump_fw_data(F4_SP_FW1_ADDR, F4_SP_FW1_SIZE);
iot_printf("\nsp_fw_2 addr 0x%08x, size 0x%08x\n", \
F4_SP_FW2_ADDR, F4_SP_FW2_SIZE);
flash_dump_fw_data(F4_SP_FW2_ADDR, F4_SP_FW2_SIZE);
iot_printf("\ncal addr 0x%08x, size 0x%08x\n", F4_CAL_ADDR, F4_CAL_SIZE);
flash_dump_fw_data(F4_CAL_ADDR, F4_CAL_SIZE);
iot_printf("####end to dump flash data####\n");
}
void flash_full_kunlun_dump(uint32_t flash_type)
{
iot_printf("\r\n>>>>flash full dump begin<<<<\r\n");
switch(flash_type) {
case FLASH_1M:
flash_1m_kunlun_dump();
break;
case FLASH_2M:
flash_2m_kunlun_dump();
break;
case FLASH_4M:
flash_4m_kunlun_dump();
break;
case FLASH_8M:
//flash_8m_kunlun_dump();
break;
case FLASH_16M:
//flash_16m_kunlun_dump();
break;
default:
break;
}
iot_printf("\r\n>>>>flash full dump over!<<<<\r\n");
}
void print_buf_data(uint8_t *buf)
{
uint32_t j = 0;
for(j = 0; j < 0x100; j++) {
if (j%4 == 0) {
iot_printf(" ");
if (j%16 == 0) {
iot_printf("\n");
}
}
iot_printf("%02x", buf[j]);
}
}
void flash_full_rw_test(uint32_t flash_type)
{
#define ONE_PAGE_SIZE 256
uint8_t r_buf[ONE_PAGE_SIZE] = {0};
uint8_t w_buf[ONE_PAGE_SIZE] = {0};
uint32_t flash_size = 0;
uint32_t i, j;
uint8_t addr_8b[4] = {0,0,0,0};
uint8_t flash_1m_count = 0;
uint32_t cur_addr = 0, start_addr = 0, end_addr = 0;
iot_printf("\r\n>>>>flash full read&write test begin<<<<\r\n");
switch(flash_type) {
case FLASH_1M:
flash_size = 0x00100000;
break;
case FLASH_2M:
flash_size = 0x00200000;
break;
case FLASH_4M:
flash_size = 0x00400000;
break;
case FLASH_8M:
//flash_size = 0x008000000;
break;
case FLASH_16M:
//flash_size = 0x01000000;
break;
default:
break;
}
flash_1m_count = flash_size / 0x00100000;
iot_printf("\n");
iot_printf("\r\nstart 1th read/write test! \n");
iot_printf("test data:0x5a, test mode:write(stand),read(sig) \n");
for(i = 0; i < flash_1m_count; i++) {
start_addr = 0x00100000 * i;
end_addr = (0x00100000 * (i +1)) - 1;
for(cur_addr = start_addr; cur_addr < end_addr; \
cur_addr += ONE_PAGE_SIZE) {
addr_8b[0] = (cur_addr >> 24) &0xff;
addr_8b[1] = (cur_addr >> 16) &0xff;
addr_8b[2] = (cur_addr >> 8) &0xff;
addr_8b[3] = addr_8b[0] ^ addr_8b[1] ^ addr_8b[2];
for(j = 0; j < ONE_PAGE_SIZE; j++) {
w_buf[j] = 0x5a ^ j ^ addr_8b[3];
}
g_sfc_ctrl->erase_page(cur_addr, MOD_SW_MODE_DIS);
g_sfc_ctrl->write(w_buf,cur_addr, sizeof(w_buf),
MOD_SFC_PROG_STAND, MOD_SW_MODE_DIS);
}
for(cur_addr = start_addr; cur_addr < end_addr; \
cur_addr += ONE_PAGE_SIZE) {
addr_8b[0] = (cur_addr >> 24) &0xff;
addr_8b[1] = (cur_addr >> 16) &0xff;
addr_8b[2] = (cur_addr >> 8) &0xff;
addr_8b[3] = addr_8b[0] ^ addr_8b[1] ^ addr_8b[2];
for(j = 0; j < ONE_PAGE_SIZE; j++) {
w_buf[j] = 0x5a ^ j ^ addr_8b[3];
}
g_sfc_ctrl->read(r_buf,cur_addr,sizeof(r_buf), MOD_SFC_READ_SIG);
for(j = 0; j < ONE_PAGE_SIZE; j++) {
if(r_buf[j] != w_buf[j]) {
iot_printf("\nflash read/write failed,addr is %d\r\n",\
cur_addr+j);
iot_printf("\nwrite buffer is:\n");
print_buf_data(w_buf);
iot_printf("\n");
iot_printf("\nread buffer is:\n");
print_buf_data(r_buf);
break;
}
}
if(r_buf[j] != w_buf[j])
break;
}
}
iot_printf("\r\nstart 2th read/write test! \r\n");
iot_printf("test data:0xa5, test mode:write(stand),read(sig) \r\n");
for(i = 0; i < flash_1m_count; i++) {
start_addr = 0x00100000 * i;
end_addr = (0x00100000 * (i +1)) - 1;
for(cur_addr = start_addr; cur_addr < end_addr; \
cur_addr += ONE_PAGE_SIZE) {
addr_8b[0] = (cur_addr >> 24) &0xff;
addr_8b[1] = (cur_addr >> 16) &0xff;
addr_8b[2] = (cur_addr >> 8) &0xff;
addr_8b[3] = addr_8b[0] ^ addr_8b[1] ^ addr_8b[2];
for(j = 0; j < ONE_PAGE_SIZE; j++) {
w_buf[j] = 0xa5 ^ j ^ addr_8b[3];
}
g_sfc_ctrl->erase_page(cur_addr, MOD_SW_MODE_DIS);
g_sfc_ctrl->write(w_buf,cur_addr, sizeof(w_buf),
MOD_SFC_PROG_STAND, MOD_SW_MODE_DIS);
}
for(cur_addr = start_addr; cur_addr < end_addr; \
cur_addr += ONE_PAGE_SIZE) {
addr_8b[0] = (cur_addr >> 24) &0xff;
addr_8b[1] = (cur_addr >> 16) &0xff;
addr_8b[2] = (cur_addr >> 8) &0xff;
addr_8b[3] = addr_8b[0] ^ addr_8b[1] ^ addr_8b[2];
for(j = 0; j < ONE_PAGE_SIZE; j++) {
w_buf[j] = 0xa5 ^ j ^ addr_8b[3];
}
g_sfc_ctrl->read(r_buf,cur_addr,sizeof(r_buf), MOD_SFC_READ_SIG);
for(j = 0; j < ONE_PAGE_SIZE; j++) {
if(r_buf[j] != w_buf[j]) {
iot_printf("\nflash read/write failed,addr is %d\r\n",\
cur_addr+j);
iot_printf("\nwrite buffer is:\n");
print_buf_data(w_buf);
iot_printf("\n");
iot_printf("\nread buffer is:\n");
print_buf_data(r_buf);
break;
}
}
if(r_buf[j] != w_buf[j])
break;
}
}
iot_printf("\r\nstart 3th read/write test! \r\n");
iot_printf("test data:0x5a, test mode:write(quad),read(quad_fast) \r\n");
for(i = 0; i < flash_1m_count; i++) {
start_addr = 0x00100000 * i;
end_addr = (0x00100000 * (i +1)) - 1;
for(cur_addr = start_addr; cur_addr < end_addr; \
cur_addr += ONE_PAGE_SIZE) {
addr_8b[0] = (cur_addr >> 24) &0xff;
addr_8b[1] = (cur_addr >> 16) &0xff;
addr_8b[2] = (cur_addr >> 8) &0xff;
addr_8b[3] = addr_8b[0] ^ addr_8b[1] ^ addr_8b[2];
for(j = 0; j < ONE_PAGE_SIZE; j++) {
w_buf[j] = 0x5a ^ j ^ addr_8b[3];
}
g_sfc_ctrl->erase_page(cur_addr, MOD_SW_MODE_DIS);
g_sfc_ctrl->write(w_buf,cur_addr, sizeof(w_buf),
MOD_SFC_PROG_QUAD, MOD_SW_MODE_DIS);
}
for(cur_addr = start_addr; cur_addr < end_addr; \
cur_addr += ONE_PAGE_SIZE) {
addr_8b[0] = (cur_addr >> 24) &0xff;
addr_8b[1] = (cur_addr >> 16) &0xff;
addr_8b[2] = (cur_addr >> 8) &0xff;
addr_8b[3] = addr_8b[0] ^ addr_8b[1] ^ addr_8b[2];
for(j = 0; j < ONE_PAGE_SIZE; j++) {
w_buf[j] = 0x5a ^ j ^ addr_8b[3];
}
g_sfc_ctrl->read(r_buf,cur_addr,sizeof(r_buf), \
MOD_SFC_READ_QUAD_FAST);
for(j = 0; j < ONE_PAGE_SIZE; j++) {
if(r_buf[j] != w_buf[j]) {
iot_printf("\nflash read/write failed,addr is %d\r\n",\
cur_addr+j);
iot_printf("\nwrite buffer is:\n");
print_buf_data(w_buf);
iot_printf("\n");
iot_printf("\nread buffer is:\n");
print_buf_data(r_buf);
break;
}
}
if(r_buf[j] != w_buf[j])
break;
}
}
iot_printf("\r\nstart 4th read/write test! \r\n");
iot_printf("test data:0xa5, test mode:write(quad),read(quad_fast) \r\n");
for(i = 0; i < flash_1m_count; i++) {
start_addr = 0x00100000 * i;
end_addr = (0x00100000 * (i +1)) - 1;
for(cur_addr = start_addr; cur_addr < end_addr; \
cur_addr += ONE_PAGE_SIZE) {
addr_8b[0] = (cur_addr >> 24) &0xff;
addr_8b[1] = (cur_addr >> 16) &0xff;
addr_8b[2] = (cur_addr >> 8) &0xff;
addr_8b[3] = addr_8b[0] ^ addr_8b[1] ^ addr_8b[2];
for(j = 0; j < ONE_PAGE_SIZE; j++) {
w_buf[j] = 0xa5 ^ j ^ addr_8b[3];
}
g_sfc_ctrl->erase_page(cur_addr, MOD_SW_MODE_DIS);
g_sfc_ctrl->write(w_buf,cur_addr, sizeof(w_buf),
MOD_SFC_PROG_QUAD, MOD_SW_MODE_DIS);
}
for(cur_addr = start_addr; cur_addr < end_addr; \
cur_addr += ONE_PAGE_SIZE) {
addr_8b[0] = (cur_addr >> 24) &0xff;
addr_8b[1] = (cur_addr >> 16) &0xff;
addr_8b[2] = (cur_addr >> 8) &0xff;
addr_8b[3] = addr_8b[0] ^ addr_8b[1] ^ addr_8b[2];
for(j = 0; j < ONE_PAGE_SIZE; j++) {
w_buf[j] = 0xa5 ^ j ^ addr_8b[3];
}
g_sfc_ctrl->read(r_buf,cur_addr,sizeof(r_buf), \
MOD_SFC_READ_QUAD_FAST);
for(j = 0; j < ONE_PAGE_SIZE; j++) {
if(r_buf[j] != w_buf[j]) {
iot_printf("\nflash read/write failed,addr is %d\r\n",\
cur_addr+j);
iot_printf("\nwrite buffer is:\n");
print_buf_data(w_buf);
iot_printf("\n");
iot_printf("\nread buffer is:\n");
print_buf_data(r_buf);
break;
}
}
if(r_buf[j] != w_buf[j])
break;
}
}
iot_printf("\r\n>>>>flash full read/write test over!<<<<\r\n");
}
void sfc_main() {
uint8_t wip_sts;
uint32_t loop = 0x10000;
int flash_id = 0x000000FF;
uint32_t flash_sn[4] = {0};
uint32_t flash_size = 0;
uint8_t sn_count = 0;
dbg_uart_init();
//dbg_uart_init_port(0, 1); // enable 3000000 baud
iot_printf("\r\n>>>>flash read&write test begin<<<<\r\n");
/* rst sfc */
//sfc_rst();
/* init sfc and flash */
flash_init(1);
/* config cpu and sfc clk */
iot_printf("set cpu clk 150m, sfc clk 37.5m\r\n");
/* cpu clk see CPU_FREQ */
clk_core_freq_set(CPU_FREQ_150M);
/* The basic frequency of SFC is 75m, 0 represents no frequency division */
sfc_clk_div_set(1);
do {
flash_get_chip_id(flash_sn);
flash_get_dev_id(&flash_id);
flash_size = flash_get_dev_size();
flash_id = (flash_id & 0x000000FF);
flash_id = (flash_size << 8 ) | flash_id;
iot_printf("flash id is %d \n",flash_id);
iot_printf("flash size is %dm \n",flash_size);
iot_printf("flash sn is ");
for(sn_count = 0; sn_count < 4; sn_count++) {
iot_printf("%08x",flash_sn[sn_count]);
}
iot_printf("\n");
iot_printf("quad: %d\n", g_sfc_ctrl->is_quad);
get_id_test();
get_sts_reg_test();
//erase_test();
g_sfc_ctrl->query_wip_sts(&wip_sts);
if(wip_sts == 1) {
iot_printf("FLASH is WORK IN STATUS\r\n");
} else{
iot_printf("erase sector test\n");
g_sfc_ctrl->erase_sector(FLASH_TEST_OFFSET, MOD_SW_MODE_DIS);
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,
sizeof(wdata), MOD_SFC_READ_SIG);
if (rdata[0] != 0xff) {
iot_printf("erase sector failed\n");
} else {
iot_printf("erase sector success\n\n");
}
write_test();
g_sfc_ctrl->erase_sector(FLASH_TEST_OFFSET, MOD_SW_MODE_DIS);
g_sfc_ctrl->read(rdata,FLASH_TEST_OFFSET,
sizeof(wdata), MOD_SFC_READ_SIG);
read_test();
}
// flash_full_kunlun_dump(flash_size);
// flash_full_rw_test(flash_size);
loop = 0x10000;
while(loop--);
} while (0);
return;
}
#ifdef __GNUC__
int main(void) {
sfc_main();
return 0;
}
#endif // __GCC__
Reference in New Issue Copy Permalink