Trait Driver

pub trait Driver: Send {
    type IdInfo: 'static;

    const ID_TABLE: IdTable<Self::IdInfo>;

    // Required method
    fn probe(
        dev: &Device<Core>,
        id_info: &Self::IdInfo,
    ) -> Result<Pin<KBox<Self>>>;

    // Provided method
    fn unbind(dev: &Device<Core>, this: Pin<&Self>) { ... }
}

The PCI driver trait.

Examples

 struct MyDriver;

 kernel::pci_device_table!(
     PCI_TABLE,
     MODULE_PCI_TABLE,
     <MyDriver as pci::Driver>::IdInfo,
     [
         (
             pci::DeviceId::from_id(bindings::PCI_VENDOR_ID_REDHAT, bindings::PCI_ANY_ID as u32),
             (),
         )
     ]
 );

 impl pci::Driver for MyDriver {
     type IdInfo = ();
     const ID_TABLE: pci::IdTable<Self::IdInfo> = &PCI_TABLE;

     fn probe(
         _pdev: &pci::Device<Core>,
         _id_info: &Self::IdInfo,
     ) -> Result<Pin<KBox<Self>>> {
         Err(ENODEV)
     }
 }

Drivers must implement this trait in order to get a PCI driver registered. Please refer to the Adapter documentation for an example.

Required Associated Constants

const ID_TABLE: IdTable<Self::IdInfo>

The table of device ids supported by the driver.

Required Associated Types

type IdInfo: 'static

The type holding information about each device id supported by the driver.

Required Methods

fn probe(dev: &Device<Core>, id_info: &Self::IdInfo) -> Result<Pin<KBox<Self>>>

PCI driver probe.

Called when a new platform device is added or discovered. Implementers should attempt to initialize the device here.

Provided Methods

fn unbind(dev: &Device<Core>, this: Pin<&Self>)

Platform driver unbind.

Called when a Device is unbound from its bound Driver. Implementing this callback is optional.

This callback serves as a place for drivers to perform teardown operations that require a &Device<Core> or &Device<Bound> reference. For instance, drivers may try to perform I/O operations to gracefully tear down the device.

Otherwise, release operations for driver resources should be performed in Self::drop.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors