register.h

/*******************************************************************************
 * Copyright 2016-2021 MINRES Technologies GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
 
#ifndef _SYSC_REGISTER_H_
#define _SYSC_REGISTER_H_
 
#include <cstddef>
#include <memory>
 
#include "resetable.h"
#include "resource_access_if.h"
#include "scc/report.h"
#include <cci_configuration>
#include <scc/traceable.h>
#include <scc/tracer_base.h>
#include <scc/utilities.h>
#ifdef _MSC_VER
#include <functional>
#else
#include "util/delegate.h"
#endif
#include <functional>
#include <limits>
#include <sstream>
 
namespace scc {
 
namespace impl {
template <typename T, bool = std::is_integral<T>::value> class helper {};
 
template <typename T> class helper<T, true> {
public:
    using Type = T;
    template <typename Type> constexpr Type get_max_uval() const {
        return std::numeric_limits<Type>::is_signed ? -1 : std::numeric_limits<Type>::max();
    }
};
 
template <typename T> class helper<T, false> {
public:
    using Type = typename T::StorageType;
    template <typename Type> constexpr Type get_max_uval() const {
        return std::numeric_limits<Type>::is_signed ? -1 : std::numeric_limits<Type>::max();
    }
};
 
template <typename Type> constexpr Type get_max_uval() {
    return std::numeric_limits<Type>::is_signed ? -1 : std::numeric_limits<Type>::max();
}

template <typename DATATYPE> class sc_register : public sc_core::sc_object, public resource_access_if, public traceable {
public:
    using this_type = sc_register<DATATYPE>;
 
    cci::cci_param<bool> enable_tracing;
    sc_register(sc_core::sc_module_name nm, DATATYPE& storage, const DATATYPE reset_val, resetable& owner,
                DATATYPE rdmask = get_max_uval<DATATYPE>(), DATATYPE wrmask = get_max_uval<DATATYPE>())
    : sc_core::sc_object(nm)
    , enable_tracing{std::string(name()) + ".enableTracing", scc::tracer_base::get_default_trace_enable(),
                     "enables tracing of this register", cci::CCI_ABSOLUTE_NAME}
    , res_val(reset_val)
    , rdmask(rdmask)
    , wrmask(wrmask)
    , storage(storage) {
        owner.register_resource(this);
    }

    ~sc_register() = default;
    bool is_trace_enabled() const override { return enable_tracing.get_value(); }
    size_t size() const override { return sizeof(DATATYPE); }
    void reset() override {
        DATATYPE r(res_val);
        if(wr_cb) {
            sc_core::sc_time d;
            wr_cb(*this, r, d);
        }
        storage = r;
    }

    bool write(const uint8_t* data, size_t length, uint64_t offset, sc_core::sc_time& d) override {
        SCC_ASSERT("Access out of range" && offset + length <= sizeof(DATATYPE));
        auto temp(storage);
        auto beg = reinterpret_cast<uint8_t*>(&temp) + offset;
        std::copy(data, data + length, beg);
        if(wr_cb)
            return wr_cb(*this, temp, d);
        storage = (temp & wrmask) | (storage & ~wrmask);
        return true;
    }

    bool read(uint8_t* data, size_t length, uint64_t offset, sc_core::sc_time& d) const override {
        SCC_ASSERT("Access out of range" && offset + length <= sizeof(DATATYPE));
        auto temp(storage);
        if(rd_cb) {
            if(!rd_cb(*this, temp, d))
                return false;
        } else
            temp &= rdmask;
        auto beg = reinterpret_cast<uint8_t*>(&temp) + offset;
        std::copy(beg, beg + length, data);
        return true;
    }

    bool write_dbg(const uint8_t* data, size_t length, uint64_t offset = 0) override {
        SCC_ASSERT("Offset out of range" && offset == 0);
        if(length != sizeof(DATATYPE))
            return false;
        storage = *reinterpret_cast<const DATATYPE*>(data);
        return true;
    }

    bool read_dbg(uint8_t* data, size_t length, uint64_t offset = 0) const override {
        SCC_ASSERT("Offset out of range" && offset == 0);
        if(length != sizeof(DATATYPE))
            return false;
        *reinterpret_cast<DATATYPE*>(data) = storage;
        return true;
    }

    operator DATATYPE() const { return storage; }
    DATATYPE get() const { return storage; }
    void put(DATATYPE data) const { storage = data; }
    this_type& operator=(DATATYPE other) {
        storage = other;
        return *this;
    }

    this_type& operator|=(DATATYPE other) {
        storage |= other;
        return *this;
    }

    this_type& operator&=(DATATYPE other) {
        storage &= other;
        return *this;
    }

    void set_read_cb(std::function<bool(const this_type&, DATATYPE&)> read_cb) {
        rd_cb = [read_cb](const this_type& reg, DATATYPE& data, sc_core::sc_time& delay) { return read_cb(reg, data); };
    }

    void set_read_cb(std::function<bool(const this_type&, DATATYPE&, sc_core::sc_time&)> read_cb) { rd_cb = read_cb; }
    void set_write_cb(std::function<bool(this_type&, const DATATYPE&)> write_cb) {
        wr_cb = [write_cb](this_type& reg, DATATYPE& data, sc_core::sc_time& delay) { return write_cb(reg, data); };
    }

    void set_write_cb(std::function<bool(this_type&, const DATATYPE&, sc_core::sc_time&)> write_cb) { wr_cb = write_cb; }
    void trace(sc_core::sc_trace_file* trf) const override { sc_core::sc_trace(trf, storage, this->name()); }
    const DATATYPE res_val;
    const DATATYPE rdmask;
    const DATATYPE wrmask;
 
private:
    const char* kind() const override { return "sc_register"; }
 
    DATATYPE& storage;
    std::function<bool(const this_type&, DATATYPE&, sc_core::sc_time&)> rd_cb;
    std::function<bool(this_type&, DATATYPE&, sc_core::sc_time&)> wr_cb;
 
#ifdef _MSC_VER
    std::function<bool(const this_type&, DATATYPE&, sc_core::sc_time&)> rd_dlgt;
    std::function<bool(this_type&, DATATYPE&, sc_core::sc_time&)> wr_dlgt;
#else
    util::delegate<bool(const this_type&, DATATYPE&, sc_core::sc_time&)> rd_dlgt;
    util::delegate<bool(this_type&, DATATYPE&, sc_core::sc_time&)> wr_dlgt;
#endif
};
} // namespace impl
template <typename DATATYPE> using sc_register = impl::sc_register<typename impl::helper<DATATYPE>::Type>;
template <typename DATATYPE, size_t SIZE, size_t START = 0> class sc_register_indexed : public indexed_resource_access_if {
public:
    using BASE_DATA_TYPE = typename impl::helper<DATATYPE>::Type;
 
    using value_type = sc_register<DATATYPE>;
    using pointer = value_type*;
    sc_register_indexed(
        sc_core::sc_module_name nm, std::array<DATATYPE, SIZE>& storage, const DATATYPE reset_val, resetable& owner,
        BASE_DATA_TYPE rdmask = std::numeric_limits<BASE_DATA_TYPE>::is_signed ? -1 : std::numeric_limits<BASE_DATA_TYPE>::max(),
        BASE_DATA_TYPE wrmask = std::numeric_limits<BASE_DATA_TYPE>::is_signed ? -1 : std::numeric_limits<BASE_DATA_TYPE>::max()) {
 
        _reg_field.init(START + SIZE, [&](const char* name, size_t idx) -> pointer {
            return new sc_register<DATATYPE>(name, storage[idx], reset_val, owner, rdmask, wrmask);
        });
    }

    ~sc_register_indexed() override {}
    size_t size() override { return SIZE; };
    void set_read_cb(std::function<bool(size_t, const sc_register<DATATYPE>&, DATATYPE&)> read_cb) {
        rd_cb = read_cb;
        for(size_t idx = START; idx < SIZE + START; ++idx)
            _reg_field[idx].set_read_cb([this, idx](const sc_register<DATATYPE>& reg, DATATYPE& dt) { return this->rd_cb(idx, reg, dt); });
    }

    void set_read_cb(std::function<bool(size_t, const sc_register<DATATYPE>&, DATATYPE&, sc_core::sc_time&)> read_cb) {
        rd_time_cb = read_cb;
        for(size_t idx = START; idx < SIZE + START; ++idx)
            _reg_field[idx].set_read_cb([this, idx](const sc_register<DATATYPE>& reg, DATATYPE& dt, sc_core::sc_time& delay) {
                return this->rd_time_cb(idx, reg, dt, delay);
            });
    }

    void set_write_cb(std::function<bool(size_t, sc_register<DATATYPE>&, DATATYPE const&)> write_cb) {
        wr_cb = write_cb;
        for(size_t idx = START; idx < SIZE + START; ++idx)
            _reg_field[idx].set_write_cb([this, idx](sc_register<DATATYPE>& reg, const DATATYPE& dt) { return this->wr_cb(idx, reg, dt); });
    }

    void set_write_cb(std::function<bool(size_t, sc_register<DATATYPE>&, DATATYPE const&, sc_core::sc_time&)> write_cb) {
        wr_time_cb = write_cb;
        for(size_t idx = START; idx < SIZE + START; ++idx)
            _reg_field[idx].set_write_cb([this, idx](sc_register<DATATYPE>& reg, const DATATYPE& dt, sc_core::sc_time& delay) {
                return this->wr_time_cb(idx, reg, dt, delay);
            });
    }

    reference operator[](size_t idx) noexcept override { return _reg_field[idx]; }
    const_reference operator[](size_t idx) const noexcept override { return _reg_field[idx]; }
    reference at(size_t idx) override {
        assert("access out of bound" && idx < SIZE);
        return _reg_field[idx];
    }

    const_reference at(size_t idx) const override {
        assert("access out of bound" && idx < SIZE);
        return _reg_field[idx];
    }
 
private:
    sc_core::sc_vector<value_type> _reg_field;
    std::function<bool(size_t, sc_register<DATATYPE>&, DATATYPE const&)> wr_cb;
    std::function<bool(size_t, sc_register<DATATYPE>&, DATATYPE const&, sc_core::sc_time&)> wr_time_cb;
    std::function<bool(size_t, sc_register<DATATYPE> const&, DATATYPE&)> rd_cb;
    std::function<bool(size_t, sc_register<DATATYPE> const&, DATATYPE&, sc_core::sc_time&)> rd_time_cb;
};

template <typename DATATYPE, DATATYPE WRMASK = impl::get_max_uval<DATATYPE>(), DATATYPE RDMASK = impl::get_max_uval<DATATYPE>()>
class sc_register_masked : public sc_register<DATATYPE> {
public:
    sc_register_masked(sc_core::sc_module_name nm, DATATYPE& storage, const DATATYPE reset_val, resetable& owner)
    : sc_register<DATATYPE>(nm, storage, reset_val, owner, RDMASK, WRMASK) {}
};

template <typename DATATYPE, size_t SIZE> struct sc_register_mem : public indexed_resource_access_if {
    using this_type = sc_register_mem<DATATYPE, SIZE>;
    using store_t = DATATYPE;
 
private:
    struct mem_wrapper : public resource_access_if {
        ~mem_wrapper() = default;
        std::size_t size() const override { return sizeof(DATATYPE); };
        void reset() override { elem = 0; };
        bool write(const uint8_t* data, std::size_t length, uint64_t offset, sc_core::sc_time& d) override {
            assert("Access out of range" && offset + length <= sizeof(DATATYPE));
            auto temp(elem);
            auto beg = reinterpret_cast<uint8_t*>(&temp) + offset;
            std::copy(data, data + length, beg);
            if(owner.wr_cb)
                return owner.wr_cb(owner, this->offset + offset, temp, d);
            elem = temp;
            return true;
        };
        bool read(uint8_t* data, std::size_t length, uint64_t offset, sc_core::sc_time& d) const override {
            assert("Access out of range" && offset + length <= sizeof(DATATYPE));
            auto temp(elem);
            if(owner.rd_cb) {
                if(!owner.rd_cb(owner, this->offset + offset, temp, d))
                    return false;
            }
            auto beg = reinterpret_cast<uint8_t*>(&temp) + offset;
            std::copy(beg, beg + length, data);
            return true;
        };
        bool write_dbg(const uint8_t* data, std::size_t length, uint64_t offset = 0) override {
            assert("Offset out of range" && offset == 0);
            if(length != sizeof(DATATYPE))
                return false;
            elem = *reinterpret_cast<const DATATYPE*>(data);
            return true;
        };
        bool read_dbg(uint8_t* data, std::size_t length, uint64_t offset = 0) const override {
            assert("Offset out of range" && offset == 0);
            if(length != sizeof(DATATYPE))
                return false;
            *reinterpret_cast<DATATYPE*>(data) = elem;
            return true;
        };
 
        mem_wrapper(sc_register_mem& owner, DATATYPE& e, size_t of)
        : owner(owner)
        , elem{e}
        , offset(of) {}
 
        sc_register_mem& owner;
        DATATYPE& elem;
        size_t offset;
    };
 
public:
    sc_register_mem(sc_core::sc_module_name nm, std::array<DATATYPE, SIZE>& storage, const DATATYPE reset_val, resetable& owner) {
        _reg_field.init(SIZE,
                        [this, &storage](const char* name, size_t idx) -> pointer { return new mem_wrapper(*this, storage[idx], idx); });
    }

    ~sc_register_mem() override {}
    size_t size() override { return SIZE; };
    reference operator[](size_t idx) noexcept override { return _reg_field[idx]; }
    const_reference operator[](size_t idx) const noexcept override { return _reg_field[idx]; }
    reference at(size_t idx) override {
        assert("access out of bound" && idx < SIZE);
        return _reg_field[idx];
    }

    const_reference const at(size_t idx) const override {
        assert("access out of bound" && idx < SIZE);
        return _reg_field[idx];
    }

    void set_read_cb(std::function<bool(const this_type&, size_t offset, DATATYPE&, sc_core::sc_time&)> read_cb) { rd_cb = read_cb; }
    void set_write_cb(std::function<bool(this_type&, size_t offset, const DATATYPE&, sc_core::sc_time&)> write_cb) { wr_cb = write_cb; }
 
private:
    sc_core::sc_vector<value_type> _reg_field;
    std::function<bool(const this_type&, size_t offset, DATATYPE&, sc_core::sc_time&)> rd_cb;
    std::function<bool(this_type&, size_t offset, DATATYPE&, sc_core::sc_time&)> wr_cb;
};
} // namespace scc
 
#endif /* _SYSC_REGISTER_H_ */