729 lines
27 KiB
C
729 lines
27 KiB
C
/****************************************************************************
|
|
|
|
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__
|
|
|