diff --git a/src/page_pool.rs b/src/page_pool.rs
index c2707c7..d767caf 100644
--- a/src/page_pool.rs
+++ b/src/page_pool.rs
@@ -3,14 +3,14 @@
 
 //! Region pool implementation for allocating pages
 
-use core::slice;
-
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use spin::Mutex;
 
+use crate::address::VirtualAddress;
+use crate::KernelAddressTranslator;
+
 use super::address::PhysicalAddress;
-use super::kernel_space::KernelSpace;
 use super::region_pool::{Region, RegionPool, RegionPoolError};
 
 /// Single 4kB page definition
@@ -48,17 +48,22 @@
     }
 
     /// Copy data to pages
-    pub fn copy_data_to_page(&mut self, data: &[u8]) {
+    pub fn copy_data_to_page<K: KernelAddressTranslator>(&mut self, data: &[u8]) {
         assert!(data.len() <= self.length);
 
-        let page_contents = unsafe { slice::from_raw_parts_mut(self.pa as *mut u8, data.len()) };
+        let page_contents = unsafe {
+            core::slice::from_raw_parts_mut(
+                K::pa_to_kernel(PhysicalAddress(self.pa)).0 as *mut u8,
+                data.len(),
+            )
+        };
         page_contents.clone_from_slice(data);
     }
 
     /// Zero init pages
-    pub fn zero_init(&mut self) {
+    pub fn zero_init<K: KernelAddressTranslator>(&mut self) {
         unsafe {
-            self.get_as_mut_slice::<u8>().fill(0);
+            self.get_as_mut_slice::<K, u8>().fill(0);
         }
     }
 
@@ -72,11 +77,11 @@
     /// # Safety
     /// The returned slice is created from its address and length which is stored in the
     /// object. The caller has to ensure that no other references are being used of the pages.
-    pub unsafe fn get_as_slice<T>(&self) -> &[T] {
+    pub unsafe fn get_as_slice<K: KernelAddressTranslator, T>(&self) -> &[T] {
         assert!((core::mem::align_of::<T>() - 1) & self.pa == 0);
 
         core::slice::from_raw_parts(
-            KernelSpace::pa_to_kernel(self.pa as u64) as *const T,
+            K::pa_to_kernel(PhysicalAddress(self.pa)).0 as *const T,
             self.length / core::mem::size_of::<T>(),
         )
     }
@@ -86,11 +91,11 @@
     /// # Safety
     /// The returned slice is created from its address and length which is stored in the
     /// object. The caller has to ensure that no other references are being used of the pages.
-    pub unsafe fn get_as_mut_slice<T>(&mut self) -> &mut [T] {
+    pub unsafe fn get_as_mut_slice<K: KernelAddressTranslator, T>(&mut self) -> &mut [T] {
         assert!((core::mem::align_of::<T>() - 1) & self.pa == 0);
 
         core::slice::from_raw_parts_mut(
-            KernelSpace::pa_to_kernel(self.pa as u64) as *mut T,
+            K::pa_to_kernel(PhysicalAddress(self.pa)).0 as *mut T,
             self.length / core::mem::size_of::<T>(),
         )
     }
@@ -99,9 +104,9 @@
     ///
     /// # Safety
     ///  The caller has to ensure that the passed slice is a valid page range.
-    pub unsafe fn from_slice<T>(s: &mut [T]) -> Pages {
+    pub unsafe fn from_slice<K: KernelAddressTranslator, T>(s: &mut [T]) -> Pages {
         Pages {
-            pa: KernelSpace::kernel_to_pa(s.as_ptr() as u64) as usize,
+            pa: K::kernel_to_pa(VirtualAddress(s.as_ptr() as usize)).0,
             length: core::mem::size_of_val(s),
             used: true,
         }
@@ -204,8 +209,13 @@
 
 impl PagePool {
     /// Create new page pool
-    pub fn new<const AREA_SIZE: usize>(page_pool_area: &'static PagePoolArea<AREA_SIZE>) -> Self {
-        let pa = KernelSpace::kernel_to_pa(&page_pool_area.area[0] as *const u8 as u64) as usize;
+    pub fn new<K: KernelAddressTranslator, const AREA_SIZE: usize>(
+        page_pool_area: &'static PagePoolArea<AREA_SIZE>,
+    ) -> Self {
+        let pa = K::kernel_to_pa(VirtualAddress(
+            &page_pool_area.area[0] as *const u8 as usize,
+        ))
+        .0;
         let length = page_pool_area.area.len();
 
         let mut region_pool = RegionPool::new();
@@ -240,6 +250,18 @@
 mod tests {
     use super::*;
 
+    struct DummyKernelAddressTranslator {}
+
+    impl KernelAddressTranslator for DummyKernelAddressTranslator {
+        fn kernel_to_pa(va: VirtualAddress) -> PhysicalAddress {
+            va.identity_pa()
+        }
+
+        fn pa_to_kernel(pa: PhysicalAddress) -> VirtualAddress {
+            pa.identity_va()
+        }
+    }
+
     #[test]
     fn test_pages() {
         let area = [0x5au8; 4096];
@@ -253,19 +275,19 @@
         assert_eq!(area.len(), pages.length());
         assert!(pages.used());
 
-        pages.copy_data_to_page(&[0, 1, 2, 3, 4, 5, 6, 7]);
+        pages.copy_data_to_page::<DummyKernelAddressTranslator>(&[0, 1, 2, 3, 4, 5, 6, 7]);
         assert_eq!([0, 1, 2, 3, 4, 5, 6, 7], area[0..8]);
 
-        pages.zero_init();
+        pages.zero_init::<DummyKernelAddressTranslator>();
         assert_eq!([0, 0, 0, 0, 0, 0, 0, 0], area[0..8]);
 
-        let s = unsafe { pages.get_as_mut_slice() };
+        let s = unsafe { pages.get_as_mut_slice::<DummyKernelAddressTranslator, u8>() };
         for (i, e) in s.iter_mut().enumerate().take(8) {
             *e = i as u8;
         }
         assert_eq!([0, 1, 2, 3, 4, 5, 6, 7], area[0..8]);
 
-        let from_slice = unsafe { Pages::from_slice(s) };
+        let from_slice = unsafe { Pages::from_slice::<DummyKernelAddressTranslator, u8>(s) };
         assert_eq!(area.as_ptr() as usize, from_slice.pa);
         assert_eq!(area.len(), from_slice.length);
         assert!(from_slice.used);