gpu: nvgpu: Move CDE code to Linux module

CDE is only used in Linux platforms, and the code is highly dependent
on Linux APIs. Move the common CDE code to Linux module and leave only
the chip specific parts to HAL.

Change-Id: I507fe7eceaf7607303dfdddcf438449a5f582ea7
Signed-off-by: Terje Bergstrom <tbergstrom@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/1554755
Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>

13 files changed, 171 insertions, 136 deletions

diff --git a/drivers/gpu/nvgpu/Makefile.nvgpu b/drivers/gpu/nvgpu/Makefile.nvgpu
index 25545f29..87199316 100644
--- a/drivers/gpu/nvgpu/Makefile.nvgpu
+++ b/drivers/gpu/nvgpu/Makefile.nvgpu
@@ -45,6 +45,7 @@ nvgpu-y := \
         common/linux/vm.o \
         common/linux/intr.o \
         common/linux/sysfs.o \
+        common/linux/cde.o \
         common/mm/nvgpu_allocator.o \
         common/mm/bitmap_allocator.o \
         common/mm/buddy_allocator.o \
@@ -92,7 +93,6 @@ nvgpu-y := \
         gk20a/ltc_gk20a.o \
         gk20a/fb_gk20a.o \
         gk20a/hal.o \
-        gk20a/cde_gk20a.o \
         gk20a/tsg_gk20a.o \
         gk20a/ctxsw_trace_gk20a.o \
         gk20a/fecs_trace_gk20a.o \
diff --git a/drivers/gpu/nvgpu/gk20a/cde_gk20a.c b/drivers/gpu/nvgpu/common/linux/cde.c
index 506207f2..5b0fb910 100644
--- a/drivers/gpu/nvgpu/gk20a/cde_gk20a.c
+++ b/drivers/gpu/nvgpu/common/linux/cde.c
@@ -31,13 +31,14 @@
 #include <nvgpu/bug.h>
 #include <nvgpu/firmware.h>
 
-#include "gk20a.h"
-#include "channel_gk20a.h"
-#include "mm_gk20a.h"
-#include "cde_gk20a.h"
-#include "fence_gk20a.h"
-#include "gr_gk20a.h"
-#include "common/linux/os_linux.h"
+#include "gk20a/gk20a.h"
+#include "gk20a/channel_gk20a.h"
+#include "gk20a/mm_gk20a.h"
+#include "gk20a/fence_gk20a.h"
+#include "gk20a/gr_gk20a.h"
+
+#include "cde.h"
+#include "os_linux.h"
 
 #include <nvgpu/hw/gk20a/hw_ccsr_gk20a.h>
 #include <nvgpu/hw/gk20a/hw_pbdma_gk20a.h>
@@ -49,7 +50,7 @@
 #include "common/linux/vm_priv.h"
 
 static int gk20a_cde_load(struct gk20a_cde_ctx *cde_ctx);
-static struct gk20a_cde_ctx *gk20a_cde_allocate_context(struct gk20a *g);
+static struct gk20a_cde_ctx *gk20a_cde_allocate_context(struct nvgpu_os_linux *l);
 
 #define CTX_DELETE_TIME 1000
 
@@ -65,7 +66,7 @@ static void gk20a_deinit_cde_img(struct gk20a_cde_ctx *cde_ctx)
                 nvgpu_dma_unmap_free(cde_ctx->vm, mem);
         }
 
-        nvgpu_kfree(cde_ctx->g, cde_ctx->init_convert_cmd);
+        nvgpu_kfree(&cde_ctx->l->g, cde_ctx->init_convert_cmd);
 
         cde_ctx->convert_cmd = NULL;
         cde_ctx->init_convert_cmd = NULL;
@@ -79,7 +80,8 @@ static void gk20a_deinit_cde_img(struct gk20a_cde_ctx *cde_ctx)
 static void gk20a_cde_remove_ctx(struct gk20a_cde_ctx *cde_ctx)
 __must_hold(&cde_app->mutex)
 {
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         struct channel_gk20a *ch = cde_ctx->ch;
         struct vm_gk20a *vm = ch->vm;
 
@@ -95,7 +97,7 @@ __must_hold(&cde_app->mutex)
 
         /* housekeeping on app */
         nvgpu_list_del(&cde_ctx->list);
-        cde_ctx->g->cde_app.ctx_count--;
+        l->cde_app.ctx_count--;
         nvgpu_kfree(g, cde_ctx);
 }
 
@@ -104,7 +106,7 @@ static void gk20a_cde_cancel_deleter(struct gk20a_cde_ctx *cde_ctx,
 __releases(&cde_app->mutex)
 __acquires(&cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &cde_ctx->g->cde_app;
+        struct gk20a_cde_app *cde_app = &cde_ctx->l->cde_app;
 
         /* permanent contexts do not have deleter works */
         if (!cde_ctx->is_temporary)
@@ -119,10 +121,10 @@ __acquires(&cde_app->mutex)
         }
 }
 
-static void gk20a_cde_remove_contexts(struct gk20a *g)
-__must_hold(&cde_app->mutex)
+static void gk20a_cde_remove_contexts(struct nvgpu_os_linux *l)
+__must_hold(&l->cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &g->cde_app;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
         struct gk20a_cde_ctx *cde_ctx, *cde_ctx_save;
 
         /* safe to go off the mutex in cancel_deleter since app is
@@ -142,38 +144,38 @@ __must_hold(&cde_app->mutex)
         }
 }
 
-static void gk20a_cde_stop(struct gk20a *g)
-__must_hold(&cde_app->mutex)
+static void gk20a_cde_stop(struct nvgpu_os_linux *l)
+__must_hold(&l->cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &g->cde_app;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
 
         /* prevent further conversions and delayed works from working */
         cde_app->initialised = false;
         /* free all data, empty the list */
-        gk20a_cde_remove_contexts(g);
+        gk20a_cde_remove_contexts(l);
 }
 
