rdrive 0.21.0

A dyn driver manager.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use alloc::{collections::btree_set::BTreeSet, vec::Vec};

use spin::{Mutex, Once};

use crate::{
    Descriptor, PlatformDevice,
    error::DriverError,
    probe::{OnProbeError, ProbeError},
    register::{DriverRegister, ProbeKind},
};

static SYSTEM: Once<System> = Once::new();

pub type FnOnProbe = fn(plat_dev: PlatformDevice) -> Result<(), OnProbeError>;

pub fn init() -> Result<(), DriverError> {
    SYSTEM.call_once(System::new);
    Ok(())
}

pub(crate) fn try_probe_register(
    register: &DriverRegister,
) -> Option<Result<Vec<Result<(), OnProbeError>>, ProbeError>> {
    SYSTEM.get().map(|system| system.probe_register(register))
}

struct System {
    probed_names: Mutex<BTreeSet<&'static str>>,
}

impl System {
    fn new() -> Self {
        Self {
            probed_names: Mutex::new(BTreeSet::new()),
        }
    }

    fn probe_register(
        &self,
        register: &DriverRegister,
    ) -> Result<Vec<Result<(), OnProbeError>>, ProbeError> {
        let mut out = Vec::new();
        for probe in register.probe_kinds {
            let ProbeKind::Static { on_probe } = probe else {
                continue;
            };
            out.push(self.probe_one(register, *on_probe));
        }

        Ok(out)
    }

    fn probe_one(
        &self,
        register: &DriverRegister,
        on_probe: FnOnProbe,
    ) -> Result<(), OnProbeError> {
        if self.probed_names.lock().contains(&register.name) {
            return Err(OnProbeError::NotMatch);
        }

        let mut descriptor = Descriptor::new();
        descriptor.name = register.name;
        let res = on_probe(PlatformDevice::new(descriptor));

        if res.is_ok() {
            self.probed_names.lock().insert(register.name);
        }

        res
    }
}