1
0
Fork 0
mirror of https://git.rwth-aachen.de/acs/public/villas/node/ synced 2025-03-09 00:00:00 +01:00
VILLASnode/fpga/lib/core.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

366 lines
12 KiB
C++
Raw Permalink Normal View History

/* FPGA IP component.
*
* Author: Steffen Vogel <post@steffenvogel.de>
* SPDX-FileCopyrightText: 2017 Institute for Automation of Complex Power Systems, RWTH Aachen University
* SPDX-License-Identifier: Apache-2.0
*/
#include <memory>
#include <string>
#include <utility>
#include <villas/exceptions.hpp>
#include <villas/log.hpp>
#include <villas/memory.hpp>
#include <villas/utils.hpp>
#include <villas/fpga/card.hpp>
#include <villas/fpga/utils.hpp>
#include <villas/fpga/vlnv.hpp>
2020-06-12 00:05:03 +02:00
#include <villas/fpga/core.hpp>
#include <villas/fpga/ips/intc.hpp>
#include <villas/fpga/ips/pcie.hpp>
#include <villas/fpga/ips/switch.hpp>
2020-06-15 21:08:49 +02:00
using namespace villas::fpga;
using namespace villas::fpga::ip;
// Special IPs that have to be initialized first. Will be initialized in the
// same order as they appear in this list, i.e. first here will be initialized
// first.
static std::list<Vlnv> vlnvInitializationOrder = {
Vlnv("xilinx.com:ip:axi_pcie:"),
Vlnv("xilinx.com:ip:xdma:"),
Vlnv("xilinx.com:module_ref:axi_pcie_intc:"),
Vlnv("xilinx.com:ip:axis_switch:"),
Vlnv("xilinx.com:ip:axi_iic:"),
};
std::list<IpIdentifier> CoreFactory::parseIpIdentifier(json_t *json_ips) {
// Parse all IP instance names and their VLNV into list `allIps`
std::list<IpIdentifier> allIps;
const char *ipName;
json_t *json_ip;
json_object_foreach(json_ips, ipName, json_ip) {
const char *vlnv;
json_error_t err;
int ret = json_unpack_ex(json_ip, &err, 0, "{ s: s }", "vlnv", &vlnv);
if (ret != 0)
throw ConfigError(json_ip, err, "", "IP {} has no VLNV", ipName);
allIps.push_back({vlnv, ipName});
}
return allIps;
}
std::list<IpIdentifier>
CoreFactory::reorderIps(std::list<IpIdentifier> allIps) {
// Pick out IPs to be initialized first.
std::list<IpIdentifier> orderedIps;
// Reverse walktrough, because we push to the
// front of the output list, so that the first element will also be the
// first to be initialized.
for (auto viIt = vlnvInitializationOrder.rbegin();
viIt != vlnvInitializationOrder.rend(); ++viIt) {
// Iterate over IPs, if VLNV matches, push to front and remove from list
for (auto it = allIps.begin(); it != allIps.end(); ++it) {
if (*viIt == it->getVlnv()) {
orderedIps.push_front(*it);
it = allIps.erase(it);
}
}
}
// Insert all other IPs at the end
orderedIps.splice(orderedIps.end(), allIps);
auto loggerStatic = CoreFactory::getStaticLogger();
loggerStatic->debug("IP initialization order:");
for (auto &id : orderedIps) {
loggerStatic->debug(" " CLR_BLD("{}"), id.getName());
}
return orderedIps;
}
std::list<std::shared_ptr<Core>>
CoreFactory::configureIps(std::list<IpIdentifier> orderedIps, json_t *json_ips,
Card *card) {
std::list<std::shared_ptr<Core>> configuredIps;
auto loggerStatic = CoreFactory::getStaticLogger();
// Configure all IPs
for (auto &id : orderedIps) {
loggerStatic->info("Configuring {}", id);
// Find the appropriate factory that can create the specified VLNV
// Note:
// This is the magic part! Factories automatically register as a
// plugin as soon as they are instantiated. If there are multiple
// candidates, the first suitable factory will be used.
auto *f = lookup(id.getVlnv());
if (f == nullptr) {
loggerStatic->warn("No plugin found to handle {}", id.getVlnv());
continue;
} else
loggerStatic->debug("Using {} for IP {}", f->getName(), id.getVlnv());
auto logger = f->getLogger();
// Create new IP instance. Since this function is virtual, it will
// construct the right, specialized type without knowing it here
// because we have already picked the right factory.
// If something goes wrong with initialization, the shared_ptr will
// take care to desctruct the Core again as it is not pushed to
// the list and will run out of scope.
auto ip = std::unique_ptr<Core>(f->make());
if (ip == nullptr) {
logger->warn("Cannot create an instance of {}", f->getName());
continue;
}
// Setup generic IP type properties
ip->card = card;
ip->id = id;
ip->logger = villas::logging.get(id.getName());
json_t *json_ip = json_object_get(json_ips, id.getName().c_str());
// parse ip baseadress
json_t *json_parameters = json_object_get(json_ip, "parameters");
if (json_is_object(json_parameters)) {
json_int_t c_baseaddr = 0;
int baseaddress_found =
json_unpack(json_parameters, "{ s?: I }", "c_baseaddr", &c_baseaddr);
if (baseaddress_found == 0)
ip->baseaddr = c_baseaddr;
}
json_t *json_irqs = json_object_get(json_ip, "irqs");
if (json_is_object(json_irqs)) {
logger->debug("Parse IRQs of {}", *ip);
const char *irqName;
json_t *json_irq;
json_object_foreach(json_irqs, irqName, json_irq) {
const char *irqEntry = json_string_value(json_irq);
auto tokens = utils::tokenize(irqEntry, ":");
if (tokens.size() != 2) {
logger->warn("Cannot parse IRQ '{}' of " CLR_BLD("{}"), irqEntry,
id.getName());
continue;
}
const std::string &irqControllerName = tokens[0];
InterruptController *intc = nullptr;
for (auto &configuredIp : configuredIps) {
if (*configuredIp == irqControllerName) {
intc = dynamic_cast<InterruptController *>(configuredIp.get());
break;
}
}
if (intc == nullptr) {
logger->error("Interrupt Controller {} for IRQ {} not found",
irqControllerName, irqName);
continue;
}
int num;
try {
num = std::stoi(tokens[1]);
} catch (const std::invalid_argument &) {
logger->warn("IRQ number is not an integer: '{}'", irqEntry);
continue;
}
logger->debug("IRQ: {} -> {}:{}", irqName, irqControllerName, num);
ip->irqs[irqName] = {num, intc, ""};
}
}
json_t *json_memory_view = json_object_get(json_ip, "memory-view");
if (json_is_object(json_memory_view)) {
logger->debug("Parse memory view of {}", *ip);
// Now find all slave address spaces this master can access
const char *bus_name;
json_t *json_bus;
json_object_foreach(json_memory_view, bus_name, json_bus) {
// This IP has a memory view => it is a bus master somewhere
// Assemble name for master address space
const std::string myAddrSpaceName =
MemoryManager::getMasterAddrSpaceName(ip->getInstanceName(),
bus_name);
// Create a master address space
const MemoryManager::AddressSpaceId myAddrSpaceId =
MemoryManager::get().getOrCreateAddressSpace(myAddrSpaceName);
ip->busMasterInterfaces[bus_name] = myAddrSpaceId;
const char *instance_name;
json_t *json_instance;
json_object_foreach(json_bus, instance_name, json_instance) {
const char *block_name;
json_t *json_block;
json_object_foreach(json_instance, block_name, json_block) {
json_int_t base, high, size;
json_error_t err;
int ret = json_unpack_ex(json_block, &err, 0,
"{ s: I, s: I, s: I }", "baseaddr", &base,
"highaddr", &high, "size", &size);
if (ret != 0)
throw ConfigError(
json_block, err, "", "Cannot parse address block {}/{}/{}/{}",
ip->getInstanceName(), bus_name, instance_name, block_name);
// Get or create the slave address space
const std::string slaveAddrSpace =
MemoryManager::getSlaveAddrSpaceName(instance_name, block_name);
const MemoryManager::AddressSpaceId slaveAddrSpaceId =
MemoryManager::get().getOrCreateAddressSpace(slaveAddrSpace);
// Create a new mapping to the slave address space
MemoryManager::get().createMapping(
static_cast<uintptr_t>(base), 0, static_cast<uintptr_t>(size),
bus_name, myAddrSpaceId, slaveAddrSpaceId);
}
}
}
}
// IP-specific setup via JSON config
f->parse(*ip, json_ip);
// Set polling mode
f->configurePollingMode(
*ip, (card->polling ? PollingMode::POLL : PollingMode::IRQ));
// IP has been configured now
configuredIps.push_back(std::move(ip));
}
return configuredIps;
}
void CoreFactory::initIps(std::list<std::shared_ptr<Core>> configuredIps,
Card *card) {
auto loggerStatic = CoreFactory::getStaticLogger();
// Start and check IPs now
for (auto &ip : configuredIps) {
loggerStatic->info("Initializing {}", *ip);
// Translate all memory blocks that the IP needs to be accessible from
// the process and cache in the instance, so this has not to be done at
// runtime.
for (auto &memoryBlock : ip->getMemoryBlocks()) {
// Construct the global name of this address block
const auto addrSpaceName = MemoryManager::getSlaveAddrSpaceName(
ip->getInstanceName(), memoryBlock);
// Retrieve its address space identifier
const auto addrSpaceId =
MemoryManager::get().findAddressSpace(addrSpaceName);
// ... and save it in IP
ip->slaveAddressSpaces.emplace(memoryBlock, addrSpaceId);
// Get the translation to the address space
const auto &translation =
MemoryManager::get().getTranslationFromProcess(addrSpaceId);
// Cache it in the IP instance only with local name
ip->addressTranslations.emplace(memoryBlock, translation);
}
if (not ip->init()) {
throw RuntimeError("Failed to initialize IP {}", *ip);
}
if (not ip->check()) {
throw RuntimeError("Failed to check IP {}", *ip);
}
// Will only be reached if the IP successfully was initialized
card->ips.push_back(std::move(ip));
}
loggerStatic->debug("Initialized IPs:");
for (auto &ip : card->ips) {
loggerStatic->debug(" {}", *ip);
}
}
std::list<std::shared_ptr<Core>> CoreFactory::make(Card *card,
json_t *json_ips) {
// We only have this logger until we know the factory to build an IP with
auto loggerStatic = getStaticLogger();
if (!card->ips.empty()) {
loggerStatic->error("IP list of card {} already contains IPs.", card->name);
throw RuntimeError("IP list of card {} already contains IPs.", card->name);
}
std::list<IpIdentifier> allIps =
parseIpIdentifier(json_ips); // All IPs available in config
std::list<IpIdentifier> orderedIps =
reorderIps(allIps); // IPs ordered in initialization order
std::list<std::shared_ptr<Core>> configuredIps =
configureIps(orderedIps, json_ips, card); // Successfully configured IPs
initIps(configuredIps, card);
return card->ips;
}
void Core::dump() {
logger->info("IP: {}", *this);
for (auto &[num, irq] : irqs) {
logger->info(" IRQ {}: {}:{}", num, irq.irqController->getInstanceName(),
irq.num);
}
for (auto &[block, translation] : addressTranslations) {
logger->info(" Memory {}: {}", block, translation);
}
}
CoreFactory *CoreFactory::lookup(const Vlnv &vlnv) {
for (auto &ip : plugin::registry->lookup<CoreFactory>()) {
if (ip->getCompatibleVlnv() == vlnv)
return ip;
}
return nullptr;
}
uintptr_t Core::getLocalAddr(const MemoryBlockName &block,
uintptr_t address) const {
// Throws exception if block not present
auto &translation = addressTranslations.at(block);
return translation.getLocalAddr(address);
}
InterruptController *
Core::getInterruptController(const std::string &interruptName) const {
try {
const IrqPort irq = irqs.at(interruptName);
return irq.irqController;
} catch (const std::out_of_range &) {
return nullptr;
}
}