rdrive/register/
mod.rs

1use alloc::{collections::btree_map::BTreeMap, vec::Vec};
2use core::ops::Deref;
3
4pub use crate::probe::fdt::FdtInfo;
5use crate::{custom_id, probe::fdt};
6pub use fdt_parser::Node;
7
8#[repr(transparent)]
9#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
10pub struct ProbePriority(pub usize);
11
12impl ProbePriority {
13    pub const CLK: ProbePriority = ProbePriority(6);
14    pub const INTC: ProbePriority = ProbePriority(10);
15    pub const DEFAULT: ProbePriority = ProbePriority(256);
16}
17
18impl From<usize> for ProbePriority {
19    fn from(value: usize) -> Self {
20        Self(value)
21    }
22}
23
24#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
25pub enum ProbeLevel {
26    PreKernel,
27    PostKernel,
28}
29
30impl ProbeLevel {
31    pub const fn new() -> Self {
32        Self::PostKernel
33    }
34}
35
36impl Default for ProbeLevel {
37    fn default() -> Self {
38        Self::new()
39    }
40}
41
42#[derive(Clone)]
43pub struct DriverRegister {
44    pub name: &'static str,
45    pub level: ProbeLevel,
46    pub priority: ProbePriority,
47    pub probe_kinds: &'static [ProbeKind],
48}
49
50unsafe impl Send for DriverRegister {}
51unsafe impl Sync for DriverRegister {}
52
53pub enum ProbeKind {
54    Fdt {
55        compatibles: &'static [&'static str],
56        on_probe: fdt::FnOnProbe,
57    },
58}
59
60#[repr(C)]
61pub struct DriverRegisterSlice {
62    data: *const u8,
63    len: usize,
64}
65
66impl DriverRegisterSlice {
67    pub fn from_raw(data: &'static [u8]) -> Self {
68        Self {
69            data: data.as_ptr(),
70            len: data.len(),
71        }
72    }
73
74    pub fn as_slice(&self) -> &[DriverRegister] {
75        if self.len == 0 {
76            return &[];
77        }
78        unsafe {
79            core::slice::from_raw_parts(self.data as _, self.len / size_of::<DriverRegister>())
80        }
81    }
82    pub fn empty() -> Self {
83        Self {
84            data: core::ptr::null(),
85            len: 0,
86        }
87    }
88}
89
90impl Deref for DriverRegisterSlice {
91    type Target = [DriverRegister];
92
93    fn deref(&self) -> &Self::Target {
94        self.as_slice()
95    }
96}
97
98#[derive(Clone)]
99pub struct DriverRegisterData {
100    pub id: RegisterId,
101    pub probed: bool,
102    pub register: DriverRegister,
103}
104
105#[derive(Default)]
106pub struct RegisterContainer {
107    id_iter: usize,
108    registers: BTreeMap<RegisterId, DriverRegisterData>,
109}
110
111impl RegisterContainer {
112    pub const fn new() -> Self {
113        Self {
114            registers: BTreeMap::new(),
115            id_iter: 0,
116        }
117    }
118
119    pub fn add(&mut self, register: DriverRegister) {
120        self.id_iter += 1;
121        let id = RegisterId(self.id_iter);
122
123        self.registers.insert(
124            id,
125            DriverRegisterData {
126                id,
127                register,
128                probed: false,
129            },
130        );
131    }
132
133    pub fn append(&mut self, register: &[DriverRegister]) {
134        for one in register {
135            self.add(one.clone());
136        }
137    }
138
139    pub fn set_probed(&mut self, register_id: RegisterId) {
140        if let Some(elem) = self.registers.get_mut(&register_id) {
141            elem.probed = true;
142        }
143    }
144
145    pub fn unregistered(&self) -> Vec<DriverRegisterData> {
146        self.registers
147            .iter()
148            .filter_map(|(_, r)| if r.probed { None } else { Some(r.clone()) })
149            .collect()
150    }
151}
152
153custom_id!(RegisterId, usize);
rdrive/register/mod.rs

rdrive/register/
mod.rs
