flash_io.hpp

 
void ReadFlashOrExit(size_t offset, RawData data)
{
  [[maybe_unused]] const auto flash_io_result = flash_.Read(offset, data);
  REQUIRE(flash_io_result == ErrorCode::OK);
}
 
template <typename Data>
void ReadFlashOrExit(size_t offset, Data& data)
{
  ReadFlashOrExit(offset, RawData(data));
}
 
void WriteFlashOrExit(size_t offset, ConstRawData data)
{
  [[maybe_unused]] const auto flash_io_result = Write(offset, data);
  REQUIRE(flash_io_result == ErrorCode::OK);
}
 
template <typename Data>
void WriteFlashOrExit(size_t offset, const Data& data)
{
  WriteFlashOrExit(offset, ConstRawData(data));
}
 
void EraseFlashOrExit(size_t offset, size_t size)
{
  [[maybe_unused]] const auto flash_io_result = flash_.Erase(offset, size);
  REQUIRE(flash_io_result == ErrorCode::OK);
}
 
void CopyFlashData(size_t dst_offset, size_t src_offset, size_t size)
{
  for (size_t i = 0; i < size; i += MinWriteSize)
  {
    ReadFlashOrExit(src_offset + i, {write_buffer_, MinWriteSize});
    WriteFlashOrExit(dst_offset + i, {write_buffer_, MinWriteSize});
  }
}
 
size_t AlignSize(size_t size)
{
  return static_cast<size_t>((size + MinWriteSize - 1) / MinWriteSize) * MinWriteSize;
}
 
ErrorCode Write(size_t offset, ConstRawData data)
{
  if (data.size_ == 0)
  {
    return ErrorCode::OK;
  }
 
  if (data.size_ % MinWriteSize == 0)
  {
    return flash_.Write(offset, data);
  }
  else
  {
    auto final_block_index = data.size_ - data.size_ % MinWriteSize;
    if (final_block_index != 0)
    {
      auto ec = flash_.Write(offset, {data.addr_, final_block_index});
      if (ec != ErrorCode::OK)
      {
        return ec;
      }
    }
    Memory::FastSet(write_buffer_, 0xff, MinWriteSize);
    LibXR::Memory::FastCopy(
        write_buffer_, reinterpret_cast<const uint8_t*>(data.addr_) + final_block_index,
        data.size_ % MinWriteSize);
    return flash_.Write(offset + final_block_index, {write_buffer_, MinWriteSize});
  }
}