38class addrtr :
public sc_core::sc_module
43 bool range_end(sc_dt::uint64 start, sc_dt::uint64 size, sc_dt::uint64& end)
const
45 if (size == 0 || start > std::numeric_limits<sc_dt::uint64>::max() - (size - 1)) {
48 end = start + size - 1;
52 bool map_window(sc_dt::uint64& start_addr, sc_dt::uint64& end_addr,
unsigned char** dmi_ptr =
nullptr)
54 sc_dt::uint64 mapped_end;
55 sc_dt::uint64 target_end;
56 const sc_dt::uint64 mapped_start = p_mapped_base_addr.get_value();
57 const sc_dt::uint64 target_start = m_base_addr;
59 if (!range_end(mapped_start, m_mapping_size, mapped_end) ||
60 !range_end(target_start, m_mapping_size, target_end) || end_addr < start_addr || end_addr < mapped_start ||
61 start_addr > mapped_end) {
65 const sc_dt::uint64 clipped_start = std::max(start_addr, mapped_start);
66 const sc_dt::uint64 clipped_end = std::min(end_addr, mapped_end);
68 if (dmi_ptr !=
nullptr && *dmi_ptr !=
nullptr) {
69 *dmi_ptr += clipped_start - start_addr;
72 start_addr = target_start + (clipped_start - mapped_start);
73 end_addr = target_start + (clipped_end - mapped_start);
77 sc_dt::uint64 addr_fw(sc_dt::uint64 addr)
79 auto offset = addr - m_base_addr;
80 return p_mapped_base_addr.get_value() + offset;
83 sc_dt::uint64 addr_bw(sc_dt::uint64 addr)
85 auto offset = addr - p_mapped_base_addr.get_value();
86 return m_base_addr + offset;
89 sc_dt::uint64 map_txn_addr(tlm::tlm_generic_payload& trans)
91 sc_dt::uint64 addr = trans.get_address();
92 sc_dt::uint64 len = trans.get_data_length();
93 sc_dt::uint64 mapped_addr = addr;
94 sc_dt::uint64 target_end;
95 sc_dt::uint64 mapped_end;
96 sc_dt::uint64 txn_end = addr;
97 const bool range_valid = range_end(m_base_addr, m_mapping_size, target_end);
98 const bool mapped_range_valid = range_end(p_mapped_base_addr.get_value(), m_mapping_size, mapped_end);
99 const bool txn_valid = (len == 0) || range_end(addr, len, txn_end);
100 if (range_valid && mapped_range_valid && txn_valid && addr >= m_base_addr && txn_end <= target_end) {
101 mapped_addr = addr_fw(addr);
102 trans.set_address(mapped_addr);
104 SCP_FATAL(()) <<
"The txn [addr: 0x" << std::hex << addr <<
"] len: 0x" << std::hex << len
105 <<
", doesn't belong to the target_socket base address: 0x" << std::hex << m_base_addr
106 <<
" size: 0x" << std::hex << m_mapping_size;
111 void b_transport(tlm::tlm_generic_payload& trans, sc_core::sc_time& delay)
113 sc_dt::uint64 orig_addr = trans.get_address();
114 sc_dt::uint64 mapped_addr = map_txn_addr(trans);
115 SCP_DEBUG(()) <<
"b_transport to addr: 0x" << std::hex << orig_addr <<
" will be mapped to addr: 0x" << std::hex
117 initiator_socket->b_transport(trans, delay);
118 trans.set_address(orig_addr);
121 unsigned int transport_dbg(tlm::tlm_generic_payload& trans)
123 sc_dt::uint64 orig_addr = trans.get_address();
124 sc_dt::uint64 mapped_addr = map_txn_addr(trans);
125 SCP_DEBUG(()) <<
"transport_dbg to addr: 0x" << std::hex << orig_addr <<
" will be mapped to addr: 0x"
126 << std::hex << mapped_addr;
127 unsigned int ret = initiator_socket->transport_dbg(trans);
128 trans.set_address(orig_addr);
132 bool get_direct_mem_ptr(tlm::tlm_generic_payload& trans, tlm::tlm_dmi& dmi_data)
134 sc_dt::uint64 orig_addr = trans.get_address();
135 sc_dt::uint64 mapped_addr = map_txn_addr(trans);
136 bool ret = initiator_socket->get_direct_mem_ptr(trans, dmi_data);
137 trans.set_address(orig_addr);
139 sc_dt::uint64 start_addr = dmi_data.get_start_address();
140 sc_dt::uint64 end_addr = dmi_data.get_end_address();
141 unsigned char* dmi_ptr = dmi_data.get_dmi_ptr();
143 if (mapped_addr < start_addr || mapped_addr > end_addr) {
144 SCP_DEBUG(()) <<
"DMI grant did not contain requested mapped address 0x" << std::hex << mapped_addr;
148 ret = map_window(start_addr, end_addr, &dmi_ptr);
150 SCP_DEBUG(()) <<
"DMI grant did not overlap mapped range";
153 dmi_data.set_dmi_ptr(dmi_ptr);
154 dmi_data.set_start_address(start_addr);
155 dmi_data.set_end_address(end_addr);
156 SCP_DEBUG(()) <<
"DMI was granted to range 0x" << std::hex << start_addr <<
" - 0x" << std::hex << end_addr;
161 void invalidate_direct_mem_ptr(sc_dt::uint64 start, sc_dt::uint64 end)
163 sc_dt::uint64 start_addr = start;
164 sc_dt::uint64 end_addr = end;
165 if (!map_window(start_addr, end_addr)) {
166 SCP_DEBUG(()) <<
"Ignoring invalidate_direct_mem_ptr outside mapped range 0x" << std::hex << start
167 <<
" - 0x" << std::hex << end;
170 SCP_DEBUG(()) <<
"invalidate_direct_mem_ptr request to range 0x" << std::hex << start_addr <<
" - 0x"
171 << std::hex << end_addr;
172 target_socket->invalidate_direct_mem_ptr(start_addr, end_addr);
176 cci::cci_broker_handle m_broker;
177 uint64_t m_base_addr;
178 uint64_t m_mapping_size;
181 tlm_utils::simple_target_socket<addrtr, DEFAULT_TLM_BUSWIDTH> target_socket;
182 tlm_utils::simple_initiator_socket<addrtr, DEFAULT_TLM_BUSWIDTH> initiator_socket;
183 cci::cci_param<uint64_t> p_mapped_base_addr;
186 explicit addrtr(
const sc_core::sc_module_name& nm)
187 : sc_core::sc_module(nm)
188 , m_broker(cci::cci_get_broker())
189 , initiator_socket(
"initiator_socket")
190 , target_socket(
"target_socket")
191 , p_mapped_base_addr(
"mapped_base_addr", 0,
"base adress for mapping")
193 SCP_TRACE(())(
"addrtr constructor");
194 target_socket.register_b_transport(
this, &addrtr::b_transport);
195 target_socket.register_transport_dbg(
this, &addrtr::transport_dbg);
196 target_socket.register_get_direct_mem_ptr(
this, &addrtr::get_direct_mem_ptr);
197 initiator_socket.register_invalidate_direct_mem_ptr(
this, &addrtr::invalidate_direct_mem_ptr);
198 m_base_addr = gs::cci_get<uint64_t>(m_broker,
199 std::string(sc_core::sc_module::name()) +
".target_socket.address");
200 m_mapping_size = gs::cci_get<uint64_t>(m_broker,
201 std::string(sc_core::sc_module::name()) +
".target_socket.size");
206 addrtr(
const addrtr&) =
delete;