Struct Registration 

pub struct Registration<'a, T: Handler> { /* private fields */ }

A registration of an IRQ handler for a given IRQ line.

Examples

The following is an example of using Registration. It uses a Completion to coordinate between the IRQ handler and process context. Completion uses interior mutability, so the handler can signal with Completion::complete_all() and the process context can wait with Completion::wait_for_completion() even though there is no way to get a mutable reference to the any of the fields in Data.

use core::pin::Pin;
use kernel::{
    irq::{
        self,
        Flags,
        IrqRequest,
        IrqReturn,
        Registration,
    },
    prelude::*,
    sync::Completion,
};

// Data shared between process and IRQ context.
#[pin_data]
struct Data {
    #[pin]
    completion: Completion,
}

impl irq::Handler for Data {
    // Executed in IRQ context.
    fn handle(&self) -> IrqReturn {
        self.completion.complete_all();
        IrqReturn::Handled
    }
}

// Registers an IRQ handler for the given IrqRequest.
//
// This runs in process context and assumes `request` was previously acquired from a device.
fn register_irq(
    request: IrqRequest<'_>,
) -> Result<Pin<KBox<Registration<'_, Data>>>> {
    // SAFETY: The returned Registration is not leaked.
    let registration = unsafe {
        Registration::new(
            request,
            Flags::SHARED,
            c"my_device",
            try_pin_init!(Data {
                completion <- Completion::new(),
            }? Error),
        )
    };

    let registration = KBox::pin_init(registration, GFP_KERNEL)?;

    registration.handler().completion.wait_for_completion();

    Ok(registration)
}

Invariants

• We own an irq handler registered via request_irq whose cookie is a pointer to Self.

Implementations

impl<'a, T: Handler> Registration<'a, T>

pub fn project<'__pin>( self: Pin<&'__pin mut Self>, ) -> RegistrationProjection<'__pin, 'a, T>

Pin-projects all fields of Self.

These fields are structurally pinned:

• handler
• _pin

These fields are not structurally pinned:

• request

impl<'a, T: Handler> Registration<'a, T>

pub unsafe fn new( request: IrqRequest<'a>, flags: Flags, name: &'static CStr, handler: impl PinInit<T, Error> + 'a, ) -> impl PinInit<Self, Error> + 'a

where T: 'a,

Registers the IRQ handler with the system for the given IRQ number.

Safety

Callers must not mem::forget() the returned Registration or otherwise prevent its Drop implementation from running.

pub fn handler(&self) -> &T

Returns a reference to the handler that was registered with the system.

pub fn synchronize(&self)

Wait for pending IRQ handlers on other CPUs.

Trait Implementations

impl<'a, T: Handler> Drop for Registration<'a, T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<'a, T: Handler> HasPinData for Registration<'a, T>

type PinData = __ThePinData<'a, T>

unsafe fn __pin_data() -> Self::PinData

impl<T: Handler> PinnedDrop for Registration<'_, T>

fn drop(self: Pin<&mut Self>, _: OnlyCallFromDrop)

Executes the pinned destructor of this type.