layout.hpp

 
enum class BlockType : uint8_t
{
  MAIN = 0,   
  BACKUP = 1  
};
 
LIBXR_PACKED_BEGIN
template <size_t BlockSize>
struct BlockBoolData
{
  uint8_t data[BlockSize];
};
LIBXR_PACKED_END
 
template <size_t BlockSize>
class BlockBoolUtil
{
 public:
  static void SetFlag(BlockBoolData<BlockSize>& obj, bool value)
  {
    Memory::FastSet(obj.data, 0xFF, BlockSize);
    if (!value)
    {
      obj.data[BlockSize - 1] &= 0xF0;
    }
  }
 
  static bool ReadFlag(const BlockBoolData<BlockSize>& obj)
  {
    uint8_t last_4bits = obj.data[BlockSize - 1] & 0x0F;
    return last_4bits == 0x0F;
  }
 
  static bool Valid(const BlockBoolData<BlockSize>& obj)
  {
    if (BlockSize == 0)
    {
      return false;
    }
 
    for (size_t i = 0; i < BlockSize - 1; ++i)
    {
      if (obj.data[i] != 0xFF)
      {
        return false;
      }
    }
 
    uint8_t last_byte = obj.data[BlockSize - 1];
    if ((last_byte & 0xF0) != 0xF0)
    {
      return false;
    }
 
    uint8_t last_4bits = last_byte & 0x0F;
    if (!(last_4bits == 0x0F || last_4bits == 0x00))
    {
      return false;
    }
 
    return true;
  }
};
 
LIBXR_PACKED_BEGIN
struct KeyInfo
{
  BlockBoolData<MinWriteSize> no_next_key;     
  BlockBoolData<MinWriteSize> available_flag;  
  BlockBoolData<MinWriteSize> uninit;          
 
  uint32_t raw_info =
      0;  
 
  KeyInfo()
  {
    BlockBoolUtil<MinWriteSize>::SetFlag(no_next_key, true);
    BlockBoolUtil<MinWriteSize>::SetFlag(available_flag, true);
    BlockBoolUtil<MinWriteSize>::SetFlag(uninit, true);
  }
 
  void SetNameLength(uint8_t len)
  {
    raw_info = (raw_info & 0x01FFFFFF) | ((len & 0x7F) << 25);
  }
 
  uint8_t GetNameLength() const { return (raw_info >> 25) & 0x7F; }
 
  void SetDataSize(uint32_t size)
  {
    raw_info = (raw_info & 0xFE000000) | (size & 0x01FFFFFF);
  }
 
  uint32_t GetDataSize() const { return raw_info & 0x01FFFFFF; }
};
LIBXR_PACKED_END
 
LIBXR_PACKED_BEGIN
struct FlashInfo
{
  FlashInfo()
  {
    header = 0xFFFFFFFF;
    Memory::FastSet(padding, 0xFF, MinWriteSize);
  }
 
  union
  {
    uint32_t header;                
    uint8_t padding[MinWriteSize];  
  };
  KeyInfo key;  
};
LIBXR_PACKED_END