-void gk20a_cde_destroy(struct gk20a *g)
-__acquires(&cde_app->mutex)
-__releases(&cde_app->mutex)
+void gk20a_cde_destroy(struct nvgpu_os_linux *l)
+__acquires(&l->cde_app->mutex)
+__releases(&l->cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &g->cde_app;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
 
         if (!cde_app->initialised)
                 return;
 
         nvgpu_mutex_acquire(&cde_app->mutex);
-        gk20a_cde_stop(g);
+        gk20a_cde_stop(l);
         nvgpu_mutex_release(&cde_app->mutex);
 
         nvgpu_mutex_destroy(&cde_app->mutex);
 }
 
-void gk20a_cde_suspend(struct gk20a *g)
-__acquires(&cde_app->mutex)
-__releases(&cde_app->mutex)
+void gk20a_cde_suspend(struct nvgpu_os_linux *l)
+__acquires(&l->cde_app->mutex)
+__releases(&l->cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &g->cde_app;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
         struct gk20a_cde_ctx *cde_ctx, *cde_ctx_save;
 
         if (!cde_app->initialised)
@@ -195,13 +197,13 @@ __releases(&cde_app->mutex)
 
 }
 
-static int gk20a_cde_create_context(struct gk20a *g)
-__must_hold(&cde_app->mutex)
+static int gk20a_cde_create_context(struct nvgpu_os_linux *l)
+__must_hold(&l->cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &g->cde_app;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
         struct gk20a_cde_ctx *cde_ctx;
 
-        cde_ctx = gk20a_cde_allocate_context(g);
+        cde_ctx = gk20a_cde_allocate_context(l);
         if (IS_ERR(cde_ctx))
                 return PTR_ERR(cde_ctx);
 
@@ -213,21 +215,21 @@ __must_hold(&cde_app->mutex)
         return 0;
 }
 
-static int gk20a_cde_create_contexts(struct gk20a *g)
-__must_hold(&g->cde_app->mutex)
+static int gk20a_cde_create_contexts(struct nvgpu_os_linux *l)
+__must_hold(&l->cde_app->mutex)
 {
         int err;
         int i;
 
         for (i = 0; i < NUM_CDE_CONTEXTS; i++) {
-                err = gk20a_cde_create_context(g);
+                err = gk20a_cde_create_context(l);
                 if (err)
                         goto out;
         }
 
         return 0;
 out:
-        gk20a_cde_remove_contexts(g);
+        gk20a_cde_remove_contexts(l);
         return err;
 }
 
