Enum StatusCode 

#[repr(u32)]
pub enum StatusCode {
    Success = 0,
    Fail = 1,
    ReadOnly = 2,
    OutOfRange = 3,
    InvalidArgument = 4,
    Timeout = 5,
    NoTransferInProgress = 6,
    FlashSizeError = 100,
    FlashAlignmentError = 101,
    FlashAddressError = 102,
    FlashAccessError = 103,
    FlashProtectionViolation = 104,
    FlashCommandFailure = 105,
    FlashUnknownProperty = 106,
    FlashEraseKeyError = 107,
    FlashRegionExecuteOnly = 108,
    FlashExecInRamNotReady = 109,
    FlashCommandNotSupported = 111,
    FlashReadOnlyProperty = 112,
    FlashInvalidPropertyValue = 113,
    FlashInvalidSpeculationOption = 114,
    FlashEccError = 116,
    FlashCompareError = 117,
    FlashRegulationLoss = 118,
    FlashInvalidWaitStateCycles = 119,
    FlashOutOfDateCfpaPage = 132,
    FlashBlankIfrPageData = 133,
    FlashEncryptedRegionsEraseNotDoneAtOnce = 134,
    FlashProgramVerificationNotAllowed = 135,
    FlashHashCheckError = 136,
    FlashSealedPfrRegion = 137,
    FlashPfrRegionWriteBroken = 138,
    FlashNmpaUpdateNotAllowed = 139,
    FlashCmpaCfgDirectEraseNotAllowed = 140,
    FlashPfrBankIsLocked = 141,
    FlashCfpaScratchPageInvalid = 148,
    FlashCfpaVersionRollbackDisallowed = 149,
    FlashReadHidingAreaDisallowed = 150,
    FlashModifyProtectedAreaDisallowed = 151,
    FlashCommandOperationInProgress = 152,
    I2cSlaveTxUnderrun = 200,
    I2cSlaveRxOverrun = 201,
    I2cArbitrationLost = 202,
    SpiSlaveTxUnderrun = 300,
    SpiSlaveRxOverrun = 301,
    QspiFlashSizeError = 400,
    QspiFlashAlignmentError = 401,
    QspiFlashAddressError = 402,
    QspiFlashCommandFailure = 403,
    QspiFlashUnknownProperty = 404,
    QspiNotConfigured = 405,
    QspiCommandNotSupported = 406,
    QspiCommandTimeout = 407,
    QspiWriteFailure = 408,
    OtfadSecurityViolation = 500,
    OtfadLogicallyDisabled = 501,
    OtfadInvalidKey = 502,
    OtfadInvalidKeyBlob = 503,
    SendingOperationConditionError = 1_812,
    FlexspiSequenceExecutionTimeoutRt5xx = 6_000,
    FlexspiInvalidSequenceRt5xx = 6_001,
    FlexspiDeviceTimeoutRt5xx = 6_002,
    FlexspiSequenceExecutionTimeout = 7_000,
    FlexspiInvalidSequence = 7_001,
    FlexspiDeviceTimeout = 7_002,
    UnknownCommand = 10_000,
    SecurityViolation = 10_001,
    AbortDataPhase = 10_002,
    PingError = 10_003,
    NoResponse = 10_004,
    NoResponseExpected = 10_005,
    UnsupportedCommand = 10_006,
    RomldrSectionOverrun = 10_100,
    RomldrSignature = 10_101,
    RomldrSectionLength = 10_102,
    RomldrUnencryptedOnly = 10_103,
    RomldrEofReached = 10_104,
    RomldrChecksum = 10_105,
    RomldrCrc32Error = 10_106,
    RomldrUnknownCommand = 10_107,
    RomldrIdNotFound = 10_108,
    RomldrDataUnderrun = 10_109,
    RomldrJumpReturned = 10_110,
    RomldrCallFailed = 10_111,
    RomldrKeyNotFound = 10_112,
    RomldrSecureOnly = 10_113,
    RomldrResetReturned = 10_114,
    RomldrRollbackBlocked = 10_115,
    RomldrInvalidSectionMacCount = 10_116,
    RomldrUnexpectedCommand = 10_117,
    RomldrBadSbkek = 10_118,
    RomldrPendingJumpCommand = 10_119,
    MemoryRangeInvalid = 10_200,
    MemoryReadFailed = 10_201,
    MemoryWriteFailed = 10_202,
    MemoryCumulativeWrite = 10_203,
    MemoryAppOverlapWithExecuteOnlyRegion = 10_204,
    MemoryNotConfigured = 10_205,
    MemoryAlignmentError = 10_206,
    MemoryVerifyFailed = 10_207,
    MemoryWriteProtected = 10_208,
    MemoryAddressError = 10_209,
    MemoryBlankCheckFailed = 10_210,
    MemoryBlankPageReadDisallowed = 10_211,
    MemoryProtectedPageReadDisallowed = 10_212,
    MemoryPfrSpecRegionWriteBroken = 10_213,
    MemoryUnsupportedCommand = 10_214,
    UnknownProperty = 10_300,
    ReadOnlyProperty = 10_301,
    InvalidPropertyValue = 10_302,
    AppCrcCheckPassed = 10_400,
    AppCrcCheckFailed = 10_401,
    AppCrcCheckInactive = 10_402,
    AppCrcCheckInvalid = 10_403,
    AppCrcCheckOutOfRange = 10_404,
    PacketizerNoPingResponse = 10_500,
    PacketizerInvalidPacketType = 10_501,
    PacketizerInvalidCrc = 10_502,
    PacketizerNoCommandResponse = 10_503,
    ReliableUpdateSuccess = 10_600,
    ReliableUpdateFail = 10_601,
    ReliableUpdateInactive = 10_602,
    ReliableUpdateBackupapplicationinvalid = 10_603,
    ReliableUpdateStillinmainapplication = 10_604,
    ReliableUpdateSwapsystemnotready = 10_605,
    ReliableUpdateBackupbootloadernotready = 10_606,
    ReliableUpdateSwapindicatoraddressinvalid = 10_607,
    ReliableUpdateSwapsystemnotavailable = 10_608,
    ReliableUpdateSwaptest = 10_609,
    SerialNorEepromAddressInvalid = 10_700,
    SerialNorEepromTransferError = 10_701,
    SerialNorEepromTypeInvalid = 10_702,
    SerialNorEepromSizeInvalid = 10_703,
    SerialNorEepromCommandInvalid = 10_704,
    RomApiNeedMoreData = 10_800,
    RomApiBufferSizeNotEnough = 10_801,
    RomApiInvalidBuffer = 10_802,
    FlexspinandReadPageFail = 20_000,
    FlexspinandReadCacheFail = 20_001,
    FlexspinandEccCheckFail = 20_002,
    FlexspinandPageLoadFail = 20_003,
    FlexspinandPageExecuteFail = 20_004,
    FlexspinandEraseBlockFail = 20_005,
    FlexspinandWaitTimeout = 20_006,
    FlexSpinandNotSupported = 20_007,
    FlexSpinandFcbUpdateFail = 20_008,
    FlexSpinandDbbtUpdateFail = 20_009,
    FlexspinandWritealignmenterror = 20_010,
    FlexspinandNotFound = 20_011,
    FlexspinorProgramFail = 20_100,
    FlexspinorEraseSectorFail = 20_101,
    FlexspinorEraseAllFail = 20_102,
    FlexspinorWaitTimeout = 20_103,
    FlexspinorNotSupported = 20_104,
    FlexspinorWriteAlignmentError = 20_105,
    FlexspinorCommandFailure = 20_106,
    FlexspinorSfdpNotFound = 20_107,
    FlexspinorUnsupportedSfdpVersion = 20_108,
    FlexspinorFlashNotFound = 20_109,
    FlexspinorDtrReadDummyProbeFailed = 20_110,
    OcotpReadFailure = 20_200,
    OcotpProgramFailure = 20_201,
    OcotpReloadFailure = 20_202,
    OcotpWaitTimeout = 20_203,
    SemcnorDeviceTimeout = 21_100,
    SemcnorInvalidMemoryAddress = 21_101,
    SemcnorUnmatchedCommandSet = 21_102,
    SemcnorAddressAlignmentError = 21_103,
    SemcnorInvalidCfiSignature = 21_104,
    SemcnorCommandErrorNoOpToSuspend = 21_105,
    SemcnorCommandErrorNoInfoAvailable = 21_106,
    SemcnorBlockEraseCommandFailure = 21_107,
    SemcnorBufferProgramCommandFailure = 21_108,
    SemcnorProgramVerifyFailure = 21_109,
    SemcnorEraseVerifyFailure = 21_110,
    SemcnorInvalidCfgTag = 21_116,
    SemcnandDeviceTimeout = 21_200,
    SemcnandInvalidMemoryAddress = 21_201,
    SemcnandNotEqualToOnePageSize = 21_202,
    SemcnandMoreThanOnePageSize = 21_203,
    SemcnandEccCheckFail = 21_204,
    SemcnandInvalidOnfiParameter = 21_205,
    SemcnandCannotEnableDeviceEcc = 21_206,
    SemcnandSwitchTimingModeFailure = 21_207,
    SemcnandProgramVerifyFailure = 21_208,
    SemcnandEraseVerifyFailure = 21_209,
    SemcnandInvalidReadbackBuffer = 21_210,
    SemcnandInvalidCfgTag = 21_216,
    SemcnandFailToUpdateFcb = 21_217,
    SemcnandFailToUpdateDbbt = 21_218,
    SemcnandDisallowOverwriteBcb = 21_219,
    SemcnandOnlySupportOnfiDevice = 21_220,
    SemcnandMoreThanMaxImageCopy = 21_221,
    SemcnandDisorderedImageCopies = 21_222,
    SpifinorProgramFail = 22_000,
    SpifinorEraseSectorfail = 22_001,
    SpifinorEraseAllFail = 22_002,
    SpifinorWaitTimeout = 22_003,
    SpifinorNotSupported = 22_004,
    SpifinorWriteAlignmentError = 22_005,
    SpifinorCommandFailure = 22_006,
    SpifinorSfdpNotFound = 22_007,
    EdgelockInvalidResponse = 30_000,
    EdgelockResponseError = 30_001,
    EdgelockAbort = 30_002,
    EdgelockOperationFailed = 30_003,
    EdgelockOtpProgramFailure = 30_004,
    EdgelockOtpLocked = 30_005,
    EdgelockOtpInvalidIdx = 30_006,
    EdgelockInvalidLifecycle = 30_007,
    OtpInvalidAddress = 52_801,
    OtpProgramFail = 52_802,
    OtpCrcFail = 52_803,
    OtpError = 52_804,
    OtpEccCrcFail = 52_805,
    OtpLocked = 52_806,
    OtpTimeout = 52_807,
    OtpCrcCheckPass = 52_808,
    OtpVerifyFail = 52_009,
    SecuritySubsystemError = 1_515_890_085,
    TpGeneralError = 80_000,
    TpCryptoError = 80_001,
    TpNullptrError = 80_002,
    TpAlreadyinitialized = 80_003,
    TpBuffersmall = 80_004,
    TpAddressError = 80_005,
    TpContainerInvalid = 80_006,
    TpContainerentryinvalid = 80_007,
    TpContainerentrynotfound = 80_008,
    TpInvalidstateoperation = 80_009,
    TpCommandError = 80_010,
    TpPufError = 80_011,
    TpFlashError = 80_012,
    TpSecretboxError = 80_013,
    TpPfrError = 80_014,
    TpVerificationError = 80_015,
    TpCfpaError = 80_016,
    TpCmpaError = 80_017,
    TpAddrOutOfRange = 80_018,
    TpContainerAddrError = 80_019,
    TpContainerAddrUnaligned = 80_020,
    TpContainerBuffSmall = 80_021,
    TpContainerNoEntry = 80_022,
    TpCertAddrError = 80_023,
    TpCertAddrUnaligned = 80_024,
    TpCertOverlapping = 80_025,
    TpPacketError = 80_026,
    TpPacketDataError = 80_027,
    TpUnknownCommand = 80_028,
    TpSb3FileError = 80_029,
    TpGeneralCriticalError = 80_101,
    TpCryptoCriticalError = 80_102,
    TpPufCriticalError = 80_103,
    TpPfrCriticalError = 80_104,
    TpPeripheralCriticalError = 80_105,
    TpPrinceCriticalError = 80_106,
    TpShaCheckCriticalError = 80_107,
    IapInvalidArgument = 100_001,
    IapOutOfMemory = 100_002,
    IapReadDisallowed = 100_003,
    IapCumulativeWrite = 100_004,
    IapEraseFailure = 100_005,
    IapCommandNotSupported = 100_006,
    IapMemoryAccessDisabled = 100_007,
    El2goProvSuccess = 1_515_870_810,
    UnknownStatusCode = 3_735_928_559,
}

