9 files changed, 143 insertions, 241 deletions

diff --git a/drivers/gpu/nvgpu/common/as.c b/drivers/gpu/nvgpu/common/as.c
index 3182642a..481fb807 100644
--- a/drivers/gpu/nvgpu/common/as.c
+++ b/drivers/gpu/nvgpu/common/as.c
@@ -16,8 +16,10 @@
 #include <trace/events/gk20a.h>
 
 #include <nvgpu/kmem.h>
+#include <nvgpu/vm.h>
 
 #include "gk20a/gk20a.h"
+#include "gk20a/platform_gk20a.h"
 
 /* dumb allocator... */
 static int generate_as_share_id(struct gk20a_as *as)
@@ -32,6 +34,51 @@ static void release_as_share_id(struct gk20a_as *as, int id)
         return;
 }
 
+/* address space interfaces for the gk20a module */
+static int gk20a_vm_alloc_share(struct gk20a_as_share *as_share,
+                                u32 big_page_size, u32 flags)
+{
+        struct gk20a_as *as = as_share->as;
+        struct gk20a *g = gk20a_from_as(as);
+        struct mm_gk20a *mm = &g->mm;
+        struct vm_gk20a *vm;
+        char name[32];
+        int err;
+        const bool userspace_managed =
+                (flags & NVGPU_GPU_IOCTL_ALLOC_AS_FLAGS_USERSPACE_MANAGED) != 0;
+
+        gk20a_dbg_fn("");
+
+        if (big_page_size == 0) {
+                big_page_size =
+                        gk20a_get_platform(g->dev)->default_big_page_size;
+        } else {
+                if (!is_power_of_2(big_page_size))
+                        return -EINVAL;
+
+                if (!(big_page_size & g->gpu_characteristics.available_big_page_sizes))
+                        return -EINVAL;
+        }
+
+        vm = nvgpu_kzalloc(g, sizeof(*vm));
+        if (!vm)
+                return -ENOMEM;
+
+        as_share->vm = vm;
+        vm->as_share = as_share;
+        vm->enable_ctag = true;
+
+        snprintf(name, sizeof(name), "as_%d", as_share->id);
+
+        err = nvgpu_init_vm(mm, vm, big_page_size,
+                            big_page_size << 10,
+                            mm->channel.kernel_size,
+                            mm->channel.user_size + mm->channel.kernel_size,
+                            !mm->disable_bigpage, userspace_managed, name);
+
+        return err;
+}
+
 int gk20a_as_alloc_share(struct gk20a *g,
                          u32 big_page_size, u32 flags,
                          struct gk20a_as_share **out)
@@ -56,7 +103,7 @@ int gk20a_as_alloc_share(struct gk20a *g,
         err = gk20a_busy(g);
         if (err)
                 goto failed;
-        err = g->ops.mm.vm_alloc_share(as_share, big_page_size, flags);
+        err = gk20a_vm_alloc_share(as_share, big_page_size, flags);
         gk20a_idle(g);
 
         if (err)
@@ -70,6 +117,20 @@ failed:
         return err;
 }
 
