3 files changed, 43 insertions, 133 deletions

diff --git a/drivers/gpu/nvgpu/common/linux/ioctl_as.c b/drivers/gpu/nvgpu/common/linux/ioctl_as.c
index 8a5318e4..f23dc53c 100644
--- a/drivers/gpu/nvgpu/common/linux/ioctl_as.c
+++ b/drivers/gpu/nvgpu/common/linux/ioctl_as.c
@@ -79,22 +79,19 @@ static int gk20a_as_ioctl_map_buffer_ex(
                 struct gk20a_as_share *as_share,
                 struct nvgpu_as_map_buffer_ex_args *args)
 {
-        s16 compressible_kind;
-        s16 incompressible_kind;
-
         gk20a_dbg_fn("");
 
-        if (args->flags & NVGPU_AS_MAP_BUFFER_FLAGS_DIRECT_KIND_CTRL) {
-                compressible_kind = args->compr_kind;
-                incompressible_kind = args->incompr_kind;
-        } else {
-                /* unsupported, direct kind control must be used */
+        /* unsupported, direct kind control must be used */
+        if (!(args->flags & NVGPU_AS_MAP_BUFFER_FLAGS_DIRECT_KIND_CTRL)) {
+                struct gk20a *g = as_share->vm->mm->g;
+                nvgpu_log_info(g, "Direct kind control must be requested");
                 return -EINVAL;
         }
 
         return nvgpu_vm_map_buffer(as_share->vm, args->dmabuf_fd,
                                    &args->offset, args->flags,
-                                   compressible_kind, incompressible_kind,
+                                   args->compr_kind,
+                                   args->incompr_kind,
                                    args->buffer_offset,
                                    args->mapping_size,
                                    NULL);
diff --git a/drivers/gpu/nvgpu/common/linux/vm.c b/drivers/gpu/nvgpu/common/linux/vm.c
index 0cfd010b..895a5771 100644
--- a/drivers/gpu/nvgpu/common/linux/vm.c
+++ b/drivers/gpu/nvgpu/common/linux/vm.c
@@ -32,7 +32,6 @@
 
 #include "gk20a/gk20a.h"
 #include "gk20a/mm_gk20a.h"
-#include "gk20a/kind_gk20a.h"
 
 #include "platform_gk20a.h"
 #include "os_linux.h"
@@ -239,14 +238,17 @@ int nvgpu_vm_map_linux(struct vm_gk20a *vm,
 
         binfo.flags = flags;
         binfo.size = dmabuf->size;
+        binfo.compr_kind = compr_kind;
+        binfo.incompr_kind = incompr_kind;
 
-        if (flags & NVGPU_AS_MAP_BUFFER_FLAGS_DIRECT_KIND_CTRL) {
-                if (compr_kind != NV_KIND_INVALID)
-                        map_key_kind = compr_kind;
-                else
-                        map_key_kind = incompr_kind;
-        } else {
+        if (compr_kind != NV_KIND_INVALID)
                 map_key_kind = compr_kind;
+        else
+                map_key_kind = incompr_kind;
+
+        if (map_key_kind == NV_KIND_INVALID) {
+                nvgpu_err(g, "Valid kind must be supplied");
+                return -EINVAL;
         }
 
         if (vm->userspace_managed &&
@@ -277,10 +279,6 @@ int nvgpu_vm_map_linux(struct vm_gk20a *vm,
                 goto clean_up;
         }
 
-        err = nvgpu_vm_init_kind_info(&binfo, compr_kind, incompr_kind);
-        if (err)
-                goto clean_up;
-
         aperture = gk20a_dmabuf_aperture(g, dmabuf);
         if (aperture == APERTURE_INVALID) {
                 err = -EINVAL;
@@ -321,9 +319,9 @@ int nvgpu_vm_map_linux(struct vm_gk20a *vm,
                 va_allocated = true;
         }
 
-        err = nvgpu_vm_compute_kind_and_compression(vm, &binfo);
+        err = nvgpu_vm_compute_compression(vm, &binfo);
         if (err) {
-                nvgpu_err(g, "failure setting up kind and compression");
+                nvgpu_err(g, "failure setting up compression");
                 goto clean_up;
         }
 
@@ -340,10 +338,12 @@ int nvgpu_vm_map_linux(struct vm_gk20a *vm,
                                            binfo.ctag_lines);
                 if (err) {
                         /* TBD: we can partially alloc ctags as well... */
-                        if (binfo.use_uc_kind_v) {
-                                /* no comptags, but fallback kind available */
-                                binfo.kind_v = binfo.uc_kind_v;
-                        } else {
+
+                        /* prevent compression ... */
+                        binfo.compr_kind = NV_KIND_INVALID;
+
+                        /* ... and make sure we have the fallback */
+                        if (binfo.incompr_kind == NV_KIND_INVALID) {
                                 nvgpu_err(g, "comptag alloc failed and no fallback kind specified");
                                 goto clean_up;
                         }
@@ -379,7 +379,8 @@ int nvgpu_vm_map_linux(struct vm_gk20a *vm,
                                         buffer_offset, /* sg offset */
                                         mapping_size,
                                         binfo.pgsz_idx,
-                                        binfo.kind_v,
+                                        (binfo.compr_kind != NV_KIND_INVALID ?
+                                         binfo.compr_kind : binfo.incompr_kind),
                                         ctag_offset,
                                         flags, rw_flag,
                                         clear_ctags,
diff --git a/drivers/gpu/nvgpu/common/mm/vm.c b/drivers/gpu/nvgpu/common/mm/vm.c
index 64c9c217..46783e4e 100644
--- a/drivers/gpu/nvgpu/common/mm/vm.c
+++ b/drivers/gpu/nvgpu/common/mm/vm.c
@@ -35,7 +35,6 @@
 
 #include "gk20a/gk20a.h"
 #include "gk20a/mm_gk20a.h"
-#include "gk20a/kind_gk20a.h"
 
 static void __nvgpu_vm_unmap(struct nvgpu_mapped_buf *mapped_buffer,
                              struct vm_gk20a_mapping_batch *batch);
@@ -829,123 +828,36 @@ done:
         return;
 }
 
-int nvgpu_vm_init_kind_info(struct nvgpu_ctag_buffer_info *binfo,
-                            s16 compr_kind, s16 incompr_kind)
-{
-        if (binfo->flags & NVGPU_AS_MAP_BUFFER_FLAGS_DIRECT_KIND_CTRL) {
-                /* were we supplied with a kind in either parameter? */
-                if ((compr_kind < 0 || compr_kind >= NV_KIND_ATTR_SIZE) &&
-                    (incompr_kind < 0 || incompr_kind >= NV_KIND_ATTR_SIZE))
-                        return -EINVAL;
-
-                if (compr_kind != NV_KIND_INVALID) {
-                        binfo->use_kind_v = true;
-                        binfo->kind_v = (u8)compr_kind;
-                }
-
-                if (incompr_kind != NV_KIND_INVALID) {
-                        binfo->use_uc_kind_v = true;
-                        binfo->uc_kind_v = (u8)incompr_kind;
-                }
-        } else {
-                if (compr_kind < 0 || compr_kind >= NV_KIND_ATTR_SIZE)
-                        return -EINVAL;
-
-                binfo->use_kind_v = true;
-                binfo->kind_v = (u8)compr_kind;
-
-                /*
-                 * Note: nvgpu_vm_kind_and_compression() will figure out
-                 * uc_kind_v or return an error.
-                 */
-        }
-
-        return 0;
-}
-
-static int nvgpu_vm_setup_kind_legacy(struct vm_gk20a *vm,
-                                      struct nvgpu_ctag_buffer_info *binfo,
-                                      bool *pkind_compressible)
+int nvgpu_vm_compute_compression(struct vm_gk20a *vm,
+                                 struct nvgpu_ctag_buffer_info *binfo)
 {
-        struct gk20a *g = gk20a_from_vm(vm);
-        bool kind_compressible;
-
-        if (unlikely(binfo->kind_v == g->ops.mm.get_kind_invalid()))
-                binfo->kind_v = g->ops.mm.get_kind_pitch();
-
-        if (unlikely(!gk20a_kind_is_supported(binfo->kind_v))) {
-                nvgpu_err(g, "kind 0x%x not supported", binfo->kind_v);
-                return -EINVAL;
-        }
-
-        binfo->uc_kind_v = g->ops.mm.get_kind_invalid();
-
-        /*
-         * Find a suitable incompressible kind if it becomes necessary later.
-         */
-        kind_compressible = gk20a_kind_is_compressible(binfo->kind_v);
-        if (kind_compressible) {
-                binfo->uc_kind_v = gk20a_get_uncompressed_kind(binfo->kind_v);
-                if (binfo->uc_kind_v == g->ops.mm.get_kind_invalid()) {
-                        /*
-                         * Shouldn't happen, but it is worth cross-checking.
-                         */
-                        nvgpu_err(g, "comptag kind 0x%x can't be"
-                                  " downgraded to uncompressed kind",
-                                  binfo->kind_v);
-                        return -EINVAL;
-                }
-        }
-
-        *pkind_compressible = kind_compressible;
-
-        return 0;
-}
-
-int nvgpu_vm_compute_kind_and_compression(struct vm_gk20a *vm,
-                                          struct nvgpu_ctag_buffer_info *binfo)
-{
-        bool kind_compressible;
+        bool kind_compressible = (binfo->compr_kind != NV_KIND_INVALID);
         struct gk20a *g = gk20a_from_vm(vm);
         int ctag_granularity = g->ops.fb.compression_page_size(g);
 
-        if (!binfo->use_kind_v)
-                binfo->kind_v = g->ops.mm.get_kind_invalid();
-        if (!binfo->use_uc_kind_v)
-                binfo->uc_kind_v = g->ops.mm.get_kind_invalid();
-
-        if (binfo->flags & NVGPU_AS_MAP_BUFFER_FLAGS_DIRECT_KIND_CTRL) {
-                kind_compressible = (binfo->kind_v !=
-                                     g->ops.mm.get_kind_invalid());
-                if (!kind_compressible)
-                        binfo->kind_v = binfo->uc_kind_v;
-        } else {
-                int err = nvgpu_vm_setup_kind_legacy(vm, binfo,
-                                                     &kind_compressible);
-
-                if (err)
-                        return err;
-        }
-
-        /* comptags only supported for suitable kinds, 128KB pagesize */
         if (kind_compressible &&
             vm->gmmu_page_sizes[binfo->pgsz_idx] <
             g->ops.fb.compressible_page_size(g)) {
-                /* it is safe to fall back to uncompressed as
-                   functionality is not harmed */
-                binfo->kind_v = binfo->uc_kind_v;
-                kind_compressible = false;
+                /*
+                 * Let's double check that there is a fallback kind
+                 */
+                if (binfo->incompr_kind == NV_KIND_INVALID) {
+                        nvgpu_err(g,
+                                  "Unsupported page size for compressible "
+                                  "kind, but no fallback kind");
+                        return -EINVAL;
+                } else {
+                        nvgpu_log(g, gpu_dbg_map,
+                                  "Unsupported page size for compressible "
+                                  "kind, demoting to incompressible");
+                        binfo->compr_kind = NV_KIND_INVALID;
+                        kind_compressible = false;
+                }
         }
 
         if (kind_compressible)
                 binfo->ctag_lines = DIV_ROUND_UP_ULL(binfo->size,
                                                      ctag_granularity);
-        else
-                binfo->ctag_lines = 0;
-
-        binfo->use_kind_v = (binfo->kind_v != g->ops.mm.get_kind_invalid());
-        binfo->use_uc_kind_v = (binfo->uc_kind_v !=
-                                g->ops.mm.get_kind_invalid());
 
         return 0;
 }