Addressed most problems that appeared in the main repo

That includes actual null pointers, corrected the location of headers, some formatting, unnecessary copying of data, moved functions to more appropriate places, additional failsafes, and some additional access features

Author: Kamilosok

external/include/stb_sprintf.h

@@ -1,15 +1,10 @@
 #ifndef DT_H
 #define DT_H
 
-#include <drivers/dt/dt_node.h>
 #include <stdbigos/types.h>
 
-#define DT_ARENA_SIZE 16384
-
-extern u8 dt_arena_buffer[DT_ARENA_SIZE];
-
-// Root of the parsed device tree
-extern struct dt_node* root_node;
+struct dt_node;
+struct dt_prop;
 
 // Initializes the device tree driver
 // TODO: Currently parses the entire FDT at init, maybe change to lazy parsing later
@@ -20,7 +15,16 @@ int dt_init(const void* fdt_blob, u32 blob_size);
 void dt_cleanup(void);
 
 // Find a node by full path in the tree, dt_node ptr if success, nullptr if error
-struct dt_node* dt_find_node(const char* path);
+struct dt_node* dt_node_find(const char* path);
+
+// Get a node's name, const char ptr name if success, nullptr if error
+const char* dt_node_get_name(const struct dt_node* node);
+
+// Get node's child count, >=0 if success, <0 if error
+int dt_node_child_count(const struct dt_node* node);
+
+// Get a node's index-th in order child, dt_node ptr if success, nullptr if error
+struct dt_node* dt_node_get_child(const struct dt_node* node, int index);
 
 // Returns the pointer to the root of the parsed device tree if success, nullptr if error
 struct dt_node* dt_get_root(void);

include/drivers/dt/dt.h

@@ -1,9 +1,11 @@
 #ifndef DT_PROPS_H
 #define DT_PROPS_H
 
-#include <drivers/dt/dt_node.h>
 #include <stdbigos/types.h>
 
+struct dt_node;
+struct dt_prop;
+
 // Find a property of node by a name, dt_prop ptr if success, nullptr if error
 struct dt_prop* dt_find_prop(const struct dt_node* node, const char* name);
 
@@ -33,4 +35,10 @@ int dt_prop_read_bool(const struct dt_node* node, const char* name);
 // Read a node's name phandle (a handle to a different node) and write it to out, 0 if success, -1 if error
 int dt_prop_read_phandle(const struct dt_node* node, const char* name, u32* out);
 
+// Print the node's properties
+void dt_print_props(const struct dt_node* node, u8 depth);
+
+// Print the entire subtree with properties
+void dt_print_tree(const struct dt_node* node, u8 depth);
+
 #endif

include/drivers/dt/dt_props.h

@@ -0,0 +1,39 @@
+#ifndef BITUTILS_H
+#define BITUTILS_H
+
+#include <stdbigos/types.h>
+
+// Reads a single 32-bit unsigned integer value from the specified address
+static inline u32 read_be32(const void* addr) {
+	const u8* bytes = (const u8*)addr;
+	return ((u32)bytes[0] << 24) | ((u32)bytes[1] << 16) | ((u32)bytes[2] << 8) | ((u32)bytes[3] << 0);
+};
+
+// Reads a single 64-bit unsigned integer value from the specified address
+static inline u64 read_be64(const void* addr) {
+	const u8* bytes = (const u8*)addr;
+	return ((u64)bytes[0] << 56) | ((u64)bytes[1] << 48) | ((u64)bytes[2] << 40) | ((u64)bytes[3] << 32) |
+	       ((u64)bytes[4] << 24) | ((u64)bytes[5] << 16) | ((u64)bytes[6] << 8) | ((u64)bytes[7] << 0);
+};
+
+// Helper for aligning to 4 bytes
+static inline u32 align4(u32 off) {
+	return (off + 3) & ~3u;
+}
+
+// Helper for aligning to 8 bytes
+static inline u32 align8(u32 off) {
+	return (off + 7) & ~7u;
+}
+
+// Helper for aligning to 16 bytes
+static inline u32 align16(u32 off) {
+	return (off + 15) & ~15u;
+}
+
+// Helper for aligning to 32 bytes
+static inline u32 align32(u32 off) {
+	return (off + 31) & ~31u;
+}
+
+#endif

