simple_initiator.h

/*
 * Copyright 2020 Arteris IP
 *
 * 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.axi_util.cpp
 */
 
#pragma once
 
#ifndef SC_INCLUDE_DYNAMIC_PROCESSES
#define SC_INCLUDE_DYNAMIC_PROCESSES
#endif
 
#include <array>
#include <axi/fsm/base.h>
#include <deque>
#include <scc/ordered_semaphore.h>
#include <sysc/kernel/sc_attribute.h>
#include <tlm/scc/pe/intor_if.h>
#include <unordered_map>
#include <unordered_set>

namespace axi {
namespace pe {
class simple_initiator_b : public sc_core::sc_module, public tlm::scc::pe::intor_fw_b, protected axi::fsm::base {
public:
    using payload_type = axi::axi_protocol_types::tlm_payload_type;
    using phase_type = axi::axi_protocol_types::tlm_phase_type;
 
    sc_core::sc_in<bool> clk_i{"clk_i"};
 
    sc_core::sc_export<tlm::scc::pe::intor_fw_b> fw_i{"fw_i"};
 
    sc_core::sc_port<tlm::scc::pe::intor_bw_b, 1, sc_core::SC_ZERO_OR_MORE_BOUND> bw_o{"bw_o"};
    sc_core::sc_attribute<unsigned> wr_data_beat_delay{"wr_data_beat_delay", 0};
    sc_core::sc_attribute<unsigned> rd_data_accept_delay{"rd_data_accept_delay", 0};
    sc_core::sc_attribute<unsigned> wr_resp_accept_delay{"wr_resp_accept_delay", 0};
    sc_core::sc_attribute<unsigned> ack_resp_delay{"ack_resp_delay", 0};
 
    void b_snoop(payload_type& trans, sc_core::sc_time& t);
 
    tlm::tlm_sync_enum nb_transport_bw(payload_type& trans, phase_type& phase, sc_core::sc_time& t);
 
    void invalidate_direct_mem_ptr(sc_dt::uint64 start_range, sc_dt::uint64 end_range){}
 
    void set_clock_period(sc_core::sc_time clk_period) { this->clk_period = clk_period; }
 
    size_t get_transferwith_in_bytes() const { return transfer_width_in_bytes; }
    void transport(payload_type& trans, bool blocking) override;
    void set_snoop_cb(std::function<unsigned(payload_type& trans)> cb) { snoop_cb = cb; }
    void snoop_resp(payload_type& trans, bool sync = false) override;
    unsigned snoop_latency{1};
    void add_protocol_cb(axi::fsm::protocol_time_point_e e, std::function<void(payload_type&, bool)> cb) {
        assert(e < axi::fsm::CB_CNT);
        protocol_cb[e] = cb;
    }
 
protected:
    explicit simple_initiator_b(const sc_core::sc_module_name& nm,
                                sc_core::sc_port_b<axi::axi_fw_transport_if<axi_protocol_types>>& port,
                                size_t transfer_width, bool coherent = false);
 
    simple_initiator_b() = delete;
 
    simple_initiator_b(simple_initiator_b const&) = delete;
 
    simple_initiator_b(simple_initiator_b&&) = delete;
 
    simple_initiator_b& operator=(simple_initiator_b const&) = delete;
 
    simple_initiator_b& operator=(simple_initiator_b&&) = delete;
 
    void fsm_clk_method() { process_fsm_clk_queue(); }
    axi::fsm::fsm_handle* create_fsm_handle() override;
    void setup_callbacks(axi::fsm::fsm_handle*) override;
 
    void process_snoop_resp();
 
