19 files changed, 365 insertions, 114 deletions

diff --git a/drivers/gpu/nvgpu/Makefile b/drivers/gpu/nvgpu/Makefile
index f3e2c29d..6b3c9e16 100644
--- a/drivers/gpu/nvgpu/Makefile
+++ b/drivers/gpu/nvgpu/Makefile
@@ -8,6 +8,7 @@ ccflags-y += -I../nvgpu/include/uapi
 ccflags-y += -Wno-multichar
 ccflags-y += -Werror
 ccflags-y += -Wno-error=cpp
+ccflags-y += -Wno-duplicate-decl-specifier
 
 ifeq ($(CONFIG_ARCH_TEGRA_18x_SOC),y)
 ccflags-y += -I$(srctree)/../nvgpu-t18x/drivers/gpu/nvgpu
diff --git a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
index f70c4bb7..a73a314c 100644
--- a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
@@ -2081,7 +2081,6 @@ int gk20a_submit_channel_gpfifo(struct channel_gk20a *c,
         }
 
         if (err) {
-                gk20a_err(d, "timeout waiting for gpfifo space");
                 err = -ENOSPC;
                 goto clean_up;
         }
@@ -2279,7 +2278,7 @@ int gk20a_submit_channel_gpfifo(struct channel_gk20a *c,
         return err;
 
 clean_up:
-        gk20a_err(d, "fail");
+        gk20a_dbg_fn("fail");
         free_priv_cmdbuf(c, wait_cmd);
         free_priv_cmdbuf(c, incr_cmd);
         gk20a_fence_put(pre_fence);
diff --git a/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c
index 011c980e..10f1213b 100644
--- a/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c
@@ -204,11 +204,8 @@ static int __gk20a_channel_syncpt_incr(struct gk20a_channel_sync *s,
                 incr_cmd_size += 2;
 
         err = gk20a_channel_alloc_priv_cmdbuf(c, incr_cmd_size, &incr_cmd);
-        if (err) {
-                gk20a_err(dev_from_gk20a(c->g),
-                                "not enough priv cmd buffer space");
+        if (err)
                 return err;
-        }
 
         off = incr_cmd->off;
 
diff --git a/drivers/gpu/nvgpu/gk20a/css_gr_gk20a.c b/drivers/gpu/nvgpu/gk20a/css_gr_gk20a.c
index 2008289b..1d05c902 100644
--- a/drivers/gpu/nvgpu/gk20a/css_gr_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/css_gr_gk20a.c
@@ -662,6 +662,10 @@ int gr_gk20a_css_attach(struct gk20a *g,
         if (!cs_client)
                 return -EINVAL;
 
+        if (!perfmon_count ||
+            perfmon_count > CSS_MAX_PERFMON_IDS - CSS_FIRST_PERFMON_ID)
+                return -EINVAL;
+
         gr = &g->gr;
         *cs_client = NULL;
 
diff --git a/drivers/gpu/nvgpu/gk20a/ctxsw_trace_gk20a.c b/drivers/gpu/nvgpu/gk20a/ctxsw_trace_gk20a.c
index 6744699f..77e93458 100644
--- a/drivers/gpu/nvgpu/gk20a/ctxsw_trace_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/ctxsw_trace_gk20a.c
@@ -70,11 +70,6 @@ static inline int ring_len(struct nvgpu_ctxsw_ring_header *hdr)
         return (hdr->write_idx - hdr->read_idx) % hdr->num_ents;
 }
 
-static inline int ring_space(struct nvgpu_ctxsw_ring_header *hdr)
-{
-        return (hdr->read_idx - hdr->write_idx - 1) % hdr->num_ents;
-}
-
 ssize_t gk20a_ctxsw_dev_read(struct file *filp, char __user *buf, size_t size,
         loff_t *off)
 {
diff --git a/drivers/gpu/nvgpu/gk20a/gk20a.c b/drivers/gpu/nvgpu/gk20a/gk20a.c
index 3ab26fb9..2e40a675 100644
--- a/drivers/gpu/nvgpu/gk20a/gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/gk20a.c
@@ -705,6 +705,13 @@ static int gk20a_pm_prepare_poweroff(struct device *dev)
         if (!g->power_on)
                 goto done;
 
+        /*
+         * After this point, gk20a interrupts should not get
+         * serviced.
+         */
+        disable_irq(g->irq_stall);
+        disable_irq(g->irq_nonstall);
+
         gk20a_scale_suspend(dev);
 
         /* cancel any pending cde work */
@@ -716,12 +723,6 @@ static int gk20a_pm_prepare_poweroff(struct device *dev)
 
         /* disable elpg before gr or fifo suspend */
         ret |= gk20a_pmu_destroy(g);
-        /*
-         * After this point, gk20a interrupts should not get
-         * serviced.
-         */
-        disable_irq(g->irq_stall);
-        disable_irq(g->irq_nonstall);
 
         ret |= gk20a_gr_suspend(g);
         ret |= gk20a_mm_suspend(g);
@@ -966,7 +967,8 @@ static int gk20a_create_device(
         struct device *dev, int devno,
         const char *interface_name, const char *cdev_name,
         struct cdev *cdev, struct device **out,
-        const struct file_operations *ops)
+        const struct file_operations *ops,
+        struct class *class)
 {
         struct device *subdev;
         int err;
@@ -982,7 +984,7 @@ static int gk20a_create_device(
                 return err;
         }
 
-        subdev = device_create(&nvgpu_class, NULL, devno, NULL,
+        subdev = device_create(class, NULL, devno, NULL,
                 interface_name, cdev_name);
 
         if (IS_ERR(subdev)) {
@@ -997,42 +999,42 @@ static int gk20a_create_device(
         return 0;
 }
 
-void gk20a_user_deinit(struct device *dev)
+void gk20a_user_deinit(struct device *dev, struct class *class)
 {
         struct gk20a *g = gk20a_from_dev(dev);
 
         if (g->channel.node) {
-                device_destroy(&nvgpu_class, g->channel.cdev.dev);
+                device_destroy(class, g->channel.cdev.dev);
                 cdev_del(&g->channel.cdev);
         }
 
         if (g->as.node) {
-                device_destroy(&nvgpu_class, g->as.cdev.dev);
+                device_destroy(class, g->as.cdev.dev);
                 cdev_del(&g->as.cdev);
         }
 
         if (g->ctrl.node) {
-                device_destroy(&nvgpu_class, g->ctrl.cdev.dev);
+                device_destroy(class, g->ctrl.cdev.dev);
                 cdev_del(&g->ctrl.cdev);
         }
 
         if (g->dbg.node) {
-                device_destroy(&nvgpu_class, g->dbg.cdev.dev);
+                device_destroy(class, g->dbg.cdev.dev);
                 cdev_del(&g->dbg.cdev);
         }
 
         if (g->prof.node) {
-                device_destroy(&nvgpu_class, g->prof.cdev.dev);
+                device_destroy(class, g->prof.cdev.dev);
                 cdev_del(&g->prof.cdev);
         }
 
         if (g->tsg.node) {
-                device_destroy(&nvgpu_class, g->tsg.cdev.dev);
+                device_destroy(class, g->tsg.cdev.dev);
                 cdev_del(&g->tsg.cdev);
         }
 
         if (g->ctxsw.node) {
-                device_destroy(&nvgpu_class, g->ctxsw.cdev.dev);
+                device_destroy(class, g->ctxsw.cdev.dev);
                 cdev_del(&g->ctxsw.cdev);
         }
 
@@ -1040,7 +1042,8 @@ void gk20a_user_deinit(struct device *dev)
                 unregister_chrdev_region(g->cdev_region, GK20A_NUM_CDEVS);
 }
 
-int gk20a_user_init(struct device *dev, const char *interface_name)
+int gk20a_user_init(struct device *dev, const char *interface_name,
+                    struct class *class)
 {
         int err;
         dev_t devno;
@@ -1055,44 +1058,51 @@ int gk20a_user_init(struct device *dev, const char *interface_name)
 
         err = gk20a_create_device(dev, devno++, interface_name, "",
                                   &g->channel.cdev, &g->channel.node,
-                                  &gk20a_channel_ops);
+                                  &gk20a_channel_ops,
+                                  class);
         if (err)
                 goto fail;
 
         err = gk20a_create_device(dev, devno++, interface_name, "-as",
                                   &g->as.cdev, &g->as.node,
-                                  &gk20a_as_ops);
+                                  &gk20a_as_ops,
+                                  class);
         if (err)
                 goto fail;
 
         err = gk20a_create_device(dev, devno++, interface_name, "-ctrl",
                                   &g->ctrl.cdev, &g->ctrl.node,
-                                  &gk20a_ctrl_ops);
+                                  &gk20a_ctrl_ops,
+                                  class);
         if (err)
                 goto fail;
 
         err = gk20a_create_device(dev, devno++, interface_name, "-dbg",
                                   &g->dbg.cdev, &g->dbg.node,
-                                  &gk20a_dbg_ops);
+                                  &gk20a_dbg_ops,
+                                  class);
         if (err)
                 goto fail;
 
         err = gk20a_create_device(dev, devno++, interface_name, "-prof",
                                   &g->prof.cdev, &g->prof.node,
-                                  &gk20a_prof_ops);
+                                  &gk20a_prof_ops,
+                                  class);
         if (err)
                 goto fail;
 
         err = gk20a_create_device(dev, devno++, interface_name, "-tsg",
                                   &g->tsg.cdev, &g->tsg.node,
-                                  &gk20a_tsg_ops);
+                                  &gk20a_tsg_ops,
+                                  class);
         if (err)
                 goto fail;
 
 #ifdef CONFIG_GK20A_CTXSW_TRACE
         err = gk20a_create_device(dev, devno++, interface_name, "-ctxsw",
                                   &g->ctxsw.cdev, &g->ctxsw.node,
-                                  &gk20a_ctxsw_ops);
+                                  &gk20a_ctxsw_ops,
+                                  class);
         if (err)
                 goto fail;
 #endif
