Struct Interrupt

pub struct Interrupt { /* private fields */ }

A hardware interrupt object.

This object provides functionalities to handle hardware interrupts from devices in device drivers:

• Enable interrupts by acquiring the object (Interrupt::create).
• Acknowledge the interrupt (Interrupt::acknowledge).
• Wait for interrupts in an event loop (Mainloop::add_interrupt)

Example

use starina_api::interrupt::Interrupt;
use starina_api::types::interrupt::Irq;

// Ideally, you should get the IRQ from the device tree.
let irq = Irq::new(1);

// Acquire the ownership of the interrupt.
let interrupt = Interrupt::create(irq).unwrap();

// Register the interrupt to the mainloop.
let mut mainloop = Mainloop::new().unwrap();
mainloop
    .add_interrupt(interrupt, Context::Interrupt)
    .unwrap();

// Wait for interrupts in the mainloop...
loop {
    match mainloop.next() {
        Event::Interrupt { ctx: Context::Interrupt, .. } => {
            // Handle the interrupt.
            do_something();

           // Tell the kernel that we have handled the interrupt and are
           // ready for the next one.
            interrupt.acknowledge().unwrap();
        }
        ev => {
            warn!("unexpected event: {:?}", ev);
        }
    }
}

Implementations

impl Interrupt

pub fn create(irq: Irq) -> Result<Interrupt, FtlError>

Creates a new interrupt object for the given IRQ.

pub fn from_handle(handle: OwnedHandle) -> Interrupt

Instantiates the object from the given handle.

pub fn handle(&self) -> &OwnedHandle

Returns the handle.

pub fn acknowledge(&self) -> Result<(), FtlError>

Acknowledges the interrupt.

This tells the CPU (or the interrupt controller) that the interrupt has been handled and we are ready to receive the next one.

Trait Implementations

impl Debug for Interrupt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.