DBT-RISE-TGC/src/sysc/core_complex.cpp

543 lines
20 KiB
C++
Raw Normal View History

2018-11-08 13:31:28 +01:00
/*******************************************************************************
* Copyright (C) 2017, 2018 MINRES Technologies GmbH
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*******************************************************************************/
2018-11-08 13:31:28 +01:00
#include "sysc/core_complex.h"
#ifdef CORE_TGC_B
#include "iss/arch/riscv_hart_m_p.h"
#include "iss/arch/tgc_b.h"
using tgc_b_plat_type = iss::arch::riscv_hart_m_p<iss::arch::tgc_b>;
#endif
2021-05-13 15:38:33 +02:00
#ifdef CORE_TGC_C
2021-05-14 13:29:39 +02:00
#include "iss/arch/riscv_hart_m_p.h"
2021-05-13 15:38:33 +02:00
#include "iss/arch/tgc_c.h"
using tgc_c_plat_type = iss::arch::riscv_hart_m_p<iss::arch::tgc_c>;
2021-05-13 15:38:33 +02:00
#endif
#ifdef CORE_TGC_D
2021-05-14 13:29:39 +02:00
#include "iss/arch/riscv_hart_mu_p.h"
2021-05-13 15:38:33 +02:00
#include "iss/arch/tgc_d.h"
using tgc_d_plat_type = iss::arch::riscv_hart_mu_p<iss::arch::tgc_d>;
2021-05-13 15:38:33 +02:00
#endif
2018-11-08 13:31:28 +01:00
#include "iss/debugger/encoderdecoder.h"
#include "iss/debugger/gdb_session.h"
2018-11-08 13:31:28 +01:00
#include "iss/debugger/server.h"
#include "iss/debugger/target_adapter_if.h"
2018-11-08 13:31:28 +01:00
#include "iss/iss.h"
#include "iss/vm_types.h"
#include "scc/report.h"
#include <iostream>
2020-09-04 15:37:21 +02:00
#include <sstream>
#define STR(X) #X
#define CREATE_CORE(CN) \
if (type == STR(CN)) { std::tie(cpu, vm) = create_core<CN ## _plat_type>(backend, gdb_port, hart_id); } else
#ifdef WITH_SCV
2018-02-06 12:34:34 +01:00
#include <array>
2018-11-08 13:31:28 +01:00
#include <scv.h>
#endif
namespace sysc {
2021-03-22 12:57:40 +01:00
namespace tgfs {
2018-02-06 12:34:34 +01:00
using namespace std;
using namespace iss;
2018-11-08 13:31:28 +01:00
using namespace logging;
using namespace sc_core;
2018-02-06 12:34:34 +01:00
namespace {
iss::debugger::encoder_decoder encdec;
2018-11-08 13:31:28 +01:00
std::array<const char, 4> lvl = {{'U', 'S', 'H', 'M'}};
}
template<typename PLAT>
class core_wrapper_t : public PLAT {
2017-10-04 10:31:11 +02:00
public:
using reg_t = typename arch::traits<typename PLAT::super>::reg_t;
using phys_addr_t = typename arch::traits<typename PLAT::super>::phys_addr_t;
using heart_state_t = typename PLAT::hart_state_type;
core_wrapper_t(core_complex *owner)
2020-09-04 15:37:21 +02:00
: owner(owner) { }
2021-03-06 08:17:42 +01:00
uint32_t get_mode() { return this->reg.PRIV; }
2020-04-17 19:23:43 +02:00
inline void set_interrupt_execution(bool v) { this->interrupt_sim = v?1:0; }
2018-11-08 13:31:28 +01:00
inline bool get_interrupt_execution() { return this->interrupt_sim; }
heart_state_t &get_state() { return this->state; }
2017-10-04 10:31:11 +02:00
void notify_phase(iss::arch_if::exec_phase p) override {
if (p == iss::arch_if::ISTART) owner->sync(this->reg.icount);
2018-04-24 19:03:30 +02:00
}
2018-02-06 12:34:34 +01:00
sync_type needed_sync() const override { return PRE_SYNC; }
2017-10-04 10:31:11 +02:00
void disass_output(uint64_t pc, const std::string instr) override {
2018-11-08 13:31:28 +01:00
if (INFO <= Log<Output2FILE<disass>>::reporting_level() && Output2FILE<disass>::stream()) {
std::stringstream s;
2021-03-06 08:17:42 +01:00
s << "[p:" << lvl[this->reg.PRIV] << ";s:0x" << std::hex << std::setfill('0')
<< std::setw(sizeof(reg_t) * 2) << (reg_t)this->state.mstatus << std::dec << ";c:" << this->reg.icount << "]";
2018-11-08 13:31:28 +01:00
Log<Output2FILE<disass>>().get(INFO, "disass")
<< "0x" << std::setw(16) << std::right << std::setfill('0') << std::hex << pc << "\t\t" << std::setw(40)
<< std::setfill(' ') << std::left << instr << s.str();
}
owner->disass_output(pc, instr);
};
2018-11-08 13:31:28 +01:00
status read_mem(phys_addr_t addr, unsigned length, uint8_t *const data) override {
if (addr.access && access_type::DEBUG)
return owner->read_mem_dbg(addr.val, length, data) ? Ok : Err;
else {
return owner->read_mem(addr.val, length, data, addr.access && access_type::FETCH) ? Ok : Err;
}
2017-10-04 10:31:11 +02:00
}
2018-11-08 13:31:28 +01:00
status write_mem(phys_addr_t addr, unsigned length, const uint8_t *const data) override {
if (addr.access && access_type::DEBUG)
return owner->write_mem_dbg(addr.val, length, data) ? Ok : Err;
else {
auto res = owner->write_mem(addr.val, length, data) ? Ok : Err;
// clear MTIP on mtimecmp write
if (addr.val == 0x2004000) {
reg_t val;
this->read_csr(arch::mip, val);
if (val & (1ULL << 7)) this->write_csr(arch::mip, val & ~(1ULL << 7));
}
return res;
}
2017-10-04 10:31:11 +02:00
}
2019-06-28 20:58:02 +02:00
status read_csr(unsigned addr, reg_t &val) override {
if((addr==arch::time || addr==arch::timeh) && owner->mtime_o.get_interface(0)){
uint64_t time_val;
bool ret = owner->mtime_o->nb_peek(time_val);
if (addr == iss::arch::time) {
val = static_cast<reg_t>(time_val);
} else if (addr == iss::arch::timeh) {
if (sizeof(reg_t) != 4) return iss::Err;
val = static_cast<reg_t>(time_val >> 32);
}
return ret?Ok:Err;
} else {
return PLAT::read_csr(addr, val);
2019-06-28 20:58:02 +02:00
}
}
2018-11-08 13:31:28 +01:00
void wait_until(uint64_t flags) override {
2020-06-18 07:38:56 +02:00
SCCDEBUG(owner->name()) << "Sleeping until interrupt";
2018-11-08 13:31:28 +01:00
do {
wait(wfi_evt);
} while (this->reg.pending_trap == 0);
PLAT::wait_until(flags);
}
2018-11-08 13:31:28 +01:00
void local_irq(short id, bool value) {
reg_t mask = 0;
2018-11-08 13:31:28 +01:00
switch (id) {
case 16: // SW
mask = 1 << 3;
break;
case 17: // timer
mask = 1 << 7;
break;
case 18: // external
mask = 1 << 11;
break;
default:
/* do nothing*/
break;
}
if (value) {
this->csr[arch::mip] |= mask;
wfi_evt.notify();
} else
this->csr[arch::mip] &= ~mask;
this->check_interrupt();
if(value)
SCCTRACE(owner->name()) << "Triggering interrupt " << id << " Pending trap: " << this->reg.pending_trap;
}
2018-11-08 13:31:28 +01:00
2017-10-04 10:31:11 +02:00
private:
core_complex *const owner;
sc_event wfi_evt;
2017-10-04 10:31:11 +02:00
};
2018-11-08 13:31:28 +01:00
int cmd_sysc(int argc, char *argv[], debugger::out_func of, debugger::data_func df,
debugger::target_adapter_if *tgt_adapter) {
if (argc > 1) {
if (strcasecmp(argv[1], "print_time") == 0) {
std::string t = sc_time_stamp().to_string();
of(t.c_str());
2018-11-08 13:31:28 +01:00
std::array<char, 64> buf;
encdec.enc_string(t.c_str(), buf.data(), 63);
df(buf.data());
2018-02-06 12:34:34 +01:00
return Ok;
2018-11-08 13:31:28 +01:00
} else if (strcasecmp(argv[1], "break") == 0) {
sc_time t;
if (argc == 4) {
t = scc::parse_from_string(argv[2], argv[3]);
} else if (argc == 3) {
t = scc::parse_from_string(argv[2]);
} else
2018-02-06 12:34:34 +01:00
return Err;
// no check needed as it is only called if debug server is active
2018-11-08 13:31:28 +01:00
tgt_adapter->add_break_condition([t]() -> unsigned {
2020-06-18 07:38:56 +02:00
SCCTRACE() << "Checking condition at " << sc_time_stamp();
2018-11-08 13:31:28 +01:00
return sc_time_stamp() >= t ? std::numeric_limits<unsigned>::max() : 0;
});
2018-02-06 12:34:34 +01:00
return Ok;
}
2018-02-06 12:34:34 +01:00
return Err;
}
2018-02-06 12:34:34 +01:00
return Err;
}
using cpu_ptr = std::unique_ptr<iss::arch_if>;
using vm_ptr= std::unique_ptr<iss::vm_if>;
class core_wrapper {
public:
core_wrapper(core_complex *owner) : owner(owner) { }
void reset(uint64_t addr){vm->reset(addr);}
inline void start(){vm->start();}
inline std::pair<uint64_t, bool> load_file(std::string const& name){ return cpu->load_file(name);};
std::function<unsigned(void)> get_mode;
std::function<uint64_t(void)> get_state;
std::function<bool(void)> get_interrupt_execution;
std::function<void(bool)> set_interrupt_execution;
std::function<void(short, bool)> local_irq;
template<typename PLAT>
std::tuple<cpu_ptr, vm_ptr> create_core(std::string const& backend, unsigned gdb_port, uint32_t hart_id){
auto* lcpu = new core_wrapper_t<PLAT>(owner);
lcpu->set_mhartid(hart_id);
get_mode = [lcpu]() { return lcpu->get_mode(); };
get_state = [lcpu]() { return lcpu->get_state().mstatus.backing.val; };
get_interrupt_execution = [lcpu]() { return lcpu->get_interrupt_execution(); };
set_interrupt_execution = [lcpu](bool b) { return lcpu->set_interrupt_execution(b); };
local_irq = [lcpu](short s, bool b) { return lcpu->local_irq(s, b); };
if(backend == "interp")
return {cpu_ptr{lcpu}, vm_ptr{iss::interp::create(lcpu, gdb_port)}};
#ifdef WITH_LLVM
if(backend == "llvm")
return {cpu_ptr{lcpu}, vm_ptr{iss::llvm::create(lcpu, gdb_port)}};
#endif
#ifdef WITH_TCC
if(backend == "tcc")
s return {cpu_ptr{lcpu}, vm_ptr{iss::tcc::create(lcpu, gdb_port)}};
#endif
return {nullptr, nullptr};
}
void create_cpu(std::string const& type, std::string const& backend, unsigned gdb_port, uint32_t hart_id){
CREATE_CORE(tgc_c)
#ifdef CORE_TGC_B
CREATE_CORE(tgc_c)
#endif
#ifdef CORE_TGC_D
CREATE_CORE(tgc_d)
#endif
{
LOG(ERROR) << "Illegal argument value for core type: " << type << std::endl;
}
auto *srv = debugger::server<debugger::gdb_session>::get();
if (srv) tgt_adapter = srv->get_target();
if (tgt_adapter)
tgt_adapter->add_custom_command(
{"sysc", [this](int argc, char *argv[], debugger::out_func of,
debugger::data_func df) -> int { return cmd_sysc(argc, argv, of, df, tgt_adapter); },
"SystemC sub-commands: break <time>, print_time"});
}
core_complex * const owner;
vm_ptr vm{nullptr};
cpu_ptr cpu{nullptr};
iss::debugger::target_adapter_if *tgt_adapter{nullptr};
};
2018-11-08 13:31:28 +01:00
core_complex::core_complex(sc_module_name name)
: sc_module(name)
2017-10-04 10:31:11 +02:00
, read_lut(tlm_dmi_ext())
, write_lut(tlm_dmi_ext())
#ifdef WITH_SCV
, m_db(scv_tr_db::get_default_db())
, stream_handle(nullptr)
, instr_tr_handle(nullptr)
, fetch_tr_handle(nullptr)
#endif
{
SC_HAS_PROCESS(core_complex);// NOLINT
2017-10-04 10:31:11 +02:00
initiator.register_invalidate_direct_mem_ptr([=](uint64_t start, uint64_t end) -> void {
auto lut_entry = read_lut.getEntry(start);
if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE && end <= lut_entry.get_end_address() + 1) {
read_lut.removeEntry(lut_entry);
}
lut_entry = write_lut.getEntry(start);
if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE && end <= lut_entry.get_end_address() + 1) {
write_lut.removeEntry(lut_entry);
}
});
SC_THREAD(run);
SC_METHOD(clk_cb);
sensitive << clk_i;
SC_METHOD(rst_cb);
sensitive << rst_i;
SC_METHOD(sw_irq_cb);
2018-11-08 13:31:28 +01:00
sensitive << sw_irq_i;
SC_METHOD(timer_irq_cb);
2018-11-08 13:31:28 +01:00
sensitive << timer_irq_i;
SC_METHOD(global_irq_cb);
2018-11-08 13:31:28 +01:00
sensitive << global_irq_i;
2017-10-04 10:31:11 +02:00
}
core_complex::~core_complex() = default;
2018-11-08 13:31:28 +01:00
void core_complex::trace(sc_trace_file *trf) const {}
2017-10-04 10:31:11 +02:00
void core_complex::before_end_of_elaboration() {
SCCDEBUG(SCMOD)<<"instantiating iss::arch::tgf with "<<backend.get_value()<<" backend";
2019-07-16 15:52:34 +02:00
cpu = scc::make_unique<core_wrapper>(this);
cpu->create_cpu(core_type.get_value(), backend.get_value(), gdb_server_port.get_value(), mhartid.get_value());
sc_assert(cpu->vm!=nullptr);
#ifdef WITH_SCV
cpu->vm->setDisassEnabled(enable_disass.get_value() || m_db != nullptr);
#else
vm->setDisassEnabled(enable_disass.get_value());
#endif
2017-10-04 10:31:11 +02:00
}
void core_complex::start_of_simulation() {
quantum_keeper.reset();
2018-11-08 13:31:28 +01:00
if (elf_file.get_value().size() > 0) {
istringstream is(elf_file.get_value());
string s;
while (getline(is, s, ',')) {
std::pair<uint64_t, bool> start_addr = cpu->load_file(s);
if (reset_address.is_default_value() && start_addr.second == true)
reset_address.set_value(start_addr.first);
}
}
#ifdef WITH_SCV
2018-11-08 13:31:28 +01:00
if (m_db != nullptr && stream_handle == nullptr) {
string basename(this->name());
stream_handle = new scv_tr_stream((basename + ".instr").c_str(), "TRANSACTOR", m_db);
instr_tr_handle = new scv_tr_generator<>("execute", *stream_handle);
fetch_tr_handle = new scv_tr_generator<uint64_t>("fetch", *stream_handle);
}
#endif
}
void core_complex::disass_output(uint64_t pc, const std::string instr_str) {
#ifdef WITH_SCV
2018-11-08 13:31:28 +01:00
if (m_db == nullptr) return;
if (tr_handle.is_active()) tr_handle.end_transaction();
tr_handle = instr_tr_handle->begin_transaction();
tr_handle.record_attribute("PC", pc);
tr_handle.record_attribute("INSTR", instr_str);
tr_handle.record_attribute("MODE", lvl[cpu->get_mode()]);
tr_handle.record_attribute("MSTATUS", cpu->get_state());
2018-11-08 13:31:28 +01:00
tr_handle.record_attribute("LTIME_START", quantum_keeper.get_current_time().value() / 1000);
#endif
2017-10-04 10:31:11 +02:00
}
void core_complex::clk_cb() {
2018-11-08 13:31:28 +01:00
curr_clk = clk_i.read();
if (curr_clk == SC_ZERO_TIME) cpu->set_interrupt_execution(true);
}
void core_complex::rst_cb() {
2018-11-08 13:31:28 +01:00
if (rst_i.read()) cpu->set_interrupt_execution(true);
}
2018-11-08 13:31:28 +01:00
void core_complex::sw_irq_cb() { cpu->local_irq(16, sw_irq_i.read()); }
2018-11-08 13:31:28 +01:00
void core_complex::timer_irq_cb() { cpu->local_irq(17, timer_irq_i.read()); }
2018-11-08 13:31:28 +01:00
void core_complex::global_irq_cb() { cpu->local_irq(18, global_irq_i.read()); }
2017-10-04 10:31:11 +02:00
void core_complex::run() {
wait(SC_ZERO_TIME); // separate from elaboration phase
2018-11-08 13:31:28 +01:00
do {
if (rst_i.read()) {
cpu->reset(reset_address.get_value());
wait(rst_i.negedge_event());
}
2018-11-08 13:31:28 +01:00
while (clk_i.read() == SC_ZERO_TIME) {
wait(clk_i.value_changed_event());
}
cpu->set_interrupt_execution(false);
cpu->start();
2018-11-08 13:31:28 +01:00
} while (cpu->get_interrupt_execution());
sc_stop();
2017-10-04 10:31:11 +02:00
}
bool core_complex::read_mem(uint64_t addr, unsigned length, uint8_t *const data, bool is_fetch) {
2017-10-04 10:31:11 +02:00
auto lut_entry = read_lut.getEntry(addr);
if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE &&
addr + length <= lut_entry.get_end_address() + 1) {
auto offset = addr - lut_entry.get_start_address();
std::copy(lut_entry.get_dmi_ptr() + offset, lut_entry.get_dmi_ptr() + offset + length, data);
quantum_keeper.inc(lut_entry.get_read_latency());
return true;
} else {
tlm::tlm_generic_payload gp;
gp.set_command(tlm::TLM_READ_COMMAND);
gp.set_address(addr);
gp.set_data_ptr(data);
gp.set_data_length(length);
gp.set_streaming_width(length);
2021-05-13 16:01:04 +02:00
sc_time delay=quantum_keeper.get_local_time();
#ifdef WITH_SCV
2018-11-08 13:31:28 +01:00
if (m_db != nullptr && tr_handle.is_valid()) {
if (is_fetch && tr_handle.is_active()) {
tr_handle.end_transaction();
}
2021-04-07 18:56:46 +02:00
auto preExt = new tlm::scc::scv::tlm_recording_extension(tr_handle, this);
gp.set_extension(preExt);
}
#endif
2017-10-04 10:31:11 +02:00
initiator->b_transport(gp, delay);
2020-06-18 07:38:56 +02:00
SCCTRACE(this->name()) << "read_mem(0x" << std::hex << addr << ") : " << data;
2017-10-04 10:31:11 +02:00
if (gp.get_response_status() != tlm::TLM_OK_RESPONSE) {
return false;
}
if (gp.is_dmi_allowed()) {
gp.set_command(tlm::TLM_READ_COMMAND);
gp.set_address(addr);
tlm_dmi_ext dmi_data;
if (initiator->get_direct_mem_ptr(gp, dmi_data)) {
if (dmi_data.is_read_allowed())
read_lut.addEntry(dmi_data, dmi_data.get_start_address(),
dmi_data.get_end_address() - dmi_data.get_start_address() + 1);
if (dmi_data.is_write_allowed())
write_lut.addEntry(dmi_data, dmi_data.get_start_address(),
dmi_data.get_end_address() - dmi_data.get_start_address() + 1);
}
}
return true;
}
}
bool core_complex::write_mem(uint64_t addr, unsigned length, const uint8_t *const data) {
auto lut_entry = write_lut.getEntry(addr);
if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE &&
addr + length <= lut_entry.get_end_address() + 1) {
auto offset = addr - lut_entry.get_start_address();
std::copy(data, data + length, lut_entry.get_dmi_ptr() + offset);
quantum_keeper.inc(lut_entry.get_read_latency());
return true;
} else {
write_buf.resize(length);
std::copy(data, data + length, write_buf.begin()); // need to copy as TLM does not guarantee data integrity
tlm::tlm_generic_payload gp;
gp.set_command(tlm::TLM_WRITE_COMMAND);
gp.set_address(addr);
gp.set_data_ptr(write_buf.data());
gp.set_data_length(length);
gp.set_streaming_width(length);
2021-05-13 16:01:04 +02:00
sc_time delay=quantum_keeper.get_local_time();
#ifdef WITH_SCV
2018-11-08 13:31:28 +01:00
if (m_db != nullptr && tr_handle.is_valid()) {
2021-04-07 18:56:46 +02:00
auto preExt = new tlm::scc::scv::tlm_recording_extension(tr_handle, this);
gp.set_extension(preExt);
}
#endif
2017-10-04 10:31:11 +02:00
initiator->b_transport(gp, delay);
quantum_keeper.set(delay);
2020-06-18 07:38:56 +02:00
SCCTRACE() << "write_mem(0x" << std::hex << addr << ") : " << data;
2017-10-04 10:31:11 +02:00
if (gp.get_response_status() != tlm::TLM_OK_RESPONSE) {
return false;
}
if (gp.is_dmi_allowed()) {
gp.set_command(tlm::TLM_READ_COMMAND);
gp.set_address(addr);
tlm_dmi_ext dmi_data;
if (initiator->get_direct_mem_ptr(gp, dmi_data)) {
if (dmi_data.is_read_allowed())
read_lut.addEntry(dmi_data, dmi_data.get_start_address(),
dmi_data.get_end_address() - dmi_data.get_start_address() + 1);
if (dmi_data.is_write_allowed())
write_lut.addEntry(dmi_data, dmi_data.get_start_address(),
dmi_data.get_end_address() - dmi_data.get_start_address() + 1);
}
}
return true;
}
}
bool core_complex::read_mem_dbg(uint64_t addr, unsigned length, uint8_t *const data) {
auto lut_entry = read_lut.getEntry(addr);
if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE &&
addr + length <= lut_entry.get_end_address() + 1) {
auto offset = addr - lut_entry.get_start_address();
std::copy(lut_entry.get_dmi_ptr() + offset, lut_entry.get_dmi_ptr() + offset + length, data);
quantum_keeper.inc(lut_entry.get_read_latency());
return true;
} else {
tlm::tlm_generic_payload gp;
gp.set_command(tlm::TLM_READ_COMMAND);
gp.set_address(addr);
gp.set_data_ptr(data);
gp.set_data_length(length);
gp.set_streaming_width(length);
return initiator->transport_dbg(gp) == length;
}
}
bool core_complex::write_mem_dbg(uint64_t addr, unsigned length, const uint8_t *const data) {
auto lut_entry = write_lut.getEntry(addr);
if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE &&
addr + length <= lut_entry.get_end_address() + 1) {
auto offset = addr - lut_entry.get_start_address();
std::copy(data, data + length, lut_entry.get_dmi_ptr() + offset);
quantum_keeper.inc(lut_entry.get_read_latency());
return true;
} else {
write_buf.resize(length);
std::copy(data, data + length, write_buf.begin()); // need to copy as TLM does not guarantee data integrity
tlm::tlm_generic_payload gp;
gp.set_command(tlm::TLM_WRITE_COMMAND);
gp.set_address(addr);
gp.set_data_ptr(write_buf.data());
gp.set_data_length(length);
gp.set_streaming_width(length);
return initiator->transport_dbg(gp) == length;
}
}
} /* namespace SiFive */
} /* namespace sysc */