diff --git a/src/lib.rs b/src/lib.rs
index 7fc5839..884f8e0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,9 +9,9 @@
 
 use core::arch::asm;
 use core::iter::zip;
-use core::ops::Range;
 use core::{fmt, panic};
 
+use address::{PhysicalAddress, VirtualAddressRange, VirtualAddress};
 use alloc::boxed::Box;
 use alloc::format;
 use alloc::string::{String, ToString};
@@ -29,6 +29,7 @@
 use self::region::{PhysicalRegion, VirtualRegion};
 use self::region_pool::{Region, RegionPool, RegionPoolError};
 
+pub mod address;
 mod descriptor;
 pub mod kernel_space;
 pub mod page_pool;
@@ -126,13 +127,13 @@
 
 #[derive(PartialEq)]
 struct Block {
-    pa: usize,
-    va: usize,
+    pa: PhysicalAddress,
+    va: VirtualAddress,
     granule: usize,
 }
 
 impl Block {
-    fn new(pa: usize, va: usize, granule: usize) -> Self {
+    fn new(pa: PhysicalAddress, va: VirtualAddress, granule: usize) -> Self {
         assert!(Xlat::GRANULE_SIZES.contains(&granule));
         Self { pa, va, granule }
     }
@@ -141,8 +142,8 @@
 impl fmt::Debug for Block {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Block")
-            .field("pa", &format_args!("{:#010x}", self.pa))
-            .field("va", &format_args!("{:#010x}", self.va))
+            .field("pa", &format_args!("{:#010x}", self.pa.0))
+            .field("va", &format_args!("{:#010x}", self.va.0))
             .field("granule", &format_args!("{:#010x}", self.granule))
             .finish()
     }
@@ -189,10 +190,10 @@
 impl Xlat {
     pub const GRANULE_SIZES: [usize; 4] = [0, 0x4000_0000, 0x0020_0000, 0x0000_1000];
 
-    pub fn new(page_pool: PagePool, va_range: Range<usize>) -> Self {
+    pub fn new(page_pool: PagePool, va_range: VirtualAddressRange) -> Self {
         let mut regions = RegionPool::new();
         regions
-            .add(VirtualRegion::new(va_range.start, va_range.len()))
+            .add(VirtualRegion::new(va_range.start, va_range.len().unwrap()))
             .unwrap();
         Self {
             base_table: Box::new(BaseTable::new()),
@@ -211,10 +212,10 @@
     /// * Virtual address of the mapped memory
     pub fn allocate_initalized_range(
         &mut self,
-        va: Option<usize>,
+        va: Option<VirtualAddress>,
         data: &[u8],
         access_rights: MemoryAccessRights,
-    ) -> Result<usize, XlatError> {
+    ) -> Result<VirtualAddress, XlatError> {
         let mut pages = self.page_pool.allocate_pages(data.len()).map_err(|e| {
             XlatError::AllocationError(format!(
                 "Cannot allocate pages for {} bytes ({:?})",
@@ -247,10 +248,10 @@
     /// * Virtual address of the mapped memory
     pub fn allocate_zero_init_range(
         &mut self,
-        va: Option<usize>,
+        va: Option<VirtualAddress>,
         length: usize,
         access_rights: MemoryAccessRights,
-    ) -> Result<usize, XlatError> {
+    ) -> Result<VirtualAddress, XlatError> {
         let mut pages = self.page_pool.allocate_pages(length).map_err(|e| {
             XlatError::AllocationError(format!("Cannot allocate pages for {length} bytes ({e:?})"))
         })?;
@@ -280,11 +281,11 @@
     /// * Virtual address of the mapped memory
     pub fn map_physical_address_range(
         &mut self,
-        va: Option<usize>,
-        pa: usize,
+        va: Option<VirtualAddress>,
+        pa: PhysicalAddress,
         length: usize,
         access_rights: MemoryAccessRights,
-    ) -> Result<usize, XlatError> {
+    ) -> Result<VirtualAddress, XlatError> {
         let resource = PhysicalRegion::PhysicalAddress(pa);
         let region = if let Some(required_va) = va {
             self.regions.acquire(required_va, length, resource)
@@ -302,7 +303,7 @@
     /// * length: Length of the memory area in bytes
     pub fn unmap_virtual_address_range(
         &mut self,
-        va: usize,
+        va: VirtualAddress,
         length: usize,
     ) -> Result<(), XlatError> {
         let pa = self.get_pa_by_va(va, length)?;
@@ -323,7 +324,11 @@
     /// * length: Length of the memory area in bytes
     /// # Return value
     /// * Physical address of the mapped memory
-    pub fn get_pa_by_va(&self, va: usize, length: usize) -> Result<usize, XlatError> {
+    pub fn get_pa_by_va(
+        &self,
+        va: VirtualAddress,
+        length: usize,
+    ) -> Result<PhysicalAddress, XlatError> {
         let containing_region = self
             .find_containing_region(va, length)
             .ok_or(XlatError::NotFound)?;
@@ -342,7 +347,7 @@
     /// * access_rights: New memory access rights of the area
     pub fn set_access_rights(
         &mut self,
-        va: usize,
+        va: VirtualAddress,
         length: usize,
         access_rights: MemoryAccessRights,
     ) -> Result<(), XlatError> {
@@ -415,7 +420,7 @@
                     "{} {:#010x} Block -> {:#010x}",
                     level_prefix,
                     va,
-                    descriptor.get_block_output_address(level)
+                    descriptor.get_block_output_address(level).0
                 ),
                 DescriptorType::Table => {
                     let next_level_table = unsafe { descriptor.get_next_level_table(level) };
@@ -442,7 +447,7 @@
         &mut self,
         region: VirtualRegion,
         attributes: Attributes,
-    ) -> Result<usize, XlatError> {
+    ) -> Result<VirtualAddress, XlatError> {
         let blocks = Self::split_region_to_blocks(region.get_pa(), region.base(), region.length())?;
         for block in blocks {
             self.map_block(block, attributes.clone());
@@ -469,7 +474,7 @@
     /// * region: Virtual address to look for
     /// # Return value
     /// * Reference to virtual region if found
-    fn find_containing_region(&self, va: usize, length: usize) -> Option<&VirtualRegion> {
+    fn find_containing_region(&self, va: VirtualAddress, length: usize) -> Option<&VirtualRegion> {
         self.regions.find_containing_region(va, length).ok()
     }
 
@@ -481,8 +486,8 @@
     /// # Return value
     /// * Vector of granule sized blocks
     fn split_region_to_blocks(
-        mut pa: usize,
-        mut va: usize,
+        mut pa: PhysicalAddress,
+        mut va: VirtualAddress,
         mut length: usize,
     ) -> Result<Vec<Block>, XlatError> {
         let min_granule_mask = Self::GRANULE_SIZES.last().unwrap() - 1;
@@ -493,12 +498,10 @@
             ));
         }
 
-        if pa & min_granule_mask != 0
-            || va & min_granule_mask != 0
-            || length & min_granule_mask != 0
-        {
+        if (pa.0 | va.0 | length) & min_granule_mask != 0 {
             return Err(XlatError::InvalidParameterError(format!(
-                "Addresses and length must be aligned {pa:#010x} {va:#010x} {length:#x}"
+                "Addresses and length must be aligned {:#08x} {:#08x} {:#x}",
+                pa.0, va.0, length
             )));
         }
 
@@ -506,10 +509,10 @@
 
         while length > 0 {
             for granule in &Self::GRANULE_SIZES {
-                if (pa | va) & (*granule - 1) == 0 && length >= *granule {
+                if (pa.0 | va.0) & (*granule - 1) == 0 && length >= *granule {
                     pages.push(Block::new(pa, va, *granule));
-                    pa += *granule;
-                    va = va.checked_add(*granule).ok_or(XlatError::Overflow)?;
+                    pa = pa.add_offset(*granule).ok_or(XlatError::Overflow)?;
+                    va = va.add_offset(*granule).ok_or(XlatError::Overflow)?;
 
                     length -= *granule;
                     break;
@@ -548,15 +551,15 @@
     /// * page_pool: Page pool where the function can allocate pages for the translation tables
     fn set_block_descriptor_recursively(
         attributes: Attributes,
-        pa: usize,
-        va: usize,
+        pa: PhysicalAddress,
+        va: VirtualAddress,
         granule: usize,
         level: usize,
         table: &mut [Descriptor],
         page_pool: &PagePool,
     ) {
         // Get descriptor of the current level
-        let descriptor = &mut table[va / Self::GRANULE_SIZES[level]];
+        let descriptor = &mut table[va.get_level_index(level)];
 
         // We reached the required granule level
         if Self::GRANULE_SIZES[level] == granule {
@@ -575,7 +578,7 @@
                 Self::set_block_descriptor_recursively(
                     attributes,
                     pa,
-                    va & (Self::GRANULE_SIZES[level] - 1),
+                    va.mask_for_level(level),
                     granule,
                     level + 1,
                     unsafe { descriptor.get_next_level_table_mut(level) },
@@ -584,7 +587,7 @@
             }
             DescriptorType::Block => {
                 // Saving current descriptor details
-                let current_va = va & !(Self::GRANULE_SIZES[level] - 1);
+                let current_va = va.mask_for_level(level);
                 let current_pa = descriptor.get_block_output_address(level);
                 let current_attributes = descriptor.get_block_attributes(level);
 
@@ -596,14 +599,17 @@
                 }
 
                 // Explode block descriptor to table entries
-                for exploded_va in (current_va..(current_va + Self::GRANULE_SIZES[level]))
-                    .step_by(Self::GRANULE_SIZES[level + 1])
+                for exploded_va in VirtualAddressRange::new(
+                    current_va,
+                    current_va.add_offset(Self::GRANULE_SIZES[level]).unwrap(),
+                )
+                .step_by(Self::GRANULE_SIZES[level + 1])
                 {
-                    let offset = exploded_va - current_va;
+                    let offset = exploded_va.diff(current_va).unwrap();
                     Self::set_block_descriptor_recursively(
                         current_attributes.clone(),
-                        current_pa + offset,
-                        exploded_va & (Self::GRANULE_SIZES[level] - 1),
+                        current_pa.add_offset(offset).unwrap(),
+                        exploded_va.mask_for_level(level),
                         Self::GRANULE_SIZES[level + 1],
                         level + 1,
                         unsafe { descriptor.get_next_level_table_mut(level) },
@@ -619,7 +625,7 @@
             DescriptorType::Table => Self::set_block_descriptor_recursively(
                 attributes,
                 pa,
-                va & (Self::GRANULE_SIZES[level] - 1),
+                va.mask_for_level(level),
                 granule,
                 level + 1,
                 unsafe { descriptor.get_next_level_table_mut(level) },
@@ -650,14 +656,14 @@
     /// * table: Translation table on the given level
     /// * page_pool: Page pool where the function can release the pages of empty tables
     fn remove_block_descriptor_recursively(
-        va: usize,
+        va: VirtualAddress,
         granule: usize,
         level: usize,
         table: &mut [Descriptor],
         page_pool: &PagePool,
     ) {
         // Get descriptor of the current level
-        let descriptor = &mut table[va / Self::GRANULE_SIZES[level]];
+        let descriptor = &mut table[va.get_level_index(level)];
 
         // We reached the required granule level
         if Self::GRANULE_SIZES[level] == granule {
@@ -676,7 +682,7 @@
             DescriptorType::Table => {
                 let next_level_table = unsafe { descriptor.get_next_level_table_mut(level) };
                 Self::remove_block_descriptor_recursively(
-                    va & (Self::GRANULE_SIZES[level] - 1),
+                    va.mask_for_level(level),
                     granule,
                     level + 1,
                     next_level_table,
@@ -695,18 +701,18 @@
         }
     }
 
-    fn get_descriptor(&mut self, va: usize, granule: usize) -> &mut Descriptor {
+    fn get_descriptor(&mut self, va: VirtualAddress, granule: usize) -> &mut Descriptor {
         Self::walk_descriptors(va, granule, 0, &mut self.base_table.descriptors)
     }
 
     fn walk_descriptors(
-        va: usize,
+        va: VirtualAddress,
         granule: usize,
         level: usize,
         table: &mut [Descriptor],
     ) -> &mut Descriptor {
         // Get descriptor of the current level
-        let descriptor = &mut table[va / Self::GRANULE_SIZES[level]];
+        let descriptor = &mut table[va.get_level_index(level)];
 
         if Self::GRANULE_SIZES[level] == granule {
             return descriptor;
@@ -720,12 +726,11 @@
             DescriptorType::Block => {
                 panic!("Cannot split existing block descriptor to table");
             }
-            DescriptorType::Table => Self::walk_descriptors(
-                va & (Self::GRANULE_SIZES[level] - 1),
-                granule,
-                level + 1,
-                unsafe { descriptor.get_next_level_table_mut(level) },
-            ),
+            DescriptorType::Table => {
+                Self::walk_descriptors(va.mask_for_level(level), granule, level + 1, unsafe {
+                    descriptor.get_next_level_table_mut(level)
+                })
+            }
         }
     }
 }
@@ -734,24 +739,38 @@
 mod tests {
     use super::*;
 
+    fn make_block(pa: usize, va: usize, granule: usize) -> Block {
+        Block::new(PhysicalAddress(pa), VirtualAddress(va), granule)
+    }
+
     #[test]
     fn test_split_to_pages() {
-        let pages = Xlat::split_region_to_blocks(0x3fff_c000, 0x3fff_c000, 0x4020_5000).unwrap();
-        assert_eq!(Block::new(0x3fff_c000, 0x3fff_c000, 0x1000), pages[0]);
-        assert_eq!(Block::new(0x3fff_d000, 0x3fff_d000, 0x1000), pages[1]);
-        assert_eq!(Block::new(0x3fff_e000, 0x3fff_e000, 0x1000), pages[2]);
-        assert_eq!(Block::new(0x3fff_f000, 0x3fff_f000, 0x1000), pages[3]);
-        assert_eq!(Block::new(0x4000_0000, 0x4000_0000, 0x4000_0000), pages[4]);
-        assert_eq!(Block::new(0x8000_0000, 0x8000_0000, 0x0020_0000), pages[5]);
-        assert_eq!(Block::new(0x8020_0000, 0x8020_0000, 0x1000), pages[6]);
+        let pages = Xlat::split_region_to_blocks(
+            PhysicalAddress(0x3fff_c000),
+            VirtualAddress(0x3fff_c000),
+            0x4020_5000,
+        )
+        .unwrap();
+        assert_eq!(make_block(0x3fff_c000, 0x3fff_c000, 0x1000), pages[0]);
+        assert_eq!(make_block(0x3fff_d000, 0x3fff_d000, 0x1000), pages[1]);
+        assert_eq!(make_block(0x3fff_e000, 0x3fff_e000, 0x1000), pages[2]);
+        assert_eq!(make_block(0x3fff_f000, 0x3fff_f000, 0x1000), pages[3]);
+        assert_eq!(make_block(0x4000_0000, 0x4000_0000, 0x4000_0000), pages[4]);
+        assert_eq!(make_block(0x8000_0000, 0x8000_0000, 0x0020_0000), pages[5]);
+        assert_eq!(make_block(0x8020_0000, 0x8020_0000, 0x1000), pages[6]);
     }
 
     #[test]
     fn test_split_to_pages_unaligned() {
-        let pages = Xlat::split_region_to_blocks(0x3fff_c000, 0x3f20_0000, 0x200000).unwrap();
+        let pages = Xlat::split_region_to_blocks(
+            PhysicalAddress(0x3fff_c000),
+            VirtualAddress(0x3f20_0000),
+            0x200000,
+        )
+        .unwrap();
         for (i, block) in pages.iter().enumerate().take(512) {
             assert_eq!(
-                Block::new(0x3fff_c000 + (i << 12), 0x3f20_0000 + (i << 12), 0x1000),
+                make_block(0x3fff_c000 + (i << 12), 0x3f20_0000 + (i << 12), 0x1000),
                 *block
             );
         }