Merge airlied/drm-next into drm-misc-next

Backmerge the main pull request to sync up with all the newly landed
drivers. Otherwise we'll have chaos even before 4.12 started in
earnest.

Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>

17 files changed, 226 insertions, 262 deletions

diff --git a/drivers/gpu/drm/i915/gvt/aperture_gm.c b/drivers/gpu/drm/i915/gvt/aperture_gm.c
index 7311aeab16f7..3b6caaca9751 100644
--- a/drivers/gpu/drm/i915/gvt/aperture_gm.c
+++ b/drivers/gpu/drm/i915/gvt/aperture_gm.c
@@ -49,20 +49,21 @@ static int alloc_gm(struct intel_vgpu *vgpu, bool high_gm)
         if (high_gm) {
                 node = &vgpu->gm.high_gm_node;
                 size = vgpu_hidden_sz(vgpu);
-                start = gvt_hidden_gmadr_base(gvt);
-                end = gvt_hidden_gmadr_end(gvt);
+                start = ALIGN(gvt_hidden_gmadr_base(gvt), I915_GTT_PAGE_SIZE);
+                end = ALIGN(gvt_hidden_gmadr_end(gvt), I915_GTT_PAGE_SIZE);
                 flags = PIN_HIGH;
         } else {
                 node = &vgpu->gm.low_gm_node;
                 size = vgpu_aperture_sz(vgpu);
-                start = gvt_aperture_gmadr_base(gvt);
-                end = gvt_aperture_gmadr_end(gvt);
+                start = ALIGN(gvt_aperture_gmadr_base(gvt), I915_GTT_PAGE_SIZE);
+                end = ALIGN(gvt_aperture_gmadr_end(gvt), I915_GTT_PAGE_SIZE);
                 flags = PIN_MAPPABLE;
         }
 
         mutex_lock(&dev_priv->drm.struct_mutex);
         ret = i915_gem_gtt_insert(&dev_priv->ggtt.base, node,
-                                  size, 4096, I915_COLOR_UNEVICTABLE,
+                                  size, I915_GTT_PAGE_SIZE,
+                                  I915_COLOR_UNEVICTABLE,
                                   start, end, flags);
         mutex_unlock(&dev_priv->drm.struct_mutex);
         if (ret)
