| // SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com> |
| // SPDX-License-Identifier: MIT OR Apache-2.0 |
| |
| #![no_std] |
| #![doc = include_str!("../README.md")] |
| #![deny(clippy::undocumented_unsafe_blocks)] |
| #![deny(unsafe_op_in_unsafe_fn)] |
| |
| //! # Specification |
| //! |
| //! This implementation is based on |
| //! [Arm Power State Coordination Interface](https://developer.arm.com/documentation/den0022/latest/) |
| //! Platform Design Document Version 1.3 issue F.b. (DEN0022). |
| //! |
| //! The type descriptions below refer to sections of this particular version of the specification. |
| |
| use bitflags::bitflags; |
| use core::fmt::Debug; |
| use num_enum::{IntoPrimitive, TryFromPrimitive}; |
| use thiserror::Error; |
| |
| /// Internal error type of the PSCI module |
| #[derive(Debug, Error, PartialEq, Eq)] |
| pub enum Error { |
| #[error("unrecognised PSCI function ID {0}")] |
| UnrecognisedFunctionId(u32), |
| #[error("unrecognised PSCI error code {0}")] |
| UnrecognisedErrorCode(i32), |
| #[error("invalid PSCI version {0}")] |
| InvalidVersion(u32), |
| #[error("invalid power state value {0}")] |
| InvalidPowerState(u32), |
| #[error("invalid 32 bit CPU MPIDR value {0}")] |
| InvalidMpidr32(u32), |
| #[error("invalid 64 bit CPU MPIDR value {0}")] |
| InvalidMpidr64(u64), |
| #[error("unrecognised SYSTEM_OFF2 type {0}")] |
| UnrecognisedSystemOff2Type(u32), |
| #[error("unrecognised SYSTEM_RESET2 type {0}")] |
| UnrecognisedSystemReset2Type(u32), |
| #[error("unrecognised PSCI_FEATURES flags {0}")] |
| UnrecognisedPsciFeaturesFlags(u32), |
| #[error("unrecognised NODE_HW_STATE {0}")] |
| UnrecognisedHwState(u32), |
| #[error("unrecognised PSCI_SET_SUSPEND_MODE mode {0}")] |
| UnrecognisedSuspendMode(u32), |
| #[error("invalid lower affinity level {0}")] |
| InvalidLowerAffinityLevel(u32), |
| } |
| |
| impl From<Error> for ErrorCode { |
| fn from(value: Error) -> Self { |
| match value { |
| Error::UnrecognisedFunctionId(_) => Self::NotSupported, |
| _ => Self::InvalidParameters, |
| } |
| } |
| } |
| |
| /// 5.1 Function prototypes |
| #[derive(Clone, Copy, Debug, Eq, IntoPrimitive, PartialEq, TryFromPrimitive)] |
| #[num_enum(error_type(name = Error, constructor = Error::UnrecognisedFunctionId))] |
| #[repr(u32)] |
| pub enum FunctionId { |
| PsciVersion = 0x84000000, |
| CpuSuspend32 = 0x84000001, |
| CpuSuspend64 = 0xc4000001, |
| CpuOff = 0x84000002, |
| CpuOn32 = 0x84000003, |
| CpuOn64 = 0xc4000003, |
| AffinityInfo32 = 0x84000004, |
| AffinityInfo64 = 0xc4000004, |
| Migrate32 = 0x84000005, |
| Migrate64 = 0xc4000005, |
| MigrateInfoType = 0x84000006, |
| MigrateInfoUpCpu32 = 0x84000007, |
| MigrateInfoUpCpu64 = 0xc4000007, |
| SystemOff = 0x84000008, |
| SystemOff232 = 0x84000015, |
| SystemOff264 = 0xc4000015, |
| SystemReset = 0x84000009, |
| SystemReset232 = 0x84000012, |
| SystemReset264 = 0xc4000012, |
| MemProtect = 0x84000013, |
| MemProtectCheckRange32 = 0x84000014, |
| MemProtectCheckRange64 = 0xc4000014, |
| PsciFeatures = 0x8400000a, |
| CpuFreeze = 0x8400000b, |
| CpuDefaultSuspend32 = 0x8400000c, |
| CpuDefaultSuspend64 = 0xc400000c, |
| NodeHwState32 = 0x8400000d, |
| NodeHwState64 = 0xc400000d, |
| SystemSuspend32 = 0x8400000e, |
| SystemSuspend64 = 0xc400000e, |
| PsciSetSuspendMode = 0x8400000f, |
| PsciStatResidency32 = 0x84000010, |
| PsciStatResidency64 = 0xc4000010, |
| PsciStatCount32 = 0x84000011, |
| PsciStatCount64 = 0xc4000011, |
| } |
| |
| /// Composite type for capturing success and error return codes. |
| /// See Table 5 Return error codes |
| /// |
| /// Clients can use `ReturnCode` to parse the result register value of a PSCI calls and easily |
| /// determine if it was a success or an error. |
| /// |
| /// Error codes are handled by the `ErrorCode` type. Having a separate type for errors helps using |
| /// `Result<(), ErrorCode>`. If a single type would include both success and error values, |
| /// then `Err(ErrorCode::Success)` would be incomprehensible. |
| #[derive(Clone, Copy, Debug, Eq, PartialEq)] |
| pub enum ReturnCode { |
| Success, |
| Error(ErrorCode), |
| } |
| |
| impl TryFrom<i32> for ReturnCode { |
| type Error = Error; |
| |
| fn try_from(value: i32) -> Result<Self, <Self as TryFrom<i32>>::Error> { |
| Ok(match value { |
| 0 => Self::Success, |
| error_code => Self::Error(ErrorCode::try_from(error_code)?), |
| }) |
| } |
| } |
| |
| impl From<ReturnCode> for i32 { |
| fn from(value: ReturnCode) -> Self { |
| match value { |
| ReturnCode::Success => 0, |
| ReturnCode::Error(error_code) => error_code.into(), |
| } |
| } |
| } |
| |
| /// Error codes |
| /// See Table 5 Return error codes |
| #[derive(Clone, Copy, Debug, Eq, Error, IntoPrimitive, PartialEq, TryFromPrimitive)] |
| #[num_enum(error_type(name = Error, constructor = Error::UnrecognisedErrorCode))] |
| #[repr(i32)] |
| pub enum ErrorCode { |
| #[error("Not supported")] |
| NotSupported = -1, |
| #[error("Invalid parameters")] |
| InvalidParameters = -2, |
| #[error("Denied")] |
| Denied = -3, |
| #[error("Already on")] |
| AlreadyOn = -4, |
| #[error("On pending")] |
| OnPending = -5, |
| #[error("Internal failure")] |
| InternalFailure = -6, |
| #[error("Not present")] |
| NotPresent = -7, |
| #[error("Disabled")] |
| Disabled = -8, |
| #[error("Invalid address")] |
| InvalidAddress = -9, |
| } |
| |
| /// Structure for describing PSCI major and minor version. |
| #[derive(Debug, Eq, PartialEq, Clone, Copy)] |
| pub struct Version { |
| pub major: u16, |
| pub minor: u16, |
| } |
| |
| impl TryFrom<u32> for Version { |
| type Error = Error; |
| |
| fn try_from(value: u32) -> Result<Self, Self::Error> { |
| const MBZ_BITS: u32 = 0x8000_0000; |
| |
| if value & MBZ_BITS != 0 { |
| Err(Error::InvalidVersion(value)) |
| } else { |
| Ok(Self { |
| major: (value >> 16) as u16, |
| minor: value as u16, |
| }) |
| } |
| } |
| } |
| |
| impl From<Version> for u32 { |
| fn from(value: Version) -> Self { |
| const MAJOR_MBZ_BITS: u16 = 0x8000; |
| |
| assert!((value.major & MAJOR_MBZ_BITS) == 0); |
| |
| ((value.major as u32) << 16) | value.minor as u32 |
| } |
| } |
| |
| /// Table 8 power_state parameter bit fields in Extended StateID format. |
| #[derive(Debug, Eq, PartialEq, Clone, Copy)] |
| pub enum PowerState { |
| StandbyOrRetention(u32), |
| PowerDown(u32), |
| } |
| |
| impl PowerState { |
| const STATE_TYPE_PD_BIT: u32 = 1 << 30; |
| const STATE_ID_MASK: u32 = 0x0fff_ffff; |
| const MBZ_BITS: u32 = !(Self::STATE_TYPE_PD_BIT | Self::STATE_ID_MASK); |
| } |
| |
| impl TryFrom<u32> for PowerState { |
| type Error = Error; |
| |
| fn try_from(value: u32) -> Result<Self, Self::Error> { |
| if value & Self::MBZ_BITS != 0 { |
| return Err(Error::InvalidPowerState(value)); |
| } |
| |
| let state_id = value & Self::STATE_ID_MASK; |
| |
| Ok(if value & Self::STATE_TYPE_PD_BIT != 0 { |
| Self::PowerDown(state_id) |
| } else { |
| Self::StandbyOrRetention(state_id) |
| }) |
| } |
| } |
| |
| impl From<PowerState> for u32 { |
| fn from(value: PowerState) -> Self { |
| let (state_type_bit, state_id) = match value { |
| PowerState::StandbyOrRetention(state_id) => (0, state_id), |
| PowerState::PowerDown(state_id) => (PowerState::STATE_TYPE_PD_BIT, state_id), |
| }; |
| |
| assert_eq!(state_id & !PowerState::STATE_ID_MASK, 0x0000_0000); |
| |
| state_type_bit | state_id |
| } |
| } |
| |
| /// Entry point descriptor |
| #[derive(Debug, Eq, PartialEq, Clone, Copy)] |
| pub enum EntryPoint { |
| Entry32 { |
| entry_point_address: u32, |
| context_id: u32, |
| }, |
| Entry64 { |
| entry_point_address: u64, |
| context_id: u64, |
| }, |
| } |
| |
| /// The type contains the affinity fields of the MPIDR register. |
| /// For AArch32 callers this contains Affinity 0, 1, 2 fields and for AAarch64 callers it has |
| /// Affinity 0, 1, 2, 3 fields. |
| #[derive(Debug, Eq, PartialEq, Clone, Copy)] |
| pub struct Mpidr { |
| pub aff0: u8, |
| pub aff1: u8, |
| pub aff2: u8, |
| pub aff3: Option<u8>, |
| } |
| |
| impl Mpidr { |
| /// Create Mpidr instance from aff3-0 values |
| pub const fn from_aff3210(aff3: u8, aff2: u8, aff1: u8, aff0: u8) -> Self { |
| Self { |
| aff0, |
| aff1, |
| aff2, |
| aff3: Some(aff3), |
| } |
| } |
| |
| /// Create Mpidr instance from aff2-0 values |
| pub const fn from_aff210(aff2: u8, aff1: u8, aff0: u8) -> Self { |
| Self { |
| aff0, |
| aff1, |
| aff2, |
| aff3: None, |
| } |
| } |
| } |
| |
| impl TryFrom<u32> for Mpidr { |
| type Error = Error; |
| |
| fn try_from(value: u32) -> Result<Self, Self::Error> { |
| const MBZ_BITS: u32 = 0xff00_0000; |
| |
| if value & MBZ_BITS != 0 { |
| Err(Error::InvalidMpidr32(value)) |
| } else { |
| Ok(Self { |
| aff0: value as u8, |
| aff1: (value >> 8) as u8, |
| aff2: (value >> 16) as u8, |
| aff3: None, |
| }) |
| } |
| } |
| } |
| |
| impl TryFrom<u64> for Mpidr { |
| type Error = Error; |
| |
| fn try_from(value: u64) -> Result<Self, Self::Error> { |
| const MBZ_BITS: u64 = 0xffff_ff00_ff00_0000; |
| |
| if value & MBZ_BITS != 0 { |
| Err(Error::InvalidMpidr64(value)) |
| } else { |
| Ok(Self { |
| aff0: value as u8, |
| aff1: (value >> 8) as u8, |
| aff2: (value >> 16) as u8, |
| aff3: Some((value >> 32) as u8), |
| }) |
| } |
| } |
| } |
| |
| impl From<Mpidr> for u32 { |
| fn from(value: Mpidr) -> Self { |
| assert_eq!(value.aff3, None); |
| ((value.aff2 as u32) << 16) | ((value.aff1 as u32) << 8) | value.aff0 as u32 |
| } |
| } |
| |
| impl From<Mpidr> for u64 { |
| fn from(value: Mpidr) -> Self { |
| assert!(value.aff3.is_some()); |
| |
| ((value.aff3.unwrap() as u64) << 32) |
| | ((value.aff2 as u64) << 16) |
| | ((value.aff1 as u64) << 8) |
| | value.aff0 as u64 |
| } |
| } |
| |
| /// 5.1.5 AFFINITY_INFO return value |
| #[derive(Clone, Copy, Debug, Eq, IntoPrimitive, PartialEq, TryFromPrimitive)] |
| #[repr(u32)] |
| pub enum AffinityInfo { |
| On = 0, |
| Off = 1, |
| OnPending = 2, |
| } |
| |
| /// 5.1.8 MIGRATE_INFO_UP_CPU return value |
| #[derive(Clone, Copy, Debug, Eq, IntoPrimitive, PartialEq, TryFromPrimitive)] |
| #[repr(u32)] |
| pub enum MigrateInfoType { |
| MigrateCapable = 0, |
| NotMigrateCapable = 1, |
| MigrationNotRequired = 2, |
| } |
| |
| /// 5.1.10 SYSTEM_OFF2 type field |
| #[derive(Clone, Copy, Debug, Eq, IntoPrimitive, PartialEq, TryFromPrimitive)] |
| #[num_enum(error_type(name = Error, constructor = Error::UnrecognisedSystemOff2Type))] |
| #[repr(u32)] |
| pub enum SystemOff2Type { |
| HibernateOff = 0x00000001, |
| } |
| |
| /// Additional off/reset parameter |
| #[derive(Clone, Copy, Debug, Eq, PartialEq)] |
| pub enum Cookie { |
| Cookie32(u32), |
| Cookie64(u64), |
| } |
| |
| /// 5.1.12 SYSTEM_RESET2 architectural reset type |
| #[derive(Clone, Copy, Debug, Eq, IntoPrimitive, PartialEq, TryFromPrimitive)] |
| #[num_enum(error_type(name = Error, constructor = Error::UnrecognisedSystemReset2Type))] |
| #[repr(u32)] |
| pub enum ArchitecturalResetType { |
| SystemWarmReset = 0x00000000, |
| } |
| |
| /// 5.1.12 SYSTEM_RESET2 reset type |
| #[derive(Clone, Copy, Debug, Eq, PartialEq)] |
| pub enum ResetType { |
| Architectural(ArchitecturalResetType), |
| VendorSpecific(u32), |
| } |
| |
| impl ResetType { |
| const VENDOR_SPECIFIC_BIT: u32 = 0x8000_0000; |
| } |
| |
| impl TryFrom<u32> for ResetType { |
| type Error = Error; |
| |
| fn try_from(value: u32) -> Result<Self, Self::Error> { |
| Ok(if value & Self::VENDOR_SPECIFIC_BIT == 0 { |
| Self::Architectural(value.try_into()?) |
| } else { |
| Self::VendorSpecific(value & !Self::VENDOR_SPECIFIC_BIT) |
| }) |
| } |
| } |
| |
| impl From<ResetType> for u32 { |
| fn from(value: ResetType) -> Self { |
| match value { |
| ResetType::Architectural(architectural_reset_type) => architectural_reset_type.into(), |
| ResetType::VendorSpecific(vendor_specific_type) => { |
| vendor_specific_type | ResetType::VENDOR_SPECIFIC_BIT |
| } |
| } |
| } |
| } |
| |
| /// 5.1.14 MEM_PROTECT_CHECK_RANGE memory range descriptor |
| #[derive(Debug, Eq, PartialEq, Clone, Copy)] |
| pub enum MemProtectRange { |
| Range32 { base: u32, length: u32 }, |
| Range64 { base: u64, length: u64 }, |
| } |
| |
| /// 5.1.15 PSCI_FEATURES psci_func_id field |
| #[derive(Debug, Eq, PartialEq, Clone, Copy)] |
| pub enum PsciFeature { |
| PsciFunction(FunctionId), |
| SmcccVersion, |
| } |
| |
| impl PsciFeature { |
| const SMCCC_VERSION: u32 = 0x8000_0000; |
| } |
| |
| impl TryFrom<u32> for PsciFeature { |
| type Error = Error; |
| |
| fn try_from(value: u32) -> Result<Self, Self::Error> { |
| Ok(if value == Self::SMCCC_VERSION { |
| Self::SmcccVersion |
| } else { |
| Self::PsciFunction(value.try_into()?) |
| }) |
| } |
| } |
| |
| impl From<PsciFeature> for u32 { |
| fn from(value: PsciFeature) -> u32 { |
| match value { |
| PsciFeature::PsciFunction(function_id) => function_id.into(), |
| PsciFeature::SmcccVersion => PsciFeature::SMCCC_VERSION, |
| } |
| } |
| } |
| |
| /// Table 11 Return values if a function is implemented / CPU_SUSPEND |
| #[derive(Debug, Eq, PartialEq, Clone, Copy)] |
| #[repr(transparent)] |
| pub struct FeatureFlagsCpuSuspend(u32); |
| |
| bitflags! { |
| impl FeatureFlagsCpuSuspend : u32 { |
| const EXTENDED_POWER_STATE = 0x0000_0002; |
| const OS_INITIATED_MODE = 0x0000_0001; |
| } |
| } |
| |
| impl TryFrom<u32> for FeatureFlagsCpuSuspend { |
| type Error = Error; |
| |
| fn try_from(value: u32) -> Result<Self, Self::Error> { |
| Self::from_bits(value).ok_or(Error::UnrecognisedPsciFeaturesFlags(value)) |
| } |
| } |
| |
| impl From<FeatureFlagsCpuSuspend> for u32 { |
| fn from(value: FeatureFlagsCpuSuspend) -> Self { |
| value.bits() |
| } |
| } |
| |
| /// Table 11 Return values if a function is implemented / SYSTEM_OFF2 |
| #[derive(Debug, Eq, PartialEq, Clone, Copy)] |
| #[repr(transparent)] |
| pub struct FeatureFlagsSystemOff2(u32); |
| |
| bitflags! { |
| impl FeatureFlagsSystemOff2 : u32 { |
| const HIBERNATE_OFF = 0x0000_0001; |
| } |
| } |
| |
| impl TryFrom<u32> for FeatureFlagsSystemOff2 { |
| type Error = Error; |
| |
| fn try_from(value: u32) -> Result<Self, Self::Error> { |
| Self::from_bits(value).ok_or(Error::UnrecognisedPsciFeaturesFlags(value)) |
| } |
| } |
| |
| impl From<FeatureFlagsSystemOff2> for u32 { |
| fn from(value: FeatureFlagsSystemOff2) -> Self { |
| value.bits() |
| } |
| } |
| |
| /// 5.1.18 NODE_HW_STATE return value |
| #[derive(Clone, Copy, Debug, Eq, IntoPrimitive, PartialEq, TryFromPrimitive)] |
| #[num_enum(error_type(name = Error, constructor = Error::UnrecognisedHwState))] |
| #[repr(u32)] |
| pub enum HwState { |
| On = 0, |
| Off = 1, |
| Standby = 2, |
| } |
| |
| /// 5.1.20 PSCI_SET_SUSPEND_MODE mode field |
| #[derive(Clone, Copy, Debug, Eq, IntoPrimitive, PartialEq, TryFromPrimitive)] |
| #[num_enum(error_type(name = Error, constructor = Error::UnrecognisedSuspendMode))] |
| #[repr(u32)] |
| pub enum SuspendMode { |
| PlatformCoordinated = 0, |
| OsInitiated = 1, |
| } |
| |
| /// Enum for representing PSCI requests and their arguments. |
| #[derive(Debug, Eq, PartialEq, Clone, Copy)] |
| pub enum Function { |
| Version, |
| CpuSuspend { |
| state: PowerState, |
| entry: EntryPoint, |
| }, |
| CpuOff, |
| CpuOn { |
| target_cpu: Mpidr, |
| entry: EntryPoint, |
| }, |
| AffinityInfo { |
| mpidr: Mpidr, |
| lowest_affinity_level: u32, |
| }, |
| Migrate { |
| target_affinity: Mpidr, |
| }, |
| MigrateInfoType, |
| MigrateInfoUpCpu { |
| is_32bit: bool, |
| }, |
| SystemOff, |
| SystemOff2 { |
| off_type: SystemOff2Type, |
| cookie: Cookie, |
| }, |
| SystemReset, |
| SystemReset2 { |
| reset_type: ResetType, |
| cookie: Cookie, |
| }, |
| MemProtect { |
| enabled: bool, |
| }, |
| MemProtectCheckRange { |
| range: MemProtectRange, |
| }, |
| Features { |
| psci_func_id: PsciFeature, |
| }, |
| CpuFreeze, |
| CpuDefaultSuspend { |
| entry: EntryPoint, |
| }, |
| NodeHwState { |
| target_cpu: Mpidr, |
| power_level: u32, |
| }, |
| SystemSuspend { |
| entry: EntryPoint, |
| }, |
| SetSuspendMode { |
| mode: SuspendMode, |
| }, |
| StatResidency { |
| target_cpu: Mpidr, |
| power_state: PowerState, |
| }, |
| StatCount { |
| target_cpu: Mpidr, |
| power_state: PowerState, |
| }, |
| } |
| |
| impl TryFrom<[u64; 4]> for Function { |
| type Error = Error; |
| |
| fn try_from(regs: [u64; 4]) -> Result<Self, Error> { |
| let fid = FunctionId::try_from(regs[0] as u32)?; |
| |
| let msg = match fid { |
| FunctionId::PsciVersion => Self::Version, |
| FunctionId::CpuSuspend32 => Self::CpuSuspend { |
| state: PowerState::try_from(regs[1] as u32)?, |
| entry: EntryPoint::Entry32 { |
| entry_point_address: regs[2] as u32, |
| context_id: regs[3] as u32, |
| }, |
| }, |
| FunctionId::CpuSuspend64 => Self::CpuSuspend { |
| state: PowerState::try_from(regs[1] as u32)?, |
| entry: EntryPoint::Entry64 { |
| entry_point_address: regs[2], |
| context_id: regs[3], |
| }, |
| }, |
| FunctionId::CpuOff => Self::CpuOff, |
| FunctionId::CpuOn32 => Self::CpuOn { |
| target_cpu: (regs[1] as u32).try_into()?, |
| entry: EntryPoint::Entry32 { |
| entry_point_address: regs[2] as u32, |
| context_id: regs[3] as u32, |
| }, |
| }, |
| FunctionId::CpuOn64 => Self::CpuOn { |
| target_cpu: regs[1].try_into()?, |
| entry: EntryPoint::Entry64 { |
| entry_point_address: regs[2], |
| context_id: regs[3], |
| }, |
| }, |
| FunctionId::AffinityInfo32 => { |
| let lowest_affinity_level = regs[2] as u32; |
| if lowest_affinity_level > 2 { |
| return Err(Error::InvalidLowerAffinityLevel(lowest_affinity_level)); |
| } |
| Self::AffinityInfo { |
| mpidr: (regs[1] as u32).try_into()?, |
| lowest_affinity_level, |
| } |
| } |
| FunctionId::AffinityInfo64 => { |
| let lowest_affinity_level = regs[2] as u32; |
| if lowest_affinity_level > 3 { |
| return Err(Error::InvalidLowerAffinityLevel(lowest_affinity_level)); |
| } |
| Self::AffinityInfo { |
| mpidr: regs[1].try_into()?, |
| lowest_affinity_level, |
| } |
| } |
| FunctionId::Migrate32 => Self::Migrate { |
| target_affinity: (regs[1] as u32).try_into()?, |
| }, |
| FunctionId::Migrate64 => Self::Migrate { |
| target_affinity: regs[1].try_into()?, |
| }, |
| FunctionId::MigrateInfoType => Self::MigrateInfoType, |
| FunctionId::MigrateInfoUpCpu32 => Self::MigrateInfoUpCpu { is_32bit: true }, |
| FunctionId::MigrateInfoUpCpu64 => Self::MigrateInfoUpCpu { is_32bit: false }, |
| FunctionId::SystemOff => Self::SystemOff, |
| FunctionId::SystemOff232 => Self::SystemOff2 { |
| off_type: SystemOff2Type::try_from_primitive(regs[1] as u32)?, |
| cookie: Cookie::Cookie32(regs[2] as u32), |
| }, |
| FunctionId::SystemOff264 => Self::SystemOff2 { |
| off_type: SystemOff2Type::try_from_primitive(regs[1] as u32)?, |
| cookie: Cookie::Cookie64(regs[2]), |
| }, |
| FunctionId::SystemReset => Self::SystemReset, |
| FunctionId::SystemReset232 => Self::SystemReset2 { |
| reset_type: (regs[1] as u32).try_into()?, |
| cookie: Cookie::Cookie32(regs[2] as u32), |
| }, |
| FunctionId::SystemReset264 => Self::SystemReset2 { |
| reset_type: (regs[1] as u32).try_into()?, |
| cookie: Cookie::Cookie64(regs[2]), |
| }, |
| FunctionId::MemProtect => Self::MemProtect { |
| enabled: regs[1] != 0, |
| }, |
| FunctionId::MemProtectCheckRange32 => Self::MemProtectCheckRange { |
| range: MemProtectRange::Range32 { |
| base: regs[1] as u32, |
| length: regs[2] as u32, |
| }, |
| }, |
| FunctionId::MemProtectCheckRange64 => Self::MemProtectCheckRange { |
| range: MemProtectRange::Range64 { |
| base: regs[1], |
| length: regs[2], |
| }, |
| }, |
| FunctionId::PsciFeatures => Self::Features { |
| psci_func_id: (regs[1] as u32).try_into()?, |
| }, |
| FunctionId::CpuFreeze => Self::CpuFreeze, |
| FunctionId::CpuDefaultSuspend32 => Self::CpuDefaultSuspend { |
| entry: EntryPoint::Entry32 { |
| entry_point_address: regs[1] as u32, |
| context_id: regs[2] as u32, |
| }, |
| }, |
| FunctionId::CpuDefaultSuspend64 => Self::CpuDefaultSuspend { |
| entry: EntryPoint::Entry64 { |
| entry_point_address: regs[1], |
| context_id: regs[2], |
| }, |
| }, |
| FunctionId::NodeHwState32 => Self::NodeHwState { |
| target_cpu: (regs[1] as u32).try_into()?, |
| power_level: regs[2] as u32, |
| }, |
| FunctionId::NodeHwState64 => Self::NodeHwState { |
| target_cpu: regs[1].try_into()?, |
| power_level: regs[2] as u32, |
| }, |
| FunctionId::SystemSuspend32 => Self::SystemSuspend { |
| entry: EntryPoint::Entry32 { |
| entry_point_address: regs[1] as u32, |
| context_id: regs[2] as u32, |
| }, |
| }, |
| FunctionId::SystemSuspend64 => Self::SystemSuspend { |
| entry: EntryPoint::Entry64 { |
| entry_point_address: regs[1], |
| context_id: regs[2], |
| }, |
| }, |
| FunctionId::PsciSetSuspendMode => Self::SetSuspendMode { |
| mode: SuspendMode::try_from_primitive(regs[1] as u32)?, |
| }, |
| FunctionId::PsciStatResidency32 => Self::StatResidency { |
| target_cpu: (regs[1] as u32).try_into()?, |
| power_state: PowerState::try_from(regs[2] as u32)?, |
| }, |
| FunctionId::PsciStatResidency64 => Self::StatResidency { |
| target_cpu: regs[1].try_into()?, |
| power_state: PowerState::try_from(regs[2] as u32)?, |
| }, |
| FunctionId::PsciStatCount32 => Self::StatCount { |
| target_cpu: (regs[1] as u32).try_into()?, |
| power_state: PowerState::try_from(regs[2] as u32)?, |
| }, |
| FunctionId::PsciStatCount64 => Self::StatCount { |
| target_cpu: regs[1].try_into()?, |
| power_state: PowerState::try_from(regs[2] as u32)?, |
| }, |
| }; |
| |
| Ok(msg) |
| } |
| } |
| |
| impl Function { |
| /// Returns the function ID for the call. |
| pub fn function_id(&self) -> FunctionId { |
| match self { |
| Function::Version => FunctionId::PsciVersion, |
| Function::CpuSuspend { |
| entry: EntryPoint::Entry32 { .. }, |
| .. |
| } => FunctionId::CpuSuspend32, |
| Function::CpuSuspend { |
| entry: EntryPoint::Entry64 { .. }, |
| .. |
| } => FunctionId::CpuSuspend64, |
| Function::CpuOff => FunctionId::CpuOff, |
| Function::CpuOn { |
| target_cpu: Mpidr { aff3: None, .. }, |
| entry: EntryPoint::Entry32 { .. }, |
| } => FunctionId::CpuOn32, |
| Function::CpuOn { |
| target_cpu: Mpidr { aff3: Some(_), .. }, |
| entry: EntryPoint::Entry64 { .. }, |
| } => FunctionId::CpuOn64, |
| Function::CpuOn { .. } => panic!("Mixed 32 bit and 64 bit CpuOn arguments"), |
| Function::AffinityInfo { |
| mpidr: Mpidr { aff3: None, .. }, |
| .. |
| } => FunctionId::AffinityInfo32, |
| Function::AffinityInfo { |
| mpidr: Mpidr { aff3: Some(_), .. }, |
| .. |
| } => FunctionId::AffinityInfo64, |
| Function::Migrate { |
| target_affinity: Mpidr { aff3: None, .. }, |
| } => FunctionId::Migrate32, |
| Function::Migrate { |
| target_affinity: Mpidr { aff3: Some(_), .. }, |
| } => FunctionId::Migrate64, |
| Function::MigrateInfoType => FunctionId::MigrateInfoType, |
| Function::MigrateInfoUpCpu { is_32bit: true } => FunctionId::MigrateInfoUpCpu32, |
| Function::MigrateInfoUpCpu { is_32bit: false } => FunctionId::MigrateInfoUpCpu64, |
| Function::SystemOff => FunctionId::SystemOff, |
| Function::SystemOff2 { |
| cookie: Cookie::Cookie32(_), |
| .. |
| } => FunctionId::SystemOff232, |
| Function::SystemOff2 { |
| cookie: Cookie::Cookie64(_), |
| .. |
| } => FunctionId::SystemOff264, |
| Function::SystemReset => FunctionId::SystemReset, |
| Function::SystemReset2 { |
| cookie: Cookie::Cookie32(_), |
| .. |
| } => FunctionId::SystemReset232, |
| Function::SystemReset2 { |
| cookie: Cookie::Cookie64(_), |
| .. |
| } => FunctionId::SystemReset264, |
| Function::MemProtect { .. } => FunctionId::MemProtect, |
| Function::MemProtectCheckRange { |
| range: MemProtectRange::Range32 { .. }, |
| } => FunctionId::MemProtectCheckRange32, |
| Function::MemProtectCheckRange { |
| range: MemProtectRange::Range64 { .. }, |
| } => FunctionId::MemProtectCheckRange64, |
| Function::Features { .. } => FunctionId::PsciFeatures, |
| Function::CpuFreeze => FunctionId::CpuFreeze, |
| Function::CpuDefaultSuspend { |
| entry: EntryPoint::Entry32 { .. }, |
| } => FunctionId::CpuDefaultSuspend32, |
| Function::CpuDefaultSuspend { |
| entry: EntryPoint::Entry64 { .. }, |
| } => FunctionId::CpuDefaultSuspend64, |
| Function::NodeHwState { |
| target_cpu: Mpidr { aff3: None, .. }, |
| .. |
| } => FunctionId::NodeHwState32, |
| Function::NodeHwState { |
| target_cpu: Mpidr { aff3: Some(_), .. }, |
| .. |
| } => FunctionId::NodeHwState64, |
| Function::SystemSuspend { |
| entry: EntryPoint::Entry32 { .. }, |
| } => FunctionId::SystemSuspend32, |
| Function::SystemSuspend { |
| entry: EntryPoint::Entry64 { .. }, |
| } => FunctionId::SystemSuspend64, |
| Function::SetSuspendMode { .. } => FunctionId::PsciSetSuspendMode, |
| Function::StatResidency { |
| target_cpu: Mpidr { aff3: None, .. }, |
| .. |
| } => FunctionId::PsciStatResidency32, |
| Function::StatResidency { |
| target_cpu: Mpidr { aff3: Some(_), .. }, |
| .. |
| } => FunctionId::PsciStatResidency64, |
| Function::StatCount { |
| target_cpu: Mpidr { aff3: None, .. }, |
| .. |
| } => FunctionId::PsciStatCount32, |
| Function::StatCount { |
| target_cpu: Mpidr { aff3: Some(_), .. }, |
| .. |
| } => FunctionId::PsciStatCount64, |
| } |
| } |
| |
| pub fn copy_to_array(&self, a: &mut [u64; 4]) { |
| a.fill(0); |
| a[0] = u32::from(self.function_id()).into(); |
| |
| match *self { |
| Function::Version |
| | Function::CpuOff |
| | Function::MigrateInfoType |
| | Function::MigrateInfoUpCpu { .. } |
| | Function::SystemOff |
| | Function::SystemReset |
| | Function::CpuFreeze => {} |
| Function::CpuSuspend { state, entry } => { |
| a[1] = u32::from(state).into(); |
| (a[2], a[3]) = match entry { |
| EntryPoint::Entry32 { |
| entry_point_address, |
| context_id, |
| } => (entry_point_address.into(), context_id.into()), |
| EntryPoint::Entry64 { |
| entry_point_address, |
| context_id, |
| } => (entry_point_address, context_id), |
| } |
| } |
| Function::CpuOn { target_cpu, entry } => { |
| a[1] = match target_cpu { |
| Mpidr { aff3: None, .. } => u32::from(target_cpu).into(), |
| Mpidr { aff3: Some(_), .. } => u64::from(target_cpu), |
| }; |
| (a[2], a[3]) = match entry { |
| EntryPoint::Entry32 { |
| entry_point_address, |
| context_id, |
| } => (entry_point_address.into(), context_id.into()), |
| EntryPoint::Entry64 { |
| entry_point_address, |
| context_id, |
| } => (entry_point_address, context_id), |
| } |
| } |
| Function::AffinityInfo { |
| mpidr, |
| lowest_affinity_level, |
| } => { |
| a[1] = match mpidr { |
| Mpidr { aff3: None, .. } => u32::from(mpidr).into(), |
| Mpidr { aff3: Some(_), .. } => u64::from(mpidr), |
| }; |
| a[2] = lowest_affinity_level.into(); |
| } |
| Function::Migrate { target_affinity } => { |
| a[1] = match target_affinity { |
| Mpidr { aff3: None, .. } => u32::from(target_affinity).into(), |
| Mpidr { aff3: Some(_), .. } => u64::from(target_affinity), |
| }; |
| } |
| Function::SystemOff2 { |
| off_type: hibernate_type, |
| cookie, |
| } => { |
| a[1] = u32::from(hibernate_type).into(); |
| a[2] = match cookie { |
| Cookie::Cookie32(value) => value.into(), |
| Cookie::Cookie64(value) => value, |
| }; |
| } |
| Function::SystemReset2 { reset_type, cookie } => { |
| a[1] = u32::from(reset_type).into(); |
| a[2] = match cookie { |
| Cookie::Cookie32(value) => value.into(), |
| Cookie::Cookie64(value) => value, |
| }; |
| } |
| Function::MemProtect { enabled } => { |
| a[1] = if enabled { 0x0000_0001 } else { 0x0000_0000 }; |
| } |
| Function::MemProtectCheckRange { range } => { |
| (a[1], a[2]) = match range { |
| MemProtectRange::Range32 { base, length } => (base.into(), length.into()), |
| MemProtectRange::Range64 { base, length } => (base, length), |
| } |
| } |
| Function::Features { psci_func_id } => { |
| a[1] = u32::from(psci_func_id).into(); |
| } |
| Function::CpuDefaultSuspend { entry } => { |
| (a[1], a[2]) = match entry { |
| EntryPoint::Entry32 { |
| entry_point_address, |
| context_id, |
| } => (entry_point_address.into(), context_id.into()), |
| EntryPoint::Entry64 { |
| entry_point_address, |
| context_id, |
| } => (entry_point_address, context_id), |
| } |
| } |
| Function::NodeHwState { |
| target_cpu, |
| power_level, |
| } => { |
| a[1] = match target_cpu { |
| Mpidr { aff3: None, .. } => u32::from(target_cpu).into(), |
| Mpidr { aff3: Some(_), .. } => u64::from(target_cpu), |
| }; |
| a[2] = power_level.into(); |
| } |
| Function::SystemSuspend { entry } => { |
| (a[1], a[2]) = match entry { |
| EntryPoint::Entry32 { |
| entry_point_address, |
| context_id, |
| } => (entry_point_address.into(), context_id.into()), |
| EntryPoint::Entry64 { |
| entry_point_address, |
| context_id, |
| } => (entry_point_address, context_id), |
| } |
| } |
| Function::SetSuspendMode { mode } => { |
| a[1] = u32::from(mode).into(); |
| } |
| Function::StatResidency { |
| target_cpu, |
| power_state, |
| } => { |
| a[1] = match target_cpu { |
| Mpidr { aff3: None, .. } => u32::from(target_cpu).into(), |
| Mpidr { aff3: Some(_), .. } => u64::from(target_cpu), |
| }; |
| a[2] = u32::from(power_state).into(); |
| } |
| Function::StatCount { |
| target_cpu, |
| power_state, |
| } => { |
| a[1] = match target_cpu { |
| Mpidr { aff3: None, .. } => u32::from(target_cpu).into(), |
| Mpidr { aff3: Some(_), .. } => u64::from(target_cpu), |
| }; |
| a[2] = u32::from(power_state).into(); |
| } |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| |
| const MPIDR32: Mpidr = Mpidr { |
| aff0: 0x11, |
| aff1: 0x22, |
| aff2: 0x33, |
| aff3: None, |
| }; |
| const MPIDR32_VALUE: u32 = 0x00332211; |
| |
| const MPIDR64: Mpidr = Mpidr { |
| aff0: 0x11, |
| aff1: 0x22, |
| aff2: 0x33, |
| aff3: Some(0x44), |
| }; |
| |
| const MPIDR64_VALUE: u64 = 0x00000044_00332211; |
| |
| const POWER_STATE: PowerState = PowerState::PowerDown(0xf12_3456); |
| |
| const POWER_STATE_VALUE: u32 = 0x4f12_3456; |
| |
| macro_rules! validate_function { |
| ( $regs:expr, $function:expr, $function_id:expr ) => { |
| assert_eq!(Ok($function), Function::try_from($regs)); |
| assert_eq!($function_id, ($function).function_id()); |
| |
| let mut built_regs = [0; 4]; |
| $function.copy_to_array(&mut built_regs); |
| assert_eq!($regs, built_regs); |
| }; |
| } |
| |
| #[test] |
| fn test_error() { |
| assert_eq!( |
| ErrorCode::NotSupported, |
| ErrorCode::from(Error::UnrecognisedFunctionId(0)) |
| ); |
| |
| assert_eq!( |
| ErrorCode::InvalidParameters, |
| ErrorCode::from(Error::InvalidVersion(0)) |
| ); |
| } |
| |
| #[test] |
| fn test_return_code() { |
| assert_eq!( |
| Err(Error::UnrecognisedErrorCode(-100)), |
| ReturnCode::try_from(-100) |
| ); |
| |
| assert_eq!(Ok(ReturnCode::Success), ReturnCode::try_from(0)); |
| assert_eq!( |
| Ok(ReturnCode::Error(ErrorCode::NotSupported)), |
| ReturnCode::try_from(-1) |
| ); |
| |
| assert_eq!(0, i32::from(ReturnCode::Success)); |
| assert_eq!(-1, i32::from(ReturnCode::Error(ErrorCode::NotSupported))); |
| } |
| |
| #[test] |
| fn test_error_code() { |
| assert_eq!(-1, i32::from(ErrorCode::NotSupported)); |
| assert_eq!(-2, i32::from(ErrorCode::InvalidParameters)); |
| assert_eq!(-3, i32::from(ErrorCode::Denied)); |
| assert_eq!(-4, i32::from(ErrorCode::AlreadyOn)); |
| assert_eq!(-5, i32::from(ErrorCode::OnPending)); |
| assert_eq!(-6, i32::from(ErrorCode::InternalFailure)); |
| assert_eq!(-7, i32::from(ErrorCode::NotPresent)); |
| assert_eq!(-8, i32::from(ErrorCode::Disabled)); |
| assert_eq!(-9, i32::from(ErrorCode::InvalidAddress)); |
| } |
| |
| #[test] |
| fn test_version() { |
| assert_eq!( |
| Err(Error::InvalidVersion(0xffff_ffff)), |
| Version::try_from(0xffff_ffff) |
| ); |
| |
| assert_eq!( |
| Ok(Version { |
| major: 0x7123, |
| minor: 0x4567 |
| }), |
| Version::try_from(0x7123_4567) |
| ); |
| |
| assert_eq!( |
| 0x789a_bcde, |
| u32::from(Version { |
| major: 0x789a, |
| minor: 0xbcde |
| }) |
| ); |
| } |
| |
| #[test] |
| fn test_power_state() { |
| assert_eq!( |
| Err(Error::InvalidPowerState(0x8000_0000)), |
| PowerState::try_from(0x8000_0000) |
| ); |
| |
| assert_eq!( |
| Err(Error::InvalidPowerState(0x3000_0000)), |
| PowerState::try_from(0x3000_0000) |
| ); |
| |
| assert_eq!( |
| Ok(PowerState::StandbyOrRetention(0xfff_ffff),), |
| PowerState::try_from(0x0fff_ffff) |
| ); |
| |
| assert_eq!( |
| Ok(PowerState::PowerDown(0x123_ffff)), |
| PowerState::try_from(0x4123_ffff) |
| ); |
| |
| assert_eq!( |
| 0x0123_4567, |
| u32::from(PowerState::StandbyOrRetention(0x123_4567)) |
| ); |
| |
| assert_eq!(0x4123_4567, u32::from(PowerState::PowerDown(0x123_4567))); |
| } |
| |
| #[test] |
| fn test_mpidr() { |
| assert_eq!( |
| Err(Error::InvalidMpidr32(0xff00_0000)), |
| Mpidr::try_from(0xff00_0000u32) |
| ); |
| |
| assert_eq!( |
| Ok(Mpidr { |
| aff0: 0x33, |
| aff1: 0x22, |
| aff2: 0x11, |
| aff3: None |
| }), |
| Mpidr::try_from(0x0011_2233u32) |
| ); |
| |
| assert_eq!( |
| Err(Error::InvalidMpidr64(0xff00_0000_0000_0000)), |
| Mpidr::try_from(0xff00_0000_0000_0000u64) |
| ); |
| |
| assert_eq!( |
| Ok(Mpidr { |
| aff0: 0x33, |
| aff1: 0x22, |
| aff2: 0x11, |
| aff3: Some(0x44) |
| }), |
| Mpidr::try_from(0x0000_0044_0011_2233u64) |
| ); |
| |
| assert_eq!( |
| 0x0011_2233u32, |
| Mpidr { |
| aff0: 0x33, |
| aff1: 0x22, |
| aff2: 0x11, |
| aff3: None |
| } |
| .into() |
| ); |
| |
| assert_eq!( |
| 0x0000_0044_0011_2233u64, |
| Mpidr { |
| aff0: 0x33, |
| aff1: 0x22, |
| aff2: 0x11, |
| aff3: Some(0x44) |
| } |
| .into() |
| ); |
| } |
| |
| #[test] |
| #[should_panic] |
| fn test_mpidr_32_invalid() { |
| let _ = u32::from(Mpidr { |
| aff0: 0x33, |
| aff1: 0x22, |
| aff2: 0x11, |
| aff3: Some(0x44), |
| }); |
| } |
| |
| #[test] |
| #[should_panic] |
| fn test_mpidr_64_invalid() { |
| let _ = u64::from(Mpidr { |
| aff0: 0x33, |
| aff1: 0x22, |
| aff2: 0x11, |
| aff3: None, |
| }); |
| } |
| |
| #[test] |
| fn test_affinity_info_value() { |
| assert_eq!(0, u32::from(AffinityInfo::On)); |
| assert_eq!(1, u32::from(AffinityInfo::Off)); |
| assert_eq!(2, u32::from(AffinityInfo::OnPending)); |
| } |
| |
| #[test] |
| fn test_migration_info_type() { |
| assert_eq!(0, u32::from(MigrateInfoType::MigrateCapable)); |
| assert_eq!(1, u32::from(MigrateInfoType::NotMigrateCapable)); |
| assert_eq!(2, u32::from(MigrateInfoType::MigrationNotRequired)); |
| } |
| |
| #[test] |
| fn test_reset_type() { |
| assert_eq!( |
| Err(Error::UnrecognisedSystemReset2Type(0x1234_5678)), |
| ResetType::try_from(0x1234_5678) |
| ); |
| |
| assert_eq!( |
| Ok(ResetType::Architectural( |
| ArchitecturalResetType::SystemWarmReset |
| )), |
| ResetType::try_from(0x0000_0000) |
| ); |
| |
| assert_eq!( |
| Ok(ResetType::VendorSpecific(0x0000_0001)), |
| ResetType::try_from(0x8000_0001) |
| ); |
| |
| assert_eq!( |
| 0x0000_0000u32, |
| ResetType::Architectural(ArchitecturalResetType::SystemWarmReset).into() |
| ); |
| assert_eq!( |
| 0x8000_0001u32, |
| ResetType::VendorSpecific(0x0000_0001).into() |
| ); |
| } |
| |
| #[test] |
| fn test_psci_feature() { |
| assert_eq!( |
| Err(Error::UnrecognisedFunctionId(0x1234_5678)), |
| PsciFeature::try_from(0x1234_5678) |
| ); |
| |
| assert_eq!( |
| Ok(PsciFeature::SmcccVersion), |
| PsciFeature::try_from(0x8000_0000) |
| ); |
| |
| assert_eq!( |
| Ok(PsciFeature::PsciFunction(FunctionId::PsciVersion)), |
| PsciFeature::try_from(0x8400_0000) |
| ); |
| |
| assert_eq!(0x8000_0000u32, PsciFeature::SmcccVersion.into()); |
| assert_eq!( |
| 0x8400_0000u32, |
| PsciFeature::PsciFunction(FunctionId::PsciVersion).into() |
| ); |
| } |
| |
| #[test] |
| fn test_feature_flags_suspend() { |
| assert_eq!( |
| Err(Error::UnrecognisedPsciFeaturesFlags(0x0000_0004)), |
| FeatureFlagsCpuSuspend::try_from(0x0000_0004) |
| ); |
| |
| assert_eq!( |
| Ok(FeatureFlagsCpuSuspend::empty()), |
| FeatureFlagsCpuSuspend::try_from(0x0000_0000) |
| ); |
| |
| assert_eq!( |
| Ok(FeatureFlagsCpuSuspend::OS_INITIATED_MODE), |
| FeatureFlagsCpuSuspend::try_from(0x0000_0001) |
| ); |
| |
| assert_eq!( |
| Ok(FeatureFlagsCpuSuspend::EXTENDED_POWER_STATE), |
| FeatureFlagsCpuSuspend::try_from(0x0000_0002) |
| ); |
| |
| assert_eq!( |
| Ok(FeatureFlagsCpuSuspend::OS_INITIATED_MODE |
| | FeatureFlagsCpuSuspend::EXTENDED_POWER_STATE), |
| FeatureFlagsCpuSuspend::try_from(0x0000_0003) |
| ); |
| |
| assert_eq!( |
| 0x0000_0003, |
| u32::from( |
| FeatureFlagsCpuSuspend::OS_INITIATED_MODE |
| | FeatureFlagsCpuSuspend::EXTENDED_POWER_STATE |
| ) |
| ); |
| } |
| |
| #[test] |
| fn test_feature_flags_system_off2() { |
| assert_eq!( |
| Err(Error::UnrecognisedPsciFeaturesFlags(0x0000_0002)), |
| FeatureFlagsSystemOff2::try_from(0x0000_0002) |
| ); |
| |
| assert_eq!( |
| Ok(FeatureFlagsSystemOff2::empty()), |
| FeatureFlagsSystemOff2::try_from(0x0000_0000) |
| ); |
| |
| assert_eq!( |
| Ok(FeatureFlagsSystemOff2::HIBERNATE_OFF), |
| FeatureFlagsSystemOff2::try_from(0x0000_0001) |
| ); |
| |
| assert_eq!(0x0000_0000u32, FeatureFlagsSystemOff2::empty().into()); |
| |
| assert_eq!(0x0000_0001u32, FeatureFlagsSystemOff2::HIBERNATE_OFF.into()); |
| } |
| |
| #[test] |
| fn test_hw_state() { |
| assert_eq!(0, u32::from(HwState::On)); |
| assert_eq!(1, u32::from(HwState::Off)); |
| assert_eq!(2, u32::from(HwState::Standby)); |
| } |
| |
| #[test] |
| fn test_function_version() { |
| validate_function!( |
| [0x8400_0000, 0, 0, 0], |
| Function::Version, |
| FunctionId::PsciVersion |
| ); |
| } |
| |
| #[test] |
| fn test_cpu_suspend() { |
| validate_function!( |
| [ |
| 0x8400_0001, |
| POWER_STATE_VALUE.into(), |
| 0xabcdef01, |
| 0x23456789 |
| ], |
| Function::CpuSuspend { |
| state: POWER_STATE, |
| entry: EntryPoint::Entry32 { |
| entry_point_address: 0xabcdef01, |
| context_id: 0x23456789 |
| } |
| }, |
| FunctionId::CpuSuspend32 |
| ); |
| |
| validate_function!( |
| [ |
| 0xc400_0001, |
| POWER_STATE_VALUE.into(), |
| 0xabcdef01_23456789, |
| 0x23456789_abcdef01 |
| ], |
| Function::CpuSuspend { |
| state: POWER_STATE, |
| entry: EntryPoint::Entry64 { |
| entry_point_address: 0xabcdef01_23456789, |
| context_id: 0x23456789_abcdef01 |
| } |
| }, |
| FunctionId::CpuSuspend64 |
| ); |
| } |
| |
| #[test] |
| fn test_function_cpu_off() { |
| validate_function!([0x8400_0002, 0, 0, 0], Function::CpuOff, FunctionId::CpuOff); |
| } |
| |
| #[test] |
| fn test_function_cpu_on() { |
| validate_function!( |
| [0x8400_0003, MPIDR32_VALUE.into(), 0xabcdef01, 0x23456789], |
| Function::CpuOn { |
| target_cpu: MPIDR32, |
| entry: EntryPoint::Entry32 { |
| entry_point_address: 0xabcdef01, |
| context_id: 0x23456789, |
| }, |
| }, |
| FunctionId::CpuOn32 |
| ); |
| |
| validate_function!( |
| [ |
| 0xc400_0003, |
| MPIDR64_VALUE, |
| 0x01234567_89abcdef, |
| 0x89abcdef_01234567, |
| ], |
| Function::CpuOn { |
| target_cpu: MPIDR64, |
| entry: EntryPoint::Entry64 { |
| entry_point_address: 0x01234567_89abcdef, |
| context_id: 0x89abcdef_01234567, |
| }, |
| }, |
| FunctionId::CpuOn64 |
| ); |
| } |
| |
| #[test] |
| #[should_panic] |
| fn test_function_cpu_on_mixed_32_64() { |
| let mut regs = [0u64; 4]; |
| Function::CpuOn { |
| target_cpu: MPIDR64, |
| entry: EntryPoint::Entry32 { |
| entry_point_address: 1, |
| context_id: 2, |
| }, |
| } |
| .copy_to_array(&mut regs); |
| } |
| |
| #[test] |
| fn test_function_affinity_info() { |
| validate_function!( |
| [0x8400_0004, MPIDR32_VALUE.into(), 2, 0], |
| Function::AffinityInfo { |
| mpidr: MPIDR32, |
| lowest_affinity_level: 2, |
| }, |
| FunctionId::AffinityInfo32 |
| ); |
| |
| validate_function!( |
| [0xc400_0004, MPIDR64_VALUE, 2, 0], |
| Function::AffinityInfo { |
| mpidr: MPIDR64, |
| lowest_affinity_level: 2, |
| }, |
| FunctionId::AffinityInfo64 |
| ); |
| |
| assert_eq!( |
| Err(Error::InvalidLowerAffinityLevel(3)), |
| Function::try_from([0x8400_0004, MPIDR32_VALUE.into(), 3, 0]) |
| ); |
| |
| assert_eq!( |
| Err(Error::InvalidLowerAffinityLevel(4)), |
| Function::try_from([0xc400_0004, MPIDR64_VALUE, 4, 0]) |
| ); |
| } |
| |
| #[test] |
| fn test_function_migrate() { |
| validate_function!( |
| [0x8400_0005, MPIDR32_VALUE.into(), 0, 0], |
| Function::Migrate { |
| target_affinity: MPIDR32, |
| }, |
| FunctionId::Migrate32 |
| ); |
| |
| validate_function!( |
| [0xc400_0005, MPIDR64_VALUE, 0, 0], |
| Function::Migrate { |
| target_affinity: MPIDR64, |
| }, |
| FunctionId::Migrate64 |
| ); |
| } |
| |
| #[test] |
| fn test_function_migrate_info_type() { |
| validate_function!( |
| [0x8400_0006, 0, 0, 0], |
| Function::MigrateInfoType, |
| FunctionId::MigrateInfoType |
| ); |
| } |
| |
| #[test] |
| fn test_function_migrate_info_up_cpu() { |
| validate_function!( |
| [0x8400_0007, 0, 0, 0], |
| Function::MigrateInfoUpCpu { is_32bit: true }, |
| FunctionId::MigrateInfoUpCpu32 |
| ); |
| |
| validate_function!( |
| [0xc400_0007, 0, 0, 0], |
| Function::MigrateInfoUpCpu { is_32bit: false }, |
| FunctionId::MigrateInfoUpCpu64 |
| ); |
| } |
| |
| #[test] |
| fn test_function_system_off() { |
| validate_function!( |
| [0x8400_0008, 0, 0, 0], |
| Function::SystemOff, |
| FunctionId::SystemOff |
| ); |
| } |
| |
| #[test] |
| fn test_function_system_off2() { |
| validate_function!( |
| [0x8400_0015, 0x0000_0001, 0xabcdef01, 0], |
| Function::SystemOff2 { |
| off_type: SystemOff2Type::HibernateOff, |
| cookie: Cookie::Cookie32(0xabcdef01), |
| }, |
| FunctionId::SystemOff232 |
| ); |
| |
| validate_function!( |
| [0xc400_0015, 0x0000_0001, 0xabcdef01_23456789, 0], |
| Function::SystemOff2 { |
| off_type: SystemOff2Type::HibernateOff, |
| cookie: Cookie::Cookie64(0xabcdef01_23456789), |
| }, |
| FunctionId::SystemOff264 |
| ); |
| } |
| |
| #[test] |
| fn test_function_system_reset() { |
| validate_function!( |
| [0x8400_0009, 0, 0, 0], |
| Function::SystemReset, |
| FunctionId::SystemReset |
| ); |
| } |
| |
| #[test] |
| fn test_function_system_reset2() { |
| validate_function!( |
| [0x8400_0012, 0, 0xabcdef01, 0], |
| Function::SystemReset2 { |
| reset_type: ResetType::Architectural(ArchitecturalResetType::SystemWarmReset), |
| cookie: Cookie::Cookie32(0xabcdef01), |
| }, |
| FunctionId::SystemReset232 |
| ); |
| |
| validate_function!( |
| [0xc400_0012, 0, 0xabcdef01_23456789, 0], |
| Function::SystemReset2 { |
| reset_type: ResetType::Architectural(ArchitecturalResetType::SystemWarmReset), |
| cookie: Cookie::Cookie64(0xabcdef01_23456789), |
| }, |
| FunctionId::SystemReset264 |
| ); |
| } |
| |
| #[test] |
| fn test_function_mem_protect() { |
| validate_function!( |
| [0x8400_0013, 0x0000_0001, 0, 0], |
| Function::MemProtect { enabled: true }, |
| FunctionId::MemProtect |
| ); |
| |
| validate_function!( |
| [0x8400_0013, 0x0000_0000, 0, 0], |
| Function::MemProtect { enabled: false }, |
| FunctionId::MemProtect |
| ); |
| } |
| |
| #[test] |
| fn test_function_mem_protect_check_range() { |
| validate_function!( |
| [0x8400_0014, 0xabcdef01, 0x23456789, 0], |
| Function::MemProtectCheckRange { |
| range: MemProtectRange::Range32 { |
| base: 0xabcdef01, |
| length: 0x23456789, |
| }, |
| }, |
| FunctionId::MemProtectCheckRange32 |
| ); |
| |
| validate_function!( |
| [0xc400_0014, 0xabcdef01_23456789, 0x23456789_abcdef01, 0], |
| Function::MemProtectCheckRange { |
| range: MemProtectRange::Range64 { |
| base: 0xabcdef01_23456789, |
| length: 0x23456789_abcdef01, |
| }, |
| }, |
| FunctionId::MemProtectCheckRange64 |
| ); |
| } |
| |
| #[test] |
| fn test_function_features() { |
| validate_function!( |
| [0x8400_000a, 0x8000_0000, 0, 0], |
| Function::Features { |
| psci_func_id: PsciFeature::SmcccVersion, |
| }, |
| FunctionId::PsciFeatures |
| ); |
| |
| validate_function!( |
| [0x8400_000a, 0x8400_0001, 0, 0], |
| Function::Features { |
| psci_func_id: PsciFeature::PsciFunction(FunctionId::CpuSuspend32), |
| }, |
| FunctionId::PsciFeatures |
| ); |
| } |
| |
| #[test] |
| fn test_function_cpu_freeze() { |
| validate_function!( |
| [0x8400_000b, 0, 0, 0], |
| Function::CpuFreeze, |
| FunctionId::CpuFreeze |
| ); |
| } |
| |
| #[test] |
| fn test_function_cpu_default_suspend() { |
| validate_function!( |
| [0x8400_000c, 0xabcdef01, 0x23456789, 0], |
| Function::CpuDefaultSuspend { |
| entry: EntryPoint::Entry32 { |
| entry_point_address: 0xabcdef01, |
| context_id: 0x23456789, |
| }, |
| }, |
| FunctionId::CpuDefaultSuspend32 |
| ); |
| |
| validate_function!( |
| [0xc400_000c, 0xabcdef01_23456789, 0x23456789_abcdef01, 0], |
| Function::CpuDefaultSuspend { |
| entry: EntryPoint::Entry64 { |
| entry_point_address: 0xabcdef01_23456789, |
| context_id: 0x23456789_abcdef01, |
| }, |
| }, |
| FunctionId::CpuDefaultSuspend64 |
| ); |
| } |
| |
| #[test] |
| fn test_function_node_hw_state() { |
| validate_function!( |
| [0x8400_000d, MPIDR32_VALUE.into(), 0xabcdef01, 0], |
| Function::NodeHwState { |
| target_cpu: MPIDR32, |
| power_level: 0xabcdef01, |
| }, |
| FunctionId::NodeHwState32 |
| ); |
| |
| validate_function!( |
| [0xc400_000d, MPIDR64_VALUE, 0xabcdef01, 0], |
| Function::NodeHwState { |
| target_cpu: MPIDR64, |
| power_level: 0xabcdef01, |
| }, |
| FunctionId::NodeHwState64 |
| ); |
| } |
| |
| #[test] |
| fn test_function_system_suspend() { |
| validate_function!( |
| [0x8400_000e, 0xabcdef01, 0x23456789, 0], |
| Function::SystemSuspend { |
| entry: EntryPoint::Entry32 { |
| entry_point_address: 0xabcdef01, |
| context_id: 0x23456789, |
| }, |
| }, |
| FunctionId::SystemSuspend32 |
| ); |
| |
| validate_function!( |
| [0xc400_000e, 0xabcdef01_23456789, 0x23456789_abcdef01, 0], |
| Function::SystemSuspend { |
| entry: EntryPoint::Entry64 { |
| entry_point_address: 0xabcdef01_23456789, |
| context_id: 0x23456789_abcdef01, |
| }, |
| }, |
| FunctionId::SystemSuspend64 |
| ); |
| } |
| |
| #[test] |
| fn test_function_set_suspend_mode() { |
| validate_function!( |
| [0x8400_000f, 0x0000_0001, 0, 0], |
| Function::SetSuspendMode { |
| mode: SuspendMode::OsInitiated, |
| }, |
| FunctionId::PsciSetSuspendMode |
| ); |
| } |
| |
| #[test] |
| fn test_function_stat_residency() { |
| validate_function!( |
| [ |
| 0x8400_0010, |
| MPIDR32_VALUE.into(), |
| POWER_STATE_VALUE.into(), |
| 0, |
| ], |
| Function::StatResidency { |
| target_cpu: MPIDR32, |
| power_state: POWER_STATE, |
| }, |
| FunctionId::PsciStatResidency32 |
| ); |
| |
| validate_function!( |
| [0xc400_0010, MPIDR64_VALUE, POWER_STATE_VALUE.into(), 0], |
| Function::StatResidency { |
| target_cpu: MPIDR64, |
| power_state: POWER_STATE, |
| }, |
| FunctionId::PsciStatResidency64 |
| ); |
| } |
| |
| #[test] |
| fn test_function_stat_count() { |
| validate_function!( |
| [ |
| 0x8400_0011, |
| MPIDR32_VALUE.into(), |
| POWER_STATE_VALUE.into(), |
| 0, |
| ], |
| Function::StatCount { |
| target_cpu: MPIDR32, |
| power_state: POWER_STATE, |
| }, |
| FunctionId::PsciStatCount32 |
| ); |
| |
| validate_function!( |
| [0xc400_0011, MPIDR64_VALUE, POWER_STATE_VALUE.into(), 0], |
| Function::StatCount { |
| target_cpu: MPIDR64, |
| power_state: POWER_STATE, |
| }, |
| FunctionId::PsciStatCount64 |
| ); |
| } |
| } |