95class loader :
public sc_core::sc_module
98 cci::cci_broker_handle m_broker;
100 template <
typename MODULE,
typename TYPES = tlm::tlm_base_protocol_types>
101 class simple_initiator_socket_zero
102 :
public tlm_utils::simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES, sc_core::SC_ZERO_OR_MORE_BOUND>
104 using typename tlm_utils::simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES,
105 sc_core::SC_ZERO_OR_MORE_BOUND>::base_target_socket_type;
106 typedef tlm_utils::simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES, sc_core::SC_ZERO_OR_MORE_BOUND> socket_b;
109 simple_initiator_socket_zero(
const char* name): socket_b(name) {}
113 simple_initiator_socket_zero<loader<BUSWIDTH>> initiator_socket;
118 uint64_t m_address = 0;
120 std::function<void(
const uint8_t* data, uint64_t offset, uint64_t len)> write_cb;
121 bool m_use_callback =
false;
123 std::list<std::string> sc_cci_children(sc_core::sc_module_name name)
125 std::list<std::string> children;
126 const std::string prefix = std::string(name) +
".";
127 const size_t prefix_length = prefix.length();
128 const auto append_child = [&children, prefix_length](
const std::string& full_name) {
129 children.push_back(full_name.substr(prefix_length, full_name.find(
".", prefix_length) - prefix_length));
131 const auto& broker = ConfigurableBroker::get_broker_interface(m_broker);
132 if (
const auto* configurable_broker =
dynamic_cast<const ConfigurableBroker*
>(&broker)) {
133 for (
const auto& full_name : configurable_broker->get_unconsumed_preset_names_with_prefix(prefix)) {
134 append_child(full_name);
137 auto uncon = m_broker.get_unconsumed_preset_values(
138 [&prefix, prefix_length](
const std::pair<std::string, cci::cci_value>& iv) {
139 return iv.first.compare(0, prefix_length, prefix) == 0;
141 for (
const auto& p : uncon) {
142 append_child(p.first);
150 void send(uint64_t addr, uint8_t* data, uint64_t len)
152 if (m_use_callback) {
153 write_cb(data, addr, len);
155 tlm::tlm_generic_payload trans;
157 trans.set_command(tlm::TLM_WRITE_COMMAND);
158 trans.set_address(addr);
159 trans.set_data_ptr(data);
160 trans.set_data_length(len);
161 trans.set_streaming_width(len);
162 trans.set_byte_enable_length(0);
163 if (initiator_socket->transport_dbg(trans) != len) {
164 SCP_FATAL(()) << name() <<
" : Error loading data to memory @ "
165 <<
"0x" << std::hex << addr;
170 template <
typename T>
171 T cci_get(std::string name)
173 return gs::cci_get<T>(m_broker, name);
176 uint32_t byte_swap32(uint32_t in)
194 loader(sc_core::sc_module_name name)
195 : m_broker(cci::cci_get_broker()), initiator_socket(
"initiator_socket"), reset(
"reset")
197 SCP_TRACE(())(
"default constructor");
198 reset.register_value_changed_cb([&](
bool value) { m_onMethod.run([&]() { doreset(value); }); });
200 void doreset(
bool value)
202 SCP_WARN(())(
"Reset");
204 end_of_elaboration();
207 loader(sc_core::sc_module_name name, std::function<
void(
const uint8_t* data, uint64_t offset, uint64_t len)> _write)
208 : m_broker(cci::cci_get_broker()), initiator_socket(
"initiator_socket"), reset(
"reset"), write_cb(_write)
210 SCP_TRACE(())(
"constructor with callback");
211 m_use_callback =
true;
212 reset.register_value_changed_cb([&](
bool value) { m_onMethod.run([&]() { doreset(value); }); });
218 void load(std::string name)
221 if (m_broker.has_preset_value(name +
".elf_file")) {
222 if (m_use_callback) {
223 SCP_WARN(()) <<
"elf file loading into local memory will interpret addresses "
224 "relative to the memory - probably not what you want?";
226 std::string file = gs::cci_get<std::string>(m_broker, name +
".elf_file");
231 if (m_use_callback) {
232 addr = gs::cci_get<uint64_t>(m_broker, name +
".offset");
234 addr = gs::cci_get<uint64_t>(m_broker, name +
".address");
237 if (gs::cci_get<std::string>(m_broker, name +
".bin_file", file)) {
238 uint64_t file_offset = 0, file_data_len = std::numeric_limits<uint64_t>::max();
239 if (!((gs::cci_get<uint64_t>(m_broker, name +
".bin_file_offset", file_offset) &&
240 gs::cci_get<uint64_t>(m_broker, name +
".bin_file_size", file_data_len)))) {
241 file_data_len = std::filesystem::file_size(std::filesystem::path(file));
244 SCP_INFO(())(
"Loading binary file: {} starting at offset: {:#x} with size: {:#x} to addr: {:#x}", file,
245 file_offset, file_data_len, addr);
246 file_load(file, addr, file_offset, file_data_len);
249 if (gs::cci_get<std::string>(m_broker, name +
".zip_archive", file)) {
250 uint64_t file_offset = 0, file_data_len = 0;
251 if (!((gs::cci_get<uint64_t>(m_broker, name +
".archived_file_offset", file_offset) &&
252 gs::cci_get<uint64_t>(m_broker, name +
".archived_file_size", file_data_len)))) {
256 std::string archived_file_name;
257 if (!gs::cci_get<std::string>(m_broker, name +
".archived_file_name", archived_file_name))
258 archived_file_name =
"";
259 SCP_INFO(()) <<
"Loading " << archived_file_name <<
" from zip file: " << file
260 <<
" starting at offset: " << file_offset <<
" to addr: " << addr;
261 zip_file_load(
nullptr, file, addr, archived_file_name, file_offset, file_data_len);
264 if (gs::cci_get<std::string>(m_broker, name +
".csv_file", file)) {
265 std::string addr_str = gs::cci_get<std::string>(m_broker, name +
".addr_str");
266 std::string val_str = gs::cci_get<std::string>(m_broker, name +
".value_str");
267 bool byte_swap =
false;
268 byte_swap = gs::cci_get<bool>(m_broker, name +
".byte_swap", byte_swap);
269 SCP_INFO(())(
"Loading csv file {}, ({}) to {:#x}", file, (name +
".csv_file"), addr);
270 csv_load(file, addr, addr_str, val_str, byte_swap);
274 if (gs::cci_get<std::string>(m_broker, name +
".param", param)) {
275 cci::cci_param_typed_handle<std::string> data(m_broker.get_param_handle(param));
276 if (!data.is_valid()) {
277 SCP_FATAL(()) <<
"Unable to find valid source param '" << param <<
"' for '" << name <<
"'";
279 SCP_INFO(())(
"Loading string parameter {} to {:#x}", param, addr);
280 str_load(data.get_value(), addr);
283 if (m_broker.has_preset_value(name +
".dtb")) {
284 SCP_FATAL(()) <<
"'" << name <<
".dtb' must be a table {base = ..., overlays = {...}}; "
285 <<
"use 'bin_file' to load a prebuilt DTB";
288 if (sc_cci_children((name +
".dtb").c_str()).size()) {
289 dtb_load(name +
".dtb", addr);
292 if (sc_cci_children((name +
".data").c_str()).size()) {
293 bool byte_swap =
false;
294 gs::cci_get<bool>(m_broker, name +
".byte_swap", byte_swap);
295 SCP_INFO(())(
"Loading config data to {:#x}", addr);
296 data_load(name +
".data", addr, byte_swap);
301 SCP_FATAL(()) <<
"Unknown loader type: '" << name <<
"'";
304 void end_of_elaboration()
307 auto children = sc_cci_children(name());
308 for (std::string s : children) {
309 if (std::count_if(s.begin(), s.end(), [](
unsigned char c) { return std::isdigit(c); })) {
310 load(std::string(name()) +
"." + s);
314 if (i == 0 && children.size() > 0) {
326 void file_load(std::string& filename, uint64_t addr, uint64_t file_offset = 0,
327 uint64_t file_data_len = std::numeric_limits<uint64_t>::max())
329 std::ifstream fin(filename, std::ios::in | std::ios::binary);
332 SCP_FATAL(()) <<
"Memory::load(): error file not found (" << filename <<
")";
335 uint64_t rem_len = file_data_len;
336 uint64_t read_len = 0;
337 fin.seekg(file_offset, std::ios::beg);
339 std::vector<uint8_t> buffer(BINFILE_READ_CHUNK_SIZE);
342 while (!fin.eof() && (rem_len > 0)) {
343 read_len = std::min(rem_len,
static_cast<uint64_t
>(BINFILE_READ_CHUNK_SIZE));
344 fin.read(
reinterpret_cast<char*
>(buffer.data()), read_len);
345 size_t r = fin.gcount();
346 send(addr + c, buffer.data(), r);
348 rem_len = ((rem_len >= r) ? rem_len - r : 0);
354 void zip_file_load(zip_t* p_archive,
const std::string& archive_name, uint64_t addr,
355 const std::string& file_name =
"", uint64_t file_offset = 0, uint64_t file_data_len = 0,
356 bool is_compressed =
false,
const std::string& uncompressed_file_name =
"")
358 std::vector<uint8_t> data;
359 if (!is_compressed) {
360 data =
gs::zip_extract(p_archive, archive_name, file_name, file_offset, file_data_len);
365 SCP_DEBUG(()) <<
"load data from zip archive " << archive_name <<
" to addr: 0x" << std::hex << addr
366 <<
" len: 0x" << std::hex << data.size();
367 send(addr, data.data(), data.size());
370 void csv_load(std::string filename, uint64_t offset, std::string addr_str, std::string value_str,
bool byte_swap)
372 std::ifstream file(filename);
375 if (!(file >> row)) {
376 SCP_FATAL(()) <<
"Unable to find " << filename;
380 for (std::size_t i = 0; i < row.size(); i++) {
381 if (row[i] == addr_str) {
384 if (row[i] == value_str) {
388 if (addr_i == -1 || value_i == -1) {
389 SCP_FATAL(()) <<
"Unable to find " << filename;
391 std::size_t min_field_count = std::max(addr_i, value_i);
392 while (file >> row) {
393 if (row.size() <= min_field_count) {
396 const std::string addr = std::string(row[addr_i]);
397 uint64_t value = std::stoll(std::string(row[value_i]),
nullptr, 0);
398 if (byte_swap) value = byte_swap32(value);
399 uint64_t addr_p = std::stoll(addr,
nullptr, 0) + offset;
400 send(addr_p, (uint8_t*)(&value),
sizeof(value));
405 void data_load(std::string param, uint64_t addr,
bool byte_swap)
407 for (std::string s : sc_cci_children(param.c_str())) {
408 if (std::count_if(s.begin(), s.end(), [](
unsigned char c) { return std::isdigit(c); })) {
411 uint8_t b[
sizeof(uint32_t)];
413 data.d = gs::cci_get<uint32_t>(m_broker, param +
"." + std::string(s));
415 data.d = byte_swap32(data.d);
417 send(addr + (stoi(s) * 0x4), &(data.b[0]), 4);
419 SCP_FATAL(()) <<
"unknown format for parameter load";
428 void dtb_load(
const std::string& param, uint64_t addr)
430 for (
const std::string& child : sc_cci_children(param.c_str())) {
431 if (child !=
"base" && child !=
"overlays" && child !=
"dump") {
432 SCP_FATAL(()) <<
"'" << param <<
"': unknown key '" << child <<
"' (expected base, overlays, dump)";
438 if (!m_broker.has_preset_value(param +
".base")) {
439 SCP_FATAL(()) <<
"'" << param <<
"' requires a 'base' DTB file";
442 if (!gs::cci_get<std::string>(m_broker, param +
".base", base) || base.empty()) {
443 SCP_FATAL(()) <<
"'" << param <<
".base' must be a file name";
447 std::vector<std::string> overlays;
448 const std::string ov_key = param +
".overlays";
449 if (m_broker.has_preset_value(ov_key)) {
450 SCP_FATAL(()) <<
"'" << ov_key <<
"' must be a list of file names";
455 const size_t n_overlays = sc_cci_children(ov_key.c_str()).size();
456 for (
size_t i = 0; i < n_overlays; ++i) {
457 const std::string key = ov_key +
"." + std::to_string(i);
459 if (!m_broker.has_preset_value(key) || !gs::cci_get<std::string>(m_broker, key, overlay) ||
461 SCP_FATAL(()) <<
"'" << ov_key <<
"' must be a list of file names (bad or missing entry " << i + 1
465 overlays.push_back(overlay);
469 const bool has_dump = m_broker.has_preset_value(param +
".dump");
470 if (has_dump && !gs::cci_get<std::string>(m_broker, param +
".dump", dump)) {
471 SCP_FATAL(()) <<
"'" << param <<
".dump' must be a file name";
476 std::vector<uint8_t> dtb =
gs::dtb_build(base, overlays, error);
478 SCP_FATAL(()) <<
"'" << param <<
"': " << error;
483 std::ofstream out(dump, std::ios::binary | std::ios::trunc);
484 out.write(
reinterpret_cast<const char*
>(dtb.data()),
static_cast<std::streamsize
>(dtb.size()));
487 SCP_FATAL(()) <<
"'" << param <<
"': unable to write '" << dump <<
"'";
493 (
"Loading DTB {} with {} overlay(s), size {:#x}, to addr: {:#x}", base, overlays.size(), dtb.size(), addr);
494 send(addr, dtb.data(), dtb.size());
498 void str_load(std::string data, uint64_t addr)
500 send(addr,
reinterpret_cast<uint8_t*
>(
const_cast<char*
>(data.c_str())), data.length());
503 void ptr_load(uint8_t* data, uint64_t addr, uint64_t len) { send(addr, data, len); }
505 void elf_load(
const std::string& path)
507 gs::elf_loader(path, [&](uint64_t addr, uint8_t* data, uint64_t len) ->
void { send(addr, data, len); });