regz: Standard format for chip properties (#757)

tact1m4n3 · web-flow · commit b4443ffd7b6c · 2025-12-10T12:43:59.000-08:00
diff --git a/core/src/cpus/cortex_m.zig b/core/src/cpus/cortex_m.zig
@@ -737,23 +737,13 @@ pub const startup_logic = struct {
                 : .{ .memory = true, .r0 = true, .r1 = true });
         }
 
-        if (fpu_present and microzig.options.cpu.enable_fpu) {
+        if (microzig.options.cpu.enable_fpu and has_fpu) {
             enable_fpu();
-        } else if (!fpu_present and microzig.options.cpu.enable_fpu) {
+        } else if (microzig.options.cpu.enable_fpu and !has_fpu) {
             @compileError(
-                \\FPU enable requested though the chip doesn't appear to have an
-                \\FPU. If your chip does have an FPU please add the `fpu_present`
-                \\equal to `true` property to your chip file, either manually or via
-                \\patches. If you want to use patches, you can use something like
-                \\this:
-                \\```
-                \\.{ .set_device_property = .{
-                \\    .device_name = "CHIP_NAME",
-                \\    .key = "fpu_present",
-                \\    .value = "true"
-                \\} },
-                \\```
-            );
+                \\FPU enable requested though the chip doesn't appear to have an FPU.
+                \\
+            ++ fpu_error_helper_message);
         }
 
         if (@hasField(types.peripherals.SystemControlBlock, "SHCSR")) {
@@ -1044,17 +1034,43 @@ const scb_base = scs_base + core.scb_base_offset;
 const mpu_base = scs_base + 0x0D90;
 const fpu_base = scs_base + 0x0F34;
 
-// TODO: will have to standardize this with regz code generation
-const mpu_present = @hasDecl(microzig.chip, "properties") and
-    @hasDecl(microzig.chip.properties, "mpu_present") and
-    is_property_true(microzig.chip.properties.mpu_present);
-const fpu_present = @hasDecl(microzig.chip, "properties") and
-    @hasDecl(microzig.chip.properties, "fpu_present") and
-    is_property_true(microzig.chip.properties.fpu_present);
-
-fn is_property_true(value: []const u8) bool {
-    return std.mem.eql(u8, value, "true") or std.mem.eql(u8, value, "1");
-}
+const has_mpu = microzig.chip.properties.has_mpu orelse
+    @compileError(
+        \\It is uncertain if this chip has an MPU or not.
+        \\
+    ++ mpu_error_helper_message);
+
+const has_fpu = microzig.chip.properties.has_fpu orelse
+    @compileError(
+        \\It is uncertain if this chip has an FPU or not.
+        \\
+    ++ fpu_error_helper_message);
+
+const mpu_error_helper_message =
+    \\If you are certain the chip does have an MPU, please set `cpu.mpuPresent`
+    \\(or `__MPU_PRESENT`) to `true` (or `1`) in your chip file, either manually
+    \\or via patches. If you want to use patches, you can use something like this:
+    \\```
+    \\.{ .set_device_property = .{
+    \\    .device_name = "CHIP_NAME",
+    \\    .key = "cpu.mpuPresent",
+    \\    .value = "true"
+    \\} },
+    \\```
+;
+
+const fpu_error_helper_message =
+    \\If you are certain your chip does have an FPU, please set `cpu.fpuPresent`
+    \\(or `__FPU_PRESENT`) to `true` (or `1`) in your chip file, either manually
+    \\or via patches. If you want to use patches, you can use something like this:
+    \\```
+    \\.{ .set_device_property = .{
+    \\    .device_name = "CHIP_NAME",
+    \\    .key = "cpu.fpuPresent",
+    \\    .value = "true"
+    \\} },
+    \\```
+;
 
 const core = blk: {
     break :blk switch (cortex_m) {
@@ -1078,10 +1094,13 @@ pub const peripherals = struct {
     pub const scb: *volatile types.peripherals.SystemControlBlock = @ptrFromInt(scb_base);
 
     /// Floating Point Unit (FPU).
-    pub const fpu: *volatile types.peripherals.FloatingPointUnit = if (fpu_present)
+    pub const fpu: *volatile types.peripherals.FloatingPointUnit = if (has_fpu)
         @ptrFromInt(fpu_base)
     else
-        @compileError("this CPU does not have an FPU");
+        @compileError(
+            \\This chip doesn't appear to have an FPU.
+            \\
+        ++ fpu_error_helper_message);
 
     /// Nested Vector Interrupt Controller (NVIC).
     pub const nvic: *volatile types.peripherals.NestedVectorInterruptController = @ptrFromInt(nvic_base);
@@ -1090,10 +1109,13 @@ pub const peripherals = struct {
     pub const systick: *volatile types.peripherals.SysTick = @ptrFromInt(systick_base);
 
     /// Memory Protection Unit (MPU).
-    pub const mpu: *volatile types.peripherals.MemoryProtectionUnit = if (mpu_present)
+    pub const mpu: *volatile types.peripherals.MemoryProtectionUnit = if (has_mpu)
         @ptrFromInt(mpu_base)
     else
-        @compileError("this CPU does not have an MPU");
+        @compileError(
+            \\This chip doesn't appear to have an MPU.
+            \\
+        ++ mpu_error_helper_message);
 
     pub const dbg: (if (@hasDecl(core, "DebugRegisters"))
         *volatile core.DebugRegisters
@@ -1120,7 +1142,10 @@ pub const types = struct {
         pub const FloatingPointUnit = if (@hasDecl(core, "FloatingPointUnit"))
             core.FloatingPointUnit
         else
-            @compileError("this CPU does not have an FPU definition");
+            @compileError(
+                \\This chip doesn't appear to have an FPU.
+                \\
+            ++ fpu_error_helper_message);
 
         /// Nested Vector Interrupt Controller (NVIC).
         pub const NestedVectorInterruptController = core.NestedVectorInterruptController;
@@ -1186,6 +1211,9 @@ pub const types = struct {
         pub const MemoryProtectionUnit = if (@hasDecl(core, "MemoryProtectionUnit"))
             core.MemoryProtectionUnit
         else
-            @compileError("this CPU does not have an MPU definition");
+            @compileError(
+                \\This chip doesn't appear to have an MPU.
+                \\
+            ++ mpu_error_helper_message);
     };
 };
diff --git a/tools/regz/src/atdf.zig b/tools/regz/src/atdf.zig
@@ -121,18 +121,12 @@ fn load_param(ctx: *Context, node: xml.Node, device_id: DeviceID) !void {
         "caption",
     });
 
-    const property_name_map: std.StaticStringMap([]const u8) = .initComptime(.{
-        .{ "__MPU_PRESENT", "mpu_present" },
-        .{ "__FPU_PRESENT", "fpu_present" },
-        .{ "__NVIC_PRIO_BITS", "nvic_prio_bits" },
-    });
-
     const name = node.get_attribute("name") orelse return error.MissingParamName;
     const value = node.get_attribute("value") orelse return error.MissingParamName;
     const desc = node.get_attribute("caption");
 
     try db.add_device_property(device_id, .{
-        .key = property_name_map.get(name) orelse name,
+        .key = name,
         .value = value,
         .description = desc,
     });
diff --git a/tools/regz/src/embassy.zig b/tools/regz/src/embassy.zig
@@ -447,7 +447,7 @@ pub fn load_into_db(db: *Database, path: []const u8) !void {
 
             if (std.mem.indexOf(u8, interrupt.name, "FPU")) |_| {
                 try db.add_device_property(device_id, .{
-                    .key = "fpu_present",
+                    .key = "cpu.fpuPresent",
                     .value = "true",
                 });
             }
diff --git a/tools/regz/src/gen.zig b/tools/regz/src/gen.zig
@@ -14,6 +14,7 @@ const EnumID = Database.EnumID;
 const StructID = Database.StructID;
 const NestedStructField = Database.NestedStructField;
 
+const Properties = @import("properties.zig").Properties;
 const Directory = @import("Directory.zig");
 const arm = @import("arch/arm.zig");
 const avr = @import("arch/avr.zig");
@@ -84,20 +85,26 @@ fn write_device_file(
 
     try write_imports(opts, true, "types.zig", writer);
 
-    try writer.writeAll(
+    try writer.writeAll(@embedFile("properties.zig") ++
+        \\
         \\pub const Interrupt = struct {
         \\    name: [:0]const u8,
         \\    index: i16,
         \\    description: ?[:0]const u8,
         \\};
         \\
-        \\
     );
 
-    const properties = try db.get_device_properties(arena, device.id);
-    if (properties.len > 0) {
-        try writer.writeAll("pub const properties = struct {\n");
-        for (properties) |prop| {
+    const raw_properties = try db.get_device_properties(arena, device.id);
+    const properties = process_properties(raw_properties);
+
+    try writer.writeAll("\npub const properties: Properties = ");
+    try std.zon.stringify.serialize(properties, .{}, writer);
+    try writer.writeAll(";\n");
+
+    if (raw_properties.len > 0) {
+        try writer.writeAll("\npub const raw_properties = struct {\n");
+        for (raw_properties) |prop| {
             try writer.print("pub const {f} = ", .{
                 std.zig.fmtId(prop.key),
             });
@@ -118,7 +125,7 @@ fn write_device_file(
     const device_peripherals = try db.get_device_peripherals(arena, device.id);
     log.debug("peripheral instances: {}", .{device_peripherals.len});
     if (device_peripherals.len > 0) {
-        try writer.writeAll("pub const peripherals = struct {\n");
+        try writer.writeAll("\npub const peripherals = struct {\n");
         for (device_peripherals) |instance| {
             write_device_peripheral(db, arena, &instance, writer) catch |err| {
                 log.warn("failed to serialize peripheral instance: {}", .{err});
@@ -1285,6 +1292,83 @@ fn to_zero_sentinel(buf: []const u8) [:0]const u8 {
     return buf[0 .. buf.len - 1 :0];
 }
 
+fn process_properties(raw_props: []const Database.DeviceProperty) Properties {
+    var properties: Properties = .{};
+
+    for (raw_props) |prop| {
+        if (std.mem.eql(u8, prop.key, "cpu.nvicPrioBits") or
+            std.mem.eql(u8, prop.key, "__NVIC_PRIO_BITS"))
+        {
+            if (prop.value) |value| {
+                properties.interrupt_priority_bits = std.fmt.parseInt(u8, value, 10) catch blk: {
+                    log.warn("failed to parse `interrupt_priority_bits` property value: expected integer, got `{s}`", .{value});
+                    break :blk null;
+                };
+            } else {
+                log.warn("`interrupt_priority_bits` property candidate detected but it has no value", .{});
+            }
+        }
+
+        if (std.mem.eql(u8, prop.key, "cpu.vtorPresent") or
+            std.mem.eql(u8, prop.key, "__VTOR_PRESENT"))
+        {
+            if (prop.value) |value| {
+                properties.has_vtor = raw_property_value_to_bool(value) catch blk: {
+                    log.warn("failed to parse `has_vtor` property value: expected boolean, got `{s}`", .{value});
+                    break :blk null;
+                };
+            } else {
+                log.warn("`has_vtor` property candidate detected but it has no value", .{});
+            }
+        }
+
+        if (std.mem.eql(u8, prop.key, "cpu.mpuPresent") or
+            std.mem.eql(u8, prop.key, "__MPU_PRESENT"))
+        {
+            if (prop.value) |value| {
+                properties.has_mpu = raw_property_value_to_bool(value) catch blk: {
+                    log.warn("failed to interpret `has_mpu` property value: expected boolean, got `{s}`", .{value});
+                    break :blk null;
+                };
+            } else {
+                log.warn("`has_mpu` property candidate detected but it has no value", .{});
+            }
+        }
+
+        if (std.mem.eql(u8, prop.key, "cpu.fpuPresent") or
+            std.mem.eql(u8, prop.key, "__FPU_PRESENT"))
+        {
+            if (prop.value) |value| {
+                properties.has_fpu = raw_property_value_to_bool(value) catch blk: {
+                    log.warn("failed to interpret `has_fpu` property value: expected boolean, got `{s}`", .{value});
+                    break :blk null;
+                };
+            } else {
+                log.warn("`has_fpu` property candidate detected but it has no value", .{});
+            }
+        }
+    }
+
+    return properties;
+}
+
+fn raw_property_value_to_bool(value: []const u8) !bool {
+    inline for (&.{ "false", "true" }, 0..) |str, i| {
+        if (std.mem.eql(u8, value, str)) {
+            return i == 1;
+        }
+    }
+
+    inline for (&.{ "0", "1" }, 0..) |str, i| {
+        if (std.mem.eql(u8, value, str)) {
+            return i == 1;
+        }
+    }
+
+    log.warn("failed to interpret `{s}` as bool", .{value});
+    return error.BadValue;
+}
+
 const tests = @import("output_tests.zig");
 
 fn expect_register(expected: *const Register, actual: *const Register) !void {
diff --git a/tools/regz/src/properties.zig b/tools/regz/src/properties.zig
@@ -0,0 +1,6 @@
+pub const Properties = struct {
+    has_vtor: ?bool = null,
+    has_mpu: ?bool = null,
+    has_fpu: ?bool = null,
+    interrupt_priority_bits: ?u8 = null,
+};
diff --git a/tools/regz/src/svd.zig b/tools/regz/src/svd.zig
@@ -94,12 +94,6 @@ pub fn load_into_db(db: *Database, doc: xml.Doc) !void {
     // peripherals
     // vendorExtensions
 
-    const property_name_map: std.StaticStringMap([]const u8) = .initComptime(.{
-        .{ "mpuPresent", "mpu_present" },
-        .{ "fpuPresent", "fpu_present" },
-        .{ "nvicPrioBits", "nvic_prio_bits" },
-    });
-
     var cpu_it = root.iterate(&.{}, &.{"cpu"});
     if (cpu_it.next()) |cpu| {
         const required_properties: []const []const u8 = &.{
@@ -131,7 +125,7 @@ pub fn load_into_db(db: *Database, doc: xml.Doc) !void {
                 return error.MissingRequiredProperty;
             };
 
-            const property_name = property_name_map.get(property) orelse try std.mem.join(
+            const property_name = try std.mem.join(
                 arena.allocator(),
                 ".",
                 &.{ "cpu", property },
@@ -144,11 +138,7 @@ pub fn load_into_db(db: *Database, doc: xml.Doc) !void {
 
         for (optional_properties) |property| {
             if (cpu.get_value(property)) |value| {
-                const property_name = property_name_map.get(property) orelse try std.mem.join(
-                    arena.allocator(),
-                    ".",
-                    &.{ "cpu", property },
-                );
+                const property_name = try std.mem.join(arena.allocator(), ".", &.{ "cpu", property });
                 try db.add_device_property(device_id, .{
                     .key = property_name,
                     .value = value,

Original file line number	Diff line number	Diff line change
`@@ -447,7 +447,7 @@ pub fn load_into_db(db: *Database, path: []const u8) !void {`
`447`	`447`
`448`	`448`	`if (std.mem.indexOf(u8, interrupt.name, "FPU")) \|_\| {`
`449`	`449`	`try db.add_device_property(device_id, .{`
`450`		`- .key = "fpu_present",`
	`450`	`+ .key = "cpu.fpuPresent",`
`451`	`451`	`.value = "true",`
`452`	`452`	`});`
`453`	`453`	`}`