#![no_std]

#[macro_use]
pub mod util;

pub mod allocators;
pub mod collections;
pub mod console;
pub mod device_tree;
pub mod drivers;
pub mod interrupts;
pub mod prelude;

#[cfg(not(test))]
mod panic;

use crate::prelude::*;

/// The entrypoint to the kernel. This should be executed by hart0 alone. It performs some early
/// boot tasks, then wakes up any other harts.
///
/// # Safety
///
/// - The `device_tree` pointer must be a valid pointer into physical memory. See
///   `device_tree::FlattenedDeviceTree::from_ptr` for the precise requirements.
/// - This must be called in supervisor mode with paging and traps disabled, but with all traps
///   delegated to supervisor mode.
/// - Any other harts must not be running concurrently with us. TODO: Define their state.
#[no_mangle]
pub unsafe extern "C" fn hart0_boot(device_tree: *const u8) -> ! {
    // Set up the logger.
    //
    // TODO: This should really be named something better than console.
    console::init();

    // Parse the DeviceTree.
    let flattened_device_tree = unsafe { device_tree::FlattenedDeviceTree::from_ptr(device_tree) }
        .expect("invalid DeviceTree");

    // Find the available physical memory areas and initialize the physical memory
    // free-list.
    flattened_device_tree
        .for_each_node(|node| {
            if node.is_unit(&["", "cpus"]) {
                // TODO: Do this later.
                if let Some(timebase_frequency) = node.get_prop_u32("timebase-frequency") {
                    // SAFETY: Other harts are not concurrently running, so they can't be
                    // concurrently accessing or modifying this.
                    unsafe {
                        drivers::riscv_timer::TIMEBASE_FREQUENCY = timebase_frequency;
                    }
                }
            } else if node.is_unit(&["", "memory"]) {
                // Get the memory ranges.
                let Some(reg) = node.get_reg_usize() else {
                    warn!("{}reg was not valid", node.name());
                    return Ok(());
                };

                for (addr, size) in reg {
                    info!("found memory: addr = {addr:#x}, size = {size:#x}");
                }
            }
            Ok(())
        })
        .unwrap_or_else(|err| void::unreachable(err));

    // After this point, everything else is for debugging.
    interrupts::example_timer();
    info!("sleeping forever...");
    loop {
        unsafe { core::arch::asm!("wfi") }
    }
}