qualcomm/qbox
Loading...
Searching...
No Matches
addrtr.h
1/*
2 * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All Rights Reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7#ifndef _GREENSOCS_BASE_COMPONENTS_ADDRTR_H
8#define _GREENSOCS_BASE_COMPONENTS_ADDRTR_H
9
10#include <algorithm>
11#include <cinttypes>
12#include <limits>
13#include <vector>
14
15#include <systemc>
16#include <tlm>
17#include <tlm_utils/simple_initiator_socket.h>
18#include <tlm_utils/simple_target_socket.h>
19#include <cci_configuration>
20#include <scp/report.h>
21
22#include <libgsutils.h>
23#include <module_factory_registery.h>
24#include <tlm_sockets_buswidth.h>
25
37
38class addrtr : public sc_core::sc_module
39{
40private:
41 SCP_LOGGER();
42
43 bool range_end(sc_dt::uint64 start, sc_dt::uint64 size, sc_dt::uint64& end) const
44 {
45 if (size == 0 || start > std::numeric_limits<sc_dt::uint64>::max() - (size - 1)) {
46 return false;
47 }
48 end = start + size - 1;
49 return true;
50 }
51
52 bool map_window(sc_dt::uint64& start_addr, sc_dt::uint64& end_addr, unsigned char** dmi_ptr = nullptr)
53 {
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;
58
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) {
62 return false;
63 }
64
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);
67
68 if (dmi_ptr != nullptr && *dmi_ptr != nullptr) {
69 *dmi_ptr += clipped_start - start_addr;
70 }
71
72 start_addr = target_start + (clipped_start - mapped_start);
73 end_addr = target_start + (clipped_end - mapped_start);
74 return true;
75 }
76
77 sc_dt::uint64 addr_fw(sc_dt::uint64 addr)
78 {
79 auto offset = addr - m_base_addr;
80 return p_mapped_base_addr.get_value() + offset;
81 }
82
83 sc_dt::uint64 addr_bw(sc_dt::uint64 addr)
84 {
85 auto offset = addr - p_mapped_base_addr.get_value();
86 return m_base_addr + offset;
87 }
88
89 sc_dt::uint64 map_txn_addr(tlm::tlm_generic_payload& trans)
90 {
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);
103 } else {
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;
107 }
108 return mapped_addr;
109 }
110
111 void b_transport(tlm::tlm_generic_payload& trans, sc_core::sc_time& delay)
112 {
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
116 << mapped_addr;
117 initiator_socket->b_transport(trans, delay);
118 trans.set_address(orig_addr);
119 }
120
121 unsigned int transport_dbg(tlm::tlm_generic_payload& trans)
122 {
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);
129 return ret;
130 }
131
132 bool get_direct_mem_ptr(tlm::tlm_generic_payload& trans, tlm::tlm_dmi& dmi_data)
133 {
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);
138 if (ret) {
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();
142
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;
145 return false;
146 }
147
148 ret = map_window(start_addr, end_addr, &dmi_ptr);
149 if (!ret) {
150 SCP_DEBUG(()) << "DMI grant did not overlap mapped range";
151 return false;
152 }
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;
157 }
158 return ret;
159 }
160
161 void invalidate_direct_mem_ptr(sc_dt::uint64 start, sc_dt::uint64 end)
162 {
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;
168 return;
169 }
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);
173 }
174
175private:
176 cci::cci_broker_handle m_broker;
177 uint64_t m_base_addr;
178 uint64_t m_mapping_size;
179
180public:
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;
184
185public:
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")
192 {
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");
202 }
203
204 addrtr() = delete;
205
206 addrtr(const addrtr&) = delete;
207
208 virtual ~addrtr() {}
209};
210
211extern "C" void module_register();
212
213#endif