Trait Driver

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

    const OF_ID_TABLE: Option<IdTable<Self::IdInfo>> = None;
    const ACPI_ID_TABLE: Option<IdTable<Self::IdInfo>> = None;

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

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

The platform driver trait.

Drivers must implement this trait in order to get a platform driver registered.

Examples

 struct MyDriver;

 kernel::of_device_table!(
     OF_TABLE,
     MODULE_OF_TABLE,
     <MyDriver as platform::Driver>::IdInfo,
     [
         (of::DeviceId::new(c_str!("test,device")), ())
     ]
 );

 kernel::acpi_device_table!(
     ACPI_TABLE,
     MODULE_ACPI_TABLE,
     <MyDriver as platform::Driver>::IdInfo,
     [
         (acpi::DeviceId::new(c_str!("LNUXBEEF")), ())
     ]
 );

 impl platform::Driver for MyDriver {
     type IdInfo = ();
     const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = Some(&OF_TABLE);
     const ACPI_ID_TABLE: Option<acpi::IdTable<Self::IdInfo>> = Some(&ACPI_TABLE);

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

Provided Associated Constants

const OF_ID_TABLE: Option<IdTable<Self::IdInfo>> = None

The table of OF device ids supported by the driver.

const ACPI_ID_TABLE: Option<IdTable<Self::IdInfo>> = None

The table of ACPI device ids supported by the driver.

Required Associated Types

type IdInfo: 'static

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

Required Methods

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

Platform 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