Add Pinctrl device class

src/c/c.zig

@@ -699,6 +699,34 @@ export fn sdfgen_sddf_gpu_serialise_config(system: *align(8) anyopaque, output_d
     return true;
 }
 
+export fn sdfgen_sddf_pinctrl(c_sdf: *align(8) anyopaque, c_device: ?*align(8) anyopaque, driver: *align(8) anyopaque) *anyopaque {
+    const sdf: *SystemDescription = @ptrCast(c_sdf);
+    const pinctrl = allocator.create(sddf.Pinctrl) catch @panic("OOM");
+    pinctrl.* = sddf.Pinctrl.init(allocator, sdf, @ptrCast(c_device), @ptrCast(driver));
+
+    return pinctrl;
+}
+
+export fn sdfgen_sddf_pinctrl_destroy(system: *align(8) anyopaque) void {
+    const pinctrl: *sddf.Pinctrl = @ptrCast(system);
+    pinctrl.deinit();
+    allocator.destroy(pinctrl);
+}
+
+export fn sdfgen_sddf_pinctrl_connect(system: *align(8) anyopaque) bool {
+    const pinctrl: *sddf.Pinctrl = @ptrCast(system);
+    pinctrl.connect() catch return false;
+
+    return true;
+}
+
+export fn sdfgen_sddf_pinctrl_serialise_config(system: *align(8) anyopaque, output_dir: [*c]u8) bool {
+    const pinctrl: *sddf.Pinctrl = @ptrCast(system);
+    pinctrl.serialiseConfig(std.mem.span(output_dir)) catch return false;
+
+    return true;
+}
+
 export fn sdfgen_vmm(c_sdf: *align(8) anyopaque, vmm_pd: *align(8) anyopaque, vm: *align(8) anyopaque, c_dtb: *align(8) anyopaque, dtb_size: u64, one_to_one_ram: bool) *anyopaque {
     const sdf: *SystemDescription = @ptrCast(c_sdf);
     const vmm = allocator.create(Vmm) catch @panic("OOM");

src/c/sdfgen.h

@@ -130,6 +130,11 @@ sdfgen_sddf_status_t sdfgen_sddf_gpu_add_client(void *system, void *client);
 bool sdfgen_sddf_gpu_connect(void *system);
 bool sdfgen_sddf_gpu_serialise_config(void *system, char *output_dir);
 
+void *sdfgen_sddf_pinctrl(void *sdf, void *device, void *driver);
+void sdfgen_sddf_pinctrl_destroy(void *system);
+bool sdfgen_sddf_pinctrl_connect(void *system);
+bool sdfgen_sddf_pinctrl_serialise_config(void *system, char *output_dir);
+
 /*** Virtual Machine Monitor ***/
 void *sdfgen_vmm(void *sdf, void *vmm_pd, void *vm, char *name, void *dtb, bool one_to_one_ram);
 bool sdfgen_vmm_add_passthrough_device(void *vmm, char *name, void *device);

src/python/module.py

@@ -141,6 +141,16 @@ class SddfStatus(IntEnum):
 libsdfgen.sdfgen_sddf_timer_serialise_config.restype = c_bool
 libsdfgen.sdfgen_sddf_timer_serialise_config.argtypes = [c_void_p, c_char_p]
 
+libsdfgen.sdfgen_sddf_pinctrl.restype = c_void_p
+libsdfgen.sdfgen_sddf_pinctrl.argtypes = [c_void_p, c_void_p, c_void_p]
+libsdfgen.sdfgen_sddf_pinctrl_destroy.restype = None
+libsdfgen.sdfgen_sddf_pinctrl_destroy.argtypes = [c_void_p]
+
+libsdfgen.sdfgen_sddf_pinctrl_connect.restype = c_bool
+libsdfgen.sdfgen_sddf_pinctrl_connect.argtypes = [c_void_p]
+libsdfgen.sdfgen_sddf_pinctrl_serialise_config.restype = c_bool
+libsdfgen.sdfgen_sddf_pinctrl_serialise_config.argtypes = [c_void_p, c_char_p]
+
 libsdfgen.sdfgen_sddf_i2c.restype = c_void_p
 libsdfgen.sdfgen_sddf_i2c.argtypes = [c_void_p, c_void_p, c_void_p, c_void_p]
 libsdfgen.sdfgen_sddf_i2c_destroy.restype = None
@@ -996,6 +1006,32 @@ def serialise_config(self, output_dir: str) -> bool:
         def __del__(self):
             libsdfgen.sdfgen_sddf_gpu_destroy(self._obj)
 
+    class Pinctrl:
+        _obj: c_void_p
+
+        def __init__(
+            self,
+            sdf: SystemDescription,
+            device: Optional[DeviceTree.Node],
+            driver: SystemDescription.ProtectionDomain
+        ) -> None:
+            if device is None:
+                device_obj = None
+            else:
+                device_obj = device._obj
+
+            self._obj: c_void_p = libsdfgen.sdfgen_sddf_pinctrl(sdf._obj, device_obj, driver._obj)
+
+        def connect(self) -> bool:
+            return libsdfgen.sdfgen_sddf_pinctrl_connect(self._obj)
+
+        def serialise_config(self, output_dir: str) -> bool:
+            c_output_dir = c_char_p(output_dir.encode("utf-8"))
+            return libsdfgen.sdfgen_sddf_pinctrl_serialise_config(self._obj, c_output_dir)
+
+        def __del__(self):
+            libsdfgen.sdfgen_sddf_pinctrl_destroy(self._obj)
+
     class Lwip:
         _obj: c_void_p
 

src/sddf.zig

@@ -282,6 +282,7 @@ pub const Config = struct {
             blk,
             i2c,
             gpu,
+            pinctrl,
 
             pub fn fromStr(str: []const u8) ?Class {
                 inline for (std.meta.fields(Class)) |field| {
@@ -301,6 +302,7 @@ pub const Config = struct {
                     .blk => &.{ "blk", "blk/mmc" },
                     .i2c => &.{"i2c"},
                     .gpu => &.{"gpu"},
+                    .pinctrl => &.{"pinctrl"},
                 };
             }
         };
@@ -1635,6 +1637,59 @@ pub const Gpu = struct {
     }
 };
 
+pub const Pinctrl = struct {
+    allocator: Allocator,
+    sdf: *SystemDescription,
+    /// Protection Domain that will act as the driver for the pinmux device
+    driver: *Pd,
+    /// Device Tree node for the pinctrl device
+    device: *dtb.Node,
+    device_res: ConfigResources.Device,
+    serialised: bool = false,
+    connected: bool = false,
+
+    pub const Error = SystemError;
+
+    pub fn init(allocator: Allocator, sdf: *SystemDescription, device: *dtb.Node, driver: *Pd) Pinctrl {
+        // First we have to set some properties on the driver. It is currently our policy that every pinctrl
+        // driver should be passive.
+        driver.passive = true;
+
+        return .{
+            .allocator = allocator,
+            .sdf = sdf,
+            .driver = driver,
+            .device = device,
+            .device_res = std.mem.zeroInit(ConfigResources.Device, .{}),
+        };
+    }
+
+    pub fn deinit(system: *Pinctrl) void {
+        // In the future when we add clients we would need to free associated resources here
+        _ = system;
+        return;
+    }
+
+    pub fn connect(system: *Pinctrl) !void {
+        // The driver must be passive
+        assert(system.driver.passive.?);
+
+        try createDriver(system.sdf, system.driver, system.device, .pinctrl, &system.device_res);
+        system.connected = true;
+    }
+
+    pub fn serialiseConfig(system: *Pinctrl, prefix: []const u8) !void {
+        if (!system.connected) return Error.NotConnected;
+
+        const allocator = system.allocator;
+
+        const device_res_data_name = fmt(allocator, "{s}_device_resources", .{system.driver.name});
+        try data.serialize(allocator, system.device_res, prefix, device_res_data_name);
+
+        system.serialised = true;
+    }
+};
+
 pub const Lwip = struct {
     const PBUF_STRUCT_SIZE = 56;