/**
* Formats a single scratch area.
*/
int
nffs_format_area(uint8_t area_idx, int is_scratch)
{
struct nffs_disk_area disk_area;
struct nffs_area *area;
uint32_t write_len;
int rc;
area = nffs_areas + area_idx;
rc = hal_flash_erase(area->na_flash_id, area->na_offset, area->na_length);
if (rc != 0) {
return rc;
}
area->na_cur = 0;
nffs_area_to_disk(area, &disk_area);
if (is_scratch) {
nffs_areas[area_idx].na_id = NFFS_AREA_ID_NONE;
write_len = sizeof disk_area - sizeof disk_area.nda_id;
} else {
write_len = sizeof disk_area;
}
rc = nffs_flash_write(area_idx, 0, &disk_area.nda_magic, write_len);
if (rc != 0) {
return rc;
}
return 0;
}
static void
boot_test_util_init_flash(void)
{
const struct nffs_area_desc *area_desc;
int rc;
rc = hal_flash_init();
TEST_ASSERT(rc == 0);
for (area_desc = boot_test_area_descs;
area_desc->nad_length != 0;
area_desc++) {
rc = hal_flash_erase(area_desc->nad_flash_id, area_desc->nad_offset,
area_desc->nad_length);
TEST_ASSERT(rc == 0);
}
rc = nffs_init();
TEST_ASSERT(rc == 0);
rc = nffs_format(boot_test_format_descs);
TEST_ASSERT(rc == 0);
rc = fs_mkdir("/boot");
TEST_ASSERT(rc == 0);
}
static void
boot_test_util_copy_area(int from_area_idx, int to_area_idx)
{
const struct nffs_area_desc *from_area_desc;
const struct nffs_area_desc *to_area_desc;
void *buf;
int rc;
from_area_desc = boot_test_area_descs + from_area_idx;
to_area_desc = boot_test_area_descs + to_area_idx;
TEST_ASSERT(from_area_desc->nad_length == to_area_desc->nad_length);
buf = malloc(from_area_desc->nad_length);
TEST_ASSERT(buf != NULL);
rc = hal_flash_read(from_area_desc->nad_flash_id,
from_area_desc->nad_offset, buf,
from_area_desc->nad_length);
TEST_ASSERT(rc == 0);
rc = hal_flash_erase(to_area_desc->nad_flash_id,
to_area_desc->nad_offset,
to_area_desc->nad_length);
TEST_ASSERT(rc == 0);
rc = hal_flash_write(to_area_desc->nad_flash_id,
to_area_desc->nad_offset, buf,
to_area_desc->nad_length);
TEST_ASSERT(rc == 0);
free(buf);
}
static int stm32l475_ota_init(hal_ota_module_t *m, void *something)
{
hal_logic_partition_t *partition_info;
hal_partition_t pno = HAL_PARTITION_OTA_TEMP;
stm32l475_ota_module.init = stm32l475_ota_init;
stm32l475_ota_module.ota_write = stm32l475_ota_write;
stm32l475_ota_module.ota_read = stm32l475_ota_read;
stm32l475_ota_module.ota_set_boot = stm32l475_ota_set_boot;
LOG("set ota init---------------\n");
_off_set = *(uint32_t*)something;
ota_info.ota_len=_off_set;
if (!FLASH_bank1_enabled()) {
pno = HAL_PARTITION_APPLICATION;
}
if(_off_set==0) {
partition_info = hal_flash_get_info( pno );
hal_flash_erase(pno, 0 ,partition_info->partition_length);
CRC16_Init( &contex );
} else {
contex.crc=hal_ota_get_crc16();
LOG("--------get crc16 context.crc=%d!--------\n",contex.crc);
}
return 0;
}
static void
boot_test_util_swap_areas(int area_idx1, int area_idx2)
{
const struct nffs_area_desc *area_desc1;
const struct nffs_area_desc *area_desc2;
void *buf1;
void *buf2;
int rc;
area_desc1 = boot_test_area_descs + area_idx1;
area_desc2 = boot_test_area_descs + area_idx2;
TEST_ASSERT(area_desc1->nad_length == area_desc2->nad_length);
buf1 = malloc(area_desc1->nad_length);
TEST_ASSERT(buf1 != NULL);
buf2 = malloc(area_desc2->nad_length);
TEST_ASSERT(buf2 != NULL);
rc = hal_flash_read(area_desc1->nad_flash_id, area_desc1->nad_offset,
buf1, area_desc1->nad_length);
TEST_ASSERT(rc == 0);
rc = hal_flash_read(area_desc2->nad_flash_id, area_desc2->nad_offset,
buf2, area_desc2->nad_length);
TEST_ASSERT(rc == 0);
rc = hal_flash_erase(area_desc1->nad_flash_id, area_desc1->nad_offset,
area_desc1->nad_length);
TEST_ASSERT(rc == 0);
rc = hal_flash_erase(area_desc2->nad_flash_id, area_desc2->nad_offset,
area_desc2->nad_length);
TEST_ASSERT(rc == 0);
rc = hal_flash_write(area_desc1->nad_flash_id, area_desc1->nad_offset,
buf2, area_desc1->nad_length);
TEST_ASSERT(rc == 0);
rc = hal_flash_write(area_desc2->nad_flash_id, area_desc2->nad_offset,
buf1, area_desc2->nad_length);
TEST_ASSERT(rc == 0);
free(buf1);
free(buf2);
}
static int
boot_erase_area(int area_idx)
{
const struct nffs_area_desc *area_desc;
int rc;
area_desc = boot_req->br_area_descs + area_idx;
rc = hal_flash_erase(area_desc->nad_flash_id, area_desc->nad_offset,
area_desc->nad_length);
if (rc != 0) {
return BOOT_EFLASH;
}
return 0;
}
static hal_result_t s_hal_eeprom_writeflash(uint32_t addr, uint32_t size, void * data)
{
uint32_t pageaddr = hal_flash_get_pageaddr(addr);
uint32_t pagesize = hal_flash_get_pagesize(addr);
uint32_t offset = addr - pageaddr;
uint32_t count = 0;
uint32_t numbytes = 0;
uint8_t* data2write = data;
if(hal_false == hal_flash_address_isvalid(addr))
{ // cannot write at the address the first bytes
return(hal_res_NOK_generic);
}
if(hal_false == hal_flash_address_isvalid(addr+size-1))
{ // cannot write at the address the last bytes
return(hal_res_NOK_generic);
}
if(NULL == s_hal_eeprom_emulated_flash_cfg.flashpagebuffer)
{ // dont have a pagebuffer
return(hal_res_NOK_generic);
}
for(;;)
{
pageaddr = hal_flash_get_pageaddr(addr);
pagesize = hal_flash_get_pagesize(addr);
offset = addr - pageaddr;
numbytes = (size<(pagesize-offset)) ? (size) : (pagesize-offset);
data2write = (uint8_t*)data + count;;
if(s_hal_eeprom_emulated_flash_cfg.flashpagesize < pagesize)
{ // cannot write in a page with size bigger than the buffer capacity
return(hal_res_NOK_generic);
}
// read a page and place content in buffer
hal_flash_read(pageaddr, pagesize, s_hal_eeprom_emulated_flash_cfg.flashpagebuffer);
// change the buffer
memcpy(&((uint8_t*)s_hal_eeprom_emulated_flash_cfg.flashpagebuffer)[offset], data2write, numbytes);
// erase the page
hal_flash_erase(pageaddr, pagesize);
// write the buffer
hal_flash_write(pageaddr, pagesize, s_hal_eeprom_emulated_flash_cfg.flashpagebuffer);
count += numbytes;
size -= numbytes;
addr = pageaddr+pagesize;
if(0 == size)
{
return(hal_res_OK);
}
}
}
static hal_result_t s_hal_eeprom_eraseflash(uint32_t addr, uint32_t size)
{
uint32_t pageaddr = hal_flash_get_pageaddr(addr);
uint32_t pagesize = hal_flash_get_pagesize(addr);
uint32_t offset = addr - pageaddr;
uint32_t numbytes = 0;
if(hal_false == hal_flash_address_isvalid(addr))
{ // cannot erase at the address of the first bytes
return(hal_res_NOK_generic);
}
if(hal_false == hal_flash_address_isvalid(addr+size-1))
{ // cannot erase at the address of the last bytes
return(hal_res_NOK_generic);
}
if(NULL == s_hal_eeprom_emulated_flash_cfg.flashpagebuffer)
{ // dont have a pagebuffer
return(hal_res_NOK_generic);
}
for(;;)
{
pageaddr = hal_flash_get_pageaddr(addr);
pagesize = hal_flash_get_pagesize(addr);
offset = addr - pageaddr;
numbytes = (size<(pagesize-offset)) ? (size) : (pagesize-offset);
if(s_hal_eeprom_emulated_flash_cfg.flashpagesize < pagesize)
{ // cannot erase a page with size bigger than the buffer capacity
return(hal_res_NOK_generic);
}
if(numbytes == pagesize)
{ // just erase
hal_flash_erase(pageaddr, pagesize);
}
else
{ // need to save some data in the page...
// read a page and place content in buffer
hal_flash_read(pageaddr, pagesize, s_hal_eeprom_emulated_flash_cfg.flashpagebuffer);
// set to 0xff a part of the buffer
memset(&((uint8_t*)s_hal_eeprom_emulated_flash_cfg.flashpagebuffer)[offset], 0xFF, numbytes);
// erase the full page
hal_flash_erase(pageaddr, pagesize);
// write the buffer
hal_flash_write(pageaddr, pagesize, s_hal_eeprom_emulated_flash_cfg.flashpagebuffer);
}
size -= numbytes;
addr = pageaddr+pagesize;
if(0 == size)
{
return(hal_res_OK);
}
}
}
