libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

[fal] using rt-thread raw API instead of std API

This commit is contained in:
Meco Man 2024-11-23 14:38:44 -05:00 committed by Rbb666
parent fbcda2a788
commit 13e0671f65
41 changed files with 621 additions and 652 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
bsp/allwinner/d1s/ports/fal/fal_norflash_sfud_port.c
View File

@ -16,9 +16,9 @@
#include <sfud.h>
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
extern sfud_flash sfud_norflash0;
struct fal_flash_dev nor_flash0 =
@ -30,13 +30,13 @@ struct fal_flash_dev nor_flash0 =
{init, read, write, erase}
};
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
sfud_read(&sfud_norflash0, nor_flash0.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
if (sfud_write(&sfud_norflash0, nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)
{
@ -46,7 +46,7 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
if (sfud_erase(&sfud_norflash0, nor_flash0.addr + offset, size) != SFUD_SUCCESS)
{

18
bsp/allwinner/d1s/ports/fal/fal_sd_sfud_port.c
View File

@ -19,9 +19,9 @@
rt_device_t sd_dev;
#define SECTOR_SIZE 512
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
struct fal_flash_dev sd_card = {
"sdcard0", /* name string match yml file */
@ -31,13 +31,13 @@ struct fal_flash_dev sd_card = {
{init, read, write, erase}
};
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
rt_size_t sector_pos;
rt_size_t sector_offset;
rt_size_t remain_size = size;
rt_size_t req_size;
rt_align(4) uint8_t buffer[SECTOR_SIZE];
rt_align(4) rt_uint8_t buffer[SECTOR_SIZE];
while (remain_size)
{
@ -54,13 +54,13 @@ static int read(long offset, uint8_t *buf, size_t size)
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
rt_size_t sector_pos;
rt_size_t sector_offset;
rt_size_t remain_size = size;
rt_size_t req_size;
rt_align(4) uint8_t buffer[SECTOR_SIZE];
rt_align(4) rt_uint8_t buffer[SECTOR_SIZE];
while (remain_size)
{
@ -79,7 +79,7 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
return size;
}
@ -93,7 +93,7 @@ static int init(void)
}
rt_device_open(sd_dev, RT_DEVICE_OFLAG_RDWR);
struct dev_sdmmc *dev_sdmmc = (struct dev_sdmmc *)sd_dev->user_data;
sd_card.len = (size_t)dev_sdmmc->geometry.bytes_per_sector * dev_sdmmc->geometry.sector_count;
sd_card.len = (rt_size_t)dev_sdmmc->geometry.bytes_per_sector * dev_sdmmc->geometry.sector_count;
sd_card.blk_size = dev_sdmmc->geometry.bytes_per_sector;
return 0;

24
bsp/hc32/ev_hc32f448_lqfp80/board/ports/fal/fal_flash_sfud_port.c
View File

@ -21,9 +21,9 @@
#endif
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static sfud_flash_t sfud_dev = NULL;
struct fal_flash_dev ext_nor_flash0 =
@ -51,19 +51,19 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
sfud_read(sfud_dev, ext_nor_flash0.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_write(sfud_dev, ext_nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)
{
return -1;
@ -72,10 +72,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_erase(sfud_dev, ext_nor_flash0.addr + offset, size) != SFUD_SUCCESS)
{
return -1;

24
bsp/hc32/ev_hc32f460_lqfp100_v2/board/ports/fal/fal_flash_sfud_port.c
View File

@ -20,9 +20,9 @@
#endif
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static sfud_flash_t sfud_dev = NULL;
struct fal_flash_dev ext_nor_flash0 =
@ -50,19 +50,19 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
sfud_read(sfud_dev, ext_nor_flash0.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_write(sfud_dev, ext_nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)
{
return -1;
@ -71,10 +71,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_erase(sfud_dev, ext_nor_flash0.addr + offset, size) != SFUD_SUCCESS)
{
return -1;

24
bsp/hc32/ev_hc32f4a0_lqfp176/board/ports/fal/fal_flash_sfud_port.c
View File

@ -20,9 +20,9 @@
#endif
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static sfud_flash_t sfud_dev = NULL;
struct fal_flash_dev ext_nor_flash0 =
@ -50,19 +50,19 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
sfud_read(sfud_dev, ext_nor_flash0.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_write(sfud_dev, ext_nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)
{
return -1;
@ -71,10 +71,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_erase(sfud_dev, ext_nor_flash0.addr + offset, size) != SFUD_SUCCESS)
{
return -1;

24
bsp/hc32/lckfb-hc32f4a0-lqfp100/board/ports/fal/fal_flash_sfud_port.c
View File

@ -20,9 +20,9 @@
#endif
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static sfud_flash_t sfud_dev = NULL;
struct fal_flash_dev ext_nor_flash0 =
@ -50,19 +50,19 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
sfud_read(sfud_dev, ext_nor_flash0.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_write(sfud_dev, ext_nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)
{
return -1;
@ -71,10 +71,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_erase(sfud_dev, ext_nor_flash0.addr + offset, size) != SFUD_SUCCESS)
{
return -1;

24
bsp/hc32/platform/fal/fal_flash_sfud_nor.c
View File

@ -25,9 +25,9 @@
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static sfud_flash_t sfud_dev = NULL;
@ -57,19 +57,19 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
sfud_read(sfud_dev, ext_nor_flash0.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_write(sfud_dev, ext_nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)
{
return -1;
@ -78,10 +78,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_erase(sfud_dev, ext_nor_flash0.addr + offset, size) != SFUD_SUCCESS)
{
return -1;

50
bsp/hpmicro/hpm5300evk/board/fal_flash_port.c
View File

@ -42,9 +42,9 @@
***************************************************************************************************/
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static xpi_nor_config_t s_flashcfg;
@ -85,9 +85,9 @@ FAL_RAMFUNC static int init(void)
{
s_flashcfg.device_info.clk_freq_for_non_read_cmd = 0U;
/* update the flash chip information */
uint32_t sector_size;
rt_uint32_t sector_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
uint32_t flash_size;
rt_uint32_t flash_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_total_size, &flash_size);
nor_flash0.blk_size = sector_size;
nor_flash0.len = flash_size;
@ -104,12 +104,12 @@ FAL_RAMFUNC static int init(void)
* @param size Size of data to be read
* @return actual read bytes
*/
FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
FAL_RAMFUNC static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t flash_addr = nor_flash0.addr + offset;
uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
uint32_t aligned_size = aligned_end - aligned_start;
rt_uint32_t flash_addr = nor_flash0.addr + offset;
rt_uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
rt_uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
rt_uint32_t aligned_size = aligned_end - aligned_start;
rt_base_t level = rt_hw_interrupt_disable();
l1c_dc_invalidate(aligned_start, aligned_size);
rt_hw_interrupt_enable(level);
@ -126,7 +126,7 @@ FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *buf, size_t size)
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const rt_uint32_t *buf, rt_size_t size)
{
hpm_stat_t status;
@ -151,21 +151,21 @@ FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *bu
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write(long offset, const uint8_t *buf, size_t size)
FAL_RAMFUNC static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t *src = NULL;
uint32_t buf_32[64];
uint32_t write_size;
size_t remaining_size = size;
rt_uint32_t *src = NULL;
rt_uint32_t buf_32[64];
rt_uint32_t write_size;
rt_size_t remaining_size = size;
int ret = (int)size;
uint32_t page_size;
rt_uint32_t page_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_page_size, &page_size);
uint32_t offset_in_page = offset % page_size;
rt_uint32_t offset_in_page = offset % page_size;
if (offset_in_page != 0)
{
uint32_t write_size_in_page = page_size - offset_in_page;
uint32_t write_page_size = MIN(write_size_in_page, size);
rt_uint32_t write_size_in_page = page_size - offset_in_page;
rt_uint32_t write_page_size = MIN(write_size_in_page, size);
(void) rt_memcpy(buf_32, buf, write_page_size);
write_size = write_unaligned_page_data(offset, buf_32, write_page_size);
if (write_size < 0)
@ -214,17 +214,17 @@ write_quit:
* @ret RT_EOK Erase operation is successful
* @retval -RT_ERROR Erase operation failed
*/
FAL_RAMFUNC static int erase(long offset, size_t size)
FAL_RAMFUNC static int erase(long offset, rt_size_t size)
{
uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
rt_uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
hpm_stat_t status;
int ret = (int)size;
uint32_t block_size;
uint32_t sector_size;
rt_uint32_t block_size;
rt_uint32_t sector_size;
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_block_size, &block_size);
uint32_t erase_unit;
rt_uint32_t erase_unit;
while (aligned_size > 0)
{
FAL_ENTER_CRITICAL();

50
bsp/hpmicro/hpm5301evklite/board/fal_flash_port.c
View File

@ -42,9 +42,9 @@
***************************************************************************************************/
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static xpi_nor_config_t s_flashcfg;
@ -85,9 +85,9 @@ FAL_RAMFUNC static int init(void)
{
s_flashcfg.device_info.clk_freq_for_non_read_cmd = 0U;
/* update the flash chip information */
uint32_t sector_size;
rt_uint32_t sector_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
uint32_t flash_size;
rt_uint32_t flash_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_total_size, &flash_size);
nor_flash0.blk_size = sector_size;
nor_flash0.len = flash_size;
@ -104,12 +104,12 @@ FAL_RAMFUNC static int init(void)
* @param size Size of data to be read
* @return actual read bytes
*/
FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
FAL_RAMFUNC static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t flash_addr = nor_flash0.addr + offset;
uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
uint32_t aligned_size = aligned_end - aligned_start;
rt_uint32_t flash_addr = nor_flash0.addr + offset;
rt_uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
rt_uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
rt_uint32_t aligned_size = aligned_end - aligned_start;
rt_base_t level = rt_hw_interrupt_disable();
l1c_dc_invalidate(aligned_start, aligned_size);
rt_hw_interrupt_enable(level);
@ -126,7 +126,7 @@ FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *buf, size_t size)
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const rt_uint32_t *buf, rt_size_t size)
{
hpm_stat_t status;
@ -151,21 +151,21 @@ FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *bu
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write(long offset, const uint8_t *buf, size_t size)
FAL_RAMFUNC static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t *src = NULL;
uint32_t buf_32[64];
uint32_t write_size;
size_t remaining_size = size;
rt_uint32_t *src = NULL;
rt_uint32_t buf_32[64];
rt_uint32_t write_size;
rt_size_t remaining_size = size;
int ret = (int)size;
uint32_t page_size;
rt_uint32_t page_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_page_size, &page_size);
uint32_t offset_in_page = offset % page_size;
rt_uint32_t offset_in_page = offset % page_size;
if (offset_in_page != 0)
{
uint32_t write_size_in_page = page_size - offset_in_page;
uint32_t write_page_size = MIN(write_size_in_page, size);
rt_uint32_t write_size_in_page = page_size - offset_in_page;
rt_uint32_t write_page_size = MIN(write_size_in_page, size);
(void) rt_memcpy(buf_32, buf, write_page_size);
write_size = write_unaligned_page_data(offset, buf_32, write_page_size);
if (write_size < 0)
@ -214,17 +214,17 @@ write_quit:
* @ret RT_EOK Erase operation is successful
* @retval -RT_ERROR Erase operation failed
*/
FAL_RAMFUNC static int erase(long offset, size_t size)
FAL_RAMFUNC static int erase(long offset, rt_size_t size)
{
uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
rt_uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
hpm_stat_t status;
int ret = (int)size;
uint32_t block_size;
uint32_t sector_size;
rt_uint32_t block_size;
rt_uint32_t sector_size;
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_block_size, &block_size);
uint32_t erase_unit;
rt_uint32_t erase_unit;
while (aligned_size > 0)
{
FAL_ENTER_CRITICAL();

50
bsp/hpmicro/hpm6200evk/board/fal_flash_port.c
View File

@ -42,9 +42,9 @@
***************************************************************************************************/
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static xpi_nor_config_t s_flashcfg;
@ -85,9 +85,9 @@ FAL_RAMFUNC static int init(void)
{
s_flashcfg.device_info.clk_freq_for_non_read_cmd = 0U;
/* update the flash chip information */
uint32_t sector_size;
rt_uint32_t sector_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
uint32_t flash_size;
rt_uint32_t flash_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_total_size, &flash_size);
nor_flash0.blk_size = sector_size;
nor_flash0.len = flash_size;
@ -104,12 +104,12 @@ FAL_RAMFUNC static int init(void)
* @param size Size of data to be read
* @return actual read bytes
*/
FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
FAL_RAMFUNC static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t flash_addr = nor_flash0.addr + offset;
uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
uint32_t aligned_size = aligned_end - aligned_start;
rt_uint32_t flash_addr = nor_flash0.addr + offset;
rt_uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
rt_uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
rt_uint32_t aligned_size = aligned_end - aligned_start;
rt_base_t level = rt_hw_interrupt_disable();
l1c_dc_invalidate(aligned_start, aligned_size);
rt_hw_interrupt_enable(level);
@ -126,7 +126,7 @@ FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *buf, size_t size)
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const rt_uint32_t *buf, rt_size_t size)
{
hpm_stat_t status;
@ -151,21 +151,21 @@ FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *bu
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write(long offset, const uint8_t *buf, size_t size)
FAL_RAMFUNC static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t *src = NULL;
uint32_t buf_32[64];
uint32_t write_size;
size_t remaining_size = size;
rt_uint32_t *src = NULL;
rt_uint32_t buf_32[64];
rt_uint32_t write_size;
rt_size_t remaining_size = size;
int ret = (int)size;
uint32_t page_size;
rt_uint32_t page_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_page_size, &page_size);
uint32_t offset_in_page = offset % page_size;
rt_uint32_t offset_in_page = offset % page_size;
if (offset_in_page != 0)
{
uint32_t write_size_in_page = page_size - offset_in_page;
uint32_t write_page_size = MIN(write_size_in_page, size);
rt_uint32_t write_size_in_page = page_size - offset_in_page;
rt_uint32_t write_page_size = MIN(write_size_in_page, size);
(void) rt_memcpy(buf_32, buf, write_page_size);
write_size = write_unaligned_page_data(offset, buf_32, write_page_size);
if (write_size < 0)
@ -214,17 +214,17 @@ write_quit:
* @ret RT_EOK Erase operation is successful
* @retval -RT_ERROR Erase operation failed
*/
FAL_RAMFUNC static int erase(long offset, size_t size)
FAL_RAMFUNC static int erase(long offset, rt_size_t size)
{
uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
rt_uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
hpm_stat_t status;
int ret = (int)size;
uint32_t block_size;
uint32_t sector_size;
rt_uint32_t block_size;
rt_uint32_t sector_size;
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_block_size, &block_size);
uint32_t erase_unit;
rt_uint32_t erase_unit;
while (aligned_size > 0)
{
FAL_ENTER_CRITICAL();

50
bsp/hpmicro/hpm6300evk/board/fal_flash_port.c
View File

@ -42,9 +42,9 @@
***************************************************************************************************/
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static xpi_nor_config_t s_flashcfg;
@ -85,9 +85,9 @@ FAL_RAMFUNC static int init(void)
{
s_flashcfg.device_info.clk_freq_for_non_read_cmd = 0U;
/* update the flash chip information */
uint32_t sector_size;
rt_uint32_t sector_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
uint32_t flash_size;
rt_uint32_t flash_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_total_size, &flash_size);
nor_flash0.blk_size = sector_size;
nor_flash0.len = flash_size;
@ -104,12 +104,12 @@ FAL_RAMFUNC static int init(void)
* @param size Size of data to be read
* @return actual read bytes
*/
FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
FAL_RAMFUNC static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t flash_addr = nor_flash0.addr + offset;
uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
uint32_t aligned_size = aligned_end - aligned_start;
rt_uint32_t flash_addr = nor_flash0.addr + offset;
rt_uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
rt_uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
rt_uint32_t aligned_size = aligned_end - aligned_start;
rt_base_t level = rt_hw_interrupt_disable();
l1c_dc_invalidate(aligned_start, aligned_size);
rt_hw_interrupt_enable(level);
@ -126,7 +126,7 @@ FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *buf, size_t size)
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const rt_uint32_t *buf, rt_size_t size)
{
hpm_stat_t status;
@ -151,21 +151,21 @@ FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *bu
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write(long offset, const uint8_t *buf, size_t size)
FAL_RAMFUNC static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t *src = NULL;
uint32_t buf_32[64];
uint32_t write_size;
size_t remaining_size = size;
rt_uint32_t *src = NULL;
rt_uint32_t buf_32[64];
rt_uint32_t write_size;
rt_size_t remaining_size = size;
int ret = (int)size;
uint32_t page_size;
rt_uint32_t page_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_page_size, &page_size);
uint32_t offset_in_page = offset % page_size;
rt_uint32_t offset_in_page = offset % page_size;
if (offset_in_page != 0)
{
uint32_t write_size_in_page = page_size - offset_in_page;
uint32_t write_page_size = MIN(write_size_in_page, size);
rt_uint32_t write_size_in_page = page_size - offset_in_page;
rt_uint32_t write_page_size = MIN(write_size_in_page, size);
(void) rt_memcpy(buf_32, buf, write_page_size);
write_size = write_unaligned_page_data(offset, buf_32, write_page_size);
if (write_size < 0)
@ -214,17 +214,17 @@ write_quit:
* @ret RT_EOK Erase operation is successful
* @retval -RT_ERROR Erase operation failed
*/
FAL_RAMFUNC static int erase(long offset, size_t size)
FAL_RAMFUNC static int erase(long offset, rt_size_t size)
{
uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
rt_uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
hpm_stat_t status;
int ret = (int)size;
uint32_t block_size;
uint32_t sector_size;
rt_uint32_t block_size;
rt_uint32_t sector_size;
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_block_size, &block_size);
uint32_t erase_unit;
rt_uint32_t erase_unit;
while (aligned_size > 0)
{
FAL_ENTER_CRITICAL();

50
bsp/hpmicro/hpm6750evk/board/fal_flash_port.c
View File

@ -56,9 +56,9 @@ static rt_base_t s_interrupt_level;
***************************************************************************************************/
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static xpi_nor_config_t s_flashcfg;
@ -98,9 +98,9 @@ FAL_RAMFUNC static int init(void)
else
{
/* update the flash chip information */
uint32_t sector_size;
rt_uint32_t sector_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
uint32_t flash_size;
rt_uint32_t flash_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_total_size, &flash_size);
nor_flash0.blk_size = sector_size;
nor_flash0.len = flash_size;
@ -117,12 +117,12 @@ FAL_RAMFUNC static int init(void)
* @param size Size of data to be read
* @return actual read bytes
*/
FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
FAL_RAMFUNC static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t flash_addr = nor_flash0.addr + offset;
uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
uint32_t aligned_size = aligned_end - aligned_start;
rt_uint32_t flash_addr = nor_flash0.addr + offset;
rt_uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
rt_uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
rt_uint32_t aligned_size = aligned_end - aligned_start;
rt_base_t level = rt_hw_interrupt_disable();
l1c_dc_invalidate(aligned_start, aligned_size);
rt_hw_interrupt_enable(level);
@ -139,7 +139,7 @@ FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *buf, size_t size)
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const rt_uint32_t *buf, rt_size_t size)
{
hpm_stat_t status;
@ -164,21 +164,21 @@ FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *bu
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write(long offset, const uint8_t *buf, size_t size)
FAL_RAMFUNC static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t *src = NULL;
uint32_t buf_32[64];
uint32_t write_size;
size_t remaining_size = size;
rt_uint32_t *src = NULL;
rt_uint32_t buf_32[64];
rt_uint32_t write_size;
rt_size_t remaining_size = size;
int ret = (int)size;
uint32_t page_size;
rt_uint32_t page_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_page_size, &page_size);
uint32_t offset_in_page = offset % page_size;
rt_uint32_t offset_in_page = offset % page_size;
if (offset_in_page != 0)
{
uint32_t write_size_in_page = page_size - offset_in_page;
uint32_t write_page_size = MIN(write_size_in_page, size);
rt_uint32_t write_size_in_page = page_size - offset_in_page;
rt_uint32_t write_page_size = MIN(write_size_in_page, size);
(void) rt_memcpy(buf_32, buf, write_page_size);
write_size = write_unaligned_page_data(offset, buf_32, write_page_size);
if (write_size < 0)
@ -227,17 +227,17 @@ write_quit:
* @ret RT_EOK Erase operation is successful
* @retval -RT_ERROR Erase operation failed
*/
FAL_RAMFUNC static int erase(long offset, size_t size)
FAL_RAMFUNC static int erase(long offset, rt_size_t size)
{
uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
rt_uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
hpm_stat_t status;
int ret = (int)size;
uint32_t block_size;
uint32_t sector_size;
rt_uint32_t block_size;
rt_uint32_t sector_size;
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_block_size, &block_size);
uint32_t erase_unit;
rt_uint32_t erase_unit;
while (aligned_size > 0)
{
FAL_ENTER_CRITICAL();

50
bsp/hpmicro/hpm6750evk2/board/fal_flash_port.c
View File

@ -57,9 +57,9 @@ static rt_base_t s_interrupt_level;
***************************************************************************************************/
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static xpi_nor_config_t s_flashcfg;
@ -99,9 +99,9 @@ FAL_RAMFUNC static int init(void)
else
{
/* update the flash chip information */
uint32_t sector_size;
rt_uint32_t sector_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
uint32_t flash_size;
rt_uint32_t flash_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_total_size, &flash_size);
nor_flash0.blk_size = sector_size;
nor_flash0.len = flash_size;
@ -118,12 +118,12 @@ FAL_RAMFUNC static int init(void)
* @param size Size of data to be read
* @return actual read bytes
*/
FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
FAL_RAMFUNC static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t flash_addr = nor_flash0.addr + offset;
uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
uint32_t aligned_size = aligned_end - aligned_start;
rt_uint32_t flash_addr = nor_flash0.addr + offset;
rt_uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
rt_uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
rt_uint32_t aligned_size = aligned_end - aligned_start;
rt_base_t level = rt_hw_interrupt_disable();
l1c_dc_invalidate(aligned_start, aligned_size);
rt_hw_interrupt_enable(level);
@ -140,7 +140,7 @@ FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *buf, size_t size)
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const rt_uint32_t *buf, rt_size_t size)
{
hpm_stat_t status;
@ -165,21 +165,21 @@ FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *bu
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write(long offset, const uint8_t *buf, size_t size)
FAL_RAMFUNC static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t *src = NULL;
uint32_t buf_32[64];
uint32_t write_size;
size_t remaining_size = size;
rt_uint32_t *src = NULL;
rt_uint32_t buf_32[64];
rt_uint32_t write_size;
rt_size_t remaining_size = size;
int ret = (int)size;
uint32_t page_size;
rt_uint32_t page_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_page_size, &page_size);
uint32_t offset_in_page = offset % page_size;
rt_uint32_t offset_in_page = offset % page_size;
if (offset_in_page != 0)
{
uint32_t write_size_in_page = page_size - offset_in_page;
uint32_t write_page_size = MIN(write_size_in_page, size);
rt_uint32_t write_size_in_page = page_size - offset_in_page;
rt_uint32_t write_page_size = MIN(write_size_in_page, size);
(void) rt_memcpy(buf_32, buf, write_page_size);
write_size = write_unaligned_page_data(offset, buf_32, write_page_size);
if (write_size < 0)
@ -228,17 +228,17 @@ write_quit:
* @ret RT_EOK Erase operation is successful
* @retval -RT_ERROR Erase operation failed
*/
FAL_RAMFUNC static int erase(long offset, size_t size)
FAL_RAMFUNC static int erase(long offset, rt_size_t size)
{
uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
rt_uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
hpm_stat_t status;
int ret = (int)size;
uint32_t block_size;
uint32_t sector_size;
rt_uint32_t block_size;
rt_uint32_t sector_size;
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_block_size, &block_size);
uint32_t erase_unit;
rt_uint32_t erase_unit;
while (aligned_size > 0)
{
FAL_ENTER_CRITICAL();

50
bsp/hpmicro/hpm6750evkmini/board/fal_flash_port.c
View File

@ -57,9 +57,9 @@ static rt_base_t s_interrupt_level;
***************************************************************************************************/
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static xpi_nor_config_t s_flashcfg;
@ -99,9 +99,9 @@ FAL_RAMFUNC static int init(void)
else
{
/* update the flash chip information */
uint32_t sector_size;
rt_uint32_t sector_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
uint32_t flash_size;
rt_uint32_t flash_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_total_size, &flash_size);
nor_flash0.blk_size = sector_size;
nor_flash0.len = flash_size;
@ -118,12 +118,12 @@ FAL_RAMFUNC static int init(void)
* @param size Size of data to be read
* @return actual read bytes
*/
FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
FAL_RAMFUNC static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t flash_addr = nor_flash0.addr + offset;
uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
uint32_t aligned_size = aligned_end - aligned_start;
rt_uint32_t flash_addr = nor_flash0.addr + offset;
rt_uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
rt_uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
rt_uint32_t aligned_size = aligned_end - aligned_start;
rt_base_t level = rt_hw_interrupt_disable();
l1c_dc_invalidate(aligned_start, aligned_size);
rt_hw_interrupt_enable(level);
@ -140,7 +140,7 @@ FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *buf, size_t size)
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const rt_uint32_t *buf, rt_size_t size)
{
hpm_stat_t status;
@ -165,21 +165,21 @@ FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *bu
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write(long offset, const uint8_t *buf, size_t size)
FAL_RAMFUNC static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t *src = NULL;
uint32_t buf_32[64];
uint32_t write_size;
size_t remaining_size = size;
rt_uint32_t *src = NULL;
rt_uint32_t buf_32[64];
rt_uint32_t write_size;
rt_size_t remaining_size = size;
int ret = (int)size;
uint32_t page_size;
rt_uint32_t page_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_page_size, &page_size);
uint32_t offset_in_page = offset % page_size;
rt_uint32_t offset_in_page = offset % page_size;
if (offset_in_page != 0)
{
uint32_t write_size_in_page = page_size - offset_in_page;
uint32_t write_page_size = MIN(write_size_in_page, size);
rt_uint32_t write_size_in_page = page_size - offset_in_page;
rt_uint32_t write_page_size = MIN(write_size_in_page, size);
(void) rt_memcpy(buf_32, buf, write_page_size);
write_size = write_unaligned_page_data(offset, buf_32, write_page_size);
if (write_size < 0)
@ -228,17 +228,17 @@ write_quit:
* @ret RT_EOK Erase operation is successful
* @retval -RT_ERROR Erase operation failed
*/
FAL_RAMFUNC static int erase(long offset, size_t size)
FAL_RAMFUNC static int erase(long offset, rt_size_t size)
{
uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
rt_uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
hpm_stat_t status;
int ret = (int)size;
uint32_t block_size;
uint32_t sector_size;
rt_uint32_t block_size;
rt_uint32_t sector_size;
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_block_size, &block_size);
uint32_t erase_unit;
rt_uint32_t erase_unit;
while (aligned_size > 0)
{
FAL_ENTER_CRITICAL();

50
bsp/hpmicro/hpm6800evk/board/fal_flash_port.c
View File

@ -57,9 +57,9 @@ static rt_base_t s_interrupt_level;
***************************************************************************************************/
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static xpi_nor_config_t s_flashcfg;
@ -99,9 +99,9 @@ FAL_RAMFUNC static int init(void)
else
{
/* update the flash chip information */
uint32_t sector_size;
rt_uint32_t sector_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
uint32_t flash_size;
rt_uint32_t flash_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_total_size, &flash_size);
nor_flash0.blk_size = sector_size;
nor_flash0.len = flash_size;
@ -118,12 +118,12 @@ FAL_RAMFUNC static int init(void)
* @param size Size of data to be read
* @return actual read bytes
*/
FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
FAL_RAMFUNC static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t flash_addr = nor_flash0.addr + offset;
uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
uint32_t aligned_size = aligned_end - aligned_start;
rt_uint32_t flash_addr = nor_flash0.addr + offset;
rt_uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
rt_uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
rt_uint32_t aligned_size = aligned_end - aligned_start;
rt_base_t level = rt_hw_interrupt_disable();
l1c_dc_invalidate(aligned_start, aligned_size);
rt_hw_interrupt_enable(level);
@ -140,7 +140,7 @@ FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *buf, size_t size)
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const rt_uint32_t *buf, rt_size_t size)
{
hpm_stat_t status;
@ -165,21 +165,21 @@ FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *bu
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write(long offset, const uint8_t *buf, size_t size)
FAL_RAMFUNC static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t *src = NULL;
uint32_t buf_32[64];
uint32_t write_size;
size_t remaining_size = size;
rt_uint32_t *src = NULL;
rt_uint32_t buf_32[64];
rt_uint32_t write_size;
rt_size_t remaining_size = size;
int ret = (int)size;
uint32_t page_size;
rt_uint32_t page_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_page_size, &page_size);
uint32_t offset_in_page = offset % page_size;
rt_uint32_t offset_in_page = offset % page_size;
if (offset_in_page != 0)
{
uint32_t write_size_in_page = page_size - offset_in_page;
uint32_t write_page_size = MIN(write_size_in_page, size);
rt_uint32_t write_size_in_page = page_size - offset_in_page;
rt_uint32_t write_page_size = MIN(write_size_in_page, size);
(void) rt_memcpy(buf_32, buf, write_page_size);
write_size = write_unaligned_page_data(offset, buf_32, write_page_size);
if (write_size < 0)
@ -228,17 +228,17 @@ write_quit:
* @ret RT_EOK Erase operation is successful
* @retval -RT_ERROR Erase operation failed
*/
FAL_RAMFUNC static int erase(long offset, size_t size)
FAL_RAMFUNC static int erase(long offset, rt_size_t size)
{
uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
rt_uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
hpm_stat_t status;
int ret = (int)size;
uint32_t block_size;
uint32_t sector_size;
rt_uint32_t block_size;
rt_uint32_t sector_size;
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_block_size, &block_size);
uint32_t erase_unit;
rt_uint32_t erase_unit;
while (aligned_size > 0)
{
FAL_ENTER_CRITICAL();

50
bsp/hpmicro/hpm6e00evk/board/fal_flash_port.c
View File

@ -57,9 +57,9 @@ static rt_base_t s_interrupt_level;
***************************************************************************************************/
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static xpi_nor_config_t s_flashcfg;
@ -99,9 +99,9 @@ FAL_RAMFUNC static int init(void)
else
{
/* update the flash chip information */
uint32_t sector_size;
rt_uint32_t sector_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
uint32_t flash_size;
rt_uint32_t flash_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_total_size, &flash_size);
nor_flash0.blk_size = sector_size;
nor_flash0.len = flash_size;
@ -118,12 +118,12 @@ FAL_RAMFUNC static int init(void)
* @param size Size of data to be read
* @return actual read bytes
*/
FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
FAL_RAMFUNC static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t flash_addr = nor_flash0.addr + offset;
uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
uint32_t aligned_size = aligned_end - aligned_start;
rt_uint32_t flash_addr = nor_flash0.addr + offset;
rt_uint32_t aligned_start = HPM_L1C_CACHELINE_ALIGN_DOWN(flash_addr);
rt_uint32_t aligned_end = HPM_L1C_CACHELINE_ALIGN_UP(flash_addr + size);
rt_uint32_t aligned_size = aligned_end - aligned_start;
rt_base_t level = rt_hw_interrupt_disable();
l1c_dc_invalidate(aligned_start, aligned_size);
rt_hw_interrupt_enable(level);
@ -140,7 +140,7 @@ FAL_RAMFUNC static int read(long offset, uint8_t *buf, size_t size)
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *buf, size_t size)
FAL_RAMFUNC static int write_unaligned_page_data(long offset, const rt_uint32_t *buf, rt_size_t size)
{
hpm_stat_t status;
@ -165,21 +165,21 @@ FAL_RAMFUNC static int write_unaligned_page_data(long offset, const uint32_t *bu
* @param size Size of data to be written
* @return actual size of written data or error code
*/
FAL_RAMFUNC static int write(long offset, const uint8_t *buf, size_t size)
FAL_RAMFUNC static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t *src = NULL;
uint32_t buf_32[64];
uint32_t write_size;
size_t remaining_size = size;
rt_uint32_t *src = NULL;
rt_uint32_t buf_32[64];
rt_uint32_t write_size;
rt_size_t remaining_size = size;
int ret = (int)size;
uint32_t page_size;
rt_uint32_t page_size;
rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_page_size, &page_size);
uint32_t offset_in_page = offset % page_size;
rt_uint32_t offset_in_page = offset % page_size;
if (offset_in_page != 0)
{
uint32_t write_size_in_page = page_size - offset_in_page;
uint32_t write_page_size = MIN(write_size_in_page, size);
rt_uint32_t write_size_in_page = page_size - offset_in_page;
rt_uint32_t write_page_size = MIN(write_size_in_page, size);
(void) rt_memcpy(buf_32, buf, write_page_size);
write_size = write_unaligned_page_data(offset, buf_32, write_page_size);
if (write_size < 0)
@ -228,17 +228,17 @@ write_quit:
* @ret RT_EOK Erase operation is successful
* @retval -RT_ERROR Erase operation failed
*/
FAL_RAMFUNC static int erase(long offset, size_t size)
FAL_RAMFUNC static int erase(long offset, rt_size_t size)
{
uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
rt_uint32_t aligned_size = (size + nor_flash0.blk_size - 1U) & ~(nor_flash0.blk_size - 1U);
hpm_stat_t status;
int ret = (int)size;
uint32_t block_size;
uint32_t sector_size;
rt_uint32_t block_size;
rt_uint32_t sector_size;
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_sector_size, &sector_size);
(void) rom_xpi_nor_get_property(BOARD_APP_XPI_NOR_XPI_BASE, &s_flashcfg, xpi_nor_property_block_size, &block_size);
uint32_t erase_unit;
rt_uint32_t erase_unit;
while (aligned_size > 0)
{
FAL_ENTER_CRITICAL();

18
bsp/nrf5x/libraries/drivers/drv_qspi_flash.c
View File

@ -35,8 +35,8 @@ static void configure_memory()
#define QSPI_STD_CMD_RSTEN 0x66
#define QSPI_STD_CMD_RST 0x99
uint8_t temporary = 0x40;
uint32_t err_code;
rt_uint8_t temporary = 0x40;
rt_uint32_t err_code;
nrf_qspi_cinstr_conf_t cinstr_cfg =
{
.opcode = QSPI_STD_CMD_RSTEN,
@ -75,7 +75,7 @@ static void configure_memory()
}
static int init(void)
{
uint32_t err_code;
rt_uint32_t err_code;
nrfx_qspi_config_t config = NRFX_QSPI_DEFAULT_CONFIG(BSP_QSPI_SCK_PIN, BSP_QSPI_CSN_PIN,
BSP_QSPI_IO0_PIN, BSP_QSPI_IO1_PIN, BSP_QSPI_IO2_PIN, BSP_QSPI_IO3_PIN);
@ -89,9 +89,9 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t err_code;
rt_uint32_t err_code;
m_finished = false;
err_code = nrfx_qspi_read(buf, size, offset);
WAIT_FOR_PERIPH();
@ -106,9 +106,9 @@ static int read(long offset, uint8_t *buf, size_t size)
}
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t err_code;
rt_uint32_t err_code;
m_finished = false;
err_code = nrfx_qspi_write(buf, size, offset);
WAIT_FOR_PERIPH();
@ -123,9 +123,9 @@ static int write(long offset, const uint8_t *buf, size_t size)
}
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
uint32_t err_code;
rt_uint32_t err_code;
m_finished = false;
err_code = nrfx_qspi_erase(NRF_QSPI_ERASE_LEN_64KB, offset);
WAIT_FOR_PERIPH();

12
bsp/nxp/lpc/lpc55sxx/lpc55s69_nxp_evk/board/ports/easyflash/ef_fal_port.c
View File

@ -36,7 +36,7 @@ static const struct fal_partition *part = NULL;
*
* @return result
*/
EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
EfErrCode ef_port_init(ef_env const **default_env, rt_size_t *default_env_size) {
EfErrCode result = EF_NO_ERR;
*default_env = default_env_set;
@ -60,10 +60,10 @@ EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
*
* @return result
*/
EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
EfErrCode ef_port_read(rt_uint32_t addr, rt_uint32_t *buf, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
fal_partition_read(part, addr, (uint8_t *)buf, size);
fal_partition_read(part, addr, (rt_uint8_t *)buf, size);
return result;
}
@ -78,7 +78,7 @@ EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
*
* @return result
*/
EfErrCode ef_port_erase(uint32_t addr, size_t size) {
EfErrCode ef_port_erase(rt_uint32_t addr, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
/* make sure the start address is a multiple of FLASH_ERASE_MIN_SIZE */
@ -102,10 +102,10 @@ EfErrCode ef_port_erase(uint32_t addr, size_t size) {
*
* @return result
*/
EfErrCode ef_port_write(uint32_t addr, const uint32_t *buf, size_t size) {
EfErrCode ef_port_write(rt_uint32_t addr, const rt_uint32_t *buf, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
if (fal_partition_write(part, addr, (uint8_t *)buf, size) < 0)
if (fal_partition_write(part, addr, (rt_uint8_t *)buf, size) < 0)
{
result = EF_WRITE_ERR;
}

4
bsp/nxp/lpc/lpc55sxx/lpc55s69_nxp_evk/board/ports/fal/fal_sample.c
View File

@ -26,7 +26,7 @@ static int fal_test(const char *partiton_name)
{
int ret;
int i, j, len;
uint8_t buf[BUF_SIZE];
rt_uint8_t buf[BUF_SIZE];
const struct fal_flash_dev *flash_dev = RT_NULL;
const struct fal_partition *partition = RT_NULL;
@ -241,7 +241,7 @@ static void easyflash_sample(void)
/* easyflash init */
if(easyflash_init() == EF_NO_ERR)
{
uint32_t i_boot_times = NULL;
rt_uint32_t i_boot_times = NULL;
char *c_old_boot_times, c_new_boot_times[11] = {0};
/* get the boot count number from Env */

24
bsp/stm32/stm32f407-atk-explorer/board/ports/fal/fal_spi_flash_sfud_port.c
View File

@ -16,9 +16,9 @@
#endif
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static sfud_flash_t sfud_dev = NULL;
struct fal_flash_dev w25q128 =
@ -46,19 +46,19 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
sfud_read(sfud_dev, w25q128.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_write(sfud_dev, w25q128.addr + offset, size, buf) != SFUD_SUCCESS)
{
return -1;
@ -67,10 +67,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_erase(sfud_dev, w25q128.addr + offset, size) != SFUD_SUCCESS)
{
return -1;

12
bsp/stm32/stm32f407-lckfb-skystar/board/ports/ef_fal_port.c
View File

@ -57,7 +57,7 @@ static const struct fal_partition *part = NULL;
*
* @return result
*/
EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
EfErrCode ef_port_init(ef_env const **default_env, rt_size_t *default_env_size) {
EfErrCode result = EF_NO_ERR;
*default_env = default_env_set;
@ -81,10 +81,10 @@ EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
*
* @return result
*/
EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
EfErrCode ef_port_read(rt_uint32_t addr, rt_uint32_t *buf, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
fal_partition_read(part, addr, (uint8_t *)buf, size);
fal_partition_read(part, addr, (rt_uint8_t *)buf, size);
return result;
}
@ -99,7 +99,7 @@ EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
*
* @return result
*/
EfErrCode ef_port_erase(uint32_t addr, size_t size) {
EfErrCode ef_port_erase(rt_uint32_t addr, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
/* make sure the start address is a multiple of FLASH_ERASE_MIN_SIZE */
@ -123,10 +123,10 @@ EfErrCode ef_port_erase(uint32_t addr, size_t size) {
*
* @return result
*/
EfErrCode ef_port_write(uint32_t addr, const uint32_t *buf, size_t size) {
EfErrCode ef_port_write(rt_uint32_t addr, const rt_uint32_t *buf, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
if (fal_partition_write(part, addr, (uint8_t *)buf, size) < 0)
if (fal_partition_write(part, addr, (rt_uint8_t *)buf, size) < 0)
{
result = EF_WRITE_ERR;
}

24
bsp/stm32/stm32f407-lckfb-skystar/board/ports/fal/fal_spi_flash_sfud_port.c
View File

@ -16,9 +16,9 @@
#endif
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static sfud_flash_t sfud_dev = NULL;
struct fal_flash_dev w25q128 =
@ -46,19 +46,19 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
sfud_read(sfud_dev, w25q128.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_write(sfud_dev, w25q128.addr + offset, size, buf) != SFUD_SUCCESS)
{
return -1;
@ -67,10 +67,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_erase(sfud_dev, w25q128.addr + offset, size) != SFUD_SUCCESS)
{
return -1;

12
bsp/stm32/stm32f407-rt-spark/board/ports/ef_fal_port.c
View File

@ -57,7 +57,7 @@ static const struct fal_partition *part = NULL;
*
* @return result
*/
EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
EfErrCode ef_port_init(ef_env const **default_env, rt_size_t *default_env_size) {
EfErrCode result = EF_NO_ERR;
*default_env = default_env_set;
@ -81,10 +81,10 @@ EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
*
* @return result
*/
EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
EfErrCode ef_port_read(rt_uint32_t addr, rt_uint32_t *buf, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
fal_partition_read(part, addr, (uint8_t *)buf, size);
fal_partition_read(part, addr, (rt_uint8_t *)buf, size);
return result;
}
@ -99,7 +99,7 @@ EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
*
* @return result
*/
EfErrCode ef_port_erase(uint32_t addr, size_t size) {
EfErrCode ef_port_erase(rt_uint32_t addr, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
/* make sure the start address is a multiple of FLASH_ERASE_MIN_SIZE */
@ -123,10 +123,10 @@ EfErrCode ef_port_erase(uint32_t addr, size_t size) {
*
* @return result
*/
EfErrCode ef_port_write(uint32_t addr, const uint32_t *buf, size_t size) {
EfErrCode ef_port_write(rt_uint32_t addr, const rt_uint32_t *buf, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
if (fal_partition_write(part, addr, (uint8_t *)buf, size) < 0)
if (fal_partition_write(part, addr, (rt_uint8_t *)buf, size) < 0)
{
result = EF_WRITE_ERR;
}

24
bsp/stm32/stm32f407-rt-spark/board/ports/fal/fal_spi_flash_sfud_port.c
View File

@ -16,9 +16,9 @@
#endif
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static sfud_flash_t sfud_dev = NULL;
struct fal_flash_dev w25q64 =
@ -46,19 +46,19 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
sfud_read(sfud_dev, w25q64.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_write(sfud_dev, w25q64.addr + offset, size, buf) != SFUD_SUCCESS)
{
return -1;
@ -67,10 +67,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_erase(sfud_dev, w25q64.addr + offset, size) != SFUD_SUCCESS)
{
return -1;

12
bsp/stm32/stm32h750-artpi/board/port/ef_fal_port.c
View File

@ -55,7 +55,7 @@ static const struct fal_partition *part = NULL;
*
* @return result
*/
EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
EfErrCode ef_port_init(ef_env const **default_env, rt_size_t *default_env_size) {
EfErrCode result = EF_NO_ERR;
*default_env = default_env_set;
@ -79,10 +79,10 @@ EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
*
* @return result
*/
EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
EfErrCode ef_port_read(rt_uint32_t addr, rt_uint32_t *buf, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
fal_partition_read(part, addr, (uint8_t *)buf, size);
fal_partition_read(part, addr, (rt_uint8_t *)buf, size);
return result;
}
@ -97,7 +97,7 @@ EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
*
* @return result
*/
EfErrCode ef_port_erase(uint32_t addr, size_t size) {
EfErrCode ef_port_erase(rt_uint32_t addr, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
/* make sure the start address is a multiple of FLASH_ERASE_MIN_SIZE */
@ -121,10 +121,10 @@ EfErrCode ef_port_erase(uint32_t addr, size_t size) {
*
* @return result
*/
EfErrCode ef_port_write(uint32_t addr, const uint32_t *buf, size_t size) {
EfErrCode ef_port_write(rt_uint32_t addr, const rt_uint32_t *buf, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
if (fal_partition_write(part, addr, (uint8_t *)buf, size) < 0)
if (fal_partition_write(part, addr, (rt_uint8_t *)buf, size) < 0)
{
result = EF_WRITE_ERR;
}

24
bsp/stm32/stm32h750-weact-ministm32h7xx/board/port/drv_qspi_flash.c
View File

@ -35,9 +35,9 @@
static sfud_flash_t sfud_dev = NULL;
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
struct fal_flash_dev nor_flash1 =
{
@ -73,19 +73,19 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
sfud_read(sfud_dev, nor_flash1.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_write(sfud_dev, nor_flash1.addr + offset, size, buf) != SFUD_SUCCESS)
{
return -1;
@ -94,10 +94,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_erase(sfud_dev, nor_flash1.addr + offset, size) != SFUD_SUCCESS)
{
return -1;

12
bsp/stm32/stm32l475-atk-pandora/board/ports/easyflash/ef_fal_port.c
View File

@ -37,7 +37,7 @@ static const struct fal_partition *part = NULL;
*
* @return result
*/
EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
EfErrCode ef_port_init(ef_env const **default_env, rt_size_t *default_env_size) {
EfErrCode result = EF_NO_ERR;
*default_env = default_env_set;
@ -61,10 +61,10 @@ EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
*
* @return result
*/
EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
EfErrCode ef_port_read(rt_uint32_t addr, rt_uint32_t *buf, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
fal_partition_read(part, addr, (uint8_t *)buf, size);
fal_partition_read(part, addr, (rt_uint8_t *)buf, size);
return result;
}
@ -79,7 +79,7 @@ EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
*
* @return result
*/
EfErrCode ef_port_erase(uint32_t addr, size_t size) {
EfErrCode ef_port_erase(rt_uint32_t addr, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
/* make sure the start address is a multiple of FLASH_ERASE_MIN_SIZE */
@ -103,10 +103,10 @@ EfErrCode ef_port_erase(uint32_t addr, size_t size) {
*
* @return result
*/
EfErrCode ef_port_write(uint32_t addr, const uint32_t *buf, size_t size) {
EfErrCode ef_port_write(rt_uint32_t addr, const rt_uint32_t *buf, rt_size_t size) {
EfErrCode result = EF_NO_ERR;
if (fal_partition_write(part, addr, (uint8_t *)buf, size) < 0)
if (fal_partition_write(part, addr, (rt_uint8_t *)buf, size) < 0)
{
result = EF_WRITE_ERR;
}

6
bsp/stm32/stm32l475-atk-pandora/board/ports/fal/fal_flash_sfud_port.c
View File

@ -29,14 +29,14 @@ static int fal_sfud_init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
sfud_read(&sfud_norflash0, nor_flash0.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
if (sfud_write(&sfud_norflash0, nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)
{
@ -46,7 +46,7 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
if (sfud_erase(&sfud_norflash0, nor_flash0.addr + offset, size) != SFUD_SUCCESS)
{

24
bsp/yichip/yc3122-pos/drivers/ports/fal_flash_yc3122_port.c
View File

@ -13,10 +13,10 @@
#include "yc_qspi.h"
#include "rtdbg.h"
#define FLASH_START_ADRESS ((uint32_t)0x1000000)
#define FLASH_SIZE ((uint32_t)4 * 1024 * 1024)
#define FLASH_BLOCK_SIZE ((uint32_t)512)
#define FLASH_END_ADDRESS ((uint32_t)(FLASH_START_ADRESS + FLASH_SIZE))
#define FLASH_START_ADRESS ((rt_uint32_t)0x1000000)
#define FLASH_SIZE ((rt_uint32_t)4 * 1024 * 1024)
#define FLASH_BLOCK_SIZE ((rt_uint32_t)512)
#define FLASH_END_ADDRESS ((rt_uint32_t)(FLASH_START_ADRESS + FLASH_SIZE))
#define FLASH_PAGE_NBPERBANK 256
#define FLASH_BANK_NUMBER 2
#define FLASH_PAGE_SIZE 256
@ -26,9 +26,9 @@
#else
#define YC3122_FLASH_DEBUG(...)
#endif
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
uint32_t addr = yc3122_onchip_flash.addr + offset;
rt_uint32_t addr = yc3122_onchip_flash.addr + offset;
if ((addr + size) > FLASH_END_ADDRESS)
{
@ -40,9 +40,9 @@ static int read(long offset, uint8_t *buf, size_t size)
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
uint32_t addr = yc3122_onchip_flash.addr + offset;
rt_uint32_t addr = yc3122_onchip_flash.addr + offset;
if ((addr + size) > FLASH_END_ADDRESS)
{
@ -54,14 +54,14 @@ static int write(long offset, const uint8_t *buf, size_t size)
return -1;
}
YC3122_FLASH_DEBUG("w_ addr:0x%x,size:0x%x\n", addr, size);
qspi_flash_write(addr, (uint8_t *)buf, size);
qspi_flash_write(addr, (rt_uint8_t *)buf, size);
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
uint32_t addr = yc3122_onchip_flash.addr + offset;
rt_uint32_t addr = yc3122_onchip_flash.addr + offset;
if ((addr + size) > FLASH_END_ADDRESS || addr % 0x100 != 0)
{
YC3122_FLASH_DEBUG("ERROR: erase outrange flash size! addr is (0x%p)\n", (void *)(addr + size));
@ -72,7 +72,7 @@ static int erase(long offset, size_t size)
{
YC3122_FLASH_DEBUG("ERROR: erase addr is not page alignment\n");
}
for (uint32_t i = 0; i < size; i += 256)
for (rt_uint32_t i = 0; i < size; i += 256)
qspi_flash_pageerase(addr + i);
return size;
}

10
components/fal/Kconfig
View File

@ -5,14 +5,10 @@ menuconfig RT_USING_FAL
default n
if RT_USING_FAL
config FAL_DEBUG_CONFIG
config FAL_USING_DEBUG
bool "Enable debug log output"
default y
config FAL_DEBUG
int
default 1 if FAL_DEBUG_CONFIG
default 0
default y if RT_USING_DEBUG
default n
config FAL_PART_HAS_TABLE_CFG
bool "FAL partition table config has defined on 'fal_cfg.h'"

10
components/fal/docs/fal_api.md
View File

@ -25,7 +25,7 @@ const struct fal_partition *fal_partition_find(const char *name)
## 获取分区表
```C
const struct fal_partition *fal_get_partition_table(size_t *len)
const struct fal_partition *fal_get_partition_table(rt_size_t *len)
```
| 参数 | 描述 |
@ -38,7 +38,7 @@ const struct fal_partition *fal_get_partition_table(size_t *len)
FAL 初始化时会自动装载默认分区表。使用该设置将临时修改分区表，重启后会 **丢失** 该设置
```C
void fal_set_partition_table_temp(struct fal_partition *table, size_t len)
void fal_set_partition_table_temp(struct fal_partition *table, rt_size_t len)
```
| 参数 | 描述 |
@ -49,7 +49,7 @@ void fal_set_partition_table_temp(struct fal_partition *table, size_t len)
## 从分区读取数据
```C
int fal_partition_read(const struct fal_partition *part, uint32_t addr, uint8_t *buf, size_t size)
int fal_partition_read(const struct fal_partition *part, rt_uint32_t addr, rt_uint8_t *buf, rt_size_t size)
```
| 参数 | 描述 |
@ -63,7 +63,7 @@ int fal_partition_read(const struct fal_partition *part, uint32_t addr, uint8_t
## 往分区写入数据
```C
int fal_partition_write(const struct fal_partition *part, uint32_t addr, const uint8_t *buf, size_t size)
int fal_partition_write(const struct fal_partition *part, rt_uint32_t addr, const rt_uint8_t *buf, rt_size_t size)
```
| 参数 | 描述 |
@ -77,7 +77,7 @@ int fal_partition_write(const struct fal_partition *part, uint32_t addr, const u
## 擦除分区数据
```C
int fal_partition_erase(const struct fal_partition *part, uint32_t addr, size_t size)
int fal_partition_erase(const struct fal_partition *part, rt_uint32_t addr, rt_size_t size)
```
| 参数 | 描述 |

10
components/fal/docs/fal_api_en.md
View File

@ -25,7 +25,7 @@ const struct fal_partition *fal_partition_find(const char *name)
## Get the partition table
```C
const struct fal_partition *fal_get_partition_table(size_t *len)
const struct fal_partition *fal_get_partition_table(rt_size_t *len)
```
| Parameters | Description |
@ -38,7 +38,7 @@ const struct fal_partition *fal_get_partition_table(size_t *len)
The default partition table will be automatically loaded when FAL is initialized. Using this setting will temporarily modify the partition table and will **lost** this setting after restarting
```C
void fal_set_partition_table_temp(struct fal_partition *table, size_t len)
void fal_set_partition_table_temp(struct fal_partition *table, rt_size_t len)
```
| Parameters | Description |
@ -49,7 +49,7 @@ void fal_set_partition_table_temp(struct fal_partition *table, size_t len)
## Read data from partition
```C
int fal_partition_read(const struct fal_partition *part, uint32_t addr, uint8_t *buf, size_t size)
int fal_partition_read(const struct fal_partition *part, rt_uint32_t addr, rt_uint8_t *buf, rt_size_t size)
```
| Parameters | Description |
@ -63,7 +63,7 @@ int fal_partition_read(const struct fal_partition *part, uint32_t addr, uint8_t
## Write data to partition
```C
int fal_partition_write(const struct fal_partition *part, uint32_t addr, const uint8_t *buf, size_t size)
int fal_partition_write(const struct fal_partition *part, rt_uint32_t addr, const rt_uint8_t *buf, rt_size_t size)
```
| Parameters | Description |
@ -77,7 +77,7 @@ int fal_partition_write(const struct fal_partition *part, uint32_t addr, const u
## Erase partition data
```C
int fal_partition_erase(const struct fal_partition *part, uint32_t addr, size_t size)
int fal_partition_erase(const struct fal_partition *part, rt_uint32_t addr, rt_size_t size)
```
| Parameters | Description |

10
components/fal/inc/fal.h
View File

@ -56,7 +56,7 @@ const struct fal_partition *fal_partition_find(const char *name);
*
* @return partition table
*/
const struct fal_partition *fal_get_partition_table(size_t *len);
const struct fal_partition *fal_get_partition_table(rt_size_t *len);
/**
* set partition table temporarily
@ -65,7 +65,7 @@ const struct fal_partition *fal_get_partition_table(size_t *len);
* @param table partition table
* @param len partition table length
*/
void fal_set_partition_table_temp(struct fal_partition *table, size_t len);
void fal_set_partition_table_temp(struct fal_partition *table, rt_size_t len);
/**
* read data from partition
@ -78,7 +78,7 @@ void fal_set_partition_table_temp(struct fal_partition *table, size_t len);
* @return >= 0: successful read data size
* -1: error
*/
int fal_partition_read(const struct fal_partition *part, uint32_t addr, uint8_t *buf, size_t size);
int fal_partition_read(const struct fal_partition *part, rt_uint32_t addr, rt_uint8_t *buf, rt_size_t size);
/**
* write data to partition
@ -91,7 +91,7 @@ int fal_partition_read(const struct fal_partition *part, uint32_t addr, uint8_t
* @return >= 0: successful write data size
* -1: error
*/
int fal_partition_write(const struct fal_partition *part, uint32_t addr, const uint8_t *buf, size_t size);
int fal_partition_write(const struct fal_partition *part, rt_uint32_t addr, const rt_uint8_t *buf, rt_size_t size);
/**
* erase partition data
@ -103,7 +103,7 @@ int fal_partition_write(const struct fal_partition *part, uint32_t addr, const u
* @return >= 0: successful erased data size
* -1: error
*/
int fal_partition_erase(const struct fal_partition *part, uint32_t addr, size_t size);
int fal_partition_erase(const struct fal_partition *part, rt_uint32_t addr, rt_size_t size);
/**
* erase partition all data

79
components/fal/inc/fal_def.h
View File

@ -11,63 +11,8 @@
#ifndef _FAL_DEF_H_
#define _FAL_DEF_H_
#include <stdint.h>
#include <stdio.h>
#include <rtthread.h>
#define FAL_PRINTF rt_kprintf
#define FAL_MALLOC rt_malloc
#define FAL_CALLOC rt_calloc
#define FAL_REALLOC rt_realloc
#define FAL_FREE rt_free
#ifndef FAL_DEBUG
#define FAL_DEBUG 0
#endif
#if FAL_DEBUG
#ifdef assert
#undef assert
#endif
#define assert(EXPR) \
if (!(EXPR)) \
{ \
FAL_PRINTF("(%s) has assert failed at %s.\n", #EXPR, __FUNCTION__); \
while (1); \
}
/* debug level log */
#ifdef log_d
#undef log_d
#endif
#define log_d(...) FAL_PRINTF("[D/FAL] (%s:%d) ", __FUNCTION__, __LINE__); FAL_PRINTF(__VA_ARGS__);FAL_PRINTF("\n")
#else
#ifdef assert
#undef assert
#endif
#define assert(EXPR) ((void)0);
/* debug level log */
#ifdef log_d
#undef log_d
#endif
#define log_d(...)
#endif /* FAL_DEBUG */
/* error level log */
#ifdef log_e
#undef log_e
#endif
#define log_e(...) FAL_PRINTF("\033[31;22m[E/FAL] (%s:%d) ", __FUNCTION__, __LINE__);FAL_PRINTF(__VA_ARGS__);FAL_PRINTF("\033[0m\n")
/* info level log */
#ifdef log_i
#undef log_i
#endif
#define log_i(...) FAL_PRINTF("\033[32;22m[I/FAL] "); FAL_PRINTF(__VA_ARGS__);FAL_PRINTF("\033[0m\n")
/* FAL flash and partition device name max length */
#ifndef FAL_DEV_NAME_MAX
#define FAL_DEV_NAME_MAX 24
@ -79,8 +24,8 @@ if (!(EXPR)) \
struct flash_blk
{
size_t size;
size_t count;
rt_size_t size;
rt_size_t count;
};
struct fal_flash_dev
@ -88,23 +33,23 @@ struct fal_flash_dev
char name[FAL_DEV_NAME_MAX];
/* flash device start address and len */
uint32_t addr;
size_t len;
rt_uint32_t addr;
rt_size_t len;
/* the block size in the flash for erase minimum granularity */
size_t blk_size;
rt_size_t blk_size;
struct
{
int (*init)(void);
int (*read)(long offset, uint8_t *buf, size_t size);
int (*write)(long offset, const uint8_t *buf, size_t size);
int (*erase)(long offset, size_t size);
int (*read)(long offset, rt_uint8_t *buf, rt_size_t size);
int (*write)(long offset, const rt_uint8_t *buf, rt_size_t size);
int (*erase)(long offset, rt_size_t size);
} ops;
/* write minimum granularity, unit: bit.
1(nor flash)/ 8(stm32f2/f4)/ 32(stm32f1)/ 64(stm32l4)
0 will not take effect. */
size_t write_gran;
rt_size_t write_gran;
struct flash_blk blocks[FAL_DEV_BLK_MAX];
};
typedef struct fal_flash_dev *fal_flash_dev_t;
@ -114,7 +59,7 @@ typedef struct fal_flash_dev *fal_flash_dev_t;
*/
struct fal_partition
{
uint32_t magic_word;
rt_uint32_t magic_word;
/* partition name */
char name[FAL_DEV_NAME_MAX];
@ -123,9 +68,9 @@ struct fal_partition
/* partition offset address on flash device */
long offset;
size_t len;
rt_size_t len;
uint32_t reserved;
rt_uint32_t reserved;
};
typedef struct fal_partition *fal_partition_t;

6
components/fal/samples/porting/README.md
View File

@ -12,7 +12,7 @@
- `static int init(void)`：**可选** 的初始化操作
- `static int read(long offset, uint8_t *buf, size_t size)`：读取操作
- `static int read(long offset, rt_uint8_t *buf, rt_size_t size)`：读取操作
|参数 |描述|
|:----- |:----|
@ -21,7 +21,7 @@
|size |待读取数据的大小|
|return |返回实际读取的数据大小|
- `static int write(long offset, const uint8_t *buf, size_t size)` ：写入操作
- `static int write(long offset, const rt_uint8_t *buf, rt_size_t size)` ：写入操作
| 参数 | 描述 |
| :----- | :------------------------ |
@ -30,7 +30,7 @@
| size | 待写入数据的大小 |
| return | 返回实际写入的数据大小 |
- `static int erase(long offset, size_t size)` ：擦除操作
- `static int erase(long offset, rt_size_t size)` ：擦除操作
| 参数 | 描述 |
| :----- | :------------------------ |

24
components/fal/samples/porting/fal_flash_sfud_port.c
View File

@ -21,9 +21,9 @@
#endif
static int init(void);
static int read(long offset, uint8_t *buf, size_t size);
static int write(long offset, const uint8_t *buf, size_t size);
static int erase(long offset, size_t size);
static int read(long offset, rt_uint8_t *buf, rt_size_t size);
static int write(long offset, const rt_uint8_t *buf, rt_size_t size);
static int erase(long offset, rt_size_t size);
static sfud_flash_t sfud_dev = NULL;
struct fal_flash_dev nor_flash0 =
@ -60,19 +60,19 @@ static int init(void)
return 0;
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
sfud_read(sfud_dev, nor_flash0.addr + offset, size, buf);
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_write(sfud_dev, nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)
{
return -1;
@ -81,10 +81,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
assert(sfud_dev);
assert(sfud_dev->init_ok);
RT_ASSERT(sfud_dev);
RT_ASSERT(sfud_dev->init_ok);
if (sfud_erase(sfud_dev, nor_flash0.addr + offset, size) != SFUD_SUCCESS)
{
return -1;

58
components/fal/samples/porting/fal_flash_stm32f2_port.c
View File

@ -13,18 +13,18 @@
#include <stm32f2xx.h>
/* base address of the flash sectors */
#define ADDR_FLASH_SECTOR_0 ((uint32_t)0x08000000) /* Base address of Sector 0, 16 K bytes */
#define ADDR_FLASH_SECTOR_1 ((uint32_t)0x08004000) /* Base address of Sector 1, 16 K bytes */
#define ADDR_FLASH_SECTOR_2 ((uint32_t)0x08008000) /* Base address of Sector 2, 16 K bytes */
#define ADDR_FLASH_SECTOR_3 ((uint32_t)0x0800C000) /* Base address of Sector 3, 16 K bytes */
#define ADDR_FLASH_SECTOR_4 ((uint32_t)0x08010000) /* Base address of Sector 4, 64 K bytes */
#define ADDR_FLASH_SECTOR_5 ((uint32_t)0x08020000) /* Base address of Sector 5, 128 K bytes */
#define ADDR_FLASH_SECTOR_6 ((uint32_t)0x08040000) /* Base address of Sector 6, 128 K bytes */
#define ADDR_FLASH_SECTOR_7 ((uint32_t)0x08060000) /* Base address of Sector 7, 128 K bytes */
#define ADDR_FLASH_SECTOR_8 ((uint32_t)0x08080000) /* Base address of Sector 8, 128 K bytes */
#define ADDR_FLASH_SECTOR_9 ((uint32_t)0x080A0000) /* Base address of Sector 9, 128 K bytes */
#define ADDR_FLASH_SECTOR_10 ((uint32_t)0x080C0000) /* Base address of Sector 10, 128 K bytes */
#define ADDR_FLASH_SECTOR_11 ((uint32_t)0x080E0000) /* Base address of Sector 11, 128 K bytes */
#define ADDR_FLASH_SECTOR_0 ((rt_uint32_t)0x08000000) /* Base address of Sector 0, 16 K bytes */
#define ADDR_FLASH_SECTOR_1 ((rt_uint32_t)0x08004000) /* Base address of Sector 1, 16 K bytes */
#define ADDR_FLASH_SECTOR_2 ((rt_uint32_t)0x08008000) /* Base address of Sector 2, 16 K bytes */
#define ADDR_FLASH_SECTOR_3 ((rt_uint32_t)0x0800C000) /* Base address of Sector 3, 16 K bytes */
#define ADDR_FLASH_SECTOR_4 ((rt_uint32_t)0x08010000) /* Base address of Sector 4, 64 K bytes */
#define ADDR_FLASH_SECTOR_5 ((rt_uint32_t)0x08020000) /* Base address of Sector 5, 128 K bytes */
#define ADDR_FLASH_SECTOR_6 ((rt_uint32_t)0x08040000) /* Base address of Sector 6, 128 K bytes */
#define ADDR_FLASH_SECTOR_7 ((rt_uint32_t)0x08060000) /* Base address of Sector 7, 128 K bytes */
#define ADDR_FLASH_SECTOR_8 ((rt_uint32_t)0x08080000) /* Base address of Sector 8, 128 K bytes */
#define ADDR_FLASH_SECTOR_9 ((rt_uint32_t)0x080A0000) /* Base address of Sector 9, 128 K bytes */
#define ADDR_FLASH_SECTOR_10 ((rt_uint32_t)0x080C0000) /* Base address of Sector 10, 128 K bytes */
#define ADDR_FLASH_SECTOR_11 ((rt_uint32_t)0x080E0000) /* Base address of Sector 11, 128 K bytes */
/**
* Get the sector of a given address
@ -33,9 +33,9 @@
*
* @return The sector of a given address
*/
static uint32_t stm32_get_sector(uint32_t address)
static rt_uint32_t stm32_get_sector(rt_uint32_t address)
{
uint32_t sector = 0;
rt_uint32_t sector = 0;
if ((address < ADDR_FLASH_SECTOR_1) && (address >= ADDR_FLASH_SECTOR_0))
{
@ -96,8 +96,8 @@ static uint32_t stm32_get_sector(uint32_t address)
*
* @return sector size
*/
static uint32_t stm32_get_sector_size(uint32_t sector) {
assert(IS_FLASH_SECTOR(sector));
static rt_uint32_t stm32_get_sector_size(rt_uint32_t sector) {
RT_ASSERT(IS_FLASH_SECTOR(sector));
switch (sector) {
case FLASH_Sector_0: return 16 * 1024;
@ -120,23 +120,23 @@ static int init(void)
/* do nothing now */
}
static int read(long offset, uint8_t *buf, size_t size)
static int read(long offset, rt_uint8_t *buf, rt_size_t size)
{
size_t i;
uint32_t addr = stm32f2_onchip_flash.addr + offset;
rt_size_t i;
rt_uint32_t addr = stm32f2_onchip_flash.addr + offset;
for (i = 0; i < size; i++, addr++, buf++)
{
*buf = *(uint8_t *) addr;
*buf = *(rt_uint8_t *) addr;
}
return size;
}
static int write(long offset, const uint8_t *buf, size_t size)
static int write(long offset, const rt_uint8_t *buf, rt_size_t size)
{
size_t i;
uint32_t read_data;
uint32_t addr = stm32f2_onchip_flash.addr + offset;
rt_size_t i;
rt_uint32_t read_data;
rt_uint32_t addr = stm32f2_onchip_flash.addr + offset;
FLASH_Unlock();
FLASH_ClearFlag(
@ -146,7 +146,7 @@ static int write(long offset, const uint8_t *buf, size_t size)
{
/* write data */
FLASH_ProgramByte(addr, *buf);
read_data = *(uint8_t *) addr;
read_data = *(rt_uint8_t *) addr;
/* check data */
if (read_data != *buf)
{
@ -158,12 +158,12 @@ static int write(long offset, const uint8_t *buf, size_t size)
return size;
}
static int erase(long offset, size_t size)
static int erase(long offset, rt_size_t size)
{
FLASH_Status flash_status;
size_t erased_size = 0;
uint32_t cur_erase_sector;
uint32_t addr = stm32f2_onchip_flash.addr + offset;
rt_size_t erased_size = 0;
rt_uint32_t cur_erase_sector;
rt_uint32_t addr = stm32f2_onchip_flash.addr + offset;
/* start erase */
FLASH_Unlock();

15
components/fal/src/fal.c
View File

@ -9,8 +9,17 @@
*/
#include <fal.h>
#include <rtdevice.h>
static uint8_t init_ok = 0;
#define DBG_TAG "FAL"
#ifdef FAL_USING_DEBUG
#define DBG_LVL DBG_LOG
#else
#define DBG_LVL DBG_WARNING
#endif
#include <rtdbg.h>
static rt_uint8_t init_ok = 0;
/**
* FAL (Flash Abstraction Layer) initialization.
@ -40,12 +49,12 @@ __exit:
if ((result > 0) && (!init_ok))
{
init_ok = 1;
log_i("RT-Thread Flash Abstraction Layer initialize success.");
LOG_I("RT-Thread Flash Abstraction Layer initialize success.");
}
else if(result <= 0)
{
init_ok = 0;
log_e("RT-Thread Flash Abstraction Layer initialize failed.");
LOG_E("RT-Thread Flash Abstraction Layer initialize failed.");
}
return result;

34
components/fal/src/fal_flash.c
View File

@ -11,14 +11,22 @@
#include <fal.h>
#include <string.h>
#define DBG_TAG "FAL"
#ifdef FAL_USING_DEBUG
#define DBG_LVL DBG_LOG
#else
#define DBG_LVL DBG_WARNING
#endif
#include <rtdbg.h>
/* flash device table, must defined by user */
#if !defined(FAL_FLASH_DEV_TABLE)
#error "You must defined flash device table (FAL_FLASH_DEV_TABLE) on 'fal_cfg.h'"
#endif
static const struct fal_flash_dev * const device_table[] = FAL_FLASH_DEV_TABLE;
static const size_t device_table_len = sizeof(device_table) / sizeof(device_table[0]);
static uint8_t init_ok = 0;
static const rt_size_t device_table_len = sizeof(device_table) / sizeof(device_table[0]);
static rt_uint8_t init_ok = 0;
/**
* Initialize all flash device on FAL flash table
@ -27,7 +35,7 @@ static uint8_t init_ok = 0;
*/
int fal_flash_init(void)
{
size_t i, j, offset;
rt_size_t i, j, offset;
if (init_ok)
{
@ -36,33 +44,33 @@ int fal_flash_init(void)
for (i = 0; i < device_table_len; i++)
{
assert(device_table[i]->ops.read);
assert(device_table[i]->ops.write);
assert(device_table[i]->ops.erase);
RT_ASSERT(device_table[i]->ops.read);
RT_ASSERT(device_table[i]->ops.write);
RT_ASSERT(device_table[i]->ops.erase);
/* init flash device on flash table */
if (device_table[i]->ops.init)
{
device_table[i]->ops.init();
}
log_d("Flash device | %*.*s | addr: 0x%08lx | len: 0x%08x | blk_size: 0x%08x |initialized finish.",
LOG_D("Flash device | %*.*s | addr: 0x%08lx | len: 0x%08x | blk_size: 0x%08x |initialized finish.",
FAL_DEV_NAME_MAX, FAL_DEV_NAME_MAX, device_table[i]->name, device_table[i]->addr, device_table[i]->len,
device_table[i]->blk_size);
offset = 0;
for (j = 0; j < FAL_DEV_BLK_MAX; j ++)
{
const struct flash_blk *blk = &device_table[i]->blocks[j];
size_t blk_len = blk->count * blk->size;
rt_size_t blk_len = blk->count * blk->size;
if (blk->count == 0 || blk->size == 0)
break;
if(offset > device_table[i]->len)
{
log_i("Flash device %*.*s: add block failed, offset %d > len %d.",
LOG_I("Flash device %*.*s: add block failed, offset %d > len %d.",
FAL_DEV_NAME_MAX, FAL_DEV_NAME_MAX, device_table[i]->name, device_table[i]->addr, offset, device_table[i]->len);
break;
}
log_d(" blk%2d | addr: 0x%08lx | len: 0x%08x | blk_size: 0x%08x |initialized finish.",
LOG_D(" blk%2d | addr: 0x%08lx | len: 0x%08x | blk_size: 0x%08x |initialized finish.",
j, device_table[i]->addr + offset, blk_len, blk->size);
offset += blk_len;
}
@ -82,10 +90,10 @@ int fal_flash_init(void)
*/
const struct fal_flash_dev *fal_flash_device_find(const char *name)
{
assert(init_ok);
assert(name);
RT_ASSERT(init_ok);
RT_ASSERT(name);
size_t i;
rt_size_t i;
for (i = 0; i < device_table_len; i++)
{

126
components/fal/src/fal_partition.c
View File

@ -10,7 +10,15 @@
#include <fal.h>
#include <string.h>
#include <stdlib.h>
#define DBG_TAG "FAL"
#ifdef FAL_USING_DEBUG
#define DBG_LVL DBG_LOG
#else
#define DBG_LVL DBG_WARNING
#endif
#include <rtdbg.h>
/* partition magic word */
#define FAL_PART_MAGIC_WORD 0x45503130
@ -55,8 +63,8 @@ static struct fal_partition *partition_table = NULL;
static struct part_flash_info *part_flash_cache = NULL;
#endif /* FAL_PART_HAS_TABLE_CFG */
static uint8_t init_ok = 0;
static size_t partition_table_len = 0;
static rt_uint8_t init_ok = 0;
static rt_size_t partition_table_len = 0;
/**
* print the partition table
@ -64,7 +72,7 @@ static size_t partition_table_len = 0;
void fal_show_part_table(void)
{
char *item1 = "name", *item2 = "flash_dev";
size_t i, part_name_max = strlen(item1), flash_dev_name_max = strlen(item2);
rt_size_t i, part_name_max = strlen(item1), flash_dev_name_max = strlen(item2);
const struct fal_partition *part;
if (partition_table_len)
@ -82,10 +90,10 @@ void fal_show_part_table(void)
}
}
}
log_i("==================== FAL partition table ====================");
log_i("| %-*.*s | %-*.*s | offset | length |", part_name_max, FAL_DEV_NAME_MAX, item1, flash_dev_name_max,
LOG_I("==================== FAL partition table ====================");
LOG_I("| %-*.*s | %-*.*s | offset | length |", part_name_max, FAL_DEV_NAME_MAX, item1, flash_dev_name_max,
FAL_DEV_NAME_MAX, item2);
log_i("-------------------------------------------------------------");
LOG_I("-------------------------------------------------------------");
for (i = 0; i < partition_table_len; i++)
{
@ -95,26 +103,26 @@ void fal_show_part_table(void)
part = &partition_table[partition_table_len - i - 1];
#endif
log_i("| %-*.*s | %-*.*s | 0x%08lx | 0x%08x |", part_name_max, FAL_DEV_NAME_MAX, part->name, flash_dev_name_max,
LOG_I("| %-*.*s | %-*.*s | 0x%08lx | 0x%08x |", part_name_max, FAL_DEV_NAME_MAX, part->name, flash_dev_name_max,
FAL_DEV_NAME_MAX, part->flash_name, part->offset, part->len);
}
log_i("=============================================================");
LOG_I("=============================================================");
}
static int check_and_update_part_cache(const struct fal_partition *table, size_t len)
static int check_and_update_part_cache(const struct fal_partition *table, rt_size_t len)
{
const struct fal_flash_dev *flash_dev = NULL;
size_t i;
rt_size_t i;
#ifndef FAL_PART_HAS_TABLE_CFG
if (part_flash_cache)
{
FAL_FREE(part_flash_cache);
rt_free(part_flash_cache);
}
part_flash_cache = FAL_MALLOC(len * sizeof(struct part_flash_info));
part_flash_cache = rt_malloc(len * sizeof(struct part_flash_info));
if (part_flash_cache == NULL)
{
log_e("Initialize failed! No memory for partition table cache");
LOG_E("Initialize failed! No memory for partition table cache");
return -2;
}
#endif
@ -124,13 +132,13 @@ static int check_and_update_part_cache(const struct fal_partition *table, size_t
flash_dev = fal_flash_device_find(table[i].flash_name);
if (flash_dev == NULL)
{
log_d("Warning: Do NOT found the flash device(%s).", table[i].flash_name);
LOG_D("Warning: Do NOT found the flash device(%s).", table[i].flash_name);
continue;
}
if (table[i].offset >= (long)flash_dev->len)
{
log_e("Initialize failed! Partition(%s) offset address(%ld) out of flash bound(<%d).",
LOG_E("Initialize failed! Partition(%s) offset address(%ld) out of flash bound(<%d).",
table[i].name, table[i].offset, flash_dev->len);
partition_table_len = 0;
@ -162,38 +170,38 @@ int fal_partition_init(void)
#else
/* load partition table from the end address FAL_PART_TABLE_END_OFFSET, error return 0 */
long part_table_offset = FAL_PART_TABLE_END_OFFSET;
size_t table_num = 0, table_item_size = 0;
uint8_t part_table_find_ok = 0;
uint32_t read_magic_word;
rt_size_t table_num = 0, table_item_size = 0;
rt_uint8_t part_table_find_ok = 0;
rt_uint32_t read_magic_word;
fal_partition_t new_part = NULL;
size_t i;
rt_size_t i;
const struct fal_flash_dev *flash_dev = NULL;
flash_dev = fal_flash_device_find(FAL_PART_TABLE_FLASH_DEV_NAME);
if (flash_dev == NULL)
{
log_e("Initialize failed! Flash device (%s) NOT found.", FAL_PART_TABLE_FLASH_DEV_NAME);
LOG_E("Initialize failed! Flash device (%s) NOT found.", FAL_PART_TABLE_FLASH_DEV_NAME);
goto _exit;
}
/* check partition table offset address */
if (part_table_offset < 0 || part_table_offset >= (long) flash_dev->len)
{
log_e("Setting partition table end offset address(%ld) out of flash bound(<%d).", part_table_offset, flash_dev->len);
LOG_E("Setting partition table end offset address(%ld) out of flash bound(<%d).", part_table_offset, flash_dev->len);
goto _exit;
}
table_item_size = sizeof(struct fal_partition);
new_part = (fal_partition_t)FAL_MALLOC(table_item_size);
new_part = (fal_partition_t)rt_malloc(table_item_size);
if (new_part == NULL)
{
log_e("Initialize failed! No memory for table buffer.");
LOG_E("Initialize failed! No memory for table buffer.");
goto _exit;
}
/* find partition table location */
{
uint8_t read_buf[64];
rt_uint8_t read_buf[64];
part_table_offset -= sizeof(read_buf);
while (part_table_offset >= 0)
@ -208,7 +216,7 @@ int fal_partition_init(void)
{
part_table_find_ok = 1;
part_table_offset += i;
log_d("Find the partition table on '%s' offset @0x%08lx.", FAL_PART_TABLE_FLASH_DEV_NAME,
LOG_D("Find the partition table on '%s' offset @0x%08lx.", FAL_PART_TABLE_FLASH_DEV_NAME,
part_table_offset);
break;
}
@ -249,10 +257,10 @@ int fal_partition_init(void)
while (part_table_find_ok)
{
memset(new_part, 0x00, table_num);
if (flash_dev->ops.read(part_table_offset - table_item_size * (table_num), (uint8_t *) new_part,
if (flash_dev->ops.read(part_table_offset - table_item_size * (table_num), (rt_uint8_t *) new_part,
table_item_size) < 0)
{
log_e("Initialize failed! Flash device (%s) read error!", flash_dev->name);
LOG_E("Initialize failed! Flash device (%s) read error!", flash_dev->name);
table_num = 0;
break;
}
@ -262,10 +270,10 @@ int fal_partition_init(void)
break;
}
partition_table = (fal_partition_t) FAL_REALLOC(partition_table, table_item_size * (table_num + 1));
partition_table = (fal_partition_t) rt_realloc(partition_table, table_item_size * (table_num + 1));
if (partition_table == NULL)
{
log_e("Initialize failed! No memory for partition table");
LOG_E("Initialize failed! No memory for partition table");
table_num = 0;
break;
}
@ -277,7 +285,7 @@ int fal_partition_init(void)
if (table_num == 0)
{
log_e("Partition table NOT found on flash: %s (len: %d) from offset: 0x%08x.", FAL_PART_TABLE_FLASH_DEV_NAME,
LOG_E("Partition table NOT found on flash: %s (len: %d) from offset: 0x%08x.", FAL_PART_TABLE_FLASH_DEV_NAME,
FAL_DEV_NAME_MAX, FAL_PART_TABLE_END_OFFSET);
goto _exit;
}
@ -297,14 +305,14 @@ int fal_partition_init(void)
_exit:
#if FAL_DEBUG
#ifdef FAL_USING_DEBUG
fal_show_part_table();
#endif
#endif /* FAL_USING_DEBUG */
#ifndef FAL_PART_HAS_TABLE_CFG
if (new_part)
{
FAL_FREE(new_part);
rt_free(new_part);
}
#endif /* !FAL_PART_HAS_TABLE_CFG */
@ -324,7 +332,7 @@ const struct fal_partition *fal_partition_find(const char *name)
if (!init_ok)
return NULL;
size_t i;
rt_size_t i;
for (i = 0; i < partition_table_len; i++)
{
@ -339,8 +347,8 @@ const struct fal_partition *fal_partition_find(const char *name)
static const struct fal_flash_dev *flash_device_find_by_part(const struct fal_partition *part)
{
assert(part >= partition_table);
assert(part <= &partition_table[partition_table_len - 1]);
RT_ASSERT(part >= partition_table);
RT_ASSERT(part <= &partition_table[partition_table_len - 1]);
return part_flash_cache[part - partition_table].flash_dev;
}
@ -352,9 +360,9 @@ static const struct fal_flash_dev *flash_device_find_by_part(const struct fal_pa
*
* @return partition table
*/
const struct fal_partition *fal_get_partition_table(size_t *len)
const struct fal_partition *fal_get_partition_table(rt_size_t *len)
{
assert(len);
RT_ASSERT(len);
if (!init_ok)
return NULL;
@ -371,13 +379,13 @@ const struct fal_partition *fal_get_partition_table(size_t *len)
* @param table partition table
* @param len partition table length
*/
void fal_set_partition_table_temp(struct fal_partition *table, size_t len)
void fal_set_partition_table_temp(struct fal_partition *table, rt_size_t len)
{
assert(table);
RT_ASSERT(table);
if (!init_ok)
{
log_e("FAL NOT initialized");
LOG_E("FAL NOT initialized");
return;
}
@ -398,31 +406,31 @@ void fal_set_partition_table_temp(struct fal_partition *table, size_t len)
* @return >= 0: successful read data size
* -1: error
*/
int fal_partition_read(const struct fal_partition *part, uint32_t addr, uint8_t *buf, size_t size)
int fal_partition_read(const struct fal_partition *part, rt_uint32_t addr, rt_uint8_t *buf, rt_size_t size)
{
int ret = 0;
const struct fal_flash_dev *flash_dev = NULL;
assert(part);
assert(buf);
RT_ASSERT(part);
RT_ASSERT(buf);
if (addr + size > part->len)
{
log_e("Partition read error! Partition(%s) address(0x%08x) out of bound(0x%08x).", part->name, addr + size, part->len);
LOG_E("Partition read error! Partition(%s) address(0x%08x) out of bound(0x%08x).", part->name, addr + size, part->len);
return -1;
}
flash_dev = flash_device_find_by_part(part);
if (flash_dev == NULL)
{
log_e("Partition read error! Don't found flash device(%s) of the partition(%s).", part->flash_name, part->name);
LOG_E("Partition read error! Don't found flash device(%s) of the partition(%s).", part->flash_name, part->name);
return -1;
}
ret = flash_dev->ops.read(part->offset + addr, buf, size);
if (ret < 0)
{
log_e("Partition read error! Flash device(%s) read error!", part->flash_name);
LOG_E("Partition read error! Flash device(%s) read error!", part->flash_name);
}
return ret;
@ -439,31 +447,31 @@ int fal_partition_read(const struct fal_partition *part, uint32_t addr, uint8_t
* @return >= 0: successful write data size
* -1: error
*/
int fal_partition_write(const struct fal_partition *part, uint32_t addr, const uint8_t *buf, size_t size)
int fal_partition_write(const struct fal_partition *part, rt_uint32_t addr, const rt_uint8_t *buf, rt_size_t size)
{
int ret = 0;
const struct fal_flash_dev *flash_dev = NULL;
assert(part);
assert(buf);
RT_ASSERT(part);
RT_ASSERT(buf);
if (addr + size > part->len)
{
log_e("Partition write error! Partition address out of bound.");
LOG_E("Partition write error! Partition address out of bound.");
return -1;
}
flash_dev = flash_device_find_by_part(part);
if (flash_dev == NULL)
{
log_e("Partition write error! Don't found flash device(%s) of the partition(%s).", part->flash_name, part->name);
LOG_E("Partition write error! Don't found flash device(%s) of the partition(%s).", part->flash_name, part->name);
return -1;
}
ret = flash_dev->ops.write(part->offset + addr, buf, size);
if (ret < 0)
{
log_e("Partition write error! Flash device(%s) write error!", part->flash_name);
LOG_E("Partition write error! Flash device(%s) write error!", part->flash_name);
}
return ret;
@ -479,30 +487,30 @@ int fal_partition_write(const struct fal_partition *part, uint32_t addr, const u
* @return >= 0: successful erased data size
* -1: error
*/
int fal_partition_erase(const struct fal_partition *part, uint32_t addr, size_t size)
int fal_partition_erase(const struct fal_partition *part, rt_uint32_t addr, rt_size_t size)
{
int ret = 0;
const struct fal_flash_dev *flash_dev = NULL;
assert(part);
RT_ASSERT(part);
if (addr + size > part->len)
{
log_e("Partition erase error! Partition address out of bound.");
LOG_E("Partition erase error! Partition address out of bound.");
return -1;
}
flash_dev = flash_device_find_by_part(part);
if (flash_dev == NULL)
{
log_e("Partition erase error! Don't found flash device(%s) of the partition(%s).", part->flash_name, part->name);
LOG_E("Partition erase error! Don't found flash device(%s) of the partition(%s).", part->flash_name, part->name);
return -1;
}
ret = flash_dev->ops.erase(part->offset + addr, size);
if (ret < 0)
{
log_e("Partition erase error! Flash device(%s) erase error!", part->flash_name);
LOG_E("Partition erase error! Flash device(%s) erase error!", part->flash_name);
}
return ret;

83
components/fal/src/fal_rtt.c
View File

@ -10,12 +10,16 @@
*/
#include <fal.h>
#ifdef RT_VER_NUM
#include <rtthread.h>
#include <rtdevice.h>
#include <string.h>
#include <stdlib.h>
#define DBG_TAG "FAL"
#ifdef FAL_USING_DEBUG
#define DBG_LVL DBG_LOG
#else
#define DBG_LVL DBG_WARNING
#endif
#include <rtdbg.h>
/* ========================== block device ======================== */
struct fal_blk_device
@ -34,7 +38,7 @@ static rt_err_t blk_dev_control(rt_device_t dev, rt_uint8_t cmd, void *args)
{
struct fal_blk_device *part = (struct fal_blk_device*) dev;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
if (cmd == RT_DEVICE_CTRL_BLK_GETGEOME)
{
@ -80,7 +84,7 @@ static rt_ssize_t blk_dev_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_s
int ret = 0;
struct fal_blk_device *part = (struct fal_blk_device*) dev;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
ret = fal_partition_read(part->fal_part, pos * part->geometry.block_size, buffer, size * part->geometry.block_size);
@ -104,7 +108,7 @@ static rt_ssize_t blk_dev_write(rt_device_t dev, rt_off_t pos, const void* buffe
rt_size_t phy_size;
part = (struct fal_blk_device*) dev;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
/* change the block device's logic address to physical address */
phy_pos = pos * part->geometry.bytes_per_sector;
@ -157,13 +161,13 @@ struct rt_device *fal_blk_device_create(const char *parition_name)
if (!fal_part)
{
log_e("Error: the partition name (%s) is not found.", parition_name);
LOG_E("Error: the partition name (%s) is not found.", parition_name);
return NULL;
}
if ((fal_flash = fal_flash_device_find(fal_part->flash_name)) == NULL)
{
log_e("Error: the flash device name (%s) is not found.", fal_part->flash_name);
LOG_E("Error: the flash device name (%s) is not found.", fal_part->flash_name);
return NULL;
}
@ -192,12 +196,12 @@ struct rt_device *fal_blk_device_create(const char *parition_name)
/* no private */
blk_dev->parent.user_data = RT_NULL;
log_i("The FAL block device (%s) created successfully", fal_part->name);
LOG_I("The FAL block device (%s) created successfully", fal_part->name);
rt_device_register(RT_DEVICE(blk_dev), fal_part->name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
}
else
{
log_e("Error: no memory for create FAL block device");
LOG_E("Error: no memory for create FAL block device");
}
return RT_DEVICE(blk_dev);
@ -217,7 +221,7 @@ static rt_ssize_t mtd_nor_dev_read(struct rt_mtd_nor_device* device, rt_off_t of
int ret = 0;
struct fal_mtd_nor_device *part = (struct fal_mtd_nor_device*) device;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
ret = fal_partition_read(part->fal_part, offset, data, length);
@ -239,7 +243,7 @@ static rt_ssize_t mtd_nor_dev_write(struct rt_mtd_nor_device* device, rt_off_t o
struct fal_mtd_nor_device *part;
part = (struct fal_mtd_nor_device*) device;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
ret = fal_partition_write(part->fal_part, offset, data, length);
@ -261,7 +265,7 @@ static rt_err_t mtd_nor_dev_erase(struct rt_mtd_nor_device* device, rt_off_t off
struct fal_mtd_nor_device *part;
part = (struct fal_mtd_nor_device*) device;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
ret = fal_partition_erase(part->fal_part, offset, length);
@ -299,13 +303,13 @@ struct rt_device *fal_mtd_nor_device_create(const char *parition_name)
if (!fal_part)
{
log_e("Error: the partition name (%s) is not found.", parition_name);
LOG_E("Error: the partition name (%s) is not found.", parition_name);
return NULL;
}
if ((fal_flash = fal_flash_device_find(fal_part->flash_name)) == NULL)
{
log_e("Error: the flash device name (%s) is not found.", fal_part->flash_name);
LOG_E("Error: the flash device name (%s) is not found.", fal_part->flash_name);
return NULL;
}
@ -321,12 +325,12 @@ struct rt_device *fal_mtd_nor_device_create(const char *parition_name)
/* set ops */
mtd_nor_dev->parent.ops = &_ops;
log_i("The FAL MTD NOR device (%s) created successfully", fal_part->name);
LOG_I("The FAL MTD NOR device (%s) created successfully", fal_part->name);
rt_mtd_nor_register_device(fal_part->name, &mtd_nor_dev->parent);
}
else
{
log_e("Error: no memory for create FAL MTD NOR device");
LOG_E("Error: no memory for create FAL MTD NOR device");
}
return RT_DEVICE(&mtd_nor_dev->parent);
@ -348,7 +352,7 @@ static rt_ssize_t char_dev_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_
int ret = 0;
struct fal_char_device *part = (struct fal_char_device *) dev;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
if (pos + size > part->fal_part->len)
size = part->fal_part->len - pos;
@ -367,7 +371,7 @@ static rt_ssize_t char_dev_write(rt_device_t dev, rt_off_t pos, const void *buff
struct fal_char_device *part;
part = (struct fal_char_device *) dev;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
if (pos == 0)
{
@ -410,7 +414,7 @@ static int char_dev_fopen(struct dfs_file *fd)
{
struct fal_char_device *part = (struct fal_char_device *) fd->vnode->data;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
switch (fd->flags & O_ACCMODE)
{
@ -429,12 +433,12 @@ static int char_dev_fopen(struct dfs_file *fd)
return RT_EOK;
}
static int char_dev_fread(struct dfs_file *fd, void *buf, size_t count)
static int char_dev_fread(struct dfs_file *fd, void *buf, rt_size_t count)
{
int ret = 0;
struct fal_char_device *part = (struct fal_char_device *) fd->vnode->data;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
if (DFS_FILE_POS(fd) + count > part->fal_part->len)
count = part->fal_part->len - DFS_FILE_POS(fd);
@ -449,12 +453,12 @@ static int char_dev_fread(struct dfs_file *fd, void *buf, size_t count)
return ret;
}
static int char_dev_fwrite(struct dfs_file *fd, const void *buf, size_t count)
static int char_dev_fwrite(struct dfs_file *fd, const void *buf, rt_size_t count)
{
int ret = 0;
struct fal_char_device *part = (struct fal_char_device *) fd->vnode->data;
assert(part != RT_NULL);
RT_ASSERT(part != RT_NULL);
if (DFS_FILE_POS(fd) + count > part->fal_part->len)
count = part->fal_part->len - DFS_FILE_POS(fd);
@ -498,13 +502,13 @@ struct rt_device *fal_char_device_create(const char *parition_name)
if (!fal_part)
{
log_e("Error: the partition name (%s) is not found.", parition_name);
LOG_E("Error: the partition name (%s) is not found.", parition_name);
return NULL;
}
if ((fal_flash_device_find(fal_part->flash_name)) == NULL)
{
log_e("Error: the flash device name (%s) is not found.", fal_part->flash_name);
LOG_E("Error: the flash device name (%s) is not found.", fal_part->flash_name);
return NULL;
}
@ -530,7 +534,7 @@ struct rt_device *fal_char_device_create(const char *parition_name)
#endif
rt_device_register(RT_DEVICE(char_dev), fal_part->name, RT_DEVICE_FLAG_RDWR);
log_i("The FAL char device (%s) created successfully", fal_part->name);
LOG_I("The FAL char device (%s) created successfully", fal_part->name);
#ifdef RT_USING_POSIX_DEVIO
/* set fops */
@ -540,7 +544,7 @@ struct rt_device *fal_char_device_create(const char *parition_name)
}
else
{
log_e("Error: no memory for create FAL char device");
LOG_E("Error: no memory for create FAL char device");
}
return RT_DEVICE(char_dev);
@ -551,7 +555,7 @@ struct rt_device *fal_char_device_create(const char *parition_name)
#include <finsh.h>
extern int fal_init_check(void);
static void fal(uint8_t argc, char **argv) {
static void fal(rt_uint8_t argc, char **argv) {
#define __is_print(ch) ((unsigned int)((ch) - ' ') < 127u - ' ')
#define HEXDUMP_WIDTH 16
@ -564,7 +568,7 @@ static void fal(uint8_t argc, char **argv) {
int result = 0;
static const struct fal_flash_dev *flash_dev = NULL;
static const struct fal_partition *part_dev = NULL;
size_t i = 0, j = 0;
rt_size_t i = 0, j = 0;
const char* help_info[] =
{
@ -593,7 +597,7 @@ static void fal(uint8_t argc, char **argv) {
else
{
const char *operator = argv[1];
uint32_t addr, size;
rt_uint32_t addr, size;
if (!strcmp(operator, "probe"))
{
@ -651,7 +655,7 @@ static void fal(uint8_t argc, char **argv) {
{
addr = strtol(argv[2], NULL, 0);
size = strtol(argv[3], NULL, 0);
uint8_t *data = rt_malloc(size);
rt_uint8_t *data = rt_malloc(size);
if (data)
{
if (flash_dev)
@ -713,7 +717,7 @@ static void fal(uint8_t argc, char **argv) {
{
addr = strtol(argv[2], NULL, 0);
size = argc - 3;
uint8_t *data = rt_malloc(size);
rt_uint8_t *data = rt_malloc(size);
if (data)
{
for (i = 0; i < size; i++)
@ -784,9 +788,9 @@ static void fal(uint8_t argc, char **argv) {
return;
}
/* full chip benchmark test */
uint32_t start_time, time_cast;
size_t write_size = strtol(argv[2], NULL, 0), read_size = strtol(argv[2], NULL, 0), cur_op_size;
uint8_t *write_data = (uint8_t *)rt_malloc(write_size), *read_data = (uint8_t *)rt_malloc(read_size);
rt_uint32_t start_time, time_cast;
rt_size_t write_size = strtol(argv[2], NULL, 0), read_size = strtol(argv[2], NULL, 0), cur_op_size;
rt_uint8_t *write_data = (rt_uint8_t *)rt_malloc(write_size), *read_data = (rt_uint8_t *)rt_malloc(read_size);
if (write_data && read_data)
{
@ -880,7 +884,7 @@ static void fal(uint8_t argc, char **argv) {
result = fal_partition_read(part_dev, i, read_data, cur_op_size);
}
/* data check */
for (size_t index = 0; index < cur_op_size; index ++)
for (rt_size_t index = 0; index < cur_op_size; index ++)
{
if (write_data[index] != read_data[index])
{
@ -936,4 +940,3 @@ static void fal(uint8_t argc, char **argv) {
MSH_CMD_EXPORT(fal, FAL (Flash Abstraction Layer) operate.);
#endif /* defined(RT_USING_FINSH) && defined(FINSH_USING_MSH) */
#endif /* RT_VER_NUM */