@@ -236,7 +238,8 @@ static int gk20a_init_cde_buf(struct gk20a_cde_ctx *cde_ctx,
                               struct gk20a_cde_hdr_buf *buf)
 {
         struct nvgpu_mem *mem;
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         int err;
 
         /* check that the file can hold the buf */
@@ -276,7 +279,8 @@ static int gk20a_init_cde_buf(struct gk20a_cde_ctx *cde_ctx,
 static int gk20a_replace_data(struct gk20a_cde_ctx *cde_ctx, void *target,
                               int type, s32 shift, u64 mask, u64 value)
 {
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         u32 *target_mem_ptr = target;
         u64 *target_mem_ptr_u64 = target;
         u64 current_value, new_value;
@@ -325,7 +329,8 @@ static int gk20a_init_cde_replace(struct gk20a_cde_ctx *cde_ctx,
 {
         struct nvgpu_mem *source_mem;
         struct nvgpu_mem *target_mem;
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         u32 *target_mem_ptr;
         u64 vaddr;
         int err;
@@ -373,7 +378,8 @@ static int gk20a_init_cde_replace(struct gk20a_cde_ctx *cde_ctx,
 
 static int gk20a_cde_patch_params(struct gk20a_cde_ctx *cde_ctx)
 {
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         struct nvgpu_mem *target_mem;
         u32 *target_mem_ptr;
         u64 new_data;
@@ -464,7 +470,8 @@ static int gk20a_init_cde_param(struct gk20a_cde_ctx *cde_ctx,
                                 struct gk20a_cde_hdr_param *param)
 {
         struct nvgpu_mem *target_mem;
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
 
         if (param->target_buf >= cde_ctx->num_bufs) {
                 nvgpu_warn(g, "cde: invalid buffer parameter. param idx = %d, target_buf=%u, num_bufs=%u",
@@ -506,7 +513,8 @@ static int gk20a_init_cde_required_class(struct gk20a_cde_ctx *cde_ctx,
                                          struct nvgpu_firmware *img,
                                          u32 required_class)
 {
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         struct nvgpu_alloc_obj_ctx_args alloc_obj_ctx;
         int err;
 
@@ -532,7 +540,8 @@ static int gk20a_init_cde_command(struct gk20a_cde_ctx *cde_ctx,
                                   struct gk20a_cde_cmd_elem *cmd_elem,
                                   u32 num_elems)
 {
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         struct nvgpu_gpfifo **gpfifo, *gpfifo_elem;
         u32 *num_entries;
         unsigned int i;
@@ -551,7 +560,7 @@ static int gk20a_init_cde_command(struct gk20a_cde_ctx *cde_ctx,
         }
 
         /* allocate gpfifo entries to be pushed */
-        *gpfifo = nvgpu_kzalloc(cde_ctx->g,
+        *gpfifo = nvgpu_kzalloc(g,
                                 sizeof(struct nvgpu_gpfifo) * num_elems);
         if (!*gpfifo) {
                 nvgpu_warn(g, "cde: could not allocate memory for gpfifo entries");
@@ -596,7 +605,8 @@ static int gk20a_init_cde_command(struct gk20a_cde_ctx *cde_ctx,
 
 static int gk20a_cde_pack_cmdbufs(struct gk20a_cde_ctx *cde_ctx)
 {
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         unsigned long init_bytes = cde_ctx->init_cmd_num_entries *
                 sizeof(struct nvgpu_gpfifo);
         unsigned long conv_bytes = cde_ctx->convert_cmd_num_entries *
@@ -605,7 +615,7 @@ static int gk20a_cde_pack_cmdbufs(struct gk20a_cde_ctx *cde_ctx)
         struct nvgpu_gpfifo *combined_cmd;
 
         /* allocate buffer that has space for both */
-        combined_cmd = nvgpu_kzalloc(cde_ctx->g, total_bytes);
+        combined_cmd = nvgpu_kzalloc(g, total_bytes);
         if (!combined_cmd) {
                 nvgpu_warn(g,
                         "cde: could not allocate memory for gpfifo entries");
@@ -617,8 +627,8 @@ static int gk20a_cde_pack_cmdbufs(struct gk20a_cde_ctx *cde_ctx)
         memcpy(combined_cmd + cde_ctx->init_cmd_num_entries,
                         cde_ctx->convert_cmd, conv_bytes);
 
-        nvgpu_kfree(cde_ctx->g, cde_ctx->init_convert_cmd);
-        nvgpu_kfree(cde_ctx->g, cde_ctx->convert_cmd);
+        nvgpu_kfree(g, cde_ctx->init_convert_cmd);
+        nvgpu_kfree(g, cde_ctx->convert_cmd);
 
         cde_ctx->init_convert_cmd = combined_cmd;
         cde_ctx->convert_cmd = combined_cmd
@@ -630,8 +640,9 @@ static int gk20a_cde_pack_cmdbufs(struct gk20a_cde_ctx *cde_ctx)
 static int gk20a_init_cde_img(struct gk20a_cde_ctx *cde_ctx,
                               struct nvgpu_firmware *img)
 {
-        struct gk20a *g = cde_ctx->g;
-        struct gk20a_cde_app *cde_app = &cde_ctx->g->cde_app;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
         u32 *data = (u32 *)img->data;
         u32 num_of_elems;
         struct gk20a_cde_hdr_elem *elem;
@@ -724,7 +735,8 @@ static int gk20a_cde_execute_buffer(struct gk20a_cde_ctx *cde_ctx,
                                     u32 op, struct nvgpu_fence *fence,
                                     u32 flags, struct gk20a_fence **fence_out)
 {
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         struct nvgpu_gpfifo *gpfifo = NULL;
         int num_entries = 0;
 
@@ -756,7 +768,7 @@ static void gk20a_cde_ctx_release(struct gk20a_cde_ctx *cde_ctx)
 __acquires(&cde_app->mutex)
 __releases(&cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &cde_ctx->g->cde_app;
+        struct gk20a_cde_app *cde_app = &cde_ctx->l->cde_app;
 
         gk20a_dbg(gpu_dbg_cde_ctx, "releasing use on %p", cde_ctx);
         trace_gk20a_cde_release(cde_ctx);
@@ -781,8 +793,9 @@ __releases(&cde_app->mutex)
         struct delayed_work *delay_work = to_delayed_work(work);
         struct gk20a_cde_ctx *cde_ctx = container_of(delay_work,
                         struct gk20a_cde_ctx, ctx_deleter_work);
-        struct gk20a_cde_app *cde_app = &cde_ctx->g->cde_app;
-        struct gk20a *g = cde_ctx->g;
+        struct gk20a_cde_app *cde_app = &cde_ctx->l->cde_app;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         int err;
 
         /* someone has just taken it? engine deletion started? */
@@ -823,10 +836,11 @@ out:
         gk20a_idle(g);
 }
 
-static struct gk20a_cde_ctx *gk20a_cde_do_get_context(struct gk20a *g)
+static struct gk20a_cde_ctx *gk20a_cde_do_get_context(struct nvgpu_os_linux *l)
 __must_hold(&cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &g->cde_app;
+        struct gk20a *g = &l->g;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
         struct gk20a_cde_ctx *cde_ctx;
 
         /* exhausted? */
@@ -862,7 +876,7 @@ __must_hold(&cde_app->mutex)
                         "cde: no free contexts, count=%d",
                         cde_app->ctx_count);
 
-        cde_ctx = gk20a_cde_allocate_context(g);
+        cde_ctx = gk20a_cde_allocate_context(l);
         if (IS_ERR(cde_ctx)) {
                 nvgpu_warn(g, "cde: cannot allocate context: %ld",
                                 PTR_ERR(cde_ctx));
@@ -881,11 +895,12 @@ __must_hold(&cde_app->mutex)
         return cde_ctx;
 }
 
-static struct gk20a_cde_ctx *gk20a_cde_get_context(struct gk20a *g)
+static struct gk20a_cde_ctx *gk20a_cde_get_context(struct nvgpu_os_linux *l)
 __releases(&cde_app->mutex)
 __acquires(&cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &g->cde_app;
+        struct gk20a *g = &l->g;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
         struct gk20a_cde_ctx *cde_ctx = NULL;
         struct nvgpu_timeout timeout;
 
@@ -893,7 +908,7 @@ __acquires(&cde_app->mutex)
                            NVGPU_TIMER_CPU_TIMER);
 
         do {
-                cde_ctx = gk20a_cde_do_get_context(g);
+                cde_ctx = gk20a_cde_do_get_context(l);
                 if (PTR_ERR(cde_ctx) != -EAGAIN)
                         break;
 
@@ -906,8 +921,9 @@ __acquires(&cde_app->mutex)
         return cde_ctx;
 }
 
-static struct gk20a_cde_ctx *gk20a_cde_allocate_context(struct gk20a *g)
+static struct gk20a_cde_ctx *gk20a_cde_allocate_context(struct nvgpu_os_linux *l)
 {
+        struct gk20a *g = &l->g;
         struct gk20a_cde_ctx *cde_ctx;
         int ret;
 
@@ -915,7 +931,7 @@ static struct gk20a_cde_ctx *gk20a_cde_allocate_context(struct gk20a *g)
         if (!cde_ctx)
                 return ERR_PTR(-ENOMEM);
 
-        cde_ctx->g = g;
+        cde_ctx->l = l;
         cde_ctx->dev = dev_from_gk20a(g);
 
         ret = gk20a_cde_load(cde_ctx);
@@ -935,16 +951,17 @@ static struct gk20a_cde_ctx *gk20a_cde_allocate_context(struct gk20a *g)
         return cde_ctx;
 }
 
-int gk20a_cde_convert(struct gk20a *g,
+int gk20a_cde_convert(struct nvgpu_os_linux *l,
                       struct dma_buf *compbits_scatter_buf,
                       u64 compbits_byte_offset,
                       u64 scatterbuffer_byte_offset,
                       struct nvgpu_fence *fence,
                       u32 __flags, struct gk20a_cde_param *params,
                       int num_params, struct gk20a_fence **fence_out)
-__acquires(&cde_app->mutex)
-__releases(&cde_app->mutex)
+__acquires(&l->cde_app->mutex)
+__releases(&l->cde_app->mutex)
 {
+        struct gk20a *g = &l->g;
         struct gk20a_cde_ctx *cde_ctx = NULL;
         struct gk20a_comptags comptags;
         u64 mapped_compbits_offset = 0;
@@ -972,9 +989,9 @@ __releases(&cde_app->mutex)
         if (err)
                 return err;
 
-        nvgpu_mutex_acquire(&g->cde_app.mutex);
-        cde_ctx = gk20a_cde_get_context(g);
-        nvgpu_mutex_release(&g->cde_app.mutex);
+        nvgpu_mutex_acquire(&l->cde_app.mutex);
+        cde_ctx = gk20a_cde_get_context(l);
+        nvgpu_mutex_release(&l->cde_app.mutex);
         if (IS_ERR(cde_ctx)) {
                 err = PTR_ERR(cde_ctx);
                 goto exit_idle;
@@ -1158,8 +1175,9 @@ __acquires(&cde_app->mutex)
 __releases(&cde_app->mutex)
 {
         struct gk20a_cde_ctx *cde_ctx = data;
-        struct gk20a *g = cde_ctx->g;
-        struct gk20a_cde_app *cde_app = &g->cde_app;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
         bool channel_idle;
 
         channel_gk20a_joblist_lock(ch);
@@ -1188,7 +1206,7 @@ __releases(&cde_app->mutex)
                         /* mark it to be deleted, replace with a new one */
                         nvgpu_mutex_acquire(&cde_app->mutex);
                         cde_ctx->is_temporary = true;
-                        if (gk20a_cde_create_context(g)) {
+                        if (gk20a_cde_create_context(l)) {
                                 nvgpu_err(g, "cde: can't replace context");
                         }
                         nvgpu_mutex_release(&cde_app->mutex);
@@ -1208,7 +1226,8 @@ __releases(&cde_app->mutex)
 
 static int gk20a_cde_load(struct gk20a_cde_ctx *cde_ctx)
 {
-        struct gk20a *g = cde_ctx->g;
+        struct nvgpu_os_linux *l = cde_ctx->l;
+        struct gk20a *g = &l->g;
         struct nvgpu_firmware *img;
         struct channel_gk20a *ch;
         struct gr_gk20a *gr = &g->gr;
@@ -1288,11 +1307,12 @@ err_get_gk20a_channel:
         return err;
 }
 
-int gk20a_cde_reload(struct gk20a *g)
-__acquires(&cde_app->mutex)
-__releases(&cde_app->mutex)
+int gk20a_cde_reload(struct nvgpu_os_linux *l)
+__acquires(&l->cde_app->mutex)
+__releases(&l->cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &g->cde_app;
+        struct gk20a *g = &l->g;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
         int err;
 
         if (!cde_app->initialised)
@@ -1304,9 +1324,9 @@ __releases(&cde_app->mutex)
 
         nvgpu_mutex_acquire(&cde_app->mutex);
 
-        gk20a_cde_stop(g);
+        gk20a_cde_stop(l);
 
-        err = gk20a_cde_create_contexts(g);
+        err = gk20a_cde_create_contexts(l);
         if (!err)
                 cde_app->initialised = true;
 
@@ -1316,11 +1336,11 @@ __releases(&cde_app->mutex)
         return err;
 }
 
-int gk20a_init_cde_support(struct gk20a *g)
+int gk20a_init_cde_support(struct nvgpu_os_linux *l)
 __acquires(&cde_app->mutex)
 __releases(&cde_app->mutex)
 {
-        struct gk20a_cde_app *cde_app = &g->cde_app;
+        struct gk20a_cde_app *cde_app = &l->cde_app;
         int err;
 
         if (cde_app->initialised)
@@ -1340,7 +1360,7 @@ __releases(&cde_app->mutex)
         cde_app->ctx_count_top = 0;
         cde_app->ctx_usecount = 0;
 
-        err = gk20a_cde_create_contexts(g);
+        err = gk20a_cde_create_contexts(l);
         if (!err)
                 cde_app->initialised = true;
 
@@ -1393,7 +1413,7 @@ enum cde_launch_patch_id {
 #define MAX_CDE_LAUNCH_PATCHES            32
 
 static int gk20a_buffer_convert_gpu_to_cde_v1(
-                struct gk20a *g,
+                struct nvgpu_os_linux *l,
                 struct dma_buf *dmabuf, u32 consumer,
                 u64 offset, u64 compbits_hoffset, u64 compbits_voffset,
                 u64 scatterbuffer_offset,
@@ -1401,6 +1421,7 @@ static int gk20a_buffer_convert_gpu_to_cde_v1(
                 u32 submit_flags, struct nvgpu_fence *fence_in,
                 struct gk20a_buffer_state *state)
 {
+        struct gk20a *g = &l->g;
         struct gk20a_cde_param params[MAX_CDE_LAUNCH_PATCHES];
         int param = 0;
         int err = 0;
@@ -1426,6 +1447,7 @@ static int gk20a_buffer_convert_gpu_to_cde_v1(
 
         if (g->ops.cde.get_program_numbers)
                 g->ops.cde.get_program_numbers(g, block_height_log2,
+                                               l->cde_app.shader_parameter,
                                                &hprog, &vprog);
         else {
                 nvgpu_warn(g, "cde: chip not supported");
@@ -1450,11 +1472,11 @@ static int gk20a_buffer_convert_gpu_to_cde_v1(
                   wgx, wgy, gridw_h, gridh_h, gridw_v, gridh_v);
         gk20a_dbg(gpu_dbg_cde, "hprog=%d, offset=0x%x, regs=%d, vprog=%d, offset=0x%x, regs=%d",
                   hprog,
-                  g->cde_app.arrays[ARRAY_PROGRAM_OFFSET][hprog],
-                  g->cde_app.arrays[ARRAY_REGISTER_COUNT][hprog],
+                  l->cde_app.arrays[ARRAY_PROGRAM_OFFSET][hprog],
+                  l->cde_app.arrays[ARRAY_REGISTER_COUNT][hprog],
                   vprog,
-                  g->cde_app.arrays[ARRAY_PROGRAM_OFFSET][vprog],
-                  g->cde_app.arrays[ARRAY_REGISTER_COUNT][vprog]);
+                  l->cde_app.arrays[ARRAY_PROGRAM_OFFSET][vprog],
+                  l->cde_app.arrays[ARRAY_REGISTER_COUNT][vprog]);
 
         /* Write parameters */
 #define WRITE_PATCH(NAME, VALUE) \
@@ -1483,40 +1505,40 @@ static int gk20a_buffer_convert_gpu_to_cde_v1(
         WRITE_PATCH(PATCH_V_VPC_CURRENT_GRID_SIZE_Z, 1);
 
         WRITE_PATCH(PATCH_H_QMD_PROGRAM_OFFSET,
-                g->cde_app.arrays[ARRAY_PROGRAM_OFFSET][hprog]);
+                l->cde_app.arrays[ARRAY_PROGRAM_OFFSET][hprog]);
         WRITE_PATCH(PATCH_H_QMD_REGISTER_COUNT,
-                g->cde_app.arrays[ARRAY_REGISTER_COUNT][hprog]);
+                l->cde_app.arrays[ARRAY_REGISTER_COUNT][hprog]);
         WRITE_PATCH(PATCH_V_QMD_PROGRAM_OFFSET,
-                g->cde_app.arrays[ARRAY_PROGRAM_OFFSET][vprog]);
+                l->cde_app.arrays[ARRAY_PROGRAM_OFFSET][vprog]);
         WRITE_PATCH(PATCH_V_QMD_REGISTER_COUNT,
-                g->cde_app.arrays[ARRAY_REGISTER_COUNT][vprog]);
+                l->cde_app.arrays[ARRAY_REGISTER_COUNT][vprog]);
 
         if (consumer & NVGPU_GPU_COMPBITS_CDEH) {
                 WRITE_PATCH(PATCH_H_LAUNCH_WORD1,
-                        g->cde_app.arrays[ARRAY_LAUNCH_COMMAND][0]);
+                        l->cde_app.arrays[ARRAY_LAUNCH_COMMAND][0]);
                 WRITE_PATCH(PATCH_H_LAUNCH_WORD2,
-                        g->cde_app.arrays[ARRAY_LAUNCH_COMMAND][1]);
+                        l->cde_app.arrays[ARRAY_LAUNCH_COMMAND][1]);
         } else {
                 WRITE_PATCH(PATCH_H_LAUNCH_WORD1,
-                        g->cde_app.arrays[ARRAY_LAUNCH_COMMAND][2]);
+                        l->cde_app.arrays[ARRAY_LAUNCH_COMMAND][2]);
                 WRITE_PATCH(PATCH_H_LAUNCH_WORD2,
-                        g->cde_app.arrays[ARRAY_LAUNCH_COMMAND][3]);
+                        l->cde_app.arrays[ARRAY_LAUNCH_COMMAND][3]);
         }
 
         if (consumer & NVGPU_GPU_COMPBITS_CDEV) {
                 WRITE_PATCH(PATCH_V_LAUNCH_WORD1,
-                        g->cde_app.arrays[ARRAY_LAUNCH_COMMAND][0]);
+                        l->cde_app.arrays[ARRAY_LAUNCH_COMMAND][0]);
                 WRITE_PATCH(PATCH_V_LAUNCH_WORD2,
-                        g->cde_app.arrays[ARRAY_LAUNCH_COMMAND][1]);
+                        l->cde_app.arrays[ARRAY_LAUNCH_COMMAND][1]);
         } else {
                 WRITE_PATCH(PATCH_V_LAUNCH_WORD1,
-                        g->cde_app.arrays[ARRAY_LAUNCH_COMMAND][2]);
+                        l->cde_app.arrays[ARRAY_LAUNCH_COMMAND][2]);
                 WRITE_PATCH(PATCH_V_LAUNCH_WORD2,
-                        g->cde_app.arrays[ARRAY_LAUNCH_COMMAND][3]);
+                        l->cde_app.arrays[ARRAY_LAUNCH_COMMAND][3]);
         }
 #undef WRITE_PATCH
 
-        err = gk20a_cde_convert(g, dmabuf,
+        err = gk20a_cde_convert(l, dmabuf,
                                 compbits_hoffset,
                                 scatterbuffer_offset,
                                 fence_in, submit_flags,
@@ -1534,30 +1556,31 @@ out:
 }
 
 static int gk20a_buffer_convert_gpu_to_cde(
-                struct gk20a *g, struct dma_buf *dmabuf, u32 consumer,
+                struct nvgpu_os_linux *l, struct dma_buf *dmabuf, u32 consumer,
                 u64 offset, u64 compbits_hoffset, u64 compbits_voffset,
                 u64 scatterbuffer_offset,
                 u32 width, u32 height, u32 block_height_log2,
                 u32 submit_flags, struct nvgpu_fence *fence_in,
                 struct gk20a_buffer_state *state)
 {
+        struct gk20a *g = &l->g;
         int err = 0;
 
-        if (!g->cde_app.initialised)
+        if (!l->cde_app.initialised)
                 return -ENOSYS;
 
         gk20a_dbg(gpu_dbg_cde, "firmware version = %d\n",
-                g->cde_app.firmware_version);
+                l->cde_app.firmware_version);
 
-        if (g->cde_app.firmware_version == 1) {
+        if (l->cde_app.firmware_version == 1) {
                 err = gk20a_buffer_convert_gpu_to_cde_v1(
-                    g, dmabuf, consumer, offset, compbits_hoffset,
+                    l, dmabuf, consumer, offset, compbits_hoffset,
                     compbits_voffset, scatterbuffer_offset,
                     width, height, block_height_log2,
                     submit_flags, fence_in, state);
         } else {
                 nvgpu_err(g, "unsupported CDE firmware version %d",
-                        g->cde_app.firmware_version);
+                        l->cde_app.firmware_version);
                 err = -EINVAL;
         }
 
@@ -1565,7 +1588,7 @@ static int gk20a_buffer_convert_gpu_to_cde(
 }
 
 int gk20a_prepare_compressible_read(
-                struct gk20a *g, u32 buffer_fd, u32 request, u64 offset,
+                struct nvgpu_os_linux *l, u32 buffer_fd, u32 request, u64 offset,
                 u64 compbits_hoffset, u64 compbits_voffset,
                 u64 scatterbuffer_offset,
                 u32 width, u32 height, u32 block_height_log2,
@@ -1573,6 +1596,7 @@ int gk20a_prepare_compressible_read(
                 u32 *valid_compbits, u32 *zbc_color,
                 struct gk20a_fence **fence_out)
 {
+        struct gk20a *g = &l->g;
         int err = 0;
         struct gk20a_buffer_state *state;
         struct dma_buf *dmabuf;
@@ -1606,7 +1630,7 @@ int gk20a_prepare_compressible_read(
                 if ((state->valid_compbits & NVGPU_GPU_COMPBITS_GPU) &&
                     missing_cde_bits) {
                         err = gk20a_buffer_convert_gpu_to_cde(
-                                        g, dmabuf,
+                                        l, dmabuf,
                                         missing_cde_bits,
                                         offset, compbits_hoffset,
                                         compbits_voffset, scatterbuffer_offset,
diff --git a/drivers/gpu/nvgpu/gk20a/cde_gk20a.h b/drivers/gpu/nvgpu/common/linux/cde.h
index 4f400bf3..22732a2a 100644
--- a/drivers/gpu/nvgpu/gk20a/cde_gk20a.h
+++ b/drivers/gpu/nvgpu/common/linux/cde.h
@@ -19,8 +19,6 @@
 #ifndef _CDE_GK20A_H_
 #define _CDE_GK20A_H_
 
-#include "mm_gk20a.h"
-
 #define MAX_CDE_BUFS            10
 #define MAX_CDE_PARAMS          64
 #define MAX_CDE_USER_PARAMS     40
@@ -214,7 +212,7 @@ struct gk20a_cde_param {
 };
 
 struct gk20a_cde_ctx {
-        struct gk20a *g;
+        struct nvgpu_os_linux *l;
         struct device *dev;
 
         /* channel related data */
@@ -284,11 +282,11 @@ struct gk20a_cde_app {
         u32 shader_parameter;
 };
 
-void gk20a_cde_destroy(struct gk20a *g);
-void gk20a_cde_suspend(struct gk20a *g);
-int gk20a_init_cde_support(struct gk20a *g);
-int gk20a_cde_reload(struct gk20a *g);
-int gk20a_cde_convert(struct gk20a *g,
+void gk20a_cde_destroy(struct nvgpu_os_linux *l);
+void gk20a_cde_suspend(struct nvgpu_os_linux *l);
+int gk20a_init_cde_support(struct nvgpu_os_linux *l);
+int gk20a_cde_reload(struct nvgpu_os_linux *l);
+int gk20a_cde_convert(struct nvgpu_os_linux *l,
                 struct dma_buf *compbits_buf,
                 u64 compbits_byte_offset,
                 u64 scatterbuffer_byte_offset,
@@ -297,7 +295,7 @@ int gk20a_cde_convert(struct gk20a *g,
                 int num_params, struct gk20a_fence **fence_out);
 
 int gk20a_prepare_compressible_read(
-                struct gk20a *g, u32 buffer_fd, u32 request, u64 offset,
+                struct nvgpu_os_linux *l, u32 buffer_fd, u32 request, u64 offset,
                 u64 compbits_hoffset, u64 compbits_voffset,
                 u64 scatterbuffer_offset,
                 u32 width, u32 height, u32 block_height_log2,
diff --git a/drivers/gpu/nvgpu/common/linux/debug_cde.c b/drivers/gpu/nvgpu/common/linux/debug_cde.c
index 40cc64a4..cbea83b9 100644
--- a/drivers/gpu/nvgpu/common/linux/debug_cde.c
+++ b/drivers/gpu/nvgpu/common/linux/debug_cde.c
@@ -22,8 +22,8 @@
 static ssize_t gk20a_cde_reload_write(struct file *file,
         const char __user *userbuf, size_t count, loff_t *ppos)
 {
-        struct gk20a *g = file->private_data;
-        gk20a_cde_reload(g);
+        struct nvgpu_os_linux *l = file->private_data;
+        gk20a_cde_reload(l);
         return count;
 }
 
@@ -41,13 +41,13 @@ void gk20a_cde_debugfs_init(struct gk20a *g)
                 return;
 
         debugfs_create_u32("cde_parameter", S_IWUSR | S_IRUGO,
-                           l->debugfs, &g->cde_app.shader_parameter);
+                           l->debugfs, &l->cde_app.shader_parameter);
         debugfs_create_u32("cde_ctx_count", S_IWUSR | S_IRUGO,
-                           l->debugfs, &g->cde_app.ctx_count);
+                           l->debugfs, &l->cde_app.ctx_count);
         debugfs_create_u32("cde_ctx_usecount", S_IWUSR | S_IRUGO,
-                           l->debugfs, &g->cde_app.ctx_usecount);
+                           l->debugfs, &l->cde_app.ctx_usecount);
         debugfs_create_u32("cde_ctx_count_top", S_IWUSR | S_IRUGO,
-                           l->debugfs, &g->cde_app.ctx_count_top);
+                           l->debugfs, &l->cde_app.ctx_count_top);
         debugfs_create_file("reload_cde_firmware", S_IWUSR, l->debugfs,
-                            g, &gk20a_cde_reload_fops);
+                            l, &gk20a_cde_reload_fops);
 }
diff --git a/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c b/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c
index 0d79b143..0357f098 100644
--- a/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c
+++ b/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c
@@ -138,6 +138,7 @@ static int gk20a_ctrl_prepare_compressible_read(
                 struct gk20a *g,
                 struct nvgpu_gpu_prepare_compressible_read_args *args)
 {
+        struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
         struct nvgpu_fence fence;
         struct gk20a_fence *fence_out = NULL;
         int ret = 0;
@@ -146,7 +147,7 @@ static int gk20a_ctrl_prepare_compressible_read(
         fence.id = args->fence.syncpt_id;
         fence.value = args->fence.syncpt_value;
 
-        ret = gk20a_prepare_compressible_read(g, args->handle,
+        ret = gk20a_prepare_compressible_read(l, args->handle,
                         args->request_compbits, args->offset,
                         args->compbits_hoffset, args->compbits_voffset,
                         args->scatterbuffer_offset,
diff --git a/drivers/gpu/nvgpu/common/linux/module.c b/drivers/gpu/nvgpu/common/linux/module.c
index 6a590baa..509930c7 100644
--- a/drivers/gpu/nvgpu/common/linux/module.c
+++ b/drivers/gpu/nvgpu/common/linux/module.c
@@ -39,6 +39,7 @@
 #include "pci.h"
 #include "module.h"
 #include "intr.h"
+#include "cde.h"
 #ifdef CONFIG_TEGRA_19x_GPU
 #include "nvgpu_gpuid_t19x.h"
 #ifdef CONFIG_TEGRA_GR_VIRTUALIZATION
@@ -185,7 +186,7 @@ int gk20a_pm_finalize_poweron(struct device *dev)
         gk20a_scale_resume(dev_from_gk20a(g));
 
         if (platform->has_cde)
-                gk20a_init_cde_support(g);
+                gk20a_init_cde_support(l);
 
 done:
         if (err)
@@ -197,6 +198,7 @@ done:
 static int gk20a_pm_prepare_poweroff(struct device *dev)
 {
         struct gk20a *g = get_gk20a(dev);
+        struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
         int ret = 0;
         struct gk20a_platform *platform = gk20a_get_platform(dev);
 
@@ -207,8 +209,15 @@ static int gk20a_pm_prepare_poweroff(struct device *dev)
         if (!g->power_on)
                 goto done;
 
+        if (gk20a_fifo_is_engine_busy(g)) {
+                ret = -EBUSY;
+                goto done;
+        }
+
         gk20a_scale_suspend(dev);
 
+        gk20a_cde_suspend(l);
+
         ret = gk20a_prepare_poweroff(g);
         if (ret)
                 goto error;
@@ -974,6 +983,7 @@ static int __exit gk20a_remove(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         struct gk20a *g = get_gk20a(dev);
+        struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
         struct gk20a_platform *platform = gk20a_get_platform(dev);
 
         gk20a_dbg_fn("");
@@ -982,7 +992,7 @@ static int __exit gk20a_remove(struct platform_device *pdev)
                 return vgpu_remove(pdev);
 
         if (platform->has_cde)
-                gk20a_cde_destroy(g);
+                gk20a_cde_destroy(l);
 
         gk20a_ctxsw_trace_cleanup(g);
 
diff --git a/drivers/gpu/nvgpu/common/linux/os_linux.h b/drivers/gpu/nvgpu/common/linux/os_linux.h
index ed8364a9..160a5738 100644
--- a/drivers/gpu/nvgpu/common/linux/os_linux.h
+++ b/drivers/gpu/nvgpu/common/linux/os_linux.h
@@ -19,6 +19,7 @@
 #include <linux/cdev.h>
 
 #include "gk20a/gk20a.h"
+#include "cde.h"
 
 struct nvgpu_os_linux {
         struct gk20a g;
@@ -108,6 +109,7 @@ struct nvgpu_os_linux {
         struct dentry *debugfs_force_preemption_gfxp;
         struct dentry *debugfs_dump_ctxsw_stats;
 #endif
+        struct gk20a_cde_app cde_app;
 };
 
 static inline struct nvgpu_os_linux *nvgpu_os_linux_from_gk20a(struct gk20a *g)
diff --git a/drivers/gpu/nvgpu/gk20a/gk20a.c b/drivers/gpu/nvgpu/gk20a/gk20a.c
index 0cd314d6..63ea5bc4 100644
--- a/drivers/gpu/nvgpu/gk20a/gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/gk20a.c
@@ -117,9 +117,6 @@ int gk20a_prepare_poweroff(struct gk20a *g)
         if (gk20a_fifo_is_engine_busy(g))
                 return -EBUSY;
 
-        /* cancel any pending cde work */
-        gk20a_cde_suspend(g);
-
         gk20a_ce_suspend(g);
 
         ret = gk20a_channel_suspend(g);
diff --git a/drivers/gpu/nvgpu/gk20a/gk20a.h b/drivers/gpu/nvgpu/gk20a/gk20a.h
index ab715bdc..69cb2253 100644
--- a/drivers/gpu/nvgpu/gk20a/gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/gk20a.h
@@ -60,7 +60,6 @@ struct nvgpu_cpu_time_correlation_sample;
 #include "pmu_gk20a.h"
 #include "priv_ring_gk20a.h"
 #include "therm_gk20a.h"
-#include "cde_gk20a.h"
 #include "sched_gk20a.h"
 #ifdef CONFIG_ARCH_TEGRA_18x_SOC
 #include "clk/clk.h"
@@ -928,6 +927,7 @@ struct gpu_ops {
         struct {
                 void (*get_program_numbers)(struct gk20a *g,
                                             u32 block_height_log2,
+                                            u32 shader_parameter,
                                             int *hprog, int *vprog);
                 bool (*need_scatter_buffer)(struct gk20a *g);
                 int (*populate_scatter_buffer)(struct gk20a *g,
@@ -1217,7 +1217,6 @@ struct gk20a {
 
         struct gk20a_sched_ctrl sched_ctrl;
 
-        struct gk20a_cde_app cde_app;
         bool mmu_debug_ctrl;
 
         u32 tpc_fs_mask_user;
diff --git a/drivers/gpu/nvgpu/gm20b/cde_gm20b.c b/drivers/gpu/nvgpu/gm20b/cde_gm20b.c
index f8267d1d..de7cf872 100644
--- a/drivers/gpu/nvgpu/gm20b/cde_gm20b.c
+++ b/drivers/gpu/nvgpu/gm20b/cde_gm20b.c
@@ -28,15 +28,16 @@ enum programs {
 
 void gm20b_cde_get_program_numbers(struct gk20a *g,
                                           u32 block_height_log2,
+                                          u32 shader_parameter,
                                           int *hprog_out, int *vprog_out)
 {
         int hprog = PROG_HPASS;
         int vprog = (block_height_log2 >= 2) ?
                 PROG_VPASS_LARGE : PROG_VPASS_SMALL;
-        if (g->cde_app.shader_parameter == 1) {
+        if (shader_parameter == 1) {
                 hprog = PROG_PASSTHROUGH;
                 vprog = PROG_PASSTHROUGH;
-        } else if (g->cde_app.shader_parameter == 2) {
+        } else if (shader_parameter == 2) {
                 hprog = PROG_HPASS_DEBUG;
                 vprog = (block_height_log2 >= 2) ?
                         PROG_VPASS_LARGE_DEBUG :
diff --git a/drivers/gpu/nvgpu/gm20b/cde_gm20b.h b/drivers/gpu/nvgpu/gm20b/cde_gm20b.h
index f2ea20a0..0ea423ad 100644
--- a/drivers/gpu/nvgpu/gm20b/cde_gm20b.h
+++ b/drivers/gpu/nvgpu/gm20b/cde_gm20b.h
@@ -20,6 +20,7 @@ struct gk20a;
 
 void gm20b_cde_get_program_numbers(struct gk20a *g,
                                           u32 block_height_log2,
+                                          u32 shader_parameter,
                                           int *hprog_out, int *vprog_out);
 
 #endif
diff --git a/drivers/gpu/nvgpu/gp10b/cde_gp10b.c b/drivers/gpu/nvgpu/gp10b/cde_gp10b.c
index 685ddbc4..1ddbcba6 100644
--- a/drivers/gpu/nvgpu/gp10b/cde_gp10b.c
+++ b/drivers/gpu/nvgpu/gp10b/cde_gp10b.c
@@ -32,17 +32,18 @@ enum gp10b_programs {
 
 void gp10b_cde_get_program_numbers(struct gk20a *g,
                                           u32 block_height_log2,
+                                          u32 shader_parameter,
                                           int *hprog_out, int *vprog_out)
 {
         int hprog, vprog;
 
-        if (g->cde_app.shader_parameter == 1) {
+        if (shader_parameter == 1) {
                 hprog = GP10B_PROG_PASSTHROUGH;
                 vprog = GP10B_PROG_PASSTHROUGH;
         } else {
                 hprog = GP10B_PROG_HPASS;
                 vprog = GP10B_PROG_VPASS;
-                if (g->cde_app.shader_parameter == 2) {
+                if (shader_parameter == 2) {
                         hprog = GP10B_PROG_HPASS_DEBUG;
                         vprog = GP10B_PROG_VPASS_DEBUG;
                 }
diff --git a/drivers/gpu/nvgpu/gp10b/cde_gp10b.h b/drivers/gpu/nvgpu/gp10b/cde_gp10b.h
index 3ee6027c..7ccfe560 100644
--- a/drivers/gpu/nvgpu/gp10b/cde_gp10b.h
+++ b/drivers/gpu/nvgpu/gp10b/cde_gp10b.h
@@ -21,6 +21,7 @@ struct sg_table;
 
 void gp10b_cde_get_program_numbers(struct gk20a *g,
                                           u32 block_height_log2,
+                                          u32 shader_parameter,
                                           int *hprog_out, int *vprog_out);
 bool gp10b_need_scatter_buffer(struct gk20a *g);
 int gp10b_populate_scatter_buffer(struct gk20a *g,