gpu: nvgpu: abstract away dma alloc attrs

Don't use enum dma_attr in the gk20a_gmmu_alloc_attr* functions, but
define nvgpu-internal flags for no kernel mapping, force contiguous, and
read only modes. Store the flags in the allocated struct mem_desc and
only use gk20a_gmmu_free, remove gk20a_gmmu_free_attr. This helps in OS
abstraction. Rename the notion of attr to flags.

Add implicit NVGPU_DMA_NO_KERNEL_MAPPING to all vidmem buffers
allocated via gk20a_gmmu_alloc_vid for consistency.

Fix a bug in gk20a_gmmu_alloc_map_attr that dropped the attr
parameter accidentally.

Bug 1853519

Change-Id: I1ff67dff9fc425457ae445ce4976a780eb4dcc9f
Signed-off-by: Konsta Holtta <kholtta@nvidia.com>
Reviewed-on: http://git-master/r/1321101
Reviewed-by: svccoveritychecker <svccoveritychecker@nvidia.com>
Reviewed-by: Alex Waterman <alexw@nvidia.com>
GVS: Gerrit_Virtual_Submit
Reviewed-by: Terje Bergstrom <tbergstrom@nvidia.com>

10 files changed, 131 insertions, 113 deletions

diff --git a/drivers/gpu/nvgpu/common/semaphore.c b/drivers/gpu/nvgpu/common/semaphore.c
index e4099bd1..ff86ada9 100644
--- a/drivers/gpu/nvgpu/common/semaphore.c
+++ b/drivers/gpu/nvgpu/common/semaphore.c
@@ -49,7 +49,7 @@ static int __nvgpu_semaphore_sea_grow(struct nvgpu_semaphore_sea *sea)
 
         __lock_sema_sea(sea);
 
