diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs
index b79673a8c..210c711b5 100644
--- a/kernel/src/syscall.rs
+++ b/kernel/src/syscall.rs
@@ -203,7 +203,7 @@ pub fn handle(call: SysCall) -> xous::Result {
                 mm.unmap_page(page as *mut usize)
                     .expect("unable to unmap page");
             }
-            xous::Result::ReturnResult
+            xous::Result::Ok
         }
         SysCall::SwitchTo(pid, context) => {
             if context as usize != 0 {
@@ -216,7 +216,7 @@ pub fn handle(call: SysCall) -> xous::Result {
         }
         SysCall::ClaimInterrupt(no, callback, arg) => {
             interrupt_claim(no, pid as definitions::PID, callback, arg)
-                .map(|_| xous::Result::ReturnResult)
+                .map(|_| xous::Result::Ok)
                 .unwrap_or_else(|e| xous::Result::Error(e))
         }
         SysCall::Yield => {
diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs
index b0dbb11e2..58928a220 100644
--- a/xous-rs/src/syscall.rs
+++ b/xous-rs/src/syscall.rs
@@ -413,7 +413,7 @@ pub struct MemoryRange {
 #[repr(C)]
 #[derive(Debug, PartialEq)]
 pub enum Result {
-    ReturnResult,
+    Ok,
     Error(Error),
     MemoryAddress(*mut u8),
     MemoryRange(MemoryRange),
@@ -463,7 +463,7 @@ pub fn map_memory(
     virt: Option<MemoryAddress>,
     size: usize,
     flags: MemoryFlags,
-) -> core::result::Result<crate::MemoryRange, crate::Error> {
+) -> core::result::Result<MemoryRange, Error> {
     let result = rsyscall(SysCall::MapMemory(
         phys.map(|x| x.get()).unwrap_or(0) as *mut usize,
         virt.map(|x| x.get()).unwrap_or(0) as *mut usize,
@@ -473,7 +473,24 @@ pub fn map_memory(
     if let Result::MemoryRange(range) = result {
         return Ok(range);
     }
-    Err(crate::Error::InternalError)
+    Err(Error::InternalError)
+}
+
+/// Claim the given interrupt for this process.
+pub fn claim_interrupt(
+    irq_no: usize,
+    callback: fn(irq_no: usize, arg: *mut usize),
+    arg: *mut usize,
+) -> core::result::Result<(), Error> {
+    let result = rsyscall(SysCall::ClaimInterrupt(
+        irq_no,
+        callback as *mut usize,
+        arg as *mut usize,
+    ))?;
+    if let Result::Ok = result {
+        return Ok(());
+    }
+    Err(Error::InternalError)
 }
 
 pub fn rsyscall(call: SysCall) -> SyscallResult {