2022-06-27 07:16:50 +00:00
|
|
|
/*
|
|
|
|
* SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
|
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
|
|
*/
|
2016-08-17 15:08:22 +00:00
|
|
|
#include "catch.hpp"
|
2022-06-27 07:16:50 +00:00
|
|
|
#include "spi_flash_mmap.h"
|
2020-04-27 00:51:31 +00:00
|
|
|
#include "esp_partition.h"
|
2016-08-17 15:08:22 +00:00
|
|
|
#include "spi_flash_emulation.h"
|
2018-11-14 12:40:24 +00:00
|
|
|
#include <functional>
|
2016-08-17 15:08:22 +00:00
|
|
|
|
|
|
|
template <typename Tit>
|
|
|
|
bool range_empty_n(Tit it_begin, size_t n)
|
|
|
|
{
|
2022-10-18 13:06:10 +00:00
|
|
|
return std::all_of(it_begin, it_begin + n, bind(std::equal_to<uint32_t>(), std::placeholders::_1, 0xffffffff));
|
2016-08-17 15:08:22 +00:00
|
|
|
}
|
|
|
|
|
2020-04-27 00:51:31 +00:00
|
|
|
struct FlashEmuFixture {
|
|
|
|
FlashEmuFixture(size_t sectors) : esp_part(), emu(sectors) { }
|
|
|
|
|
|
|
|
esp_partition_t esp_part;
|
|
|
|
SpiFlashEmulator emu;
|
|
|
|
};
|
|
|
|
|
2016-08-17 15:08:22 +00:00
|
|
|
TEST_CASE("flash starts with all bytes == 0xff", "[spi_flash_emu]")
|
|
|
|
{
|
2020-04-27 00:51:31 +00:00
|
|
|
FlashEmuFixture f(4);
|
2016-08-17 15:08:22 +00:00
|
|
|
|
|
|
|
uint8_t sector[SPI_FLASH_SEC_SIZE];
|
|
|
|
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
2020-04-27 00:51:31 +00:00
|
|
|
CHECK(esp_partition_read(&f.esp_part, 0, sector, sizeof(sector)) == ESP_OK);
|
2016-08-17 15:08:22 +00:00
|
|
|
for (auto v: sector) {
|
|
|
|
CHECK(v == 0xff);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_CASE("invalid writes are checked", "[spi_flash_emu]")
|
|
|
|
{
|
2020-04-27 00:51:31 +00:00
|
|
|
FlashEmuFixture f(1);
|
2016-08-17 15:08:22 +00:00
|
|
|
|
|
|
|
uint32_t val = 0;
|
2020-04-27 00:51:31 +00:00
|
|
|
CHECK(esp_partition_write(&f.esp_part, 0, &val, 4) == ESP_OK);
|
2016-08-17 15:08:22 +00:00
|
|
|
val = 1;
|
2020-04-27 00:51:31 +00:00
|
|
|
CHECK(esp_partition_write(&f.esp_part, 0, &val, 4) == ESP_ERR_FLASH_OP_FAIL);
|
2016-08-17 15:08:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST_CASE("out of bounds writes fail", "[spi_flash_emu]")
|
|
|
|
{
|
2020-04-27 00:51:31 +00:00
|
|
|
FlashEmuFixture f(4);
|
2016-08-17 15:08:22 +00:00
|
|
|
uint32_t vals[8];
|
|
|
|
std::fill_n(vals, 8, 0);
|
2020-04-27 00:51:31 +00:00
|
|
|
CHECK(esp_partition_write(&f.esp_part, 0, &vals, sizeof(vals)) == ESP_OK);
|
2016-08-17 15:08:22 +00:00
|
|
|
|
2020-04-27 00:51:31 +00:00
|
|
|
CHECK(esp_partition_write(&f.esp_part, 4*4096 - sizeof(vals), &vals, sizeof(vals)) == ESP_OK);
|
2016-08-17 15:08:22 +00:00
|
|
|
|
2020-04-27 00:51:31 +00:00
|
|
|
CHECK(esp_partition_write(&f.esp_part, 4*4096 - sizeof(vals) + 4, &vals, sizeof(vals)) == ESP_ERR_FLASH_OP_FAIL);
|
2016-08-17 15:08:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_CASE("after erase the sector is set to 0xff", "[spi_flash_emu]")
|
|
|
|
{
|
2020-04-27 00:51:31 +00:00
|
|
|
FlashEmuFixture f(4);
|
2016-08-17 15:08:22 +00:00
|
|
|
uint32_t val1 = 0xab00cd12;
|
2020-04-27 00:51:31 +00:00
|
|
|
CHECK(esp_partition_write(&f.esp_part, 0, &val1, sizeof(val1)) == ESP_OK);
|
2016-08-17 15:08:22 +00:00
|
|
|
uint32_t val2 = 0x5678efab;
|
2020-04-27 00:51:31 +00:00
|
|
|
CHECK(esp_partition_write(&f.esp_part, 4096 - 4, &val2, sizeof(val2)) == ESP_OK);
|
|
|
|
|
|
|
|
CHECK(f.emu.words()[0] == val1);
|
|
|
|
CHECK(range_empty_n(f.emu.words() + 1, 4096 / 4 - 2));
|
|
|
|
CHECK(f.emu.words()[4096 / 4 - 1] == val2);
|
|
|
|
|
|
|
|
CHECK(esp_partition_erase_range(&f.esp_part, 0, SPI_FLASH_SEC_SIZE) == ESP_OK);
|
|
|
|
|
|
|
|
CHECK(f.emu.words()[0] == 0xffffffff);
|
|
|
|
CHECK(range_empty_n(f.emu.words() + 1, 4096 / 4 - 2));
|
|
|
|
CHECK(f.emu.words()[4096 / 4 - 1] == 0xffffffff);
|
|
|
|
}
|
2016-08-17 15:08:22 +00:00
|
|
|
|
2020-04-27 00:51:31 +00:00
|
|
|
TEST_CASE("EMU raw read function works", "[spi_flash_emu]")
|
|
|
|
{
|
|
|
|
FlashEmuFixture f(4);
|
|
|
|
uint32_t value = 0xdeadbeef;
|
|
|
|
uint32_t read_value = 0;
|
|
|
|
CHECK(esp_partition_write(&f.esp_part, 0, &value, sizeof(value)) == ESP_OK);
|
|
|
|
|
2023-04-03 20:25:02 +00:00
|
|
|
CHECK(esp_partition_read_raw(&f.esp_part, 0, &read_value, sizeof(read_value)) == ESP_OK);
|
2020-04-27 00:51:31 +00:00
|
|
|
|
|
|
|
CHECK(read_value == 0xdeadbeef);
|
|
|
|
}
|
2016-08-17 15:08:22 +00:00
|
|
|
|
2020-04-27 00:51:31 +00:00
|
|
|
TEST_CASE("EMU raw write function works", "[spi_flash_emu]")
|
|
|
|
{
|
|
|
|
FlashEmuFixture f(4);
|
|
|
|
uint32_t value = 0xdeadbeef;
|
|
|
|
uint32_t read_value = 0;
|
|
|
|
CHECK(esp_partition_write_raw(&f.esp_part, 0, &value, sizeof(value)) == ESP_OK);
|
|
|
|
|
2023-04-03 20:25:02 +00:00
|
|
|
CHECK(esp_partition_read(&f.esp_part, 0, &read_value, sizeof(read_value)) == ESP_OK);
|
2016-08-17 15:08:22 +00:00
|
|
|
|
2020-04-27 00:51:31 +00:00
|
|
|
CHECK(read_value == 0xdeadbeef);
|
2016-08-17 15:08:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_CASE("read/write/erase operation times are calculated correctly", "[spi_flash_emu]")
|
|
|
|
{
|
2020-04-27 00:51:31 +00:00
|
|
|
FlashEmuFixture f(1);
|
2016-10-21 09:28:50 +00:00
|
|
|
uint8_t data[512];
|
2020-04-27 00:51:31 +00:00
|
|
|
esp_partition_read(&f.esp_part, 0, data, 4);
|
|
|
|
CHECK(f.emu.getTotalTime() == 7);
|
|
|
|
CHECK(f.emu.getReadOps() == 1);
|
|
|
|
CHECK(f.emu.getReadBytes() == 4);
|
|
|
|
f.emu.clearStats();
|
|
|
|
esp_partition_read(&f.esp_part, 0, data, 8);
|
|
|
|
CHECK(f.emu.getTotalTime() == 5);
|
|
|
|
CHECK(f.emu.getReadOps() == 1);
|
|
|
|
CHECK(f.emu.getReadBytes() == 8);
|
|
|
|
f.emu.clearStats();
|
|
|
|
esp_partition_read(&f.esp_part, 0, data, 16);
|
|
|
|
CHECK(f.emu.getTotalTime() == 6);
|
|
|
|
CHECK(f.emu.getReadOps() == 1);
|
|
|
|
CHECK(f.emu.getReadBytes() == 16);
|
|
|
|
f.emu.clearStats();
|
|
|
|
esp_partition_read(&f.esp_part, 0, data, 128);
|
|
|
|
CHECK(f.emu.getTotalTime() == 18);
|
|
|
|
CHECK(f.emu.getReadOps() == 1);
|
|
|
|
CHECK(f.emu.getReadBytes() == 128);
|
|
|
|
f.emu.clearStats();
|
|
|
|
esp_partition_read(&f.esp_part, 0, data, 256);
|
|
|
|
CHECK(f.emu.getTotalTime() == 32);
|
|
|
|
f.emu.clearStats();
|
|
|
|
esp_partition_read(&f.esp_part, 0, data, (128+256)/2);
|
|
|
|
CHECK(f.emu.getTotalTime() == (18+32)/2);
|
|
|
|
f.emu.clearStats();
|
|
|
|
|
|
|
|
esp_partition_write(&f.esp_part, 0, data, 4);
|
|
|
|
CHECK(f.emu.getTotalTime() == 19);
|
|
|
|
CHECK(f.emu.getWriteOps() == 1);
|
|
|
|
CHECK(f.emu.getWriteBytes() == 4);
|
|
|
|
f.emu.clearStats();
|
|
|
|
CHECK(f.emu.getWriteOps() == 0);
|
|
|
|
CHECK(f.emu.getWriteBytes() == 0);
|
|
|
|
esp_partition_write(&f.esp_part, 0, data, 8);
|
|
|
|
CHECK(f.emu.getTotalTime() == 23);
|
|
|
|
f.emu.clearStats();
|
|
|
|
esp_partition_write(&f.esp_part, 0, data, 16);
|
|
|
|
CHECK(f.emu.getTotalTime() == 35);
|
|
|
|
CHECK(f.emu.getWriteOps() == 1);
|
|
|
|
CHECK(f.emu.getWriteBytes() == 16);
|
|
|
|
f.emu.clearStats();
|
|
|
|
esp_partition_write(&f.esp_part, 0, data, 128);
|
|
|
|
CHECK(f.emu.getTotalTime() == 205);
|
|
|
|
f.emu.clearStats();
|
|
|
|
esp_partition_write(&f.esp_part, 0, data, 256);
|
|
|
|
CHECK(f.emu.getTotalTime() == 417);
|
|
|
|
f.emu.clearStats();
|
|
|
|
esp_partition_write(&f.esp_part, 0, data, (128+256)/2);
|
|
|
|
CHECK(f.emu.getTotalTime() == (205+417)/2);
|
|
|
|
f.emu.clearStats();
|
|
|
|
|
|
|
|
esp_partition_erase_range(&f.esp_part, 0, SPI_FLASH_SEC_SIZE);
|
|
|
|
CHECK(f.emu.getEraseOps() == 1);
|
|
|
|
CHECK(f.emu.getTotalTime() == 37142);
|
2016-08-17 15:08:22 +00:00
|
|
|
}
|
|
|
|
|
2016-10-21 09:28:50 +00:00
|
|
|
TEST_CASE("data is randomized predictably", "[spi_flash_emu]")
|
2016-08-17 15:08:22 +00:00
|
|
|
{
|
|
|
|
SpiFlashEmulator emu1(3);
|
|
|
|
emu1.randomize(0x12345678);
|
2020-04-27 00:51:31 +00:00
|
|
|
|
2016-08-17 15:08:22 +00:00
|
|
|
SpiFlashEmulator emu2(3);
|
|
|
|
emu2.randomize(0x12345678);
|
2020-04-27 00:51:31 +00:00
|
|
|
|
2016-08-17 15:08:22 +00:00
|
|
|
CHECK(std::equal(emu1.bytes(), emu1.bytes() + emu1.size(), emu2.bytes()));
|
|
|
|
}
|