flash_io.hpp

 
  void ReadFlashOrExit(size_t offset, RawData data)
  {
    REQUIRE(flash_.Read(offset, data) == ErrorCode::OK);
  }
 
  template <typename Data>
  void ReadFlashOrExit(size_t offset, Data& data)
  {
    ReadFlashOrExit(offset, RawData(data));
  }
 
  void WriteFlashOrExit(size_t offset, ConstRawData data)
  {
    REQUIRE(Write(offset, data) == 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)
  {
    REQUIRE(flash_.Erase(offset, size) == 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});
    }
  }