FPGA: Device and Driver

common/include/villas/kernel/devices/device.hpp

@@ -0,0 +1,33 @@
+/* Interface for Linux/Unix devices.
+ *
+ * Author: Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ *
+ * SPDX-FileCopyrightText: 2023-2024 Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <filesystem>
+#include <optional>
+#include <villas/kernel/devices/driver.hpp>
+
+namespace villas {
+namespace kernel {
+namespace devices {
+
+class Device {
+public:
+  virtual ~Device(){};
+
+  virtual std::optional<std::unique_ptr<Driver>> driver() const = 0;
+  virtual std::optional<int> iommu_group() const = 0;
+  virtual std::string name() const = 0;
+  virtual std::filesystem::path override_path() const = 0;
+  virtual std::filesystem::path path() const = 0;
+  virtual void probe() const = 0;
+};
+
+} // namespace devices
+} // namespace kernel
+} // namespace villas

common/include/villas/kernel/devices/driver.hpp

@@ -0,0 +1,29 @@
+/* Interface for device drivers. OS/platform independend. 
+ * Implemented for Linux/Unix drivers in linux_driver.hpp
+ *
+ * Author: Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ *
+ * SPDX-FileCopyrightText: 2023-2024 Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+namespace villas {
+namespace kernel {
+namespace devices {
+
+class Device;
+
+class Driver {
+public:
+  virtual void attach(const Device &device) const = 0;
+  virtual void bind(const Device &device) const = 0;
+  virtual std::string name() const = 0;
+  virtual void override(const Device &device) const = 0;
+  virtual void unbind(const Device &device) const = 0;
+};
+
+} // namespace devices
+} // namespace kernel
+} // namespace villas

common/include/villas/kernel/devices/ip_device.hpp

@@ -0,0 +1,36 @@
+/* Linux/Unix device which represents an IP component of a FPGA.
+ *
+ * Author: Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ *
+ * SPDX-FileCopyrightText: 2023-2024 Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <filesystem>
+#include <villas/kernel/devices/platform_device.hpp>
+
+namespace villas {
+namespace kernel {
+namespace devices {
+
+class IpDevice : public PlatformDevice {
+public:
+  static IpDevice from(const std::filesystem::path unsafe_path);
+  static bool is_path_valid(const std::filesystem::path unsafe_path);
+
+private:
+  IpDevice() = delete;
+  IpDevice(
+      const std::filesystem::path valid_path) //! Dont allow unvalidated paths
+      : PlatformDevice(valid_path){};
+
+public:
+  size_t addr() const;
+  std::string ip_name() const;
+};
+
+} // namespace devices
+} // namespace kernel
+} // namespace villas

common/include/villas/kernel/devices/linux_driver.hpp

@@ -0,0 +1,52 @@
+/* Implementation of driver interface for Linux/Unix based operation system drivers.
+ *
+ * Author: Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ *
+ * SPDX-FileCopyrightText: 2023-2024 Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <villas/kernel/devices/driver.hpp>
+
+namespace villas {
+namespace kernel {
+namespace devices {
+
+class LinuxDriver : public Driver {
+private:
+  static constexpr char BIND_DEFAULT[] = "bind";
+  static constexpr char UNBIND_DEFAULT[] = "unbind";
+
+public:
+  const std::filesystem::path path;
+
+private:
+  const std::filesystem::path bind_path;
+  const std::filesystem::path unbind_path;
+
+public:
+  LinuxDriver(const std::filesystem::path path)
+      : LinuxDriver(path, path / std::filesystem::path(BIND_DEFAULT),
+                    path / std::filesystem::path(UNBIND_DEFAULT)){};
+
+  LinuxDriver(const std::filesystem::path path,
+              const std::filesystem::path bind_path,
+              const std::filesystem::path unbind_path)
+      : path(path), bind_path(bind_path), unbind_path(unbind_path){};
+
+public:
+  void attach(const Device &device) const override;
+  void bind(const Device &device) const override;
+  std::string name() const override;
+  void override(const Device &device) const override;
+  void unbind(const Device &device) const override;
+};
+
+} // namespace devices
+} // namespace kernel
+} // namespace villas

common/include/villas/kernel/devices/pci_device.hpp

@@ -20,7 +20,7 @@ namespace kernel {
 namespace devices {
 
 #define PCI_SLOT(devfn) (((devfn) >> 3) & 0x1f)
-#define PCI_FUNC(devfn) ((devfn) & 0x07)
+#define PCI_FUNC(devfn) ((devfn)&0x07)
 
 class Id {
 public:

common/include/villas/kernel/devices/platform_device.hpp

@@ -0,0 +1,51 @@
+/* Platform bus based Linux/Unix device.
+ *
+ * Author: Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ *
+ * SPDX-FileCopyrightText: 2023-2024 Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <filesystem>
+#include <villas/kernel/devices/device.hpp>
+#include <villas/kernel/devices/driver.hpp>
+
+namespace villas {
+namespace kernel {
+namespace devices {
+
+class PlatformDevice : public Device {
+private:
+  static constexpr char PROBE_DEFAULT[] = "/sys/bus/platform/drivers_probe";
+  static constexpr char OVERRIDE_DEFAULT[] = "driver_override";
+
+private:
+  const std::filesystem::path m_path;
+  const std::filesystem::path m_probe_path;
+  const std::filesystem::path m_override_path;
+
+public:
+  PlatformDevice(const std::filesystem::path path)
+      : PlatformDevice(path, std::filesystem::path(PROBE_DEFAULT),
+                       path / std::filesystem::path(OVERRIDE_DEFAULT)){};
+
+  PlatformDevice(const std::filesystem::path path,
+                 const std::filesystem::path probe_path,
+                 const std::filesystem::path override_path)
+      : m_path(path), m_probe_path(probe_path),
+        m_override_path(override_path){};
+
+  // Implement device interface
+  std::optional<std::unique_ptr<Driver>> driver() const override;
+  std::optional<int> iommu_group() const override;
+  std::string name() const override;
+  std::filesystem::path override_path() const override;
+  std::filesystem::path path() const override;
+  void probe() const override;
+};
+
+} // namespace devices
+} // namespace kernel
+} // namespace villas

common/include/villas/task.hpp

@@ -45,7 +45,7 @@ struct Task {
 #if PERIODIC_TASK_IMPL == TIMERFD
   int fd; // The timerfd_create(2) file descriptior.
 #elif PERIODIC_TASK_IMPL == RDTSC
-  struct Tsc tsc; // Initialized by tsc_init().
+  struct Tsc tsc;         // Initialized by tsc_init().
 #endif
 
   // Create a new task with the given rate.

common/include/villas/utils.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <filesystem>
 #include <list>
 #include <string>
 #include <vector>
@@ -52,7 +53,7 @@
 #ifdef ALIGN
 #undef ALIGN
 #endif
-#define ALIGN(x, a) ALIGN_MASK(x, (uintptr_t)(a) - 1)
+#define ALIGN(x, a) ALIGN_MASK(x, (uintptr_t)(a)-1)
 #define ALIGN_MASK(x, m) (((uintptr_t)(x) + (m)) & ~(m))
 #define IS_ALIGNED(x, a) (ALIGN(x, a) == (uintptr_t)x)
 
@@ -64,13 +65,13 @@
   } while (0)
 
 // Round-up integer division
-#define CEIL(x, y) (((x) + (y) - 1) / (y))
+#define CEIL(x, y) (((x) + (y)-1) / (y))
 
 // Get nearest up-rounded power of 2
-#define LOG2_CEIL(x) (1 << (villas::utils::log2i((x) - 1) + 1))
+#define LOG2_CEIL(x) (1 << (villas::utils::log2i((x)-1) + 1))
 
 // Check if the number is a power of 2
-#define IS_POW2(x) (((x) != 0) && !((x) & ((x) - 1)))
+#define IS_POW2(x) (((x) != 0) && !((x) & ((x)-1)))
 
 // Calculate the number of elements in an array.
 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a)[0])
@@ -208,9 +209,13 @@ template <class... Ts> struct overloaded : Ts... {
   using Ts::operator()...;
 };
 
-// explicit deduction guide (not needed as of C++20)
+// Explicit deduction guide (not needed as of C++20)
 template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
 
+void write_to_file(std::string data, const std::filesystem::path file);
+std::vector<std::string>
+read_names_in_directory(const std::filesystem::path &directory);
+
 namespace base64 {
 
 using byte = std::uint8_t;

common/lib/CMakeLists.txt

@@ -39,7 +39,10 @@ endif()
 
 if(CMAKE_SYSTEM_NAME STREQUAL Linux)
     target_sources(villas-common PRIVATE
+        kernel/devices/ip_device.cpp
+        kernel/devices/linux_driver.cpp
         kernel/devices/pci_device.cpp
+        kernel/devices/platform_device.cpp
         kernel/vfio_device.cpp
         kernel/vfio_group.cpp
         kernel/vfio_container.cpp

common/lib/base64.cpp

@@ -110,7 +110,7 @@ std::vector<byte> decode(const std::string &input) {
 
     decoded.push_back((temp >> 16) & 0x000000FF);
     decoded.push_back((temp >> 8) & 0x000000FF);
-    decoded.push_back((temp) & 0x000000FF);
+    decoded.push_back((temp)&0x000000FF);
   }
 
   return decoded;

common/lib/kernel/devices/ip_device.cpp

@@ -0,0 +1,54 @@
+/* Linux/Unix device which represents an IP component of a FPGA.
+ *
+ * Author: Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ *
+ * SPDX-FileCopyrightText: 2023-2024 Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <filesystem>
+#include <regex>
+#include <stdexcept>
+
+#include <villas/exceptions.hpp>
+#include <villas/kernel/devices/ip_device.hpp>
+
+using villas::kernel::devices::IpDevice;
+
+IpDevice IpDevice::from(const std::filesystem::path unsafe_path) {
+  if (!is_path_valid(unsafe_path))
+    throw RuntimeError(
+        "Path {} failed validation as IpDevicePath [adress in hex].[name] ",
+        unsafe_path.u8string());
+  return IpDevice(unsafe_path);
+}
+
+std::string IpDevice::ip_name() const {
+  int pos = name().find('.');
+  return name().substr(pos + 1);
+}
+
+size_t IpDevice::addr() const {
+  size_t pos = name().find('.');
+  std::string addr_hex = name().substr(0, pos);
+
+  // Convert from hex-string to number
+  std::stringstream ss;
+  ss << std::hex << addr_hex;
+  size_t addr = 0;
+  ss >> addr;
+
+  return addr;
+}
+
+bool IpDevice::is_path_valid(const std::filesystem::path unsafe_path) {
+  std::string assumed_device_name = unsafe_path.filename();
+
+  // Match format of hexaddr.devicename
+  if (!std::regex_match(assumed_device_name,
+                        std::regex(R"([0-9A-Fa-f]+\..*)"))) {
+    return false;
+  }
+
+  return true;
+}

common/lib/kernel/devices/linux_driver.cpp

@@ -0,0 +1,40 @@
+/* Implementation of driver interface for Linux/Unix based operation system drivers.
+ *
+ * Author: Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ *
+ * SPDX-FileCopyrightText: 2023-2024 Pascal Bauer <pascal.bauer@rwth-aachen.de>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <villas/kernel/devices/linux_driver.hpp>
+
+#include <villas/kernel/devices/device.hpp>
+#include <villas/utils.hpp>
+
+using villas::kernel::devices::Device, villas::kernel::devices::LinuxDriver;
+using villas::utils::write_to_file;
+
+void LinuxDriver::attach(const Device &device) const {
+  if (device.driver().has_value()) {
+    device.driver().value()->unbind(device);
+  }
+  this->override(device);
+  device.probe();
+}
+
+void LinuxDriver::bind(const Device &device) const {
+  write_to_file(device.name(), this->bind_path);
+}
+
+std::string LinuxDriver::name() const {
+  size_t pos = path.u8string().rfind('/');
+  return path.u8string().substr(pos + 1);
+}
+
+void LinuxDriver::override(const Device &device) const {
+  write_to_file(this->name(), device.override_path());
+}
+
+void LinuxDriver::unbind(const Device &device) const {
+  write_to_file(device.name(), this->unbind_path);
+}