struct intel_memory_region *mem = obj->mm.region;
 
                info->apertures->ranges[0].base = mem->io_start;
-               info->apertures->ranges[0].size = mem->total;
+               info->apertures->ranges[0].size = mem->io_size;
 
                /* Use fbdev's framebuffer from lmem for discrete */
                info->fix.smem_start =
 
 {
        return intel_memory_region_create(i915, 0,
                                          totalram_pages() << PAGE_SHIFT,
-                                         PAGE_SIZE, 0,
+                                         PAGE_SIZE, 0, 0,
                                          type, instance,
                                          &shmem_region_ops);
 }
 
 
        /* Exclude the reserved region from driver use */
        mem->region.end = reserved_base - 1;
+       mem->io_size = resource_size(&mem->region);
 
        /* It is possible for the reserved area to end before the end of stolen
         * memory, so just consider the start. */
 
        if (!io_mapping_init_wc(&mem->iomap,
                                mem->io_start,
-                               resource_size(&mem->region)))
+                               mem->io_size))
                return -EIO;
 
        /*
                                                I915_GTT_PAGE_SIZE_4K;
 
        mem = intel_memory_region_create(i915, lmem_base, lmem_size,
-                                        min_page_size, io_start,
+                                        min_page_size,
+                                        io_start, lmem_size,
                                         type, instance,
                                         &i915_region_stolen_lmem_ops);
        if (IS_ERR(mem))
        mem = intel_memory_region_create(i915,
                                         intel_graphics_stolen_res.start,
                                         resource_size(&intel_graphics_stolen_res),
-                                        PAGE_SIZE, 0, type, instance,
+                                        PAGE_SIZE, 0, 0, type, instance,
                                         &i915_region_stolen_smem_ops);
        if (IS_ERR(mem))
                return mem;
 
 
        mr = intel_memory_region_create(i915, 0,
                                        totalram_pages() << PAGE_SHIFT,
-                                       PAGE_SIZE, 0,
+                                       PAGE_SIZE, 0, 0,
                                        type, instance,
                                        &ttm_system_region_ops);
        if (IS_ERR(mr))
 
        int bit;
        int err = 0;
 
-       mem = mock_region_create(i915, 0, SZ_2G, I915_GTT_PAGE_SIZE_4K, 0);
+       mem = mock_region_create(i915, 0, SZ_2G, I915_GTT_PAGE_SIZE_4K, 0, 0);
        if (IS_ERR(mem)) {
                pr_err("%s failed to create memory region\n", __func__);
                return PTR_ERR(mem);
 
 
        if (!io_mapping_init_wc(&mem->iomap,
                                mem->io_start,
-                               resource_size(&mem->region)))
+                               mem->io_size))
                return -EIO;
 
        ret = intel_region_ttm_init(mem);
                                         lmem_size,
                                         min_page_size,
                                         io_start,
+                                        lmem_size,
                                         INTEL_MEMORY_LOCAL,
                                         0,
                                         &intel_region_lmem_ops);
        drm_dbg(&i915->drm, "Local memory: %pR\n", &mem->region);
        drm_dbg(&i915->drm, "Local memory IO start: %pa\n",
                &mem->io_start);
+       drm_info(&i915->drm, "Local memory IO size: %pa\n",
+                &mem->io_size);
        drm_info(&i915->drm, "Local memory available: %pa\n",
                 &lmem_size);
 
 
        resource_size_t last, page;
        int err;
 
-       if (resource_size(&mem->region) < PAGE_SIZE)
+       if (mem->io_size < PAGE_SIZE)
                return 0;
 
-       last = resource_size(&mem->region) - PAGE_SIZE;
+       last = mem->io_size - PAGE_SIZE;
 
        /*
         * Quick test to check read/write access to the iomap (backing store).
                           resource_size_t size,
                           resource_size_t min_page_size,
                           resource_size_t io_start,
+                          resource_size_t io_size,
                           u16 type,
                           u16 instance,
                           const struct intel_memory_region_ops *ops)
        mem->i915 = i915;
        mem->region = (struct resource)DEFINE_RES_MEM(start, size);
        mem->io_start = io_start;
+       mem->io_size = io_size;
        mem->min_page_size = min_page_size;
        mem->ops = ops;
        mem->total = size;
 
        struct resource region;
 
        resource_size_t io_start;
+       resource_size_t io_size;
        resource_size_t min_page_size;
        resource_size_t total;
        resource_size_t avail;
                           resource_size_t size,
                           resource_size_t min_page_size,
                           resource_size_t io_start,
+                          resource_size_t io_size,
                           u16 type,
                           u16 instance,
                           const struct intel_memory_region_ops *ops);
 
        if (!order)
                return 0;
 
-       mem = mock_region_create(i915, 0, SZ_2G, I915_GTT_PAGE_SIZE_4K, 0);
+       mem = mock_region_create(i915, 0, SZ_2G, I915_GTT_PAGE_SIZE_4K, 0, 0);
        if (IS_ERR(mem)) {
                pr_err("failed to create memory region\n");
                err = PTR_ERR(mem);
         */
 
        size = (SZ_4G - 1) & PAGE_MASK;
-       mem = mock_region_create(i915, 0, size, PAGE_SIZE, 0);
+       mem = mock_region_create(i915, 0, size, PAGE_SIZE, 0, 0);
        if (IS_ERR(mem))
                return PTR_ERR(mem);
 
         */
 
        size = SZ_8G;
-       mem = mock_region_create(i915, 0, size, PAGE_SIZE, 0);
+       mem = mock_region_create(i915, 0, size, PAGE_SIZE, 0, 0);
        if (IS_ERR(mem))
                return PTR_ERR(mem);
 
        if (!i915)
                return -ENOMEM;
 
-       mem = mock_region_create(i915, 0, SZ_2G, I915_GTT_PAGE_SIZE_4K, 0);
+       mem = mock_region_create(i915, 0, SZ_2G, I915_GTT_PAGE_SIZE_4K, 0, 0);
        if (IS_ERR(mem)) {
                pr_err("failed to create memory region\n");
                err = PTR_ERR(mem);
 
                   resource_size_t start,
                   resource_size_t size,
                   resource_size_t min_page_size,
-                  resource_size_t io_start)
+                  resource_size_t io_start,
+                  resource_size_t io_size)
 {
        int instance = ida_alloc_max(&i915->selftest.mock_region_instances,
                                     TTM_NUM_MEM_TYPES - TTM_PL_PRIV - 1,
                return ERR_PTR(instance);
 
        return intel_memory_region_create(i915, start, size, min_page_size,
-                                         io_start, INTEL_MEMORY_MOCK, instance,
+                                         io_start, io_size,
+                                         INTEL_MEMORY_MOCK, instance,
                                          &mock_region_ops);
 }
 
                   resource_size_t start,
                   resource_size_t size,
                   resource_size_t min_page_size,
-                  resource_size_t io_start);
+                  resource_size_t io_start,
+                  resource_size_t io_size);
 
 #endif /* !__MOCK_REGION_H */