Bootloader status codes enumeration.

Represents all possible status codes that can be returned by the bootloader. Status codes are organized by subsystem and indicate the result of command execution.

Variants

Success = 0

Command executed successfully

Fail = 1

General failure

ReadOnly = 2

Operation not allowed on read-only target

OutOfRange = 3

Parameter value is out of range

InvalidArgument = 4

Invalid argument provided

Timeout = 5

Operation timed out

NoTransferInProgress = 6

No data transfer currently in progress

FlashSizeError = 100

Flash driver: Size parameter is invalid

FlashAlignmentError = 101

Flash driver: Address alignment is incorrect

FlashAddressError = 102

Flash driver: Address is invalid or out of range

FlashAccessError = 103

Flash driver: Access to flash memory failed

FlashProtectionViolation = 104

Flash driver: Write protection violation

FlashCommandFailure = 105

Flash driver: Flash command execution failed

FlashUnknownProperty = 106

Flash driver: Unknown property requested

FlashEraseKeyError = 107

Flash driver: Erase key does not match programmed key

FlashRegionExecuteOnly = 108

Flash driver: Region is execute-only

FlashExecInRamNotReady = 109

Flash driver: Execute-in-RAM function not ready

FlashCommandNotSupported = 111

Flash driver: Command not supported

FlashReadOnlyProperty = 112

Flash driver: Property is read-only

FlashInvalidPropertyValue = 113

Flash driver: Property value is out of range

FlashInvalidSpeculationOption = 114

Flash driver: Prefetch speculation option is invalid

FlashEccError = 116

Flash driver: ECC error detected

FlashCompareError = 117

Flash driver: Memory contents do not match after verification

FlashRegulationLoss = 118

Flash driver: Regulation lost during read operation

FlashInvalidWaitStateCycles = 119

Flash driver: Wait state cycles setting is invalid

FlashOutOfDateCfpaPage = 132

Flash driver: CFPA page is out of date

FlashBlankIfrPageData = 133

Flash driver: IFR page data is blank

FlashEncryptedRegionsEraseNotDoneAtOnce = 134

Flash driver: Encrypted regions must be erased together

FlashProgramVerificationNotAllowed = 135

Flash driver: Program verification is not allowed

FlashHashCheckError = 136

Flash driver: Hash check failed

FlashSealedPfrRegion = 137

Flash driver: PFR region is sealed

FlashPfrRegionWriteBroken = 138

Flash driver: PFR region write is broken

FlashNmpaUpdateNotAllowed = 139

Flash driver: NMPA update is not allowed

FlashCmpaCfgDirectEraseNotAllowed = 140

Flash driver: CMPA configuration direct erase is not allowed

FlashPfrBankIsLocked = 141

Flash driver: PFR bank is locked

FlashCfpaScratchPageInvalid = 148

Flash driver: CFPA scratch page is invalid

FlashCfpaVersionRollbackDisallowed = 149

Flash driver: CFPA version rollback is disallowed

FlashReadHidingAreaDisallowed = 150

Flash driver: Reading from hiding area is disallowed

FlashModifyProtectedAreaDisallowed = 151

Flash driver: Modifying protected area is disallowed

FlashCommandOperationInProgress = 152

Flash driver: Flash command operation is in progress

I2cSlaveTxUnderrun = 200

I2C driver: Slave transmit underrun

I2cSlaveRxOverrun = 201

I2C driver: Slave receive overrun

I2cArbitrationLost = 202

I2C driver: Arbitration lost on bus

SpiSlaveTxUnderrun = 300

SPI driver: Slave transmit underrun

SpiSlaveRxOverrun = 301

SPI driver: Slave receive overrun

QspiFlashSizeError = 400

QuadSPI driver: Flash size error

QspiFlashAlignmentError = 401

QuadSPI driver: Flash alignment error

QspiFlashAddressError = 402

QuadSPI driver: Flash address error

QspiFlashCommandFailure = 403

QuadSPI driver: Flash command failure

QspiFlashUnknownProperty = 404

QuadSPI driver: Unknown property

QspiNotConfigured = 405

QuadSPI driver: Interface not configured

QspiCommandNotSupported = 406

QuadSPI driver: Command not supported

QspiCommandTimeout = 407

QuadSPI driver: Command timed out

QspiWriteFailure = 408

QuadSPI driver: Write operation failed

OtfadSecurityViolation = 500

OTFAD driver: Security violation detected

OtfadLogicallyDisabled = 501

OTFAD driver: Logically disabled

OtfadInvalidKey = 502

OTFAD driver: Invalid key provided

OtfadInvalidKeyBlob = 503

OTFAD driver: Invalid key blob

SendingOperationConditionError = 1_812

Send operation condition failed

FlexspiSequenceExecutionTimeoutRt5xx = 6_000

FlexSPI: Sequence execution timeout (RT5xx)

FlexspiInvalidSequenceRt5xx = 6_001

FlexSPI: Invalid sequence (RT5xx)

FlexspiDeviceTimeoutRt5xx = 6_002

FlexSPI: Device timeout (RT5xx)

FlexspiSequenceExecutionTimeout = 7_000

FlexSPI: Sequence execution timeout

FlexspiInvalidSequence = 7_001

FlexSPI: Invalid sequence

FlexspiDeviceTimeout = 7_002

FlexSPI: Device timeout

UnknownCommand = 10_000

Bootloader: Unknown command received

SecurityViolation = 10_001

Bootloader: Security violation detected

AbortDataPhase = 10_002

Bootloader: Data phase aborted

PingError = 10_003

Bootloader: Ping command failed

NoResponse = 10_004

Bootloader: No response packet received from target

