ids_rs 0.1.0

A no_std PCI device identification library for operating systems
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! PCI device definitions and utilities.

use crate::types::{DeviceId, SubvendorId, SubdeviceId};

/// Represents a PCI subsystem device.
#[derive(Debug, Clone)]
pub struct Subsystem {
    /// The subvendor ID
    pub subvendor_id: SubvendorId,
    /// The subdevice ID
    pub subdevice_id: SubdeviceId,
    /// The subsystem name
    pub name: &'static str,
}

impl Subsystem {
    /// Create a new subsystem.
    #[inline]
    pub const fn new(subvendor_id: SubvendorId, subdevice_id: SubdeviceId, name: &'static str) -> Self {
        Self {
            subvendor_id,
            subdevice_id,
            name,
        }
    }

    /// Get the subvendor ID.
    #[inline]
    pub const fn subvendor_id(&self) -> SubvendorId {
        self.subvendor_id
    }

    /// Get the subdevice ID.
    #[inline]
    pub const fn subdevice_id(&self) -> SubdeviceId {
        self.subdevice_id
    }

    /// Get the subsystem name.
    #[inline]
    pub const fn name(&self) -> &'static str {
        self.name
    }
}

impl PartialEq for Subsystem {
    fn eq(&self, other: &Self) -> bool {
        self.subvendor_id == other.subvendor_id && self.subdevice_id == other.subdevice_id
    }
}

impl Eq for Subsystem {}

/// Represents a PCI device.
#[derive(Debug, Clone)]
pub struct Device {
    /// The device ID
    pub id: DeviceId,
    /// The device name
    pub name: &'static str,
    /// The subsystems for this device
    pub subsystems: &'static [Subsystem],
}

impl Device {
    /// Create a new device.
    #[inline]
    pub const fn new(id: DeviceId, name: &'static str, subsystems: &'static [Subsystem]) -> Self {
        Self { id, name, subsystems }
    }

    /// Get the device ID.
    #[inline]
    pub const fn id(&self) -> DeviceId {
        self.id
    }

    /// Get the device name.
    #[inline]
    pub const fn name(&self) -> &'static str {
        self.name
    }

    /// Get all subsystems for this device.
    #[inline]
    pub const fn subsystems(&self) -> &'static [Subsystem] {
        self.subsystems
    }

    /// Find a specific subsystem by subvendor and subdevice IDs.
    pub fn find_subsystem(&self, subvendor_id: SubvendorId, subdevice_id: SubdeviceId) -> Option<&Subsystem> {
        self.subsystems.iter().find(|subsystem| {
            subsystem.subvendor_id == subvendor_id && subsystem.subdevice_id == subdevice_id
        })
    }

    /// Get the number of subsystems for this device.
    #[inline]
    pub const fn subsystem_count(&self) -> usize {
        self.subsystems.len()
    }

    /// Check if this device has a specific subsystem.
    pub fn has_subsystem(&self, subvendor_id: SubvendorId, subdevice_id: SubdeviceId) -> bool {
        self.find_subsystem(subvendor_id, subdevice_id).is_some()
    }

    /// Iterate over all subsystems for this device.
    pub fn iter_subsystems(&self) -> core::slice::Iter<'_, Subsystem> {
        self.subsystems.iter()
    }
}

impl PartialEq for Device {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl Eq for Device {}

impl PartialOrd for Device {
    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Device {
    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
        self.id.cmp(&other.id)
    }
}