gpu: nvgpu: Direct GMMU PTE kind control

Allow userspace to control directly the PTE kind for the mappings by
supplying NVGPU_AS_MAP_BUFFER_FLAGS_DIRECT_KIND_CTRL for MAP_BUFFER_EX.

In particular, in this mode, the userspace will tell the kernel
whether the kind is compressible, and if so, what is the
incompressible fallback kind. By supplying only the compressible kind,
the userspace can require that the map kind will not be demoted to the
incompressible fallback kind in case of comptag allocation failure.

Add also a GPU characteristics flag
NVGPU_GPU_FLAGS_SUPPORT_MAP_DIRECT_KIND_CTRL to signal whether direct
kind control is supported.

Fix indentation of nvgpu_as_map_buffer_ex_args header comment.

Bug 1705731

Change-Id: I317ab474ae53b78eb8fdd31bd6bca0541fcba9a4
Signed-off-by: Sami Kiminki <skiminki@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/1543462
Reviewed-by: svc-mobile-coverity <svc-mobile-coverity@nvidia.com>
Reviewed-by: Konsta Holtta <kholtta@nvidia.com>
Reviewed-by: Automatic_Commit_Validation_User
GVS: Gerrit_Virtual_Submit
Reviewed-by: Alex Waterman <alexw@nvidia.com>
Reviewed-by: svccoveritychecker <svccoveritychecker@nvidia.com>
Reviewed-by: Terje Bergstrom <tbergstrom@nvidia.com>

3 files changed, 43 insertions, 10 deletions

diff --git a/drivers/gpu/nvgpu/gk20a/dbg_gpu_gk20a.c b/drivers/gpu/nvgpu/gk20a/dbg_gpu_gk20a.c
index 19433df9..2b37a62a 100644
--- a/drivers/gpu/nvgpu/gk20a/dbg_gpu_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/dbg_gpu_gk20a.c
@@ -1929,6 +1929,7 @@ static int gk20a_perfbuf_map(struct dbg_session_gk20a *dbg_s,
                         0,
                         0,
                         0,
+                        0,
                         args->mapping_size,
                         NULL);
         if (err)
diff --git a/drivers/gpu/nvgpu/gk20a/gk20a.c b/drivers/gpu/nvgpu/gk20a/gk20a.c
index 455fa238..e9948c16 100644
--- a/drivers/gpu/nvgpu/gk20a/gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/gk20a.c
@@ -411,7 +411,8 @@ int gk20a_init_gpu_characteristics(struct gk20a *g)
                         gpu->available_big_page_sizes |= g->ops.mm.get_big_page_sizes();
         }
 
-        gpu->flags = NVGPU_GPU_FLAGS_SUPPORT_PARTIAL_MAPPINGS;
+        gpu->flags = NVGPU_GPU_FLAGS_SUPPORT_PARTIAL_MAPPINGS |
+                NVGPU_GPU_FLAGS_SUPPORT_MAP_DIRECT_KIND_CTRL;
 
         if (IS_ENABLED(CONFIG_SYNC))
                 gpu->flags |= NVGPU_GPU_FLAGS_SUPPORT_SYNC_FENCE_FDS;
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
index a6507d2d..97b7aa80 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
@@ -822,14 +822,11 @@ static void nvgpu_vm_unmap_user(struct vm_gk20a *vm, u64 offset,
         nvgpu_mutex_release(&vm->update_gmmu_lock);
 }
 
-int setup_buffer_kind_and_compression(struct vm_gk20a *vm,
-                                      u32 flags,
-                                      struct buffer_attrs *bfr,
-                                      enum gmmu_pgsz_gk20a pgsz_idx)
+static int setup_kind_legacy(struct vm_gk20a *vm, struct buffer_attrs *bfr,
+                             bool *pkind_compressible)
 {
-        bool kind_compressible;
         struct gk20a *g = gk20a_from_vm(vm);
-        int ctag_granularity = g->ops.fb.compression_page_size(g);
+        bool kind_compressible;
 
         if (unlikely(bfr->kind_v == gmmu_pte_kind_invalid_v()))
                 bfr->kind_v = gmmu_pte_kind_pitch_v();
@@ -840,7 +837,7 @@ int setup_buffer_kind_and_compression(struct vm_gk20a *vm,
         }
 
         bfr->uc_kind_v = gmmu_pte_kind_invalid_v();
-        /* find a suitable uncompressed kind if it becomes necessary later */
+        /* find a suitable incompressible kind if it becomes necessary later */
         kind_compressible = gk20a_kind_is_compressible(bfr->kind_v);
         if (kind_compressible) {
                 bfr->uc_kind_v = gk20a_get_uncompressed_kind(bfr->kind_v);
@@ -852,6 +849,36 @@ int setup_buffer_kind_and_compression(struct vm_gk20a *vm,
                         return -EINVAL;
                 }
         }
+
+        *pkind_compressible = kind_compressible;
+        return 0;
+}
+
+int setup_buffer_kind_and_compression(struct vm_gk20a *vm,
+                                      u32 flags,
+                                      struct buffer_attrs *bfr,
+                                      enum gmmu_pgsz_gk20a pgsz_idx)
+{
+        bool kind_compressible;
+        struct gk20a *g = gk20a_from_vm(vm);
+        int ctag_granularity = g->ops.fb.compression_page_size(g);
+
+        if (!bfr->use_kind_v)
+                bfr->kind_v = gmmu_pte_kind_invalid_v();
+        if (!bfr->use_uc_kind_v)
+                bfr->uc_kind_v = gmmu_pte_kind_invalid_v();
+
+        if (flags & NVGPU_AS_MAP_BUFFER_FLAGS_DIRECT_KIND_CTRL) {
+                kind_compressible = (bfr->kind_v != gmmu_pte_kind_invalid_v());
+                if (!kind_compressible)
+                        bfr->kind_v = bfr->uc_kind_v;
+        } else {
+                int err = setup_kind_legacy(vm, bfr, &kind_compressible);
+
+                if (err)
+                        return err;
+        }
+
         /* comptags only supported for suitable kinds, 128KB pagesize */
         if (kind_compressible &&
             vm->gmmu_page_sizes[pgsz_idx] < g->ops.fb.compressible_page_size(g)) {
@@ -865,6 +892,9 @@ int setup_buffer_kind_and_compression(struct vm_gk20a *vm,
         else
                 bfr->ctag_lines = 0;
 
+        bfr->use_kind_v = (bfr->kind_v != gmmu_pte_kind_invalid_v());
+        bfr->use_uc_kind_v = (bfr->uc_kind_v != gmmu_pte_kind_invalid_v());
+
         return 0;
 }
 
@@ -1649,7 +1679,8 @@ int nvgpu_vm_map_buffer(struct vm_gk20a *vm,
                         int dmabuf_fd,
                         u64 *offset_align,
                         u32 flags, /*NVGPU_AS_MAP_BUFFER_FLAGS_*/
-                        int kind,
+                        s16 compr_kind,
+                        s16 incompr_kind,
                         u64 buffer_offset,
                         u64 mapping_size,
                         struct vm_gk20a_mapping_batch *batch)
@@ -1690,7 +1721,7 @@ int nvgpu_vm_map_buffer(struct vm_gk20a *vm,
         }
 
         ret_va = nvgpu_vm_map(vm, dmabuf, *offset_align,
-                        flags, kind, true,
+                        flags, compr_kind, incompr_kind, true,
                         gk20a_mem_flag_none,
                         buffer_offset,
                         mapping_size,