NoResponseExpected = 10_005

Bootloader: No response expected for this command

UnsupportedCommand = 10_006

Bootloader: Command is not supported

RomldrSectionOverrun = 10_100

ROM loader: Section overrun detected

RomldrSignature = 10_101

ROM loader: Signature verification failed

RomldrSectionLength = 10_102

ROM loader: Section length is invalid

RomldrUnencryptedOnly = 10_103

ROM loader: Only unencrypted content allowed

RomldrEofReached = 10_104

ROM loader: End of file reached

RomldrChecksum = 10_105

ROM loader: Checksum verification failed

RomldrCrc32Error = 10_106

ROM loader: CRC32 verification failed

RomldrUnknownCommand = 10_107

ROM loader: Unknown command received

RomldrIdNotFound = 10_108

ROM loader: ID not found

RomldrDataUnderrun = 10_109

ROM loader: Data underrun detected

RomldrJumpReturned = 10_110

ROM loader: Jump instruction returned

RomldrCallFailed = 10_111

ROM loader: Function call failed

RomldrKeyNotFound = 10_112

ROM loader: Key not found

RomldrSecureOnly = 10_113

ROM loader: Secure mode only

RomldrResetReturned = 10_114

ROM loader: Reset instruction returned

RomldrRollbackBlocked = 10_115

ROM loader: Rollback is blocked

RomldrInvalidSectionMacCount = 10_116

ROM loader: Invalid section MAC count

RomldrUnexpectedCommand = 10_117

ROM loader: Unexpected command received

RomldrBadSbkek = 10_118

ROM loader: Bad SBKEK detected

RomldrPendingJumpCommand = 10_119

ROM loader: Jump command is pending

MemoryRangeInvalid = 10_200

Memory interface: Address range is invalid

MemoryReadFailed = 10_201

Memory interface: Read operation failed

MemoryWriteFailed = 10_202

Memory interface: Write operation failed

MemoryCumulativeWrite = 10_203

Memory interface: Cumulative write detected

MemoryAppOverlapWithExecuteOnlyRegion = 10_204

Memory interface: Application overlaps with execute-only region

MemoryNotConfigured = 10_205

Memory interface: Memory not configured

MemoryAlignmentError = 10_206

Memory interface: Address alignment error

MemoryVerifyFailed = 10_207

Memory interface: Verification failed

MemoryWriteProtected = 10_208

Memory interface: Memory is write protected

MemoryAddressError = 10_209

Memory interface: Address is invalid

MemoryBlankCheckFailed = 10_210

Memory interface: Blank check failed

MemoryBlankPageReadDisallowed = 10_211

Memory interface: Blank page read is disallowed

MemoryProtectedPageReadDisallowed = 10_212

Memory interface: Protected page read is disallowed

MemoryPfrSpecRegionWriteBroken = 10_213

Memory interface: PFR spec region write is broken

MemoryUnsupportedCommand = 10_214

Memory interface: Command not supported

UnknownProperty = 10_300

Property store: Unknown property requested

ReadOnlyProperty = 10_301

Property store: Property is read-only

InvalidPropertyValue = 10_302

Property store: Property value is invalid

AppCrcCheckPassed = 10_400

Application CRC check passed

AppCrcCheckFailed = 10_401

Application CRC check failed

AppCrcCheckInactive = 10_402

Application CRC check is inactive

AppCrcCheckInvalid = 10_403

Application CRC check is invalid

AppCrcCheckOutOfRange = 10_404

Application CRC check is out of range

PacketizerNoPingResponse = 10_500

Packetizer: No ping response received

PacketizerInvalidPacketType = 10_501

Packetizer: Invalid packet type

PacketizerInvalidCrc = 10_502

Packetizer: Invalid CRC

PacketizerNoCommandResponse = 10_503

Packetizer: No command response received

ReliableUpdateSuccess = 10_600

Reliable update: Operation successful

ReliableUpdateFail = 10_601

Reliable update: Operation failed

ReliableUpdateInactive = 10_602

Reliable update: Feature is inactive

ReliableUpdateBackupapplicationinvalid = 10_603

Reliable update: Backup application is invalid

ReliableUpdateStillinmainapplication = 10_604

Reliable update: Still in main application

ReliableUpdateSwapsystemnotready = 10_605

Reliable update: Swap system is not ready

ReliableUpdateBackupbootloadernotready = 10_606

Reliable update: Backup bootloader is not ready

ReliableUpdateSwapindicatoraddressinvalid = 10_607

Reliable update: Swap indicator address is invalid

ReliableUpdateSwapsystemnotavailable = 10_608

Reliable update: Swap system is not available

ReliableUpdateSwaptest = 10_609

Reliable update: Swap test mode

SerialNorEepromAddressInvalid = 10_700

Serial NOR/EEPROM: Address is invalid

SerialNorEepromTransferError = 10_701

Serial NOR/EEPROM: Transfer error occurred

SerialNorEepromTypeInvalid = 10_702

Serial NOR/EEPROM: Type is invalid

SerialNorEepromSizeInvalid = 10_703

Serial NOR/EEPROM: Size is invalid

SerialNorEepromCommandInvalid = 10_704

Serial NOR/EEPROM: Command is invalid

RomApiNeedMoreData = 10_800

ROM API: Need more data

RomApiBufferSizeNotEnough = 10_801

ROM API: Buffer size is not enough

RomApiInvalidBuffer = 10_802

ROM API: Invalid buffer provided

FlexspinandReadPageFail = 20_000

FlexSPI NAND: Read page failed

FlexspinandReadCacheFail = 20_001

FlexSPI NAND: Read cache failed

FlexspinandEccCheckFail = 20_002

FlexSPI NAND: ECC check failed

FlexspinandPageLoadFail = 20_003

FlexSPI NAND: Page load failed

FlexspinandPageExecuteFail = 20_004

FlexSPI NAND: Page execute failed

FlexspinandEraseBlockFail = 20_005

FlexSPI NAND: Erase block failed

FlexspinandWaitTimeout = 20_006

FlexSPI NAND: Wait timeout occurred

FlexSpinandNotSupported = 20_007

FlexSPI NAND: Page size exceeds maximum supported

FlexSpinandFcbUpdateFail = 20_008

FlexSPI NAND: FCB update failed

FlexSpinandDbbtUpdateFail = 20_009

FlexSPI NAND: DBBT update failed

FlexspinandWritealignmenterror = 20_010

FlexSPI NAND: Write alignment error

FlexspinandNotFound = 20_011

FlexSPI NAND: Device not found

FlexspinorProgramFail = 20_100

FlexSPI NOR: Program operation failed

FlexspinorEraseSectorFail = 20_101

FlexSPI NOR: Erase sector failed

FlexspinorEraseAllFail = 20_102

FlexSPI NOR: Erase all failed

FlexspinorWaitTimeout = 20_103

FlexSPI NOR: Wait timeout occurred

FlexspinorNotSupported = 20_104

FlexSPI NOR: Page size exceeds maximum supported

FlexspinorWriteAlignmentError = 20_105

FlexSPI NOR: Write alignment error

FlexspinorCommandFailure = 20_106

FlexSPI NOR: Command failure

FlexspinorSfdpNotFound = 20_107

FlexSPI NOR: SFDP not found

FlexspinorUnsupportedSfdpVersion = 20_108

FlexSPI NOR: Unsupported SFDP version

FlexspinorFlashNotFound = 20_109

FlexSPI NOR: Flash not found

FlexspinorDtrReadDummyProbeFailed = 20_110

FlexSPI NOR: DTR read dummy probe failed

OcotpReadFailure = 20_200

OCOTP: Read failure

OcotpProgramFailure = 20_201

OCOTP: Program failure

OcotpReloadFailure = 20_202

OCOTP: Reload failure

OcotpWaitTimeout = 20_203

OCOTP: Wait timeout occurred

SemcnorDeviceTimeout = 21_100

SEMC NOR: Device timeout

SemcnorInvalidMemoryAddress = 21_101

SEMC NOR: Invalid memory address

SemcnorUnmatchedCommandSet = 21_102

SEMC NOR: Unmatched command set

SemcnorAddressAlignmentError = 21_103

SEMC NOR: Address alignment error

SemcnorInvalidCfiSignature = 21_104

SEMC NOR: Invalid CFI signature

SemcnorCommandErrorNoOpToSuspend = 21_105

SEMC NOR: Command error - no operation to suspend

SemcnorCommandErrorNoInfoAvailable = 21_106

SEMC NOR: Command error - no information available

SemcnorBlockEraseCommandFailure = 21_107

SEMC NOR: Block erase command failure

SemcnorBufferProgramCommandFailure = 21_108

SEMC NOR: Buffer program command failure

SemcnorProgramVerifyFailure = 21_109

SEMC NOR: Program verify failure

SemcnorEraseVerifyFailure = 21_110

SEMC NOR: Erase verify failure

SemcnorInvalidCfgTag = 21_116

SEMC NOR: Invalid configuration tag

SemcnandDeviceTimeout = 21_200

SEMC NAND: Device timeout

SemcnandInvalidMemoryAddress = 21_201

SEMC NAND: Invalid memory address

SemcnandNotEqualToOnePageSize = 21_202

SEMC NAND: Not equal to one page size

