sim_memory.h

Go to the documentation of this file.

/*
 * sim_memory.h
 *
 *  Copyright 2022-2026 Clement Savergne <csavergne@yahoo.com>
 
    This file is part of yasim-avr.
 
    yasim-avr is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    yasim-avr is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with yasim-avr.  If not, see <http://www.gnu.org/licenses/>.
 */
 
//=======================================================================================
 
#ifndef __YASIMAVR_MEMORY_H__
#define __YASIMAVR_MEMORY_H__
 
#include "sim_types.h"
#include "sim_signal.h"
 
YASIMAVR_BEGIN_NAMESPACE
 
//=======================================================================================
 
class AVR_CORE_PUBLIC_API NonVolatileMemory {
 
public:
 
    explicit NonVolatileMemory(size_t size);
    NonVolatileMemory(const NonVolatileMemory& other);
    ~NonVolatileMemory();
 
    size_t size() const;
 
    bool programmed(size_t pos) const;
    bytes_view_t programmed(size_t base, size_t len) const;
 
    unsigned char operator[](size_t pos) const;
 
    bytes_view_t view() const;
    bytes_view_t view(size_t base, size_t len) const;
 
    bool program(const bytes_view_t& mem_block, size_t base = 0);
 
    void erase();
    void erase(size_t base, size_t size);
    void erase(const bytes_view_t& buf, size_t base);
 
    int read(size_t pos) const;
    size_t readinto(unsigned char* buf, size_t base, size_t len) const;
    void write(unsigned char v, size_t pos);
    void write(const bytes_view_t& buf, size_t base);
 
    void spm_write(unsigned char v, size_t pos);
    void spm_write(const bytes_view_t& buf, const bytes_view_t& bufset, size_t base);
 
    NonVolatileMemory& operator=(const NonVolatileMemory& other);
 
private:
 
    size_t m_size;
    unsigned char* m_memory;
    unsigned char* m_tag;
 
};
 
inline size_t NonVolatileMemory::size() const
{
    return m_size;
}
 
inline bool NonVolatileMemory::programmed(size_t pos) const
{
    return m_tag[pos];
}
 
inline uint8_t NonVolatileMemory::operator[](size_t pos) const
{
    return m_memory[pos];
}
 
 
//=======================================================================================
 
class AVR_CORE_PUBLIC_API MemorySectionManager {
 
public:
 
    enum AccessFlag {
        Access_Read = 0x01,
        Access_Write = 0x02,
    };
 
    enum SignalId {
        Signal_Leave,
        Signal_Enter,
    };
 
    MemorySectionManager(flash_addr_t page_count, flash_addr_t page_size, unsigned int section_count);
 
    flash_addr_t page_count() const;
    flash_addr_t page_size() const;
    unsigned int section_count() const;
 
    unsigned int current_section() const;
 
    //Management of section boundaries
    void set_section_limits(const std::vector<flash_addr_t>& limits);
    flash_addr_t section_start(unsigned int section) const;
    flash_addr_t section_end(unsigned int section) const;
    flash_addr_t section_size(unsigned int section) const;
 
    //Conversion page/address to section
    unsigned int page_to_section(flash_addr_t page) const;
    unsigned int address_to_section(flash_addr_t addr) const;
 
    //Access control flags management
    void set_access_flags(unsigned int src, unsigned int dst, uint8_t flags);
    void set_access_flags(unsigned int section, uint8_t flags);
    uint8_t access_flags(unsigned int section_src, unsigned int section_dst) const;
    uint8_t access_flags(unsigned int section) const;
    bool can_read(flash_addr_t addr) const;
    bool can_write(flash_addr_t addr) const;
    uint8_t address_access_flags(flash_addr_t addr) const;
 
    //Address fetch management (setting the current section)
    void set_fetch_allowed(unsigned int section, bool allowed);
    bool fetch_address(flash_addr_t addr);
 
    Signal& signal();
 
private:
 
    static const uint8_t ACCESS_FLAGS_MASK = 0x3F;
    static const uint8_t FETCH_ALLOWED     = 0x40;
    static const uint8_t CURRENT_SECTION   = 0x80;
 
    flash_addr_t m_page_count;
    flash_addr_t m_page_size;
    unsigned int m_section_count;
    unsigned int m_current_section;
    std::vector<flash_addr_t> m_limits;
    std::vector<uint8_t> m_flags;
    std::vector<uint8_t> m_pages;
    Signal m_signal;
 
    void update_current_section(flash_addr_t src);
    void invalidate_page_access_map();
 
};
 
inline flash_addr_t MemorySectionManager::page_count() const
{
    return m_page_count;
}
 
inline flash_addr_t MemorySectionManager::page_size() const
{
    return m_page_size;
}
 
inline unsigned int MemorySectionManager::section_count() const
{
    return m_section_count;
}
 
inline unsigned int MemorySectionManager::current_section() const
{
    return m_current_section;
}
 
inline flash_addr_t MemorySectionManager::section_start(unsigned int index) const
{
    return m_limits[index];
}
 
inline flash_addr_t MemorySectionManager::section_end(unsigned int index) const
{
    if (m_limits[index] < m_page_count)
        return m_limits[index + 1] - 1;
    else
        return m_page_count;
}
 
inline flash_addr_t MemorySectionManager::section_size(unsigned int index) const
{
    return m_limits[index + 1] - m_limits[index];
}
 
inline unsigned int MemorySectionManager::address_to_section(flash_addr_t addr) const
{
    return page_to_section(addr / m_page_size);
}
 
inline uint8_t MemorySectionManager::access_flags(unsigned int section_src, unsigned int section_dst) const
{
    return m_flags[section_src * m_section_count + section_dst] & ACCESS_FLAGS_MASK;
}
 
inline uint8_t MemorySectionManager::access_flags(unsigned int section) const
{
    return m_flags[section * (m_section_count + 1)] & ACCESS_FLAGS_MASK;
}
 
inline bool MemorySectionManager::can_read(flash_addr_t addr) const
{
    return m_pages[addr / m_page_size] & Access_Read;
}
 
inline bool MemorySectionManager::can_write(flash_addr_t addr) const
{
    return m_pages[addr / m_page_size] & Access_Write;
}
 
inline uint8_t MemorySectionManager::address_access_flags(flash_addr_t addr) const
{
    return m_pages[addr / m_page_size] & ACCESS_FLAGS_MASK;
}
 
inline Signal& MemorySectionManager::signal()
{
    return m_signal;
}
 
 
YASIMAVR_END_NAMESPACE
 
#endif //__YASIMAVR_MEMORY_H__