initiator-tester.h

/*
 * This file is part of libgsutils
 * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
 * Author: GreenSocs 2022
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _GREENSOCS_GSUTILS_TESTS_INITIATOR_TESTER_H
#define _GREENSOCS_GSUTILS_TESTS_INITIATOR_TESTER_H
 
#include <functional>
 
#include <systemc>
#include <tlm>
#include <tlm_utils/simple_initiator_socket.h>
#include <module_factory_registery.h>
#include <tlm_sockets_buswidth.h>
 
class InitiatorTester : public sc_core::sc_module
{
public:
    using TlmGenericPayload = tlm::tlm_generic_payload;
    using TlmResponseStatus = tlm::tlm_response_status;
    using TlmDmi = tlm::tlm_dmi;
 
    using InvalidateDirectMemPtrFn = std::function<void(uint64_t, uint64_t)>;
 
private:
    sc_core::sc_time m_last_txn_delay;
    unsigned int m_last_transport_debug_ret;
    bool m_last_dmi_hint = false;
 
    TlmDmi m_last_dmi_data;
 
    InvalidateDirectMemPtrFn m_dmi_inval_cb;
 
    void invalidate_direct_mem_ptr(sc_dt::uint64 start, sc_dt::uint64 end)
    {
        if (m_dmi_inval_cb) {
            m_dmi_inval_cb(start, end);
        }
    }
 
protected:
    virtual void prepare_txn(TlmGenericPayload& txn, bool is_read, uint64_t addr, uint8_t* data, size_t len)
    {
        using namespace tlm;
 
        tlm_command cmd = is_read ? TLM_READ_COMMAND : TLM_WRITE_COMMAND;
 
        txn.set_address(addr);
        txn.set_data_length(len);
        txn.set_data_ptr(data);
        txn.set_command(cmd);
        txn.set_streaming_width(len);
        txn.set_byte_enable_ptr(nullptr);
        txn.set_response_status(TLM_INCOMPLETE_RESPONSE);
    }
 
public:
    tlm_utils::simple_initiator_socket<InitiatorTester, DEFAULT_TLM_BUSWIDTH> socket;
 
    InitiatorTester(const sc_core::sc_module_name& n): sc_core::sc_module(n), socket("initiator_socket")
    {
        socket.register_invalidate_direct_mem_ptr(this, &InitiatorTester::invalidate_direct_mem_ptr);
    }
 
    virtual ~InitiatorTester() {}
 
    /*
     * b_transport / transport_dbg helpers
     * -----------------------------------
     */
 
    TlmResponseStatus do_b_transport(TlmGenericPayload& txn)
    {
        socket->b_transport(txn, m_last_txn_delay);
        m_last_dmi_hint = txn.is_dmi_allowed();
 
        return txn.get_response_status();
    }
 
    TlmResponseStatus do_transport_dbg(TlmGenericPayload& txn)
    {
        m_last_transport_debug_ret = socket->transport_dbg(txn);
 
        return txn.get_response_status();
    }
 
    TlmResponseStatus do_transaction(TlmGenericPayload& txn, bool debug = false)
    {
        if (debug) {
            return do_transport_dbg(txn);
        } else {
            return do_b_transport(txn);
        }
    }
 
    TlmResponseStatus do_read_with_txn_and_ptr(TlmGenericPayload& txn, uint64_t addr, uint8_t* data, size_t len,
                                               bool debug = false)
    {
        prepare_txn(txn, true, addr, data, len);
        return do_transaction(txn, debug);
    }
 
    TlmResponseStatus do_write_with_txn_and_ptr(TlmGenericPayload& txn, uint64_t addr, const uint8_t* data, size_t len,
                                                bool debug = false)
    {
        prepare_txn(txn, false, addr, const_cast<uint8_t*>(data), len);
        return do_transaction(txn, debug);
    }
 
    TlmResponseStatus do_read_with_ptr(uint64_t addr, uint8_t* data, size_t len, bool debug = false)
    {
        TlmGenericPayload txn;
 
        return do_read_with_txn_and_ptr(txn, addr, data, len, debug);
    }
 
    TlmResponseStatus do_write_with_ptr(uint64_t addr, const uint8_t* data, size_t len, bool debug = false)
    {
        TlmGenericPayload txn;
 
        return do_write_with_txn_and_ptr(txn, addr, data, len, debug);
    }
 
    template <class T>
    TlmResponseStatus do_read_with_txn(TlmGenericPayload& txn, uint64_t addr, T& data, bool debug = false)
    {
        uint8_t* ptr = reinterpret_cast<uint8_t*>(&data);
 
        return do_read_with_txn_and_ptr(txn, addr, ptr, sizeof(data), debug);
    }
 
    template <class T>
    TlmResponseStatus do_write_with_txn(TlmGenericPayload& txn, uint64_t addr, const T& data, bool debug = false)
    {
        const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&data);
 
        return do_write_with_txn_and_ptr(txn, addr, ptr, sizeof(data), debug);
    }
 
    template <class T>
    TlmResponseStatus do_read(uint64_t addr, T& data, bool debug = false)
    {
        uint8_t* ptr = reinterpret_cast<uint8_t*>(&data);
 
        return do_read_with_ptr(addr, ptr, sizeof(data), debug);
    }
 
    template <class T>
    TlmResponseStatus do_write(uint64_t addr, const T& data, bool debug = false)
    {
        const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&data);
 
        return do_write_with_ptr(addr, ptr, sizeof(data), debug);
    }
 
    void set_next_txn_delay(const sc_core::sc_time& delay) { m_last_txn_delay = delay; }
 
    const sc_core::sc_time& get_last_txn_delay() const { return m_last_txn_delay; }
 
    unsigned int get_last_transport_debug_ret() const { return m_last_transport_debug_ret; }
 
    bool get_last_dmi_hint() const { return m_last_dmi_hint; }
 
    /*
     * get_direct_mem_ptr helpers
     * --------------------------
     */
 
    bool do_dmi_request(uint64_t addr)
    {
        TlmGenericPayload txn;
 
        prepare_txn(txn, true, addr, nullptr, 0);
        return socket->get_direct_mem_ptr(txn, m_last_dmi_data);
    }
 
    const TlmDmi& get_last_dmi_data() const { return m_last_dmi_data; }
 
    /*
     * Backward interface helpers
     * --------------------------
     */
 
    void register_invalidate_direct_mem_ptr(InvalidateDirectMemPtrFn cb) { m_dmi_inval_cb = cb; }
};
 
GSC_MODULE_REGISTER(InitiatorTester);
 
#endif