SemcnandMoreThanOnePageSize = 21_203

SEMC NAND: More than one page size

SemcnandEccCheckFail = 21_204

SEMC NAND: ECC check failed

SemcnandInvalidOnfiParameter = 21_205

SEMC NAND: Invalid ONFI parameter

SemcnandCannotEnableDeviceEcc = 21_206

SEMC NAND: Cannot enable device ECC

SemcnandSwitchTimingModeFailure = 21_207

SEMC NAND: Switch timing mode failure

SemcnandProgramVerifyFailure = 21_208

SEMC NAND: Program verify failure

SemcnandEraseVerifyFailure = 21_209

SEMC NAND: Erase verify failure

SemcnandInvalidReadbackBuffer = 21_210

SEMC NAND: Invalid readback buffer

SemcnandInvalidCfgTag = 21_216

SEMC NAND: Invalid configuration tag

SemcnandFailToUpdateFcb = 21_217

SEMC NAND: Failed to update FCB

SemcnandFailToUpdateDbbt = 21_218

SEMC NAND: Failed to update DBBT

SemcnandDisallowOverwriteBcb = 21_219

SEMC NAND: Disallow overwrite BCB

SemcnandOnlySupportOnfiDevice = 21_220

SEMC NAND: Only support ONFI device

SemcnandMoreThanMaxImageCopy = 21_221

SEMC NAND: More than max image copy

SemcnandDisorderedImageCopies = 21_222

SEMC NAND: Disordered image copies

SpifinorProgramFail = 22_000

SPIFI NOR: Program operation failed

SpifinorEraseSectorfail = 22_001

SPIFI NOR: Erase sector failed

SpifinorEraseAllFail = 22_002

SPIFI NOR: Erase all failed

SpifinorWaitTimeout = 22_003

SPIFI NOR: Wait timeout occurred

SpifinorNotSupported = 22_004

SPIFI NOR: Operation not supported

SpifinorWriteAlignmentError = 22_005

SPIFI NOR: Write alignment error

SpifinorCommandFailure = 22_006

SPIFI NOR: Command failure

SpifinorSfdpNotFound = 22_007

SPIFI NOR: SFDP not found

EdgelockInvalidResponse = 30_000

EdgeLock Enclave: Invalid response

EdgelockResponseError = 30_001

EdgeLock Enclave: Response error

EdgelockAbort = 30_002

EdgeLock Enclave: Operation aborted

EdgelockOperationFailed = 30_003

EdgeLock Enclave: Operation failed

EdgelockOtpProgramFailure = 30_004

EdgeLock Enclave: OTP program failure

EdgelockOtpLocked = 30_005

EdgeLock Enclave: OTP is locked

EdgelockOtpInvalidIdx = 30_006

EdgeLock Enclave: OTP invalid index

EdgelockInvalidLifecycle = 30_007

EdgeLock Enclave: Invalid lifecycle state

OtpInvalidAddress = 52_801

OTP: Invalid OTP address

OtpProgramFail = 52_802

OTP: Programming failed

OtpCrcFail = 52_803

OTP: CRC check failed

OtpError = 52_804

OTP: Error occurred during operation

OtpEccCrcFail = 52_805

OTP: ECC check failed during operation

OtpLocked = 52_806

OTP: Field is locked when programming

OtpTimeout = 52_807

OTP: Operation timed out

OtpCrcCheckPass = 52_808

OTP: CRC check passed

OtpVerifyFail = 52_009

OTP: Failed to verify OTP write

SecuritySubsystemError = 1_515_890_085

Security subsystem error

TpGeneralError = 80_000

Trust Provisioning: General error

TpCryptoError = 80_001

Trust Provisioning: Cryptographic operation error

TpNullptrError = 80_002

Trust Provisioning: Null pointer dereference or buffer allocation failed

TpAlreadyinitialized = 80_003

Trust Provisioning: Already initialized

TpBuffersmall = 80_004

Trust Provisioning: Buffer is too small

TpAddressError = 80_005

Trust Provisioning: Address out of range or buffer allocation failed

TpContainerInvalid = 80_006

Trust Provisioning: Container header or size is invalid

TpContainerentryinvalid = 80_007

Trust Provisioning: Container entry invalid

TpContainerentrynotfound = 80_008

Trust Provisioning: Container entry not found

TpInvalidstateoperation = 80_009

Trust Provisioning: Invalid state operation

TpCommandError = 80_010

Trust Provisioning: ISP command arguments are invalid

TpPufError = 80_011

Trust Provisioning: PUF operation error

TpFlashError = 80_012

Trust Provisioning: Flash operation failed

TpSecretboxError = 80_013

Trust Provisioning: Secret box error

TpPfrError = 80_014

Trust Provisioning: PFR operation failed

TpVerificationError = 80_015

Trust Provisioning: Container signature verification failed

TpCfpaError = 80_016

Trust Provisioning: CFPA page cannot be stored

TpCmpaError = 80_017

Trust Provisioning: CMPA page cannot be stored

TpAddrOutOfRange = 80_018

Trust Provisioning: Address is out of range

TpContainerAddrError = 80_019

Trust Provisioning: Container address error

TpContainerAddrUnaligned = 80_020

Trust Provisioning: Container address unaligned

TpContainerBuffSmall = 80_021

Trust Provisioning: Container buffer too small

TpContainerNoEntry = 80_022

Trust Provisioning: Container has no entry

TpCertAddrError = 80_023

Trust Provisioning: Certificate address error

TpCertAddrUnaligned = 80_024

Trust Provisioning: Certificate address unaligned

TpCertOverlapping = 80_025

Trust Provisioning: Certificate overlapping

TpPacketError = 80_026

Trust Provisioning: Packet error

TpPacketDataError = 80_027

Trust Provisioning: Packet data error

TpUnknownCommand = 80_028

Trust Provisioning: Unknown command

TpSb3FileError = 80_029

Trust Provisioning: SB3 file error

TpGeneralCriticalError = 80_101

Trust Provisioning: General critical error

TpCryptoCriticalError = 80_102

Trust Provisioning: Crypto critical error

TpPufCriticalError = 80_103

Trust Provisioning: PUF critical error

TpPfrCriticalError = 80_104

Trust Provisioning: PFR critical error

TpPeripheralCriticalError = 80_105

Trust Provisioning: Peripheral critical error

TpPrinceCriticalError = 80_106

Trust Provisioning: Prince critical error

TpShaCheckCriticalError = 80_107

Trust Provisioning: SHA check verification failed

IapInvalidArgument = 100_001

IAP: Invalid argument detected during API execution

IapOutOfMemory = 100_002

IAP: Heap size not large enough during API execution

IapReadDisallowed = 100_003

IAP: Read memory operation disallowed during API execution

IapCumulativeWrite = 100_004

IAP: Flash memory region to be programmed is not empty

IapEraseFailure = 100_005

IAP: Erase operation failed

IapCommandNotSupported = 100_006

IAP: Specific command not supported

IapMemoryAccessDisabled = 100_007

IAP: Memory access disabled

El2goProvSuccess = 1_515_870_810

EL2Go: Device has been successfully provisioned

UnknownStatusCode = 3_735_928_559

Unknown status code (fallback for unrecognized codes)

Not defined in any specification, only for handling unexpected or undefined status codes

Implementations

impl StatusCode

pub const fn is_success(&self) -> bool

Returns true if the enum is StatusCode::Success otherwise false

pub const fn is_fail(&self) -> bool

Returns true if the enum is StatusCode::Fail otherwise false

pub const fn is_read_only(&self) -> bool

Returns true if the enum is StatusCode::ReadOnly otherwise false

pub const fn is_out_of_range(&self) -> bool

Returns true if the enum is StatusCode::OutOfRange otherwise false

pub const fn is_invalid_argument(&self) -> bool

Returns true if the enum is StatusCode::InvalidArgument otherwise false

pub const fn is_timeout(&self) -> bool

Returns true if the enum is StatusCode::Timeout otherwise false

pub const fn is_no_transfer_in_progress(&self) -> bool

Returns true if the enum is StatusCode::NoTransferInProgress otherwise false

pub const fn is_flash_size_error(&self) -> bool

Returns true if the enum is StatusCode::FlashSizeError otherwise false

pub const fn is_flash_alignment_error(&self) -> bool

Returns true if the enum is StatusCode::FlashAlignmentError otherwise false

pub const fn is_flash_address_error(&self) -> bool

Returns true if the enum is StatusCode::FlashAddressError otherwise false

pub const fn is_flash_access_error(&self) -> bool

Returns true if the enum is StatusCode::FlashAccessError otherwise false

pub const fn is_flash_protection_violation(&self) -> bool

Returns true if the enum is StatusCode::FlashProtectionViolation otherwise false

pub const fn is_flash_command_failure(&self) -> bool

Returns true if the enum is StatusCode::FlashCommandFailure otherwise false

pub const fn is_flash_unknown_property(&self) -> bool

Returns true if the enum is StatusCode::FlashUnknownProperty otherwise false

pub const fn is_flash_erase_key_error(&self) -> bool

Returns true if the enum is StatusCode::FlashEraseKeyError otherwise false

pub const fn is_flash_region_execute_only(&self) -> bool

Returns true if the enum is StatusCode::FlashRegionExecuteOnly otherwise false

