const std = @import("std"); const Type = std.builtin.Type; const kernel = @import("root.zig"); pub const DeviceTree = struct { bytes: struct { toplevel: []const u8, dt_struct: []const u8, dt_strings: []const u8, dt_rsvmap: [*]const u8, }, pub const InitError = std.Io.Reader.Error || error{ InvalidMagic, UnsupportedVersion, }; pub fn init(ptr: *const anyopaque) InitError!DeviceTree { const Header = extern struct { magic: u32, totalsize: u32, off_dt_struct: u32, off_dt_strings: u32, off_mem_rsvmap: u32, version: u32, last_comp_version: u32, boot_cpuid_phys: u32, size_dt_strings: u32, size_dt_struct: u32, const magic_value: u32 = 0xd00dfeed; }; const bytes_ptr: [*]const u8 = @ptrCast(@alignCast(ptr)); var reader = std.Io.Reader.fixed(bytes_ptr[0..@sizeOf(Header)]); const header = try reader.takeStruct(Header, .big); if (header.magic != Header.magic_value) { return InitError.InvalidMagic; } if (header.last_comp_version > 17) { return InitError.UnsupportedVersion; } const dt_total = bytes_ptr[0..header.totalsize]; const dt_struct = bytes_ptr[header.off_dt_struct..][0..header.size_dt_struct]; const dt_strings = bytes_ptr[header.off_dt_strings..][0..header.size_dt_strings]; const dt_rsvmap = bytes_ptr[header.off_mem_rsvmap..]; return .{ .bytes = .{ .toplevel = dt_total, .dt_struct = dt_struct, .dt_strings = dt_strings, .dt_rsvmap = dt_rsvmap, }, }; } pub const PropEntry = struct { name: [:0]const u8, value: []const u8, }; pub const Entry = union(enum) { begin_node: struct { full_name: [:0]const u8, node_name: []const u8, unit_address: ?[]const u8, }, prop: PropEntry, end_node, }; pub fn entries(dt: *const DeviceTree) EntryIterator { return .{ .dt_strings = dt.bytes.dt_strings, .reader = .fixed(dt.bytes.dt_struct), }; } pub const EntryIterator = struct { dt_strings: []const u8, reader: ?std.Io.Reader, pub const Error = std.Io.Reader.Error || std.Io.Reader.TakeEnumError || std.Io.Reader.DelimiterError; pub fn skip_out_of_node(self: *EntryIterator) Error!void { var depth: u32 = 1; while (depth != 0) { const next_entry = try self.next() orelse return std.Io.Reader.Error.EndOfStream; switch (next_entry) { .begin_node => depth += 1, .prop => {}, .end_node => depth -= 1, } } } pub fn skip_begin_root(self: *EntryIterator) Error!void { if (try self.next()) |entry| { switch (entry) { .begin_node => |node| { if (node.full_name.len != 0) { return Error.ReadFailed; } }, .end_node, .prop => return Error.ReadFailed, } } else { return Error.ReadFailed; } } pub fn next(self: *EntryIterator) Error!?Entry { const EntryType = enum(u32) { begin_node = 1, end_node = 2, prop = 3, nop = 4, end = 9, }; const reader = if (self.reader) |*reader| reader else return null; const alignment = @sizeOf(u32); while (true) { switch (try reader.takeEnum(EntryType, .big)) { .begin_node => { const full_name = try reader.takeSentinel(0); alignReader(reader, alignment); var node_name = full_name[0..full_name.len]; var unit_address: ?[]const u8 = null; if (std.mem.find(u8, full_name, "@")) |delim_pos| { node_name = full_name[0..delim_pos]; unit_address = full_name[delim_pos..]; } return .{ .begin_node = .{ .full_name = full_name, .node_name = node_name, .unit_address = unit_address, } }; }, .end_node => return .end_node, .prop => { const RawPropEntry = extern struct { len: u32, nameoff: u32, }; const entry = try reader.takeStruct(RawPropEntry, .big); const name_size = std.mem.find(u8, self.dt_strings[entry.nameoff..], &.{0}) orelse return std.Io.Reader.Error.ReadFailed; const name: [:0]const u8 = self.dt_strings[entry.nameoff..][0..name_size :0]; const value = try reader.take(entry.len); alignReader(reader, alignment); return .{ .prop = .{ .name = name, .value = value } }; }, .nop => continue, .end => { self.reader = null; return null; }, } } } fn alignReader( reader: *std.Io.Reader, alignment: usize, ) void { reader.toss((32 - (@intFromPtr(reader.buffer.ptr) + reader.seek) % alignment) % alignment); } }; pub fn reservations(self: *const DeviceTree) ReservationIterator { return .{ .dt_rsvmap = self.bytes.dt_rsvmap }; } pub const ReservationIterator = struct { dt_rsvmap: ?[*]const u8, pub const Error = std.Io.Reader.Error || error{ InvalidAddress, InvalidSize, }; pub fn next(self: *ReservationIterator) Error!?kernel.mem.Range { const dt_rsvmap = if (self.dt_rsvmap) |dt_rsvmap| dt_rsvmap else return null; const entry_size = @sizeOf(u64) * 2; var reader = std.Io.Reader.fixed(dt_rsvmap[0..entry_size]); const address_u64 = try reader.takeInt(u64, .big); const address = std.math.cast(usize, address_u64) orelse return Error.InvalidAddress; const size_u64 = try reader.takeInt(u64, .big); const size = std.math.cast(usize, size_u64) orelse return Error.InvalidSize; if (address == 0 and size == 0) { self.dt_rsvmap = null; return null; } else { self.dt_rsvmap = dt_rsvmap + entry_size; } return .{ .start = address, .end = address + size, }; } }; };