gpu: nvgpu: Rename vidmem APIs

Rename the VIDMEM APIs to be prefixed by nvgpu_ to ensure
consistency and that all the non-static vidmem functions are
properly namespaced.

JIRA NVGPU-30
JIRA NVGPU-138

Change-Id: I9986ee8f2c8f95a4b7c5e2b9607bc1e77933ccfc
Signed-off-by: Alex Waterman <alexw@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/1540707
Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>

8 files changed, 43 insertions, 42 deletions

diff --git a/drivers/gpu/nvgpu/common/linux/dma.c b/drivers/gpu/nvgpu/common/linux/dma.c
index 2ed1cc5a..ca657da2 100644
--- a/drivers/gpu/nvgpu/common/linux/dma.c
+++ b/drivers/gpu/nvgpu/common/linux/dma.c
@@ -343,7 +343,7 @@ int nvgpu_dma_alloc_flags_vid_at(struct gk20a *g, unsigned long flags,
         if (err)
                 goto fail_kfree;
 
-        set_vidmem_page_alloc(mem->priv.sgt->sgl, addr);
+        nvgpu_vidmem_set_page_alloc(mem->priv.sgt->sgl, addr);
         sg_set_page(mem->priv.sgt->sgl, NULL, size, 0);
 
         mem->aligned_size = size;
@@ -535,7 +535,7 @@ static void nvgpu_dma_free_vid(struct gk20a *g, struct nvgpu_mem *mem)
         } else {
                 nvgpu_memset(g, mem, 0, 0, mem->aligned_size);
                 nvgpu_free(mem->allocator,
-                           (u64)get_vidmem_page_alloc(mem->priv.sgt->sgl));
+                           (u64)nvgpu_vidmem_get_page_alloc(mem->priv.sgt->sgl));
                 nvgpu_free_sgtable(g, &mem->priv.sgt);
 
                 mem->size = 0;
diff --git a/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c b/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c
index c8460bd9..7180256a 100644
--- a/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c
+++ b/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c
@@ -693,7 +693,7 @@ static int nvgpu_gpu_alloc_vidmem(struct gk20a *g,
                 return -EINVAL;
         }
 
-        fd = gk20a_vidmem_buf_alloc(g, args->in.size);
+        fd = nvgpu_vidmem_buf_alloc(g, args->in.size);
         if (fd < 0)
                 return fd;
 
@@ -715,7 +715,7 @@ static int nvgpu_gpu_get_memory_state(struct gk20a *g,
             args->reserved[2] || args->reserved[3])
                 return -EINVAL;
 
-        err = gk20a_vidmem_get_space(g, &args->total_free_bytes);
+        err = nvgpu_vidmem_get_space(g, &args->total_free_bytes);
 
         gk20a_dbg_fn("done, err=%d, bytes=%lld", err, args->total_free_bytes);
 
diff --git a/drivers/gpu/nvgpu/common/linux/nvgpu_mem.c b/drivers/gpu/nvgpu/common/linux/nvgpu_mem.c
index eb51676c..e1f8a598 100644
--- a/drivers/gpu/nvgpu/common/linux/nvgpu_mem.c
+++ b/drivers/gpu/nvgpu/common/linux/nvgpu_mem.c
@@ -355,7 +355,7 @@ u64 nvgpu_mem_get_addr(struct gk20a *g, struct nvgpu_mem *mem)
         /*
          * Otherwise get the vidmem address.
          */
-        alloc = get_vidmem_page_alloc(mem->priv.sgt->sgl);
+        alloc = nvgpu_vidmem_get_page_alloc(mem->priv.sgt->sgl);
 
         /* This API should not be used with > 1 chunks */
         WARN_ON(alloc->nr_chunks != 1);
