Ideally suited for generating a binary externally, containing key-value pairs specific to device manufacturers. Utility allows creation of a binary, compatible with NVS structure, which can be separately flashed onto a new partition. This helps device manufacturers set different values for different devices, e.g. serial numbers, but using a single firmaware image.
242 lines
6.3 KiB
C++
242 lines
6.3 KiB
C++
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
#ifndef spi_flash_emulation_h
|
|
#define spi_flash_emulation_h
|
|
|
|
#include <vector>
|
|
#include <cassert>
|
|
#include <algorithm>
|
|
#include <random>
|
|
#include "esp_spi_flash.h"
|
|
#include "catch.hpp"
|
|
|
|
using std::copy;
|
|
using std::begin;
|
|
using std::end;
|
|
using std::fill_n;
|
|
|
|
class SpiFlashEmulator;
|
|
|
|
void spi_flash_emulator_set(SpiFlashEmulator*);
|
|
|
|
class SpiFlashEmulator
|
|
{
|
|
public:
|
|
SpiFlashEmulator(size_t sectorCount) : mUpperSectorBound(sectorCount)
|
|
{
|
|
mData.resize(sectorCount * SPI_FLASH_SEC_SIZE / 4, 0xffffffff);
|
|
spi_flash_emulator_set(this);
|
|
}
|
|
|
|
SpiFlashEmulator(const char *filename)
|
|
{
|
|
load(filename);
|
|
// Atleast one page should be free, hence we create mData of size of 2 sectors.
|
|
mData.resize(2 * SPI_FLASH_SEC_SIZE / 4, 0xffffffff);
|
|
spi_flash_emulator_set(this);
|
|
}
|
|
|
|
~SpiFlashEmulator()
|
|
{
|
|
spi_flash_emulator_set(nullptr);
|
|
}
|
|
|
|
bool read(uint32_t* dest, size_t srcAddr, size_t size) const
|
|
{
|
|
if (srcAddr % 4 != 0 ||
|
|
size % 4 != 0 ||
|
|
srcAddr + size > mData.size() * 4) {
|
|
return false;
|
|
}
|
|
|
|
copy(begin(mData) + srcAddr / 4, begin(mData) + (srcAddr + size) / 4, dest);
|
|
|
|
++mReadOps;
|
|
mReadBytes += size;
|
|
mTotalTime += getReadOpTime(static_cast<uint32_t>(size));
|
|
return true;
|
|
}
|
|
|
|
bool write(size_t dstAddr, const uint32_t* src, size_t size)
|
|
{
|
|
uint32_t sectorNumber = dstAddr/SPI_FLASH_SEC_SIZE;
|
|
if (sectorNumber < mLowerSectorBound || sectorNumber >= mUpperSectorBound) {
|
|
WARN("invalid flash operation detected: erase sector=" << sectorNumber);
|
|
return false;
|
|
}
|
|
|
|
if (dstAddr % 4 != 0 ||
|
|
size % 4 != 0 ||
|
|
dstAddr + size > mData.size() * 4) {
|
|
return false;
|
|
}
|
|
|
|
for (size_t i = 0; i < size / 4; ++i) {
|
|
if (mFailCountdown != SIZE_MAX && mFailCountdown-- == 0) {
|
|
return false;
|
|
}
|
|
|
|
uint32_t sv = src[i];
|
|
size_t pos = dstAddr / 4 + i;
|
|
uint32_t& dv = mData[pos];
|
|
|
|
if (((~dv) & sv) != 0) { // are we trying to set some 0 bits to 1?
|
|
WARN("invalid flash operation detected: dst=" << dstAddr << " size=" << size << " i=" << i);
|
|
return false;
|
|
}
|
|
|
|
dv = sv;
|
|
}
|
|
++mWriteOps;
|
|
mWriteBytes += size;
|
|
mTotalTime += getWriteOpTime(static_cast<uint32_t>(size));
|
|
return true;
|
|
}
|
|
|
|
bool erase(size_t sectorNumber)
|
|
{
|
|
size_t offset = sectorNumber * SPI_FLASH_SEC_SIZE / 4;
|
|
if (offset > mData.size()) {
|
|
return false;
|
|
}
|
|
|
|
if (sectorNumber < mLowerSectorBound || sectorNumber >= mUpperSectorBound) {
|
|
WARN("invalid flash operation detected: erase sector=" << sectorNumber);
|
|
return false;
|
|
}
|
|
|
|
if (mFailCountdown != SIZE_MAX && mFailCountdown-- == 0) {
|
|
return false;
|
|
}
|
|
|
|
std::fill_n(begin(mData) + offset, SPI_FLASH_SEC_SIZE / 4, 0xffffffff);
|
|
|
|
++mEraseOps;
|
|
mTotalTime += getEraseOpTime();
|
|
return true;
|
|
}
|
|
|
|
void randomize(uint32_t seed)
|
|
{
|
|
std::random_device rd;
|
|
std::mt19937 gen(rd());
|
|
gen.seed(seed);
|
|
std::generate_n(mData.data(), mData.size(), gen);
|
|
}
|
|
|
|
size_t size() const
|
|
{
|
|
return mData.size() * 4;
|
|
}
|
|
|
|
const uint32_t* words() const
|
|
{
|
|
return mData.data();
|
|
}
|
|
|
|
const uint8_t* bytes() const
|
|
{
|
|
return reinterpret_cast<const uint8_t*>(mData.data());
|
|
}
|
|
|
|
void load(const char* filename)
|
|
{
|
|
FILE* f = fopen(filename, "rb");
|
|
fseek(f, 0, SEEK_END);
|
|
off_t size = ftell(f);
|
|
assert(size % SPI_FLASH_SEC_SIZE == 0);
|
|
mData.resize(size / sizeof(uint32_t));
|
|
fseek(f, 0, SEEK_SET);
|
|
auto s = fread(mData.data(), SPI_FLASH_SEC_SIZE, size / SPI_FLASH_SEC_SIZE, f);
|
|
assert(s == static_cast<size_t>(size / SPI_FLASH_SEC_SIZE));
|
|
fclose(f);
|
|
}
|
|
|
|
void save(const char* filename)
|
|
{
|
|
FILE* f = fopen(filename, "wb");
|
|
auto n_sectors = mData.size() * sizeof(uint32_t) / SPI_FLASH_SEC_SIZE;
|
|
auto s = fwrite(mData.data(), SPI_FLASH_SEC_SIZE, n_sectors, f);
|
|
assert(s == n_sectors);
|
|
fclose(f);
|
|
}
|
|
|
|
void clearStats()
|
|
{
|
|
mReadBytes = 0;
|
|
mWriteBytes = 0;
|
|
mEraseOps = 0;
|
|
mReadOps = 0;
|
|
mWriteOps = 0;
|
|
mTotalTime = 0;
|
|
}
|
|
|
|
size_t getReadOps() const
|
|
{
|
|
return mReadOps;
|
|
}
|
|
size_t getWriteOps() const
|
|
{
|
|
return mWriteOps;
|
|
}
|
|
size_t getEraseOps() const
|
|
{
|
|
return mEraseOps;
|
|
}
|
|
size_t getReadBytes() const
|
|
{
|
|
return mReadBytes;
|
|
}
|
|
size_t getWriteBytes() const
|
|
{
|
|
return mWriteBytes;
|
|
}
|
|
size_t getTotalTime() const
|
|
{
|
|
return mTotalTime;
|
|
}
|
|
|
|
void setBounds(uint32_t lowerSector, uint32_t upperSector) {
|
|
mLowerSectorBound = lowerSector;
|
|
mUpperSectorBound = upperSector;
|
|
}
|
|
|
|
void failAfter(uint32_t count) {
|
|
mFailCountdown = count;
|
|
}
|
|
|
|
protected:
|
|
static size_t getReadOpTime(uint32_t bytes);
|
|
static size_t getWriteOpTime(uint32_t bytes);
|
|
static size_t getEraseOpTime();
|
|
|
|
|
|
std::vector<uint32_t> mData;
|
|
|
|
mutable size_t mReadOps = 0;
|
|
mutable size_t mWriteOps = 0;
|
|
mutable size_t mReadBytes = 0;
|
|
mutable size_t mWriteBytes = 0;
|
|
mutable size_t mEraseOps = 0;
|
|
mutable size_t mTotalTime = 0;
|
|
size_t mLowerSectorBound = 0;
|
|
size_t mUpperSectorBound = 0;
|
|
|
|
size_t mFailCountdown = SIZE_MAX;
|
|
|
|
};
|
|
|
|
|
|
|
|
#endif /* spi_flash_emulation_h */
|