Struct ThreadedRegistration

pub struct ThreadedRegistration<T: ThreadedHandler + 'static> { /* private fields */ }

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

Two callbacks are required: one to handle the IRQ, and one to handle any other work in a separate thread.

The thread handler is only called if the IRQ handler returns ThreadedIrqReturn::WakeThread.

Examples

The following is an example of using ThreadedRegistration. It uses a Mutex to provide interior mutability.

use kernel::c_str;
use kernel::device::{Bound, Device};
use kernel::irq::{
  self, Flags, IrqRequest, IrqReturn, ThreadedHandler, ThreadedIrqReturn,
  ThreadedRegistration,
};
use kernel::prelude::*;
use kernel::sync::{Arc, Mutex};

// Declare a struct that will be passed in when the interrupt fires. The u32
// merely serves as an example of some internal data.
//
// [`irq::ThreadedHandler::handle`] takes `&self`. This example
// illustrates how interior mutability can be used when sharing the data
// between process context and IRQ context.
#[pin_data]
struct Data {
    #[pin]
    value: Mutex<u32>,
}

impl ThreadedHandler for Data {
    // This will run (in a separate kthread) if and only if
    // [`ThreadedHandler::handle`] returns [`WakeThread`], which it does by
    // default.
    fn handle_threaded(&self, _dev: &Device<Bound>) -> IrqReturn {
        let mut data = self.value.lock();
        *data += 1;
        IrqReturn::Handled
    }
}

// Registers a threaded IRQ handler for the given [`IrqRequest`].
//
// This is executing in process context and assumes that `request` was
// previously acquired from a device.
fn register_threaded_irq(
    handler: impl PinInit<Data, Error>,
    request: IrqRequest<'_>,
) -> Result<Arc<ThreadedRegistration<Data>>> {
    let registration =
        ThreadedRegistration::new(request, Flags::SHARED, c_str!("my_device"), handler);

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

    {
        // The data can be accessed from process context too.
        let mut data = registration.handler().value.lock();
        *data += 1;
    }

    Ok(registration)
}

Invariants

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

Implementations

impl<T: ThreadedHandler + 'static> ThreadedRegistration<T>

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

Pin-projects all fields of Self.

These fields are structurally pinned:

• inner
• handler
• _pin

These fields are not structurally pinned:

impl<T: ThreadedHandler + 'static> ThreadedRegistration<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: ThreadedHandler + 'static> HasPinData for ThreadedRegistration<T>

type PinData = __ThePinData<T>

unsafe fn __pin_data() -> Self::PinData