tlm_target_bfs_register_base.h

/*******************************************************************************
 * Copyright 2021, 2021 Chair of Electronic Design Automation, TU Munich
 *
 * 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 __SCC_TLM_TARGET_BFS_REGISTER_BASE_H__
#define __SCC_TLM_TARGET_BFS_REGISTER_BASE_H__
 
#include <algorithm>
#include <cstddef>
#include <functional>
#include <string>
#include <vector>
 
#include <boost/preprocessor/arithmetic/add.hpp>
#include <boost/preprocessor/arithmetic/mul.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/facilities/overload.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
 
#include "resetable.h"
#include "resource_access_if.h"
#include "sysc/kernel/sc_module_name.h"
#include "sysc/kernel/sc_object.h"
#include "tlm_target.h"
 
#define ID_SCC_TLM_TARGET_BFS_REGISTER_BASE "scc: tlm target bitfield support register base"
 
namespace scc {

template <typename datatype_t> class abstract_bitfield {
public:
    abstract_bitfield(std::string name, size_t bitOffset, size_t bitSize, std::string urid)
    : bitOffset{bitOffset}
    , bitSize{bitSize}
    , name{std::move(name)}
    , urid{std::move(urid)} {}
 
    virtual void write(datatype_t& valueToWrite) = 0;
    virtual datatype_t read() = 0;
    virtual ~abstract_bitfield() = default;
 
    constexpr bool affected(size_t byteOffset, size_t byteLength) const noexcept {
        return (byteOffset * 8 < bitOffset + bitSize) && (bitOffset < (byteOffset + byteLength) * 8);
    }
 
    constexpr datatype_t mask() const noexcept { return ((1ULL << bitSize) - 1) << bitOffset; }
 
    const size_t bitOffset;
    const size_t bitSize;
    const std::string name;
    const std::string urid;
};

template <typename datatype_t> class bitfield_register : public sc_core::sc_object, public scc::resource_access_if {
public:
    bitfield_register(sc_core::sc_module_name name, size_t offset, datatype_t resetValue = 0, datatype_t writeMask = -1,
                      datatype_t readMask = -1)
    : sc_core::sc_object{name}
    , offset{offset}
    , resetValue{resetValue}
    , writeMask{writeMask}
    , readMask{readMask} {}

    constexpr size_t size() const noexcept override { return sizeof(datatype_t); }
 
    void reset() override { storage = resetValue; }
 
    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 <= this->size());
        auto valueToWrite{storage};
        std::copy(data, data + length, reinterpret_cast<uint8_t*>(&valueToWrite) + offset);
        for(auto&& bitfield : bitfields) {
            if(bitfield.get().affected(offset, length)) {
                auto mask = bitfield.get().mask();
                auto bits = (valueToWrite & mask) >> bitfield.get().bitOffset;
                bitfield.get().write(bits);
                valueToWrite = (valueToWrite & ~mask) | ((bits << bitfield.get().bitOffset) & mask);
            }
        }
        if(writeCallback)
            writeCallback(*this, valueToWrite);
        storage = (valueToWrite & writeMask) | (storage & ~writeMask);
        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 <= this->size());
        auto result{storage};
        result &= readMask;
        for(auto&& bitfield : bitfields) {
            if(bitfield.get().affected(offset, length)) {
                auto bitfieldValue = bitfield.get().read();
                auto mask = bitfield.get().mask();
                result = (result & ~mask) | ((bitfieldValue << bitfield.get().bitOffset) & mask);
            }
        }
        if(readCallback)
            readCallback(*this, result);
        auto begin = reinterpret_cast<const uint8_t*>(&result) + offset;
        std::copy(begin, begin + 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 != this->size())
            return false;
        std::copy(data, data + length, reinterpret_cast<uint8_t*>(&storage));
        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 != this->size())
            return false;
        auto storagePtr = reinterpret_cast<const uint8_t*>(&storage);
        std::copy(storagePtr, storagePtr + length, data);
        return true;
    }

    constexpr datatype_t get() const { return storage; }
    void put(datatype_t value) { storage = value; }
 
    void registerBitfield(abstract_bitfield<datatype_t>& bitfield) { bitfields.push_back(bitfield); }

    constexpr operator datatype_t() const { return storage; }
    bitfield_register<datatype_t>& operator=(datatype_t other) {
        storage = other;
        return *this;
    }

    void setWriteCallback(std::function<void(bitfield_register<datatype_t>&, datatype_t& valueToWrite)> callback) {
        writeCallback = std::move(callback);
    }

    void setReadCallback(std::function<void(const bitfield_register<datatype_t>&, datatype_t& result)> callback) {
        readCallback = std::move(callback);
    }
 
    const size_t offset;
 
protected:
    const datatype_t resetValue;
    const datatype_t writeMask;
    const datatype_t readMask;
    datatype_t storage;
 
    std::function<void(bitfield_register<datatype_t>&, datatype_t&)> writeCallback;
    std::function<void(const bitfield_register<datatype_t>&, datatype_t&)> readCallback;
    std::vector<std::reference_wrapper<abstract_bitfield<datatype_t>>> bitfields;
};
 
template <typename datatype_t> class bitfield : public abstract_bitfield<datatype_t> {
public:
    enum Access { RW, ReadOnly };
    using abstract_bitfield<datatype_t>::mask;
    using abstract_bitfield<datatype_t>::bitOffset;

    // constexpr //TODO: requires c++14
    bitfield(bitfield_register<datatype_t>& reg, std::string name, size_t bitOffset, size_t bitSize, std::string urid, Access access = RW)
    : reg{reg}
    , abstract_bitfield<datatype_t>{std::move(name), bitOffset, bitSize, std::move(urid)}
    , access{access} {
        reg.registerBitfield(*this);
    }
    bitfield(const bitfield&) = delete;
    bitfield& operator=(const bitfield&) = delete;
 
    void write(datatype_t& valueToWrite) override {
        if(writeCallback)
            writeCallback(*this, valueToWrite);
        if(access == ReadOnly)
            valueToWrite = get();
    }
    datatype_t read() override {
        if(readCallback)
            return readCallback(*this);
        else
            return get();
    }

    constexpr datatype_t get() const { return (reg.get() & mask()) >> bitOffset; }
    void put(datatype_t value) { reg.put((reg.get() & ~mask()) | ((value << bitOffset) & mask())); }

    constexpr operator datatype_t() const { return get(); }
    bitfield<datatype_t>& operator=(datatype_t other) {
        put(other);
        return *this;
    }

    void setWriteCallback(std::function<void(bitfield<datatype_t>&, datatype_t& valueToWrite)> callback) {
        writeCallback = std::move(callback);
    }

    void setReadCallback(std::function<datatype_t(const bitfield<datatype_t>&)> callback) { readCallback = std::move(callback); }
 
    bitfield_register<datatype_t>& reg;
    Access access;
 
protected:
    std::function<void(bitfield<datatype_t>&, datatype_t&)> writeCallback;
    std::function<datatype_t(const bitfield<datatype_t>&)> readCallback;
};

template <typename derived_t, bool use_URID = false> class tlm_target_bfs_register_base : public sc_core::sc_object, public scc::resetable {
public:
    tlm_target_bfs_register_base(sc_core::sc_module_name name)
    : sc_core::sc_object{name} {}
 
    template <unsigned buswidth> void registerResources(scc::tlm_target<buswidth>& target) {
        for(auto&& reg : asDerived().registers) {
            target.addResource(reg, reg.offset);
            this->register_resource(&reg);
        }
    }

    bitfield_register<uint32_t>& getRegister(const std::string& name) {
        auto found = std::find_if(asDerived().registers.begin(), asDerived().registers.end(),
                                  [name](const bitfield_register<uint32_t>& reg) { return name.compare(reg.basename()) == 0; });
        if(found == asDerived().registers.end()) {
            SC_REPORT_FATAL(ID_SCC_TLM_TARGET_BFS_REGISTER_BASE, ("Register " + name + " not found").c_str());
        }
        return *found;
    }

    bitfield<uint32_t>& getBitfieldByName(const std::string& regname, const std::string& name) {
        auto found =
            std::find_if(asDerived().bitfields.begin(), asDerived().bitfields.end(), [regname, name](const bitfield<uint32_t>& bf) {
                return regname.compare(bf.reg.basename()) == 0 && name == bf.name;
            });
        if(found == asDerived().bitfields.end()) {
            SC_REPORT_FATAL(ID_SCC_TLM_TARGET_BFS_REGISTER_BASE, ("Bitfield " + name + " in register " + regname + " not found").c_str());
        }
        return *found;
    }

    bitfield<uint32_t>& getBitfieldById(const std::string& urid) {
        auto found = std::find_if(asDerived().bitfields.begin(), asDerived().bitfields.end(),
                                  [urid](const bitfield<uint32_t>& bf) { return urid == bf.urid; });
        if(found == asDerived().bitfields.end()) {
            SC_REPORT_FATAL(ID_SCC_TLM_TARGET_BFS_REGISTER_BASE, ("Bitfield with urid " + urid + " not found").c_str());
        }
        return *found;
    }

    bitfield<uint32_t>& getBitfield(const std::string& regname, const std::string& name, const std::string& urid) {
        if(use_URID) {
            return getBitfieldById(urid);
        } else {
            bitfield<uint32_t>& result = getBitfieldByName(regname, name);
            if(result.urid != urid) {
                SC_REPORT_WARNING(ID_SCC_TLM_TARGET_BFS_REGISTER_BASE,
                                  ("URID of register is " + result.urid + " but " + urid + " was passed").c_str());
            }
            return result;
        }
    }
 
private:
    derived_t& asDerived() { return static_cast<derived_t&>(*this); }
};
 
} // namespace scc

#define BITFIELD_ARRAY_ELEMENT(z, i, elem)                                                                                                 \
    BOOST_PP_COMMA_IF(i) {                                                                                                                 \
        getRegister(BOOST_PP_TUPLE_ELEM(0, elem)),                                                                                         \
            BOOST_PP_TUPLE_ELEM(1, elem)                                                                                                   \
                BOOST_PP_STRINGIZE(i), BOOST_PP_TUPLE_ELEM(2, elem) + i *BOOST_PP_TUPLE_ELEM(3, elem), BOOST_PP_TUPLE_ELEM(3, elem),       \
                                   BOOST_PP_TUPLE_ELEM(4, elem) BOOST_PP_STRINGIZE(i) BOOST_PP_TUPLE_ELEM(5, elem)                         \
    }

#define BITFIELD_ARRAY(regname, basename, offset, size, uridbase, count)                                                                   \
    BOOST_PP_REPEAT(count, BITFIELD_ARRAY_ELEMENT, (regname, basename, offset, size, uridbase, ))

#define BITFIELD_ARRAY_POSTFIX(regname, basename, offset, size, uridbase, uridpostfix, count)                                              \
    BOOST_PP_REPEAT(count, BITFIELD_ARRAY_ELEMENT, (regname, basename, offset, size, uridbase, uridpostfix))

#define REGISTER_ARRAY_ELEMENT(z, i, elem)                                                                                                 \
    BOOST_PP_COMMA_IF(i) {                                                                                                                 \
        BOOST_PP_TUPLE_ELEM(0, elem)                                                                                                       \
        BOOST_PP_STRINGIZE(i), BOOST_PP_TUPLE_ELEM(1, elem) + i* BOOST_PP_TUPLE_ELEM(2, elem)                                              \
    }

#define REGISTER_ARRAY(basename, offset, size, count) BOOST_PP_REPEAT(count, REGISTER_ARRAY_ELEMENT, (basename, offset, size))
 
#endif // __SCC_TLM_TARGET_BFS_REGISTER_BASE_H__