pub const fn is_flash_exec_in_ram_not_ready(&self) -> bool

Returns true if the enum is StatusCode::FlashExecInRamNotReady otherwise false

pub const fn is_flash_command_not_supported(&self) -> bool

Returns true if the enum is StatusCode::FlashCommandNotSupported otherwise false

pub const fn is_flash_read_only_property(&self) -> bool

Returns true if the enum is StatusCode::FlashReadOnlyProperty otherwise false

pub const fn is_flash_invalid_property_value(&self) -> bool

Returns true if the enum is StatusCode::FlashInvalidPropertyValue otherwise false

pub const fn is_flash_invalid_speculation_option(&self) -> bool

Returns true if the enum is StatusCode::FlashInvalidSpeculationOption otherwise false

pub const fn is_flash_ecc_error(&self) -> bool

Returns true if the enum is StatusCode::FlashEccError otherwise false

pub const fn is_flash_compare_error(&self) -> bool

Returns true if the enum is StatusCode::FlashCompareError otherwise false

pub const fn is_flash_regulation_loss(&self) -> bool

Returns true if the enum is StatusCode::FlashRegulationLoss otherwise false

pub const fn is_flash_invalid_wait_state_cycles(&self) -> bool

Returns true if the enum is StatusCode::FlashInvalidWaitStateCycles otherwise false

pub const fn is_flash_out_of_date_cfpa_page(&self) -> bool

Returns true if the enum is StatusCode::FlashOutOfDateCfpaPage otherwise false

pub const fn is_flash_blank_ifr_page_data(&self) -> bool

Returns true if the enum is StatusCode::FlashBlankIfrPageData otherwise false

pub const fn is_flash_encrypted_regions_erase_not_done_at_once(&self) -> bool

Returns true if the enum is StatusCode::FlashEncryptedRegionsEraseNotDoneAtOnce otherwise false

pub const fn is_flash_program_verification_not_allowed(&self) -> bool

Returns true if the enum is StatusCode::FlashProgramVerificationNotAllowed otherwise false

pub const fn is_flash_hash_check_error(&self) -> bool

Returns true if the enum is StatusCode::FlashHashCheckError otherwise false

pub const fn is_flash_sealed_pfr_region(&self) -> bool

Returns true if the enum is StatusCode::FlashSealedPfrRegion otherwise false

pub const fn is_flash_pfr_region_write_broken(&self) -> bool

Returns true if the enum is StatusCode::FlashPfrRegionWriteBroken otherwise false

pub const fn is_flash_nmpa_update_not_allowed(&self) -> bool

Returns true if the enum is StatusCode::FlashNmpaUpdateNotAllowed otherwise false

pub const fn is_flash_cmpa_cfg_direct_erase_not_allowed(&self) -> bool

Returns true if the enum is StatusCode::FlashCmpaCfgDirectEraseNotAllowed otherwise false

pub const fn is_flash_pfr_bank_is_locked(&self) -> bool

Returns true if the enum is StatusCode::FlashPfrBankIsLocked otherwise false

pub const fn is_flash_cfpa_scratch_page_invalid(&self) -> bool

Returns true if the enum is StatusCode::FlashCfpaScratchPageInvalid otherwise false

pub const fn is_flash_cfpa_version_rollback_disallowed(&self) -> bool

Returns true if the enum is StatusCode::FlashCfpaVersionRollbackDisallowed otherwise false

pub const fn is_flash_read_hiding_area_disallowed(&self) -> bool

Returns true if the enum is StatusCode::FlashReadHidingAreaDisallowed otherwise false

pub const fn is_flash_modify_protected_area_disallowed(&self) -> bool

Returns true if the enum is StatusCode::FlashModifyProtectedAreaDisallowed otherwise false

pub const fn is_flash_command_operation_in_progress(&self) -> bool

Returns true if the enum is StatusCode::FlashCommandOperationInProgress otherwise false

pub const fn is_i_2c_slave_tx_underrun(&self) -> bool

Returns true if the enum is StatusCode::I2cSlaveTxUnderrun otherwise false

pub const fn is_i_2c_slave_rx_overrun(&self) -> bool

Returns true if the enum is StatusCode::I2cSlaveRxOverrun otherwise false

pub const fn is_i_2c_arbitration_lost(&self) -> bool

Returns true if the enum is StatusCode::I2cArbitrationLost otherwise false

pub const fn is_spi_slave_tx_underrun(&self) -> bool

Returns true if the enum is StatusCode::SpiSlaveTxUnderrun otherwise false

pub const fn is_spi_slave_rx_overrun(&self) -> bool

Returns true if the enum is StatusCode::SpiSlaveRxOverrun otherwise false

pub const fn is_qspi_flash_size_error(&self) -> bool

Returns true if the enum is StatusCode::QspiFlashSizeError otherwise false

pub const fn is_qspi_flash_alignment_error(&self) -> bool

Returns true if the enum is StatusCode::QspiFlashAlignmentError otherwise false

pub const fn is_qspi_flash_address_error(&self) -> bool

Returns true if the enum is StatusCode::QspiFlashAddressError otherwise false

pub const fn is_qspi_flash_command_failure(&self) -> bool

Returns true if the enum is StatusCode::QspiFlashCommandFailure otherwise false

pub const fn is_qspi_flash_unknown_property(&self) -> bool

Returns true if the enum is StatusCode::QspiFlashUnknownProperty otherwise false

pub const fn is_qspi_not_configured(&self) -> bool

Returns true if the enum is StatusCode::QspiNotConfigured otherwise false

pub const fn is_qspi_command_not_supported(&self) -> bool

Returns true if the enum is StatusCode::QspiCommandNotSupported otherwise false

pub const fn is_qspi_command_timeout(&self) -> bool

Returns true if the enum is StatusCode::QspiCommandTimeout otherwise false

pub const fn is_qspi_write_failure(&self) -> bool

Returns true if the enum is StatusCode::QspiWriteFailure otherwise false

pub const fn is_otfad_security_violation(&self) -> bool

Returns true if the enum is StatusCode::OtfadSecurityViolation otherwise false

pub const fn is_otfad_logically_disabled(&self) -> bool

Returns true if the enum is StatusCode::OtfadLogicallyDisabled otherwise false

pub const fn is_otfad_invalid_key(&self) -> bool

Returns true if the enum is StatusCode::OtfadInvalidKey otherwise false

pub const fn is_otfad_invalid_key_blob(&self) -> bool

Returns true if the enum is StatusCode::OtfadInvalidKeyBlob otherwise false

pub const fn is_sending_operation_condition_error(&self) -> bool

Returns true if the enum is StatusCode::SendingOperationConditionError otherwise false

pub const fn is_flexspi_sequence_execution_timeout_rt_5xx(&self) -> bool

Returns true if the enum is StatusCode::FlexspiSequenceExecutionTimeoutRt5xx otherwise false

pub const fn is_flexspi_invalid_sequence_rt_5xx(&self) -> bool

Returns true if the enum is StatusCode::FlexspiInvalidSequenceRt5xx otherwise false

pub const fn is_flexspi_device_timeout_rt_5xx(&self) -> bool

Returns true if the enum is StatusCode::FlexspiDeviceTimeoutRt5xx otherwise false

pub const fn is_flexspi_sequence_execution_timeout(&self) -> bool

Returns true if the enum is StatusCode::FlexspiSequenceExecutionTimeout otherwise false

pub const fn is_flexspi_invalid_sequence(&self) -> bool

Returns true if the enum is StatusCode::FlexspiInvalidSequence otherwise false

pub const fn is_flexspi_device_timeout(&self) -> bool

Returns true if the enum is StatusCode::FlexspiDeviceTimeout otherwise false

pub const fn is_unknown_command(&self) -> bool

Returns true if the enum is StatusCode::UnknownCommand otherwise false

pub const fn is_security_violation(&self) -> bool

Returns true if the enum is StatusCode::SecurityViolation otherwise false

pub const fn is_abort_data_phase(&self) -> bool

Returns true if the enum is StatusCode::AbortDataPhase otherwise false

pub const fn is_ping_error(&self) -> bool

Returns true if the enum is StatusCode::PingError otherwise false

pub const fn is_no_response(&self) -> bool

Returns true if the enum is StatusCode::NoResponse otherwise false

pub const fn is_no_response_expected(&self) -> bool

Returns true if the enum is StatusCode::NoResponseExpected otherwise false

pub const fn is_unsupported_command(&self) -> bool

Returns true if the enum is StatusCode::UnsupportedCommand otherwise false

pub const fn is_romldr_section_overrun(&self) -> bool

Returns true if the enum is StatusCode::RomldrSectionOverrun otherwise false

pub const fn is_romldr_signature(&self) -> bool

Returns true if the enum is StatusCode::RomldrSignature otherwise false

pub const fn is_romldr_section_length(&self) -> bool

Returns true if the enum is StatusCode::RomldrSectionLength otherwise false

pub const fn is_romldr_unencrypted_only(&self) -> bool

Returns true if the enum is StatusCode::RomldrUnencryptedOnly otherwise false

pub const fn is_romldr_eof_reached(&self) -> bool

Returns true if the enum is StatusCode::RomldrEofReached otherwise false

pub const fn is_romldr_checksum(&self) -> bool

