DMIBlockingMemoryIF.hpp

 
#pragma once
 
#include <string.h>
#include "sparta/memory/BlockingMemoryIF.hpp"
 
namespace sparta {
    namespace memory {
 
        class DMIBlockingMemoryIF final : public BlockingMemoryIF
        {
        public:
            DMIBlockingMemoryIF(void * raw_pointer,
                                addr_t start_addr,
                                addr_t size) :
                BlockingMemoryIF("DMI", size, {start_addr, start_addr + size}),
                start_addr_(start_addr),
                raw_pointer_(raw_pointer)
            { }
 
            void * getRawDataPtr() {
                sparta_assert(isValid(), "This DMI pointer is invalid " << this);
                return raw_pointer_;
            }
 
            bool isValid() const { return valid_; }
 
            void clearValid() { valid_ = false; }
 
            bool tryRead(addr_t addr,
                         addr_t size,
                         uint8_t *buf,
                         const void *in_supplement=nullptr,
                         void *out_supplement=nullptr) override final
            {
                if(false == isValid()) { return false; }
                return BlockingMemoryIF::tryRead(addr, size, buf, in_supplement, out_supplement);
            }
 
            bool tryWrite(addr_t addr,
                          addr_t size,
                          const uint8_t *buf,
                          const void *in_supplement=nullptr,
                          void *out_supplement=nullptr) override final
            {
                if(false == isValid()) { return false; }
                return BlockingMemoryIF::tryWrite(addr, size, buf, in_supplement, out_supplement);
            }
 
        private:
 
            DMIBlockingMemoryIF * getDMI(addr_t, addr_t) override final {
                sparta_assert(false, "You cannot get a DMI interface from a DMI interface!");
                return nullptr;
            }
 
            void *computeHostAddress_(const addr_t addr) const
            {
                return (uint8_t *)raw_pointer_ + (addr - start_addr_);
            }
 
            // When this method is called, access windowing is alraedy
            // checked as well as address spanning
            bool tryRead_(addr_t addr,
                          addr_t size,
                          uint8_t *buf,
                          const void *,
                          void *) noexcept override
            {
                ::memcpy(buf, computeHostAddress_(addr), size);
                return true;
            }
 
            // When this method is called, access windowing is alraedy
            // checked as well as address spanning
            bool tryWrite_(addr_t addr,
                           addr_t size,
                           const uint8_t *buf,
                           const void *,
                           void *) noexcept override
            {
                ::memcpy(computeHostAddress_(addr), buf, size);
                return true;
            }
 
            // When this method is called, access windowing is alraedy
            // checked as well as address spanning
            bool tryPeek_(addr_t addr, addr_t size, uint8_t *buf) const noexcept override
            {
                ::memcpy(buf, computeHostAddress_(addr), size);
                return true;
            }
 
            // When this method is called, access windowing is alraedy
            // checked as well as address spanning
            bool tryPoke_(addr_t addr, addr_t size, const uint8_t *buf) noexcept override
            {
                ::memcpy(computeHostAddress_(addr), buf, size);
                return true;
            }
 
            addr_t start_addr_;
            void * raw_pointer_ = nullptr;
            bool valid_ = true;
        };
 
    } // namespace memory
} // namespace sparta