include/stdbigos/bitutils.h

@@ -1,4 +1,9 @@
 add_subdirectory(dt)
 
-SETUP_LIBRARY(drivers)
-target_link_libraries(drivers PRIVATE stdbigos)
+add_library(drivers INTERFACE)
+target_link_libraries(drivers INTERFACE dt)
+
+target_include_directories(drivers
+  INTERFACE
+    ${CMAKE_SOURCE_DIR}/include/drivers
+)

src/drivers/CMakeLists.txt

@@ -1,3 +1,11 @@
 SETUP_LIBRARY(dt)
 
-target_link_libraries(dt PRIVATE stdbigos)
+target_link_libraries(dt PRIVATE stdbigos)
+
+
+target_include_directories(dt
+  PUBLIC
+    ${CMAKE_SOURCE_DIR}/include/drivers/dt   # for dt.h / dt_props.h
+  PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}              # for dt_node.h, dt_alloc.h, dt_parser.h
+)

src/drivers/dt/CMakeLists.txt

@@ -1,9 +1,21 @@
 #include <drivers/dt/dt.h>
-#include <drivers/dt/dt_node.h>
-#include <drivers/dt/dt_parser.h>
-#include <drivers/dt/dt_props.h>
+#include <stdbigos/bitutils.h>
+#include <stdbigos/sbi.h>
 #include <stdbigos/string.h>
 
+#include "dt_alloc.h"
+#include "dt_node.h"
+#include "dt_parser.h"
+
+static void sbi_puts(const char* str) {
+	while (*str) sbi_debug_console_write_byte(*str++);
+}
+
+// There has to be a better way to do this
+static void gap(u8 size) {
+	for (u8 i = 0; i < size; i++) sbi_puts("\t");
+}
+
 struct dt_node* dt_get_root(void) {
 	return root_node;
 }
@@ -14,12 +26,12 @@ static struct dt_node* find_child_by_name(struct dt_node* parent, const char* na
 			return child;
 		}
 	}
-	return ((void*)0);
+	return nullptr;
 }
 