Returns true if the enum is StatusCode::RomldrChecksum otherwise false

pub const fn is_romldr_crc_32_error(&self) -> bool

Returns true if the enum is StatusCode::RomldrCrc32Error otherwise false

pub const fn is_romldr_unknown_command(&self) -> bool

Returns true if the enum is StatusCode::RomldrUnknownCommand otherwise false

pub const fn is_romldr_id_not_found(&self) -> bool

Returns true if the enum is StatusCode::RomldrIdNotFound otherwise false

pub const fn is_romldr_data_underrun(&self) -> bool

Returns true if the enum is StatusCode::RomldrDataUnderrun otherwise false

pub const fn is_romldr_jump_returned(&self) -> bool

Returns true if the enum is StatusCode::RomldrJumpReturned otherwise false

pub const fn is_romldr_call_failed(&self) -> bool

Returns true if the enum is StatusCode::RomldrCallFailed otherwise false

pub const fn is_romldr_key_not_found(&self) -> bool

Returns true if the enum is StatusCode::RomldrKeyNotFound otherwise false

pub const fn is_romldr_secure_only(&self) -> bool

Returns true if the enum is StatusCode::RomldrSecureOnly otherwise false

pub const fn is_romldr_reset_returned(&self) -> bool

Returns true if the enum is StatusCode::RomldrResetReturned otherwise false

pub const fn is_romldr_rollback_blocked(&self) -> bool

Returns true if the enum is StatusCode::RomldrRollbackBlocked otherwise false

pub const fn is_romldr_invalid_section_mac_count(&self) -> bool

Returns true if the enum is StatusCode::RomldrInvalidSectionMacCount otherwise false

pub const fn is_romldr_unexpected_command(&self) -> bool

Returns true if the enum is StatusCode::RomldrUnexpectedCommand otherwise false

pub const fn is_romldr_bad_sbkek(&self) -> bool

Returns true if the enum is StatusCode::RomldrBadSbkek otherwise false

pub const fn is_romldr_pending_jump_command(&self) -> bool

Returns true if the enum is StatusCode::RomldrPendingJumpCommand otherwise false

pub const fn is_memory_range_invalid(&self) -> bool

Returns true if the enum is StatusCode::MemoryRangeInvalid otherwise false

pub const fn is_memory_read_failed(&self) -> bool

Returns true if the enum is StatusCode::MemoryReadFailed otherwise false

pub const fn is_memory_write_failed(&self) -> bool

Returns true if the enum is StatusCode::MemoryWriteFailed otherwise false

pub const fn is_memory_cumulative_write(&self) -> bool

Returns true if the enum is StatusCode::MemoryCumulativeWrite otherwise false

pub const fn is_memory_app_overlap_with_execute_only_region(&self) -> bool

Returns true if the enum is StatusCode::MemoryAppOverlapWithExecuteOnlyRegion otherwise false

pub const fn is_memory_not_configured(&self) -> bool

Returns true if the enum is StatusCode::MemoryNotConfigured otherwise false

pub const fn is_memory_alignment_error(&self) -> bool

Returns true if the enum is StatusCode::MemoryAlignmentError otherwise false

pub const fn is_memory_verify_failed(&self) -> bool

Returns true if the enum is StatusCode::MemoryVerifyFailed otherwise false

pub const fn is_memory_write_protected(&self) -> bool

Returns true if the enum is StatusCode::MemoryWriteProtected otherwise false

pub const fn is_memory_address_error(&self) -> bool

Returns true if the enum is StatusCode::MemoryAddressError otherwise false

pub const fn is_memory_blank_check_failed(&self) -> bool

Returns true if the enum is StatusCode::MemoryBlankCheckFailed otherwise false

pub const fn is_memory_blank_page_read_disallowed(&self) -> bool

Returns true if the enum is StatusCode::MemoryBlankPageReadDisallowed otherwise false

pub const fn is_memory_protected_page_read_disallowed(&self) -> bool

Returns true if the enum is StatusCode::MemoryProtectedPageReadDisallowed otherwise false

pub const fn is_memory_pfr_spec_region_write_broken(&self) -> bool

Returns true if the enum is StatusCode::MemoryPfrSpecRegionWriteBroken otherwise false

pub const fn is_memory_unsupported_command(&self) -> bool

Returns true if the enum is StatusCode::MemoryUnsupportedCommand otherwise false

pub const fn is_unknown_property(&self) -> bool

Returns true if the enum is StatusCode::UnknownProperty otherwise false

pub const fn is_read_only_property(&self) -> bool

Returns true if the enum is StatusCode::ReadOnlyProperty otherwise false

pub const fn is_invalid_property_value(&self) -> bool

Returns true if the enum is StatusCode::InvalidPropertyValue otherwise false

pub const fn is_app_crc_check_passed(&self) -> bool

Returns true if the enum is StatusCode::AppCrcCheckPassed otherwise false

pub const fn is_app_crc_check_failed(&self) -> bool

Returns true if the enum is StatusCode::AppCrcCheckFailed otherwise false

pub const fn is_app_crc_check_inactive(&self) -> bool

Returns true if the enum is StatusCode::AppCrcCheckInactive otherwise false

pub const fn is_app_crc_check_invalid(&self) -> bool

Returns true if the enum is StatusCode::AppCrcCheckInvalid otherwise false

pub const fn is_app_crc_check_out_of_range(&self) -> bool

Returns true if the enum is StatusCode::AppCrcCheckOutOfRange otherwise false

pub const fn is_packetizer_no_ping_response(&self) -> bool

Returns true if the enum is StatusCode::PacketizerNoPingResponse otherwise false

pub const fn is_packetizer_invalid_packet_type(&self) -> bool

Returns true if the enum is StatusCode::PacketizerInvalidPacketType otherwise false

pub const fn is_packetizer_invalid_crc(&self) -> bool

Returns true if the enum is StatusCode::PacketizerInvalidCrc otherwise false

pub const fn is_packetizer_no_command_response(&self) -> bool

Returns true if the enum is StatusCode::PacketizerNoCommandResponse otherwise false

pub const fn is_reliable_update_success(&self) -> bool

Returns true if the enum is StatusCode::ReliableUpdateSuccess otherwise false

pub const fn is_reliable_update_fail(&self) -> bool

Returns true if the enum is StatusCode::ReliableUpdateFail otherwise false

pub const fn is_reliable_update_inactive(&self) -> bool

Returns true if the enum is StatusCode::ReliableUpdateInactive otherwise false

pub const fn is_reliable_update_backupapplicationinvalid(&self) -> bool

Returns true if the enum is StatusCode::ReliableUpdateBackupapplicationinvalid otherwise false

pub const fn is_reliable_update_stillinmainapplication(&self) -> bool

Returns true if the enum is StatusCode::ReliableUpdateStillinmainapplication otherwise false

pub const fn is_reliable_update_swapsystemnotready(&self) -> bool

Returns true if the enum is StatusCode::ReliableUpdateSwapsystemnotready otherwise false

pub const fn is_reliable_update_backupbootloadernotready(&self) -> bool

Returns true if the enum is StatusCode::ReliableUpdateBackupbootloadernotready otherwise false

pub const fn is_reliable_update_swapindicatoraddressinvalid(&self) -> bool

Returns true if the enum is StatusCode::ReliableUpdateSwapindicatoraddressinvalid otherwise false

pub const fn is_reliable_update_swapsystemnotavailable(&self) -> bool

Returns true if the enum is StatusCode::ReliableUpdateSwapsystemnotavailable otherwise false

pub const fn is_reliable_update_swaptest(&self) -> bool

Returns true if the enum is StatusCode::ReliableUpdateSwaptest otherwise false

pub const fn is_serial_nor_eeprom_address_invalid(&self) -> bool

Returns true if the enum is StatusCode::SerialNorEepromAddressInvalid otherwise false

pub const fn is_serial_nor_eeprom_transfer_error(&self) -> bool

Returns true if the enum is StatusCode::SerialNorEepromTransferError otherwise false

pub const fn is_serial_nor_eeprom_type_invalid(&self) -> bool

Returns true if the enum is StatusCode::SerialNorEepromTypeInvalid otherwise false

pub const fn is_serial_nor_eeprom_size_invalid(&self) -> bool

Returns true if the enum is StatusCode::SerialNorEepromSizeInvalid otherwise false

pub const fn is_serial_nor_eeprom_command_invalid(&self) -> bool

Returns true if the enum is StatusCode::SerialNorEepromCommandInvalid otherwise false

pub const fn is_rom_api_need_more_data(&self) -> bool

Returns true if the enum is StatusCode::RomApiNeedMoreData otherwise false

pub const fn is_rom_api_buffer_size_not_enough(&self) -> bool

Returns true if the enum is StatusCode::RomApiBufferSizeNotEnough otherwise false

pub const fn is_rom_api_invalid_buffer(&self) -> bool

Returns true if the enum is StatusCode::RomApiInvalidBuffer otherwise false

pub const fn is_flexspinand_read_page_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexspinandReadPageFail otherwise false

pub const fn is_flexspinand_read_cache_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexspinandReadCacheFail otherwise false

pub const fn is_flexspinand_ecc_check_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexspinandEccCheckFail otherwise false

