EEPROMEmulation.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_COMMON_EEPROMEMULATION_HXX_
#define _FREERTOS_DRIVERS_COMMON_EEPROMEMULATION_HXX_
 
#include "EEPROM.hxx"
 
extern const char __eeprom_start;
extern const char __eeprom_end;
 
class EEPROMEmulation : public EEPROM
{
protected:
    EEPROMEmulation(const char *name, size_t file_size);
 
    ~EEPROMEmulation()
    {
    }
 
    void mount();
 
    static const size_t SECTOR_SIZE;
 
    static const size_t BLOCK_SIZE;
 
    static constexpr unsigned MAX_BLOCK_SIZE = 16;
 
private:
    void updated_notification();
 
    void write(unsigned int offset, const void *buf, size_t len) OVERRIDE;
 
    void read(unsigned int offset, void *buf, size_t len) OVERRIDE;
 
    #define EEPROMEMU_FLASH_SIZE ((uintptr_t)(&__eeprom_end - &__eeprom_start))
    
    static const size_t BYTES_PER_BLOCK;
 
    static const size_t HEADER_BLOCK_COUNT;
 
    static const bool SHADOW_IN_RAM;
 
protected:
    static const uint32_t MAGIC_INTACT;
 
    static const uint32_t MAGIC_DIRTY;
 
    static const uint32_t MAGIC_USED;
 
    static const uint32_t MAGIC_ERASED;
 
    enum MagicBlockIndex
    {
         MAGIC_FIRST_INDEX = 0, 
         MAGIC_DIRTY_INDEX = 0,
         MAGIC_INTACT_INDEX,
         MAGIC_USED_INDEX,
         MAGIC_COUNT 
    };
 
private:
    void write_fblock(unsigned int index, const uint8_t data[]);
 
    bool read_fblock(unsigned int index, uint8_t data[]);
 
    unsigned next_active()
    {
        unsigned next = activeSector_ + 1;
        if (next >= sectorCount_) next = 0;
        return next;
    }
 
    unsigned sector_count()
    {
        return sectorCount_;
    }
 
    unsigned slot_count()
    {
        return rawBlockCount_ - MAGIC_COUNT;
    }
 
    unsigned slot_last()
    {
        return rawBlockCount_ - 1;
    }
 
    unsigned slot_first()
    {
        return MAGIC_COUNT;
    }
 
    virtual const uint32_t* block(unsigned sector, unsigned offset) = 0;
 
    virtual void flash_erase(unsigned sector) = 0;
 
    virtual void flash_program(unsigned sector, unsigned start_block, uint32_t *data, uint32_t byte_count) = 0;
 
protected:
    const uint8_t sectorCount_{(uint8_t)(EEPROMEMU_FLASH_SIZE / SECTOR_SIZE)};
 
    uint8_t activeSector_{0};
 
    const uint16_t rawBlockCount_{(uint16_t)(SECTOR_SIZE / BLOCK_SIZE)};
 
    size_t availableSlots_{0};
 
    bool shadowInRam_{false};
 
    uint8_t *shadow_{nullptr};
 
 
    EEPROMEmulation();
 
    DISALLOW_COPY_AND_ASSIGN(EEPROMEmulation);
};
 
#endif /* _FREERTOS_DRIVERS_COMMON_EEPROMEMULATION_HXX_ */