+int gk20a_vm_release_share(struct gk20a_as_share *as_share)
+{
+        struct vm_gk20a *vm = as_share->vm;
+
+        gk20a_dbg_fn("");
+
+        vm->as_share = NULL;
+        as_share->vm = NULL;
+
+        nvgpu_vm_put(vm);
+
+        return 0;
+}
+
 /*
  * channels and the device nodes call this to release.
  * once the ref_cnt hits zero the share is deleted.
diff --git a/drivers/gpu/nvgpu/common/mm/vm.c b/drivers/gpu/nvgpu/common/mm/vm.c
index b957e755..171a67ca 100644
--- a/drivers/gpu/nvgpu/common/mm/vm.c
+++ b/drivers/gpu/nvgpu/common/mm/vm.c
@@ -24,6 +24,8 @@
 #include <nvgpu/semaphore.h>
 #include <nvgpu/enabled.h>
 
+#include <nvgpu/vgpu/vm.h>
+
 #include "gk20a/gk20a.h"
 #include "gk20a/mm_gk20a.h"
 
@@ -209,10 +211,11 @@ static int nvgpu_init_sema_pool(struct vm_gk20a *vm)
  * @vm - The VM to init.
  * @big_page_size - Size of big pages associated with this VM.
  * @low_hole - The size of the low hole (unaddressable memory at the bottom of
- *             the address space.
+ *             the address space).
  * @kernel_reserved - Space reserved for kernel only allocations.
  * @aperture_size - Total size of the aperture.
- * @big_pages - Ignored. Will be set based on other passed params.
+ * @big_pages - If true then big pages are possible in the VM. Note this does
+ *              not guarantee that big pages will be possible.
  * @name - Name of the address space.
  *
  * This function initializes an address space according to the following map:
@@ -284,10 +287,21 @@ int nvgpu_init_vm(struct mm_gk20a *mm,
         vm->userspace_managed = userspace_managed;
         vm->mmu_levels        = g->ops.mm.get_mmu_levels(g, vm->big_page_size);
 
+#ifdef CONFIG_TEGRA_GR_VIRTUALIZATION
+        if (g->is_virtual && userspace_managed) {
+                nvgpu_err(g, "vGPU: no userspace managed addr space support");
+                return -ENOSYS;
+        }
+        if (g->is_virtual && vgpu_vm_init(g, vm)) {
+                nvgpu_err(g, "Failed to init vGPU VM!");
+                return -ENOMEM;
+        }
+#endif
+
         /* Initialize the page table data structures. */
         err = nvgpu_vm_init_page_tables(vm);
         if (err)
-                return err;
+                goto clean_up_vgpu_vm;
 
         /* Setup vma limits. */
         if (kernel_reserved + low_hole < aperture_size) {
@@ -445,6 +459,11 @@ clean_up_page_tables:
         /* Cleans up nvgpu_vm_init_page_tables() */
         nvgpu_vfree(g, vm->pdb.entries);
         free_gmmu_pages(vm, &vm->pdb);
+clean_up_vgpu_vm:
+#ifdef CONFIG_TEGRA_GR_VIRTUALIZATION
+        if (g->is_virtual)
+                vgpu_vm_remove(vm);
+#endif
         return err;
 }
 
@@ -503,7 +522,7 @@ void __nvgpu_vm_remove(struct vm_gk20a *vm)
 
 #ifdef CONFIG_TEGRA_GR_VIRTUALIZATION
         if (g->is_virtual)
-                nvgpu_vm_remove_vgpu(vm);
+                vgpu_vm_remove(vm);
 #endif
 
         nvgpu_mutex_release(&vm->update_gmmu_lock);
diff --git a/drivers/gpu/nvgpu/gk20a/gk20a.h b/drivers/gpu/nvgpu/gk20a/gk20a.h
index 4fc626e8..a02215d2 100644
--- a/drivers/gpu/nvgpu/gk20a/gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/gk20a.h
@@ -672,8 +672,6 @@ struct gpu_ops {
                                 int rw_flag,
                                 bool sparse,
                                 struct vm_gk20a_mapping_batch *batch);
-                int (*vm_alloc_share)(struct gk20a_as_share *as_share,
-                                      u32 big_page_size, u32 flags);
                 int (*vm_bind_channel)(struct gk20a_as_share *as_share,
                                 struct channel_gk20a *ch);
                 int (*fb_flush)(struct gk20a *g);
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
index ec020d5f..87e6f30c 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
@@ -702,8 +702,6 @@ int gk20a_init_mm_setup_sw(struct gk20a *g)
         if (err)
                 return err;
 
