Refactor devicetree parsing and driver interface

[Gelbpunkt]

Ideally, we would let the drivers handle most of the devicetree parsing and keep a mapping of compatibles to drivers so that we can probe all the drivers for the devicetree in use.

We should however abstract away more of the low-level parsing (i.e. expose the defined interrupts and memory regions with a higher-level interface).

A driver would then e.g. define a probe method that takes the devicetree node it was matched on as a parameter. It would then set up interrupt handlers, configure GPIOs, etc.

[Gelbpunkt]

The way Linux handles loading of drivers is fairly simple and what I took inspiration from. A driver has a list of compatibles that it matches on.

Now when the kernel boots, it will look at all devicetree nodes and load the modules which have a compatible in the devicetree in their compatible list.

A lot of things are abstracted over in a generic way - there's methods to register a pin controller, an interrupt controller, request an IRQ, etc., all independent of platform.

Imagine the following: There's a devicetree node for an audio amplifier. It has a reset GPIO that needs to be toggled in order to turn on the amplifier:

	tfa9874: codec@34 {
		compatible = "nxp,tfa9874";
		reg = <0x34>;

		reset-gpio = <&tlmm 12 GPIO_ACTIVE_HIGH>;
		irq-gpio = <&tlmm 56 GPIO_ACTIVE_HIGH>;

		pinctrl-names = "default";
		pinctrl-0 = <&amp_reset_default &amp_int_default>;

		sound-name-prefix = "Speaker";
		#sound-dai-cells = <0>;
	};

Linux sees that this devicetree node has a dependency on the tlmm node, which needs to be bound to a driver first before this one can be initialized. It builds a dependency tree at boot, will then probe the tlmm devicetree node, which registers a pin controller. The driver for the amplifier can then request the GPIO as follows:

reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);

and later set the value:

gpiod_set_value_cansleep(reset_gpio, 1);

This works, independent of the actual pin controller behind it. It knows which one of the registered pin controllers to request it from and which GPIO it is from the devicetree, and all the driver needs to tell the kernel is the name of the GPIO in the devicetree (which is also in the devicetree bindings). Interrupts and other resources function very similarly.

I think we can do something similar in Hermit. It would let us get rid of the devicetree parsing in the architecture specific code, the parsing of the devicetree nodes should be done in the drivers.

Here's a very rough idea of what this could look like:

use fdt::node::FdtNode;
use linkme::distributed_slice;

pub trait Driver: Sync {
    fn name(&self) -> &'static str;

    fn compatibles(&self) -> &'static [&'static str];

    fn probe(&self, fdt: FdtNode);

    fn remove(&self);
}

#[distributed_slice]
pub static DRIVERS: [&'static dyn Driver];

#[macro_export]
macro_rules! register_driver {
    ($i:expr) => {
        #[linkme::distributed_slice(crate::drivers::DRIVERS)]
        static DRIVER: &dyn Driver = &($i) as &dyn Driver;
    };
}

//! Driver for the ARM PrimeCell UART (PL011)

use fdt::node::FdtNode;
use heapless::Vec;
use log::info;

use crate::{drivers::Driver, register_driver};

struct Pl011Uart {
    base_address: u64,
}

// This driver doesn't actually do anything other than getting probed
impl Driver for Pl011Uart {
    fn name(&self) -> &'static str {
        "pl011-uart"
    }

    fn compatibles(&self) -> &'static [&'static str] {
        &["arm,pl011"]
    }

    fn probe(&self, node: FdtNode) {
        // This is where one would do something with the properties in the dts

        // And finally register this as a UART driver
        register_uart_driver(...);
    }

    fn remove(&self) {
        info!("Removed pl011");
    }
}

register_driver!(Pl011Uart { base_address: 0 });

This lets us register drivers without having to maintain a central list of them - the linkme crate takes care of doing that for us. We can then probe all necessary drivers very easily:

    // Probe all of our drivers that hardware is present for
    for driver in drivers::DRIVERS {
        let name = driver.name();
        let compatibles = driver.compatibles();

        for node in fdt.all_nodes() {
            if node
                .compatible()
                .and_then(|compats| compats.all().find(|c| compatibles.contains(c)))
                .is_some()
            {
                info!("Probing driver {name} (matched on {})", node.name);

                driver.probe(node);
            }
        }
    }