@@ -549,7 +549,7 @@ static struct nvgpu_sgt *__nvgpu_mem_get_sgl_from_vidmem(
 {
         struct nvgpu_page_alloc *vidmem_alloc;
 
-        vidmem_alloc = get_vidmem_page_alloc(linux_sgl);
+        vidmem_alloc = nvgpu_vidmem_get_page_alloc(linux_sgl);
         if (!vidmem_alloc)
                 return NULL;
 
@@ -561,7 +561,7 @@ struct nvgpu_sgt *nvgpu_linux_sgt_create(struct gk20a *g, struct sg_table *sgt)
         struct nvgpu_sgt *nvgpu_sgt;
         struct scatterlist *linux_sgl = sgt->sgl;
 
-        if (is_vidmem_page_alloc(sg_dma_address(linux_sgl)))
+        if (nvgpu_addr_is_vidmem_page_alloc(sg_dma_address(linux_sgl)))
                 return __nvgpu_mem_get_sgl_from_vidmem(g, linux_sgl);
 
         nvgpu_sgt = nvgpu_kzalloc(g, sizeof(*nvgpu_sgt));
diff --git a/drivers/gpu/nvgpu/common/linux/vidmem.c b/drivers/gpu/nvgpu/common/linux/vidmem.c
index e89dd07a..5d47c858 100644
--- a/drivers/gpu/nvgpu/common/linux/vidmem.c
+++ b/drivers/gpu/nvgpu/common/linux/vidmem.c
@@ -31,24 +31,24 @@
 
 #include "vm_priv.h"
 
-void set_vidmem_page_alloc(struct scatterlist *sgl, u64 addr)
+bool nvgpu_addr_is_vidmem_page_alloc(u64 addr)
 {
-        /* set bit 0 to indicate vidmem allocation */
-        sg_dma_address(sgl) = (addr | 1ULL);
+        return !!(addr & 1ULL);
 }
 
-bool is_vidmem_page_alloc(u64 addr)
+void nvgpu_vidmem_set_page_alloc(struct scatterlist *sgl, u64 addr)
 {
-        return !!(addr & 1ULL);
+        /* set bit 0 to indicate vidmem allocation */
+        sg_dma_address(sgl) = (addr | 1ULL);
 }
 
-struct nvgpu_page_alloc *get_vidmem_page_alloc(struct scatterlist *sgl)
+struct nvgpu_page_alloc *nvgpu_vidmem_get_page_alloc(struct scatterlist *sgl)
 {
         u64 addr;
 
         addr = sg_dma_address(sgl);
 
-        if (is_vidmem_page_alloc(addr))
+        if (nvgpu_addr_is_vidmem_page_alloc(addr))
                 addr = addr & ~1ULL;
         else
                 WARN_ON(1);
@@ -59,7 +59,7 @@ struct nvgpu_page_alloc *get_vidmem_page_alloc(struct scatterlist *sgl)
 static struct sg_table *gk20a_vidbuf_map_dma_buf(
         struct dma_buf_attachment *attach, enum dma_data_direction dir)
 {
-        struct gk20a_vidmem_buf *buf = attach->dmabuf->priv;
+        struct nvgpu_vidmem_buf *buf = attach->dmabuf->priv;
 
         return buf->mem->priv.sgt;
 }
@@ -72,7 +72,7 @@ static void gk20a_vidbuf_unmap_dma_buf(struct dma_buf_attachment *attach,
 
 static void gk20a_vidbuf_release(struct dma_buf *dmabuf)
 {
-        struct gk20a_vidmem_buf *buf = dmabuf->priv;
+        struct nvgpu_vidmem_buf *buf = dmabuf->priv;
 
         gk20a_dbg_fn("");
 
@@ -104,7 +104,7 @@ static int gk20a_vidbuf_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)
 static int gk20a_vidbuf_set_private(struct dma_buf *dmabuf,
                 struct device *dev, void *priv, void (*delete)(void *priv))
 {
-        struct gk20a_vidmem_buf *buf = dmabuf->priv;
+        struct nvgpu_vidmem_buf *buf = dmabuf->priv;
 
         buf->dmabuf_priv = priv;
         buf->dmabuf_priv_delete = delete;
@@ -115,7 +115,7 @@ static int gk20a_vidbuf_set_private(struct dma_buf *dmabuf,
 static void *gk20a_vidbuf_get_private(struct dma_buf *dmabuf,
                 struct device *dev)
 {
-        struct gk20a_vidmem_buf *buf = dmabuf->priv;
+        struct nvgpu_vidmem_buf *buf = dmabuf->priv;
 
         return buf->dmabuf_priv;
 }
@@ -131,7 +131,7 @@ static const struct dma_buf_ops gk20a_vidbuf_ops = {
         .get_drvdata      = gk20a_vidbuf_get_private,
 };
 
-static struct dma_buf *gk20a_vidbuf_export(struct gk20a_vidmem_buf *buf)
+static struct dma_buf *gk20a_vidbuf_export(struct nvgpu_vidmem_buf *buf)
 {
         DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
 
@@ -143,9 +143,9 @@ static struct dma_buf *gk20a_vidbuf_export(struct gk20a_vidmem_buf *buf)
         return dma_buf_export(&exp_info);
 }
 
-struct gk20a *gk20a_vidmem_buf_owner(struct dma_buf *dmabuf)
+struct gk20a *nvgpu_vidmem_buf_owner(struct dma_buf *dmabuf)
 {
-        struct gk20a_vidmem_buf *buf = dmabuf->priv;
+        struct nvgpu_vidmem_buf *buf = dmabuf->priv;
 
         if (dmabuf->ops != &gk20a_vidbuf_ops)
                 return NULL;
@@ -153,9 +153,9 @@ struct gk20a *gk20a_vidmem_buf_owner(struct dma_buf *dmabuf)
         return buf->g;
 }
 
-int gk20a_vidmem_buf_alloc(struct gk20a *g, size_t bytes)
+int nvgpu_vidmem_buf_alloc(struct gk20a *g, size_t bytes)
 {
-        struct gk20a_vidmem_buf *buf;
+        struct nvgpu_vidmem_buf *buf;
         int err = 0, fd;
 
         gk20a_dbg_fn("");
@@ -169,7 +169,7 @@ int gk20a_vidmem_buf_alloc(struct gk20a *g, size_t bytes)
         if (!g->mm.vidmem.cleared) {
                 nvgpu_mutex_acquire(&g->mm.vidmem.first_clear_mutex);
                 if (!g->mm.vidmem.cleared) {
-                        err = gk20a_vidmem_clear_all(g);
+                        err = nvgpu_vidmem_clear_all(g);
                         if (err) {
                                 nvgpu_err(g,
                                           "failed to clear whole vidmem");
@@ -216,10 +216,10 @@ err_kfree:
         return err;
 }
 
-int gk20a_vidbuf_access_memory(struct gk20a *g, struct dma_buf *dmabuf,
+int nvgpu_vidmem_buf_access_memory(struct gk20a *g, struct dma_buf *dmabuf,
                 void *buffer, u64 offset, u64 size, u32 cmd)
 {
-        struct gk20a_vidmem_buf *vidmem_buf;
+        struct nvgpu_vidmem_buf *vidmem_buf;
         struct nvgpu_mem *mem;
         int err = 0;
 
@@ -245,17 +245,17 @@ int gk20a_vidbuf_access_memory(struct gk20a *g, struct dma_buf *dmabuf,
         return err;
 }
 
-void gk20a_vidmem_clear_mem_worker(struct work_struct *work)
+void nvgpu_vidmem_clear_mem_worker(struct work_struct *work)
 {
         struct mm_gk20a *mm = container_of(work, struct mm_gk20a,
                                         vidmem.clear_mem_worker);
         struct gk20a *g = mm->g;
         struct nvgpu_mem *mem;
 
-        while ((mem = get_pending_mem_desc(mm)) != NULL) {
-                gk20a_gmmu_clear_vidmem_mem(g, mem);
+        while ((mem = nvgpu_vidmem_get_pending_alloc(mm)) != NULL) {
+                nvgpu_vidmem_clear(g, mem);
                 nvgpu_free(mem->allocator,
-                           (u64)get_vidmem_page_alloc(mem->priv.sgt->sgl));
+                           (u64)nvgpu_vidmem_get_page_alloc(mem->priv.sgt->sgl));
                 nvgpu_free_sgtable(g, &mem->priv.sgt);
 
                 WARN_ON(nvgpu_atomic64_sub_return(mem->aligned_size,
diff --git a/drivers/gpu/nvgpu/common/linux/vm.c b/drivers/gpu/nvgpu/common/linux/vm.c
index f4ac3d41..d0f87148 100644
--- a/drivers/gpu/nvgpu/common/linux/vm.c
+++ b/drivers/gpu/nvgpu/common/linux/vm.c
@@ -42,7 +42,7 @@
 enum nvgpu_aperture gk20a_dmabuf_aperture(struct gk20a *g,
                                           struct dma_buf *dmabuf)
 {
-        struct gk20a *buf_owner = gk20a_vidmem_buf_owner(dmabuf);
+        struct gk20a *buf_owner = nvgpu_vidmem_buf_owner(dmabuf);
         bool unified_memory = nvgpu_is_enabled(g, NVGPU_MM_UNIFIED_MEMORY);
 
         if (buf_owner == NULL) {
@@ -97,7 +97,8 @@ static u64 nvgpu_get_buffer_alignment(struct gk20a *g, struct scatterlist *sgl,
         u64 buf_addr;
 
         if (aperture == APERTURE_VIDMEM) {
-                struct nvgpu_page_alloc *alloc = get_vidmem_page_alloc(sgl);
+                struct nvgpu_page_alloc *alloc =
+                        nvgpu_vidmem_get_page_alloc(sgl);
                 struct nvgpu_sgt *sgt = &alloc->sgt;
                 void *sgl_vid = sgt->sgl;
 
diff --git a/drivers/gpu/nvgpu/common/mm/nvgpu_mem.c b/drivers/gpu/nvgpu/common/mm/nvgpu_mem.c
index 2b6e6e6a..9f677058 100644
--- a/drivers/gpu/nvgpu/common/mm/nvgpu_mem.c
+++ b/drivers/gpu/nvgpu/common/mm/nvgpu_mem.c
@@ -62,7 +62,7 @@ void nvgpu_sgt_free(struct nvgpu_sgt *sgt, struct gk20a *g)
 u64 nvgpu_mem_iommu_translate(struct gk20a *g, u64 phys)
 {
         /* ensure it is not vidmem allocation */
-        WARN_ON(is_vidmem_page_alloc(phys));
+        WARN_ON(nvgpu_addr_is_vidmem_page_alloc(phys));
 
         if (nvgpu_iommuable(g) && g->ops.mm.get_iommu_bit)
                 return phys | 1ULL << g->ops.mm.get_iommu_bit(g);
diff --git a/drivers/gpu/nvgpu/common/mm/vidmem.c b/drivers/gpu/nvgpu/common/mm/vidmem.c
index 1ba07ca6..c95cedec 100644
--- a/drivers/gpu/nvgpu/common/mm/vidmem.c
+++ b/drivers/gpu/nvgpu/common/mm/vidmem.c
@@ -28,13 +28,13 @@
 #include "gk20a/gk20a.h"
 #include "gk20a/mm_gk20a.h"
 
-void gk20a_vidmem_destroy(struct gk20a *g)
+void nvgpu_vidmem_destroy(struct gk20a *g)
 {
         if (nvgpu_alloc_initialized(&g->mm.vidmem.allocator))
                 nvgpu_alloc_destroy(&g->mm.vidmem.allocator);
 }
 
-int gk20a_vidmem_clear_all(struct gk20a *g)
+int nvgpu_vidmem_clear_all(struct gk20a *g)
 {
         struct mm_gk20a *mm = &g->mm;
         struct gk20a_fence *gk20a_fence_out = NULL;
@@ -106,7 +106,7 @@ int gk20a_vidmem_clear_all(struct gk20a *g)
         return 0;
 }
 
-int gk20a_init_vidmem(struct mm_gk20a *mm)
+int nvgpu_vidmem_init(struct mm_gk20a *mm)
 {
         struct gk20a *g = mm->g;
         size_t size = g->ops.mm.get_vidmem_size ?
@@ -157,7 +157,7 @@ int gk20a_init_vidmem(struct mm_gk20a *mm)
 
         nvgpu_mutex_init(&mm->vidmem.first_clear_mutex);
 
-        INIT_WORK(&mm->vidmem.clear_mem_worker, gk20a_vidmem_clear_mem_worker);
+        INIT_WORK(&mm->vidmem.clear_mem_worker, nvgpu_vidmem_clear_mem_worker);
         nvgpu_atomic64_set(&mm->vidmem.bytes_pending, 0);
         nvgpu_init_list_node(&mm->vidmem.clear_list_head);
         nvgpu_mutex_init(&mm->vidmem.clear_list_mutex);
@@ -167,7 +167,7 @@ int gk20a_init_vidmem(struct mm_gk20a *mm)
         return 0;
 }
 
-int gk20a_vidmem_get_space(struct gk20a *g, u64 *space)
+int nvgpu_vidmem_get_space(struct gk20a *g, u64 *space)
 {
         struct nvgpu_allocator *allocator = &g->mm.vidmem.allocator;
 
@@ -183,7 +183,7 @@ int gk20a_vidmem_get_space(struct gk20a *g, u64 *space)
         return 0;
 }
 
-int gk20a_gmmu_clear_vidmem_mem(struct gk20a *g, struct nvgpu_mem *mem)
+int nvgpu_vidmem_clear(struct gk20a *g, struct nvgpu_mem *mem)
 {
         struct gk20a_fence *gk20a_fence_out = NULL;
         struct gk20a_fence *gk20a_last_fence = NULL;
@@ -194,7 +194,7 @@ int gk20a_gmmu_clear_vidmem_mem(struct gk20a *g, struct nvgpu_mem *mem)
         if (g->mm.vidmem.ce_ctx_id == (u32)~0)
                 return -EINVAL;
 
-        alloc = get_vidmem_page_alloc(mem->priv.sgt->sgl);
+        alloc = nvgpu_vidmem_get_page_alloc(mem->priv.sgt->sgl);
 
         nvgpu_sgt_for_each_sgl(sgl, &alloc->sgt) {
                 if (gk20a_last_fence)
@@ -243,7 +243,7 @@ int gk20a_gmmu_clear_vidmem_mem(struct gk20a *g, struct nvgpu_mem *mem)
         return err;
 }
 
-struct nvgpu_mem *get_pending_mem_desc(struct mm_gk20a *mm)
+struct nvgpu_mem *nvgpu_vidmem_get_pending_alloc(struct mm_gk20a *mm)
 {
         struct nvgpu_mem *mem = NULL;
 
diff --git a/drivers/gpu/nvgpu/common/pramin.c b/drivers/gpu/nvgpu/common/pramin.c
index abe5b561..b7bc7439 100644
--- a/drivers/gpu/nvgpu/common/pramin.c
+++ b/drivers/gpu/nvgpu/common/pramin.c
@@ -55,7 +55,7 @@ void nvgpu_pramin_access_batched(struct gk20a *g, struct nvgpu_mem *mem,
         if (!g->regs && nvgpu_is_enabled(g, NVGPU_DRIVER_IS_DYING))
                 return;
 
-        alloc = get_vidmem_page_alloc(mem->priv.sgt->sgl);
+        alloc = nvgpu_vidmem_get_page_alloc(mem->priv.sgt->sgl);
         sgt = &alloc->sgt;
 
         nvgpu_sgt_for_each_sgl(sgl, sgt) {