Improved encapsulation and logic

Author: Kamilosok

include/debug/debug_stdio.h

@@ -3,6 +3,7 @@
 
 void dputc(char c);
 void dputs(const char* s);
+void dputgap(unsigned int gap_size);
 
 [[gnu::format(printf, 1, 2)]]
 void dprintf(const char* fmt, ...);
@@ -12,6 +13,7 @@ void dprintf(const char* fmt, ...);
 	#define DEBUG_PUTC(c)          dputc(c)
 	#define DEBUG_PUTS(s)          dputs(s)
 	#define DEBUG_PRINTF(fmt, ...) dprintf(fmt __VA_OPT__(, ) __VA_ARGS__)
+	#define DEBUG_PUTGAP(n)        dputgap(n)
 
 #else
 

include/drivers/dt/dt.h

@@ -1,18 +1,15 @@
 #ifndef DT_H
 #define DT_H
 
+#include <drivers/dt/dt_node.h>
 #include <stdbigos/buffer.h>
 #include <stdbigos/types.h>
 
-// I don't think there's an other way than a forward declaration
-typedef struct dt_node_t dt_node_t;
-typedef struct dt_prop_t dt_prop_t;
-
 // Initializes the device tree driver, the second argument specifies, whether the machine operates on big endian numbers
 // natively
 // TODO: Currently parses the entire FDT at init, maybe change to lazy parsing later
 // Builds the actual tree structure handleable by the driver, 0 if success, <0 if error
-int dt_init(buffer_t fdt_buf, endianness_t machine_big_endian);
+int dt_init(const void* fdt, endianness_t machine_big_endian);
 
 // Frees all memory used by the arena
 void dt_cleanup(void);
@@ -26,10 +23,12 @@ const char* dt_node_get_name(const dt_node_t* node);
 // Get node's child count, >=0 if success, <0 if error
 int dt_node_child_count(const dt_node_t* node);
 
-// Get a node's index-th in order child, dt_node_t ptr if success, nullptr if error
-dt_node_t* dt_node_get_child(const dt_node_t* node, int index);
+// Get a node's next sibling, dt_node_t ptr if success, nullptr if error or node is the last child
+dt_node_t* dt_get_next_child(const dt_node_t* node);
 
 // Returns the pointer to the root of the parsed device tree if success, nullptr if error
 dt_node_t* dt_get_root(void);
 
+void dt_reset_root(void);
+
 #endif

src/drivers/dt/dt_node.h include/drivers/dt/dt_node.hsrc/drivers/dt/dt_node.h renamed to include/drivers/dt/dt_node.h

@@ -1,11 +1,9 @@
 #ifndef DT_PROPS_H
 #define DT_PROPS_H
 
+#include <drivers/dt/dt_node.h>
 #include <stdbigos/types.h>
 
-typedef struct dt_node_t dt_node_t;
-typedef struct dt_prop_t dt_prop_t;
-
 // Find a property of node by a name, dt_prop_t ptr if success, nullptr if error
 dt_prop_t* dt_find_prop(const dt_node_t* node, const char* name);
 

include/drivers/dt/dt_props.h

