Struct Registration

pub struct Registration<T: Handler + 'static> { /* 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 kernel::c_str;
use kernel::device::{Bound, Device};
use kernel::irq::{self, Flags, IrqRequest, IrqReturn, Registration};
use kernel::prelude::*;
use kernel::sync::{Arc, 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, _dev: &Device<Bound>) -> 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(
    handler: impl PinInit<Data, Error>,
    request: IrqRequest<'_>,
) -> Result<Arc<Registration<Data>>> {
    let registration = Registration::new(request, Flags::SHARED, c_str!("my_device"), handler);

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

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

    Ok(registration)
}

Invariants

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

Implementations

impl<T: Handler + 'static> Registration<T>

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

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

pub fn handler(&self) -> &T

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

pub fn try_synchronize(&self) -> Result

Wait for pending IRQ handlers on other CPUs.

This will attempt to access the inner Devres container.

pub fn synchronize(&self, dev: &Device<Bound>) -> Result

Wait for pending IRQ handlers on other CPUs.

Trait Implementations

impl<T: Handler + 'static> HasPinData for Registration<T>

type PinData = __ThePinData<T>

unsafe fn __pin_data() -> Self::PinData