14 files changed, 86 insertions, 76 deletions

diff --git a/drivers/gpu/nvgpu/gk20a/cde_gk20a.c b/drivers/gpu/nvgpu/gk20a/cde_gk20a.c
index 02b1938a..4b84dc69 100644
--- a/drivers/gpu/nvgpu/gk20a/cde_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/cde_gk20a.c
@@ -241,7 +241,7 @@ static int gk20a_init_cde_buf(struct gk20a_cde_ctx *cde_ctx,
 
         /* allocate buf */
         mem = cde_ctx->mem + cde_ctx->num_bufs;
-        err = gk20a_gmmu_alloc_map(cde_ctx->vm, buf->num_bytes, mem);
+        err = gk20a_gmmu_alloc_map_sys(cde_ctx->vm, buf->num_bytes, mem);
         if (err) {
                 gk20a_warn(cde_ctx->dev, "cde: could not allocate device memory. buffer idx = %d",
                            cde_ctx->num_bufs);
diff --git a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
index ad452919..1439410e 100644
--- a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
@@ -1327,7 +1327,7 @@ static int channel_gk20a_alloc_priv_cmdbuf(struct channel_gk20a *c)
         size = roundup_pow_of_two(c->gpfifo.entry_num *
                                   2 * 18 * sizeof(u32) / 3);
 
-        err = gk20a_gmmu_alloc_map(ch_vm, size, &q->mem);
+        err = gk20a_gmmu_alloc_map_sys(ch_vm, size, &q->mem);
         if (err) {
                 gk20a_err(d, "%s: memory allocation failed\n", __func__);
                 goto clean_up;
@@ -1464,7 +1464,7 @@ int gk20a_alloc_channel_gpfifo(struct channel_gk20a *c,
                 return -EEXIST;
         }
 
-        err = gk20a_gmmu_alloc_map(ch_vm,
+        err = gk20a_gmmu_alloc_map_sys(ch_vm,
                         gpfifo_size * sizeof(struct nvgpu_gpfifo),
                         &c->gpfifo.mem);
         if (err) {
diff --git a/drivers/gpu/nvgpu/gk20a/css_gr_gk20a.c b/drivers/gpu/nvgpu/gk20a/css_gr_gk20a.c
index 5edb07a7..62f60761 100644
--- a/drivers/gpu/nvgpu/gk20a/css_gr_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/css_gr_gk20a.c
@@ -231,7 +231,7 @@ static int css_hw_enable_snapshot(struct gr_gk20a *gr, u32 snapshot_size)
         if (snapshot_size < CSS_MIN_HW_SNAPSHOT_SIZE)
                 snapshot_size = CSS_MIN_HW_SNAPSHOT_SIZE;
 
-        ret = gk20a_gmmu_alloc_map(&g->mm.pmu.vm, snapshot_size,
+        ret = gk20a_gmmu_alloc_map_sys(&g->mm.pmu.vm, snapshot_size,
                                                         &data->hw_memdesc);
         if (ret)
                 return ret;
diff --git a/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c b/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c
index 52166b7f..69e2b409 100644
--- a/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c
@@ -385,7 +385,7 @@ static int gk20a_fecs_trace_alloc_ring(struct gk20a *g)
 {
         struct gk20a_fecs_trace *trace = g->fecs_trace;
 
-        return gk20a_gmmu_alloc(g, GK20A_FECS_TRACE_NUM_RECORDS
+        return gk20a_gmmu_alloc_sys(g, GK20A_FECS_TRACE_NUM_RECORDS
                         * ctxsw_prog_record_timestamp_record_size_in_bytes_v(),
                         &trace->trace_buf);
 }
diff --git a/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c b/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c
index 0e006cb6..3e55e3c1 100644
--- a/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c
@@ -591,7 +591,8 @@ static int init_runlist(struct gk20a *g, struct fifo_gk20a *f)
 
                 runlist_size  = ram_rl_entry_size_v() * f->num_runlist_entries;
                 for (i = 0; i < MAX_RUNLIST_BUFFERS; i++) {
-                        int err = gk20a_gmmu_alloc(g, runlist_size, &runlist->mem[i]);
+                        int err = gk20a_gmmu_alloc_sys(g, runlist_size,
+                                        &runlist->mem[i]);
                         if (err) {
                                 dev_err(d, "memory allocation failed\n");
                                 goto clean_up_runlist;
@@ -766,7 +767,7 @@ static int gk20a_init_fifo_setup_sw(struct gk20a *g)
 
         f->userd_entry_size = 1 << ram_userd_base_shift_v();
 
-        err = gk20a_gmmu_alloc_map(&g->mm.bar1.vm,
+        err = gk20a_gmmu_alloc_map_sys(&g->mm.bar1.vm,
                                    f->userd_entry_size * f->num_channels,
                                    &f->userd);
         if (err) {
diff --git a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
index 0d97e84c..c5b2ba5c 100644
--- a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
@@ -1810,7 +1810,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(g, DMA_ATTR_NO_KERNEL_MAPPING,
+                        ret = gk20a_gmmu_alloc_attr_sys(g,
+                                        DMA_ATTR_NO_KERNEL_MAPPING,
                                         g->gr.ctx_vars.pm_ctxsw_image_size,
                                         &pm_ctx->mem);
                         if (ret) {
@@ -2148,7 +2149,7 @@ int gr_gk20a_init_ctxsw_ucode(struct gk20a *g)
                 g->gr.ctx_vars.ucode.gpccs.inst.count * sizeof(u32),
                 g->gr.ctx_vars.ucode.gpccs.data.count * sizeof(u32));
 
-        err = gk20a_gmmu_alloc(g, ucode_size, &ucode_info->surface_desc);
+        err = gk20a_gmmu_alloc_sys(g, ucode_size, &ucode_info->surface_desc);
         if (err)
                 goto clean_up;
 
@@ -2535,7 +2536,7 @@ static int gk20a_gr_alloc_ctx_buffer(struct gk20a *g,
 {
         int err = 0;
 
-        err = gk20a_gmmu_alloc_attr(g, DMA_ATTR_NO_KERNEL_MAPPING,
+        err = gk20a_gmmu_alloc_attr_sys(g, DMA_ATTR_NO_KERNEL_MAPPING,
                                     size, &desc->mem);
         if (err)
                 return err;
@@ -2778,13 +2779,15 @@ 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_attr_sys(g, DMA_ATTR_NO_KERNEL_MAPPING,
                                         gr->ctx_vars.buffer_total_size,
                                         &gr_ctx->mem);
         if (err)
                 goto err_free_ctx;
 
-        gr_ctx->mem.gpu_va = gk20a_gmmu_map(vm, &gr_ctx->mem.sgt, gr_ctx->mem.size,
+        gr_ctx->mem.gpu_va = gk20a_gmmu_map(vm,
+                                        &gr_ctx->mem.sgt,
+                                        gr_ctx->mem.size,
                                         NVGPU_MAP_BUFFER_FLAGS_CACHEABLE_TRUE,
                                         gk20a_mem_flag_none, true,
                                         gr_ctx->mem.aperture);
@@ -2874,7 +2877,7 @@ static int gr_gk20a_alloc_channel_patch_ctx(struct gk20a *g,
 
         gk20a_dbg_fn("");
 
-        err = gk20a_gmmu_alloc_map_attr(ch_vm, DMA_ATTR_NO_KERNEL_MAPPING,
+        err = gk20a_gmmu_alloc_map_attr_sys(ch_vm, DMA_ATTR_NO_KERNEL_MAPPING,
                                         128 * sizeof(u32), &patch_ctx->mem);
         if (err)
                 return err;
@@ -3486,11 +3489,11 @@ static int gr_gk20a_init_mmu_sw(struct gk20a *g, struct gr_gk20a *gr)
 {
         int err;
 
-        err = gk20a_gmmu_alloc(g, 0x1000, &gr->mmu_wr_mem);
+        err = gk20a_gmmu_alloc_sys(g, 0x1000, &gr->mmu_wr_mem);
         if (err)
                 goto err;
 
-        err = gk20a_gmmu_alloc(g, 0x1000, &gr->mmu_rd_mem);
+        err = gk20a_gmmu_alloc_sys(g, 0x1000, &gr->mmu_rd_mem);
         if (err)
                 goto err_free_wr_mem;
         return 0;
@@ -4945,7 +4948,7 @@ static int gk20a_init_gr_bind_fecs_elpg(struct gk20a *g)
         }
 
         if (!pmu->pg_buf.cpu_va) {
-                err = gk20a_gmmu_alloc_map(vm, size, &pmu->pg_buf);
+                err = gk20a_gmmu_alloc_map_sys(vm, size, &pmu->pg_buf);
                 if (err) {
                         gk20a_err(d, "failed to allocate memory\n");
                         return -ENOMEM;
diff --git a/drivers/gpu/nvgpu/gk20a/ltc_common.c b/drivers/gpu/nvgpu/gk20a/ltc_common.c
index a4d16b67..45607154 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(g, DMA_ATTR_FORCE_CONTIGUOUS,
+        return gk20a_gmmu_alloc_attr_sys(g, DMA_ATTR_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(g, DMA_ATTR_NO_KERNEL_MAPPING,
+        return gk20a_gmmu_alloc_attr_sys(g, DMA_ATTR_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 5e87ae25..d7ace0d8 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
@@ -713,7 +713,7 @@ static void gk20a_remove_mm_support(struct mm_gk20a *mm)
 
 static int gk20a_alloc_sysmem_flush(struct gk20a *g)
 {
-        return gk20a_gmmu_alloc(g, SZ_4K, &g->mm.sysmem_flush);
+        return gk20a_gmmu_alloc_sys(g, SZ_4K, &g->mm.sysmem_flush);
 }
 
 static void gk20a_init_pramin(struct mm_gk20a *mm)
@@ -976,9 +976,9 @@ static int alloc_gmmu_pages(struct vm_gk20a *vm, u32 order,
          * default.
          */
         if (IS_ENABLED(CONFIG_ARM64))
-                err = gk20a_gmmu_alloc(g, len, &entry->mem);
+                err = gk20a_gmmu_alloc_sys(g, len, &entry->mem);
         else
-                err = gk20a_gmmu_alloc_attr(g, DMA_ATTR_NO_KERNEL_MAPPING,
+                err = gk20a_gmmu_alloc_attr_sys(g, DMA_ATTR_NO_KERNEL_MAPPING,
                                 len, &entry->mem);
 
 
@@ -2363,9 +2363,17 @@ 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,
                 struct mem_desc *mem)
 {
+        if (g->mm.vidmem_is_vidmem)
+                return gk20a_gmmu_alloc_attr_vid(g, attr, size, mem);
+
         return gk20a_gmmu_alloc_attr_sys(g, attr, 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);
+}
+
 int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr,
                 size_t size, struct mem_desc *mem)
 {
@@ -2594,7 +2602,8 @@ u32 gk20a_aperture_mask(struct gk20a *g, struct mem_desc *mem,
                         sysmem_mask, vidmem_mask);
 }
 
-int gk20a_gmmu_alloc_map(struct vm_gk20a *vm, size_t size, 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);
 }
@@ -2602,7 +2611,22 @@ 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, size_t size, struct mem_desc *mem)
 {
-        int err = gk20a_gmmu_alloc_attr(vm->mm->g, attr, size, mem);
+        if (vm->mm->vidmem_is_vidmem)
+                return gk20a_gmmu_alloc_map_attr_vid(vm, 0, size, mem);
+
+        return gk20a_gmmu_alloc_map_attr_sys(vm, 0, 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);
+}
+
+int gk20a_gmmu_alloc_map_attr_sys(struct vm_gk20a *vm,
+                         enum dma_attr attr, size_t size, struct mem_desc *mem)
+{
+        int err = gk20a_gmmu_alloc_attr_sys(vm->mm->g, attr, size, mem);
 
         if (err)
                 return err;
@@ -3983,7 +4007,7 @@ int gk20a_alloc_inst_block(struct gk20a *g, struct mem_desc *inst_block)
 
         gk20a_dbg_fn("");
 
-        err = gk20a_gmmu_alloc(g, ram_in_alloc_size_v(), inst_block);
+        err = gk20a_gmmu_alloc_sys(g, ram_in_alloc_size_v(), inst_block);
         if (err) {
                 gk20a_err(dev, "%s: memory allocation failed\n", __func__);
                 return err;
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
index f87ba605..4b811ddf 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
@@ -536,61 +536,39 @@ u64 gk20a_gmmu_fixed_map(struct vm_gk20a *vm,
                 bool priv,
                 enum gk20a_aperture aperture);
 
-int gk20a_gmmu_alloc_map(struct vm_gk20a *vm,
-                size_t size,
+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,
+                size_t size, struct mem_desc *mem);
 
-int gk20a_gmmu_alloc_map_attr(struct vm_gk20a *vm,
-                enum dma_attr attr,
-                size_t size,
+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,
+                size_t size, struct mem_desc *mem);
 
-int gk20a_gmmu_alloc_map_vid(struct vm_gk20a *vm,
-                size_t size,
+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,
+                size_t size, struct mem_desc *mem);
 
-int gk20a_gmmu_alloc_map_attr_vid(struct vm_gk20a *vm,
-                enum dma_attr attr,
-                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);
+void gk20a_gmmu_unmap_free(struct vm_gk20a *vm, struct mem_desc *mem);
 
-int gk20a_gmmu_alloc_attr(struct gk20a *g,
-                enum dma_attr attr,
-                size_t size,
+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,
                 struct mem_desc *mem);
 
-int gk20a_gmmu_alloc_attr_sys(struct gk20a *g,
-                enum dma_attr attr,
-                size_t size,
+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_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,
-                size_t size,
-                struct mem_desc *mem,
-                dma_addr_t at);
-
-void gk20a_gmmu_free(struct gk20a *g,
+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,
+                size_t size, struct mem_desc *mem, dma_addr_t at);
 
-void gk20a_gmmu_free_attr(struct gk20a *g,
-                enum dma_attr attr,
+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/pmu_gk20a.c b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
index b0940229..347d7158 100644
--- a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
@@ -2894,7 +2894,8 @@ static int gk20a_prepare_ucode(struct gk20a *g)
         pmu->ucode_image = (u32 *)((u8 *)pmu->desc +
                         pmu->desc->descriptor_size);
 
-        err = gk20a_gmmu_alloc_map(vm, GK20A_PMU_UCODE_SIZE_MAX, &pmu->ucode);
+        err = gk20a_gmmu_alloc_map_sys(vm, GK20A_PMU_UCODE_SIZE_MAX,
+                        &pmu->ucode);
         if (err)
                 goto err_release_fw;
 
@@ -2965,13 +2966,15 @@ static int gk20a_init_pmu_setup_sw(struct gk20a *g)
 
         INIT_WORK(&pmu->pg_init, pmu_setup_hw);
 
-        err = gk20a_gmmu_alloc_map(vm, GK20A_PMU_SEQ_BUF_SIZE, &pmu->seq_buf);
+        err = gk20a_gmmu_alloc_map_sys(vm, GK20A_PMU_SEQ_BUF_SIZE,
+                        &pmu->seq_buf);
         if (err) {
                 gk20a_err(d, "failed to allocate memory\n");
                 goto err_free_seq;
         }
 
-        err = gk20a_gmmu_alloc_map(vm, GK20A_PMU_TRACE_BUFSIZE, &pmu->trace_buf);
+        err = gk20a_gmmu_alloc_map_sys(vm, GK20A_PMU_TRACE_BUFSIZE,
+                        &pmu->trace_buf);
         if (err) {
                 gk20a_err(d, "failed to allocate trace memory\n");
                 goto err_free_seq_buf;
diff --git a/drivers/gpu/nvgpu/gk20a/semaphore_gk20a.c b/drivers/gpu/nvgpu/gk20a/semaphore_gk20a.c
index 113c59ef..d513fa84 100644
--- a/drivers/gpu/nvgpu/gk20a/semaphore_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/semaphore_gk20a.c
@@ -52,7 +52,7 @@ static int __gk20a_semaphore_sea_grow(struct gk20a_semaphore_sea *sea)
 
         __lock_sema_sea(sea);
 
-        ret = gk20a_gmmu_alloc_attr(gk20a, DMA_ATTR_NO_KERNEL_MAPPING,
+        ret = gk20a_gmmu_alloc_attr_sys(gk20a, DMA_ATTR_NO_KERNEL_MAPPING,
                                     PAGE_SIZE * SEMAPHORE_POOL_COUNT,
                                     &sea->sea_mem);
         if (ret)
diff --git a/drivers/gpu/nvgpu/gm206/acr_gm206.c b/drivers/gpu/nvgpu/gm206/acr_gm206.c
index 5a61bd21..988761f0 100644
--- a/drivers/gpu/nvgpu/gm206/acr_gm206.c
+++ b/drivers/gpu/nvgpu/gm206/acr_gm206.c
@@ -252,7 +252,7 @@ static int gm206_bootstrap_hs_flcn(struct gk20a *g)
                         err = -1;
                         goto err_release_acr_fw;
                 }
-                err = gk20a_gmmu_alloc_map(vm, img_size_in_bytes,
+                err = gk20a_gmmu_alloc_map_sys(vm, img_size_in_bytes,
                                 &acr->acr_ucode);
                 if (err) {
                         err = -ENOMEM;
diff --git a/drivers/gpu/nvgpu/gm20b/acr_gm20b.c b/drivers/gpu/nvgpu/gm20b/acr_gm20b.c
index c503bc48..c4a188ff 100644
--- a/drivers/gpu/nvgpu/gm20b/acr_gm20b.c
+++ b/drivers/gpu/nvgpu/gm20b/acr_gm20b.c
@@ -355,7 +355,7 @@ static int gm20b_alloc_blob_space(struct gk20a *g,
 {
         int err;
 
-        err = gk20a_gmmu_alloc(g, size, mem);
+        err = gk20a_gmmu_alloc_sys(g, size, mem);
 
         return err;
 }
@@ -1100,7 +1100,7 @@ static int gm20b_bootstrap_hs_flcn(struct gk20a *g)
                         err = -1;
                         goto err_release_acr_fw;
                 }
-                err = gk20a_gmmu_alloc_map(vm, img_size_in_bytes,
+                err = gk20a_gmmu_alloc_map_sys(vm, img_size_in_bytes,
                                 &acr->acr_ucode);
                 if (err) {
                         err = -ENOMEM;
@@ -1403,7 +1403,7 @@ 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(g,
+                err = gk20a_gmmu_alloc_attr_sys(g,
                                 DMA_ATTR_READ_ONLY, bl_sz, &acr->hsbl_ucode);
                 if (err) {
                         gk20a_err(d, "failed to allocate memory\n");
diff --git a/drivers/gpu/nvgpu/vgpu/fifo_vgpu.c b/drivers/gpu/nvgpu/vgpu/fifo_vgpu.c
index ffa16cd3..29692573 100644
--- a/drivers/gpu/nvgpu/vgpu/fifo_vgpu.c
+++ b/drivers/gpu/nvgpu/vgpu/fifo_vgpu.c
@@ -217,7 +217,8 @@ static int init_runlist(struct gk20a *g, struct fifo_gk20a *f)
 
                         runlist_size  = sizeof(u16) * f->num_channels;
                         for (i = 0; i < MAX_RUNLIST_BUFFERS; i++) {
-                                int err = gk20a_gmmu_alloc(g, runlist_size, &runlist->mem[i]);
+                                int err = gk20a_gmmu_alloc_sys(g, runlist_size,
+                                                &runlist->mem[i]);
                                 if (err) {
                                         dev_err(d, "memory allocation failed\n");
                                         goto clean_up_runlist;
@@ -265,7 +266,7 @@ static int vgpu_init_fifo_setup_sw(struct gk20a *g)
 
         f->userd_entry_size = 1 << ram_userd_base_shift_v();
 
-        err = gk20a_gmmu_alloc(g, f->userd_entry_size * f->num_channels,
+        err = gk20a_gmmu_alloc_sys(g, f->userd_entry_size * f->num_channels,
                         &f->userd);
         if (err) {
                 dev_err(d, "memory allocation failed\n");