    unsigned thread_avail{0}, thread_active{0};
    sc_core::sc_fifo<tlm::scc::tlm_gp_shared_ptr> dispatch_queue{"dispatch_queue"};
    sc_core::sc_port_b<axi::axi_fw_transport_if<axi_protocol_types>>& socket_fw;
    std::deque<fsm::fsm_handle*> idle_proc;
    ::scc::ordered_semaphore rd{1}, wr{1}, snp{1};
    ::scc::fifo_w_cb<std::tuple<axi::fsm::protocol_time_point_e, payload_type*, unsigned>> snp_resp_queue;
    sc_core::sc_process_handle snp_resp_queue_hndl;
    // TODO: remove hard coded value
    sc_core::sc_time clk_period{1, sc_core::SC_NS};
    std::function<unsigned(payload_type& trans)> snoop_cb;
    std::array<std::function<void(payload_type&, bool)>, axi::fsm::CB_CNT> protocol_cb;
    sc_core::sc_clock* clk_if{nullptr};
    void end_of_elaboration() override;
    scc::peq<std::tuple<axi::fsm::protocol_time_point_e, tlm::scc::tlm_gp_shared_ptr, bool>> cbpeq;
    void cbpeq_cb();
};

template <unsigned int BUSWIDTH = 32, typename TYPES = axi::axi_protocol_types, int N = 1,
          sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND>
class simple_axi_initiator : public simple_initiator_b, public axi::axi_bw_transport_if<axi::axi_protocol_types> {
public:
    using base = simple_initiator_b;
 
    using payload_type = base::payload_type;
    using phase_type = base::phase_type;
    simple_axi_initiator(const sc_core::sc_module_name& nm, axi::axi_initiator_socket<BUSWIDTH, TYPES, N, POL>& socket_)
    : simple_initiator_b(nm, socket_.get_base_port(), BUSWIDTH)
    , socket(socket_) {
        socket(*this);
        this->instance_name = name();
    }
 
    simple_axi_initiator() = delete;
 
    simple_axi_initiator(simple_axi_initiator const&) = delete;
 
    simple_axi_initiator(simple_axi_initiator&&) = delete;
 
    simple_axi_initiator& operator=(simple_axi_initiator const&) = delete;
 
    simple_axi_initiator& operator=(simple_axi_initiator&&) = delete;

    tlm::tlm_sync_enum nb_transport_bw(payload_type& trans, phase_type& phase, sc_core::sc_time& t) override {
        return base::nb_transport_bw(trans, phase, t);
    }

    void invalidate_direct_mem_ptr(sc_dt::uint64 start_range, sc_dt::uint64 end_range) override {
        return base::invalidate_direct_mem_ptr(start_range, end_range);
    }
 
private:
    axi::axi_initiator_socket<BUSWIDTH, TYPES, N, POL>& socket;
};

template <unsigned int BUSWIDTH = 32, typename TYPES = axi::axi_protocol_types, int N = 1,
          sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND>
class simple_ace_initiator : public simple_initiator_b, public axi::ace_bw_transport_if<axi::axi_protocol_types> {
public:
    using base = simple_initiator_b;
 
    using payload_type = base::payload_type;
    using phase_type = base::phase_type;
 
    simple_ace_initiator(const sc_core::sc_module_name& nm, axi::ace_initiator_socket<BUSWIDTH, TYPES, N, POL>& socket)
    : simple_initiator_b(nm, socket.get_base_port(), BUSWIDTH, true)
    , socket(socket) {
        socket(*this);
        this->instance_name = name();
    }
 
    simple_ace_initiator() = delete;
 
    simple_ace_initiator(simple_ace_initiator const&) = delete;
 
    simple_ace_initiator(simple_ace_initiator&&) = delete;
 
    simple_ace_initiator& operator=(simple_ace_initiator const&) = delete;
 
    simple_ace_initiator& operator=(simple_ace_initiator&&) = delete;
    void b_snoop(payload_type& trans, sc_core::sc_time& t) override { base::b_snoop(trans, t); }
    tlm::tlm_sync_enum nb_transport_bw(payload_type& trans, phase_type& phase, sc_core::sc_time& t) override {
        return base::nb_transport_bw(trans, phase, t);
    }

    void invalidate_direct_mem_ptr(sc_dt::uint64 start_range, sc_dt::uint64 end_range) override {
        return base::invalidate_direct_mem_ptr(start_range, end_range);
    }
 
private:
    axi::ace_initiator_socket<BUSWIDTH, TYPES, N, POL>& socket;
};
 
} // namespace pe
} // namespace axi