diff --git a/src/kernel/hal/arch/riscv/memory_region.c b/src/kernel/hal/arch/riscv/memory_regions.c similarity index 72% rename from src/kernel/hal/arch/riscv/memory_region.c rename to src/kernel/hal/arch/riscv/memory_regions.c index c0e278d5..240f8672 100644 --- a/src/kernel/hal/arch/riscv/memory_region.c +++ b/src/kernel/hal/arch/riscv/memory_regions.c @@ -4,22 +4,20 @@ * @ingroup hal_riscv_mem */ +#include "hal/include/memory_regions.h" + #include #include #include -#include "../../hal_internal.h" -#include "../../include/memory_regions.h" - -static fdt_t g_hal_riscv_fdt; -static void* g_hal_riscv_fdt_addr = NULL; +#include "hal/hal_internal.h" -static error_t hal_riscv_read_u32_cells_be(buffer_t buf, size_t offset, u32 cell_count, u64* out); +static error_t s_get_fdt(const fdt_t** fdtOUT) { + static fdt_t hal_riscv_fdt; + static void* hal_riscv_fdt_addr = NULL; -static error_t hal_riscv_init_fdt(fdt_t* fdtOUT) { if (fdtOUT == nullptr) return ERR_BAD_ARG; - if (!ihal_is_init()) return ERR_NOT_INITIALIZED; @@ -28,31 +26,18 @@ static error_t hal_riscv_init_fdt(fdt_t* fdtOUT) { if (err) return err; - return dt_init(dtb, fdtOUT); -} - -static error_t hal_riscv_get_fdt(const fdt_t** fdtOUT) { - if (fdtOUT == nullptr) - return ERR_BAD_ARG; - - void* dtb = nullptr; - error_t err = ihal_get_dtb(&dtb); - if (err) - return err; - - if (g_hal_riscv_fdt_addr != dtb) { - error_t err = hal_riscv_init_fdt(&g_hal_riscv_fdt); + if (hal_riscv_fdt_addr != dtb) { + err = dt_init(dtb, &hal_riscv_fdt); if (err) return err; - - g_hal_riscv_fdt_addr = dtb; + hal_riscv_fdt_addr = dtb; } - *fdtOUT = &g_hal_riscv_fdt; + *fdtOUT = &hal_riscv_fdt; return ERR_NONE; } -static error_t hal_riscv_node_is_memory(const fdt_t* fdt, dt_node_t node, bool* isMemoryOUT) { +static error_t s_node_is_memory(const fdt_t* fdt, dt_node_t node, bool* isMemoryOUT) { if (fdt == nullptr || isMemoryOUT == nullptr) return ERR_BAD_ARG; @@ -90,7 +75,7 @@ static error_t hal_riscv_node_is_memory(const fdt_t* fdt, dt_node_t node, bool* /// \param node Current node (0 to get first memory node, or previous memory node to get next) /// \param nodeOUT Output parameter for the found memory node /// \return ERR_NONE on success, error code otherwise -static error_t hal_riscv_find_next_memory_node(const fdt_t* fdt, dt_node_t node, dt_node_t* nodeOUT) { +static error_t s_find_next_memory_node(const fdt_t* fdt, dt_node_t node, dt_node_t* nodeOUT) { if (fdt == nullptr || nodeOUT == nullptr) return ERR_BAD_ARG; @@ -105,7 +90,7 @@ static error_t hal_riscv_find_next_memory_node(const fdt_t* fdt, dt_node_t node, while (true) { bool is_memory; - err = hal_riscv_node_is_memory(fdt, node, &is_memory); + err = s_node_is_memory(fdt, node, &is_memory); if (err) return err; @@ -120,8 +105,30 @@ static error_t hal_riscv_find_next_memory_node(const fdt_t* fdt, dt_node_t node, } } -static error_t hal_riscv_read_reg_entry(const fdt_t* fdt, dt_node_t node, u32 reg_idx, u32 address_cells, - u32 size_cells, u64* addrOUT, u64* sizeOUT) { +static error_t s_read_u32_cells_be(buffer_t buf, size_t offset, u32 cell_count, u64* out) { + if (out == nullptr || cell_count == 0 || cell_count > 2) + return ERR_BAD_ARG; + + if (buf.size < offset) + return ERR_NOT_VALID; + if (buf.size - offset < (size_t)cell_count * sizeof(u32)) + return ERR_NOT_VALID; + + u64 value = 0; + for (u32 idx = 0; idx < cell_count; ++idx) { + u32 cell = 0; + if (!buffer_read_u32_be(buf, offset + (size_t)idx * sizeof(u32), &cell)) + return ERR_NOT_VALID; + + value = (value << 32) | cell; + } + + *out = value; + return ERR_NONE; +} + +static error_t s_read_reg_entry(const fdt_t* fdt, dt_node_t node, u32 reg_idx, u32 address_cells, u32 size_cells, + u64* addrOUT, u64* sizeOUT) { if (fdt == nullptr || addrOUT == nullptr || sizeOUT == nullptr) return ERR_BAD_ARG; @@ -146,11 +153,11 @@ static error_t hal_riscv_read_reg_entry(const fdt_t* fdt, dt_node_t node, u32 re u64 addr; u64 size; - err = hal_riscv_read_u32_cells_be(reg_buf, entry_offset, address_cells, &addr); + err = s_read_u32_cells_be(reg_buf, entry_offset, address_cells, &addr); if (err) return err; - err = hal_riscv_read_u32_cells_be(reg_buf, entry_offset + (size_t)address_cells * sizeof(u32), size_cells, &size); + err = s_read_u32_cells_be(reg_buf, entry_offset + (size_t)address_cells * sizeof(u32), size_cells, &size); if (err) return err; @@ -159,28 +166,6 @@ static error_t hal_riscv_read_reg_entry(const fdt_t* fdt, dt_node_t node, u32 re return ERR_NONE; } -static error_t hal_riscv_read_u32_cells_be(buffer_t buf, size_t offset, u32 cell_count, u64* out) { - if (out == nullptr || cell_count == 0 || cell_count > 2) - return ERR_BAD_ARG; - - if (buf.size < offset) - return ERR_NOT_VALID; - if (buf.size - offset < (size_t)cell_count * sizeof(u32)) - return ERR_NOT_VALID; - - u64 value = 0; - for (u32 idx = 0; idx < cell_count; ++idx) { - u32 cell = 0; - if (!buffer_read_u32_be(buf, offset + (size_t)idx * sizeof(u32), &cell)) - return ERR_NOT_VALID; - - value = (value << 32) | cell; - } - - *out = value; - return ERR_NONE; -} - typedef struct { u32 memreserve_idx; bool is_in_resmem; @@ -188,15 +173,19 @@ typedef struct { u32 resmem_address_cells; u32 resmem_size_cells; u32 resmem_reg_idx; -} riscv_hal_res_mem_iter_t; -static_assert(sizeof(riscv_hal_res_mem_iter_t) <= sizeof(hal_reserved_memory_iterator_t)); +} internal_res_mem_iter_t; +static_assert(sizeof(internal_res_mem_iter_t) <= sizeof(hal_reserved_memory_iterator_t)); + +// ========================================== +// Public +// ========================================== error_t hal_get_reserved_regions_iterator(hal_reserved_memory_iterator_t* iterOUT) { if (iterOUT == nullptr) return ERR_BAD_ARG; const fdt_t* fdt; - error_t err = hal_riscv_get_fdt(&fdt); + error_t err = s_get_fdt(&fdt); if (err) return err; @@ -216,7 +205,7 @@ error_t hal_get_reserved_regions_iterator(hal_reserved_memory_iterator_t* iterOU if (err) return err; - const riscv_hal_res_mem_iter_t init = { + const internal_res_mem_iter_t init = { .memreserve_idx = 0, .is_in_resmem = false, .resmem_current_node = resmem_first_node, @@ -224,7 +213,7 @@ error_t hal_get_reserved_regions_iterator(hal_reserved_memory_iterator_t* iterOU .resmem_size_cells = size_cells, .resmem_reg_idx = 0, }; - *(riscv_hal_res_mem_iter_t*)iterOUT = init; + *(internal_res_mem_iter_t*)iterOUT = init; return ERR_NONE; } @@ -233,11 +222,11 @@ error_t hal_get_next_reserved_region(hal_reserved_memory_iterator_t* iter, memor return ERR_BAD_ARG; const fdt_t* fdt; - error_t err = hal_riscv_get_fdt(&fdt); + error_t err = s_get_fdt(&fdt); if (err) return err; - riscv_hal_res_mem_iter_t next_iter = *(riscv_hal_res_mem_iter_t*)iter; + internal_res_mem_iter_t next_iter = *(internal_res_mem_iter_t*)iter; if (!next_iter.is_in_resmem) { fdt_rsv_entry entry; @@ -248,7 +237,7 @@ error_t hal_get_next_reserved_region(hal_reserved_memory_iterator_t* iter, memor .size = entry.size, }; next_iter.memreserve_idx += 1; - *(riscv_hal_res_mem_iter_t*)iter = next_iter; + *(internal_res_mem_iter_t*)iter = next_iter; *areaOUT = area; return ERR_NONE; } @@ -262,8 +251,8 @@ error_t hal_get_next_reserved_region(hal_reserved_memory_iterator_t* iter, memor while (next_iter.resmem_current_node) { u64 addr; u64 size; - err = hal_riscv_read_reg_entry(fdt, next_iter.resmem_current_node, next_iter.resmem_reg_idx, - next_iter.resmem_address_cells, next_iter.resmem_size_cells, &addr, &size); + err = s_read_reg_entry(fdt, next_iter.resmem_current_node, next_iter.resmem_reg_idx, + next_iter.resmem_address_cells, next_iter.resmem_size_cells, &addr, &size); if (err != ERR_NONE && err != ERR_NOT_FOUND) { return err; } @@ -273,7 +262,7 @@ error_t hal_get_next_reserved_region(hal_reserved_memory_iterator_t* iter, memor .size = size, }; next_iter.resmem_reg_idx += 1; - *(riscv_hal_res_mem_iter_t*)iter = next_iter; + *(internal_res_mem_iter_t*)iter = next_iter; *areaOUT = area; return ERR_NONE; } @@ -297,15 +286,15 @@ typedef struct { u32 reg_idx; u32 size_cells; u32 address_cells; -} riscv_hal_mem_iter_t; -static_assert(sizeof(riscv_hal_mem_iter_t) <= sizeof(hal_memory_iterator_t)); +} internal_hal_mem_iter_t; +static_assert(sizeof(internal_hal_mem_iter_t) <= sizeof(hal_memory_iterator_t)); error_t hal_get_memory_regions_iterator(hal_memory_iterator_t* iterOUT) { if (iterOUT == nullptr) return ERR_BAD_ARG; const fdt_t* fdt; - error_t err = hal_riscv_get_fdt(&fdt); + error_t err = s_get_fdt(&fdt); if (err) return err; @@ -316,17 +305,17 @@ error_t hal_get_memory_regions_iterator(hal_memory_iterator_t* iterOUT) { return err; dt_node_t first_memory_node; - err = hal_riscv_find_next_memory_node(fdt, 0, &first_memory_node); + err = s_find_next_memory_node(fdt, 0, &first_memory_node); if (err) return err; - const riscv_hal_mem_iter_t init = { + const internal_hal_mem_iter_t init = { .node = first_memory_node, .reg_idx = 0, .size_cells = size_cells, .address_cells = address_cells, }; - *(riscv_hal_mem_iter_t*)iterOUT = init; + *(internal_hal_mem_iter_t*)iterOUT = init; return ERR_NONE; } @@ -334,10 +323,10 @@ error_t hal_get_next_memory_region(hal_memory_iterator_t* iter, physical_memory_ if (iter == nullptr || areaOUT == nullptr) return ERR_BAD_ARG; - riscv_hal_mem_iter_t next_iter = *(riscv_hal_mem_iter_t*)iter; + internal_hal_mem_iter_t next_iter = *(internal_hal_mem_iter_t*)iter; const fdt_t* fdt; - error_t err = hal_riscv_get_fdt(&fdt); + error_t err = s_get_fdt(&fdt); if (err) return err; @@ -347,7 +336,7 @@ error_t hal_get_next_memory_region(hal_memory_iterator_t* iter, physical_memory_ while (next_iter.node != 0) { u64 addr; u64 size; - err = hal_riscv_read_reg_entry(fdt, next_iter.node, next_iter.reg_idx, address_cells, size_cells, &addr, &size); + err = s_read_reg_entry(fdt, next_iter.node, next_iter.reg_idx, address_cells, size_cells, &addr, &size); if (err != ERR_NONE && err != ERR_NOT_FOUND) { return err; } @@ -357,13 +346,13 @@ error_t hal_get_next_memory_region(hal_memory_iterator_t* iter, physical_memory_ .size = size, }; next_iter.reg_idx += 1; - *(riscv_hal_mem_iter_t*)iter = next_iter; + *(internal_hal_mem_iter_t*)iter = next_iter; *areaOUT = area; return ERR_NONE; } dt_node_t next_memory_node; - err = hal_riscv_find_next_memory_node(fdt, next_iter.node, &next_memory_node); + err = s_find_next_memory_node(fdt, next_iter.node, &next_memory_node); if (err == ERR_NONE) { next_iter.node = next_memory_node; next_iter.reg_idx = 0; diff --git a/src/kernel/memory_management/physical_memory/manager.c b/src/kernel/memory_management/physical_memory/manager.c index 771e56ba..3b7b3f5d 100644 --- a/src/kernel/memory_management/physical_memory/manager.c +++ b/src/kernel/memory_management/physical_memory/manager.c @@ -23,12 +23,12 @@ typedef struct { static __phys header_storage_node_t* g_root_header_storage_node = nullptr; -bool get_next_reserved_region(void* user, memory_area_t* areaOUT) { +static bool s_get_next_reserved_region(void* user, memory_area_t* areaOUT) { hal_reserved_memory_iterator_t* iter = user; return hal_get_next_reserved_region(iter, areaOUT) == ERR_NONE; } -static error_t init_header_storage_node(physical_memory_region_t storage_region) { +static error_t s_init_header_storage_node(physical_memory_region_t storage_region) { header_storage_node_t* effective_hsn = physical_to_effective(g_root_header_storage_node); effective_hsn->max_count = (storage_region.size - sizeof(header_storage_node_t)) / sizeof(physical_memory_region_t); effective_hsn->count = 0; @@ -39,7 +39,7 @@ static error_t init_header_storage_node(physical_memory_region_t storage_region) } [[gnu::nonnull]] -static error_t get_header_pmr(u32 idx, physical_memory_region_t* headerOUT) { +static error_t s_get_header_pmr(u32 idx, physical_memory_region_t* headerOUT) { header_storage_node_t* effective_hsn = physical_to_effective(g_root_header_storage_node); while (idx > (effective_hsn->count - 1)) { idx -= effective_hsn->count; @@ -51,7 +51,7 @@ static error_t get_header_pmr(u32 idx, physical_memory_region_t* headerOUT) { return ERR_NONE; } -static error_t store_header(physical_memory_region_t header) { +static error_t s_store_header(physical_memory_region_t header) { header_storage_node_t* effective_hsn = physical_to_effective(g_root_header_storage_node); while (effective_hsn->count == effective_hsn->max_count) { if (effective_hsn->next != nullptr) { @@ -61,7 +61,7 @@ static error_t store_header(physical_memory_region_t header) { error_t err = phys_mem_alloc_frame(FRAME_ORDER_4KiB, &new_reg); if (err) return err; - err = init_header_storage_node(new_reg); + err = s_init_header_storage_node(new_reg); if (err) return err; KLOGLN_TRACE("New region for storage of physical region headers was added of size: %zu at addra: %p", @@ -109,7 +109,7 @@ error_t phys_mem_init() { KLOGLN_ERROR("Failed to reset reserved memory regions iterator"); return ERR_NOT_VALID; } - err = pmallocator_get_header(pmr_area, get_next_reserved_region, &iter, &header_area); + err = pmallocator_get_header(pmr_area, s_get_next_reserved_region, &iter, &header_area); if (err) { KLOGLN_WARNING("Failed to get header region of memory region [%p - %p]", pmr.addr, pmr.addr + pmr.size); continue; @@ -126,7 +126,7 @@ error_t phys_mem_init() { KLOGLN_ERROR("Failed to reset reserved memory regions iterator"); return ERR_NOT_VALID; } - err = pmallocator_init_region(pmr_area, header_eff_reg, get_next_reserved_region, &iter); + err = pmallocator_init_region(pmr_area, header_eff_reg, s_get_next_reserved_region, &iter); if (err) { KLOGLN_WARNING("Failed to init header region of memory region [%p - %p]", pmr.addr, pmr.addr + pmr.size); continue; @@ -150,7 +150,7 @@ error_t phys_mem_init() { .addr = (__phys void*)new_area.addr, .size = new_area.size, }; - err = init_header_storage_node(new_reg); + err = s_init_header_storage_node(new_reg); if (err) { // No need to free this region since this error is, and should be, fatal KLOG_ERROR("4KiB was not enough to store any header regions. A single header region should be nowhere " @@ -161,7 +161,7 @@ error_t phys_mem_init() { g_root_header_storage_node = new_reg.addr; } - err = store_header(header_pmr); + err = s_store_header(header_pmr); if (err) KLOG_DO_RETURN(ERR_OUT_OF_BOUNDS, KLRF_TRACE_ERR | KLRF_END_BLOCK); } @@ -173,7 +173,7 @@ error_t phys_mem_init() { error_t phys_mem_alloc_frame(frame_order_t frame_size, physical_memory_region_t* regOUT) { u32 idx = 0; physical_memory_region_t header_pmr; - while (get_header_pmr(idx, &header_pmr) == ERR_NONE) { + while (s_get_header_pmr(idx, &header_pmr) == ERR_NONE) { memory_region_t header_region = physical_memory_region_to_effective(header_pmr); memory_area_t area_out; error_t err = pmallocator_allocate(frame_size, header_region, &area_out); @@ -197,7 +197,7 @@ error_t phys_mem_alloc_frame(frame_order_t frame_size, physical_memory_region_t* error_t phys_mem_free_frame(physical_memory_region_t reg) { u32 idx = 0; physical_memory_region_t header_pmr; - while (get_header_pmr(idx, &header_pmr) == ERR_NONE) { + while (s_get_header_pmr(idx, &header_pmr) == ERR_NONE) { memory_region_t header_region = physical_memory_region_to_effective(header_pmr); memory_area_t area = physical_memory_region_to_area(reg); error_t err = pmallocator_free(area, header_region); diff --git a/tests/kernel/hal/CMakeLists.txt b/tests/kernel/hal/CMakeLists.txt new file mode 100644 index 00000000..2e47f342 --- /dev/null +++ b/tests/kernel/hal/CMakeLists.txt @@ -0,0 +1,6 @@ +file(GLOB CHILDREN RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *) +foreach(CHILD ${CHILDREN}) + if(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${CHILD}) + add_subdirectory(${CHILD}) + endif() +endforeach() diff --git a/tests/kernel/hal/riscv/CMakeLists.txt b/tests/kernel/hal/riscv/CMakeLists.txt new file mode 100644 index 00000000..d0377dfe --- /dev/null +++ b/tests/kernel/hal/riscv/CMakeLists.txt @@ -0,0 +1,9 @@ +SETUP_UNIT_TEST(hal_memory_regions_test + test_hal_memory_regions.c + ${PROJECT_SOURCE_DIR}/src/kernel/hal/arch/riscv/memory_regions.c) + +target_include_directories(hal_memory_regions_test PRIVATE + ${PROJECT_SOURCE_DIR}/include + ${PROJECT_SOURCE_DIR}/external/include + ${PROJECT_SOURCE_DIR}/src/kernel +) diff --git a/tests/kernel/memory_management/physical_memory/test_hal_memory_regions.c b/tests/kernel/hal/riscv/test_hal_memory_regions.c similarity index 86% rename from tests/kernel/memory_management/physical_memory/test_hal_memory_regions.c rename to tests/kernel/hal/riscv/test_hal_memory_regions.c index 01f3861e..42565379 100644 --- a/tests/kernel/memory_management/physical_memory/test_hal_memory_regions.c +++ b/tests/kernel/hal/riscv/test_hal_memory_regions.c @@ -1,8 +1,8 @@ #include -#include "hal/include/memory_regions.h" +#include #include -#include +#include "hal/include/memory_regions.h" static bool g_hal_initialized = true; static int g_fake_dtb; @@ -45,16 +45,16 @@ static const u8 s_memory_word[] = {'m', 'e', 'm', 'o', 'r', 'y'}; // address_cells=1, size_cells=1 => each entry is 8 bytes (u32 addr + u32 size), big-endian. static const u8 s_reg_memory_a[] = { - 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, // [0x1000, 0x2000] - 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x10, 0x00, // [0x4000, 0x1000] + 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, // [0x1000, 0x2000] + 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x10, 0x00, // [0x4000, 0x1000] }; static const u8 s_reg_memory_b[] = { - 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x10, 0x00, // [0x8000, 0x1000] + 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x10, 0x00, // [0x8000, 0x1000] }; static const u8 s_reg_reserved_child[] = { - 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x20, 0x00, // [0xA000, 0x2000] + 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x20, 0x00, // [0xA000, 0x2000] }; error_t dt_init(const void* fdt, fdt_t* obj) { @@ -66,8 +66,7 @@ error_t dt_init(const void* fdt, fdt_t* obj) { return ERR_NONE; } -void dt_reset([[maybe_unused]] fdt_t* obj) { -} +void dt_reset([[maybe_unused]] fdt_t* obj) {} error_t dt_get_node_in_subtree_by_path(const fdt_t* fdt, dt_node_t node, const char* node_path, dt_node_t* nodeOUT) { (void)fdt; @@ -78,9 +77,7 @@ error_t dt_get_node_in_subtree_by_path(const fdt_t* fdt, dt_node_t node, const c } error_t dt_get_node_by_path(const fdt_t* fdt, const char* node_path, dt_node_t* nodeOUT) { - if (fdt == NULL || node_path == NULL || nodeOUT == NULL) - return ERR_BAD_ARG; - + (void)fdt; if (strcmp(node_path, "/reserved-memory") == 0) { *nodeOUT = NODE_RESERVED_ROOT; return ERR_NONE; @@ -90,9 +87,7 @@ error_t dt_get_node_by_path(const fdt_t* fdt, const char* node_path, dt_node_t* } error_t dt_get_node_child(const fdt_t* fdt, dt_node_t node, dt_node_t* nodeOUT) { - if (fdt == NULL || nodeOUT == NULL) - return ERR_BAD_ARG; - + (void)fdt; if (node == NODE_ROOT) { *nodeOUT = NODE_NON_MEMORY; return ERR_NONE; @@ -107,9 +102,7 @@ error_t dt_get_node_child(const fdt_t* fdt, dt_node_t node, dt_node_t* nodeOUT) } error_t dt_get_node_sibling(const fdt_t* fdt, dt_node_t node, dt_node_t* nodeOUT) { - if (fdt == NULL || nodeOUT == NULL) - return ERR_BAD_ARG; - + (void)fdt; if (node == NODE_NON_MEMORY) { *nodeOUT = NODE_MEMORY_A; return ERR_NONE; @@ -138,9 +131,7 @@ error_t dt_get_node_name_ptr(const fdt_t* fdt, dt_node_t node, const char** ptrO } error_t dt_get_prop_by_name(const fdt_t* fdt, dt_node_t node, const char* prop_name, dt_prop_t* propOUT) { - if (fdt == NULL || prop_name == NULL || propOUT == NULL) - return ERR_BAD_ARG; - + (void)fdt; if (strcmp(prop_name, "device_type") == 0) { if (node == NODE_MEMORY_A) { *propOUT = PROP_DEVICE_TYPE_MEMORY_A; @@ -201,32 +192,21 @@ error_t dt_get_prop_name_ptr(const fdt_t* fdt, dt_prop_t prop, const char** ptrO } error_t dt_get_prop_buffer(const fdt_t* fdt, dt_prop_t prop, buffer_t* bufOUT) { - if (fdt == NULL || bufOUT == NULL) - return ERR_BAD_ARG; - + (void)fdt; switch (prop) { case PROP_DEVICE_TYPE_MEMORY_A: - case PROP_DEVICE_TYPE_MEMORY_B: - *bufOUT = make_buffer((void*)s_memory_word, sizeof(s_memory_word)); - return ERR_NONE; - case PROP_REG_MEMORY_A: - *bufOUT = make_buffer((void*)s_reg_memory_a, sizeof(s_reg_memory_a)); - return ERR_NONE; - case PROP_REG_MEMORY_B: - *bufOUT = make_buffer((void*)s_reg_memory_b, sizeof(s_reg_memory_b)); - return ERR_NONE; + case PROP_DEVICE_TYPE_MEMORY_B: *bufOUT = make_buffer((void*)s_memory_word, sizeof(s_memory_word)); return ERR_NONE; + case PROP_REG_MEMORY_A: *bufOUT = make_buffer((void*)s_reg_memory_a, sizeof(s_reg_memory_a)); return ERR_NONE; + case PROP_REG_MEMORY_B: *bufOUT = make_buffer((void*)s_reg_memory_b, sizeof(s_reg_memory_b)); return ERR_NONE; case PROP_REG_RESERVED_CHILD: *bufOUT = make_buffer((void*)s_reg_reserved_child, sizeof(s_reg_reserved_child)); return ERR_NONE; - default: - return ERR_NOT_FOUND; + default: return ERR_NOT_FOUND; } } error_t dt_get_rsv_mem_entry(const fdt_t* fdt, u32 index, fdt_rsv_entry* entryOUT) { - if (fdt == NULL || entryOUT == NULL) - return ERR_BAD_ARG; - + (void)fdt; if (index == 0) { entryOUT->address = 0x9000; entryOUT->size = 0x1000; @@ -237,9 +217,7 @@ error_t dt_get_rsv_mem_entry(const fdt_t* fdt, u32 index, fdt_rsv_entry* entryOU } error_t dt_get_reg_cell_counts(const fdt_t* fdt, dt_node_t node, u32* address_cellsOUT, u32* size_cellsOUT) { - if (fdt == NULL || address_cellsOUT == NULL || size_cellsOUT == NULL) - return ERR_BAD_ARG; - + (void)fdt; if (node == NODE_ROOT || node == NODE_RESERVED_ROOT) { *address_cellsOUT = 1; *size_cellsOUT = 1; @@ -254,8 +232,7 @@ void setUp(void) { g_hal_initialized = true; } -void tearDown(void) { -} +void tearDown(void) {} static void test_memory_iterator_returns_not_initialized_when_hal_not_ready(void) { g_hal_initialized = false; diff --git a/tests/kernel/memory_management/physical_memory/CMakeLists.txt b/tests/kernel/memory_management/physical_memory/CMakeLists.txt index 34030eaf..dcc6a4b8 100644 --- a/tests/kernel/memory_management/physical_memory/CMakeLists.txt +++ b/tests/kernel/memory_management/physical_memory/CMakeLists.txt @@ -6,13 +6,3 @@ SETUP_UNIT_TEST(pmallocator_test target_include_directories(pmallocator_test PRIVATE ${PROJECT_SOURCE_DIR}/src/kernel ) - -SETUP_UNIT_TEST(hal_memory_regions_test - test_hal_memory_regions.c - ${PROJECT_SOURCE_DIR}/src/kernel/hal/arch/riscv/memory_region.c) - -target_include_directories(hal_memory_regions_test PRIVATE - ${PROJECT_SOURCE_DIR}/include - ${PROJECT_SOURCE_DIR}/external/include - ${PROJECT_SOURCE_DIR}/src/kernel -)