Struct DeviceManager 

pub struct DeviceManager {
    devices: Mutex<BTreeMap<usize, SharedDevice>>,
    device_by_name: Mutex<BTreeMap<String, SharedDevice>>,
    name_to_id: Mutex<BTreeMap<String, usize>>,
    drivers: Mutex<BTreeMap<DriverPriority, Vec<Box<dyn DeviceDriver>>>>,
    next_device_id: AtomicUsize,
}

DeviceManager

This struct is the main device management system. It handles all devices and drivers with priority-based initialization.

Fields

• devices: A mutex-protected map of all registered devices by ID.
• device_by_name: A mutex-protected map of devices by name.
• name_to_id: A mutex-protected map from device name to device ID.
• drivers: A mutex-protected map of device drivers organized by priority.
• next_device_id: Atomic counter for generating unique device IDs.

Fields

devices: Mutex<BTreeMap<usize, SharedDevice>>

device_by_name: Mutex<BTreeMap<String, SharedDevice>>

name_to_id: Mutex<BTreeMap<String, usize>>

drivers: Mutex<BTreeMap<DriverPriority, Vec<Box<dyn DeviceDriver>>>>

next_device_id: AtomicUsize

Implementations

impl DeviceManager

const fn new() -> Self

pub fn get_manager() -> &'static DeviceManager

pub fn register_device(&self, device: Arc<dyn Device>) -> usize

Register a device with the manager

Arguments

• device: The device to register.

Returns

• The id of the registered device.

Example

let device = Arc::new(MyDevice::new());
let id = DeviceManager::get_manager().register_device(device);

pub fn register_device_with_name( &self, name: String, device: Arc<dyn Device>, ) -> usize

Register a device with the manager by name

Arguments

• name: The name of the device.
• device: The device to register.

Returns

• The id of the registered device.

pub fn get_device(&self, id: usize) -> Option<SharedDevice>

Get a device by ID

Arguments

• id: The id of the device to get.

Returns

• The device if found, or None if not found.

pub fn get_device_by_name(&self, name: &str) -> Option<SharedDevice>

Get a device by name

Arguments

• name: The name of the device to get.

Returns

• The device if found, or None if not found.

pub fn get_device_id_by_name(&self, name: &str) -> Option<usize>

Get a device ID by name

Arguments

• name: The name of the device to find.

Returns

• The device ID if found, or None if not found.

pub fn get_devices_count(&self) -> usize

Get the number of devices

Returns

The number of devices.

pub fn get_first_device_by_type(&self, device_type: DeviceType) -> Option<usize>

Get the first device of a specific type

Arguments

• device_type: The device type to find.

Returns

• The first device ID of the specified type, or None if not found.

pub fn get_named_devices(&self) -> Vec<(String, SharedDevice)>

Get all devices registered by name

Returns an iterator over (name, device) pairs for all devices that were registered with explicit names.

Returns

Vector of (name, device) tuples

pub fn borrow_drivers( &self, ) -> &Mutex<BTreeMap<DriverPriority, Vec<Box<dyn DeviceDriver>>>>

pub fn populate_devices(&self)

Populates devices from the FDT (Flattened Device Tree).

This function searches for the /soc node in the FDT and iterates through its children. For each child node, it checks if there is a compatible driver registered. If a matching driver is found, it probes the device using the driver’s probe method. If the probe is successful, the device is registered with the driver.

Deprecated

Use populate_devices_from_source with DeviceSource::Fdt instead.

pub fn populate_devices_from_source( &self, device_source: &DeviceSource, priorities: Option<&[DriverPriority]>, )

Populate devices using a specific device source

Arguments

• device_source - The source of device information (FDT, UEFI, ACPI, etc.)
• priorities - Optional slice of priority levels to use. If None, uses all priorities in order.

fn populate_devices_from_fdt(&self, priorities: Option<&[DriverPriority]>)

Populate devices from FDT

fn process_priority_level(&self, fdt: &Fdt<'_>, priority: DriverPriority)

Process devices for a single priority level - reduces stack nesting

fn process_single_device_node( &self, child: FdtNode<'_, '_>, priority: DriverPriority, idx: &mut usize, )

Process a single device node with minimal stack usage

fn build_minimal_resources( &self, child: &FdtNode<'_, '_>, ) -> Vec<PlatformDeviceResource>

Build device resources with minimal stack allocation

fn try_match_and_probe_device( &self, child: FdtNode<'_, '_>, priority: DriverPriority, idx: &mut usize, compatible: Vec<&str>, resources: Vec<PlatformDeviceResource>, )

Try to match device with drivers and probe if successful

fn populate_devices_from_uefi(&self, _priorities: Option<&[DriverPriority]>)

Populate devices from UEFI (stub implementation)

Arguments

• priorities - Optional slice of priority levels to use. If None, uses all priorities in order.

Note

This is currently a stub implementation. UEFI device discovery will be implemented when UEFI boot support is added.

fn populate_devices_from_acpi(&self, _priorities: Option<&[DriverPriority]>)

Populate devices from ACPI (stub implementation)

Arguments

• priorities - Optional slice of priority levels to use. If None, uses all priorities in order.

Note

This is currently a stub implementation. ACPI device discovery will be implemented when x86 support is added.

pub fn populate_devices_by_priority( &self, priorities: Option<&[DriverPriority]>, )

Populate devices using drivers of specific priority levels

Arguments

• priorities - Optional slice of priority levels to use. If None, uses all priorities in order.

Deprecated

Use populate_devices_from_source instead.

pub fn register_driver( &self, driver: Box<dyn DeviceDriver>, priority: DriverPriority, )

Registers a device driver with the device manager.

This function takes a boxed device driver and adds it to the list of registered drivers at the specified priority level.

Arguments

• driver - A boxed device driver that implements the DeviceDriver trait.
• priority - The priority level for this driver.

Example

let driver = Box::new(MyDeviceDriver::new());
DeviceManager::get_manager().register_driver(driver, DriverPriority::Standard);

pub fn register_driver_default(&self, driver: Box<dyn DeviceDriver>)

Registers a device driver with default Standard priority.

This is a convenience method for backward compatibility.

Arguments

• driver - A boxed device driver that implements the DeviceDriver trait.