Allow callers to write Class::STORAGE_SCSI instead of
bindings::PCI_CLASS_STORAGE_SCSI, for example.
New APIs:
Class::STORAGE_SCSI, Class::NETWORK_ETHERNET, etc.
Class::from_u32(), as_u32()
Class::MASK_FULL, MASK_CLASS_SUBCLASS
DeviceId::from_class_and_vendor()
Device::class_code_raw(), class_enum()
Cc: Danilo Krummrich <dakr@xxxxxxxxxx>
Signed-off-by: John Hubbard <jhubbard@xxxxxxxxxx>
---
rust/kernel/pci.rs | 202 +++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 202 insertions(+)
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index 887ee611b553..9caa1d342d52 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -23,6 +23,179 @@
};
use kernel::prelude::*;
+macro_rules! define_all_pci_classes {
+ (
+ $($variant:ident = $binding:expr,)+
+ ) => {
+ /// Converts a PCI class constant to 24-bit format.
+ ///
+ /// Many device drivers use only the upper 16 bits (base class and subclass), but some
+ /// use the full 24 bits. In order to support both cases, store the class code as a 24-bit
+ /// value, where 16-bit values are shifted up 8 bits.
+ const fn to_24bit_class(val: u32) -> u32 {
+ if val > 0xFFFF { val } else { val << 8 }
+ }
+
+ /// PCI device class codes.
+ ///
+ /// Each entry contains the full 24-bit PCI class code (base class in bits 23-16, subclass
+ /// in bits 15-8, programming interface in bits 7-0).
+ ///
+ #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+ #[repr(transparent)]
+ pub struct Class(u32);
+
+ impl Class {
+ $(
+ #[allow(missing_docs)]
+ pub const $variant: Self = Self(to_24bit_class($binding));
+ )+
+
+ /// Match the full class code.
+ pub const MASK_FULL: u32 = 0xffffff;
+
+ /// Match the upper 16 bits of the class code (base class and subclass only).
+ pub const MASK_CLASS_SUBCLASS: u32 = 0xffff00;
+
+ /// Create a `Class` from the raw class code value, or `None` if the value doesn't
+ /// match any known class.
+ pub fn from_u32(value: u32) -> Option<Self> {
+ match value {
+ $(x if x == Self::$variant.0 => Some(Self::$variant),)+
+ _ => None,
+ }
+ }
+
+ /// Get the raw 24-bit class code value.
+ pub const fn as_u32(self) -> u32 {
+ self.0
+ }
+ }
+ };
+}
+
+define_all_pci_classes! {
+ NOT_DEFINED = bindings::PCI_CLASS_NOT_DEFINED, // 0x000000
+
+ ...
+
+ OTHERS = bindings::PCI_CLASS_OTHERS, // 0xff0000
+}
+
/// An adapter for the registration of PCI drivers.
pub struct Adapter<T: Driver>(T);
@@ -157,6 +330,23 @@ pub const fn from_class(class: u32, class_mask: u32) -> Self {
override_only: 0,
})
}
+
+ /// Create a new `pci::DeviceId` from a class number, mask, and specific vendor.
+ ///
+ /// This is more targeted than [`DeviceId::from_class`]: in addition to matching by Vendor, it
+ /// also matches the PCI Class (up to the entire 24 bits, depending on the mask).
+ pub const fn from_class_and_vendor(class: Class, class_mask: u32, vendor: u32) -> Self {
+ Self(bindings::pci_device_id {
+ vendor,
+ device: DeviceId::PCI_ANY_ID,
+ subvendor: DeviceId::PCI_ANY_ID,
+ subdevice: DeviceId::PCI_ANY_ID,
+ class: class.as_u32(),
+ class_mask,
+ driver_data: 0,
+ override_only: 0,
+ })
+ }
}
// SAFETY: `DeviceId` is a `#[repr(transparent)]` wrapper of `pci_device_id` and does not add
@@ -410,6 +600,18 @@ pub fn resource_len(&self, bar: u32) -> Result<bindings::resource_size_t> {
// - by its type invariant `self.as_raw` is always a valid pointer to a `struct pci_dev`.
Ok(unsafe { bindings::pci_resource_len(self.as_raw(), bar.try_into()?) })
}
+
+ /// Returns the full 24-bit PCI class code as stored in hardware.
+ /// This includes base class, subclass, and programming interface.
+ pub fn class_code_raw(&self) -> u32 {
+ // SAFETY: `self.as_raw` is a valid pointer to a `struct pci_dev`.
+ unsafe { (*self.as_raw()).class }
+ }
+
+ /// Returns the PCI class as a `Class` struct, or `None` if the class code is invalid.
+ pub fn class_enum(&self) -> Option<Class> {
+ Class::from_u32(self.class_code_raw())
+ }
}
impl Device<device::Bound> {
--
2.50.1