-        /* 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->remove_ce_support = gk20a_remove_mm_ce_support;
 
@@ -2451,65 +2449,6 @@ enum gmmu_pgsz_gk20a __get_pte_size(struct vm_gk20a *vm, u64 base, u64 size)
         return gmmu_page_size_small;
 }
 
-/* address space interfaces for the gk20a module */
-int gk20a_vm_alloc_share(struct gk20a_as_share *as_share, u32 big_page_size,
-                         u32 flags)
-{
-        struct gk20a_as *as = as_share->as;
-        struct gk20a *g = gk20a_from_as(as);
-        struct mm_gk20a *mm = &g->mm;
-        struct vm_gk20a *vm;
-        char name[32];
-        int err;
-        const bool userspace_managed =
-                (flags & NVGPU_GPU_IOCTL_ALLOC_AS_FLAGS_USERSPACE_MANAGED) != 0;
-
-        gk20a_dbg_fn("");
-
-        if (big_page_size == 0) {
-                big_page_size =
-                        gk20a_get_platform(g->dev)->default_big_page_size;
-        } else {
-                if (!is_power_of_2(big_page_size))
-                        return -EINVAL;
-
-                if (!(big_page_size & g->gpu_characteristics.available_big_page_sizes))
-                        return -EINVAL;
-        }
-
-        vm = nvgpu_kzalloc(g, sizeof(*vm));
-        if (!vm)
-                return -ENOMEM;
-
-        as_share->vm = vm;
-        vm->as_share = as_share;
-        vm->enable_ctag = true;
-
-        snprintf(name, sizeof(name), "as_%d", as_share->id);
-
-        err = nvgpu_init_vm(mm, vm, big_page_size,
-                            big_page_size << 10,
-                            mm->channel.kernel_size,
-                            mm->channel.user_size + mm->channel.kernel_size,
-                            !mm->disable_bigpage, userspace_managed, name);
-
-        return err;
-}
-
-int gk20a_vm_release_share(struct gk20a_as_share *as_share)
-{
-        struct vm_gk20a *vm = as_share->vm;
-
-        gk20a_dbg_fn("");
-
-        vm->as_share = NULL;
-        as_share->vm = NULL;
-
-        nvgpu_vm_put(vm);
-
-        return 0;
-}
-
 int __gk20a_vm_bind_channel(struct vm_gk20a *vm, struct channel_gk20a *ch)
 {
         int err = 0;
@@ -3130,7 +3069,6 @@ void gk20a_init_mm(struct gpu_ops *gops)
 {
         gops->mm.gmmu_map = gk20a_locked_gmmu_map;
         gops->mm.gmmu_unmap = gk20a_locked_gmmu_unmap;
-        gops->mm.vm_alloc_share = gk20a_vm_alloc_share;
         gops->mm.vm_bind_channel = gk20a_vm_bind_channel;
         gops->mm.fb_flush = gk20a_mm_fb_flush;
         gops->mm.l2_invalidate = gk20a_mm_l2_invalidate;
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
index 94342818..16c35d34 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
@@ -416,8 +416,6 @@ int nvgpu_vm_get_compbits_info(struct vm_gk20a *vm,
 /* vm-as interface */
 struct nvgpu_as_alloc_space_args;
 struct nvgpu_as_free_space_args;
-int gk20a_vm_alloc_share(struct gk20a_as_share *as_share, u32 big_page_size,
-                         u32 flags);
 int gk20a_vm_release_share(struct gk20a_as_share *as_share);
 int gk20a_vm_bind_channel(struct gk20a_as_share *as_share,
                           struct channel_gk20a *ch);
diff --git a/drivers/gpu/nvgpu/gm20b/mm_gm20b.c b/drivers/gpu/nvgpu/gm20b/mm_gm20b.c
index 78e083d0..0595fe2e 100644
--- a/drivers/gpu/nvgpu/gm20b/mm_gm20b.c
+++ b/drivers/gpu/nvgpu/gm20b/mm_gm20b.c
@@ -60,7 +60,6 @@ void gm20b_init_mm(struct gpu_ops *gops)
         gops->mm.support_sparse = gm20b_mm_support_sparse;
         gops->mm.gmmu_map = gk20a_locked_gmmu_map;
         gops->mm.gmmu_unmap = gk20a_locked_gmmu_unmap;
-        gops->mm.vm_alloc_share = gk20a_vm_alloc_share;
         gops->mm.vm_bind_channel = gk20a_vm_bind_channel;
         gops->mm.fb_flush = gk20a_mm_fb_flush;
         gops->mm.l2_invalidate = gk20a_mm_l2_invalidate;
diff --git a/drivers/gpu/nvgpu/include/nvgpu/vgpu/vm.h b/drivers/gpu/nvgpu/include/nvgpu/vgpu/vm.h
new file mode 100644
index 00000000..364baac6
--- /dev/null
+++ b/drivers/gpu/nvgpu/include/nvgpu/vgpu/vm.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2017, 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/>.
+ */
+
+#ifndef __NVGPU_VM_VGPU_H__
+#define __NVGPU_VM_VGPU_H__
+
+#ifdef CONFIG_TEGRA_GR_VIRTUALIZATION
+int  vgpu_vm_init(struct gk20a *g, struct vm_gk20a *vm);
+void vgpu_vm_remove(struct vm_gk20a *vm);
+#endif
+
+#endif
diff --git a/drivers/gpu/nvgpu/include/nvgpu/vm.h b/drivers/gpu/nvgpu/include/nvgpu/vm.h
index fed58f24..403f3b18 100644
--- a/drivers/gpu/nvgpu/include/nvgpu/vm.h
+++ b/drivers/gpu/nvgpu/include/nvgpu/vm.h
@@ -225,12 +225,10 @@ int nvgpu_insert_mapped_buf(struct vm_gk20a *vm,
 void nvgpu_remove_mapped_buf(struct vm_gk20a *vm,
                              struct nvgpu_mapped_buf *mapped_buffer);
 
+void nvgpu_deinit_vm(struct vm_gk20a *vm);
 void __nvgpu_vm_remove(struct vm_gk20a *vm);
 void nvgpu_vm_remove(struct vm_gk20a *vm);
 void nvgpu_vm_remove_inst(struct vm_gk20a *vm, struct nvgpu_mem *inst_block);
-#ifdef CONFIG_TEGRA_GR_VIRTUALIZATION
-void nvgpu_vm_remove_vgpu(struct vm_gk20a *vm);
-#endif
 
 int nvgpu_init_vm(struct mm_gk20a *mm,
                   struct vm_gk20a *vm,
@@ -241,7 +239,6 @@ int nvgpu_init_vm(struct mm_gk20a *mm,
                   bool big_pages,
                   bool userspace_managed,
                   char *name);
-void nvgpu_deinit_vm(struct vm_gk20a *vm);
 
 /*
  * These are private to the VM code but are unfortunately used by the vgpu code.
diff --git a/drivers/gpu/nvgpu/vgpu/mm_vgpu.c b/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
index 287567d6..b2bc6f0a 100644
--- a/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
+++ b/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
@@ -21,6 +21,8 @@
 #include <nvgpu/vm.h>
 #include <nvgpu/vm_area.h>
 
+#include <nvgpu/vgpu/vm.h>
+
 #include "vgpu/vgpu.h"
 #include "gk20a/mm_gk20a.h"
 
@@ -201,7 +203,36 @@ static void vgpu_locked_gmmu_unmap(struct vm_gk20a *vm,
         /* TLB invalidate handled on server side */
 }
 
-void nvgpu_vm_remove_vgpu(struct vm_gk20a *vm)
+/*
+ * This is called by the common VM init routine to handle vGPU specifics of
+ * intializing a VM on a vGPU. This alone is not enough to init a VM. See
+ * nvgpu_vm_init().
+ */
+int vgpu_vm_init(struct gk20a *g, struct vm_gk20a *vm)
+{
+        struct tegra_vgpu_cmd_msg msg;
+        struct tegra_vgpu_as_share_params *p = &msg.params.as_share;
+        int err;
+
+        msg.cmd = TEGRA_VGPU_CMD_AS_ALLOC_SHARE;
+        msg.handle = vgpu_get_handle(g);
+        p->size = vm->va_limit;
+        p->big_page_size = vm->big_page_size;
+
+        err = vgpu_comm_sendrecv(&msg, sizeof(msg), sizeof(msg));
+        if (err || msg.ret)
+                return -ENOMEM;
+
+        vm->handle = p->handle;
+
+        return 0;
+}
+
+/*
+ * Similar to vgpu_vm_init() this is called as part of the cleanup path for
+ * VMs. This alone is not enough to remove a VM - see nvgpu_vm_remove().
+ */
+void vgpu_vm_remove(struct vm_gk20a *vm)
 {
         struct gk20a *g = gk20a_from_vm(vm);
         struct tegra_vgpu_cmd_msg msg;
@@ -238,169 +269,6 @@ u64 vgpu_bar1_map(struct gk20a *g, struct sg_table **sgt, u64 size)
         return addr;
 }
 
-/* address space interfaces for the gk20a module */
-static int vgpu_vm_alloc_share(struct gk20a_as_share *as_share,
-                               u32 big_page_size, u32 flags)
-{
-        struct gk20a_as *as = as_share->as;
-        struct gk20a *g = gk20a_from_as(as);
-        struct gk20a_platform *platform = gk20a_get_platform(g->dev);
-        struct tegra_vgpu_cmd_msg msg;
-        struct tegra_vgpu_as_share_params *p = &msg.params.as_share;
-        struct mm_gk20a *mm = &g->mm;
-        struct vm_gk20a *vm;
-        u64 user_vma_start, user_vma_limit, kernel_vma_start, kernel_vma_limit;
-        char name[32];
-        int err, i;
-        const bool userspace_managed =
-                (flags & NVGPU_GPU_IOCTL_ALLOC_AS_FLAGS_USERSPACE_MANAGED) != 0;
-
-        /* note: keep the page sizes sorted lowest to highest here */
-        u32 gmmu_page_sizes[gmmu_nr_page_sizes] = {
-                SZ_4K,
-                big_page_size ? big_page_size : platform->default_big_page_size,
-                SZ_4K
-        };
-
-        gk20a_dbg_fn("");
-
-        if (userspace_managed) {
-                nvgpu_err(g,
-                          "userspace-managed address spaces not yet supported");
-                return -ENOSYS;
-        }
-
-        big_page_size = gmmu_page_sizes[gmmu_page_size_big];
-
-        vm = nvgpu_kzalloc(g, sizeof(*vm));
-        if (!vm)
-                return -ENOMEM;
-
-        as_share->vm = vm;
-
-        vm->mm = mm;
-        vm->as_share = as_share;
-
-        /* Set up vma pointers. */
-        vm->vma[0] = &vm->user;
-        vm->vma[1] = &vm->user;
-        vm->vma[2] = &vm->kernel;
-
-        for (i = 0; i < gmmu_nr_page_sizes; i++)
-                vm->gmmu_page_sizes[i] = gmmu_page_sizes[i];
-
-        vm->big_pages = !mm->disable_bigpage;
-        vm->big_page_size = big_page_size;
-
-        vm->va_start  = big_page_size << 10;   /* create a one pde hole */
-        vm->va_limit  = mm->channel.user_size + mm->channel.kernel_size;
-
-        msg.cmd = TEGRA_VGPU_CMD_AS_ALLOC_SHARE;
-        msg.handle = vgpu_get_handle(g);
-        p->size = vm->va_limit;
-        p->big_page_size = vm->big_page_size;
-        err = vgpu_comm_sendrecv(&msg, sizeof(msg), sizeof(msg));
-        if (err || msg.ret) {
-                err = -ENOMEM;
-                goto clean_up;
-        }
-
-        vm->handle = p->handle;
-
-        /* setup vma limits */
-        user_vma_start = vm->va_start;
-        user_vma_limit = vm->va_limit - mm->channel.kernel_size;
-
-        kernel_vma_start = vm->va_limit - mm->channel.kernel_size;
-        kernel_vma_limit = vm->va_limit;
-
-        gk20a_dbg_info(
-                "user_vma=[0x%llx,0x%llx) kernel_vma=[0x%llx,0x%llx)\n",
-                user_vma_start, user_vma_limit,
-                kernel_vma_start, kernel_vma_limit);
-
-        WARN_ON(user_vma_start > user_vma_limit);
-        WARN_ON(kernel_vma_start >= kernel_vma_limit);
-
-        if (user_vma_start > user_vma_limit ||
-            kernel_vma_start >= kernel_vma_limit) {
-                err = -EINVAL;
-                goto clean_up_share;
-        }
-
-        if (user_vma_start < user_vma_limit) {
-                snprintf(name, sizeof(name), "gk20a_as_%d-%dKB", as_share->id,
-                         gmmu_page_sizes[gmmu_page_size_small] >> 10);
-                if (!nvgpu_big_pages_possible(vm, user_vma_start,
-                                              user_vma_limit - user_vma_start))
-                        vm->big_pages = false;
-
-                err = __nvgpu_buddy_allocator_init(
-                                        g,
-                                        vm->vma[gmmu_page_size_small],
-                                        vm, name,
-                                        user_vma_start,
-                                        user_vma_limit - user_vma_start,
-                                        SZ_4K,
-                                        GPU_BALLOC_MAX_ORDER,
-                                        GPU_ALLOC_GVA_SPACE);
-                if (err)
-                        goto clean_up_share;
-        } else {
-                /*
-                 * Make these allocator pointers point to the kernel allocator
-                 * since we still use the legacy notion of page size to choose
-                 * the allocator.
-                 */
-                vm->vma[0] = &vm->kernel;
-                vm->vma[1] = &vm->kernel;
-        }
-
-        snprintf(name, sizeof(name), "gk20a_as_%dKB-sys",
-                 gmmu_page_sizes[gmmu_page_size_kernel] >> 10);
-        if (!nvgpu_big_pages_possible(vm, kernel_vma_start,
-                                     kernel_vma_limit - kernel_vma_start))
-                vm->big_pages = false;
-
-        /*
-         * kernel reserved VMA is at the end of the aperture
-         */
-        err = __nvgpu_buddy_allocator_init(
-                                g,
-                                vm->vma[gmmu_page_size_kernel],
-                                vm, name,
-                                kernel_vma_start,
-                                kernel_vma_limit - kernel_vma_start,
-                                SZ_4K,
-                                GPU_BALLOC_MAX_ORDER,
-                                GPU_ALLOC_GVA_SPACE);
-        if (err)
-                goto clean_up_user_allocator;
-
-        vm->mapped_buffers = NULL;
-
-        nvgpu_mutex_init(&vm->update_gmmu_lock);
-        kref_init(&vm->ref);
-        nvgpu_init_list_node(&vm->vm_area_list);
-
-        vm->enable_ctag = true;
-
-        return 0;
-
-clean_up_user_allocator:
-        if (user_vma_start < user_vma_limit)
-                nvgpu_alloc_destroy(&vm->user);
-clean_up_share:
-        msg.cmd = TEGRA_VGPU_CMD_AS_FREE_SHARE;
-        msg.handle = vgpu_get_handle(g);
-        p->handle = vm->handle;
-        WARN_ON(vgpu_comm_sendrecv(&msg, sizeof(msg), sizeof(msg)) || msg.ret);
-clean_up:
-        nvgpu_kfree(g, vm);
-        as_share->vm = NULL;
-        return err;
-}
-
 static int vgpu_vm_bind_channel(struct gk20a_as_share *as_share,
                                 struct channel_gk20a *ch)
 {
@@ -501,7 +369,6 @@ void vgpu_init_mm_ops(struct gpu_ops *gops)
         gops->fb.set_debug_mode = vgpu_mm_mmu_set_debug_mode;
         gops->mm.gmmu_map = vgpu_locked_gmmu_map;
         gops->mm.gmmu_unmap = vgpu_locked_gmmu_unmap;
-        gops->mm.vm_alloc_share = vgpu_vm_alloc_share;
         gops->mm.vm_bind_channel = vgpu_vm_bind_channel;
         gops->mm.fb_flush = vgpu_mm_fb_flush;
         gops->mm.l2_invalidate = vgpu_mm_l2_invalidate;