pub const fn is_flexspinand_page_load_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexspinandPageLoadFail otherwise false

pub const fn is_flexspinand_page_execute_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexspinandPageExecuteFail otherwise false

pub const fn is_flexspinand_erase_block_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexspinandEraseBlockFail otherwise false

pub const fn is_flexspinand_wait_timeout(&self) -> bool

Returns true if the enum is StatusCode::FlexspinandWaitTimeout otherwise false

pub const fn is_flex_spinand_not_supported(&self) -> bool

Returns true if the enum is StatusCode::FlexSpinandNotSupported otherwise false

pub const fn is_flex_spinand_fcb_update_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexSpinandFcbUpdateFail otherwise false

pub const fn is_flex_spinand_dbbt_update_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexSpinandDbbtUpdateFail otherwise false

pub const fn is_flexspinand_writealignmenterror(&self) -> bool

Returns true if the enum is StatusCode::FlexspinandWritealignmenterror otherwise false

pub const fn is_flexspinand_not_found(&self) -> bool

Returns true if the enum is StatusCode::FlexspinandNotFound otherwise false

pub const fn is_flexspinor_program_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorProgramFail otherwise false

pub const fn is_flexspinor_erase_sector_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorEraseSectorFail otherwise false

pub const fn is_flexspinor_erase_all_fail(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorEraseAllFail otherwise false

pub const fn is_flexspinor_wait_timeout(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorWaitTimeout otherwise false

pub const fn is_flexspinor_not_supported(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorNotSupported otherwise false

pub const fn is_flexspinor_write_alignment_error(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorWriteAlignmentError otherwise false

pub const fn is_flexspinor_command_failure(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorCommandFailure otherwise false

pub const fn is_flexspinor_sfdp_not_found(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorSfdpNotFound otherwise false

pub const fn is_flexspinor_unsupported_sfdp_version(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorUnsupportedSfdpVersion otherwise false

pub const fn is_flexspinor_flash_not_found(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorFlashNotFound otherwise false

pub const fn is_flexspinor_dtr_read_dummy_probe_failed(&self) -> bool

Returns true if the enum is StatusCode::FlexspinorDtrReadDummyProbeFailed otherwise false

pub const fn is_ocotp_read_failure(&self) -> bool

Returns true if the enum is StatusCode::OcotpReadFailure otherwise false

pub const fn is_ocotp_program_failure(&self) -> bool

Returns true if the enum is StatusCode::OcotpProgramFailure otherwise false

pub const fn is_ocotp_reload_failure(&self) -> bool

Returns true if the enum is StatusCode::OcotpReloadFailure otherwise false

pub const fn is_ocotp_wait_timeout(&self) -> bool

Returns true if the enum is StatusCode::OcotpWaitTimeout otherwise false

pub const fn is_semcnor_device_timeout(&self) -> bool

Returns true if the enum is StatusCode::SemcnorDeviceTimeout otherwise false

pub const fn is_semcnor_invalid_memory_address(&self) -> bool

Returns true if the enum is StatusCode::SemcnorInvalidMemoryAddress otherwise false

pub const fn is_semcnor_unmatched_command_set(&self) -> bool

Returns true if the enum is StatusCode::SemcnorUnmatchedCommandSet otherwise false

pub const fn is_semcnor_address_alignment_error(&self) -> bool

Returns true if the enum is StatusCode::SemcnorAddressAlignmentError otherwise false

pub const fn is_semcnor_invalid_cfi_signature(&self) -> bool

Returns true if the enum is StatusCode::SemcnorInvalidCfiSignature otherwise false

pub const fn is_semcnor_command_error_no_op_to_suspend(&self) -> bool

Returns true if the enum is StatusCode::SemcnorCommandErrorNoOpToSuspend otherwise false

pub const fn is_semcnor_command_error_no_info_available(&self) -> bool

Returns true if the enum is StatusCode::SemcnorCommandErrorNoInfoAvailable otherwise false

pub const fn is_semcnor_block_erase_command_failure(&self) -> bool

Returns true if the enum is StatusCode::SemcnorBlockEraseCommandFailure otherwise false

pub const fn is_semcnor_buffer_program_command_failure(&self) -> bool

Returns true if the enum is StatusCode::SemcnorBufferProgramCommandFailure otherwise false

pub const fn is_semcnor_program_verify_failure(&self) -> bool

Returns true if the enum is StatusCode::SemcnorProgramVerifyFailure otherwise false

pub const fn is_semcnor_erase_verify_failure(&self) -> bool

Returns true if the enum is StatusCode::SemcnorEraseVerifyFailure otherwise false

pub const fn is_semcnor_invalid_cfg_tag(&self) -> bool

Returns true if the enum is StatusCode::SemcnorInvalidCfgTag otherwise false

pub const fn is_semcnand_device_timeout(&self) -> bool

Returns true if the enum is StatusCode::SemcnandDeviceTimeout otherwise false

pub const fn is_semcnand_invalid_memory_address(&self) -> bool

Returns true if the enum is StatusCode::SemcnandInvalidMemoryAddress otherwise false

pub const fn is_semcnand_not_equal_to_one_page_size(&self) -> bool

Returns true if the enum is StatusCode::SemcnandNotEqualToOnePageSize otherwise false

pub const fn is_semcnand_more_than_one_page_size(&self) -> bool

Returns true if the enum is StatusCode::SemcnandMoreThanOnePageSize otherwise false

pub const fn is_semcnand_ecc_check_fail(&self) -> bool

Returns true if the enum is StatusCode::SemcnandEccCheckFail otherwise false

pub const fn is_semcnand_invalid_onfi_parameter(&self) -> bool

Returns true if the enum is StatusCode::SemcnandInvalidOnfiParameter otherwise false

pub const fn is_semcnand_cannot_enable_device_ecc(&self) -> bool

Returns true if the enum is StatusCode::SemcnandCannotEnableDeviceEcc otherwise false

pub const fn is_semcnand_switch_timing_mode_failure(&self) -> bool

Returns true if the enum is StatusCode::SemcnandSwitchTimingModeFailure otherwise false

pub const fn is_semcnand_program_verify_failure(&self) -> bool

Returns true if the enum is StatusCode::SemcnandProgramVerifyFailure otherwise false

pub const fn is_semcnand_erase_verify_failure(&self) -> bool

Returns true if the enum is StatusCode::SemcnandEraseVerifyFailure otherwise false

pub const fn is_semcnand_invalid_readback_buffer(&self) -> bool

Returns true if the enum is StatusCode::SemcnandInvalidReadbackBuffer otherwise false

pub const fn is_semcnand_invalid_cfg_tag(&self) -> bool

Returns true if the enum is StatusCode::SemcnandInvalidCfgTag otherwise false

pub const fn is_semcnand_fail_to_update_fcb(&self) -> bool

Returns true if the enum is StatusCode::SemcnandFailToUpdateFcb otherwise false

pub const fn is_semcnand_fail_to_update_dbbt(&self) -> bool

Returns true if the enum is StatusCode::SemcnandFailToUpdateDbbt otherwise false

pub const fn is_semcnand_disallow_overwrite_bcb(&self) -> bool

Returns true if the enum is StatusCode::SemcnandDisallowOverwriteBcb otherwise false

pub const fn is_semcnand_only_support_onfi_device(&self) -> bool

Returns true if the enum is StatusCode::SemcnandOnlySupportOnfiDevice otherwise false

pub const fn is_semcnand_more_than_max_image_copy(&self) -> bool

Returns true if the enum is StatusCode::SemcnandMoreThanMaxImageCopy otherwise false

pub const fn is_semcnand_disordered_image_copies(&self) -> bool

Returns true if the enum is StatusCode::SemcnandDisorderedImageCopies otherwise false

pub const fn is_spifinor_program_fail(&self) -> bool

Returns true if the enum is StatusCode::SpifinorProgramFail otherwise false

pub const fn is_spifinor_erase_sectorfail(&self) -> bool

Returns true if the enum is StatusCode::SpifinorEraseSectorfail otherwise false

pub const fn is_spifinor_erase_all_fail(&self) -> bool

Returns true if the enum is StatusCode::SpifinorEraseAllFail otherwise false

pub const fn is_spifinor_wait_timeout(&self) -> bool

Returns true if the enum is StatusCode::SpifinorWaitTimeout otherwise false

pub const fn is_spifinor_not_supported(&self) -> bool

Returns true if the enum is StatusCode::SpifinorNotSupported otherwise false

pub const fn is_spifinor_write_alignment_error(&self) -> bool

Returns true if the enum is StatusCode::SpifinorWriteAlignmentError otherwise false

pub const fn is_spifinor_command_failure(&self) -> bool

Returns true if the enum is StatusCode::SpifinorCommandFailure otherwise false

pub const fn is_spifinor_sfdp_not_found(&self) -> bool

Returns true if the enum is StatusCode::SpifinorSfdpNotFound otherwise false

pub const fn is_edgelock_invalid_response(&self) -> bool

Returns true if the enum is StatusCode::EdgelockInvalidResponse otherwise false

pub const fn is_edgelock_response_error(&self) -> bool

Returns true if the enum is StatusCode::EdgelockResponseError otherwise false

pub const fn is_edgelock_abort(&self) -> bool

Returns true if the enum is StatusCode::EdgelockAbort otherwise false

pub const fn is_edgelock_operation_failed(&self) -> bool

Returns true if the enum is StatusCode::EdgelockOperationFailed otherwise false

pub const fn is_edgelock_otp_program_failure(&self) -> bool

Returns true if the enum is StatusCode::EdgelockOtpProgramFailure otherwise false

pub const fn is_edgelock_otp_locked(&self) -> bool

Returns true if the enum is StatusCode::EdgelockOtpLocked otherwise false

pub const fn is_edgelock_otp_invalid_idx(&self) -> bool

Returns true if the enum is StatusCode::EdgelockOtpInvalidIdx otherwise false

pub const fn is_edgelock_invalid_lifecycle(&self) -> bool

Returns true if the enum is StatusCode::EdgelockInvalidLifecycle otherwise false

pub const fn is_otp_invalid_address(&self) -> bool

Returns true if the enum is StatusCode::OtpInvalidAddress otherwise false

pub const fn is_otp_program_fail(&self) -> bool

Returns true if the enum is StatusCode::OtpProgramFail otherwise false

pub const fn is_otp_crc_fail(&self) -> bool

Returns true if the enum is StatusCode::OtpCrcFail otherwise false

pub const fn is_otp_error(&self) -> bool

Returns true if the enum is StatusCode::OtpError otherwise false

pub const fn is_otp_ecc_crc_fail(&self) -> bool

Returns true if the enum is StatusCode::OtpEccCrcFail otherwise false

pub const fn is_otp_locked(&self) -> bool

Returns true if the enum is StatusCode::OtpLocked otherwise false

pub const fn is_otp_timeout(&self) -> bool

Returns true if the enum is StatusCode::OtpTimeout otherwise false

pub const fn is_otp_crc_check_pass(&self) -> bool

Returns true if the enum is StatusCode::OtpCrcCheckPass otherwise false

pub const fn is_otp_verify_fail(&self) -> bool

Returns true if the enum is StatusCode::OtpVerifyFail otherwise false

pub const fn is_security_subsystem_error(&self) -> bool

Returns true if the enum is StatusCode::SecuritySubsystemError otherwise false

pub const fn is_tp_general_error(&self) -> bool

Returns true if the enum is StatusCode::TpGeneralError otherwise false

pub const fn is_tp_crypto_error(&self) -> bool

Returns true if the enum is StatusCode::TpCryptoError otherwise false

pub const fn is_tp_nullptr_error(&self) -> bool

Returns true if the enum is StatusCode::TpNullptrError otherwise false

pub const fn is_tp_alreadyinitialized(&self) -> bool

Returns true if the enum is StatusCode::TpAlreadyinitialized otherwise false

pub const fn is_tp_buffersmall(&self) -> bool

Returns true if the enum is StatusCode::TpBuffersmall otherwise false

pub const fn is_tp_address_error(&self) -> bool

Returns true if the enum is StatusCode::TpAddressError otherwise false

pub const fn is_tp_container_invalid(&self) -> bool

Returns true if the enum is StatusCode::TpContainerInvalid otherwise false

pub const fn is_tp_containerentryinvalid(&self) -> bool

Returns true if the enum is StatusCode::TpContainerentryinvalid otherwise false

pub const fn is_tp_containerentrynotfound(&self) -> bool

Returns true if the enum is StatusCode::TpContainerentrynotfound otherwise false

pub const fn is_tp_invalidstateoperation(&self) -> bool

Returns true if the enum is StatusCode::TpInvalidstateoperation otherwise false

pub const fn is_tp_command_error(&self) -> bool

Returns true if the enum is StatusCode::TpCommandError otherwise false

pub const fn is_tp_puf_error(&self) -> bool

Returns true if the enum is StatusCode::TpPufError otherwise false

pub const fn is_tp_flash_error(&self) -> bool

Returns true if the enum is StatusCode::TpFlashError otherwise false

pub const fn is_tp_secretbox_error(&self) -> bool

Returns true if the enum is StatusCode::TpSecretboxError otherwise false

pub const fn is_tp_pfr_error(&self) -> bool

Returns true if the enum is StatusCode::TpPfrError otherwise false

pub const fn is_tp_verification_error(&self) -> bool

Returns true if the enum is StatusCode::TpVerificationError otherwise false

pub const fn is_tp_cfpa_error(&self) -> bool

Returns true if the enum is StatusCode::TpCfpaError otherwise false

pub const fn is_tp_cmpa_error(&self) -> bool

Returns true if the enum is StatusCode::TpCmpaError otherwise false

pub const fn is_tp_addr_out_of_range(&self) -> bool

Returns true if the enum is StatusCode::TpAddrOutOfRange otherwise false

pub const fn is_tp_container_addr_error(&self) -> bool

Returns true if the enum is StatusCode::TpContainerAddrError otherwise false

pub const fn is_tp_container_addr_unaligned(&self) -> bool

Returns true if the enum is StatusCode::TpContainerAddrUnaligned otherwise false

pub const fn is_tp_container_buff_small(&self) -> bool

Returns true if the enum is StatusCode::TpContainerBuffSmall otherwise false

pub const fn is_tp_container_no_entry(&self) -> bool

Returns true if the enum is StatusCode::TpContainerNoEntry otherwise false

pub const fn is_tp_cert_addr_error(&self) -> bool

Returns true if the enum is StatusCode::TpCertAddrError otherwise false

pub const fn is_tp_cert_addr_unaligned(&self) -> bool

Returns true if the enum is StatusCode::TpCertAddrUnaligned otherwise false

pub const fn is_tp_cert_overlapping(&self) -> bool

Returns true if the enum is StatusCode::TpCertOverlapping otherwise false

pub const fn is_tp_packet_error(&self) -> bool

Returns true if the enum is StatusCode::TpPacketError otherwise false

pub const fn is_tp_packet_data_error(&self) -> bool

Returns true if the enum is StatusCode::TpPacketDataError otherwise false

pub const fn is_tp_unknown_command(&self) -> bool

Returns true if the enum is StatusCode::TpUnknownCommand otherwise false

pub const fn is_tp_sb_3_file_error(&self) -> bool

Returns true if the enum is StatusCode::TpSb3FileError otherwise false

pub const fn is_tp_general_critical_error(&self) -> bool

Returns true if the enum is StatusCode::TpGeneralCriticalError otherwise false

pub const fn is_tp_crypto_critical_error(&self) -> bool

Returns true if the enum is StatusCode::TpCryptoCriticalError otherwise false

pub const fn is_tp_puf_critical_error(&self) -> bool

Returns true if the enum is StatusCode::TpPufCriticalError otherwise false

pub const fn is_tp_pfr_critical_error(&self) -> bool

Returns true if the enum is StatusCode::TpPfrCriticalError otherwise false

pub const fn is_tp_peripheral_critical_error(&self) -> bool

Returns true if the enum is StatusCode::TpPeripheralCriticalError otherwise false

pub const fn is_tp_prince_critical_error(&self) -> bool

Returns true if the enum is StatusCode::TpPrinceCriticalError otherwise false

pub const fn is_tp_sha_check_critical_error(&self) -> bool

Returns true if the enum is StatusCode::TpShaCheckCriticalError otherwise false

pub const fn is_iap_invalid_argument(&self) -> bool

Returns true if the enum is StatusCode::IapInvalidArgument otherwise false

pub const fn is_iap_out_of_memory(&self) -> bool

Returns true if the enum is StatusCode::IapOutOfMemory otherwise false

pub const fn is_iap_read_disallowed(&self) -> bool

Returns true if the enum is StatusCode::IapReadDisallowed otherwise false

pub const fn is_iap_cumulative_write(&self) -> bool

Returns true if the enum is StatusCode::IapCumulativeWrite otherwise false

pub const fn is_iap_erase_failure(&self) -> bool

Returns true if the enum is StatusCode::IapEraseFailure otherwise false

pub const fn is_iap_command_not_supported(&self) -> bool

Returns true if the enum is StatusCode::IapCommandNotSupported otherwise false

pub const fn is_iap_memory_access_disabled(&self) -> bool

Returns true if the enum is StatusCode::IapMemoryAccessDisabled otherwise false

pub const fn is_el_2go_prov_success(&self) -> bool

Returns true if the enum is StatusCode::El2goProvSuccess otherwise false

pub const fn is_unknown_status_code(&self) -> bool

Returns true if the enum is StatusCode::UnknownStatusCode otherwise false

Trait Implementations

impl Clone for StatusCode

fn clone(&self) -> StatusCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StatusCode

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

Formats the value using the given formatter.

impl Display for StatusCode

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

Formats the value using the given formatter.

impl From<StatusCode> for CommunicationError

fn from(value: StatusCode) -> Self

Convert a McuBoot status code to a communication error

impl From<StatusCode> for u32

fn from(value: StatusCode) -> Self

Convert status code to its numeric representation.

impl PartialEq for StatusCode

fn eq(&self, other: &StatusCode) -> 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 TryFrom<u32> for StatusCode

type Error = TryFromReprError<u32>

The type returned in the event of a conversion error.

fn try_from(val: u32) -> Result<Self, TryFromReprError<u32>>

Performs the conversion.

impl Copy for StatusCode

impl Eq for StatusCode

impl StructuralPartialEq for StatusCode