Struct kernel::irq::Flags

pub struct Flags(/* private fields */);

Flags to be used when registering IRQ handlers.

Flags can be used to request specific behaviors when registering an IRQ handler, and can be combined using the |, &, and ! operators to further control the system’s behavior.

A common use case is to register a shared interrupt, as sharing the line between devices is increasingly common in modern systems and is even required for some buses. This requires setting Flags::SHARED when requesting the interrupt. Other use cases include setting the trigger type through Flags::TRIGGER_*, which determines when the interrupt fires, or controlling whether the interrupt is masked after the handler runs by using Flags::ONESHOT.

If an invalid combination of flags is provided, the system will refuse to register the handler, and lower layers will enforce certain flags when necessary. This means, for example, that all the crate::irq::Registration for a shared interrupt have to agree on Flags::SHARED and on the same trigger type, if set.

Implementations

impl Flags

pub const TRIGGER_NONE: Flags = _

Use the interrupt line as already configured.

pub const TRIGGER_RISING: Flags = _

The interrupt is triggered when the signal goes from low to high.

pub const TRIGGER_FALLING: Flags = _

The interrupt is triggered when the signal goes from high to low.

pub const TRIGGER_HIGH: Flags = _

The interrupt is triggered while the signal is held high.

pub const TRIGGER_LOW: Flags = _

The interrupt is triggered while the signal is held low.

pub const SHARED: Flags = _

Allow sharing the IRQ among several devices.

pub const PROBE_SHARED: Flags = _

Set by callers when they expect sharing mismatches to occur.

pub const TIMER: Flags = _

Flag to mark this interrupt as timer interrupt.

pub const PERCPU: Flags = _

Interrupt is per CPU.

pub const NOBALANCING: Flags = _

Flag to exclude this interrupt from irq balancing.

pub const IRQPOLL: Flags = _

Interrupt is used for polling (only the interrupt that is registered first in a shared interrupt is considered for performance reasons).

pub const ONESHOT: Flags = _

Interrupt is not re-enabled after the hardirq handler finished. Used by threaded interrupts which need to keep the irq line disabled until the threaded handler has been run.

pub const NO_SUSPEND: Flags = _

Do not disable this IRQ during suspend. Does not guarantee that this interrupt will wake the system from a suspended state.

pub const FORCE_RESUME: Flags = _

Force enable it on resume even if Flags::NO_SUSPEND is set.

pub const NO_THREAD: Flags = _

Interrupt cannot be threaded.

pub const EARLY_RESUME: Flags = _

Resume IRQ early during syscore instead of at device resume time.

pub const COND_SUSPEND: Flags = _

If the IRQ is shared with a Flags::NO_SUSPEND user, execute this interrupt handler after suspending interrupts. For system wakeup devices users need to implement wakeup detection in their interrupt handlers.

pub const NO_AUTOEN: Flags = _

Don’t enable IRQ or NMI automatically when users request it. Users will enable it explicitly by enable_irq or enable_nmi later.

pub const NO_DEBUG: Flags = _

Exclude from runnaway detection for IPI and similar handlers, depends on PERCPU.

Trait Implementations

impl BitAnd for Flags

type Output = Flags

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitOr for Flags

type Output = Flags

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl Clone for Flags

fn clone(&self) -> Flags

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Not for Flags

type Output = Flags

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for Flags

fn eq(&self, other: &Flags) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Flags

impl Eq for Flags

impl StructuralPartialEq for Flags