@@ -254,7 +255,7 @@ static int alloc_resource(struct intel_vgpu *vgpu,
         if (request > avail)
                 goto no_enough_resource;
 
-        vgpu_aperture_sz(vgpu) = request;
+        vgpu_aperture_sz(vgpu) = ALIGN(request, I915_GTT_PAGE_SIZE);
 
         item = "high GM space";
         max = gvt_hidden_sz(gvt) - HOST_HIGH_GM_SIZE;
@@ -265,7 +266,7 @@ static int alloc_resource(struct intel_vgpu *vgpu,
         if (request > avail)
                 goto no_enough_resource;
 
-        vgpu_hidden_sz(vgpu) = request;
+        vgpu_hidden_sz(vgpu) = ALIGN(request, I915_GTT_PAGE_SIZE);
 
         item = "fence";
         max = gvt_fence_sz(gvt) - HOST_FENCE;
diff --git a/drivers/gpu/drm/i915/gvt/cmd_parser.c b/drivers/gpu/drm/i915/gvt/cmd_parser.c
index 9a4b23c3ee97..b9c8e2407682 100644
--- a/drivers/gpu/drm/i915/gvt/cmd_parser.c
+++ b/drivers/gpu/drm/i915/gvt/cmd_parser.c
@@ -481,7 +481,6 @@ struct parser_exec_state {
         (s->vgpu->gvt->device_info.gmadr_bytes_in_cmd >> 2)
 
 static unsigned long bypass_scan_mask = 0;
-static bool bypass_batch_buffer_scan = true;
 
 /* ring ALL, type = 0 */
 static struct sub_op_bits sub_op_mi[] = {
@@ -1135,6 +1134,8 @@ static int skl_decode_mi_display_flip(struct parser_exec_state *s,
         u32 dword2 = cmd_val(s, 2);
         u32 plane = (dword0 & GENMASK(12, 8)) >> 8;
 
+        info->plane = PRIMARY_PLANE;
+
         switch (plane) {
         case MI_DISPLAY_FLIP_SKL_PLANE_1_A:
                 info->pipe = PIPE_A;
@@ -1148,12 +1149,28 @@ static int skl_decode_mi_display_flip(struct parser_exec_state *s,
                 info->pipe = PIPE_C;
                 info->event = PRIMARY_C_FLIP_DONE;
                 break;
+
+        case MI_DISPLAY_FLIP_SKL_PLANE_2_A:
+                info->pipe = PIPE_A;
+                info->event = SPRITE_A_FLIP_DONE;
+                info->plane = SPRITE_PLANE;
+                break;
+        case MI_DISPLAY_FLIP_SKL_PLANE_2_B:
+                info->pipe = PIPE_B;
+                info->event = SPRITE_B_FLIP_DONE;
+                info->plane = SPRITE_PLANE;
+                break;
+        case MI_DISPLAY_FLIP_SKL_PLANE_2_C:
+                info->pipe = PIPE_C;
+                info->event = SPRITE_C_FLIP_DONE;
+                info->plane = SPRITE_PLANE;
+                break;
+
         default:
                 gvt_err("unknown plane code %d\n", plane);
                 return -EINVAL;
         }
 
-        info->pipe = PRIMARY_PLANE;
         info->stride_val = (dword1 & GENMASK(15, 6)) >> 6;
         info->tile_val = (dword1 & GENMASK(2, 0));
         info->surf_val = (dword2 & GENMASK(31, 12)) >> 12;
@@ -1525,9 +1542,6 @@ static int batch_buffer_needs_scan(struct parser_exec_state *s)
 {
         struct intel_gvt *gvt = s->vgpu->gvt;
 
-        if (bypass_batch_buffer_scan)
-                return 0;
-
         if (IS_BROADWELL(gvt->dev_priv) || IS_SKYLAKE(gvt->dev_priv)) {
                 /* BDW decides privilege based on address space */
                 if (cmd_val(s, 0) & (1 << 8))
diff --git a/drivers/gpu/drm/i915/gvt/display.c b/drivers/gpu/drm/i915/gvt/display.c
index c0c884aeb30e..6d8fde880c39 100644
--- a/drivers/gpu/drm/i915/gvt/display.c
+++ b/drivers/gpu/drm/i915/gvt/display.c
@@ -83,7 +83,7 @@ static int pipe_is_enabled(struct intel_vgpu *vgpu, int pipe)
         return 0;
 }
 
-/* EDID with 1024x768 as its resolution */
+/* EDID with 1920x1200 as its resolution */
 static unsigned char virtual_dp_monitor_edid[] = {
         /*Header*/
         0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
@@ -97,11 +97,16 @@ static unsigned char virtual_dp_monitor_edid[] = {
         0xfc, 0x81, 0xa4, 0x55, 0x4d, 0x9d, 0x25, 0x12, 0x50, 0x54,
         /* Established Timings: maximum resolution is 1024x768 */
         0x21, 0x08, 0x00,
-        /* Standard Timings. All invalid */
-        0x00, 0xc0, 0x00, 0xc0, 0x00, 0x40, 0x00, 0x80, 0x00, 0x00,
-        0x00, 0x40, 0x00, 0x00, 0x00, 0x01,
-        /* 18 Byte Data Blocks 1: invalid */
-        0x00, 0x00, 0x80, 0xa0, 0x70, 0xb0,
+        /*
+         * Standard Timings.
+         * below new resolutions can be supported:
+         * 1920x1080, 1280x720, 1280x960, 1280x1024,
+         * 1440x900, 1600x1200, 1680x1050
+         */
+        0xd1, 0xc0, 0x81, 0xc0, 0x81, 0x40, 0x81, 0x80, 0x95, 0x00,
+        0xa9, 0x40, 0xb3, 0x00, 0x01, 0x01,
+        /* 18 Byte Data Blocks 1: max resolution is 1920x1200 */
+        0x28, 0x3c, 0x80, 0xa0, 0x70, 0xb0,
         0x23, 0x40, 0x30, 0x20, 0x36, 0x00, 0x06, 0x44, 0x21, 0x00, 0x00, 0x1a,
         /* 18 Byte Data Blocks 2: invalid */
         0x00, 0x00, 0x00, 0xfd, 0x00, 0x18, 0x3c, 0x18, 0x50, 0x11, 0x00, 0x0a,
@@ -115,7 +120,7 @@ static unsigned char virtual_dp_monitor_edid[] = {
         /* Extension Block Count */
         0x00,
         /* Checksum */
-        0xef,
+        0x45,
 };
 
 #define DPCD_HEADER_SIZE        0xb
@@ -328,3 +333,15 @@ int intel_vgpu_init_display(struct intel_vgpu *vgpu)
         else
                 return setup_virtual_dp_monitor(vgpu, PORT_B, GVT_DP_B);
 }
+
+/**
+ * intel_vgpu_reset_display- reset vGPU virtual display emulation
+ * @vgpu: a vGPU
+ *
+ * This function is used to reset vGPU virtual display emulation stuffs
+ *
+ */
+void intel_vgpu_reset_display(struct intel_vgpu *vgpu)
+{
+        emulate_monitor_status_change(vgpu);
+}
diff --git a/drivers/gpu/drm/i915/gvt/display.h b/drivers/gpu/drm/i915/gvt/display.h
index 7a60cb848268..8b234ea961f6 100644
--- a/drivers/gpu/drm/i915/gvt/display.h
+++ b/drivers/gpu/drm/i915/gvt/display.h
@@ -158,6 +158,7 @@ void intel_gvt_emulate_vblank(struct intel_gvt *gvt);
 void intel_gvt_check_vblank_emulation(struct intel_gvt *gvt);
 
 int intel_vgpu_init_display(struct intel_vgpu *vgpu);
+void intel_vgpu_reset_display(struct intel_vgpu *vgpu);
 void intel_vgpu_clean_display(struct intel_vgpu *vgpu);
 
 #endif
diff --git a/drivers/gpu/drm/i915/gvt/execlist.c b/drivers/gpu/drm/i915/gvt/execlist.c
index f32bb6f6495c..46eb9fd3c03f 100644
--- a/drivers/gpu/drm/i915/gvt/execlist.c
+++ b/drivers/gpu/drm/i915/gvt/execlist.c
@@ -364,58 +364,30 @@ static void free_workload(struct intel_vgpu_workload *workload)
 #define get_desc_from_elsp_dwords(ed, i) \
         ((struct execlist_ctx_descriptor_format *)&((ed)->data[i * 2]))
 
-
-#define BATCH_BUFFER_ADDR_MASK ((1UL << 32) - (1U << 2))
-#define BATCH_BUFFER_ADDR_HIGH_MASK ((1UL << 16) - (1U))
-static int set_gma_to_bb_cmd(struct intel_shadow_bb_entry *entry_obj,
-                             unsigned long add, int gmadr_bytes)
-{
-        if (WARN_ON(gmadr_bytes != 4 && gmadr_bytes != 8))
-                return -1;
-
-        *((u32 *)(entry_obj->bb_start_cmd_va + (1 << 2))) = add &
-                BATCH_BUFFER_ADDR_MASK;
-        if (gmadr_bytes == 8) {
-                *((u32 *)(entry_obj->bb_start_cmd_va + (2 << 2))) =
-                        add & BATCH_BUFFER_ADDR_HIGH_MASK;
-        }
-
-        return 0;
-}
-
 static void prepare_shadow_batch_buffer(struct intel_vgpu_workload *workload)
 {
-        int gmadr_bytes = workload->vgpu->gvt->device_info.gmadr_bytes_in_cmd;
+        const int gmadr_bytes = workload->vgpu->gvt->device_info.gmadr_bytes_in_cmd;
+        struct intel_shadow_bb_entry *entry_obj;
 
         /* pin the gem object to ggtt */
-        if (!list_empty(&workload->shadow_bb)) {
-                struct intel_shadow_bb_entry *entry_obj =
-                        list_first_entry(&workload->shadow_bb,
-                                         struct intel_shadow_bb_entry,
-                                         list);
-                struct intel_shadow_bb_entry *temp;
+        list_for_each_entry(entry_obj, &workload->shadow_bb, list) {
+                struct i915_vma *vma;
 
-                list_for_each_entry_safe(entry_obj, temp, &workload->shadow_bb,
-                                list) {
-                        struct i915_vma *vma;
-
-                        vma = i915_gem_object_ggtt_pin(entry_obj->obj, NULL, 0,
-                                                       4, 0);
-                        if (IS_ERR(vma)) {
-                                gvt_err("Cannot pin\n");
-                                return;
-                        }
-
-                        /* FIXME: we are not tracking our pinned VMA leaving it
-                         * up to the core to fix up the stray pin_count upon
-                         * free.
-                         */
-
-                        /* update the relocate gma with shadow batch buffer*/
-                        set_gma_to_bb_cmd(entry_obj,
-                                          i915_ggtt_offset(vma),
-                                          gmadr_bytes);
+                vma = i915_gem_object_ggtt_pin(entry_obj->obj, NULL, 0, 4, 0);
+                if (IS_ERR(vma)) {
+                        gvt_err("Cannot pin\n");
+                        return;
                 }
+
+                /* FIXME: we are not tracking our pinned VMA leaving it
+                 * up to the core to fix up the stray pin_count upon
+                 * free.
+                 */
+
+                /* update the relocate gma with shadow batch buffer*/
+                entry_obj->bb_start_cmd_va[1] = i915_ggtt_offset(vma);
+                if (gmadr_bytes == 8)
+                        entry_obj->bb_start_cmd_va[2] = 0;
         }
 }
 
@@ -515,7 +487,7 @@ static void release_shadow_batch_buffer(struct intel_vgpu_workload *workload)
 
 static void release_shadow_wa_ctx(struct intel_shadow_wa_ctx *wa_ctx)
 {
-        if (wa_ctx->indirect_ctx.size == 0)
+        if (!wa_ctx->indirect_ctx.obj)
                 return;
 
         i915_gem_object_unpin_map(wa_ctx->indirect_ctx.obj);
@@ -826,7 +798,7 @@ int intel_vgpu_init_execlist(struct intel_vgpu *vgpu)
                 INIT_LIST_HEAD(&vgpu->workload_q_head[i]);
         }
 
-        vgpu->workloads = kmem_cache_create("gvt-g vgpu workload",
+        vgpu->workloads = kmem_cache_create("gvt-g_vgpu_workload",
                         sizeof(struct intel_vgpu_workload), 0,
                         SLAB_HWCACHE_ALIGN,
                         NULL);
diff --git a/drivers/gpu/drm/i915/gvt/firmware.c b/drivers/gpu/drm/i915/gvt/firmware.c
index 2fae2a2ca96f..1cb29b2d7dc6 100644
--- a/drivers/gpu/drm/i915/gvt/firmware.c
+++ b/drivers/gpu/drm/i915/gvt/firmware.c
@@ -48,31 +48,6 @@ struct gvt_firmware_header {
         unsigned char data[1];
 };
 
-#define RD(offset) (readl(mmio + offset.reg))
-#define WR(v, offset) (writel(v, mmio + offset.reg))
-
-static void bdw_forcewake_get(void __iomem *mmio)
-{
-        WR(_MASKED_BIT_DISABLE(0xffff), FORCEWAKE_MT);
-
-        RD(ECOBUS);
-
-        if (wait_for((RD(FORCEWAKE_ACK_HSW) & FORCEWAKE_KERNEL) == 0, 50))
-                gvt_err("fail to wait forcewake idle\n");
-
-        WR(_MASKED_BIT_ENABLE(FORCEWAKE_KERNEL), FORCEWAKE_MT);
-
-        if (wait_for((RD(FORCEWAKE_ACK_HSW) & FORCEWAKE_KERNEL), 50))
-                gvt_err("fail to wait forcewake ack\n");
-
-        if (wait_for((RD(GEN6_GT_THREAD_STATUS_REG) &
-                      GEN6_GT_THREAD_STATUS_CORE_MASK) == 0, 50))
-                gvt_err("fail to wait c0 wake up\n");
-}
-
-#undef RD
-#undef WR
-
 #define dev_to_drm_minor(d) dev_get_drvdata((d))
 
 static ssize_t
@@ -91,9 +66,9 @@ static struct bin_attribute firmware_attr = {
         .mmap = NULL,
 };
 
-static int expose_firmware_sysfs(struct intel_gvt *gvt,
-                                        void __iomem *mmio)
+static int expose_firmware_sysfs(struct intel_gvt *gvt)
 {
+        struct drm_i915_private *dev_priv = gvt->dev_priv;
         struct intel_gvt_device_info *info = &gvt->device_info;
         struct pci_dev *pdev = gvt->dev_priv->drm.pdev;
         struct intel_gvt_mmio_info *e;
@@ -132,7 +107,7 @@ static int expose_firmware_sysfs(struct intel_gvt *gvt,
 
                 for (j = 0; j < e->length; j += 4)
                         *(u32 *)(p + e->offset + j) =
-                                readl(mmio + e->offset + j);
+                                I915_READ_NOTRACE(_MMIO(e->offset + j));
         }
 
         memcpy(gvt->firmware.mmio, p, info->mmio_size);
@@ -235,7 +210,6 @@ int intel_gvt_load_firmware(struct intel_gvt *gvt)
         struct gvt_firmware_header *h;
         const struct firmware *fw;
         char *path;
-        void __iomem *mmio;
         void *mem;
         int ret;
 
@@ -260,17 +234,6 @@ int intel_gvt_load_firmware(struct intel_gvt *gvt)
 
         firmware->mmio = mem;
 
-        mmio = pci_iomap(pdev, info->mmio_bar, info->mmio_size);
-        if (!mmio) {
-                kfree(path);
-                kfree(firmware->cfg_space);
-                kfree(firmware->mmio);
-                return -EINVAL;
-        }
-
-        if (IS_BROADWELL(gvt->dev_priv) || IS_SKYLAKE(gvt->dev_priv))
-                bdw_forcewake_get(mmio);
-
         sprintf(path, "%s/vid_0x%04x_did_0x%04x_rid_0x%04x.golden_hw_state",
                  GVT_FIRMWARE_PATH, pdev->vendor, pdev->device,
                  pdev->revision);
@@ -300,13 +263,11 @@ int intel_gvt_load_firmware(struct intel_gvt *gvt)
 
         release_firmware(fw);
         firmware->firmware_loaded = true;
-        pci_iounmap(pdev, mmio);
         return 0;
 
 out_free_fw:
         release_firmware(fw);
 expose_firmware:
-        expose_firmware_sysfs(gvt, mmio);
-        pci_iounmap(pdev, mmio);
+        expose_firmware_sysfs(gvt);
         return 0;
 }
diff --git a/drivers/gpu/drm/i915/gvt/gtt.c b/drivers/gpu/drm/i915/gvt/gtt.c
index 47dec4acf7ff..28c92346db0e 100644
--- a/drivers/gpu/drm/i915/gvt/gtt.c
+++ b/drivers/gpu/drm/i915/gvt/gtt.c
@@ -606,21 +606,33 @@ struct intel_vgpu_guest_page *intel_vgpu_find_guest_page(
 static inline int init_shadow_page(struct intel_vgpu *vgpu,
                 struct intel_vgpu_shadow_page *p, int type)
 {
+        struct device *kdev = &vgpu->gvt->dev_priv->drm.pdev->dev;
+        dma_addr_t daddr;
+
+        daddr = dma_map_page(kdev, p->page, 0, 4096, PCI_DMA_BIDIRECTIONAL);
+        if (dma_mapping_error(kdev, daddr)) {
+                gvt_err("fail to map dma addr\n");
+                return -EINVAL;
+        }
+
         p->vaddr = page_address(p->page);
         p->type = type;
 
         INIT_HLIST_NODE(&p->node);
 
-        p->mfn = intel_gvt_hypervisor_virt_to_mfn(p->vaddr);
-        if (p->mfn == INTEL_GVT_INVALID_ADDR)
-                return -EFAULT;
-
+        p->mfn = daddr >> GTT_PAGE_SHIFT;
         hash_add(vgpu->gtt.shadow_page_hash_table, &p->node, p->mfn);
         return 0;
 }
 
-static inline void clean_shadow_page(struct intel_vgpu_shadow_page *p)
+static inline void clean_shadow_page(struct intel_vgpu *vgpu,
+                struct intel_vgpu_shadow_page *p)
 {
+        struct device *kdev = &vgpu->gvt->dev_priv->drm.pdev->dev;
+
+        dma_unmap_page(kdev, p->mfn << GTT_PAGE_SHIFT, 4096,
+                        PCI_DMA_BIDIRECTIONAL);
+
         if (!hlist_unhashed(&p->node))
                 hash_del(&p->node);
 }
@@ -670,7 +682,7 @@ static void ppgtt_free_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
 {
         trace_spt_free(spt->vgpu->id, spt, spt->shadow_page.type);
 
-        clean_shadow_page(&spt->shadow_page);
+        clean_shadow_page(spt->vgpu, &spt->shadow_page);
         intel_vgpu_clean_guest_page(spt->vgpu, &spt->guest_page);
         list_del_init(&spt->post_shadow_list);
 
@@ -1875,8 +1887,9 @@ static int alloc_scratch_pages(struct intel_vgpu *vgpu,
         int page_entry_num = GTT_PAGE_SIZE >>
                                 vgpu->gvt->device_info.gtt_entry_size_shift;
         void *scratch_pt;
-        unsigned long mfn;
         int i;
+        struct device *dev = &vgpu->gvt->dev_priv->drm.pdev->dev;
+        dma_addr_t daddr;
 
         if (WARN_ON(type < GTT_TYPE_PPGTT_PTE_PT || type >= GTT_TYPE_MAX))
                 return -EINVAL;
@@ -1887,16 +1900,18 @@ static int alloc_scratch_pages(struct intel_vgpu *vgpu,
                 return -ENOMEM;
         }
 
-        mfn = intel_gvt_hypervisor_virt_to_mfn(scratch_pt);
-        if (mfn == INTEL_GVT_INVALID_ADDR) {
-                gvt_err("fail to translate vaddr:0x%lx\n", (unsigned long)scratch_pt);
-                free_page((unsigned long)scratch_pt);
-                return -EFAULT;
+        daddr = dma_map_page(dev, virt_to_page(scratch_pt), 0,
+                        4096, PCI_DMA_BIDIRECTIONAL);
+        if (dma_mapping_error(dev, daddr)) {
+                gvt_err("fail to dmamap scratch_pt\n");
+                __free_page(virt_to_page(scratch_pt));
+                return -ENOMEM;
         }
-        gtt->scratch_pt[type].page_mfn = mfn;
+        gtt->scratch_pt[type].page_mfn =
+                (unsigned long)(daddr >> GTT_PAGE_SHIFT);
         gtt->scratch_pt[type].page = virt_to_page(scratch_pt);
         gvt_dbg_mm("vgpu%d create scratch_pt: type %d mfn=0x%lx\n",
-                        vgpu->id, type, mfn);
+                        vgpu->id, type, gtt->scratch_pt[type].page_mfn);
 
         /* Build the tree by full filled the scratch pt with the entries which
          * point to the next level scratch pt or scratch page. The
@@ -1930,9 +1945,14 @@ static int alloc_scratch_pages(struct intel_vgpu *vgpu,
 static int release_scratch_page_tree(struct intel_vgpu *vgpu)
 {
         int i;
+        struct device *dev = &vgpu->gvt->dev_priv->drm.pdev->dev;
+        dma_addr_t daddr;
 
         for (i = GTT_TYPE_PPGTT_PTE_PT; i < GTT_TYPE_MAX; i++) {
                 if (vgpu->gtt.scratch_pt[i].page != NULL) {
+                        daddr = (dma_addr_t)(vgpu->gtt.scratch_pt[i].page_mfn <<
+                                        GTT_PAGE_SHIFT);
+                        dma_unmap_page(dev, daddr, 4096, PCI_DMA_BIDIRECTIONAL);
                         __free_page(vgpu->gtt.scratch_pt[i].page);
                         vgpu->gtt.scratch_pt[i].page = NULL;
                         vgpu->gtt.scratch_pt[i].page_mfn = 0;
@@ -2192,6 +2212,8 @@ int intel_gvt_init_gtt(struct intel_gvt *gvt)
 {
         int ret;
         void *page;
+        struct device *dev = &gvt->dev_priv->drm.pdev->dev;
+        dma_addr_t daddr;
 
         gvt_dbg_core("init gtt\n");
 
@@ -2209,14 +2231,16 @@ int intel_gvt_init_gtt(struct intel_gvt *gvt)
                 gvt_err("fail to allocate scratch ggtt page\n");
                 return -ENOMEM;
         }
-        gvt->gtt.scratch_ggtt_page = virt_to_page(page);
 
-        gvt->gtt.scratch_ggtt_mfn = intel_gvt_hypervisor_virt_to_mfn(page);
-        if (gvt->gtt.scratch_ggtt_mfn == INTEL_GVT_INVALID_ADDR) {
-                gvt_err("fail to translate scratch ggtt page\n");
-                __free_page(gvt->gtt.scratch_ggtt_page);
-                return -EFAULT;
+        daddr = dma_map_page(dev, virt_to_page(page), 0,
+                        4096, PCI_DMA_BIDIRECTIONAL);
+        if (dma_mapping_error(dev, daddr)) {
+                gvt_err("fail to dmamap scratch ggtt page\n");
+                __free_page(virt_to_page(page));
+                return -ENOMEM;
         }
+        gvt->gtt.scratch_ggtt_page = virt_to_page(page);
+        gvt->gtt.scratch_ggtt_mfn = (unsigned long)(daddr >> GTT_PAGE_SHIFT);
 
         if (enable_out_of_sync) {
                 ret = setup_spt_oos(gvt);
@@ -2239,6 +2263,12 @@ int intel_gvt_init_gtt(struct intel_gvt *gvt)
  */
 void intel_gvt_clean_gtt(struct intel_gvt *gvt)
 {
+        struct device *dev = &gvt->dev_priv->drm.pdev->dev;
+        dma_addr_t daddr = (dma_addr_t)(gvt->gtt.scratch_ggtt_mfn <<
+                                        GTT_PAGE_SHIFT);
+
+        dma_unmap_page(dev, daddr, 4096, PCI_DMA_BIDIRECTIONAL);
+
         __free_page(gvt->gtt.scratch_ggtt_page);
 
         if (enable_out_of_sync)
diff --git a/drivers/gpu/drm/i915/gvt/gvt.c b/drivers/gpu/drm/i915/gvt/gvt.c
index e6bf5c533fbe..3b9d59e457ba 100644
--- a/drivers/gpu/drm/i915/gvt/gvt.c
+++ b/drivers/gpu/drm/i915/gvt/gvt.c
@@ -68,8 +68,6 @@ static const struct intel_gvt_ops intel_gvt_ops = {
  */
 int intel_gvt_init_host(void)
 {
-        int ret;
-
         if (intel_gvt_host.initialized)
                 return 0;
 
@@ -96,11 +94,6 @@ int intel_gvt_init_host(void)
         if (!intel_gvt_host.mpt)
                 return -EINVAL;
 
-        /* Try to detect if we're running in host instead of VM. */
-        ret = intel_gvt_hypervisor_detect_host();
-        if (ret)
-                return -ENODEV;
-
         gvt_dbg_core("Running with hypervisor %s in host mode\n",
                         supported_hypervisors[intel_gvt_host.hypervisor_type]);
 
diff --git a/drivers/gpu/drm/i915/gvt/hypercall.h b/drivers/gpu/drm/i915/gvt/hypercall.h
index 30e543f5a703..df7f33abd393 100644
--- a/drivers/gpu/drm/i915/gvt/hypercall.h
+++ b/drivers/gpu/drm/i915/gvt/hypercall.h
@@ -38,7 +38,6 @@
  * both Xen and KVM by providing dedicated hypervisor-related MPT modules.
  */
 struct intel_gvt_mpt {
-        int (*detect_host)(void);
         int (*host_init)(struct device *dev, void *gvt, const void *ops);
         void (*host_exit)(struct device *dev, void *gvt);
         int (*attach_vgpu)(void *vgpu, unsigned long *handle);
diff --git a/drivers/gpu/drm/i915/gvt/interrupt.c b/drivers/gpu/drm/i915/gvt/interrupt.c
index f7be02ac4be1..92bb247e3478 100644
--- a/drivers/gpu/drm/i915/gvt/interrupt.c
+++ b/drivers/gpu/drm/i915/gvt/interrupt.c
@@ -176,26 +176,15 @@ int intel_vgpu_reg_imr_handler(struct intel_vgpu *vgpu,
 {
         struct intel_gvt *gvt = vgpu->gvt;
         struct intel_gvt_irq_ops *ops = gvt->irq.ops;
-        u32 changed, masked, unmasked;
         u32 imr = *(u32 *)p_data;
 
-        gvt_dbg_irq("write IMR %x with val %x\n",
-                reg, imr);
-
-        gvt_dbg_irq("old vIMR %x\n", vgpu_vreg(vgpu, reg));
-
-        /* figure out newly masked/unmasked bits */
-        changed = vgpu_vreg(vgpu, reg) ^ imr;
-        masked = (vgpu_vreg(vgpu, reg) & changed) ^ changed;
-        unmasked = masked ^ changed;
-
-        gvt_dbg_irq("changed %x, masked %x, unmasked %x\n",
-                changed, masked, unmasked);
+        gvt_dbg_irq("write IMR %x, new %08x, old %08x, changed %08x\n",
+                    reg, imr, vgpu_vreg(vgpu, reg), vgpu_vreg(vgpu, reg) ^ imr);
 
         vgpu_vreg(vgpu, reg) = imr;
 
         ops->check_pending_irq(vgpu);
-        gvt_dbg_irq("IRQ: new vIMR %x\n", vgpu_vreg(vgpu, reg));
+
         return 0;
 }
 
@@ -217,14 +206,11 @@ int intel_vgpu_reg_master_irq_handler(struct intel_vgpu *vgpu,
 {
         struct intel_gvt *gvt = vgpu->gvt;
         struct intel_gvt_irq_ops *ops = gvt->irq.ops;
-        u32 changed, enabled, disabled;
         u32 ier = *(u32 *)p_data;
         u32 virtual_ier = vgpu_vreg(vgpu, reg);
 
-        gvt_dbg_irq("write master irq reg %x with val %x\n",
-                reg, ier);
-
-        gvt_dbg_irq("old vreg %x\n", vgpu_vreg(vgpu, reg));
+        gvt_dbg_irq("write MASTER_IRQ %x, new %08x, old %08x, changed %08x\n",
+                    reg, ier, virtual_ier, virtual_ier ^ ier);
 
         /*
          * GEN8_MASTER_IRQ is a special irq register,
@@ -236,16 +222,8 @@ int intel_vgpu_reg_master_irq_handler(struct intel_vgpu *vgpu,
         vgpu_vreg(vgpu, reg) &= ~GEN8_MASTER_IRQ_CONTROL;
         vgpu_vreg(vgpu, reg) |= ier;
 
-        /* figure out newly enabled/disable bits */
-        changed = virtual_ier ^ ier;
-        enabled = (virtual_ier & changed) ^ changed;
-        disabled = enabled ^ changed;
-
-        gvt_dbg_irq("changed %x, enabled %x, disabled %x\n",
-                        changed, enabled, disabled);
-
         ops->check_pending_irq(vgpu);
-        gvt_dbg_irq("new vreg %x\n", vgpu_vreg(vgpu, reg));
+
         return 0;
 }
 
@@ -268,21 +246,11 @@ int intel_vgpu_reg_ier_handler(struct intel_vgpu *vgpu,
         struct intel_gvt *gvt = vgpu->gvt;
         struct intel_gvt_irq_ops *ops = gvt->irq.ops;
         struct intel_gvt_irq_info *info;
-        u32 changed, enabled, disabled;
         u32 ier = *(u32 *)p_data;
 
-        gvt_dbg_irq("write IER %x with val %x\n",
-                reg, ier);
-
-        gvt_dbg_irq("old vIER %x\n", vgpu_vreg(vgpu, reg));
+        gvt_dbg_irq("write IER %x, new %08x, old %08x, changed %08x\n",
+                    reg, ier, vgpu_vreg(vgpu, reg), vgpu_vreg(vgpu, reg) ^ ier);
 
-        /* figure out newly enabled/disable bits */
-        changed = vgpu_vreg(vgpu, reg) ^ ier;
-        enabled = (vgpu_vreg(vgpu, reg) & changed) ^ changed;
-        disabled = enabled ^ changed;
-
-        gvt_dbg_irq("changed %x, enabled %x, disabled %x\n",
-                        changed, enabled, disabled);
         vgpu_vreg(vgpu, reg) = ier;
 
         info = regbase_to_irq_info(gvt, ier_to_regbase(reg));
@@ -293,7 +261,7 @@ int intel_vgpu_reg_ier_handler(struct intel_vgpu *vgpu,
                 update_upstream_irq(vgpu, info);
 
         ops->check_pending_irq(vgpu);
-        gvt_dbg_irq("new vIER %x\n", vgpu_vreg(vgpu, reg));
+
         return 0;
 }
 
@@ -317,7 +285,8 @@ int intel_vgpu_reg_iir_handler(struct intel_vgpu *vgpu, unsigned int reg,
                 iir_to_regbase(reg));
         u32 iir = *(u32 *)p_data;
 
-        gvt_dbg_irq("write IIR %x with val %x\n", reg, iir);
+        gvt_dbg_irq("write IIR %x, new %08x, old %08x, changed %08x\n",
+                    reg, iir, vgpu_vreg(vgpu, reg), vgpu_vreg(vgpu, reg) ^ iir);
 
         if (WARN_ON(!info))
                 return -EINVAL;
@@ -619,6 +588,10 @@ static void gen8_init_irq(
                 SET_BIT_INFO(irq, 3, PRIMARY_A_FLIP_DONE, INTEL_GVT_IRQ_INFO_DE_PIPE_A);
                 SET_BIT_INFO(irq, 3, PRIMARY_B_FLIP_DONE, INTEL_GVT_IRQ_INFO_DE_PIPE_B);
                 SET_BIT_INFO(irq, 3, PRIMARY_C_FLIP_DONE, INTEL_GVT_IRQ_INFO_DE_PIPE_C);
+
+                SET_BIT_INFO(irq, 4, SPRITE_A_FLIP_DONE, INTEL_GVT_IRQ_INFO_DE_PIPE_A);
+                SET_BIT_INFO(irq, 4, SPRITE_B_FLIP_DONE, INTEL_GVT_IRQ_INFO_DE_PIPE_B);
+                SET_BIT_INFO(irq, 4, SPRITE_C_FLIP_DONE, INTEL_GVT_IRQ_INFO_DE_PIPE_C);
         }
 
         /* GEN8 interrupt PCU events */
diff --git a/drivers/gpu/drm/i915/gvt/kvmgt.c b/drivers/gpu/drm/i915/gvt/kvmgt.c
index 0c9234a87a20..0f7f5d97f582 100644
--- a/drivers/gpu/drm/i915/gvt/kvmgt.c
+++ b/drivers/gpu/drm/i915/gvt/kvmgt.c
@@ -77,7 +77,7 @@ struct kvmgt_guest_info {
 struct gvt_dma {
         struct rb_node node;
         gfn_t gfn;
-        kvm_pfn_t pfn;
+        unsigned long iova;
 };
 
 static inline bool handle_valid(unsigned long handle)
@@ -89,6 +89,35 @@ static int kvmgt_guest_init(struct mdev_device *mdev);
 static void intel_vgpu_release_work(struct work_struct *work);
 static bool kvmgt_guest_exit(struct kvmgt_guest_info *info);
 
+static int gvt_dma_map_iova(struct intel_vgpu *vgpu, kvm_pfn_t pfn,
+                unsigned long *iova)
+{
+        struct page *page;
+        struct device *dev = &vgpu->gvt->dev_priv->drm.pdev->dev;
+        dma_addr_t daddr;
+
+        page = pfn_to_page(pfn);
+        if (is_error_page(page))
+                return -EFAULT;
+
+        daddr = dma_map_page(dev, page, 0, PAGE_SIZE,
+                        PCI_DMA_BIDIRECTIONAL);
+        if (dma_mapping_error(dev, daddr))
+                return -ENOMEM;
+
+        *iova = (unsigned long)(daddr >> PAGE_SHIFT);
+        return 0;
+}
+
+static void gvt_dma_unmap_iova(struct intel_vgpu *vgpu, unsigned long iova)
+{
+        struct device *dev = &vgpu->gvt->dev_priv->drm.pdev->dev;
+        dma_addr_t daddr;
+
+        daddr = (dma_addr_t)(iova << PAGE_SHIFT);
+        dma_unmap_page(dev, daddr, PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
+}
+
 static struct gvt_dma *__gvt_cache_find(struct intel_vgpu *vgpu, gfn_t gfn)
 {
         struct rb_node *node = vgpu->vdev.cache.rb_node;
@@ -111,21 +140,22 @@ out:
         return ret;
 }
 
-static kvm_pfn_t gvt_cache_find(struct intel_vgpu *vgpu, gfn_t gfn)
+static unsigned long gvt_cache_find(struct intel_vgpu *vgpu, gfn_t gfn)
 {
         struct gvt_dma *entry;
-        kvm_pfn_t pfn;
+        unsigned long iova;
 
         mutex_lock(&vgpu->vdev.cache_lock);
 
         entry = __gvt_cache_find(vgpu, gfn);
-        pfn = (entry == NULL) ? 0 : entry->pfn;
+        iova = (entry == NULL) ? INTEL_GVT_INVALID_ADDR : entry->iova;
 
         mutex_unlock(&vgpu->vdev.cache_lock);
-        return pfn;
+        return iova;
 }
 
-static void gvt_cache_add(struct intel_vgpu *vgpu, gfn_t gfn, kvm_pfn_t pfn)
+static void gvt_cache_add(struct intel_vgpu *vgpu, gfn_t gfn,
+                unsigned long iova)
 {
         struct gvt_dma *new, *itr;
         struct rb_node **link = &vgpu->vdev.cache.rb_node, *parent = NULL;
@@ -135,7 +165,7 @@ static void gvt_cache_add(struct intel_vgpu *vgpu, gfn_t gfn, kvm_pfn_t pfn)
                 return;
 
         new->gfn = gfn;
-        new->pfn = pfn;
+        new->iova = iova;
 
         mutex_lock(&vgpu->vdev.cache_lock);
         while (*link) {
@@ -182,6 +212,7 @@ static void gvt_cache_remove(struct intel_vgpu *vgpu, gfn_t gfn)
         }
 
         g1 = gfn;
+        gvt_dma_unmap_iova(vgpu, this->iova);
         rc = vfio_unpin_pages(dev, &g1, 1);
         WARN_ON(rc != 1);
         __gvt_cache_remove_entry(vgpu, this);
@@ -204,6 +235,7 @@ static void gvt_cache_destroy(struct intel_vgpu *vgpu)
         mutex_lock(&vgpu->vdev.cache_lock);
         while ((node = rb_first(&vgpu->vdev.cache))) {
                 dma = rb_entry(node, struct gvt_dma, node);
+                gvt_dma_unmap_iova(vgpu, dma->iova);
                 gfn = dma->gfn;
 
                 vfio_unpin_pages(dev, &gfn, 1);
@@ -230,8 +262,8 @@ static struct intel_vgpu_type *intel_gvt_find_vgpu_type(struct intel_gvt *gvt,
         return NULL;
 }
 
-static ssize_t available_instance_show(struct kobject *kobj, struct device *dev,
-                char *buf)
+static ssize_t available_instances_show(struct kobject *kobj,
+                                        struct device *dev, char *buf)
 {
         struct intel_vgpu_type *type;
         unsigned int num = 0;
@@ -269,12 +301,12 @@ static ssize_t description_show(struct kobject *kobj, struct device *dev,
                                 type->fence);
 }
 
-static MDEV_TYPE_ATTR_RO(available_instance);
+static MDEV_TYPE_ATTR_RO(available_instances);
 static MDEV_TYPE_ATTR_RO(device_api);
 static MDEV_TYPE_ATTR_RO(description);
 
 static struct attribute *type_attrs[] = {
-        &mdev_type_attr_available_instance.attr,
+        &mdev_type_attr_available_instances.attr,
         &mdev_type_attr_device_api.attr,
         &mdev_type_attr_description.attr,
         NULL,
@@ -965,11 +997,6 @@ static long intel_vgpu_ioctl(struct mdev_device *mdev, unsigned int cmd,
                         sparse->areas[0].offset =
                                         PAGE_ALIGN(vgpu_aperture_offset(vgpu));
                         sparse->areas[0].size = vgpu_aperture_sz(vgpu);
-                        if (!caps.buf) {
-                                kfree(caps.buf);
-                                caps.buf = NULL;
-                                caps.size = 0;
-                        }
                         break;
 
                 case VFIO_PCI_BAR3_REGION_INDEX ... VFIO_PCI_BAR5_REGION_INDEX:
@@ -1248,43 +1275,6 @@ static void kvmgt_page_track_flush_slot(struct kvm *kvm,
         spin_unlock(&kvm->mmu_lock);
 }
 
-static bool kvmgt_check_guest(void)
-{
-        unsigned int eax, ebx, ecx, edx;
-        char s[12];
-        unsigned int *i;
-
-        eax = KVM_CPUID_SIGNATURE;
-        ebx = ecx = edx = 0;
-
-        asm volatile ("cpuid"
-                      : "+a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx)
-                      :
-                      : "cc", "memory");
-        i = (unsigned int *)s;
-        i[0] = ebx;
-        i[1] = ecx;
-        i[2] = edx;
-
-        return !strncmp(s, "KVMKVMKVM", strlen("KVMKVMKVM"));
-}
-
-/**
- * NOTE:
- * It's actually impossible to check if we are running in KVM host,
- * since the "KVM host" is simply native. So we only dectect guest here.
- */
-static int kvmgt_detect_host(void)
-{
-#ifdef CONFIG_INTEL_IOMMU
-        if (intel_iommu_gfx_mapped) {
-                gvt_err("Hardware IOMMU compatibility not yet supported, try to boot with intel_iommu=igfx_off\n");
-                return -ENODEV;
-        }
-#endif
-        return kvmgt_check_guest() ? -ENODEV : 0;
-}
-
 static bool __kvmgt_vgpu_exist(struct intel_vgpu *vgpu, struct kvm *kvm)
 {
         struct intel_vgpu *itr;
@@ -1390,7 +1380,7 @@ static int kvmgt_inject_msi(unsigned long handle, u32 addr, u16 data)
 
 static unsigned long kvmgt_gfn_to_pfn(unsigned long handle, unsigned long gfn)
 {
-        unsigned long pfn;
+        unsigned long iova, pfn;
         struct kvmgt_guest_info *info;
         struct device *dev;
         int rc;
@@ -1399,9 +1389,9 @@ static unsigned long kvmgt_gfn_to_pfn(unsigned long handle, unsigned long gfn)
                 return INTEL_GVT_INVALID_ADDR;
 
         info = (struct kvmgt_guest_info *)handle;
-        pfn = gvt_cache_find(info->vgpu, gfn);
-        if (pfn != 0)
-                return pfn;
+        iova = gvt_cache_find(info->vgpu, gfn);
+        if (iova != INTEL_GVT_INVALID_ADDR)
+                return iova;
 
         pfn = INTEL_GVT_INVALID_ADDR;
         dev = mdev_dev(info->vgpu->vdev.mdev);
@@ -1410,9 +1400,16 @@ static unsigned long kvmgt_gfn_to_pfn(unsigned long handle, unsigned long gfn)
                 gvt_err("vfio_pin_pages failed for gfn 0x%lx: %d\n", gfn, rc);
                 return INTEL_GVT_INVALID_ADDR;
         }
+        /* transfer to host iova for GFX to use DMA */
+        rc = gvt_dma_map_iova(info->vgpu, pfn, &iova);
+        if (rc) {
+                gvt_err("gvt_dma_map_iova failed for gfn: 0x%lx\n", gfn);
+                vfio_unpin_pages(dev, &gfn, 1);
+                return INTEL_GVT_INVALID_ADDR;
+        }
 
-        gvt_cache_add(info->vgpu, gfn, pfn);
-        return pfn;
+        gvt_cache_add(info->vgpu, gfn, iova);
+        return iova;
 }
 
 static int kvmgt_rw_gpa(unsigned long handle, unsigned long gpa,
@@ -1459,7 +1456,6 @@ static unsigned long kvmgt_virt_to_pfn(void *addr)
 }
 
 struct intel_gvt_mpt kvmgt_mpt = {
-        .detect_host = kvmgt_detect_host,
         .host_init = kvmgt_host_init,
         .host_exit = kvmgt_host_exit,
         .attach_vgpu = kvmgt_attach_vgpu,
diff --git a/drivers/gpu/drm/i915/gvt/mpt.h b/drivers/gpu/drm/i915/gvt/mpt.h
index 1af5830c0a56..419353624c5a 100644
--- a/drivers/gpu/drm/i915/gvt/mpt.h
+++ b/drivers/gpu/drm/i915/gvt/mpt.h
@@ -44,18 +44,6 @@
  */
 
 /**
- * intel_gvt_hypervisor_detect_host - check if GVT-g is running within
- * hypervisor host/privilged domain
- *
- * Returns:
- * Zero on success, -ENODEV if current kernel is running inside a VM
- */
-static inline int intel_gvt_hypervisor_detect_host(void)
-{
-        return intel_gvt_host.mpt->detect_host();
-}
-
-/**
  * intel_gvt_hypervisor_host_init - init GVT-g host side
  *
  * Returns:
diff --git a/drivers/gpu/drm/i915/gvt/render.c b/drivers/gpu/drm/i915/gvt/render.c
index 44136b1f3aab..2b3a642284b6 100644
--- a/drivers/gpu/drm/i915/gvt/render.c
+++ b/drivers/gpu/drm/i915/gvt/render.c
@@ -236,12 +236,18 @@ static void restore_mocs(struct intel_vgpu *vgpu, int ring_id)
         }
 }
 
+#define CTX_CONTEXT_CONTROL_VAL 0x03
+
 void intel_gvt_load_render_mmio(struct intel_vgpu *vgpu, int ring_id)
 {
         struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
         struct render_mmio *mmio;
         u32 v;
         int i, array_size;
+        u32 *reg_state = vgpu->shadow_ctx->engine[ring_id].lrc_reg_state;
+        u32 ctx_ctrl = reg_state[CTX_CONTEXT_CONTROL_VAL];
+        u32 inhibit_mask =
+                _MASKED_BIT_ENABLE(CTX_CTRL_ENGINE_CTX_RESTORE_INHIBIT);
 
         if (IS_SKYLAKE(vgpu->gvt->dev_priv)) {
                 mmio = gen9_render_mmio_list;
@@ -257,6 +263,17 @@ void intel_gvt_load_render_mmio(struct intel_vgpu *vgpu, int ring_id)
                         continue;
 
                 mmio->value = I915_READ(mmio->reg);
+
+                /*
+                 * if it is an inhibit context, load in_context mmio
+                 * into HW by mmio write. If it is not, skip this mmio
+                 * write.
+                 */
+                if (mmio->in_context &&
+                                ((ctx_ctrl & inhibit_mask) != inhibit_mask) &&
+                                i915.enable_execlists)
+                        continue;
+
                 if (mmio->mask)
                         v = vgpu_vreg(vgpu, mmio->reg) | (mmio->mask << 16);
                 else
diff --git a/drivers/gpu/drm/i915/gvt/sched_policy.c b/drivers/gpu/drm/i915/gvt/sched_policy.c
index 678b0be85376..06c9584ac5f0 100644
--- a/drivers/gpu/drm/i915/gvt/sched_policy.c
+++ b/drivers/gpu/drm/i915/gvt/sched_policy.c
@@ -125,7 +125,6 @@ static void tbs_sched_func(struct work_struct *work)
                 vgpu_data = scheduler->current_vgpu->sched_data;
                 head = &vgpu_data->list;
         } else {
-                gvt_dbg_sched("no current vgpu search from q head\n");
                 head = &sched_data->runq_head;
         }
 
diff --git a/drivers/gpu/drm/i915/gvt/scheduler.c b/drivers/gpu/drm/i915/gvt/scheduler.c
index 7ea68a75dc46..d6b6d0efdd1a 100644
--- a/drivers/gpu/drm/i915/gvt/scheduler.c
+++ b/drivers/gpu/drm/i915/gvt/scheduler.c
@@ -169,7 +169,8 @@ static int dispatch_workload(struct intel_vgpu_workload *workload)
         gvt_dbg_sched("ring id %d prepare to dispatch workload %p\n",
                 ring_id, workload);
 
-        shadow_ctx->desc_template = workload->ctx_desc.addressing_mode <<
+        shadow_ctx->desc_template &= ~(0x3 << GEN8_CTX_ADDRESSING_MODE_SHIFT);
+        shadow_ctx->desc_template |= workload->ctx_desc.addressing_mode <<
                                     GEN8_CTX_ADDRESSING_MODE_SHIFT;
 
         mutex_lock(&dev_priv->drm.struct_mutex);
@@ -456,7 +457,7 @@ static int workload_thread(void *priv)
                 }
 
 complete:
-                gvt_dbg_sched("will complete workload %p\n, status: %d\n",
+                gvt_dbg_sched("will complete workload %p, status: %d\n",
                                 workload, workload->status);
 
                 if (workload->req)
diff --git a/drivers/gpu/drm/i915/gvt/scheduler.h b/drivers/gpu/drm/i915/gvt/scheduler.h
index 3b30c28bff51..2833dfa8c9ae 100644
--- a/drivers/gpu/drm/i915/gvt/scheduler.h
+++ b/drivers/gpu/drm/i915/gvt/scheduler.h
@@ -113,7 +113,7 @@ struct intel_shadow_bb_entry {
         struct drm_i915_gem_object *obj;
         void *va;
         unsigned long len;
-        void *bb_start_cmd_va;
+        u32 *bb_start_cmd_va;
 };
 
 #define workload_q_head(vgpu, ring_id) \
diff --git a/drivers/gpu/drm/i915/gvt/vgpu.c b/drivers/gpu/drm/i915/gvt/vgpu.c
index 7295bc8e12fb..95a97aa0051e 100644
--- a/drivers/gpu/drm/i915/gvt/vgpu.c
+++ b/drivers/gpu/drm/i915/gvt/vgpu.c
@@ -74,7 +74,7 @@ void populate_pvinfo_page(struct intel_vgpu *vgpu)
 int intel_gvt_init_vgpu_types(struct intel_gvt *gvt)
 {
         unsigned int num_types;
-        unsigned int i, low_avail;
+        unsigned int i, low_avail, high_avail;
         unsigned int min_low;
 
         /* vGPU type name is defined as GVTg_Vx_y which contains
@@ -89,9 +89,9 @@ int intel_gvt_init_vgpu_types(struct intel_gvt *gvt)
          * to indicate how many vGPU instance can be created for this
          * type.
          *
-         * Currently use static size here as we init type earlier..
          */
-        low_avail = MB_TO_BYTES(256) - HOST_LOW_GM_SIZE;
+        low_avail = gvt_aperture_sz(gvt) - HOST_LOW_GM_SIZE;
+        high_avail = gvt_hidden_sz(gvt) - HOST_HIGH_GM_SIZE;
         num_types = 4;
 
         gvt->types = kzalloc(num_types * sizeof(struct intel_vgpu_type),
@@ -106,7 +106,8 @@ int intel_gvt_init_vgpu_types(struct intel_gvt *gvt)
                 gvt->types[i].low_gm_size = min_low;
                 gvt->types[i].high_gm_size = max((min_low<<3), MB_TO_BYTES(384U));
                 gvt->types[i].fence = 4;
-                gvt->types[i].max_instance = low_avail / min_low;
+                gvt->types[i].max_instance = min(low_avail / min_low,
+                                                 high_avail / gvt->types[i].high_gm_size);
                 gvt->types[i].avail_instance = gvt->types[i].max_instance;
 
                 if (IS_GEN8(gvt->dev_priv))
@@ -142,9 +143,9 @@ static void intel_gvt_update_vgpu_types(struct intel_gvt *gvt)
         /* Need to depend on maxium hw resource size but keep on
          * static config for now.
          */
-        low_gm_avail = MB_TO_BYTES(256) - HOST_LOW_GM_SIZE -
+        low_gm_avail = gvt_aperture_sz(gvt) - HOST_LOW_GM_SIZE -
                 gvt->gm.vgpu_allocated_low_gm_size;
-        high_gm_avail = MB_TO_BYTES(256) * 8UL - HOST_HIGH_GM_SIZE -
+        high_gm_avail = gvt_hidden_sz(gvt) - HOST_HIGH_GM_SIZE -
                 gvt->gm.vgpu_allocated_high_gm_size;
         fence_avail = gvt_fence_sz(gvt) - HOST_FENCE -
                 gvt->fence.vgpu_allocated_fence_num;
@@ -384,6 +385,7 @@ void intel_gvt_reset_vgpu_locked(struct intel_vgpu *vgpu, bool dmlr,
                 intel_vgpu_reset_resource(vgpu);
                 intel_vgpu_reset_mmio(vgpu);
                 populate_pvinfo_page(vgpu);
+                intel_vgpu_reset_display(vgpu);
 
                 if (dmlr)
                         intel_vgpu_reset_cfg_space(vgpu);