Enum AlertPeripheral

#[repr(u32)]
pub enum AlertPeripheral {
    Uart0 = 0,
    Uart1 = 1,
    Uart2 = 2,
    Uart3 = 3,
    Gpio = 4,
    SpiDevice = 5,
    I2c0 = 6,
    I2c1 = 7,
    I2c2 = 8,
    Pattgen = 9,
    RvTimer = 10,
    OtpCtrl = 11,
    LcCtrl = 12,
    SpiHost0 = 13,
    SpiHost1 = 14,
    Usbdev = 15,
    PwrmgrAon = 16,
    RstmgrAon = 17,
    ClkmgrAon = 18,
    SysrstCtrlAon = 19,
    AdcCtrlAon = 20,
    PwmAon = 21,
    PinmuxAon = 22,
    AonTimerAon = 23,
    SensorCtrl = 24,
    SramCtrlRetAon = 25,
    FlashCtrl = 26,
    RvDm = 27,
    RvPlic = 28,
    Aes = 29,
    Hmac = 30,
    Kmac = 31,
    Otbn = 32,
    Keymgr = 33,
    Csrng = 34,
    EntropySrc = 35,
    Edn0 = 36,
    Edn1 = 37,
    SramCtrlMain = 38,
    RomCtrl = 39,
    RvCoreIbex = 40,
}

Alert Handler Source Peripheral.

Enumeration used to determine which peripheral asserted the corresponding alert.

Variants

Uart0 = 0

uart0

Uart1 = 1

uart1

Uart2 = 2

uart2

Uart3 = 3

uart3

Gpio = 4

gpio

SpiDevice = 5

spi_device

I2c0 = 6

i2c0

I2c1 = 7

i2c1

I2c2 = 8

i2c2

Pattgen = 9

pattgen

RvTimer = 10

rv_timer

OtpCtrl = 11

otp_ctrl

LcCtrl = 12

lc_ctrl

SpiHost0 = 13

spi_host0

SpiHost1 = 14

spi_host1

Usbdev = 15

usbdev

PwrmgrAon = 16

pwrmgr_aon

RstmgrAon = 17

rstmgr_aon

ClkmgrAon = 18

clkmgr_aon

SysrstCtrlAon = 19

sysrst_ctrl_aon

AdcCtrlAon = 20

adc_ctrl_aon

PwmAon = 21

pwm_aon

PinmuxAon = 22

pinmux_aon

AonTimerAon = 23

aon_timer_aon

SensorCtrl = 24

sensor_ctrl

SramCtrlRetAon = 25

sram_ctrl_ret_aon

FlashCtrl = 26

flash_ctrl

RvDm = 27

rv_dm

RvPlic = 28

rv_plic

Aes = 29

aes

Hmac = 30

hmac

Kmac = 31

kmac

Otbn = 32

otbn

Keymgr = 33

keymgr

Csrng = 34

csrng

EntropySrc = 35

entropy_src

Edn0 = 36

edn0

Edn1 = 37

edn1

SramCtrlMain = 38

sram_ctrl_main

RomCtrl = 39

rom_ctrl

RvCoreIbex = 40

rv_core_ibex

Trait Implementations

impl Clone for AlertPeripheral

fn clone(&self) -> AlertPeripheral

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq for AlertPeripheral

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for AlertPeripheral

impl Eq for AlertPeripheral

impl StructuralPartialEq for AlertPeripheral