@@ -14,23 +14,23 @@ typedef struct buffer_t {
 
 // Helper to create a buffer
 static inline buffer_t make_buffer(const void* data, size_t size) {
-	buffer_t buf = {data, size};
+	buffer_t buf = {.data = data, .size = size};
 	return buf;
 }
 
 // Read big-endian 32-bit from buffer at given offset
-int buffer_read_u32_be(const buffer_t* buf, size_t offset, u32* out);
+int buffer_read_u32_be(buffer_t buf, size_t offset, u32* out);
 
 // Read big-endian 64-bit from buffer at given offset
-int buffer_read_u64_be(const buffer_t* buf, size_t offset, u64* out);
+int buffer_read_u64_be(buffer_t buf, size_t offset, u64* out);
 
 // Read little-endian 32-bit from buffer at given offset
-int buffer_read_u32_le(const buffer_t* buf, size_t offset, u32* out);
+int buffer_read_u32_le(buffer_t buf, size_t offset, u32* out);
 
 // Read little-endian 64-bit from buffer at given offset
-int buffer_read_u64_le(const buffer_t* buf, size_t offset, u64* out);
+int buffer_read_u64_le(buffer_t buf, size_t offset, u64* out);
 
 // Read a zero-terminated C-string from buf at offset
-int buffer_read_cstring(const buffer_t* buf, size_t offset, const char** out_str);
+int buffer_read_cstring(buffer_t buf, size_t offset, const char** out_str);
 
 #endif

include/stdbigos/buffer.h

@@ -1,25 +1,12 @@
+#include <debug/debug_stdio.h>
 #include <drivers/dt/dt.h>
+#include <drivers/dt/dt_node.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");
-}
-
-dt_node_t* dt_get_root(void) {
-	return root_node;
-}
-
 static dt_node_t* find_child_by_name(dt_node_t* parent, const char* name) {
 	for (dt_node_t* child = parent->first_child; child; child = child->next_sibling) {
 		if (strcmp(child->name, name) == 0) {
@@ -30,6 +17,8 @@ static dt_node_t* find_child_by_name(dt_node_t* parent, const char* name) {
 }
 
 dt_node_t* dt_node_find(const char* path) {
+	dt_node_t* root_node = dt_get_root();
+
 	if (!path || path[0] != '/' || !root_node)
 		return nullptr;
 
@@ -77,10 +66,12 @@ int dt_node_child_count(const dt_node_t* n) {
 	return c;
 }
 
-dt_node_t* dt_node_get_child(const dt_node_t* n, int idx) {
-	dt_node_t* ch = n ? n->first_child : NULL;
-	for (; ch && idx > 0; ch = ch->next_sibling, idx--);
-	return ch;
+dt_node_t* dt_get_next_child(const dt_node_t* node) {
+	if (!node)
+		return nullptr;
+
+	// If there's no next sibling, it will automatically return a nullptr, as per documentation
+	return node->next_sibling;
 }
 
 dt_prop_t* dt_find_prop(const dt_node_t* node, const char* name) {
@@ -125,22 +116,21 @@ int dt_prop_read_u64(const dt_node_t* node, const char* name, u64* out) {
 void dt_print_props(const dt_node_t* node, u8 depth) {
 	dt_prop_t* next = node->props;
 	while (next) {
-		gap(depth);
-		sbi_puts(next->name);
-		sbi_puts("\n");
+		DEBUG_PUTGAP(depth);
+		DEBUG_PRINTF("%s\n", next->name);
 		next = next->next_prop;
 	}
 }
 
+// Use only in debug preset
 void dt_print_tree(const dt_node_t* node, u8 depth) {
-	gap(depth);
-	sbi_puts("NODE: ");
-	sbi_puts(node->name);
-	sbi_puts("\n");
-	gap(depth);
-	sbi_puts("PROPERTIES:\n");
+	DEBUG_PUTGAP(depth);
+	DEBUG_PRINTF("NODE: %s\n", node->name);
+	DEBUG_PUTGAP(depth);
+
+	DEBUG_PRINTF("PROPERTIES:\n");
 	dt_print_props(node, depth + 1);
-	sbi_puts("\n");
+	DEBUG_PUTC('\n');
 	dt_node_t* next = node->first_child;
 	while (next) {
 		dt_print_tree(next, depth + 1);

src/drivers/dt/dt_access.c

@@ -5,7 +5,7 @@
 #include <stdbigos/types.h>
 
 // Arena proper
-u8 dt_arena_buffer[DT_ARENA_SIZE];
+static u8 dt_arena_buffer[DT_ARENA_SIZE];
 
 static u32* arena_start = nullptr;
 
@@ -15,6 +15,10 @@ static u32 arena_size;
 // Used area size in bytes
 static u32 arena_offset;
 
+u8* dt_get_arena_buffer(void) {
+	return dt_arena_buffer;
+}
+
 int dt_arena_init(void* start, u32 size) {
 	if (start == nullptr || size == 0)
 		return -1;

src/drivers/dt/dt_alloc.c

@@ -1,14 +1,12 @@
 #ifndef DT_ALLOC_H
 #define DT_ALLOC_H
 
+#include <drivers/dt/dt_node.h>
 #include <stdbigos/types.h>
 
-#include "dt_node.h"
-
 #define DT_ARENA_SIZE 32760
-extern u8 dt_arena_buffer[DT_ARENA_SIZE];
 
-extern dt_node_t* root_node;
+u8* dt_get_arena_buffer(void);
 
 // 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);

src/drivers/dt/dt_alloc.h

@@ -4,6 +4,5 @@
 
 void dt_cleanup(void) {
 	dt_arena_reset();
-
-	root_node = nullptr;
+	dt_reset_root();
 }

src/drivers/dt/dt_cleanup.c

@@ -1,11 +1,20 @@
 #include <drivers/dt/dt.h>
+#include <stdbigos/bitutils.h>
 #include <stdbigos/buffer.h>
 #include <stdbigos/types.h>
 
 #include "dt_alloc.h"
 #include "dt_parser.h"
 
-dt_node_t* root_node = nullptr;
+static dt_node_t* root_node = nullptr;
+
+dt_node_t* dt_get_root(void) {
+	return root_node;
+}
+
+void dt_reset_root(void) {
+	root_node = nullptr;
+}
 
 #define FDT_MAGIC                 0xd00dfeed
 #define FDT_OFF_MAGIC             0x00
@@ -19,34 +28,40 @@ dt_node_t* root_node = nullptr;
 #define FDT_OFF_SIZE_DT_STRINGS   0x20
 #define FDT_OFF_SIZE_DT_STRUCT    0x24
 
-// HACK: WARNING, the handling on big endian native machines not implemented, the second argument is ignored for now
-int dt_init(buffer_t fdt_buf, [[maybe_unused]] endianness_t machine_big_endian) {
-	if (!fdt_buf.data || fdt_buf.size < (FDT_OFF_OFF_DT_STRINGS + 4))
+// TODO: implement reading dependent on endianness of the machine
+int dt_init(const void* fdt, [[maybe_unused]] endianness_t machine_big_endian) {
+	u32 magic = read_be32(fdt);
+	if (magic != FDT_MAGIC)
 		return -1;
 
-	u32 magic;
-	if (buffer_read_u32_be(&fdt_buf, 0, &magic) != BUFFER_OK || magic != FDT_MAGIC)
-		return -2;
+	u32 fdt_size = read_be32((u8*)fdt + 4);
+
+	buffer_t fdt_buf = make_buffer(fdt, fdt_size);
+
+	if (fdt_buf.size < (FDT_OFF_OFF_DT_STRINGS + 4))
+		return -1;
 
 	u32 total_size;
-	if (buffer_read_u32_be(&fdt_buf, FDT_OFF_TOTAL_SIZE, &total_size) != BUFFER_OK)
+	if (buffer_read_u32_be(fdt_buf, FDT_OFF_TOTAL_SIZE, &total_size) != BUFFER_OK)
 		return -2;
 
 	u32 struct_off;
-	if (buffer_read_u32_be(&fdt_buf, FDT_OFF_OFF_DT_STRUCT, &struct_off) != BUFFER_OK)
+	if (buffer_read_u32_be(fdt_buf, FDT_OFF_OFF_DT_STRUCT, &struct_off) != BUFFER_OK)
 		return -2;
 
 	u32 strings_off;
-	if (buffer_read_u32_be(&fdt_buf, FDT_OFF_OFF_DT_STRINGS, &strings_off) != BUFFER_OK)
+	if (buffer_read_u32_be(fdt_buf, FDT_OFF_OFF_DT_STRINGS, &strings_off) != BUFFER_OK)
 		return -2;
 
 	u32 struct_size;
-	if (buffer_read_u32_be(&fdt_buf, FDT_OFF_SIZE_DT_STRUCT, &struct_size) != BUFFER_OK)
+	if (buffer_read_u32_be(fdt_buf, FDT_OFF_SIZE_DT_STRUCT, &struct_size) != BUFFER_OK)
 		return -2;
 
 	if (struct_off + struct_size > total_size)
 		return -3;
 
+	u8* dt_arena_buffer = dt_get_arena_buffer();
+
 	if (dt_arena_init(dt_arena_buffer, DT_ARENA_SIZE) < 0)
 		return -4;