diff --git a/src/descriptor.rs b/src/descriptor.rs
index 627799c..b5db7cc 100644
--- a/src/descriptor.rs
+++ b/src/descriptor.rs
@@ -8,7 +8,6 @@
 use core::cell::UnsafeCell;
 use core::ptr;
 
-use crate::kernel_space::KernelSpace;
 use crate::MemoryAttributesIndex;
 
 use super::address::PhysicalAddress;
@@ -294,19 +293,16 @@
     }
 
     /// Set table descriptor
-    ///
-    /// Safety: The caller has to ensure that the passed next level table has the same life as
-    /// the descriptor.
-    pub unsafe fn set_table_descriptor(
+    pub fn set_table_descriptor(
         &mut self,
         level: isize,
-        next_level_table: &mut [Descriptor],
+        next_level_table: PhysicalAddress,
         next_level_attributes: Option<NextLevelAttributes>,
     ) {
         assert!(level <= 2);
         assert!(self.get_descriptor_type(level) != DescriptorType::Table);
 
-        let table_addr = KernelSpace::kernel_to_pa(next_level_table.as_ptr() as u64);
+        let table_addr = next_level_table.0 as u64;
         assert_eq!(0, table_addr & !Self::TA_MASK);
 
         let mut raw_desc_value = Self::VALID_BIT | Self::TABLE_BIT | table_addr;
@@ -321,37 +317,11 @@
     }
 
     /// Get next level table
-    ///
-    /// Safety: The returned next level table is based on the address read from the descriptor.
-    /// The caller has to ensure that no other references are being used of the table.
-    pub unsafe fn get_next_level_table<const VA_BITS: usize>(
-        &self,
-        granule: TranslationGranule<VA_BITS>,
-        level: isize,
-    ) -> &[Descriptor] {
+    pub fn get_next_level_table(&self, level: isize) -> PhysicalAddress {
         assert!(level <= 2);
         assert_eq!(DescriptorType::Table, self.get_descriptor_type(level));
 
-        let table_address =
-            KernelSpace::pa_to_kernel(self.get() & Self::TA_MASK) as *const Descriptor;
-        core::slice::from_raw_parts(table_address, granule.entry_count_at_level(level + 1))
-    }
-
-    /// Get mutable next level table
-    ///
-    /// Safety: The returned next level table is based on the address read from the descriptor.
-    /// The caller has to ensure that no other references are being used of the table.
-    pub unsafe fn get_next_level_table_mut<const VA_BITS: usize>(
-        &mut self,
-        granule: TranslationGranule<VA_BITS>,
-        level: isize,
-    ) -> &mut [Descriptor] {
-        assert!(level <= 2);
-        assert_eq!(DescriptorType::Table, self.get_descriptor_type(level));
-
-        let table_address =
-            KernelSpace::pa_to_kernel(self.get() & Self::TA_MASK) as *mut Descriptor;
-        core::slice::from_raw_parts_mut(table_address, granule.entry_count_at_level(level + 1))
+        PhysicalAddress((self.get() & Self::TA_MASK) as usize)
     }
 
     /// Get next level attributes
@@ -363,21 +333,13 @@
     }
 
     /// Set table descriptor to invalid
-    ///
-    /// **Unsafe:** The returned descriptor reference must be released by the caller, i.e. release
-    /// to `PagePool`
-    pub unsafe fn set_table_descriptor_to_invalid<const VA_BITS: usize>(
-        &mut self,
-        granule: TranslationGranule<VA_BITS>,
-        level: isize,
-    ) -> &mut [Descriptor] {
+    pub fn set_table_descriptor_to_invalid(&mut self, level: isize) -> PhysicalAddress {
         assert!(level <= 2);
         assert_eq!(DescriptorType::Table, self.get_descriptor_type(level));
 
-        let table_address =
-            KernelSpace::pa_to_kernel(self.get() & Self::TA_MASK) as *mut Descriptor;
+        let pa = PhysicalAddress((self.get() & Self::TA_MASK) as usize);
         self.set(Self::INVALID_DESCRIPTOR_VALUE);
-        core::slice::from_raw_parts_mut(table_address, granule.entry_count_at_level(level + 1))
+        pa
     }
 
     /// Get raw descriptor value
@@ -691,94 +653,62 @@
     #[test]
     #[should_panic]
     fn test_descriptor_level3_to_table() {
-        let mut next_level_table = [Descriptor {
-            cell: UnsafeCell::new(0),
-        }];
         let mut descriptor = Descriptor {
             cell: UnsafeCell::new(0),
         };
 
-        unsafe {
-            descriptor.set_table_descriptor(3, &mut next_level_table, None);
-        }
+        descriptor.set_table_descriptor(3, PhysicalAddress(0), None);
     }
 
     #[test]
     fn test_descriptor_block_to_table() {
-        let next_level_table =
-            unsafe { core::slice::from_raw_parts_mut(0x1000 as *mut Descriptor, 512) };
+        let next_level_table = PhysicalAddress(0x1000);
         let mut descriptor = Descriptor {
             cell: UnsafeCell::new(1),
         };
 
-        unsafe {
-            descriptor.set_table_descriptor(0, next_level_table, None);
-        }
+        descriptor.set_table_descriptor(0, next_level_table, None);
         assert_eq!(0x1003, descriptor.get());
     }
 
     #[test]
     #[should_panic]
-    fn test_descriptor_table_invalid_count() {
-        let next_level_table =
-            unsafe { core::slice::from_raw_parts_mut(0x800 as *mut Descriptor, 511) };
-        let mut descriptor = Descriptor {
-            cell: UnsafeCell::new(0),
-        };
-
-        unsafe {
-            descriptor.set_table_descriptor(0, next_level_table, None);
-        }
-    }
-
-    #[test]
-    #[should_panic]
     fn test_descriptor_table_non_aligned() {
-        let next_level_table =
-            unsafe { core::slice::from_raw_parts_mut(0x800 as *mut Descriptor, 512) };
+        let next_level_table = PhysicalAddress(0x800);
         let mut descriptor = Descriptor {
             cell: UnsafeCell::new(0),
         };
 
-        unsafe {
-            descriptor.set_table_descriptor(0, next_level_table, None);
-        }
+        descriptor.set_table_descriptor(0, next_level_table, None);
     }
 
     #[test]
     fn test_descriptor_table() {
-        let next_level_table = unsafe {
-            core::slice::from_raw_parts_mut(0x0000_000c_ba98_7000 as *mut Descriptor, 512)
-        };
+        let next_level_table = PhysicalAddress(0x0000_000c_ba98_7000);
         let mut descriptor = Descriptor {
             cell: UnsafeCell::new(0),
         };
 
-        unsafe {
-            descriptor.set_table_descriptor(0, next_level_table, None);
-        }
+        descriptor.set_table_descriptor(0, next_level_table, None);
         assert_eq!(0x0000_000c_ba98_7003, descriptor.get());
     }
 
     #[test]
     fn test_descriptor_table_next_level_attr() {
         const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
-        let next_level_table =
-            unsafe { core::slice::from_raw_parts_mut(NEXT_LEVEL_ADDR as *mut Descriptor, 512) };
+        let next_level_table = PhysicalAddress(0x0000_000c_ba98_7000);
         let mut descriptor = Descriptor {
             cell: UnsafeCell::new(0),
         };
 
-        unsafe {
-            descriptor.set_table_descriptor(
-                0,
-                next_level_table,
-                Some(NextLevelAttributes {
-                    ns_table: true,
-                    ..Default::default()
-                }),
-            );
-        }
+        descriptor.set_table_descriptor(
+            0,
+            next_level_table,
+            Some(NextLevelAttributes {
+                ns_table: true,
+                ..Default::default()
+            }),
+        );
         assert_eq!(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003, descriptor.get());
     }
 
@@ -788,24 +718,7 @@
         let descriptor = Descriptor {
             cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
         };
-        assert_eq!(KernelSpace::pa_to_kernel(NEXT_LEVEL_ADDR), unsafe {
-            descriptor
-                .get_next_level_table::<36>(TranslationGranule::Granule4k, 0)
-                .as_ptr() as u64
-        });
-    }
-
-    #[test]
-    fn test_descriptor_table_get_next_level_table_mut() {
-        const NEXT_LEVEL_ADDR: u64 = 0x0000_000c_ba98_7000;
-        let mut descriptor = Descriptor {
-            cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
-        };
-        assert_eq!(KernelSpace::pa_to_kernel(NEXT_LEVEL_ADDR), unsafe {
-            descriptor
-                .get_next_level_table_mut::<36>(TranslationGranule::Granule4k, 0)
-                .as_ptr() as *mut Descriptor as u64
-        });
+        assert_eq!(NEXT_LEVEL_ADDR, descriptor.get_next_level_table(0).0 as u64);
     }
 
     #[test]
@@ -829,11 +742,10 @@
         let mut descriptor = Descriptor {
             cell: UnsafeCell::new(NEXT_LEVEL_ADDR | 0x8000_0000_0000_0003),
         };
-        assert_eq!(KernelSpace::pa_to_kernel(NEXT_LEVEL_ADDR), unsafe {
-            descriptor
-                .set_table_descriptor_to_invalid::<36>(TranslationGranule::Granule4k, 0)
-                .as_ptr() as *mut Descriptor as u64
-        });
+        assert_eq!(
+            NEXT_LEVEL_ADDR,
+            descriptor.set_table_descriptor_to_invalid(0).0 as u64
+        );
         assert_eq!(0, descriptor.get());
     }