1 files changed, 30 insertions, 30 deletions

diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
index 5ef8ae25..394d1d25 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
@@ -270,11 +270,13 @@ struct vm_gk20a {
 
         struct gk20a_mm_entry pdb;
 
-        struct nvgpu_allocator vma[gmmu_nr_page_sizes];
-
         /* If necessary, split fixed from non-fixed. */
         struct nvgpu_allocator fixed;
 
+        struct nvgpu_allocator *vma[gmmu_nr_page_sizes];
+        struct nvgpu_allocator kernel;
+        struct nvgpu_allocator user;
+
         struct rb_root mapped_buffers;
 
         struct list_head reserved_va_list;
@@ -425,7 +427,7 @@ static inline int bar1_aperture_size_mb_gk20a(void)
         return 16; /* 16MB is more than enough atm. */
 }
 
-/*The maximum GPU VA range supported */
+/* The maximum GPU VA range supported */
 #define NV_GMMU_VA_RANGE          38
 
 /* The default userspace-visible GPU VA size */
@@ -434,43 +436,39 @@ static inline int bar1_aperture_size_mb_gk20a(void)
 /* The default kernel-reserved GPU VA size */
 #define NV_MM_DEFAULT_KERNEL_SIZE (1ULL << 32)
 
-/*
- * The bottom 16GB of the space are used for small pages, the remaining high
- * memory is for large pages.
- */
-static inline u64 __nv_gmmu_va_small_page_limit(void)
-{
-        return ((u64)SZ_1G * 16);
-}
-
-static inline int __nv_gmmu_va_is_big_page_region(struct vm_gk20a *vm, u64 addr)
-{
-        struct nvgpu_allocator *a = &vm->vma[gmmu_page_size_big];
-
-        if (!vm->big_pages)
-                return 0;
-
-        return addr >= nvgpu_alloc_base(a) &&
-                addr < nvgpu_alloc_base(a) + nvgpu_alloc_length(a);
-}
+enum gmmu_pgsz_gk20a __get_pte_size_fixed_map(struct vm_gk20a *vm,
+                                              u64 base, u64 size);
 
 /*
  * This determines the PTE size for a given alloc. Used by both the GVA space
  * allocator and the mm core code so that agreement can be reached on how to
  * map allocations.
+ *
+ * The page size of a buffer is this:
+ *
+ *   o  If the VM doesn't support large pages then obviously small pages
+ *      must be used.
+ *   o  If the base address is non-zero (fixed address map):
+ *      - Attempt to find a reserved memory area and use the page size
+ *        based on that.
+ *      - If no reserved page size is available, default to small pages.
+ *   o  If the base is zero:
+ *      - If the size is greater than or equal to the big page size, use big
+ *        pages.
+ *      - Otherwise use small pages.
  */
 static inline enum gmmu_pgsz_gk20a __get_pte_size(struct vm_gk20a *vm,
                                                   u64 base, u64 size)
 {
-        /*
-         * Currently userspace is not ready for a true unified address space.
-         * As a result, even though the allocator supports mixed address spaces
-         * the address spaces must be treated as separate for now.
-         */
-        if (__nv_gmmu_va_is_big_page_region(vm, base))
-                return gmmu_page_size_big;
-        else
+        if (!vm->big_pages)
                 return gmmu_page_size_small;
+
+        if (base)
+                return __get_pte_size_fixed_map(vm, base, size);
+
+        if (size >= vm->gmmu_page_sizes[gmmu_page_size_big])
+                return gmmu_page_size_big;
+        return gmmu_page_size_small;
 }
 
 /*
@@ -797,6 +795,8 @@ void gk20a_mm_init_pdb(struct gk20a *g, struct mem_desc *mem,
 
 void gk20a_remove_vm(struct vm_gk20a *vm, struct mem_desc *inst_block);
 
+int gk20a_big_pages_possible(struct vm_gk20a *vm, u64 base, u64 size);
+
 extern const struct gk20a_mmu_level gk20a_mm_levels_64k[];
 extern const struct gk20a_mmu_level gk20a_mm_levels_128k[];