-struct dt_node* dt_find_node(const char* path) {
+struct dt_node* dt_node_find(const char* path) {
 	if (!path || path[0] != '/' || !root_node)
-		return ((void*)0);
+		return nullptr;
 
 	if (strcmp(path, "/") == 0)
 		return root_node;
@@ -37,32 +49,51 @@ struct dt_node* dt_find_node(const char* path) {
 
 		char segment[64];
 		if (len >= (int)sizeof(segment))
-			return ((void*)0);
+			return nullptr;
 
 		memcpy(segment, p, len);
 		segment[len] = '\0';
 
 		current = find_child_by_name(current, segment);
 		if (!current)
-			return ((void*)0);
+			return nullptr;
 
 		p = (*slash == '/') ? slash + 1 : slash;
 	}
 
 	return current;
 }
 
+const char* dt_node_get_name(const struct dt_node* node) {
+	if (!node)
+		return nullptr;
+
+	return node->name;
+}
+
+int dt_node_child_count(const struct dt_node* n) {
+	int c = 0;
+	for (struct dt_node* ch = n->first_child; ch; ch = ch->next_sibling) c++;
+	return c;
+}
+
+struct dt_node* dt_node_get_child(const struct dt_node* n, int idx) {
+	struct dt_node* ch = n ? n->first_child : NULL;
+	for (; ch && idx > 0; ch = ch->next_sibling, idx--);
+	return ch;
+}
+
 struct dt_prop* dt_find_prop(const struct dt_node* node, const char* name) {
 	if (!node || !name)
-		return ((void*)0);
+		return nullptr;
 
 	for (struct dt_prop* prop = node->props; prop; prop = prop->next_prop) {
 		if (strcmp(prop->name, name) == 0) {
 			return prop;
 		}
 	}
 
-	return ((void*)0);
+	return nullptr;
 }
 
 int dt_prop_read_u32(const struct dt_node* node, const char* name, u32* out) {
@@ -84,11 +115,35 @@ int dt_prop_read_u64(const struct dt_node* node, const char* name, u64* out) {
 	if (!prop || prop->data_length < 8 || !prop->value)
 		return -1;
 
-	const u8* val = (const u8*)prop->value;
+	u64 val = read_be64(prop->value);
 
-	u32 high = read_be32(val);
-	u32 low = read_be32(val + 4);
+	*out = val;
 
-	*out = ((u64)high << 32) | (u64)low;
 	return 0;
 }
+
+void dt_print_props(const struct dt_node* node, u8 depth) {
+	struct dt_prop* next = node->props;
+	while (next) {
+		gap(depth);
+		sbi_puts(next->name);
+		sbi_puts("\n");
+		next = next->next_prop;
+	}
+}
+
+void dt_print_tree(const struct dt_node* node, u8 depth) {
+	gap(depth);
+	sbi_puts("NODE: ");
+	sbi_puts(node->name);
+	sbi_puts("\n");
+	gap(depth);
+	sbi_puts("PROPERTIES:\n");
+	dt_print_props(node, depth + 1);
+	sbi_puts("\n");
+	struct dt_node* next = node->first_child;
+	while (next) {
+		dt_print_tree(next, depth + 1);
+		next = next->next_sibling;
+	}
+}

src/drivers/dt/dt_access.c

@@ -1,27 +1,22 @@
-#include <drivers/dt/dt_alloc.h>
+#include "dt_alloc.h"
+
+#include <stdbigos/bitutils.h>
 #include <stdbigos/types.h>
 
+// Arena
+u8 dt_arena_buffer[DT_ARENA_SIZE];
+
 // Ptr to start of arena area
-static u32* arena_start = ((void*)0);
+static u32* arena_start = nullptr;
 
 // Arena size in bytes
 static u32 arena_size;
 
 // Used area size in bytes
 static u32 arena_offset;
 
-// Helper for aligning to 4 bytes
-u32 align4(u32 off) {
-	return (off + 3) & ~3u;
-}
-
-// Helper for aligning to 32 bytes
-u32 align32(u32 off) {
-	return (off + 31) & ~31u;
-}
-
 int dt_arena_init(void* start, u32 size) {
-	if (start == ((void*)0) || size == 0)
+	if (start == nullptr || size == 0)
 		return -1;
 
 	arena_start = (u32*)start;
@@ -32,23 +27,23 @@ int dt_arena_init(void* start, u32 size) {
 }
 
 void* dt_alloc(u32 size) {
-	// Idk if needed
+	//  May not be needed
 	if (size == 0)
-		return ((void*)0);
+		return nullptr;
 
 	// Align to 4 bytes
 	u32 align = align4(size);
 
 	if (arena_offset + align > arena_size)
-		return ((void*)0);
+		return nullptr;
 
 	void* new_block = arena_start + arena_offset;
 	arena_offset += align;
 
 	return new_block;
 }
 
+// Invalidates previously allocated blocks by ignoring them
 void dt_arena_reset(void) {
-	// Invalidates previously allocated blocks by ignoring them
 	arena_offset = 0;
 }

src/drivers/dt/dt_alloc.c

@@ -3,6 +3,11 @@
 
 #include <stdbigos/types.h>
 
+#define DT_ARENA_SIZE 32760
+extern u8 dt_arena_buffer[DT_ARENA_SIZE];
+
+extern struct dt_node* root_node;
+
 // Initialize the arena allocator with the start ptr at the start of the memory block of size bytes for allocations
 int dt_arena_init(void* start, u32 size);
 

include/drivers/dt/dt_alloc.h src/drivers/dt/dt_alloc.hinclude/drivers/dt/dt_alloc.h renamed to src/drivers/dt/dt_alloc.h

@@ -1,8 +1,9 @@
 #include <drivers/dt/dt.h>
-#include <drivers/dt/dt_alloc.h>
+
+#include "dt_alloc.h"
 
 void dt_cleanup(void) {
 	dt_arena_reset();
 
-	root_node = ((void*)0);
+	root_node = nullptr;
 }