diff --git a/src/lib.rs b/src/lib.rs
index 1408d51..fb30191 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -60,6 +60,8 @@
     InvalidVersionForFunctionId(Version, FuncId),
     #[error("Invalid character count {0}")]
     InvalidCharacterCount(u8),
+    #[error("Memory management error")]
+    MemoryManagementError(#[from] memory_management::Error),
 }
 
 impl From<Error> for FfaError {
@@ -81,7 +83,8 @@
             | Error::InvalidSuccessArgsVariant
             | Error::InvalidNotificationCount
             | Error::InvalidPartitionInfoGetRegsResponse
-            | Error::InvalidCharacterCount(_) => Self::InvalidParameters,
+            | Error::InvalidCharacterCount(_)
+            | Error::MemoryManagementError(_) => Self::InvalidParameters,
         }
     }
 }
@@ -1278,7 +1281,7 @@
     MemPermSet {
         addr: MemAddr,
         page_cnt: u32,
-        mem_perm: u32,
+        mem_perm: memory_management::MemPermissionsGetSet,
     },
     ConsoleLog {
         chars: ConsoleLogChars,
@@ -1800,12 +1803,12 @@
             FuncId::MemPermSet32 => Self::MemPermSet {
                 addr: MemAddr::Addr32(regs[1] as u32),
                 page_cnt: regs[2] as u32,
-                mem_perm: regs[3] as u32,
+                mem_perm: (regs[3] as u32).try_into()?,
             },
             FuncId::MemPermSet64 => Self::MemPermSet {
                 addr: MemAddr::Addr64(regs[1]),
                 page_cnt: regs[2] as u32,
-                mem_perm: regs[3] as u32,
+                mem_perm: (regs[3] as u32).try_into()?,
             },
             FuncId::ConsoleLog32 => {
                 let char_cnt = regs[1] as u8;
@@ -2272,7 +2275,7 @@
                     MemAddr::Addr64(addr) => addr,
                 };
                 a[2] = page_cnt.into();
-                a[3] = mem_perm.into();
+                a[3] = u32::from(mem_perm).into();
             }
             Interface::ConsoleLog { chars } => match chars {
                 ConsoleLogChars::Chars32(ConsoleLogChars32 {
diff --git a/src/memory_management.rs b/src/memory_management.rs
index 1302f82..a3b5ce7 100644
--- a/src/memory_management.rs
+++ b/src/memory_management.rs
@@ -26,7 +26,7 @@
 
 /// Rich error types returned by this module. Should be converted to [`crate::FfaError`] when used
 /// with the `FFA_ERROR` interface.
-#[derive(Debug, Error)]
+#[derive(Debug, Error, PartialEq, Eq)]
 pub enum Error {
     #[error("Invalid cacheability attribute {0}")]
     InvalidCacheability(u16),
@@ -50,6 +50,12 @@
     InvalidBufferSize,
     #[error("Malformed descriptor")]
     MalformedDescriptor,
+    #[error("Invalid get/set instruction access permission {0}")]
+    InvalidInstrAccessPermGetSet(u32),
+    #[error("Invalid get/set instruction data permission {0}")]
+    InvalidDataAccessPermGetSet(u32),
+    #[error("Invalid page count")]
+    InvalidPageCount,
 }
 
 impl From<Error> for crate::FfaError {
@@ -811,6 +817,112 @@
     }
 }
 
+/// Data access permission enum for `FFA_MEM_PERM_GET` and `FFA_MEM_PERM_SET` calls.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum DataAccessPermGetSet {
+    NoAccess = Self::NO_ACCESS << Self::SHIFT,
+    ReadWrite = Self::READ_WRITE << Self::SHIFT,
+    ReadOnly = Self::READ_ONLY << Self::SHIFT,
+}
+
+impl DataAccessPermGetSet {
+    const SHIFT: usize = 0;
+    const MASK: u32 = 0b11;
+    const NO_ACCESS: u32 = 0b00;
+    const READ_WRITE: u32 = 0b01;
+    const READ_ONLY: u32 = 0b11;
+}
+
+impl TryFrom<u32> for DataAccessPermGetSet {
+    type Error = Error;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match (value >> Self::SHIFT) & Self::MASK {
+            Self::NO_ACCESS => Ok(Self::NoAccess),
+            Self::READ_WRITE => Ok(Self::ReadWrite),
+            Self::READ_ONLY => Ok(Self::ReadOnly),
+            _ => Err(Error::InvalidDataAccessPermGetSet(value)),
+        }
+    }
+}
+
+/// Instructions access permission enum for `FFA_MEM_PERM_GET` and `FFA_MEM_PERM_SET` calls.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum InstructionAccessPermGetSet {
+    Executable = Self::EXECUTABLE << Self::SHIFT,
+    NonExecutable = Self::NON_EXECUTABLE << Self::SHIFT,
+}
+
+impl InstructionAccessPermGetSet {
+    const SHIFT: usize = 2;
+    const MASK: u32 = 0b1;
+    const EXECUTABLE: u32 = 0b0;
+    const NON_EXECUTABLE: u32 = 0b1;
+}
+
+impl TryFrom<u32> for InstructionAccessPermGetSet {
+    type Error = Error;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match (value >> Self::SHIFT) & Self::MASK {
+            Self::EXECUTABLE => Ok(Self::Executable),
+            Self::NON_EXECUTABLE => Ok(Self::NonExecutable),
+            _ => Err(Error::InvalidInstrAccessPermGetSet(value)),
+        }
+    }
+}
+
+/// Memory permission structure for `FFA_MEM_PERM_GET` and `FFA_MEM_PERM_SET` calls.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct MemPermissionsGetSet {
+    pub data_access: DataAccessPermGetSet,
+    pub instr_access: InstructionAccessPermGetSet,
+}
+
+impl TryFrom<u32> for MemPermissionsGetSet {
+    type Error = Error;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        Ok(Self {
+            data_access: value.try_into()?,
+            instr_access: value.try_into()?,
+        })
+    }
+}
+
+impl From<MemPermissionsGetSet> for u32 {
+    fn from(value: MemPermissionsGetSet) -> Self {
+        value.data_access as u32 | value.instr_access as u32
+    }
+}
+
+/// Success argument structure for `FFA_MEM_PERM_GET`.
+pub struct SuccessArgsMemPermGet {
+    pub perm: MemPermissionsGetSet,
+    pub page_cnt: u32,
+}
+
+impl From<SuccessArgsMemPermGet> for SuccessArgs {
+    fn from(value: SuccessArgsMemPermGet) -> Self {
+        assert_ne!(value.page_cnt, 0);
+        SuccessArgs::Args32([value.perm.into(), value.page_cnt - 1, 0, 0, 0, 0])
+    }
+}
+
+impl TryFrom<SuccessArgs> for SuccessArgsMemPermGet {
+    type Error = crate::Error;
+
+    fn try_from(value: SuccessArgs) -> Result<Self, Self::Error> {
+        let [perm, page_cnt, ..] = value.try_get_args32()?;
+        Ok(Self {
+            perm: perm.try_into()?,
+            page_cnt: page_cnt.checked_add(1).ok_or(Error::InvalidPageCount)?,
+        })
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;