-        ret = gk20a_gmmu_alloc_attr_sys(gk20a, DMA_ATTR_NO_KERNEL_MAPPING,
+        ret = gk20a_gmmu_alloc_flags_sys(gk20a, NVGPU_DMA_NO_KERNEL_MAPPING,
                                     PAGE_SIZE * SEMAPHORE_POOL_COUNT,
                                     &sea->sea_mem);
         if (ret)
diff --git a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
index 2451786b..5a76822f 100644
--- a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
@@ -1936,8 +1936,8 @@ int gr_gk20a_update_hwpm_ctxsw_mode(struct gk20a *g,
         if (enable_hwpm_ctxsw) {
                 /* Allocate buffer if necessary */
                 if (pm_ctx->mem.gpu_va == 0) {
-                        ret = gk20a_gmmu_alloc_attr_sys(g,
-                                        DMA_ATTR_NO_KERNEL_MAPPING,
+                        ret = gk20a_gmmu_alloc_flags_sys(g,
+                                        NVGPU_DMA_NO_KERNEL_MAPPING,
                                         g->gr.ctx_vars.pm_ctxsw_image_size,
                                         &pm_ctx->mem);
                         if (ret) {
@@ -1956,8 +1956,7 @@ int gr_gk20a_update_hwpm_ctxsw_mode(struct gk20a *g,
                         if (!pm_ctx->mem.gpu_va) {
                                 gk20a_err(dev_from_gk20a(g),
                                         "failed to map pm ctxt buffer");
-                                gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING,
-                                                &pm_ctx->mem);
+                                gk20a_gmmu_free(g, &pm_ctx->mem);
                                 c->g->ops.fifo.enable_channel(c);
                                 return -ENOMEM;
                         }
@@ -2017,7 +2016,7 @@ clean_up_mem:
 cleanup_pm_buf:
         gk20a_gmmu_unmap(c->vm, pm_ctx->mem.gpu_va, pm_ctx->mem.size,
                         gk20a_mem_flag_none);
-        gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &pm_ctx->mem);
+        gk20a_gmmu_free(g, &pm_ctx->mem);
         memset(&pm_ctx->mem, 0, sizeof(struct mem_desc));
 
         gk20a_enable_channel_tsg(g, c);
@@ -2699,7 +2698,7 @@ static void gk20a_gr_destroy_ctx_buffer(struct gk20a *g,
 {
         if (!desc)
                 return;
-        gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &desc->mem);
+        gk20a_gmmu_free(g, &desc->mem);
         desc->destroy = NULL;
 }
 
@@ -2709,7 +2708,7 @@ static int gk20a_gr_alloc_ctx_buffer(struct gk20a *g,
 {
         int err = 0;
 
-        err = gk20a_gmmu_alloc_attr_sys(g, DMA_ATTR_NO_KERNEL_MAPPING,
+        err = gk20a_gmmu_alloc_flags_sys(g, NVGPU_DMA_NO_KERNEL_MAPPING,
                                     size, &desc->mem);
         if (err)
                 return err;
@@ -2952,7 +2951,7 @@ int gr_gk20a_alloc_gr_ctx(struct gk20a *g,
         if (!gr_ctx)
                 return -ENOMEM;
 
-        err = gk20a_gmmu_alloc_attr(g, DMA_ATTR_NO_KERNEL_MAPPING,
+        err = gk20a_gmmu_alloc_flags(g, NVGPU_DMA_NO_KERNEL_MAPPING,
                                         gr->ctx_vars.buffer_total_size,
                                         &gr_ctx->mem);
         if (err)
@@ -2972,7 +2971,7 @@ int gr_gk20a_alloc_gr_ctx(struct gk20a *g,
         return 0;
 
  err_free_mem:
-        gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &gr_ctx->mem);
+        gk20a_gmmu_free(g, &gr_ctx->mem);
  err_free_ctx:
         kfree(gr_ctx);
         gr_ctx = NULL;
@@ -3021,7 +3020,7 @@ void gr_gk20a_free_gr_ctx(struct gk20a *g,
 
         gk20a_gmmu_unmap(vm, gr_ctx->mem.gpu_va,
                 gr_ctx->mem.size, gk20a_mem_flag_none);
-        gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &gr_ctx->mem);
+        gk20a_gmmu_free(g, &gr_ctx->mem);
         kfree(gr_ctx);
 }
 
@@ -3050,7 +3049,7 @@ static int gr_gk20a_alloc_channel_patch_ctx(struct gk20a *g,
 
         gk20a_dbg_fn("");
 
-        err = gk20a_gmmu_alloc_map_attr_sys(ch_vm, DMA_ATTR_NO_KERNEL_MAPPING,
+        err = gk20a_gmmu_alloc_map_flags_sys(ch_vm, NVGPU_DMA_NO_KERNEL_MAPPING,
                                         128 * sizeof(u32), &patch_ctx->mem);
         if (err)
                 return err;
@@ -3070,7 +3069,7 @@ static void gr_gk20a_free_channel_patch_ctx(struct channel_gk20a *c)
                 gk20a_gmmu_unmap(c->vm, patch_ctx->mem.gpu_va,
                                  patch_ctx->mem.size, gk20a_mem_flag_none);
 
-        gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &patch_ctx->mem);
+        gk20a_gmmu_free(g, &patch_ctx->mem);
         patch_ctx->data_count = 0;
 }
 
@@ -3085,7 +3084,7 @@ static void gr_gk20a_free_channel_pm_ctx(struct channel_gk20a *c)
                 gk20a_gmmu_unmap(c->vm, pm_ctx->mem.gpu_va,
                                  pm_ctx->mem.size, gk20a_mem_flag_none);
 
-                gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &pm_ctx->mem);
+                gk20a_gmmu_free(g, &pm_ctx->mem);
         }
 }
 
@@ -3365,8 +3364,7 @@ static void gk20a_remove_gr_support(struct gr_gk20a *gr)
         gk20a_gmmu_free(g, &gr->mmu_wr_mem);
         gk20a_gmmu_free(g, &gr->mmu_rd_mem);
 
-        gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING,
-                             &gr->compbit_store.mem);
+        gk20a_gmmu_free(g, &gr->compbit_store.mem);
 
         memset(&gr->compbit_store, 0, sizeof(struct compbit_store_desc));
 
diff --git a/drivers/gpu/nvgpu/gk20a/ltc_common.c b/drivers/gpu/nvgpu/gk20a/ltc_common.c
index 13819872..7c4db84e 100644
--- a/drivers/gpu/nvgpu/gk20a/ltc_common.c
+++ b/drivers/gpu/nvgpu/gk20a/ltc_common.c
@@ -68,7 +68,7 @@ static int gk20a_ltc_alloc_phys_cbc(struct gk20a *g,
 {
         struct gr_gk20a *gr = &g->gr;
 
-        return gk20a_gmmu_alloc_attr_sys(g, DMA_ATTR_FORCE_CONTIGUOUS,
+        return gk20a_gmmu_alloc_flags_sys(g, NVGPU_DMA_FORCE_CONTIGUOUS,
                                     compbit_backing_size,
                                     &gr->compbit_store.mem);
 }
@@ -78,7 +78,7 @@ static int gk20a_ltc_alloc_virt_cbc(struct gk20a *g,
 {
         struct gr_gk20a *gr = &g->gr;
 
-        return gk20a_gmmu_alloc_attr_sys(g, DMA_ATTR_NO_KERNEL_MAPPING,
+        return gk20a_gmmu_alloc_flags_sys(g, NVGPU_DMA_NO_KERNEL_MAPPING,
                                     compbit_backing_size,
                                     &gr->compbit_store.mem);
 }
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
index 32d1f32f..b9678fbb 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
@@ -25,6 +25,8 @@
 #include <soc/tegra/chip-id.h>
 #include <linux/vmalloc.h>
 #include <linux/dma-buf.h>
+#include <linux/dma-mapping.h>
+#include <linux/dma-attrs.h>
 #include <linux/lcm.h>
 #include <linux/fdtable.h>
 #include <uapi/linux/nvgpu.h>
@@ -1253,7 +1255,7 @@ static int alloc_gmmu_pages(struct vm_gk20a *vm, u32 order,
         if (IS_ENABLED(CONFIG_ARM64))
                 err = gk20a_gmmu_alloc(g, len, &entry->mem);
         else
-                err = gk20a_gmmu_alloc_attr(g, DMA_ATTR_NO_KERNEL_MAPPING,
+                err = gk20a_gmmu_alloc_flags(g, NVGPU_DMA_NO_KERNEL_MAPPING,
                                 len, &entry->mem);
 
 
@@ -1284,15 +1286,7 @@ void free_gmmu_pages(struct vm_gk20a *vm,
                 return;
         }
 
-        /*
-         * On arm32 we're limited by vmalloc space, so we do not map pages by
-         * default.
-         */
-        if (IS_ENABLED(CONFIG_ARM64))
-                gk20a_gmmu_free(g, &entry->mem);
-        else
-                gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING,
-                                &entry->mem);
+        gk20a_gmmu_free(g, &entry->mem);
 }
 
 int map_gmmu_pages(struct gk20a *g, struct gk20a_mm_entry *entry)
@@ -2910,14 +2904,14 @@ u64 gk20a_gmmu_fixed_map(struct vm_gk20a *vm,
 
 int gk20a_gmmu_alloc(struct gk20a *g, size_t size, struct mem_desc *mem)
 {
-        return gk20a_gmmu_alloc_attr(g, 0, size, mem);
+        return gk20a_gmmu_alloc_flags(g, 0, size, mem);
 }
 
-int gk20a_gmmu_alloc_attr(struct gk20a *g, enum dma_attr attr, size_t size,
+int gk20a_gmmu_alloc_flags(struct gk20a *g, unsigned long flags, size_t size,
                 struct mem_desc *mem)
 {
         if (g->mm.vidmem_is_vidmem) {
-                int err = gk20a_gmmu_alloc_attr_vid(g, attr, size, mem);
+                int err = gk20a_gmmu_alloc_flags_vid(g, flags, size, mem);
 
                 if (!err)
                         return 0;
@@ -2927,15 +2921,26 @@ int gk20a_gmmu_alloc_attr(struct gk20a *g, enum dma_attr attr, size_t size,
                  */
         }
 
-        return gk20a_gmmu_alloc_attr_sys(g, attr, size, mem);
+        return gk20a_gmmu_alloc_flags_sys(g, flags, size, mem);
 }
 
 int gk20a_gmmu_alloc_sys(struct gk20a *g, size_t size, struct mem_desc *mem)
 {
-        return gk20a_gmmu_alloc_attr_sys(g, 0, size, mem);
+        return gk20a_gmmu_alloc_flags_sys(g, 0, size, mem);
 }
 
-int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr,
+static void gk20a_dma_flags_to_attrs(struct dma_attrs *attrs,
+                unsigned long flags)
+{
+        if (flags & NVGPU_DMA_NO_KERNEL_MAPPING)
+                dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs);
+        if (flags & NVGPU_DMA_FORCE_CONTIGUOUS)
+                dma_set_attr(DMA_ATTR_FORCE_CONTIGUOUS, attrs);
+        if (flags & NVGPU_DMA_READ_ONLY)
+                dma_set_attr(DMA_ATTR_READ_ONLY, attrs);
+}
+
+int gk20a_gmmu_alloc_flags_sys(struct gk20a *g, unsigned long flags,
                 size_t size, struct mem_desc *mem)
 {
         struct device *d = dev_from_gk20a(g);
@@ -2944,17 +2949,19 @@ int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr,
 
         gk20a_dbg_fn("");
 
-        if (attr) {
-                DEFINE_DMA_ATTRS(attrs);
-                dma_set_attr(attr, &attrs);
-                if (attr == DMA_ATTR_NO_KERNEL_MAPPING) {
+        if (flags) {
+                DEFINE_DMA_ATTRS(dma_attrs);
+
+                gk20a_dma_flags_to_attrs(&dma_attrs, flags);
+
+                if (flags & NVGPU_DMA_NO_KERNEL_MAPPING) {
                         mem->pages = dma_alloc_attrs(d,
-                                        size, &iova, GFP_KERNEL, &attrs);
+                                        size, &iova, GFP_KERNEL, &dma_attrs);
                         if (!mem->pages)
                                 return -ENOMEM;
                 } else {
                         mem->cpu_va = dma_alloc_attrs(d,
-                                        size, &iova, GFP_KERNEL, &attrs);
+                                        size, &iova, GFP_KERNEL, &dma_attrs);
                         if (!mem->cpu_va)
                                 return -ENOMEM;
                 }
@@ -2964,7 +2971,7 @@ int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr,
                         return -ENOMEM;
         }
 
-        if (attr == DMA_ATTR_NO_KERNEL_MAPPING)
+        if (flags & NVGPU_DMA_NO_KERNEL_MAPPING)
                 err = gk20a_get_sgtable_from_pages(d, &mem->sgt, mem->pages,
                                                    iova, size);
         else {
@@ -2976,6 +2983,7 @@ int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr,
 
         mem->size = size;
         mem->aperture = APERTURE_SYSMEM;
+        mem->flags = flags;
 
         gk20a_dbg_fn("done");
 
@@ -2988,31 +2996,28 @@ fail_free:
         return err;
 }
 
-static void gk20a_gmmu_free_attr_sys(struct gk20a *g, enum dma_attr attr,
-                          struct mem_desc *mem)
+static void gk20a_gmmu_free_sys(struct gk20a *g, struct mem_desc *mem)
 {
         struct device *d = dev_from_gk20a(g);
 
         if (mem->cpu_va || mem->pages) {
-                if (attr) {
-                        DEFINE_DMA_ATTRS(attrs);
-                        dma_set_attr(attr, &attrs);
-                        if (attr == DMA_ATTR_NO_KERNEL_MAPPING) {
-                                if (mem->pages)
-                                        dma_free_attrs(d, mem->size, mem->pages,
-                                                sg_dma_address(mem->sgt->sgl),
-                                                &attrs);
+                if (mem->flags) {
+                        DEFINE_DMA_ATTRS(dma_attrs);
+
+                        gk20a_dma_flags_to_attrs(&dma_attrs, mem->flags);
+
+                        if (mem->flags & NVGPU_DMA_NO_KERNEL_MAPPING) {
+                                dma_free_attrs(d, mem->size, mem->pages,
+                                        sg_dma_address(mem->sgt->sgl),
+                                        &dma_attrs);
                         } else {
-                                if (mem->cpu_va)
-                                        dma_free_attrs(d, mem->size,
-                                                mem->cpu_va,
-                                                sg_dma_address(mem->sgt->sgl),
-                                                &attrs);
+                                dma_free_attrs(d, mem->size, mem->cpu_va,
+                                        sg_dma_address(mem->sgt->sgl),
+                                        &dma_attrs);
                         }
                 } else {
-                        if (mem->cpu_va)
-                                dma_free_coherent(d, mem->size, mem->cpu_va,
-                                                sg_dma_address(mem->sgt->sgl));
+                        dma_free_coherent(d, mem->size, mem->cpu_va,
+                                        sg_dma_address(mem->sgt->sgl));
                 }
                 mem->cpu_va = NULL;
                 mem->pages = NULL;
@@ -3089,13 +3094,14 @@ static int gk20a_gmmu_clear_vidmem_mem(struct gk20a *g, struct mem_desc *mem)
 
 int gk20a_gmmu_alloc_vid(struct gk20a *g, size_t size, struct mem_desc *mem)
 {
-        return gk20a_gmmu_alloc_attr_vid(g, 0, size, mem);
+        return gk20a_gmmu_alloc_flags_vid(g,
+                        NVGPU_DMA_NO_KERNEL_MAPPING, size, mem);
 }
 
-int gk20a_gmmu_alloc_attr_vid(struct gk20a *g, enum dma_attr attr,
+int gk20a_gmmu_alloc_flags_vid(struct gk20a *g, unsigned long flags,
                 size_t size, struct mem_desc *mem)
 {
-        return gk20a_gmmu_alloc_attr_vid_at(g, attr, size, mem, 0);
+        return gk20a_gmmu_alloc_flags_vid_at(g, flags, size, mem, 0);
 }
 
 #if defined(CONFIG_GK20A_VIDMEM)
@@ -3113,7 +3119,7 @@ static u64 __gk20a_gmmu_alloc(struct nvgpu_allocator *allocator, dma_addr_t at,
 }
 #endif
 
-int gk20a_gmmu_alloc_attr_vid_at(struct gk20a *g, enum dma_attr attr,
+int gk20a_gmmu_alloc_flags_vid_at(struct gk20a *g, unsigned long flags,
                 size_t size, struct mem_desc *mem, dma_addr_t at)
 {
 #if defined(CONFIG_GK20A_VIDMEM)
@@ -3129,9 +3135,11 @@ int gk20a_gmmu_alloc_attr_vid_at(struct gk20a *g, enum dma_attr attr,
         if (!nvgpu_alloc_initialized(&g->mm.vidmem.allocator))
                 return -ENOSYS;
 
-        /* we don't support dma attributes here, except that kernel mappings
-         * are not done anyway */
-        WARN_ON(attr != 0 && attr != DMA_ATTR_NO_KERNEL_MAPPING);
+        /*
+         * Our own allocator doesn't have any flags yet, and we can't
+         * kernel-map these, so require explicit flags.
+         */
+        WARN_ON(flags != NVGPU_DMA_NO_KERNEL_MAPPING);
 
         nvgpu_mutex_acquire(&g->mm.vidmem.clear_list_mutex);
         before_pending = atomic64_read(&g->mm.vidmem.bytes_pending);
@@ -3186,12 +3194,14 @@ fail_physfree:
 #endif
 }
 
-static void gk20a_gmmu_free_attr_vid(struct gk20a *g, enum dma_attr attr,
-                          struct mem_desc *mem)
+static void gk20a_gmmu_free_vid(struct gk20a *g, struct mem_desc *mem)
 {
 #if defined(CONFIG_GK20A_VIDMEM)
         bool was_empty;
 
+        /* Sanity check - only this supported when allocating. */
+        WARN_ON(mem->flags != NVGPU_DMA_NO_KERNEL_MAPPING);
+
         if (mem->user_mem) {
                 nvgpu_mutex_acquire(&g->mm.vidmem.clear_list_mutex);
                 was_empty = list_empty(&g->mm.vidmem.clear_list_head);
@@ -3216,24 +3226,18 @@ static void gk20a_gmmu_free_attr_vid(struct gk20a *g, enum dma_attr attr,
 #endif
 }
 
-void gk20a_gmmu_free_attr(struct gk20a *g, enum dma_attr attr,
-                          struct mem_desc *mem)
+void gk20a_gmmu_free(struct gk20a *g, struct mem_desc *mem)
 {
         switch (mem->aperture) {
         case APERTURE_SYSMEM:
-                return gk20a_gmmu_free_attr_sys(g, attr, mem);
+                return gk20a_gmmu_free_sys(g, mem);
         case APERTURE_VIDMEM:
-                return gk20a_gmmu_free_attr_vid(g, attr, mem);
+                return gk20a_gmmu_free_vid(g, mem);
         default:
                 break; /* like free() on "null" memory */
         }
 }
 
-void gk20a_gmmu_free(struct gk20a *g, struct mem_desc *mem)
-{
-        return gk20a_gmmu_free_attr(g, 0, mem);
-}
-
 /*
  * If mem is in VIDMEM, return base address in vidmem
  * else return IOVA address for SYSMEM
@@ -3322,14 +3326,14 @@ u32 gk20a_aperture_mask(struct gk20a *g, struct mem_desc *mem,
 int gk20a_gmmu_alloc_map(struct vm_gk20a *vm, size_t size,
                 struct mem_desc *mem)
 {
-        return gk20a_gmmu_alloc_map_attr(vm, 0, size, mem);
+        return gk20a_gmmu_alloc_map_flags(vm, 0, size, mem);
 }
 
-int gk20a_gmmu_alloc_map_attr(struct vm_gk20a *vm,
-                         enum dma_attr attr, size_t size, struct mem_desc *mem)
+int gk20a_gmmu_alloc_map_flags(struct vm_gk20a *vm, unsigned long flags,
+                size_t size, struct mem_desc *mem)
 {
         if (vm->mm->vidmem_is_vidmem) {
-                int err = gk20a_gmmu_alloc_map_attr_vid(vm, 0, size, mem);
+                int err = gk20a_gmmu_alloc_map_flags_vid(vm, flags, size, mem);
 
                 if (!err)
                         return 0;
@@ -3339,19 +3343,19 @@ int gk20a_gmmu_alloc_map_attr(struct vm_gk20a *vm,
                  */
         }
 
-        return gk20a_gmmu_alloc_map_attr_sys(vm, 0, size, mem);
+        return gk20a_gmmu_alloc_map_flags_sys(vm, flags, size, mem);
 }
 
 int gk20a_gmmu_alloc_map_sys(struct vm_gk20a *vm, size_t size,
                 struct mem_desc *mem)
 {
-        return gk20a_gmmu_alloc_map_attr_sys(vm, 0, size, mem);
+        return gk20a_gmmu_alloc_map_flags_sys(vm, 0, size, mem);
 }
 
-int gk20a_gmmu_alloc_map_attr_sys(struct vm_gk20a *vm,
-                         enum dma_attr attr, size_t size, struct mem_desc *mem)
+int gk20a_gmmu_alloc_map_flags_sys(struct vm_gk20a *vm, unsigned long flags,
+                size_t size, struct mem_desc *mem)
 {
-        int err = gk20a_gmmu_alloc_attr_sys(vm->mm->g, attr, size, mem);
+        int err = gk20a_gmmu_alloc_flags_sys(vm->mm->g, flags, size, mem);
 
         if (err)
                 return err;
@@ -3371,15 +3375,16 @@ fail_free:
         return err;
 }
 
-int gk20a_gmmu_alloc_map_vid(struct vm_gk20a *vm, size_t size, struct mem_desc *mem)
+int gk20a_gmmu_alloc_map_vid(struct vm_gk20a *vm, size_t size,
+                struct mem_desc *mem)
 {
-        return gk20a_gmmu_alloc_map_attr_vid(vm, 0, size, mem);
+        return gk20a_gmmu_alloc_map_flags_vid(vm, 0, size, mem);
 }
 
-int gk20a_gmmu_alloc_map_attr_vid(struct vm_gk20a *vm,
-                         enum dma_attr attr, size_t size, struct mem_desc *mem)
+int gk20a_gmmu_alloc_map_flags_vid(struct vm_gk20a *vm, unsigned long flags,
+                size_t size, struct mem_desc *mem)
 {
-        int err = gk20a_gmmu_alloc_attr_vid(vm->mm->g, attr, size, mem);
+        int err = gk20a_gmmu_alloc_flags_vid(vm->mm->g, flags, size, mem);
 
         if (err)
                 return err;
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
index 0d3547e1..52e5d4db 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
@@ -19,7 +19,6 @@
 #define MM_GK20A_H
 
 #include <linux/scatterlist.h>
-#include <linux/dma-attrs.h>
 #include <linux/iommu.h>
 #include <soc/tegra/chip-id.h>
 #include <linux/vmalloc.h>
@@ -80,6 +79,7 @@ struct mem_desc {
         struct nvgpu_allocator *allocator; /* vidmem only */
         struct list_head clear_list_entry; /* vidmem only */
         bool skip_wmb;
+        unsigned long flags;
 };
 
 struct mem_desc_sub {
@@ -545,40 +545,55 @@ u64 gk20a_gmmu_fixed_map(struct vm_gk20a *vm,
                 bool priv,
                 enum gk20a_aperture aperture);
 
+/* Flags for the below gk20a_gmmu_{alloc,alloc_map}_flags* */
+
+/*
+ * Don't create a virtual kernel mapping for the buffer but only allocate it;
+ * this may save some resources. The buffer can be mapped later explicitly.
+ */
+#define NVGPU_DMA_NO_KERNEL_MAPPING     (1 << 0)
+/*
+ * Don't allow building the buffer from individual pages but require a
+ * physically contiguous block.
+ */
+#define NVGPU_DMA_FORCE_CONTIGUOUS      (1 << 1)
+/*
+ * Make the mapping read-only.
+ */
+#define NVGPU_DMA_READ_ONLY             (1 << 2)
+
 int gk20a_gmmu_alloc_map(struct vm_gk20a *vm, size_t size,
                 struct mem_desc *mem);
-int gk20a_gmmu_alloc_map_attr(struct vm_gk20a *vm, enum dma_attr attr,
+int gk20a_gmmu_alloc_map_flags(struct vm_gk20a *vm, unsigned long flags,
                 size_t size, struct mem_desc *mem);
 
 int gk20a_gmmu_alloc_map_sys(struct vm_gk20a *vm, size_t size,
                 struct mem_desc *mem);
-int gk20a_gmmu_alloc_map_attr_sys(struct vm_gk20a *vm, enum dma_attr attr,
+int gk20a_gmmu_alloc_map_flags_sys(struct vm_gk20a *vm, unsigned long flags,
                 size_t size, struct mem_desc *mem);
 
 int gk20a_gmmu_alloc_map_vid(struct vm_gk20a *vm, size_t size,
                 struct mem_desc *mem);
-int gk20a_gmmu_alloc_map_attr_vid(struct vm_gk20a *vm, enum dma_attr attr,
+int gk20a_gmmu_alloc_map_flags_vid(struct vm_gk20a *vm, unsigned long flags,
                 size_t size, struct mem_desc *mem);
 
 void gk20a_gmmu_unmap_free(struct vm_gk20a *vm, struct mem_desc *mem);
 
 int gk20a_gmmu_alloc(struct gk20a *g, size_t size, struct mem_desc *mem);
-int gk20a_gmmu_alloc_attr(struct gk20a *g, enum dma_attr attr, size_t size,
+int gk20a_gmmu_alloc_flags(struct gk20a *g, unsigned long flags, size_t size,
                 struct mem_desc *mem);
 
 int gk20a_gmmu_alloc_sys(struct gk20a *g, size_t size, struct mem_desc *mem);
-int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr, size_t size,
-                struct mem_desc *mem);
+int gk20a_gmmu_alloc_flags_sys(struct gk20a *g, unsigned long flags,
+                size_t size, struct mem_desc *mem);
 
 int gk20a_gmmu_alloc_vid(struct gk20a *g, size_t size, struct mem_desc *mem);
-int gk20a_gmmu_alloc_attr_vid(struct gk20a *g, enum dma_attr attr, size_t size,
-                struct mem_desc *mem);
-int gk20a_gmmu_alloc_attr_vid_at(struct gk20a *g, enum dma_attr attr,
+int gk20a_gmmu_alloc_flags_vid(struct gk20a *g, unsigned long flags,
+                size_t size, struct mem_desc *mem);
+int gk20a_gmmu_alloc_flags_vid_at(struct gk20a *g, unsigned long flags,
                 size_t size, struct mem_desc *mem, dma_addr_t at);
 
 void gk20a_gmmu_free(struct gk20a *g, struct mem_desc *mem);
-void gk20a_gmmu_free_attr(struct gk20a *g, enum dma_attr attr,
-                struct mem_desc *mem);
 
 static inline phys_addr_t gk20a_mem_phys(struct mem_desc *mem)
 {
diff --git a/drivers/gpu/nvgpu/gk20a/platform_gk20a.h b/drivers/gpu/nvgpu/gk20a/platform_gk20a.h
index b23d0091..99ea1bb7 100644
--- a/drivers/gpu/nvgpu/gk20a/platform_gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/platform_gk20a.h
@@ -17,7 +17,6 @@
 #define _GK20A_PLATFORM_H_
 
 #include <linux/device.h>
-#include <linux/dma-attrs.h>
 #include <linux/version.h>
 
 #include <nvgpu/lock.h>
@@ -33,7 +32,6 @@ struct secure_page_buffer {
         void (*destroy)(struct device *, struct secure_page_buffer *);
         size_t size;
         u64 iova;
-        struct dma_attrs attrs;
 };
 
 struct gk20a_platform {
diff --git a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
index c7e68f44..ee995d44 100644
--- a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
@@ -4746,7 +4746,7 @@ int gk20a_pmu_sysmem_surface_alloc(struct gk20a *g, struct mem_desc *mem,
 
 void gk20a_pmu_surface_free(struct gk20a *g, struct mem_desc *mem)
 {
-        gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, mem);
+        gk20a_gmmu_free(g, mem);
         memset(mem, 0, sizeof(struct mem_desc));
 }
 
diff --git a/drivers/gpu/nvgpu/gm20b/acr_gm20b.c b/drivers/gpu/nvgpu/gm20b/acr_gm20b.c
index bcad4437..e613e65f 100644
--- a/drivers/gpu/nvgpu/gm20b/acr_gm20b.c
+++ b/drivers/gpu/nvgpu/gm20b/acr_gm20b.c
@@ -1411,8 +1411,8 @@ int pmu_exec_gen_bl(struct gk20a *g, void *desc, u8 b_wait_for_halt)
                 /*TODO in code verify that enable PMU is done,
                         scrubbing etc is done*/
                 /*TODO in code verify that gmmu vm init is done*/
-                err = gk20a_gmmu_alloc_attr_sys(g,
-                                DMA_ATTR_READ_ONLY, bl_sz, &acr->hsbl_ucode);
+                err = gk20a_gmmu_alloc_flags_sys(g,
+                                NVGPU_DMA_READ_ONLY, bl_sz, &acr->hsbl_ucode);
                 if (err) {
                         gk20a_err(d, "failed to allocate memory\n");
                         goto err_done;
diff --git a/drivers/gpu/nvgpu/gp106/acr_gp106.c b/drivers/gpu/nvgpu/gp106/acr_gp106.c
index f5228136..afb9ebe2 100644
--- a/drivers/gpu/nvgpu/gp106/acr_gp106.c
+++ b/drivers/gpu/nvgpu/gp106/acr_gp106.c
@@ -109,12 +109,14 @@ static int gp106_alloc_blob_space(struct gk20a *g,
          * Even though this mem_desc wouldn't be used, the wpr region needs to
          * be reserved in the allocator.
          */
-        err = gk20a_gmmu_alloc_attr_vid_at(g, 0, wpr_inf.size,
-                                &g->acr.wpr_dummy, wpr_inf.wpr_base);
+        err = gk20a_gmmu_alloc_flags_vid_at(g,
+                        NVGPU_DMA_NO_KERNEL_MAPPING, wpr_inf.size,
+                        &g->acr.wpr_dummy, wpr_inf.wpr_base);
         if (err)
                 return err;
 
-        return gk20a_gmmu_alloc_attr_vid_at(g, 0, wpr_inf.size, mem,
+        return gk20a_gmmu_alloc_flags_vid_at(g,
+                        NVGPU_DMA_NO_KERNEL_MAPPING, wpr_inf.size, mem,
                         wpr_inf.nonwpr_base);
 }
 
diff --git a/drivers/gpu/nvgpu/tegra/linux/platform_gk20a_tegra.c b/drivers/gpu/nvgpu/tegra/linux/platform_gk20a_tegra.c
index 1b40702a..d612fcd2 100644
--- a/drivers/gpu/nvgpu/tegra/linux/platform_gk20a_tegra.c
+++ b/drivers/gpu/nvgpu/tegra/linux/platform_gk20a_tegra.c
@@ -95,9 +95,10 @@ static inline void __maybe_unused pmc_write(u32 val, unsigned long reg)
 static void gk20a_tegra_secure_page_destroy(struct device *dev,
                                        struct secure_page_buffer *secure_buffer)
 {
+        DEFINE_DMA_ATTRS(attrs);
         dma_free_attrs(&tegra_vpr_dev, secure_buffer->size,
                         (void *)(uintptr_t)secure_buffer->iova,
-                        secure_buffer->iova, &secure_buffer->attrs);
+                        secure_buffer->iova, &attrs);
 }
 
 int gk20a_tegra_secure_page_alloc(struct device *dev)
@@ -118,7 +119,6 @@ int gk20a_tegra_secure_page_alloc(struct device *dev)
 
         secure_buffer->size = size;
         secure_buffer->iova = iova;
-        secure_buffer->attrs = attrs;
         secure_buffer->destroy = gk20a_tegra_secure_page_destroy;
 
         return 0;