@@ -1100,7 +1110,7 @@ int gk20a_user_init(struct device *dev, const char *interface_name)
 
         return 0;
 fail:
-        gk20a_user_deinit(dev);
+        gk20a_user_deinit(dev, &nvgpu_class);
         return err;
 }
 
@@ -1464,7 +1474,7 @@ static int gk20a_probe(struct platform_device *dev)
         if (gk20a->irq_stall != gk20a->irq_nonstall)
                 disable_irq(gk20a->irq_nonstall);
 
-        err = gk20a_user_init(&dev->dev, INTERFACE_NAME);
+        err = gk20a_user_init(&dev->dev, INTERFACE_NAME, &nvgpu_class);
         if (err)
                 return err;
 
@@ -1644,7 +1654,7 @@ static int __exit gk20a_remove(struct platform_device *pdev)
         if (g->remove_support)
                 g->remove_support(dev);
 
-        gk20a_user_deinit(dev);
+        gk20a_user_deinit(dev, &nvgpu_class);
 
         debugfs_remove_recursive(platform->debugfs);
         debugfs_remove_recursive(platform->debugfs_alias);
@@ -1751,7 +1761,6 @@ static int gk20a_domain_init(struct of_device_id *matches)
 }
 #endif
 
-
 struct class nvgpu_class = {
         .owner = THIS_MODULE,
         .name = CLASS_NAME,
diff --git a/drivers/gpu/nvgpu/gk20a/gk20a.h b/drivers/gpu/nvgpu/gk20a/gk20a.h
index f5b4bb3f..d131862b 100644
--- a/drivers/gpu/nvgpu/gk20a/gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/gk20a.h
@@ -1067,8 +1067,9 @@ int gk20a_init_gpu_characteristics(struct gk20a *g);
 
 void gk20a_pbus_isr(struct gk20a *g);
 
-int gk20a_user_init(struct device *dev, const char *interface_name);
-void gk20a_user_deinit(struct device *dev);
+int gk20a_user_init(struct device *dev, const char *interface_name,
+                    struct class *class);
+void gk20a_user_deinit(struct device *dev, struct class *class);
 
 void gk20a_debug_dump_device(void *dev);
 
diff --git a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
index 60247da8..e8d363e1 100644
--- a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
@@ -1203,15 +1203,18 @@ static int gr_gk20a_setup_alpha_beta_tables(struct gk20a *g,
         u32 reg_offset;
         bool assign_alpha;
 
-        u32 map_alpha[gr_pd_alpha_ratio_table__size_1_v()];
-        u32 map_beta[gr_pd_alpha_ratio_table__size_1_v()];
-        u32 map_reg_used[gr_pd_alpha_ratio_table__size_1_v()];
+        u32 *map_alpha;
+        u32 *map_beta;
+        u32 *map_reg_used;
 
         gk20a_dbg_fn("");
 
-        memset(map_alpha, 0, gr_pd_alpha_ratio_table__size_1_v() * sizeof(u32));
-        memset(map_beta, 0, gr_pd_alpha_ratio_table__size_1_v() * sizeof(u32));
-        memset(map_reg_used, 0, gr_pd_alpha_ratio_table__size_1_v() * sizeof(u32));
+        map_alpha = kzalloc(3 * gr_pd_alpha_ratio_table__size_1_v() *
+                                sizeof(u32), GFP_KERNEL);
+        if (!map_alpha)
+                return -ENOMEM;
+        map_beta = map_alpha + gr_pd_alpha_ratio_table__size_1_v();
+        map_reg_used = map_beta + gr_pd_alpha_ratio_table__size_1_v();
 
         for (row = 0; row < rows; ++row) {
                 alpha_target = max_t(u32, gr->tpc_count * row / rows, 1);
@@ -1277,6 +1280,7 @@ static int gr_gk20a_setup_alpha_beta_tables(struct gk20a *g,
                 }
         }
 
+        kfree(map_alpha);
         return 0;
 }
 
@@ -2032,8 +2036,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_attr(g, DMA_ATTR_READ_ONLY, ucode_size,
-                        &ucode_info->surface_desc);
+        err = gk20a_gmmu_alloc(g, ucode_size, &ucode_info->surface_desc);
         if (err)
                 goto clean_up;
 
@@ -3261,15 +3264,17 @@ static int gr_gk20a_init_gr_config(struct gk20a *g, struct gr_gk20a *gr)
                                 g->ops.gr.get_gpc_tpc_mask(g, gpc_index);
 
                 for (pes_index = 0; pes_index < gr->pe_count_per_gpc; pes_index++) {
-                        gr->pes_tpc_count[pes_index] =
-                                kzalloc(gr->gpc_count * sizeof(u32),
-                                        GFP_KERNEL);
-                        gr->pes_tpc_mask[pes_index] =
-                                kzalloc(gr->gpc_count * sizeof(u32),
-                                        GFP_KERNEL);
-                        if (!gr->pes_tpc_count[pes_index] ||
-                            !gr->pes_tpc_mask[pes_index])
-                                goto clean_up;
+                        if (!gr->pes_tpc_count[pes_index]) {
+                                gr->pes_tpc_count[pes_index] =
+                                        kzalloc(gr->gpc_count * sizeof(u32),
+                                                GFP_KERNEL);
+                                gr->pes_tpc_mask[pes_index] =
+                                        kzalloc(gr->gpc_count * sizeof(u32),
+                                                GFP_KERNEL);
+                                if (!gr->pes_tpc_count[pes_index] ||
+                                    !gr->pes_tpc_mask[pes_index])
+                                        goto clean_up;
+                        }
 
                         tmp = gk20a_readl(g,
                                 gr_gpc0_gpm_pd_pes_tpc_id_mask_r(pes_index) +
diff --git a/drivers/gpu/nvgpu/gk20a/hw_bus_gk20a.h b/drivers/gpu/nvgpu/gk20a/hw_bus_gk20a.h
index 8a69c573..2c902f52 100644
--- a/drivers/gpu/nvgpu/gk20a/hw_bus_gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/hw_bus_gk20a.h
@@ -50,6 +50,30 @@
 #ifndef _hw_bus_gk20a_h_
 #define _hw_bus_gk20a_h_
 
+static inline u32 bus_bar0_window_r(void)
+{
+        return 0x00001700;
+}
+static inline u32 bus_bar0_window_base_f(u32 v)
+{
+        return (v & 0xffffff) << 0;
+}
+static inline u32 bus_bar0_window_target_vid_mem_f(void)
+{
+        return 0x0;
+}
+static inline u32 bus_bar0_window_target_sys_mem_coherent_f(void)
+{
+        return 0x2000000;
+}
+static inline u32 bus_bar0_window_target_sys_mem_noncoherent_f(void)
+{
+        return 0x3000000;
+}
+static inline u32 bus_bar0_window_target_bar0_window_base_shift_v(void)
+{
+        return 0x00000010;
+}
 static inline u32 bus_bar1_block_r(void)
 {
         return 0x00001704;
diff --git a/drivers/gpu/nvgpu/gk20a/hw_pram_gk20a.h b/drivers/gpu/nvgpu/gk20a/hw_pram_gk20a.h
new file mode 100644
index 00000000..918dad9a
--- /dev/null
+++ b/drivers/gpu/nvgpu/gk20a/hw_pram_gk20a.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Function naming determines intended use:
+ *
+ *     <x>_r(void) : Returns the offset for register <x>.
+ *
+ *     <x>_o(void) : Returns the offset for element <x>.
+ *
+ *     <x>_w(void) : Returns the word offset for word (4 byte) element <x>.
+ *
+ *     <x>_<y>_s(void) : Returns size of field <y> of register <x> in bits.
+ *
+ *     <x>_<y>_f(u32 v) : Returns a value based on 'v' which has been shifted
+ *         and masked to place it at field <y> of register <x>.  This value
+ *         can be |'d with others to produce a full register value for
+ *         register <x>.
+ *
+ *     <x>_<y>_m(void) : Returns a mask for field <y> of register <x>.  This
+ *         value can be ~'d and then &'d to clear the value of field <y> for
+ *         register <x>.
+ *
+ *     <x>_<y>_<z>_f(void) : Returns the constant value <z> after being shifted
+ *         to place it at field <y> of register <x>.  This value can be |'d
+ *         with others to produce a full register value for <x>.
+ *
+ *     <x>_<y>_v(u32 r) : Returns the value of field <y> from a full register
+ *         <x> value 'r' after being shifted to place its LSB at bit 0.
+ *         This value is suitable for direct comparison with other unshifted
+ *         values appropriate for use in field <y> of register <x>.
+ *
+ *     <x>_<y>_<z>_v(void) : Returns the constant value for <z> defined for
+ *         field <y> of register <x>.  This value is suitable for direct
+ *         comparison with unshifted values appropriate for use in field <y>
+ *         of register <x>.
+ */
+#ifndef _hw_pram_gk20a_h_
+#define _hw_pram_gk20a_h_
+
+static inline u32 pram_data032_r(u32 i)
+{
+        return 0x00700000 + i*4;
+}
+#endif
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
index eb4f01e0..ec946fb6 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
@@ -37,6 +37,7 @@
 #include "hw_fb_gk20a.h"
 #include "hw_bus_gk20a.h"
 #include "hw_ram_gk20a.h"
+#include "hw_pram_gk20a.h"
 #include "hw_mc_gk20a.h"
 #include "hw_flush_gk20a.h"
 #include "hw_ltc_gk20a.h"
@@ -44,10 +45,20 @@
 #include "kind_gk20a.h"
 #include "semaphore_gk20a.h"
 
+/*
+ * Flip this to force all gk20a_mem* accesses via PRAMIN from the start of the
+ * boot, even for buffers that would work via cpu_va. In runtime, the flag is
+ * in debugfs, called "force_pramin".
+ */
+#define GK20A_FORCE_PRAMIN_DEFAULT false
+
 int gk20a_mem_begin(struct gk20a *g, struct mem_desc *mem)
 {
         void *cpu_va;
 
+        if (mem->aperture != APERTURE_SYSMEM || g->mm.force_pramin)
+                return 0;
+
         if (WARN_ON(mem->cpu_va)) {
                 gk20a_warn(dev_from_gk20a(g), "nested %s", __func__);
                 return -EBUSY;
@@ -66,20 +77,66 @@ int gk20a_mem_begin(struct gk20a *g, struct mem_desc *mem)
 
 void gk20a_mem_end(struct gk20a *g, struct mem_desc *mem)
 {
+        if (mem->aperture != APERTURE_SYSMEM || g->mm.force_pramin)
+                return;
+
         vunmap(mem->cpu_va);
         mem->cpu_va = NULL;
 }
 
+/* WARNING: returns pramin_base_lock taken, complement with pramin_exit() */
+static u32 gk20a_pramin_enter(struct gk20a *g, struct mem_desc *mem, u32 w)
+{
+        u64 bufbase = g->ops.mm.get_iova_addr(g, mem->sgt->sgl, 0);
+        u64 addr = bufbase + w * sizeof(u32);
+        u32 hi = (u32)((addr & ~(u64)0xfffff)
+                >> bus_bar0_window_target_bar0_window_base_shift_v());
+        u32 lo = (addr & 0xfffff);
+
+        gk20a_dbg(gpu_dbg_mem, "0x%08x:%08x begin for %p", hi, lo, mem);
+
+        WARN_ON(!bufbase);
+        spin_lock(&g->mm.pramin_base_lock);
+        if (g->mm.pramin_base != hi) {
+                gk20a_writel(g, bus_bar0_window_r(),
+                                (g->mm.vidmem_is_vidmem
+                                 && mem->aperture == APERTURE_SYSMEM ?
+                                 bus_bar0_window_target_sys_mem_noncoherent_f() :
+                                 bus_bar0_window_target_vid_mem_f()) |
+                                bus_bar0_window_base_f(hi));
+                gk20a_readl(g, bus_bar0_window_r());
+                g->mm.pramin_base = hi;
+        }
+
+        return lo;
+}
+
+static void gk20a_pramin_exit(struct gk20a *g, struct mem_desc *mem)
+{
+        gk20a_dbg(gpu_dbg_mem, "end for %p", mem);
+        spin_unlock(&g->mm.pramin_base_lock);
+}
+
 u32 gk20a_mem_rd32(struct gk20a *g, struct mem_desc *mem, u32 w)
 {
-        u32 *ptr = mem->cpu_va;
-        u32 data;
+        u32 data = 0;
+
+        if (mem->aperture == APERTURE_SYSMEM && !g->mm.force_pramin) {
+                u32 *ptr = mem->cpu_va;
 
-        WARN_ON(!ptr);
-        data = ptr[w];
+                WARN_ON(!ptr);
+                data = ptr[w];
 #ifdef CONFIG_TEGRA_SIMULATION_PLATFORM
-        gk20a_dbg(gpu_dbg_mem, " %p = 0x%x", ptr + w, data);
+                gk20a_dbg(gpu_dbg_mem, " %p = 0x%x", ptr + w, data);
 #endif
+        } else if (mem->aperture == APERTURE_VIDMEM || g->mm.force_pramin) {
+                u32 addr = gk20a_pramin_enter(g, mem, w);
+                data = gk20a_readl(g, pram_data032_r(addr / sizeof(u32)));
+                gk20a_pramin_exit(g, mem);
+        } else {
+                WARN_ON("Accessing unallocated mem_desc");
+        }
+
         return data;
 }
 
@@ -106,13 +163,23 @@ void gk20a_mem_rd_n(struct gk20a *g, struct mem_desc *mem,
 
 void gk20a_mem_wr32(struct gk20a *g, struct mem_desc *mem, u32 w, u32 data)
 {
-        u32 *ptr = mem->cpu_va;
+        if (mem->aperture == APERTURE_SYSMEM && !g->mm.force_pramin) {
+                u32 *ptr = mem->cpu_va;
 
-        WARN_ON(!ptr);
+                WARN_ON(!ptr);
 #ifdef CONFIG_TEGRA_SIMULATION_PLATFORM
-        gk20a_dbg(gpu_dbg_mem, " %p = 0x%x", ptr + w, data);
+                gk20a_dbg(gpu_dbg_mem, " %p = 0x%x", ptr + w, data);
 #endif
-        ptr[w] = data;
+                ptr[w] = data;
+        } else if (mem->aperture == APERTURE_VIDMEM || g->mm.force_pramin) {
+                u32 addr = gk20a_pramin_enter(g, mem, w);
+                gk20a_writel(g, pram_data032_r(addr / sizeof(u32)), data);
+                /* read back to synchronize accesses*/
+                gk20a_readl(g, pram_data032_r(addr / sizeof(u32)));
+                gk20a_pramin_exit(g, mem);
+        } else {
+                WARN_ON("Accessing unallocated mem_desc");
+        }
 }
 
 void gk20a_mem_wr(struct gk20a *g, struct mem_desc *mem, u32 offset, u32 data)
@@ -535,6 +602,13 @@ static int gk20a_alloc_sysmem_flush(struct gk20a *g)
         return gk20a_gmmu_alloc(g, SZ_4K, &g->mm.sysmem_flush);
 }
 
+static void gk20a_init_pramin(struct mm_gk20a *mm)
+{
+        mm->pramin_base = 0;
+        spin_lock_init(&mm->pramin_base_lock);
+        mm->force_pramin = GK20A_FORCE_PRAMIN_DEFAULT;
+}
+
 int gk20a_init_mm_setup_sw(struct gk20a *g)
 {
         struct mm_gk20a *mm = &g->mm;
@@ -558,6 +632,8 @@ int gk20a_init_mm_setup_sw(struct gk20a *g)
                        (int)(mm->channel.user_size >> 20),
                        (int)(mm->channel.kernel_size >> 20));
 
+        gk20a_init_pramin(mm);
+
         err = gk20a_alloc_sysmem_flush(g);
         if (err)
                 return err;
@@ -586,6 +662,7 @@ int gk20a_init_mm_setup_sw(struct gk20a *g)
         /* set vm_alloc_share op here as gk20a_as_alloc_share needs it */
         g->ops.mm.vm_alloc_share = gk20a_vm_alloc_share;
         mm->remove_support = gk20a_remove_mm_support;
+
         mm->sw_ready = true;
 
         gk20a_dbg_fn("done");
@@ -690,6 +767,7 @@ static int alloc_gmmu_phys_pages(struct vm_gk20a *vm, u32 order,
         entry->mem.cpu_va = page_address(pages);
         memset(entry->mem.cpu_va, 0, len);
         entry->mem.size = len;
+        entry->mem.aperture = APERTURE_SYSMEM;
         FLUSH_CPU_DCACHE(entry->mem.cpu_va, sg_phys(entry->mem.sgt->sgl), len);
 
         return 0;
@@ -716,6 +794,7 @@ static void free_gmmu_phys_pages(struct vm_gk20a *vm,
         kfree(entry->mem.sgt);
         entry->mem.sgt = NULL;
         entry->mem.size = 0;
+        entry->mem.aperture = APERTURE_INVALID;
 }
 
 static int map_gmmu_phys_pages(struct gk20a_mm_entry *entry)
@@ -2164,6 +2243,7 @@ int gk20a_gmmu_alloc_attr(struct gk20a *g, enum dma_attr attr, size_t size, stru
                 goto fail_free;
 
         mem->size = size;
+        mem->aperture = APERTURE_SYSMEM;
 
         gk20a_dbg_fn("done");
 
@@ -2210,6 +2290,7 @@ void gk20a_gmmu_free_attr(struct gk20a *g, enum dma_attr attr,
                 gk20a_free_sgtable(&mem->sgt);
 
         mem->size = 0;
+        mem->aperture = APERTURE_INVALID;
 }
 
 void gk20a_gmmu_free(struct gk20a *g, struct mem_desc *mem)
@@ -4015,6 +4096,9 @@ void gk20a_mm_debugfs_init(struct device *dev)
 
         debugfs_create_x64("separate_fixed_allocs", 0664, gpu_root,
                            &g->separate_fixed_allocs);
+
+        debugfs_create_bool("force_pramin", 0664, gpu_root,
+                           &g->mm.force_pramin);
 }
 
 void gk20a_init_mm(struct gpu_ops *gops)
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
index d943b231..c58a4fec 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
@@ -40,10 +40,17 @@
                 outer_flush_range(pa, pa + (size_t)(size));             \
         } while (0)
 
+enum gk20a_aperture {
+        APERTURE_INVALID, /* e.g., unallocated */
+        APERTURE_SYSMEM,
+        APERTURE_VIDMEM
+};
+
 struct mem_desc {
         void *cpu_va;
         struct page **pages;
         struct sg_table *sgt;
+        enum gk20a_aperture aperture;
         size_t size;
         u64 gpu_va;
 };
@@ -357,6 +364,14 @@ struct mm_gk20a {
         bool vidmem_is_vidmem;
 
         struct mem_desc sysmem_flush;
+
+        u32 pramin_base;
+        spinlock_t pramin_base_lock;
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,4,0)
+        u32 force_pramin; /* via debugfs */
+#else
+        bool force_pramin; /* via debugfs */
+#endif
 };
 
 int gk20a_mm_init(struct mm_gk20a *mm);
diff --git a/drivers/gpu/nvgpu/gk20a/platform_gk20a_tegra.c b/drivers/gpu/nvgpu/gk20a/platform_gk20a_tegra.c
index abe6771c..ca36d481 100644
--- a/drivers/gpu/nvgpu/gk20a/platform_gk20a_tegra.c
+++ b/drivers/gpu/nvgpu/gk20a/platform_gk20a_tegra.c
@@ -52,12 +52,12 @@ struct gk20a_emc_params {
 };
 
 static void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE);
-static inline u32 pmc_read(unsigned long reg)
+static inline u32 __maybe_unused pmc_read(unsigned long reg)
 {
         return readl(pmc + reg);
 }
 
-static inline void pmc_write(u32 val, unsigned long reg)
+static inline void __maybe_unused pmc_write(u32 val, unsigned long reg)
 {
         writel_relaxed(val, pmc + reg);
 }
diff --git a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
index 8bf382fd..08ef7738 100644
--- a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
@@ -2443,8 +2443,7 @@ static int gk20a_prepare_ucode(struct gk20a *g)
         pmu->ucode_image = (u32 *)((u8 *)pmu->desc +
                         pmu->desc->descriptor_size);
 
-        err = gk20a_gmmu_alloc_map_attr(vm, DMA_ATTR_READ_ONLY,
-                               GK20A_PMU_UCODE_SIZE_MAX, &pmu->ucode);
+        err = gk20a_gmmu_alloc_map(vm, GK20A_PMU_UCODE_SIZE_MAX, &pmu->ucode);
         if (err)
                 goto err_release_fw;
 
diff --git a/drivers/gpu/nvgpu/gm20b/hw_bus_gm20b.h b/drivers/gpu/nvgpu/gm20b/hw_bus_gm20b.h
index e69275e0..0b4eefe0 100644
--- a/drivers/gpu/nvgpu/gm20b/hw_bus_gm20b.h
+++ b/drivers/gpu/nvgpu/gm20b/hw_bus_gm20b.h
@@ -50,6 +50,30 @@
 #ifndef _hw_bus_gm20b_h_
 #define _hw_bus_gm20b_h_
 
+static inline u32 bus_bar0_window_r(void)
+{
+        return 0x00001700;
+}
+static inline u32 bus_bar0_window_base_f(u32 v)
+{
+        return (v & 0xffffff) << 0;
+}
+static inline u32 bus_bar0_window_target_vid_mem_f(void)
+{
+        return 0x0;
+}
+static inline u32 bus_bar0_window_target_sys_mem_coherent_f(void)
+{
+        return 0x2000000;
+}
+static inline u32 bus_bar0_window_target_sys_mem_noncoherent_f(void)
+{
+        return 0x3000000;
+}
+static inline u32 bus_bar0_window_target_bar0_window_base_shift_v(void)
+{
+        return 0x00000010;
+}
 static inline u32 bus_bar1_block_r(void)
 {
         return 0x00001704;
diff --git a/drivers/gpu/nvgpu/gm20b/hw_pram_gm20b.h b/drivers/gpu/nvgpu/gm20b/hw_pram_gm20b.h
new file mode 100644
index 00000000..f9c6f3d4
--- /dev/null
+++ b/drivers/gpu/nvgpu/gm20b/hw_pram_gm20b.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Function naming determines intended use:
+ *
+ *     <x>_r(void) : Returns the offset for register <x>.
+ *
+ *     <x>_o(void) : Returns the offset for element <x>.
+ *
+ *     <x>_w(void) : Returns the word offset for word (4 byte) element <x>.
+ *
+ *     <x>_<y>_s(void) : Returns size of field <y> of register <x> in bits.
+ *
+ *     <x>_<y>_f(u32 v) : Returns a value based on 'v' which has been shifted
+ *         and masked to place it at field <y> of register <x>.  This value
+ *         can be |'d with others to produce a full register value for
+ *         register <x>.
+ *
+ *     <x>_<y>_m(void) : Returns a mask for field <y> of register <x>.  This
+ *         value can be ~'d and then &'d to clear the value of field <y> for
+ *         register <x>.
+ *
+ *     <x>_<y>_<z>_f(void) : Returns the constant value <z> after being shifted
+ *         to place it at field <y> of register <x>.  This value can be |'d
+ *         with others to produce a full register value for <x>.
+ *
+ *     <x>_<y>_v(u32 r) : Returns the value of field <y> from a full register
+ *         <x> value 'r' after being shifted to place its LSB at bit 0.
+ *         This value is suitable for direct comparison with other unshifted
+ *         values appropriate for use in field <y> of register <x>.
+ *
+ *     <x>_<y>_<z>_v(void) : Returns the constant value for <z> defined for
+ *         field <y> of register <x>.  This value is suitable for direct
+ *         comparison with unshifted values appropriate for use in field <y>
+ *         of register <x>.
+ */
+#ifndef _hw_pram_gm20b_h_
+#define _hw_pram_gm20b_h_
+
+static inline u32 pram_data032_r(u32 i)
+{
+        return 0x00700000 + i*4;
+}
+#endif
diff --git a/drivers/gpu/nvgpu/gm20b/pmu_gm20b.c b/drivers/gpu/nvgpu/gm20b/pmu_gm20b.c
index 8eb600ef..8702658c 100644
--- a/drivers/gpu/nvgpu/gm20b/pmu_gm20b.c
+++ b/drivers/gpu/nvgpu/gm20b/pmu_gm20b.c
@@ -69,44 +69,6 @@ static struct pg_init_sequence_list _pginitseq_gm20b[] = {
                 { 0x0010e06c, 0x00000099},
                 { 0x0010e06c, 0x0000009a},
                 { 0x0010e06c, 0x0000009b},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
-                { 0x0010e06c, 0x00000000},
                 { 0x0010ab14, 0x00000000},
                 { 0x0010ab18, 0x00000000},
                 { 0x0010e024, 0x00000000},
diff --git a/drivers/gpu/nvgpu/pci.c b/drivers/gpu/nvgpu/pci.c
index 9ae5e2c6..3057a625 100644
--- a/drivers/gpu/nvgpu/pci.c
+++ b/drivers/gpu/nvgpu/pci.c
@@ -21,7 +21,7 @@
 #include "gk20a/gk20a.h"
 #include "gk20a/platform_gk20a.h"
 
-#define PCI_INTERFACE_NAME "nvgpu-pci-%s%%s"
+#define PCI_INTERFACE_NAME "card-%s%%s"
 
 static int nvgpu_pci_tegra_probe(struct device *dev)
 {
@@ -135,6 +135,17 @@ static int nvgpu_pci_init_support(struct pci_dev *pdev)
         return err;
 }
 
+static char *nvgpu_pci_devnode(struct device *dev, umode_t *mode)
+{
+        return kasprintf(GFP_KERNEL, "nvgpu-pci/%s", dev_name(dev));
+}
+
+struct class nvgpu_pci_class = {
+        .owner = THIS_MODULE,
+        .name = "nvidia-pci-gpu",
+        .devnode = nvgpu_pci_devnode,
+};
+
 static int nvgpu_pci_probe(struct pci_dev *pdev,
                            const struct pci_device_id *pent)
 {
@@ -187,7 +198,7 @@ static int nvgpu_pci_probe(struct pci_dev *pdev,
         if (!nodefmt)
                 return -ENOMEM;
 
-        err = gk20a_user_init(&pdev->dev, nodefmt);
+        err = gk20a_user_init(&pdev->dev, nodefmt, &nvgpu_pci_class);
         kfree(nodefmt);
         nodefmt = NULL;
         if (err)
@@ -248,7 +259,7 @@ static void nvgpu_pci_remove(struct pci_dev *pdev)
         if (g->remove_support)
                 g->remove_support(g->dev);
 
-        gk20a_user_deinit(g->dev);
+        gk20a_user_deinit(g->dev, &nvgpu_pci_class);
 
         debugfs_remove_recursive(platform->debugfs);
         debugfs_remove_recursive(platform->debugfs_alias);
@@ -270,10 +281,17 @@ static struct pci_driver nvgpu_pci_driver = {
 
 int __init nvgpu_pci_init(void)
 {
+        int ret;
+
+        ret = class_register(&nvgpu_pci_class);
+        if (ret)
+                return ret;
+
         return pci_register_driver(&nvgpu_pci_driver);
 }
 
 void __exit nvgpu_pci_exit(void)
 {
         pci_unregister_driver(&nvgpu_pci_driver);
+        class_unregister(&nvgpu_pci_class);
 }
diff --git a/drivers/gpu/nvgpu/vgpu/vgpu.c b/drivers/gpu/nvgpu/vgpu/vgpu.c
index 78492d3b..3c06652b 100644
--- a/drivers/gpu/nvgpu/vgpu/vgpu.c
+++ b/drivers/gpu/nvgpu/vgpu/vgpu.c
@@ -418,7 +418,7 @@ int vgpu_probe(struct platform_device *pdev)
         platform->g = gk20a;
         gk20a->dev = dev;
 
-        err = gk20a_user_init(dev, INTERFACE_NAME);
+        err = gk20a_user_init(dev, INTERFACE_NAME, &nvgpu_class);
         if (err)
                 return err;
 
@@ -498,7 +498,7 @@ int vgpu_remove(struct platform_device *pdev)
         kfree(vgpu_gpd);
 
         vgpu_comm_deinit();
-        gk20a_user_deinit(dev);
+        gk20a_user_deinit(dev, &nvgpu_class);
         gk20a_get_platform(dev)->g = NULL;
         kfree(g);
         return 0;