drm/i915/gvt: vGPU display virtualization
authorZhi Wang <zhi.a.wang@intel.com>
Mon, 25 Apr 2016 22:28:56 +0000 (18:28 -0400)
committerZhenyu Wang <zhenyuw@linux.intel.com>
Fri, 14 Oct 2016 10:13:06 +0000 (18:13 +0800)
This patch introduces the GVT-g display virtualization.

It consists a collection of display MMIO handlers, like power well register
handler, pipe register handler, plane register handler, which will emulate
all display MMIOs behavior to support virtual mode setting sequence for
guest.

Signed-off-by: Bing Niu <bing.niu@intel.com>
Signed-off-by: Zhi Wang <zhi.a.wang@intel.com>
Signed-off-by: Zhenyu Wang <zhenyuw@linux.intel.com>
12 files changed:
drivers/gpu/drm/i915/gvt/Makefile
drivers/gpu/drm/i915/gvt/debug.h
drivers/gpu/drm/i915/gvt/display.c [new file with mode: 0644]
drivers/gpu/drm/i915/gvt/display.h [new file with mode: 0644]
drivers/gpu/drm/i915/gvt/edid.c [new file with mode: 0644]
drivers/gpu/drm/i915/gvt/edid.h [new file with mode: 0644]
drivers/gpu/drm/i915/gvt/gvt.c
drivers/gpu/drm/i915/gvt/gvt.h
drivers/gpu/drm/i915/gvt/handlers.c
drivers/gpu/drm/i915/gvt/interrupt.c
drivers/gpu/drm/i915/gvt/interrupt.h
drivers/gpu/drm/i915/gvt/vgpu.c

index 1a783a19bc4d164696442d048ee6cf76cf705647..f87cd7fe95743c1fcd8ec46ad9f313025a3ea644 100644 (file)
@@ -1,6 +1,6 @@
 GVT_DIR := gvt
 GVT_SOURCE := gvt.o aperture_gm.o handlers.o vgpu.o trace_points.o firmware.o \
-       interrupt.o gtt.o cfg_space.o opregion.o mmio.o
+       interrupt.o gtt.o cfg_space.o opregion.o mmio.o display.o edid.o
 
 ccflags-y                      += -I$(src) -I$(src)/$(GVT_DIR) -Wall
 i915-y                        += $(addprefix $(GVT_DIR)/, $(GVT_SOURCE))
index 47fabb065ac5329baaf204c253bb21d5df2279c3..5c21c585ac00469e75510d645ce714d4dd522d49 100644 (file)
@@ -39,4 +39,7 @@
 #define gvt_dbg_mmio(fmt, args...) \
        DRM_DEBUG_DRIVER("gvt: mmio: "fmt, ##args)
 
+#define gvt_dbg_dpy(fmt, args...) \
+       DRM_DEBUG_DRIVER("gvt: dpy: "fmt, ##args)
+
 #endif
diff --git a/drivers/gpu/drm/i915/gvt/display.c b/drivers/gpu/drm/i915/gvt/display.c
new file mode 100644 (file)
index 0000000..534000b
--- /dev/null
@@ -0,0 +1,329 @@
+/*
+ * Copyright(c) 2011-2016 Intel Corporation. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Authors:
+ *    Ke Yu
+ *    Zhiyuan Lv <zhiyuan.lv@intel.com>
+ *
+ * Contributors:
+ *    Terrence Xu <terrence.xu@intel.com>
+ *    Changbin Du <changbin.du@intel.com>
+ *    Bing Niu <bing.niu@intel.com>
+ *    Zhi Wang <zhi.a.wang@intel.com>
+ *
+ */
+
+#include "i915_drv.h"
+
+static int get_edp_pipe(struct intel_vgpu *vgpu)
+{
+       u32 data = vgpu_vreg(vgpu, _TRANS_DDI_FUNC_CTL_EDP);
+       int pipe = -1;
+
+       switch (data & TRANS_DDI_EDP_INPUT_MASK) {
+       case TRANS_DDI_EDP_INPUT_A_ON:
+       case TRANS_DDI_EDP_INPUT_A_ONOFF:
+               pipe = PIPE_A;
+               break;
+       case TRANS_DDI_EDP_INPUT_B_ONOFF:
+               pipe = PIPE_B;
+               break;
+       case TRANS_DDI_EDP_INPUT_C_ONOFF:
+               pipe = PIPE_C;
+               break;
+       }
+       return pipe;
+}
+
+static int edp_pipe_is_enabled(struct intel_vgpu *vgpu)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+
+       if (!(vgpu_vreg(vgpu, PIPECONF(_PIPE_EDP)) & PIPECONF_ENABLE))
+               return 0;
+
+       if (!(vgpu_vreg(vgpu, _TRANS_DDI_FUNC_CTL_EDP) & TRANS_DDI_FUNC_ENABLE))
+               return 0;
+       return 1;
+}
+
+static int pipe_is_enabled(struct intel_vgpu *vgpu, int pipe)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+
+       if (WARN_ON(pipe < PIPE_A || pipe >= I915_MAX_PIPES))
+               return -EINVAL;
+
+       if (vgpu_vreg(vgpu, PIPECONF(pipe)) & PIPECONF_ENABLE)
+               return 1;
+
+       if (edp_pipe_is_enabled(vgpu) &&
+                       get_edp_pipe(vgpu) == pipe)
+               return 1;
+       return 0;
+}
+
+/* EDID with 1024x768 as its resolution */
+static unsigned char virtual_dp_monitor_edid[] = {
+       /*Header*/
+       0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
+       /* Vendor & Product Identification */
+       0x22, 0xf0, 0x54, 0x29, 0x00, 0x00, 0x00, 0x00, 0x04, 0x17,
+       /* Version & Revision */
+       0x01, 0x04,
+       /* Basic Display Parameters & Features */
+       0xa5, 0x34, 0x20, 0x78, 0x23,
+       /* Color Characteristics */
+       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,
+       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,
+       0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+       /* 18 Byte Data Blocks 3: invalid */
+       0x00, 0x00, 0x00, 0xfc, 0x00, 0x48,
+       0x50, 0x20, 0x5a, 0x52, 0x32, 0x34, 0x34, 0x30, 0x77, 0x0a, 0x20, 0x20,
+       /* 18 Byte Data Blocks 4: invalid */
+       0x00, 0x00, 0x00, 0xff, 0x00, 0x43, 0x4e, 0x34, 0x33, 0x30, 0x34, 0x30,
+       0x44, 0x58, 0x51, 0x0a, 0x20, 0x20,
+       /* Extension Block Count */
+       0x00,
+       /* Checksum */
+       0xef,
+};
+
+#define DPCD_HEADER_SIZE        0xb
+
+u8 dpcd_fix_data[DPCD_HEADER_SIZE] = {
+       0x11, 0x0a, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static void emulate_monitor_status_change(struct intel_vgpu *vgpu)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+       vgpu_vreg(vgpu, SDEISR) &= ~(SDE_PORTB_HOTPLUG_CPT |
+                       SDE_PORTC_HOTPLUG_CPT |
+                       SDE_PORTD_HOTPLUG_CPT);
+
+       if (IS_SKYLAKE(dev_priv))
+               vgpu_vreg(vgpu, SDEISR) &= ~(SDE_PORTA_HOTPLUG_SPT |
+                               SDE_PORTE_HOTPLUG_SPT);
+
+       if (intel_vgpu_has_monitor_on_port(vgpu, PORT_B))
+               vgpu_vreg(vgpu, SDEISR) |= SDE_PORTB_HOTPLUG_CPT;
+
+       if (intel_vgpu_has_monitor_on_port(vgpu, PORT_C))
+               vgpu_vreg(vgpu, SDEISR) |= SDE_PORTC_HOTPLUG_CPT;
+
+       if (intel_vgpu_has_monitor_on_port(vgpu, PORT_D))
+               vgpu_vreg(vgpu, SDEISR) |= SDE_PORTD_HOTPLUG_CPT;
+
+       if (IS_SKYLAKE(dev_priv) &&
+                       intel_vgpu_has_monitor_on_port(vgpu, PORT_E)) {
+               vgpu_vreg(vgpu, SDEISR) |= SDE_PORTE_HOTPLUG_SPT;
+       }
+
+       if (intel_vgpu_has_monitor_on_port(vgpu, PORT_A)) {
+               if (IS_BROADWELL(dev_priv))
+                       vgpu_vreg(vgpu, GEN8_DE_PORT_ISR) |=
+                               GEN8_PORT_DP_A_HOTPLUG;
+               else
+                       vgpu_vreg(vgpu, SDEISR) |= SDE_PORTA_HOTPLUG_SPT;
+       }
+}
+
+static void clean_virtual_dp_monitor(struct intel_vgpu *vgpu, int port_num)
+{
+       struct intel_vgpu_port *port = intel_vgpu_port(vgpu, port_num);
+
+       kfree(port->edid);
+       port->edid = NULL;
+
+       kfree(port->dpcd);
+       port->dpcd = NULL;
+}
+
+static int setup_virtual_dp_monitor(struct intel_vgpu *vgpu, int port_num,
+               int type)
+{
+       struct intel_vgpu_port *port = intel_vgpu_port(vgpu, port_num);
+
+       port->edid = kzalloc(sizeof(*(port->edid)), GFP_KERNEL);
+       if (!port->edid)
+               return -ENOMEM;
+
+       port->dpcd = kzalloc(sizeof(*(port->dpcd)), GFP_KERNEL);
+       if (!port->dpcd) {
+               kfree(port->edid);
+               return -ENOMEM;
+       }
+
+       memcpy(port->edid->edid_block, virtual_dp_monitor_edid,
+                       EDID_SIZE);
+       port->edid->data_valid = true;
+
+       memcpy(port->dpcd->data, dpcd_fix_data, DPCD_HEADER_SIZE);
+       port->dpcd->data_valid = true;
+       port->dpcd->data[DPCD_SINK_COUNT] = 0x1;
+       port->type = type;
+
+       emulate_monitor_status_change(vgpu);
+       return 0;
+}
+
+/**
+ * intel_gvt_check_vblank_emulation - check if vblank emulation timer should
+ * be turned on/off when a virtual pipe is enabled/disabled.
+ * @gvt: a GVT device
+ *
+ * This function is used to turn on/off vblank timer according to currently
+ * enabled/disabled virtual pipes.
+ *
+ */
+void intel_gvt_check_vblank_emulation(struct intel_gvt *gvt)
+{
+       struct intel_gvt_irq *irq = &gvt->irq;
+       struct intel_vgpu *vgpu;
+       bool have_enabled_pipe = false;
+       int pipe, id;
+
+       if (WARN_ON(!mutex_is_locked(&gvt->lock)))
+               return;
+
+       hrtimer_cancel(&irq->vblank_timer.timer);
+
+       for_each_active_vgpu(gvt, vgpu, id) {
+               for (pipe = 0; pipe < I915_MAX_PIPES; pipe++) {
+                       have_enabled_pipe =
+                               pipe_is_enabled(vgpu, pipe);
+                       if (have_enabled_pipe)
+                               break;
+               }
+       }
+
+       if (have_enabled_pipe)
+               hrtimer_start(&irq->vblank_timer.timer,
+                       ktime_add_ns(ktime_get(), irq->vblank_timer.period),
+                       HRTIMER_MODE_ABS);
+}
+
+static void emulate_vblank_on_pipe(struct intel_vgpu *vgpu, int pipe)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+       struct intel_vgpu_irq *irq = &vgpu->irq;
+       int vblank_event[] = {
+               [PIPE_A] = PIPE_A_VBLANK,
+               [PIPE_B] = PIPE_B_VBLANK,
+               [PIPE_C] = PIPE_C_VBLANK,
+       };
+       int event;
+
+       if (pipe < PIPE_A || pipe > PIPE_C)
+               return;
+
+       for_each_set_bit(event, irq->flip_done_event[pipe],
+                       INTEL_GVT_EVENT_MAX) {
+               clear_bit(event, irq->flip_done_event[pipe]);
+               if (!pipe_is_enabled(vgpu, pipe))
+                       continue;
+
+               vgpu_vreg(vgpu, PIPE_FLIPCOUNT_G4X(pipe))++;
+               intel_vgpu_trigger_virtual_event(vgpu, event);
+       }
+
+       if (pipe_is_enabled(vgpu, pipe)) {
+               vgpu_vreg(vgpu, PIPE_FRMCOUNT_G4X(pipe))++;
+               intel_vgpu_trigger_virtual_event(vgpu, vblank_event[pipe]);
+       }
+}
+
+static void emulate_vblank(struct intel_vgpu *vgpu)
+{
+       int pipe;
+
+       for_each_pipe(vgpu->gvt->dev_priv, pipe)
+               emulate_vblank_on_pipe(vgpu, pipe);
+}
+
+/**
+ * intel_gvt_emulate_vblank - trigger vblank events for vGPUs on GVT device
+ * @gvt: a GVT device
+ *
+ * This function is used to trigger vblank interrupts for vGPUs on GVT device
+ *
+ */
+void intel_gvt_emulate_vblank(struct intel_gvt *gvt)
+{
+       struct intel_vgpu *vgpu;
+       int id;
+
+       if (WARN_ON(!mutex_is_locked(&gvt->lock)))
+               return;
+
+       for_each_active_vgpu(gvt, vgpu, id)
+               emulate_vblank(vgpu);
+}
+
+/**
+ * intel_vgpu_clean_display - clean vGPU virtual display emulation
+ * @vgpu: a vGPU
+ *
+ * This function is used to clean vGPU virtual display emulation stuffs
+ *
+ */
+void intel_vgpu_clean_display(struct intel_vgpu *vgpu)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+
+       if (IS_SKYLAKE(dev_priv))
+               clean_virtual_dp_monitor(vgpu, PORT_D);
+       else
+               clean_virtual_dp_monitor(vgpu, PORT_B);
+}
+
+/**
+ * intel_vgpu_init_display- initialize vGPU virtual display emulation
+ * @vgpu: a vGPU
+ *
+ * This function is used to initialize vGPU virtual display emulation stuffs
+ *
+ * Returns:
+ * Zero on success, negative error code if failed.
+ *
+ */
+int intel_vgpu_init_display(struct intel_vgpu *vgpu)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+
+       intel_vgpu_init_i2c_edid(vgpu);
+
+       if (IS_SKYLAKE(dev_priv))
+               return setup_virtual_dp_monitor(vgpu, PORT_D, GVT_DP_D);
+       else
+               return setup_virtual_dp_monitor(vgpu, PORT_B, GVT_DP_B);
+}
diff --git a/drivers/gpu/drm/i915/gvt/display.h b/drivers/gpu/drm/i915/gvt/display.h
new file mode 100644 (file)
index 0000000..7a60cb8
--- /dev/null
@@ -0,0 +1,163 @@
+/*
+ * Copyright(c) 2011-2016 Intel Corporation. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Authors:
+ *    Ke Yu
+ *    Zhiyuan Lv <zhiyuan.lv@intel.com>
+ *
+ * Contributors:
+ *    Terrence Xu <terrence.xu@intel.com>
+ *    Changbin Du <changbin.du@intel.com>
+ *    Bing Niu <bing.niu@intel.com>
+ *    Zhi Wang <zhi.a.wang@intel.com>
+ *
+ */
+
+#ifndef _GVT_DISPLAY_H_
+#define _GVT_DISPLAY_H_
+
+#define SBI_REG_MAX    20
+#define DPCD_SIZE      0x700
+
+#define intel_vgpu_port(vgpu, port) \
+       (&(vgpu->display.ports[port]))
+
+#define intel_vgpu_has_monitor_on_port(vgpu, port) \
+       (intel_vgpu_port(vgpu, port)->edid && \
+               intel_vgpu_port(vgpu, port)->edid->data_valid)
+
+#define intel_vgpu_port_is_dp(vgpu, port) \
+       ((intel_vgpu_port(vgpu, port)->type == GVT_DP_A) || \
+       (intel_vgpu_port(vgpu, port)->type == GVT_DP_B) || \
+       (intel_vgpu_port(vgpu, port)->type == GVT_DP_C) || \
+       (intel_vgpu_port(vgpu, port)->type == GVT_DP_D))
+
+#define INTEL_GVT_MAX_UEVENT_VARS      3
+
+/* DPCD start */
+#define DPCD_SIZE      0x700
+
+/* DPCD */
+#define DP_SET_POWER            0x600
+#define DP_SET_POWER_D0         0x1
+#define AUX_NATIVE_WRITE        0x8
+#define AUX_NATIVE_READ         0x9
+
+#define AUX_NATIVE_REPLY_MASK   (0x3 << 4)
+#define AUX_NATIVE_REPLY_ACK    (0x0 << 4)
+#define AUX_NATIVE_REPLY_NAK    (0x1 << 4)
+#define AUX_NATIVE_REPLY_DEFER  (0x2 << 4)
+
+#define AUX_BURST_SIZE          16
+
+/* DPCD addresses */
+#define DPCD_REV                       0x000
+#define DPCD_MAX_LINK_RATE             0x001
+#define DPCD_MAX_LANE_COUNT            0x002
+
+#define DPCD_TRAINING_PATTERN_SET      0x102
+#define        DPCD_SINK_COUNT                 0x200
+#define DPCD_LANE0_1_STATUS            0x202
+#define DPCD_LANE2_3_STATUS            0x203
+#define DPCD_LANE_ALIGN_STATUS_UPDATED 0x204
+#define DPCD_SINK_STATUS               0x205
+
+/* link training */
+#define DPCD_TRAINING_PATTERN_SET_MASK 0x03
+#define DPCD_LINK_TRAINING_DISABLED    0x00
+#define DPCD_TRAINING_PATTERN_1                0x01
+#define DPCD_TRAINING_PATTERN_2                0x02
+
+#define DPCD_CP_READY_MASK             (1 << 6)
+
+/* lane status */
+#define DPCD_LANES_CR_DONE             0x11
+#define DPCD_LANES_EQ_DONE             0x22
+#define DPCD_SYMBOL_LOCKED             0x44
+
+#define DPCD_INTERLANE_ALIGN_DONE      0x01
+
+#define DPCD_SINK_IN_SYNC              0x03
+/* DPCD end */
+
+#define SBI_RESPONSE_MASK               0x3
+#define SBI_RESPONSE_SHIFT              0x1
+#define SBI_STAT_MASK                   0x1
+#define SBI_STAT_SHIFT                  0x0
+#define SBI_OPCODE_SHIFT                8
+#define SBI_OPCODE_MASK                        (0xff << SBI_OPCODE_SHIFT)
+#define SBI_CMD_IORD                    2
+#define SBI_CMD_IOWR                    3
+#define SBI_CMD_CRRD                    6
+#define SBI_CMD_CRWR                    7
+#define SBI_ADDR_OFFSET_SHIFT           16
+#define SBI_ADDR_OFFSET_MASK            (0xffff << SBI_ADDR_OFFSET_SHIFT)
+
+struct intel_vgpu_sbi_register {
+       unsigned int offset;
+       u32 value;
+};
+
+struct intel_vgpu_sbi {
+       int number;
+       struct intel_vgpu_sbi_register registers[SBI_REG_MAX];
+};
+
+enum intel_gvt_plane_type {
+       PRIMARY_PLANE = 0,
+       CURSOR_PLANE,
+       SPRITE_PLANE,
+       MAX_PLANE
+};
+
+struct intel_vgpu_dpcd_data {
+       bool data_valid;
+       u8 data[DPCD_SIZE];
+};
+
+enum intel_vgpu_port_type {
+       GVT_CRT = 0,
+       GVT_DP_A,
+       GVT_DP_B,
+       GVT_DP_C,
+       GVT_DP_D,
+       GVT_HDMI_B,
+       GVT_HDMI_C,
+       GVT_HDMI_D,
+       GVT_PORT_MAX
+};
+
+struct intel_vgpu_port {
+       /* per display EDID information */
+       struct intel_vgpu_edid_data *edid;
+       /* per display DPCD information */
+       struct intel_vgpu_dpcd_data *dpcd;
+       int type;
+};
+
+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_clean_display(struct intel_vgpu *vgpu);
+
+#endif
diff --git a/drivers/gpu/drm/i915/gvt/edid.c b/drivers/gpu/drm/i915/gvt/edid.c
new file mode 100644 (file)
index 0000000..a07e427
--- /dev/null
@@ -0,0 +1,531 @@
+/*
+ * Copyright(c) 2011-2016 Intel Corporation. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Authors:
+ *    Ke Yu
+ *    Zhiyuan Lv <zhiyuan.lv@intel.com>
+ *
+ * Contributors:
+ *    Terrence Xu <terrence.xu@intel.com>
+ *    Changbin Du <changbin.du@intel.com>
+ *    Bing Niu <bing.niu@intel.com>
+ *    Zhi Wang <zhi.a.wang@intel.com>
+ *
+ */
+
+#include "i915_drv.h"
+
+#define GMBUS1_TOTAL_BYTES_SHIFT 16
+#define GMBUS1_TOTAL_BYTES_MASK 0x1ff
+#define gmbus1_total_byte_count(v) (((v) >> \
+       GMBUS1_TOTAL_BYTES_SHIFT) & GMBUS1_TOTAL_BYTES_MASK)
+#define gmbus1_slave_addr(v) (((v) & 0xff) >> 1)
+#define gmbus1_slave_index(v) (((v) >> 8) & 0xff)
+#define gmbus1_bus_cycle(v) (((v) >> 25) & 0x7)
+
+/* GMBUS0 bits definitions */
+#define _GMBUS_PIN_SEL_MASK     (0x7)
+
+static unsigned char edid_get_byte(struct intel_vgpu *vgpu)
+{
+       struct intel_vgpu_i2c_edid *edid = &vgpu->display.i2c_edid;
+       unsigned char chr = 0;
+
+       if (edid->state == I2C_NOT_SPECIFIED || !edid->slave_selected) {
+               gvt_err("Driver tries to read EDID without proper sequence!\n");
+               return 0;
+       }
+       if (edid->current_edid_read >= EDID_SIZE) {
+               gvt_err("edid_get_byte() exceeds the size of EDID!\n");
+               return 0;
+       }
+
+       if (!edid->edid_available) {
+               gvt_err("Reading EDID but EDID is not available!\n");
+               return 0;
+       }
+
+       if (intel_vgpu_has_monitor_on_port(vgpu, edid->port)) {
+               struct intel_vgpu_edid_data *edid_data =
+                       intel_vgpu_port(vgpu, edid->port)->edid;
+
+               chr = edid_data->edid_block[edid->current_edid_read];
+               edid->current_edid_read++;
+       } else {
+               gvt_err("No EDID available during the reading?\n");
+       }
+       return chr;
+}
+
+static inline int get_port_from_gmbus0(u32 gmbus0)
+{
+       int port_select = gmbus0 & _GMBUS_PIN_SEL_MASK;
+       int port = -EINVAL;
+
+       if (port_select == 2)
+               port = PORT_E;
+       else if (port_select == 4)
+               port = PORT_C;
+       else if (port_select == 5)
+               port = PORT_B;
+       else if (port_select == 6)
+               port = PORT_D;
+       return port;
+}
+
+static void reset_gmbus_controller(struct intel_vgpu *vgpu)
+{
+       vgpu_vreg(vgpu, PCH_GMBUS2) = GMBUS_HW_RDY;
+       if (!vgpu->display.i2c_edid.edid_available)
+               vgpu_vreg(vgpu, PCH_GMBUS2) |= GMBUS_SATOER;
+       vgpu->display.i2c_edid.gmbus.phase = GMBUS_IDLE_PHASE;
+}
+
+/* GMBUS0 */
+static int gmbus0_mmio_write(struct intel_vgpu *vgpu,
+                       unsigned int offset, void *p_data, unsigned int bytes)
+{
+       int port, pin_select;
+
+       memcpy(&vgpu_vreg(vgpu, offset), p_data, bytes);
+
+       pin_select = vgpu_vreg(vgpu, offset) & _GMBUS_PIN_SEL_MASK;
+
+       intel_vgpu_init_i2c_edid(vgpu);
+
+       if (pin_select == 0)
+               return 0;
+
+       port = get_port_from_gmbus0(pin_select);
+       if (WARN_ON(port < 0))
+               return 0;
+
+       vgpu->display.i2c_edid.state = I2C_GMBUS;
+       vgpu->display.i2c_edid.gmbus.phase = GMBUS_IDLE_PHASE;
+
+       vgpu_vreg(vgpu, PCH_GMBUS2) &= ~GMBUS_ACTIVE;
+       vgpu_vreg(vgpu, PCH_GMBUS2) |= GMBUS_HW_RDY | GMBUS_HW_WAIT_PHASE;
+
+       if (intel_vgpu_has_monitor_on_port(vgpu, port) &&
+                       !intel_vgpu_port_is_dp(vgpu, port)) {
+               vgpu->display.i2c_edid.port = port;
+               vgpu->display.i2c_edid.edid_available = true;
+               vgpu_vreg(vgpu, PCH_GMBUS2) &= ~GMBUS_SATOER;
+       } else
+               vgpu_vreg(vgpu, PCH_GMBUS2) |= GMBUS_SATOER;
+       return 0;
+}
+
+static int gmbus1_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       struct intel_vgpu_i2c_edid *i2c_edid = &vgpu->display.i2c_edid;
+       u32 slave_addr;
+       u32 wvalue = *(u32 *)p_data;
+
+       if (vgpu_vreg(vgpu, offset) & GMBUS_SW_CLR_INT) {
+               if (!(wvalue & GMBUS_SW_CLR_INT)) {
+                       vgpu_vreg(vgpu, offset) &= ~GMBUS_SW_CLR_INT;
+                       reset_gmbus_controller(vgpu);
+               }
+               /*
+                * TODO: "This bit is cleared to zero when an event
+                * causes the HW_RDY bit transition to occur "
+                */
+       } else {
+               /*
+                * per bspec setting this bit can cause:
+                * 1) INT status bit cleared
+                * 2) HW_RDY bit asserted
+                */
+               if (wvalue & GMBUS_SW_CLR_INT) {
+                       vgpu_vreg(vgpu, PCH_GMBUS2) &= ~GMBUS_INT;
+                       vgpu_vreg(vgpu, PCH_GMBUS2) |= GMBUS_HW_RDY;
+               }
+
+               /* For virtualization, we suppose that HW is always ready,
+                * so GMBUS_SW_RDY should always be cleared
+                */
+               if (wvalue & GMBUS_SW_RDY)
+                       wvalue &= ~GMBUS_SW_RDY;
+
+               i2c_edid->gmbus.total_byte_count =
+                       gmbus1_total_byte_count(wvalue);
+               slave_addr = gmbus1_slave_addr(wvalue);
+
+               /* vgpu gmbus only support EDID */
+               if (slave_addr == EDID_ADDR) {
+                       i2c_edid->slave_selected = true;
+               } else if (slave_addr != 0) {
+                       gvt_dbg_dpy(
+                               "vgpu%d: unsupported gmbus slave addr(0x%x)\n"
+                               "       gmbus operations will be ignored.\n",
+                                       vgpu->id, slave_addr);
+               }
+
+               if (wvalue & GMBUS_CYCLE_INDEX)
+                       i2c_edid->current_edid_read =
+                               gmbus1_slave_index(wvalue);
+
+               i2c_edid->gmbus.cycle_type = gmbus1_bus_cycle(wvalue);
+               switch (gmbus1_bus_cycle(wvalue)) {
+               case GMBUS_NOCYCLE:
+                       break;
+               case GMBUS_STOP:
+                       /* From spec:
+                        * This can only cause a STOP to be generated
+                        * if a GMBUS cycle is generated, the GMBUS is
+                        * currently in a data/wait/idle phase, or it is in a
+                        * WAIT phase
+                        */
+                       if (gmbus1_bus_cycle(vgpu_vreg(vgpu, offset))
+                               != GMBUS_NOCYCLE) {
+                               intel_vgpu_init_i2c_edid(vgpu);
+                               /* After the 'stop' cycle, hw state would become
+                                * 'stop phase' and then 'idle phase' after a
+                                * few milliseconds. In emulation, we just set
+                                * it as 'idle phase' ('stop phase' is not
+                                * visible in gmbus interface)
+                                */
+                               i2c_edid->gmbus.phase = GMBUS_IDLE_PHASE;
+                               vgpu_vreg(vgpu, PCH_GMBUS2) &= ~GMBUS_ACTIVE;
+                       }
+                       break;
+               case NIDX_NS_W:
+               case IDX_NS_W:
+               case NIDX_STOP:
+               case IDX_STOP:
+                       /* From hw spec the GMBUS phase
+                        * transition like this:
+                        * START (-->INDEX) -->DATA
+                        */
+                       i2c_edid->gmbus.phase = GMBUS_DATA_PHASE;
+                       vgpu_vreg(vgpu, PCH_GMBUS2) |= GMBUS_ACTIVE;
+                       break;
+               default:
+                       gvt_err("Unknown/reserved GMBUS cycle detected!\n");
+                       break;
+               }
+               /*
+                * From hw spec the WAIT state will be
+                * cleared:
+                * (1) in a new GMBUS cycle
+                * (2) by generating a stop
+                */
+               vgpu_vreg(vgpu, offset) = wvalue;
+       }
+       return 0;
+}
+
+static int gmbus3_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+       void *p_data, unsigned int bytes)
+{
+       WARN_ON(1);
+       return 0;
+}
+
+static int gmbus3_mmio_read(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       int i;
+       unsigned char byte_data;
+       struct intel_vgpu_i2c_edid *i2c_edid = &vgpu->display.i2c_edid;
+       int byte_left = i2c_edid->gmbus.total_byte_count -
+                               i2c_edid->current_edid_read;
+       int byte_count = byte_left;
+       u32 reg_data = 0;
+
+       /* Data can only be recevied if previous settings correct */
+       if (vgpu_vreg(vgpu, PCH_GMBUS1) & GMBUS_SLAVE_READ) {
+               if (byte_left <= 0) {
+                       memcpy(p_data, &vgpu_vreg(vgpu, offset), bytes);
+                       return 0;
+               }
+
+               if (byte_count > 4)
+                       byte_count = 4;
+               for (i = 0; i < byte_count; i++) {
+                       byte_data = edid_get_byte(vgpu);
+                       reg_data |= (byte_data << (i << 3));
+               }
+
+               memcpy(&vgpu_vreg(vgpu, offset), &reg_data, byte_count);
+               memcpy(p_data, &vgpu_vreg(vgpu, offset), bytes);
+
+               if (byte_left <= 4) {
+                       switch (i2c_edid->gmbus.cycle_type) {
+                       case NIDX_STOP:
+                       case IDX_STOP:
+                               i2c_edid->gmbus.phase = GMBUS_IDLE_PHASE;
+                               break;
+                       case NIDX_NS_W:
+                       case IDX_NS_W:
+                       default:
+                               i2c_edid->gmbus.phase = GMBUS_WAIT_PHASE;
+                               break;
+                       }
+                       intel_vgpu_init_i2c_edid(vgpu);
+               }
+               /*
+                * Read GMBUS3 during send operation,
+                * return the latest written value
+                */
+       } else {
+               memcpy(p_data, &vgpu_vreg(vgpu, offset), bytes);
+               gvt_err("vgpu%d: warning: gmbus3 read with nothing returned\n",
+                               vgpu->id);
+       }
+       return 0;
+}
+
+static int gmbus2_mmio_read(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       u32 value = vgpu_vreg(vgpu, offset);
+
+       if (!(vgpu_vreg(vgpu, offset) & GMBUS_INUSE))
+               vgpu_vreg(vgpu, offset) |= GMBUS_INUSE;
+       memcpy(p_data, (void *)&value, bytes);
+       return 0;
+}
+
+static int gmbus2_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       u32 wvalue = *(u32 *)p_data;
+
+       if (wvalue & GMBUS_INUSE)
+               vgpu_vreg(vgpu, offset) &= ~GMBUS_INUSE;
+       /* All other bits are read-only */
+       return 0;
+}
+
+/**
+ * intel_gvt_i2c_handle_gmbus_read - emulate gmbus register mmio read
+ * @vgpu: a vGPU
+ *
+ * This function is used to emulate gmbus register mmio read
+ *
+ * Returns:
+ * Zero on success, negative error code if failed.
+ *
+ */
+int intel_gvt_i2c_handle_gmbus_read(struct intel_vgpu *vgpu,
+       unsigned int offset, void *p_data, unsigned int bytes)
+{
+       if (WARN_ON(bytes > 8 && (offset & (bytes - 1))))
+               return -EINVAL;
+
+       if (offset == i915_mmio_reg_offset(PCH_GMBUS2))
+               return gmbus2_mmio_read(vgpu, offset, p_data, bytes);
+       else if (offset == i915_mmio_reg_offset(PCH_GMBUS3))
+               return gmbus3_mmio_read(vgpu, offset, p_data, bytes);
+
+       memcpy(p_data, &vgpu_vreg(vgpu, offset), bytes);
+       return 0;
+}
+
+/**
+ * intel_gvt_i2c_handle_gmbus_write - emulate gmbus register mmio write
+ * @vgpu: a vGPU
+ *
+ * This function is used to emulate gmbus register mmio write
+ *
+ * Returns:
+ * Zero on success, negative error code if failed.
+ *
+ */
+int intel_gvt_i2c_handle_gmbus_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       if (WARN_ON(bytes > 8 && (offset & (bytes - 1))))
+               return -EINVAL;
+
+       if (offset == i915_mmio_reg_offset(PCH_GMBUS0))
+               return gmbus0_mmio_write(vgpu, offset, p_data, bytes);
+       else if (offset == i915_mmio_reg_offset(PCH_GMBUS1))
+               return gmbus1_mmio_write(vgpu, offset, p_data, bytes);
+       else if (offset == i915_mmio_reg_offset(PCH_GMBUS2))
+               return gmbus2_mmio_write(vgpu, offset, p_data, bytes);
+       else if (offset == i915_mmio_reg_offset(PCH_GMBUS3))
+               return gmbus3_mmio_write(vgpu, offset, p_data, bytes);
+
+       memcpy(&vgpu_vreg(vgpu, offset), p_data, bytes);
+       return 0;
+}
+
+enum {
+       AUX_CH_CTL = 0,
+       AUX_CH_DATA1,
+       AUX_CH_DATA2,
+       AUX_CH_DATA3,
+       AUX_CH_DATA4,
+       AUX_CH_DATA5
+};
+
+static inline int get_aux_ch_reg(unsigned int offset)
+{
+       int reg;
+
+       switch (offset & 0xff) {
+       case 0x10:
+               reg = AUX_CH_CTL;
+               break;
+       case 0x14:
+               reg = AUX_CH_DATA1;
+               break;
+       case 0x18:
+               reg = AUX_CH_DATA2;
+               break;
+       case 0x1c:
+               reg = AUX_CH_DATA3;
+               break;
+       case 0x20:
+               reg = AUX_CH_DATA4;
+               break;
+       case 0x24:
+               reg = AUX_CH_DATA5;
+               break;
+       default:
+               reg = -1;
+               break;
+       }
+       return reg;
+}
+
+#define AUX_CTL_MSG_LENGTH(reg) \
+       ((reg & DP_AUX_CH_CTL_MESSAGE_SIZE_MASK) >> \
+               DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT)
+
+/**
+ * intel_gvt_i2c_handle_aux_ch_write - emulate AUX channel register write
+ * @vgpu: a vGPU
+ *
+ * This function is used to emulate AUX channel register write
+ *
+ */
+void intel_gvt_i2c_handle_aux_ch_write(struct intel_vgpu *vgpu,
+                               int port_idx,
+                               unsigned int offset,
+                               void *p_data)
+{
+       struct intel_vgpu_i2c_edid *i2c_edid = &vgpu->display.i2c_edid;
+       int msg_length, ret_msg_size;
+       int msg, addr, ctrl, op;
+       u32 value = *(u32 *)p_data;
+       int aux_data_for_write = 0;
+       int reg = get_aux_ch_reg(offset);
+
+       if (reg != AUX_CH_CTL) {
+               vgpu_vreg(vgpu, offset) = value;
+               return;
+       }
+
+       msg_length = AUX_CTL_MSG_LENGTH(value);
+       // check the msg in DATA register.
+       msg = vgpu_vreg(vgpu, offset + 4);
+       addr = (msg >> 8) & 0xffff;
+       ctrl = (msg >> 24) & 0xff;
+       op = ctrl >> 4;
+       if (!(value & DP_AUX_CH_CTL_SEND_BUSY)) {
+               /* The ctl write to clear some states */
+               return;
+       }
+
+       /* Always set the wanted value for vms. */
+       ret_msg_size = (((op & 0x1) == GVT_AUX_I2C_READ) ? 2 : 1);
+       vgpu_vreg(vgpu, offset) =
+               DP_AUX_CH_CTL_DONE |
+               ((ret_msg_size << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) &
+               DP_AUX_CH_CTL_MESSAGE_SIZE_MASK);
+
+       if (msg_length == 3) {
+               if (!(op & GVT_AUX_I2C_MOT)) {
+                       /* stop */
+                       intel_vgpu_init_i2c_edid(vgpu);
+               } else {
+                       /* start or restart */
+                       i2c_edid->aux_ch.i2c_over_aux_ch = true;
+                       i2c_edid->aux_ch.aux_ch_mot = true;
+                       if (addr == 0) {
+                               /* reset the address */
+                               intel_vgpu_init_i2c_edid(vgpu);
+                       } else if (addr == EDID_ADDR) {
+                               i2c_edid->state = I2C_AUX_CH;
+                               i2c_edid->port = port_idx;
+                               i2c_edid->slave_selected = true;
+                               if (intel_vgpu_has_monitor_on_port(vgpu,
+                                       port_idx) &&
+                                       intel_vgpu_port_is_dp(vgpu, port_idx))
+                                       i2c_edid->edid_available = true;
+                       }
+               }
+       } else if ((op & 0x1) == GVT_AUX_I2C_WRITE) {
+               /* TODO
+                * We only support EDID reading from I2C_over_AUX. And
+                * we do not expect the index mode to be used. Right now
+                * the WRITE operation is ignored. It is good enough to
+                * support the gfx driver to do EDID access.
+                */
+       } else {
+               if (WARN_ON((op & 0x1) != GVT_AUX_I2C_READ))
+                       return;
+               if (WARN_ON(msg_length != 4))
+                       return;
+               if (i2c_edid->edid_available && i2c_edid->slave_selected) {
+                       unsigned char val = edid_get_byte(vgpu);
+
+                       aux_data_for_write = (val << 16);
+               }
+       }
+       /* write the return value in AUX_CH_DATA reg which includes:
+        * ACK of I2C_WRITE
+        * returned byte if it is READ
+        */
+
+       aux_data_for_write |= (GVT_AUX_I2C_REPLY_ACK & 0xff) << 24;
+       vgpu_vreg(vgpu, offset + 4) = aux_data_for_write;
+}
+
+/**
+ * intel_vgpu_init_i2c_edid - initialize vGPU i2c edid emulation
+ * @vgpu: a vGPU
+ *
+ * This function is used to initialize vGPU i2c edid emulation stuffs
+ *
+ */
+void intel_vgpu_init_i2c_edid(struct intel_vgpu *vgpu)
+{
+       struct intel_vgpu_i2c_edid *edid = &vgpu->display.i2c_edid;
+
+       edid->state = I2C_NOT_SPECIFIED;
+
+       edid->port = -1;
+       edid->slave_selected = false;
+       edid->edid_available = false;
+       edid->current_edid_read = 0;
+
+       memset(&edid->gmbus, 0, sizeof(struct intel_vgpu_i2c_gmbus));
+
+       edid->aux_ch.i2c_over_aux_ch = false;
+       edid->aux_ch.aux_ch_mot = false;
+}
diff --git a/drivers/gpu/drm/i915/gvt/edid.h b/drivers/gpu/drm/i915/gvt/edid.h
new file mode 100644 (file)
index 0000000..de366b1
--- /dev/null
@@ -0,0 +1,150 @@
+/*
+ * Copyright(c) 2011-2016 Intel Corporation. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Authors:
+ *    Ke Yu
+ *    Zhiyuan Lv <zhiyuan.lv@intel.com>
+ *
+ * Contributors:
+ *    Terrence Xu <terrence.xu@intel.com>
+ *    Changbin Du <changbin.du@intel.com>
+ *    Bing Niu <bing.niu@intel.com>
+ *    Zhi Wang <zhi.a.wang@intel.com>
+ *
+ */
+
+#ifndef _GVT_EDID_H_
+#define _GVT_EDID_H_
+
+#define EDID_SIZE              128
+#define EDID_ADDR              0x50 /* Linux hvm EDID addr */
+
+#define GVT_AUX_NATIVE_WRITE                   0x8
+#define GVT_AUX_NATIVE_READ                    0x9
+#define GVT_AUX_I2C_WRITE                      0x0
+#define GVT_AUX_I2C_READ                       0x1
+#define GVT_AUX_I2C_STATUS                     0x2
+#define GVT_AUX_I2C_MOT                                0x4
+#define GVT_AUX_I2C_REPLY_ACK                  (0x0 << 6)
+
+struct intel_vgpu_edid_data {
+       bool data_valid;
+       unsigned char edid_block[EDID_SIZE];
+};
+
+enum gmbus_cycle_type {
+       GMBUS_NOCYCLE   = 0x0,
+       NIDX_NS_W       = 0x1,
+       IDX_NS_W        = 0x3,
+       GMBUS_STOP      = 0x4,
+       NIDX_STOP       = 0x5,
+       IDX_STOP        = 0x7
+};
+
+/*
+ * States of GMBUS
+ *
+ * GMBUS0-3 could be related to the EDID virtualization. Another two GMBUS
+ * registers, GMBUS4 (interrupt mask) and GMBUS5 (2 byte indes register), are
+ * not considered here. Below describes the usage of GMBUS registers that are
+ * cared by the EDID virtualization
+ *
+ * GMBUS0:
+ *      R/W
+ *      port selection. value of bit0 - bit2 corresponds to the GPIO registers.
+ *
+ * GMBUS1:
+ *      R/W Protect
+ *      Command and Status.
+ *      bit0 is the direction bit: 1 is read; 0 is write.
+ *      bit1 - bit7 is slave 7-bit address.
+ *      bit16 - bit24 total byte count (ignore?)
+ *
+ * GMBUS2:
+ *      Most of bits are read only except bit 15 (IN_USE)
+ *      Status register
+ *      bit0 - bit8 current byte count
+ *      bit 11: hardware ready;
+ *
+ * GMBUS3:
+ *      Read/Write
+ *      Data for transfer
+ */
+
+/* From hw specs, Other phases like START, ADDRESS, INDEX
+ * are invisible to GMBUS MMIO interface. So no definitions
+ * in below enum types
+ */
+enum gvt_gmbus_phase {
+       GMBUS_IDLE_PHASE = 0,
+       GMBUS_DATA_PHASE,
+       GMBUS_WAIT_PHASE,
+       //GMBUS_STOP_PHASE,
+       GMBUS_MAX_PHASE
+};
+
+struct intel_vgpu_i2c_gmbus {
+       unsigned int total_byte_count; /* from GMBUS1 */
+       enum gmbus_cycle_type cycle_type;
+       enum gvt_gmbus_phase phase;
+};
+
+struct intel_vgpu_i2c_aux_ch {
+       bool i2c_over_aux_ch;
+       bool aux_ch_mot;
+};
+
+enum i2c_state {
+       I2C_NOT_SPECIFIED = 0,
+       I2C_GMBUS = 1,
+       I2C_AUX_CH = 2
+};
+
+/* I2C sequences cannot interleave.
+ * GMBUS and AUX_CH sequences cannot interleave.
+ */
+struct intel_vgpu_i2c_edid {
+       enum i2c_state state;
+
+       unsigned int port;
+       bool slave_selected;
+       bool edid_available;
+       unsigned int current_edid_read;
+
+       struct intel_vgpu_i2c_gmbus gmbus;
+       struct intel_vgpu_i2c_aux_ch aux_ch;
+};
+
+void intel_vgpu_init_i2c_edid(struct intel_vgpu *vgpu);
+
+int intel_gvt_i2c_handle_gmbus_read(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes);
+
+int intel_gvt_i2c_handle_gmbus_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes);
+
+void intel_gvt_i2c_handle_aux_ch_write(struct intel_vgpu *vgpu,
+               int port_idx,
+               unsigned int offset,
+               void *p_data);
+
+#endif /*_GVT_EDID_H_*/
index 6b5061bfebb008b67f3110faa5a09a90cc31618f..27e1dd9a2570ab04a50410ed1fd79a9507c18f0b 100644 (file)
@@ -32,6 +32,7 @@
 
 #include <linux/types.h>
 #include <xen/xen.h>
+#include <linux/kthread.h>
 
 #include "i915_drv.h"
 
@@ -114,6 +115,52 @@ static void init_device_info(struct intel_gvt *gvt)
        }
 }
 
+static int gvt_service_thread(void *data)
+{
+       struct intel_gvt *gvt = (struct intel_gvt *)data;
+       int ret;
+
+       gvt_dbg_core("service thread start\n");
+
+       while (!kthread_should_stop()) {
+               ret = wait_event_interruptible(gvt->service_thread_wq,
+                               kthread_should_stop() || gvt->service_request);
+
+               if (kthread_should_stop())
+                       break;
+
+               if (WARN_ONCE(ret, "service thread is waken up by signal.\n"))
+                       continue;
+
+               if (test_and_clear_bit(INTEL_GVT_REQUEST_EMULATE_VBLANK,
+                                       (void *)&gvt->service_request)) {
+                       mutex_lock(&gvt->lock);
+                       intel_gvt_emulate_vblank(gvt);
+                       mutex_unlock(&gvt->lock);
+               }
+       }
+
+       return 0;
+}
+
+static void clean_service_thread(struct intel_gvt *gvt)
+{
+       kthread_stop(gvt->service_thread);
+}
+
+static int init_service_thread(struct intel_gvt *gvt)
+{
+       init_waitqueue_head(&gvt->service_thread_wq);
+
+       gvt->service_thread = kthread_run(gvt_service_thread,
+                       gvt, "gvt_service_thread");
+       if (IS_ERR(gvt->service_thread)) {
+               gvt_err("fail to start service thread.\n");
+               return PTR_ERR(gvt->service_thread);
+       }
+       return 0;
+}
+
 /**
  * intel_gvt_clean_device - clean a GVT device
  * @gvt: intel gvt device
@@ -129,6 +176,7 @@ void intel_gvt_clean_device(struct drm_i915_private *dev_priv)
        if (WARN_ON(!gvt->initialized))
                return;
 
+       clean_service_thread(gvt);
        intel_gvt_clean_opregion(gvt);
        intel_gvt_clean_gtt(gvt);
        intel_gvt_clean_irq(gvt);
@@ -191,10 +239,16 @@ int intel_gvt_init_device(struct drm_i915_private *dev_priv)
        if (ret)
                goto out_clean_gtt;
 
+       ret = init_service_thread(gvt);
+       if (ret)
+               goto out_clean_opregion;
+
        gvt_dbg_core("gvt device creation is done\n");
        gvt->initialized = true;
        return 0;
 
+out_clean_opregion:
+       intel_gvt_clean_opregion(gvt);
 out_clean_gtt:
        intel_gvt_clean_gtt(gvt);
 out_clean_irq:
index 2560c3aaac45f980abb309071a9ea3f68efb6bb3..1619881dbd51dfb3ae3b03779419d312c25afae6 100644 (file)
@@ -39,6 +39,8 @@
 #include "reg.h"
 #include "interrupt.h"
 #include "gtt.h"
+#include "display.h"
+#include "edid.h"
 
 #define GVT_MAX_VGPU 8
 
@@ -105,8 +107,12 @@ struct intel_vgpu_cfg_space {
 
 #define vgpu_cfg_space(vgpu) ((vgpu)->cfg_space.virtual_cfg_space)
 
+#define INTEL_GVT_MAX_PIPE 4
+
 struct intel_vgpu_irq {
        bool irq_warn_once[INTEL_GVT_EVENT_MAX];
+       DECLARE_BITMAP(flip_done_event[INTEL_GVT_MAX_PIPE],
+                      INTEL_GVT_EVENT_MAX);
 };
 
 struct intel_vgpu_opregion {
@@ -117,6 +123,14 @@ struct intel_vgpu_opregion {
 
 #define vgpu_opregion(vgpu) (&(vgpu->opregion))
 
+#define INTEL_GVT_MAX_PORT 5
+
+struct intel_vgpu_display {
+       struct intel_vgpu_i2c_edid i2c_edid;
+       struct intel_vgpu_port ports[INTEL_GVT_MAX_PORT];
+       struct intel_vgpu_sbi sbi;
+};
+
 struct intel_vgpu {
        struct intel_gvt *gvt;
        int id;
@@ -131,6 +145,7 @@ struct intel_vgpu {
        struct intel_vgpu_irq irq;
        struct intel_vgpu_gtt gtt;
        struct intel_vgpu_opregion opregion;
+       struct intel_vgpu_display display;
 };
 
 struct intel_gvt_gm {
@@ -175,8 +190,23 @@ struct intel_gvt {
        struct intel_gvt_irq irq;
        struct intel_gvt_gtt gtt;
        struct intel_gvt_opregion opregion;
+
+       struct task_struct *service_thread;
+       wait_queue_head_t service_thread_wq;
+       unsigned long service_request;
 };
 
+enum {
+       INTEL_GVT_REQUEST_EMULATE_VBLANK = 0,
+};
+
+static inline void intel_gvt_request_service(struct intel_gvt *gvt,
+               int service)
+{
+       set_bit(service, (void *)&gvt->service_request);
+       wake_up(&gvt->service_thread_wq);
+}
+
 void intel_gvt_free_firmware(struct intel_gvt *gvt);
 int intel_gvt_load_firmware(struct intel_gvt *gvt);
 
index b29c3bfdc599794ab2c44b1648e1e2cea7590243..194778b374fff789b1ab1df64bec615848296c82 100644 (file)
@@ -251,6 +251,704 @@ static int gdrst_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
        return 0;
 }
 
+static int gmbus_mmio_read(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       return intel_gvt_i2c_handle_gmbus_read(vgpu, offset, p_data, bytes);
+}
+
+static int gmbus_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       return intel_gvt_i2c_handle_gmbus_write(vgpu, offset, p_data, bytes);
+}
+
+static int pch_pp_control_mmio_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       write_vreg(vgpu, offset, p_data, bytes);
+
+       if (vgpu_vreg(vgpu, offset) & PANEL_POWER_ON) {
+               vgpu_vreg(vgpu, PCH_PP_STATUS) |= PP_ON;
+               vgpu_vreg(vgpu, PCH_PP_STATUS) |= PP_SEQUENCE_STATE_ON_IDLE;
+               vgpu_vreg(vgpu, PCH_PP_STATUS) &= ~PP_SEQUENCE_POWER_DOWN;
+               vgpu_vreg(vgpu, PCH_PP_STATUS) &= ~PP_CYCLE_DELAY_ACTIVE;
+
+       } else
+               vgpu_vreg(vgpu, PCH_PP_STATUS) &=
+                       ~(PP_ON | PP_SEQUENCE_POWER_DOWN
+                                       | PP_CYCLE_DELAY_ACTIVE);
+       return 0;
+}
+
+static int transconf_mmio_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       write_vreg(vgpu, offset, p_data, bytes);
+
+       if (vgpu_vreg(vgpu, offset) & TRANS_ENABLE)
+               vgpu_vreg(vgpu, offset) |= TRANS_STATE_ENABLE;
+       else
+               vgpu_vreg(vgpu, offset) &= ~TRANS_STATE_ENABLE;
+       return 0;
+}
+
+static int lcpll_ctl_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       write_vreg(vgpu, offset, p_data, bytes);
+
+       if (vgpu_vreg(vgpu, offset) & LCPLL_PLL_DISABLE)
+               vgpu_vreg(vgpu, offset) &= ~LCPLL_PLL_LOCK;
+       else
+               vgpu_vreg(vgpu, offset) |= LCPLL_PLL_LOCK;
+
+       if (vgpu_vreg(vgpu, offset) & LCPLL_CD_SOURCE_FCLK)
+               vgpu_vreg(vgpu, offset) |= LCPLL_CD_SOURCE_FCLK_DONE;
+       else
+               vgpu_vreg(vgpu, offset) &= ~LCPLL_CD_SOURCE_FCLK_DONE;
+
+       return 0;
+}
+
+static int dpy_reg_mmio_read(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       *(u32 *)p_data = (1 << 17);
+       return 0;
+}
+
+static int dpy_reg_mmio_read_2(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       *(u32 *)p_data = 3;
+       return 0;
+}
+
+static int dpy_reg_mmio_read_3(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       *(u32 *)p_data = (0x2f << 16);
+       return 0;
+}
+
+static int pipeconf_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       u32 data;
+
+       write_vreg(vgpu, offset, p_data, bytes);
+       data = vgpu_vreg(vgpu, offset);
+
+       if (data & PIPECONF_ENABLE)
+               vgpu_vreg(vgpu, offset) |= I965_PIPECONF_ACTIVE;
+       else
+               vgpu_vreg(vgpu, offset) &= ~I965_PIPECONF_ACTIVE;
+       intel_gvt_check_vblank_emulation(vgpu->gvt);
+       return 0;
+}
+
+static int ddi_buf_ctl_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       write_vreg(vgpu, offset, p_data, bytes);
+
+       if (vgpu_vreg(vgpu, offset) & DDI_BUF_CTL_ENABLE) {
+               vgpu_vreg(vgpu, offset) &= ~DDI_BUF_IS_IDLE;
+       } else {
+               vgpu_vreg(vgpu, offset) |= DDI_BUF_IS_IDLE;
+               if (offset == i915_mmio_reg_offset(DDI_BUF_CTL(PORT_E)))
+                       vgpu_vreg(vgpu, DP_TP_STATUS(PORT_E))
+                               &= ~DP_TP_STATUS_AUTOTRAIN_DONE;
+       }
+       return 0;
+}
+
+static int fdi_rx_iir_mmio_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       vgpu_vreg(vgpu, offset) &= ~*(u32 *)p_data;
+       return 0;
+}
+
+#define FDI_LINK_TRAIN_PATTERN1         0
+#define FDI_LINK_TRAIN_PATTERN2         1
+
+static int fdi_auto_training_started(struct intel_vgpu *vgpu)
+{
+       u32 ddi_buf_ctl = vgpu_vreg(vgpu, DDI_BUF_CTL(PORT_E));
+       u32 rx_ctl = vgpu_vreg(vgpu, _FDI_RXA_CTL);
+       u32 tx_ctl = vgpu_vreg(vgpu, DP_TP_CTL(PORT_E));
+
+       if ((ddi_buf_ctl & DDI_BUF_CTL_ENABLE) &&
+                       (rx_ctl & FDI_RX_ENABLE) &&
+                       (rx_ctl & FDI_AUTO_TRAINING) &&
+                       (tx_ctl & DP_TP_CTL_ENABLE) &&
+                       (tx_ctl & DP_TP_CTL_FDI_AUTOTRAIN))
+               return 1;
+       else
+               return 0;
+}
+
+static int check_fdi_rx_train_status(struct intel_vgpu *vgpu,
+               enum pipe pipe, unsigned int train_pattern)
+{
+       i915_reg_t fdi_rx_imr, fdi_tx_ctl, fdi_rx_ctl;
+       unsigned int fdi_rx_check_bits, fdi_tx_check_bits;
+       unsigned int fdi_rx_train_bits, fdi_tx_train_bits;
+       unsigned int fdi_iir_check_bits;
+
+       fdi_rx_imr = FDI_RX_IMR(pipe);
+       fdi_tx_ctl = FDI_TX_CTL(pipe);
+       fdi_rx_ctl = FDI_RX_CTL(pipe);
+
+       if (train_pattern == FDI_LINK_TRAIN_PATTERN1) {
+               fdi_rx_train_bits = FDI_LINK_TRAIN_PATTERN_1_CPT;
+               fdi_tx_train_bits = FDI_LINK_TRAIN_PATTERN_1;
+               fdi_iir_check_bits = FDI_RX_BIT_LOCK;
+       } else if (train_pattern == FDI_LINK_TRAIN_PATTERN2) {
+               fdi_rx_train_bits = FDI_LINK_TRAIN_PATTERN_2_CPT;
+               fdi_tx_train_bits = FDI_LINK_TRAIN_PATTERN_2;
+               fdi_iir_check_bits = FDI_RX_SYMBOL_LOCK;
+       } else {
+               gvt_err("Invalid train pattern %d\n", train_pattern);
+               return -EINVAL;
+       }
+
+       fdi_rx_check_bits = FDI_RX_ENABLE | fdi_rx_train_bits;
+       fdi_tx_check_bits = FDI_TX_ENABLE | fdi_tx_train_bits;
+
+       /* If imr bit has been masked */
+       if (vgpu_vreg(vgpu, fdi_rx_imr) & fdi_iir_check_bits)
+               return 0;
+
+       if (((vgpu_vreg(vgpu, fdi_tx_ctl) & fdi_tx_check_bits)
+                       == fdi_tx_check_bits)
+               && ((vgpu_vreg(vgpu, fdi_rx_ctl) & fdi_rx_check_bits)
+                       == fdi_rx_check_bits))
+               return 1;
+       else
+               return 0;
+}
+
+#define INVALID_INDEX (~0U)
+
+static unsigned int calc_index(unsigned int offset, unsigned int start,
+       unsigned int next, unsigned int end, i915_reg_t i915_end)
+{
+       unsigned int range = next - start;
+
+       if (!end)
+               end = i915_mmio_reg_offset(i915_end);
+       if (offset < start || offset > end)
+               return INVALID_INDEX;
+       offset -= start;
+       return offset / range;
+}
+
+#define FDI_RX_CTL_TO_PIPE(offset) \
+       calc_index(offset, _FDI_RXA_CTL, _FDI_RXB_CTL, 0, FDI_RX_CTL(PIPE_C))
+
+#define FDI_TX_CTL_TO_PIPE(offset) \
+       calc_index(offset, _FDI_TXA_CTL, _FDI_TXB_CTL, 0, FDI_TX_CTL(PIPE_C))
+
+#define FDI_RX_IMR_TO_PIPE(offset) \
+       calc_index(offset, _FDI_RXA_IMR, _FDI_RXB_IMR, 0, FDI_RX_IMR(PIPE_C))
+
+static int update_fdi_rx_iir_status(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       i915_reg_t fdi_rx_iir;
+       unsigned int index;
+       int ret;
+
+       if (FDI_RX_CTL_TO_PIPE(offset) != INVALID_INDEX)
+               index = FDI_RX_CTL_TO_PIPE(offset);
+       else if (FDI_TX_CTL_TO_PIPE(offset) != INVALID_INDEX)
+               index = FDI_TX_CTL_TO_PIPE(offset);
+       else if (FDI_RX_IMR_TO_PIPE(offset) != INVALID_INDEX)
+               index = FDI_RX_IMR_TO_PIPE(offset);
+       else {
+               gvt_err("Unsupport registers %x\n", offset);
+               return -EINVAL;
+       }
+
+       write_vreg(vgpu, offset, p_data, bytes);
+
+       fdi_rx_iir = FDI_RX_IIR(index);
+
+       ret = check_fdi_rx_train_status(vgpu, index, FDI_LINK_TRAIN_PATTERN1);
+       if (ret < 0)
+               return ret;
+       if (ret)
+               vgpu_vreg(vgpu, fdi_rx_iir) |= FDI_RX_BIT_LOCK;
+
+       ret = check_fdi_rx_train_status(vgpu, index, FDI_LINK_TRAIN_PATTERN2);
+       if (ret < 0)
+               return ret;
+       if (ret)
+               vgpu_vreg(vgpu, fdi_rx_iir) |= FDI_RX_SYMBOL_LOCK;
+
+       if (offset == _FDI_RXA_CTL)
+               if (fdi_auto_training_started(vgpu))
+                       vgpu_vreg(vgpu, DP_TP_STATUS(PORT_E)) |=
+                               DP_TP_STATUS_AUTOTRAIN_DONE;
+       return 0;
+}
+
+#define DP_TP_CTL_TO_PORT(offset) \
+       calc_index(offset, _DP_TP_CTL_A, _DP_TP_CTL_B, 0, DP_TP_CTL(PORT_E))
+
+static int dp_tp_ctl_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       i915_reg_t status_reg;
+       unsigned int index;
+       u32 data;
+
+       write_vreg(vgpu, offset, p_data, bytes);
+
+       index = DP_TP_CTL_TO_PORT(offset);
+       data = (vgpu_vreg(vgpu, offset) & GENMASK(10, 8)) >> 8;
+       if (data == 0x2) {
+               status_reg = DP_TP_STATUS(index);
+               vgpu_vreg(vgpu, status_reg) |= (1 << 25);
+       }
+       return 0;
+}
+
+static int dp_tp_status_mmio_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       u32 reg_val;
+       u32 sticky_mask;
+
+       reg_val = *((u32 *)p_data);
+       sticky_mask = GENMASK(27, 26) | (1 << 24);
+
+       vgpu_vreg(vgpu, offset) = (reg_val & ~sticky_mask) |
+               (vgpu_vreg(vgpu, offset) & sticky_mask);
+       vgpu_vreg(vgpu, offset) &= ~(reg_val & sticky_mask);
+       return 0;
+}
+
+static int pch_adpa_mmio_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       u32 data;
+
+       write_vreg(vgpu, offset, p_data, bytes);
+       data = vgpu_vreg(vgpu, offset);
+
+       if (data & ADPA_CRT_HOTPLUG_FORCE_TRIGGER)
+               vgpu_vreg(vgpu, offset) &= ~ADPA_CRT_HOTPLUG_FORCE_TRIGGER;
+       return 0;
+}
+
+static int south_chicken2_mmio_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       u32 data;
+
+       write_vreg(vgpu, offset, p_data, bytes);
+       data = vgpu_vreg(vgpu, offset);
+
+       if (data & FDI_MPHY_IOSFSB_RESET_CTL)
+               vgpu_vreg(vgpu, offset) |= FDI_MPHY_IOSFSB_RESET_STATUS;
+       else
+               vgpu_vreg(vgpu, offset) &= ~FDI_MPHY_IOSFSB_RESET_STATUS;
+       return 0;
+}
+
+#define DSPSURF_TO_PIPE(offset) \
+       calc_index(offset, _DSPASURF, _DSPBSURF, 0, DSPSURF(PIPE_C))
+
+static int pri_surf_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+       unsigned int index = DSPSURF_TO_PIPE(offset);
+       i915_reg_t surflive_reg = DSPSURFLIVE(index);
+       int flip_event[] = {
+               [PIPE_A] = PRIMARY_A_FLIP_DONE,
+               [PIPE_B] = PRIMARY_B_FLIP_DONE,
+               [PIPE_C] = PRIMARY_C_FLIP_DONE,
+       };
+
+       write_vreg(vgpu, offset, p_data, bytes);
+       vgpu_vreg(vgpu, surflive_reg) = vgpu_vreg(vgpu, offset);
+
+       set_bit(flip_event[index], vgpu->irq.flip_done_event[index]);
+       return 0;
+}
+
+#define SPRSURF_TO_PIPE(offset) \
+       calc_index(offset, _SPRA_SURF, _SPRB_SURF, 0, SPRSURF(PIPE_C))
+
+static int spr_surf_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       unsigned int index = SPRSURF_TO_PIPE(offset);
+       i915_reg_t surflive_reg = SPRSURFLIVE(index);
+       int flip_event[] = {
+               [PIPE_A] = SPRITE_A_FLIP_DONE,
+               [PIPE_B] = SPRITE_B_FLIP_DONE,
+               [PIPE_C] = SPRITE_C_FLIP_DONE,
+       };
+
+       write_vreg(vgpu, offset, p_data, bytes);
+       vgpu_vreg(vgpu, surflive_reg) = vgpu_vreg(vgpu, offset);
+
+       set_bit(flip_event[index], vgpu->irq.flip_done_event[index]);
+       return 0;
+}
+
+static int trigger_aux_channel_interrupt(struct intel_vgpu *vgpu,
+               unsigned int reg)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+       enum intel_gvt_event_type event;
+
+       if (reg == _DPA_AUX_CH_CTL)
+               event = AUX_CHANNEL_A;
+       else if (reg == _PCH_DPB_AUX_CH_CTL || reg == _DPB_AUX_CH_CTL)
+               event = AUX_CHANNEL_B;
+       else if (reg == _PCH_DPC_AUX_CH_CTL || reg == _DPC_AUX_CH_CTL)
+               event = AUX_CHANNEL_C;
+       else if (reg == _PCH_DPD_AUX_CH_CTL || reg == _DPD_AUX_CH_CTL)
+               event = AUX_CHANNEL_D;
+       else {
+               WARN_ON(true);
+               return -EINVAL;
+       }
+
+       intel_vgpu_trigger_virtual_event(vgpu, event);
+       return 0;
+}
+
+static int dp_aux_ch_ctl_trans_done(struct intel_vgpu *vgpu, u32 value,
+               unsigned int reg, int len, bool data_valid)
+{
+       /* mark transaction done */
+       value |= DP_AUX_CH_CTL_DONE;
+       value &= ~DP_AUX_CH_CTL_SEND_BUSY;
+       value &= ~DP_AUX_CH_CTL_RECEIVE_ERROR;
+
+       if (data_valid)
+               value &= ~DP_AUX_CH_CTL_TIME_OUT_ERROR;
+       else
+               value |= DP_AUX_CH_CTL_TIME_OUT_ERROR;
+
+       /* message size */
+       value &= ~(0xf << 20);
+       value |= (len << 20);
+       vgpu_vreg(vgpu, reg) = value;
+
+       if (value & DP_AUX_CH_CTL_INTERRUPT)
+               return trigger_aux_channel_interrupt(vgpu, reg);
+       return 0;
+}
+
+static void dp_aux_ch_ctl_link_training(struct intel_vgpu_dpcd_data *dpcd,
+               uint8_t t)
+{
+       if ((t & DPCD_TRAINING_PATTERN_SET_MASK) == DPCD_TRAINING_PATTERN_1) {
+               /* training pattern 1 for CR */
+               /* set LANE0_CR_DONE, LANE1_CR_DONE */
+               dpcd->data[DPCD_LANE0_1_STATUS] |= DPCD_LANES_CR_DONE;
+               /* set LANE2_CR_DONE, LANE3_CR_DONE */
+               dpcd->data[DPCD_LANE2_3_STATUS] |= DPCD_LANES_CR_DONE;
+       } else if ((t & DPCD_TRAINING_PATTERN_SET_MASK) ==
+                       DPCD_TRAINING_PATTERN_2) {
+               /* training pattern 2 for EQ */
+               /* Set CHANNEL_EQ_DONE and  SYMBOL_LOCKED for Lane0_1 */
+               dpcd->data[DPCD_LANE0_1_STATUS] |= DPCD_LANES_EQ_DONE;
+               dpcd->data[DPCD_LANE0_1_STATUS] |= DPCD_SYMBOL_LOCKED;
+               /* Set CHANNEL_EQ_DONE and  SYMBOL_LOCKED for Lane2_3 */
+               dpcd->data[DPCD_LANE2_3_STATUS] |= DPCD_LANES_EQ_DONE;
+               dpcd->data[DPCD_LANE2_3_STATUS] |= DPCD_SYMBOL_LOCKED;
+               /* set INTERLANE_ALIGN_DONE */
+               dpcd->data[DPCD_LANE_ALIGN_STATUS_UPDATED] |=
+                       DPCD_INTERLANE_ALIGN_DONE;
+       } else if ((t & DPCD_TRAINING_PATTERN_SET_MASK) ==
+                       DPCD_LINK_TRAINING_DISABLED) {
+               /* finish link training */
+               /* set sink status as synchronized */
+               dpcd->data[DPCD_SINK_STATUS] = DPCD_SINK_IN_SYNC;
+       }
+}
+
+#define _REG_HSW_DP_AUX_CH_CTL(dp) \
+       ((dp) ? (_PCH_DPB_AUX_CH_CTL + ((dp)-1)*0x100) : 0x64010)
+
+#define _REG_SKL_DP_AUX_CH_CTL(dp) (0x64010 + (dp) * 0x100)
+
+#define OFFSET_TO_DP_AUX_PORT(offset) (((offset) & 0xF00) >> 8)
+
+#define dpy_is_valid_port(port)        \
+               (((port) >= PORT_A) && ((port) < I915_MAX_PORTS))
+
+static int dp_aux_ch_ctl_mmio_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       struct intel_vgpu_display *display = &vgpu->display;
+       int msg, addr, ctrl, op, len;
+       int port_index = OFFSET_TO_DP_AUX_PORT(offset);
+       struct intel_vgpu_dpcd_data *dpcd = NULL;
+       struct intel_vgpu_port *port = NULL;
+       u32 data;
+
+       if (!dpy_is_valid_port(port_index)) {
+               gvt_err("GVT(%d): Unsupported DP port access!\n", vgpu->id);
+               return 0;
+       }
+
+       write_vreg(vgpu, offset, p_data, bytes);
+       data = vgpu_vreg(vgpu, offset);
+
+       if (IS_SKYLAKE(vgpu->gvt->dev_priv) &&
+           offset != _REG_SKL_DP_AUX_CH_CTL(port_index)) {
+               /* SKL DPB/C/D aux ctl register changed */
+               return 0;
+       } else if (IS_BROADWELL(vgpu->gvt->dev_priv) &&
+                  offset != _REG_HSW_DP_AUX_CH_CTL(port_index)) {
+               /* write to the data registers */
+               return 0;
+       }
+
+       if (!(data & DP_AUX_CH_CTL_SEND_BUSY)) {
+               /* just want to clear the sticky bits */
+               vgpu_vreg(vgpu, offset) = 0;
+               return 0;
+       }
+
+       port = &display->ports[port_index];
+       dpcd = port->dpcd;
+
+       /* read out message from DATA1 register */
+       msg = vgpu_vreg(vgpu, offset + 4);
+       addr = (msg >> 8) & 0xffff;
+       ctrl = (msg >> 24) & 0xff;
+       len = msg & 0xff;
+       op = ctrl >> 4;
+
+       if (op == GVT_AUX_NATIVE_WRITE) {
+               int t;
+               uint8_t buf[16];
+
+               if ((addr + len + 1) >= DPCD_SIZE) {
+                       /*
+                        * Write request exceeds what we supported,
+                        * DCPD spec: When a Source Device is writing a DPCD
+                        * address not supported by the Sink Device, the Sink
+                        * Device shall reply with AUX NACK and â€œM” equal to
+                        * zero.
+                        */
+
+                       /* NAK the write */
+                       vgpu_vreg(vgpu, offset + 4) = AUX_NATIVE_REPLY_NAK;
+                       dp_aux_ch_ctl_trans_done(vgpu, data, offset, 2, true);
+                       return 0;
+               }
+
+               /*
+                * Write request format: (command + address) occupies
+                * 3 bytes, followed by (len + 1) bytes of data.
+                */
+               if (WARN_ON((len + 4) > AUX_BURST_SIZE))
+                       return -EINVAL;
+
+               /* unpack data from vreg to buf */
+               for (t = 0; t < 4; t++) {
+                       u32 r = vgpu_vreg(vgpu, offset + 8 + t * 4);
+
+                       buf[t * 4] = (r >> 24) & 0xff;
+                       buf[t * 4 + 1] = (r >> 16) & 0xff;
+                       buf[t * 4 + 2] = (r >> 8) & 0xff;
+                       buf[t * 4 + 3] = r & 0xff;
+               }
+
+               /* write to virtual DPCD */
+               if (dpcd && dpcd->data_valid) {
+                       for (t = 0; t <= len; t++) {
+                               int p = addr + t;
+
+                               dpcd->data[p] = buf[t];
+                               /* check for link training */
+                               if (p == DPCD_TRAINING_PATTERN_SET)
+                                       dp_aux_ch_ctl_link_training(dpcd,
+                                                       buf[t]);
+                       }
+               }
+
+               /* ACK the write */
+               vgpu_vreg(vgpu, offset + 4) = 0;
+               dp_aux_ch_ctl_trans_done(vgpu, data, offset, 1,
+                               dpcd && dpcd->data_valid);
+               return 0;
+       }
+
+       if (op == GVT_AUX_NATIVE_READ) {
+               int idx, i, ret = 0;
+
+               if ((addr + len + 1) >= DPCD_SIZE) {
+                       /*
+                        * read request exceeds what we supported
+                        * DPCD spec: A Sink Device receiving a Native AUX CH
+                        * read request for an unsupported DPCD address must
+                        * reply with an AUX ACK and read data set equal to
+                        * zero instead of replying with AUX NACK.
+                        */
+
+                       /* ACK the READ*/
+                       vgpu_vreg(vgpu, offset + 4) = 0;
+                       vgpu_vreg(vgpu, offset + 8) = 0;
+                       vgpu_vreg(vgpu, offset + 12) = 0;
+                       vgpu_vreg(vgpu, offset + 16) = 0;
+                       vgpu_vreg(vgpu, offset + 20) = 0;
+
+                       dp_aux_ch_ctl_trans_done(vgpu, data, offset, len + 2,
+                                       true);
+                       return 0;
+               }
+
+               for (idx = 1; idx <= 5; idx++) {
+                       /* clear the data registers */
+                       vgpu_vreg(vgpu, offset + 4 * idx) = 0;
+               }
+
+               /*
+                * Read reply format: ACK (1 byte) plus (len + 1) bytes of data.
+                */
+               if (WARN_ON((len + 2) > AUX_BURST_SIZE))
+                       return -EINVAL;
+
+               /* read from virtual DPCD to vreg */
+               /* first 4 bytes: [ACK][addr][addr+1][addr+2] */
+               if (dpcd && dpcd->data_valid) {
+                       for (i = 1; i <= (len + 1); i++) {
+                               int t;
+
+                               t = dpcd->data[addr + i - 1];
+                               t <<= (24 - 8 * (i % 4));
+                               ret |= t;
+
+                               if ((i % 4 == 3) || (i == (len + 1))) {
+                                       vgpu_vreg(vgpu, offset +
+                                                       (i / 4 + 1) * 4) = ret;
+                                       ret = 0;
+                               }
+                       }
+               }
+               dp_aux_ch_ctl_trans_done(vgpu, data, offset, len + 2,
+                               dpcd && dpcd->data_valid);
+               return 0;
+       }
+
+       /* i2c transaction starts */
+       intel_gvt_i2c_handle_aux_ch_write(vgpu, port_index, offset, p_data);
+
+       if (data & DP_AUX_CH_CTL_INTERRUPT)
+               trigger_aux_channel_interrupt(vgpu, offset);
+       return 0;
+}
+
+static int vga_control_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       bool vga_disable;
+
+       write_vreg(vgpu, offset, p_data, bytes);
+       vga_disable = vgpu_vreg(vgpu, offset) & VGA_DISP_DISABLE;
+
+       gvt_dbg_core("vgpu%d: %s VGA mode\n", vgpu->id,
+                       vga_disable ? "Disable" : "Enable");
+       return 0;
+}
+
+static u32 read_virtual_sbi_register(struct intel_vgpu *vgpu,
+               unsigned int sbi_offset)
+{
+       struct intel_vgpu_display *display = &vgpu->display;
+       int num = display->sbi.number;
+       int i;
+
+       for (i = 0; i < num; ++i)
+               if (display->sbi.registers[i].offset == sbi_offset)
+                       break;
+
+       if (i == num)
+               return 0;
+
+       return display->sbi.registers[i].value;
+}
+
+static void write_virtual_sbi_register(struct intel_vgpu *vgpu,
+               unsigned int offset, u32 value)
+{
+       struct intel_vgpu_display *display = &vgpu->display;
+       int num = display->sbi.number;
+       int i;
+
+       for (i = 0; i < num; ++i) {
+               if (display->sbi.registers[i].offset == offset)
+                       break;
+       }
+
+       if (i == num) {
+               if (num == SBI_REG_MAX) {
+                       gvt_err("vgpu%d: SBI caching meets maximum limits\n",
+                                       vgpu->id);
+                       return;
+               }
+               display->sbi.number++;
+       }
+
+       display->sbi.registers[i].offset = offset;
+       display->sbi.registers[i].value = value;
+}
+
+static int sbi_data_mmio_read(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       if (((vgpu_vreg(vgpu, SBI_CTL_STAT) & SBI_OPCODE_MASK) >>
+                               SBI_OPCODE_SHIFT) == SBI_CMD_CRRD) {
+               unsigned int sbi_offset = (vgpu_vreg(vgpu, SBI_ADDR) &
+                               SBI_ADDR_OFFSET_MASK) >> SBI_ADDR_OFFSET_SHIFT;
+               vgpu_vreg(vgpu, offset) = read_virtual_sbi_register(vgpu,
+                               sbi_offset);
+       }
+       read_vreg(vgpu, offset, p_data, bytes);
+       return 0;
+}
+
+static bool sbi_ctl_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       u32 data;
+
+       write_vreg(vgpu, offset, p_data, bytes);
+       data = vgpu_vreg(vgpu, offset);
+
+       data &= ~(SBI_STAT_MASK << SBI_STAT_SHIFT);
+       data |= SBI_READY;
+
+       data &= ~(SBI_RESPONSE_MASK << SBI_RESPONSE_SHIFT);
+       data |= SBI_RESPONSE_SUCCESS;
+
+       vgpu_vreg(vgpu, offset) = data;
+
+       if (((vgpu_vreg(vgpu, SBI_CTL_STAT) & SBI_OPCODE_MASK) >>
+                               SBI_OPCODE_SHIFT) == SBI_CMD_CRWR) {
+               unsigned int sbi_offset = (vgpu_vreg(vgpu, SBI_ADDR) &
+                               SBI_ADDR_OFFSET_MASK) >> SBI_ADDR_OFFSET_SHIFT;
+
+               write_virtual_sbi_register(vgpu, sbi_offset,
+                               vgpu_vreg(vgpu, SBI_DATA));
+       }
+       return 0;
+}
+
 #define _vgtif_reg(x) \
        (VGT_PVINFO_PAGE + offsetof(struct vgt_if, x))
 
@@ -312,6 +1010,23 @@ static int handle_g2v_notification(struct intel_vgpu *vgpu, int notification)
        return ret;
 }
 
+static int send_display_ready_uevent(struct intel_vgpu *vgpu, int ready)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+       struct kobject *kobj = &dev_priv->drm.primary->kdev->kobj;
+       char *env[3] = {NULL, NULL, NULL};
+       char vmid_str[20];
+       char display_ready_str[20];
+
+       snprintf(display_ready_str, 20, "GVT_DISPLAY_READY=%d\n", ready);
+       env[0] = display_ready_str;
+
+       snprintf(vmid_str, 20, "VMID=%d", vgpu->id);
+       env[1] = vmid_str;
+
+       return kobject_uevent_env(kobj, KOBJ_ADD, env);
+}
+
 static int pvinfo_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
                void *p_data, unsigned int bytes)
 {
@@ -323,6 +1038,8 @@ static int pvinfo_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
 
        switch (offset) {
        case _vgtif_reg(display_ready):
+               send_display_ready_uevent(vgpu, data ? 1 : 0);
+               break;
        case _vgtif_reg(g2v_notify):
                ret = handle_g2v_notification(vgpu, data);
                break;
@@ -348,6 +1065,34 @@ static int pvinfo_mmio_write(struct intel_vgpu *vgpu, unsigned int offset,
        return 0;
 }
 
+static int pf_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       u32 val = *(u32 *)p_data;
+
+       if ((offset == _PS_1A_CTRL || offset == _PS_2A_CTRL ||
+          offset == _PS_1B_CTRL || offset == _PS_2B_CTRL ||
+          offset == _PS_1C_CTRL) && (val & PS_PLANE_SEL_MASK) != 0) {
+               WARN_ONCE(true, "VM(%d): guest is trying to scaling a plane\n",
+                         vgpu->id);
+               return 0;
+       }
+
+       return intel_vgpu_default_mmio_write(vgpu, offset, p_data, bytes);
+}
+
+static int power_well_ctl_mmio_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       write_vreg(vgpu, offset, p_data, bytes);
+
+       if (vgpu_vreg(vgpu, offset) & HSW_PWR_WELL_ENABLE_REQUEST)
+               vgpu_vreg(vgpu, offset) |= HSW_PWR_WELL_STATE_ENABLED;
+       else
+               vgpu_vreg(vgpu, offset) &= ~HSW_PWR_WELL_STATE_ENABLED;
+       return 0;
+}
+
 static int fpga_dbg_mmio_write(struct intel_vgpu *vgpu,
        unsigned int offset, void *p_data, unsigned int bytes)
 {
@@ -404,6 +1149,119 @@ static int gen9_trtt_chicken_write(struct intel_vgpu *vgpu, unsigned int offset,
        return 0;
 }
 
+static int dpll_status_read(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       u32 v = 0;
+
+       if (vgpu_vreg(vgpu, 0x46010) & (1 << 31))
+               v |= (1 << 0);
+
+       if (vgpu_vreg(vgpu, 0x46014) & (1 << 31))
+               v |= (1 << 8);
+
+       if (vgpu_vreg(vgpu, 0x46040) & (1 << 31))
+               v |= (1 << 16);
+
+       if (vgpu_vreg(vgpu, 0x46060) & (1 << 31))
+               v |= (1 << 24);
+
+       vgpu_vreg(vgpu, offset) = v;
+
+       return intel_vgpu_default_mmio_read(vgpu, offset, p_data, bytes);
+}
+
+static int mailbox_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       u32 value = *(u32 *)p_data;
+       u32 cmd = value & 0xff;
+       u32 *data0 = &vgpu_vreg(vgpu, GEN6_PCODE_DATA);
+
+       switch (cmd) {
+       case 0x6:
+               /**
+                * "Read memory latency" command on gen9.
+                * Below memory latency values are read
+                * from skylake platform.
+                */
+               if (!*data0)
+                       *data0 = 0x1e1a1100;
+               else
+                       *data0 = 0x61514b3d;
+               break;
+       case 0x5:
+               *data0 |= 0x1;
+               break;
+       }
+
+       gvt_dbg_core("VM(%d) write %x to mailbox, return data0 %x\n",
+                    vgpu->id, value, *data0);
+
+       value &= ~(1 << 31);
+       return intel_vgpu_default_mmio_write(vgpu, offset, &value, bytes);
+}
+
+static int skl_power_well_ctl_write(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       u32 v = *(u32 *)p_data;
+
+       v &= (1 << 31) | (1 << 29) | (1 << 9) |
+            (1 << 7) | (1 << 5) | (1 << 3) | (1 << 1);
+       v |= (v >> 1);
+
+       return intel_vgpu_default_mmio_write(vgpu, offset, &v, bytes);
+}
+
+static int skl_misc_ctl_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+       i915_reg_t reg = {.reg = offset};
+
+       switch (offset) {
+       case 0x4ddc:
+               vgpu_vreg(vgpu, offset) = 0x8000003c;
+               break;
+       case 0x42080:
+               vgpu_vreg(vgpu, offset) = 0x8000;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       /**
+        * TODO: need detect stepping info after gvt contain such information
+        * 0x4ddc enabled after C0, 0x42080 enabled after E0.
+        */
+       I915_WRITE(reg, vgpu_vreg(vgpu, offset));
+       return 0;
+}
+
+static int skl_lcpll_write(struct intel_vgpu *vgpu, unsigned int offset,
+               void *p_data, unsigned int bytes)
+{
+       u32 v = *(u32 *)p_data;
+
+       /* other bits are MBZ. */
+       v &= (1 << 31) | (1 << 30);
+       v & (1 << 31) ? (v |= (1 << 30)) : (v &= ~(1 << 30));
+
+       vgpu_vreg(vgpu, offset) = v;
+
+       return 0;
+}
+
+static int ring_timestamp_mmio_read(struct intel_vgpu *vgpu,
+               unsigned int offset, void *p_data, unsigned int bytes)
+{
+       struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+
+       vgpu_vreg(vgpu, offset) = I915_READ(_MMIO(offset));
+       return intel_vgpu_default_mmio_read(vgpu, offset, p_data, bytes);
+}
+
 #define MMIO_F(reg, s, f, am, rm, d, r, w) do { \
        ret = new_mmio_info(gvt, INTEL_GVT_MMIO_OFFSET(reg), \
                f, s, am, rm, d, r, w); \
@@ -490,8 +1348,10 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
 
        MMIO_RING_DFH(RING_MI_MODE, D_ALL, F_MODE_MASK, NULL, NULL);
        MMIO_RING_DFH(RING_INSTPM, D_ALL, F_MODE_MASK, NULL, NULL);
-       MMIO_RING_DFH(RING_TIMESTAMP, D_ALL, F_CMD_ACCESS, NULL, NULL);
-       MMIO_RING_DFH(RING_TIMESTAMP_UDW, D_ALL, F_CMD_ACCESS, NULL, NULL);
+       MMIO_RING_DFH(RING_TIMESTAMP, D_ALL, F_CMD_ACCESS,
+                       ring_timestamp_mmio_read, NULL);
+       MMIO_RING_DFH(RING_TIMESTAMP_UDW, D_ALL, F_CMD_ACCESS,
+                       ring_timestamp_mmio_read, NULL);
 
        MMIO_DFH(GEN7_GT_MODE, D_ALL, F_MODE_MASK, NULL, NULL);
        MMIO_DFH(CACHE_MODE_0_GEN7, D_ALL, F_MODE_MASK, NULL, NULL);
@@ -531,10 +1391,10 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(PIPEDSL(PIPE_C), D_ALL);
        MMIO_D(PIPEDSL(_PIPE_EDP), D_ALL);
 
-       MMIO_DH(PIPECONF(PIPE_A), D_ALL, NULL, NULL);
-       MMIO_DH(PIPECONF(PIPE_B), D_ALL, NULL, NULL);
-       MMIO_DH(PIPECONF(PIPE_C), D_ALL, NULL, NULL);
-       MMIO_DH(PIPECONF(_PIPE_EDP), D_ALL, NULL, NULL);
+       MMIO_DH(PIPECONF(PIPE_A), D_ALL, NULL, pipeconf_mmio_write);
+       MMIO_DH(PIPECONF(PIPE_B), D_ALL, NULL, pipeconf_mmio_write);
+       MMIO_DH(PIPECONF(PIPE_C), D_ALL, NULL, pipeconf_mmio_write);
+       MMIO_DH(PIPECONF(_PIPE_EDP), D_ALL, NULL, pipeconf_mmio_write);
 
        MMIO_D(PIPESTAT(PIPE_A), D_ALL);
        MMIO_D(PIPESTAT(PIPE_B), D_ALL);
@@ -577,7 +1437,7 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(DSPSTRIDE(PIPE_A), D_ALL);
        MMIO_D(DSPPOS(PIPE_A), D_ALL);
        MMIO_D(DSPSIZE(PIPE_A), D_ALL);
-       MMIO_D(DSPSURF(PIPE_A), D_ALL);
+       MMIO_DH(DSPSURF(PIPE_A), D_ALL, NULL, pri_surf_mmio_write);
        MMIO_D(DSPOFFSET(PIPE_A), D_ALL);
        MMIO_D(DSPSURFLIVE(PIPE_A), D_ALL);
 
@@ -586,7 +1446,7 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(DSPSTRIDE(PIPE_B), D_ALL);
        MMIO_D(DSPPOS(PIPE_B), D_ALL);
        MMIO_D(DSPSIZE(PIPE_B), D_ALL);
-       MMIO_D(DSPSURF(PIPE_B), D_ALL);
+       MMIO_DH(DSPSURF(PIPE_B), D_ALL, NULL, pri_surf_mmio_write);
        MMIO_D(DSPOFFSET(PIPE_B), D_ALL);
        MMIO_D(DSPSURFLIVE(PIPE_B), D_ALL);
 
@@ -595,7 +1455,7 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(DSPSTRIDE(PIPE_C), D_ALL);
        MMIO_D(DSPPOS(PIPE_C), D_ALL);
        MMIO_D(DSPSIZE(PIPE_C), D_ALL);
-       MMIO_D(DSPSURF(PIPE_C), D_ALL);
+       MMIO_DH(DSPSURF(PIPE_C), D_ALL, NULL, pri_surf_mmio_write);
        MMIO_D(DSPOFFSET(PIPE_C), D_ALL);
        MMIO_D(DSPSURFLIVE(PIPE_C), D_ALL);
 
@@ -606,7 +1466,7 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(SPRSIZE(PIPE_A), D_ALL);
        MMIO_D(SPRKEYVAL(PIPE_A), D_ALL);
        MMIO_D(SPRKEYMSK(PIPE_A), D_ALL);
-       MMIO_D(SPRSURF(PIPE_A), D_ALL);
+       MMIO_DH(SPRSURF(PIPE_A), D_ALL, NULL, spr_surf_mmio_write);
        MMIO_D(SPRKEYMAX(PIPE_A), D_ALL);
        MMIO_D(SPROFFSET(PIPE_A), D_ALL);
        MMIO_D(SPRSCALE(PIPE_A), D_ALL);
@@ -619,7 +1479,7 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(SPRSIZE(PIPE_B), D_ALL);
        MMIO_D(SPRKEYVAL(PIPE_B), D_ALL);
        MMIO_D(SPRKEYMSK(PIPE_B), D_ALL);
-       MMIO_D(SPRSURF(PIPE_B), D_ALL);
+       MMIO_DH(SPRSURF(PIPE_B), D_ALL, NULL, spr_surf_mmio_write);
        MMIO_D(SPRKEYMAX(PIPE_B), D_ALL);
        MMIO_D(SPROFFSET(PIPE_B), D_ALL);
        MMIO_D(SPRSCALE(PIPE_B), D_ALL);
@@ -632,7 +1492,7 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(SPRSIZE(PIPE_C), D_ALL);
        MMIO_D(SPRKEYVAL(PIPE_C), D_ALL);
        MMIO_D(SPRKEYMSK(PIPE_C), D_ALL);
-       MMIO_D(SPRSURF(PIPE_C), D_ALL);
+       MMIO_DH(SPRSURF(PIPE_C), D_ALL, NULL, spr_surf_mmio_write);
        MMIO_D(SPRKEYMAX(PIPE_C), D_ALL);
        MMIO_D(SPROFFSET(PIPE_C), D_ALL);
        MMIO_D(SPRSCALE(PIPE_C), D_ALL);
@@ -752,29 +1612,32 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
 
        MMIO_D(0x48268, D_ALL);
 
-       MMIO_F(PCH_GMBUS0, 4 * 4, 0, 0, 0, D_ALL, NULL, NULL);
-       MMIO_F(PCH_GPIOA, 6 * 4, 0, 0, 0, D_ALL, NULL, NULL);
+       MMIO_F(PCH_GMBUS0, 4 * 4, 0, 0, 0, D_ALL, gmbus_mmio_read,
+               gmbus_mmio_write);
+       MMIO_F(PCH_GPIOA, 6 * 4, F_UNALIGN, 0, 0, D_ALL, NULL, NULL);
        MMIO_F(0xe4f00, 0x28, 0, 0, 0, D_ALL, NULL, NULL);
 
-       MMIO_F(_PCH_DPB_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_PRE_SKL, NULL, NULL);
-       MMIO_F(_PCH_DPC_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_PRE_SKL, NULL, NULL);
-       MMIO_F(_PCH_DPD_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_PRE_SKL, NULL, NULL);
+       MMIO_F(_PCH_DPB_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_PRE_SKL, NULL,
+               dp_aux_ch_ctl_mmio_write);
+       MMIO_F(_PCH_DPC_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_PRE_SKL, NULL,
+               dp_aux_ch_ctl_mmio_write);
+       MMIO_F(_PCH_DPD_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_PRE_SKL, NULL,
+               dp_aux_ch_ctl_mmio_write);
 
-       MMIO_RO(PCH_ADPA, D_ALL, 0,
-                       ADPA_CRT_HOTPLUG_MONITOR_MASK, NULL, NULL);
+       MMIO_RO(PCH_ADPA, D_ALL, 0, ADPA_CRT_HOTPLUG_MONITOR_MASK, NULL, pch_adpa_mmio_write);
 
-       MMIO_DH(_PCH_TRANSACONF, D_ALL, NULL, NULL);
-       MMIO_DH(_PCH_TRANSBCONF, D_ALL, NULL, NULL);
+       MMIO_DH(_PCH_TRANSACONF, D_ALL, NULL, transconf_mmio_write);
+       MMIO_DH(_PCH_TRANSBCONF, D_ALL, NULL, transconf_mmio_write);
 
-       MMIO_DH(FDI_RX_IIR(PIPE_A), D_ALL, NULL, NULL);
-       MMIO_DH(FDI_RX_IIR(PIPE_B), D_ALL, NULL, NULL);
-       MMIO_DH(FDI_RX_IIR(PIPE_C), D_ALL, NULL, NULL);
-       MMIO_DH(FDI_RX_IMR(PIPE_A), D_ALL, NULL, NULL);
-       MMIO_DH(FDI_RX_IMR(PIPE_B), D_ALL, NULL, NULL);
-       MMIO_DH(FDI_RX_IMR(PIPE_C), D_ALL, NULL, NULL);
-       MMIO_DH(FDI_RX_CTL(PIPE_A), D_ALL, NULL, NULL);
-       MMIO_DH(FDI_RX_CTL(PIPE_B), D_ALL, NULL, NULL);
-       MMIO_DH(FDI_RX_CTL(PIPE_C), D_ALL, NULL, NULL);
+       MMIO_DH(FDI_RX_IIR(PIPE_A), D_ALL, NULL, fdi_rx_iir_mmio_write);
+       MMIO_DH(FDI_RX_IIR(PIPE_B), D_ALL, NULL, fdi_rx_iir_mmio_write);
+       MMIO_DH(FDI_RX_IIR(PIPE_C), D_ALL, NULL, fdi_rx_iir_mmio_write);
+       MMIO_DH(FDI_RX_IMR(PIPE_A), D_ALL, NULL, update_fdi_rx_iir_status);
+       MMIO_DH(FDI_RX_IMR(PIPE_B), D_ALL, NULL, update_fdi_rx_iir_status);
+       MMIO_DH(FDI_RX_IMR(PIPE_C), D_ALL, NULL, update_fdi_rx_iir_status);
+       MMIO_DH(FDI_RX_CTL(PIPE_A), D_ALL, NULL, update_fdi_rx_iir_status);
+       MMIO_DH(FDI_RX_CTL(PIPE_B), D_ALL, NULL, update_fdi_rx_iir_status);
+       MMIO_DH(FDI_RX_CTL(PIPE_C), D_ALL, NULL, update_fdi_rx_iir_status);
 
        MMIO_D(_PCH_TRANS_HTOTAL_A, D_ALL);
        MMIO_D(_PCH_TRANS_HBLANK_A, D_ALL);
@@ -824,7 +1687,7 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(_FDI_RXB_TUSIZE1, D_ALL);
        MMIO_D(_FDI_RXB_TUSIZE2, D_ALL);
 
-       MMIO_DH(PCH_PP_CONTROL, D_ALL, NULL, NULL);
+       MMIO_DH(PCH_PP_CONTROL, D_ALL, NULL, pch_pp_control_mmio_write);
        MMIO_D(PCH_PP_DIVISOR, D_ALL);
        MMIO_D(PCH_PP_STATUS,  D_ALL);
        MMIO_D(PCH_LVDS, D_ALL);
@@ -843,12 +1706,12 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(PCH_PP_ON_DELAYS, D_ALL);
        MMIO_D(PCH_PP_OFF_DELAYS, D_ALL);
 
-       MMIO_DH(0xe651c, D_ALL, NULL, NULL);
-       MMIO_DH(0xe661c, D_ALL, NULL, NULL);
-       MMIO_DH(0xe671c, D_ALL, NULL, NULL);
-       MMIO_DH(0xe681c, D_ALL, NULL, NULL);
-       MMIO_DH(0xe6c04, D_ALL, NULL, NULL);
-       MMIO_DH(0xe6e1c, D_ALL, NULL, NULL);
+       MMIO_DH(0xe651c, D_ALL, dpy_reg_mmio_read, NULL);
+       MMIO_DH(0xe661c, D_ALL, dpy_reg_mmio_read, NULL);
+       MMIO_DH(0xe671c, D_ALL, dpy_reg_mmio_read, NULL);
+       MMIO_DH(0xe681c, D_ALL, dpy_reg_mmio_read, NULL);
+       MMIO_DH(0xe6c04, D_ALL, dpy_reg_mmio_read_2, NULL);
+       MMIO_DH(0xe6e1c, D_ALL, dpy_reg_mmio_read_3, NULL);
 
        MMIO_RO(PCH_PORT_HOTPLUG, D_ALL, 0,
                PORTA_HOTPLUG_STATUS_MASK
@@ -857,7 +1720,7 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
                | PORTD_HOTPLUG_STATUS_MASK,
                NULL, NULL);
 
-       MMIO_DH(LCPLL_CTL, D_ALL, NULL, NULL);
+       MMIO_DH(LCPLL_CTL, D_ALL, NULL, lcpll_ctl_mmio_write);
        MMIO_D(FUSE_STRAP, D_ALL);
        MMIO_D(DIGITAL_PORT_HOTPLUG_CNTRL, D_ALL);
 
@@ -869,7 +1732,7 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(ILK_DSPCLK_GATE_D, D_ALL);
 
        MMIO_D(SOUTH_CHICKEN1, D_ALL);
-       MMIO_DH(SOUTH_CHICKEN2, D_ALL, NULL, NULL);
+       MMIO_DH(SOUTH_CHICKEN2, D_ALL, NULL, south_chicken2_mmio_write);
        MMIO_D(_TRANSA_CHICKEN1, D_ALL);
        MMIO_D(_TRANSB_CHICKEN1, D_ALL);
        MMIO_D(SOUTH_DSPCLK_GATE_D, D_ALL);
@@ -928,6 +1791,18 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(PIPE_CSC_POSTOFF_ME(PIPE_C), D_ALL);
        MMIO_D(PIPE_CSC_POSTOFF_LO(PIPE_C), D_ALL);
 
+       MMIO_D(PREC_PAL_INDEX(PIPE_A), D_ALL);
+       MMIO_D(PREC_PAL_DATA(PIPE_A), D_ALL);
+       MMIO_F(PREC_PAL_GC_MAX(PIPE_A, 0), 4 * 3, 0, 0, 0, D_ALL, NULL, NULL);
+
+       MMIO_D(PREC_PAL_INDEX(PIPE_B), D_ALL);
+       MMIO_D(PREC_PAL_DATA(PIPE_B), D_ALL);
+       MMIO_F(PREC_PAL_GC_MAX(PIPE_B, 0), 4 * 3, 0, 0, 0, D_ALL, NULL, NULL);
+
+       MMIO_D(PREC_PAL_INDEX(PIPE_C), D_ALL);
+       MMIO_D(PREC_PAL_DATA(PIPE_C), D_ALL);
+       MMIO_F(PREC_PAL_GC_MAX(PIPE_C, 0), 4 * 3, 0, 0, 0, D_ALL, NULL, NULL);
+
        MMIO_D(0x60110, D_ALL);
        MMIO_D(0x61110, D_ALL);
        MMIO_F(0x70400, 0x40, 0, 0, 0, D_ALL, NULL, NULL);
@@ -970,10 +1845,6 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(GAMMA_MODE(PIPE_B), D_ALL);
        MMIO_D(GAMMA_MODE(PIPE_C), D_ALL);
 
-       MMIO_D(0x4a400, D_ALL);
-       MMIO_D(0x4ac00, D_ALL);
-       MMIO_D(0x4b400, D_ALL);
-
        MMIO_D(PIPE_MULT(PIPE_A), D_ALL);
        MMIO_D(PIPE_MULT(PIPE_B), D_ALL);
        MMIO_D(PIPE_MULT(PIPE_C), D_ALL);
@@ -984,39 +1855,30 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
 
        MMIO_DH(SFUSE_STRAP, D_ALL, NULL, NULL);
        MMIO_D(SBI_ADDR, D_ALL);
-       MMIO_DH(SBI_DATA, D_ALL, NULL, NULL);
-       MMIO_DH(SBI_CTL_STAT, D_ALL, NULL, NULL);
+       MMIO_DH(SBI_DATA, D_ALL, sbi_data_mmio_read, NULL);
+       MMIO_DH(SBI_CTL_STAT, D_ALL, NULL, sbi_ctl_mmio_write);
        MMIO_D(PIXCLK_GATE, D_ALL);
 
-       MMIO_F(_DPA_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_ALL, NULL, NULL);
-
-       MMIO_RO(DDI_BUF_CTL(PORT_A), D_ALL, 0,
-               DDI_INIT_DISPLAY_DETECTED, NULL, NULL);
-       MMIO_RO(DDI_BUF_CTL(PORT_B), D_ALL, 0,
-               DDI_INIT_DISPLAY_DETECTED, NULL, NULL);
-       MMIO_RO(DDI_BUF_CTL(PORT_C), D_ALL, 0,
-               DDI_INIT_DISPLAY_DETECTED, NULL, NULL);
-       MMIO_RO(DDI_BUF_CTL(PORT_D), D_ALL, 0,
-               DDI_INIT_DISPLAY_DETECTED, NULL, NULL);
-       MMIO_RO(DDI_BUF_CTL(PORT_E), D_ALL, 0,
-               DDI_INIT_DISPLAY_DETECTED, NULL, NULL);
-
-       MMIO_DH(DP_TP_CTL(PORT_A), D_ALL, NULL, NULL);
-       MMIO_DH(DP_TP_CTL(PORT_B), D_ALL, NULL, NULL);
-       MMIO_DH(DP_TP_CTL(PORT_C), D_ALL, NULL, NULL);
-       MMIO_DH(DP_TP_CTL(PORT_D), D_ALL, NULL, NULL);
-       MMIO_DH(DP_TP_CTL(PORT_E), D_ALL, NULL, NULL);
-
-       MMIO_RO(DP_TP_STATUS(PORT_A), D_ALL, 0,
-                       (1 << 27) | (1 << 26) | (1 << 24), NULL, NULL);
-       MMIO_RO(DP_TP_STATUS(PORT_B), D_ALL, 0,
-                       (1 << 27) | (1 << 26) | (1 << 24), NULL, NULL);
-       MMIO_RO(DP_TP_STATUS(PORT_C), D_ALL, 0,
-                       (1 << 27) | (1 << 26) | (1 << 24), NULL, NULL);
-       MMIO_RO(DP_TP_STATUS(PORT_D), D_ALL, 0,
-                       (1 << 27) | (1 << 26) | (1 << 24), NULL, NULL);
-       MMIO_RO(DP_TP_STATUS(PORT_E), D_ALL, 0,
-                       (1 << 27) | (1 << 26) | (1 << 24), NULL, NULL);
+       MMIO_F(_DPA_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_ALL, NULL,
+               dp_aux_ch_ctl_mmio_write);
+
+       MMIO_DH(DDI_BUF_CTL(PORT_A), D_ALL, NULL, ddi_buf_ctl_mmio_write);
+       MMIO_DH(DDI_BUF_CTL(PORT_B), D_ALL, NULL, ddi_buf_ctl_mmio_write);
+       MMIO_DH(DDI_BUF_CTL(PORT_C), D_ALL, NULL, ddi_buf_ctl_mmio_write);
+       MMIO_DH(DDI_BUF_CTL(PORT_D), D_ALL, NULL, ddi_buf_ctl_mmio_write);
+       MMIO_DH(DDI_BUF_CTL(PORT_E), D_ALL, NULL, ddi_buf_ctl_mmio_write);
+
+       MMIO_DH(DP_TP_CTL(PORT_A), D_ALL, NULL, dp_tp_ctl_mmio_write);
+       MMIO_DH(DP_TP_CTL(PORT_B), D_ALL, NULL, dp_tp_ctl_mmio_write);
+       MMIO_DH(DP_TP_CTL(PORT_C), D_ALL, NULL, dp_tp_ctl_mmio_write);
+       MMIO_DH(DP_TP_CTL(PORT_D), D_ALL, NULL, dp_tp_ctl_mmio_write);
+       MMIO_DH(DP_TP_CTL(PORT_E), D_ALL, NULL, dp_tp_ctl_mmio_write);
+
+       MMIO_DH(DP_TP_STATUS(PORT_A), D_ALL, NULL, dp_tp_status_mmio_write);
+       MMIO_DH(DP_TP_STATUS(PORT_B), D_ALL, NULL, dp_tp_status_mmio_write);
+       MMIO_DH(DP_TP_STATUS(PORT_C), D_ALL, NULL, dp_tp_status_mmio_write);
+       MMIO_DH(DP_TP_STATUS(PORT_D), D_ALL, NULL, dp_tp_status_mmio_write);
+       MMIO_DH(DP_TP_STATUS(PORT_E), D_ALL, NULL, NULL);
 
        MMIO_F(_DDI_BUF_TRANS_A, 0x50, 0, 0, 0, D_ALL, NULL, NULL);
        MMIO_F(0x64e60, 0x50, 0, 0, 0, D_ALL, NULL, NULL);
@@ -1076,19 +1938,19 @@ static int init_generic_mmio_info(struct intel_gvt *gvt)
        MMIO_D(GEN6_RC6p_THRESHOLD, D_ALL);
        MMIO_D(GEN6_RC6pp_THRESHOLD, D_ALL);
        MMIO_D(GEN6_PMINTRMSK, D_ALL);
-       MMIO_DH(HSW_PWR_WELL_BIOS, D_HSW | D_BDW, NULL, NULL);
-       MMIO_DH(HSW_PWR_WELL_DRIVER, D_HSW | D_BDW, NULL, NULL);
-       MMIO_DH(HSW_PWR_WELL_KVMR, D_HSW | D_BDW, NULL, NULL);
-       MMIO_DH(HSW_PWR_WELL_DEBUG, D_HSW | D_BDW, NULL, NULL);
-       MMIO_DH(HSW_PWR_WELL_CTL5, D_HSW | D_BDW, NULL, NULL);
-       MMIO_DH(HSW_PWR_WELL_CTL6, D_HSW | D_BDW, NULL, NULL);
+       MMIO_DH(HSW_PWR_WELL_BIOS, D_HSW | D_BDW, NULL, power_well_ctl_mmio_write);
+       MMIO_DH(HSW_PWR_WELL_DRIVER, D_HSW | D_BDW, NULL, power_well_ctl_mmio_write);
+       MMIO_DH(HSW_PWR_WELL_KVMR, D_HSW | D_BDW, NULL, power_well_ctl_mmio_write);
+       MMIO_DH(HSW_PWR_WELL_DEBUG, D_HSW | D_BDW, NULL, power_well_ctl_mmio_write);
+       MMIO_DH(HSW_PWR_WELL_CTL5, D_HSW | D_BDW, NULL, power_well_ctl_mmio_write);
+       MMIO_DH(HSW_PWR_WELL_CTL6, D_HSW | D_BDW, NULL, power_well_ctl_mmio_write);
 
        MMIO_D(RSTDBYCTL, D_ALL);
 
        MMIO_DH(GEN6_GDRST, D_ALL, NULL, gdrst_mmio_write);
        MMIO_F(FENCE_REG_GEN6_LO(0), 0x80, 0, 0, 0, D_ALL, fence_mmio_read, fence_mmio_write);
        MMIO_F(VGT_PVINFO_PAGE, VGT_PVINFO_SIZE, F_UNALIGN, 0, 0, D_ALL, pvinfo_mmio_read, pvinfo_mmio_write);
-       MMIO_DH(CPU_VGACNTRL, D_ALL, NULL, NULL);
+       MMIO_DH(CPU_VGACNTRL, D_ALL, NULL, vga_control_mmio_write);
 
        MMIO_F(MCHBAR_MIRROR_BASE_SNB, 0x40000, 0, 0, 0, D_ALL, NULL, NULL);
 
@@ -1301,8 +2163,8 @@ static int init_broadwell_mmio_info(struct intel_gvt *gvt)
                        NULL, NULL);
        MMIO_DFH(RING_INSTPM(GEN8_BSD2_RING_BASE), D_BDW_PLUS, F_MODE_MASK,
                        NULL, NULL);
-       MMIO_DFH(RING_TIMESTAMP(GEN8_BSD2_RING_BASE), D_BDW_PLUS, F_MODE_MASK,
-                       NULL, NULL);
+       MMIO_DFH(RING_TIMESTAMP(GEN8_BSD2_RING_BASE), D_BDW_PLUS, F_CMD_ACCESS,
+                       ring_timestamp_mmio_read, NULL);
 
        MMIO_RING_D(RING_ACTHD_UDW, D_BDW_PLUS);
 
@@ -1422,24 +2284,24 @@ static int init_skl_mmio_info(struct intel_gvt *gvt)
        MMIO_DH(FORCEWAKE_MEDIA_GEN9, D_SKL_PLUS, NULL, mul_force_wake_write);
        MMIO_DH(FORCEWAKE_ACK_MEDIA_GEN9, D_SKL_PLUS, NULL, NULL);
 
-       MMIO_F(_DPB_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_SKL, NULL, NULL);
-       MMIO_F(_DPC_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_SKL, NULL, NULL);
-       MMIO_F(_DPD_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_SKL, NULL, NULL);
+       MMIO_F(_DPB_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_SKL, NULL, dp_aux_ch_ctl_mmio_write);
+       MMIO_F(_DPC_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_SKL, NULL, dp_aux_ch_ctl_mmio_write);
+       MMIO_F(_DPD_AUX_CH_CTL, 6 * 4, 0, 0, 0, D_SKL, NULL, dp_aux_ch_ctl_mmio_write);
 
        MMIO_D(HSW_PWR_WELL_BIOS, D_SKL);
-       MMIO_DH(HSW_PWR_WELL_DRIVER, D_SKL, NULL, NULL);
+       MMIO_DH(HSW_PWR_WELL_DRIVER, D_SKL, NULL, skl_power_well_ctl_write);
 
-       MMIO_DH(GEN6_PCODE_MAILBOX, D_SKL, NULL, NULL);
+       MMIO_DH(GEN6_PCODE_MAILBOX, D_SKL, NULL, mailbox_write);
        MMIO_D(0xa210, D_SKL_PLUS);
        MMIO_D(GEN9_MEDIA_PG_IDLE_HYSTERESIS, D_SKL_PLUS);
        MMIO_D(GEN9_RENDER_PG_IDLE_HYSTERESIS, D_SKL_PLUS);
-       MMIO_DH(0x4ddc, D_SKL, NULL, NULL);
-       MMIO_DH(0x42080, D_SKL, NULL, NULL);
+       MMIO_DH(0x4ddc, D_SKL, NULL, skl_misc_ctl_write);
+       MMIO_DH(0x42080, D_SKL, NULL, skl_misc_ctl_write);
        MMIO_D(0x45504, D_SKL);
        MMIO_D(0x45520, D_SKL);
        MMIO_D(0x46000, D_SKL);
-       MMIO_DH(0x46010, D_SKL, NULL, NULL);
-       MMIO_DH(0x46014, D_SKL, NULL, NULL);
+       MMIO_DH(0x46010, D_SKL, NULL, skl_lcpll_write);
+       MMIO_DH(0x46014, D_SKL, NULL, skl_lcpll_write);
        MMIO_D(0x6C040, D_SKL);
        MMIO_D(0x6C048, D_SKL);
        MMIO_D(0x6C050, D_SKL);
@@ -1448,28 +2310,28 @@ static int init_skl_mmio_info(struct intel_gvt *gvt)
        MMIO_D(0x6C054, D_SKL);
        MMIO_D(0x6c058, D_SKL);
        MMIO_D(0x6c05c, D_SKL);
-       MMIO_DH(0x6c060, D_SKL, NULL, NULL);
-
-       MMIO_DH(SKL_PS_WIN_POS(PIPE_A, 0), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_WIN_POS(PIPE_A, 1), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_WIN_POS(PIPE_B, 0), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_WIN_POS(PIPE_B, 1), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_WIN_POS(PIPE_C, 0), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_WIN_POS(PIPE_C, 1), D_SKL, NULL, NULL);
-
-       MMIO_DH(SKL_PS_WIN_SZ(PIPE_A, 0), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_WIN_SZ(PIPE_A, 1), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_WIN_SZ(PIPE_B, 0), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_WIN_SZ(PIPE_B, 1), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_WIN_SZ(PIPE_C, 0), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_WIN_SZ(PIPE_C, 1), D_SKL, NULL, NULL);
-
-       MMIO_DH(SKL_PS_CTRL(PIPE_A, 0), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_CTRL(PIPE_A, 1), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_CTRL(PIPE_B, 0), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_CTRL(PIPE_B, 1), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_CTRL(PIPE_C, 0), D_SKL, NULL, NULL);
-       MMIO_DH(SKL_PS_CTRL(PIPE_C, 1), D_SKL, NULL, NULL);
+       MMIO_DH(0X6c060, D_SKL, dpll_status_read, NULL);
+
+       MMIO_DH(SKL_PS_WIN_POS(PIPE_A, 0), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_WIN_POS(PIPE_A, 1), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_WIN_POS(PIPE_B, 0), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_WIN_POS(PIPE_B, 1), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_WIN_POS(PIPE_C, 0), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_WIN_POS(PIPE_C, 1), D_SKL, NULL, pf_write);
+
+       MMIO_DH(SKL_PS_WIN_SZ(PIPE_A, 0), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_WIN_SZ(PIPE_A, 1), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_WIN_SZ(PIPE_B, 0), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_WIN_SZ(PIPE_B, 1), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_WIN_SZ(PIPE_C, 0), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_WIN_SZ(PIPE_C, 1), D_SKL, NULL, pf_write);
+
+       MMIO_DH(SKL_PS_CTRL(PIPE_A, 0), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_CTRL(PIPE_A, 1), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_CTRL(PIPE_B, 0), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_CTRL(PIPE_B, 1), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_CTRL(PIPE_C, 0), D_SKL, NULL, pf_write);
+       MMIO_DH(SKL_PS_CTRL(PIPE_C, 1), D_SKL, NULL, pf_write);
 
        MMIO_DH(PLANE_BUF_CFG(PIPE_A, 0), D_SKL, NULL, NULL);
        MMIO_DH(PLANE_BUF_CFG(PIPE_A, 1), D_SKL, NULL, NULL);
@@ -1634,6 +2496,7 @@ static int init_skl_mmio_info(struct intel_gvt *gvt)
        MMIO_D(0x44500, D_SKL);
        return 0;
 }
+
 /**
  * intel_gvt_find_mmio_info - find MMIO information entry by aligned offset
  * @gvt: GVT device
index d90c5f660b00342f1ff29104247cc307801c1880..84d7174d0081d3770cd890200a458d8e5a59334d 100644 (file)
@@ -667,6 +667,21 @@ static void init_events(
        }
 }
 
+static enum hrtimer_restart vblank_timer_fn(struct hrtimer *data)
+{
+       struct intel_gvt_vblank_timer *vblank_timer;
+       struct intel_gvt_irq *irq;
+       struct intel_gvt *gvt;
+
+       vblank_timer = container_of(data, struct intel_gvt_vblank_timer, timer);
+       irq = container_of(vblank_timer, struct intel_gvt_irq, vblank_timer);
+       gvt = container_of(irq, struct intel_gvt, irq);
+
+       intel_gvt_request_service(gvt, INTEL_GVT_REQUEST_EMULATE_VBLANK);
+       hrtimer_add_expires_ns(&vblank_timer->timer, vblank_timer->period);
+       return HRTIMER_RESTART;
+}
+
 /**
  * intel_gvt_clean_irq - clean up GVT-g IRQ emulation subsystem
  * @gvt: a GVT device
@@ -677,8 +692,13 @@ static void init_events(
  */
 void intel_gvt_clean_irq(struct intel_gvt *gvt)
 {
+       struct intel_gvt_irq *irq = &gvt->irq;
+
+       hrtimer_cancel(&irq->vblank_timer.timer);
 }
 
+#define VBLNAK_TIMER_PERIOD 16000000
+
 /**
  * intel_gvt_init_irq - initialize GVT-g IRQ emulation subsystem
  * @gvt: a GVT device
@@ -692,6 +712,7 @@ void intel_gvt_clean_irq(struct intel_gvt *gvt)
 int intel_gvt_init_irq(struct intel_gvt *gvt)
 {
        struct intel_gvt_irq *irq = &gvt->irq;
+       struct intel_gvt_vblank_timer *vblank_timer = &irq->vblank_timer;
 
        gvt_dbg_core("init irq framework\n");
 
@@ -710,5 +731,10 @@ int intel_gvt_init_irq(struct intel_gvt *gvt)
        irq->ops->init_irq(irq);
 
        init_irq_map(irq);
+
+       hrtimer_init(&vblank_timer->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
+       vblank_timer->timer.function = vblank_timer_fn;
+       vblank_timer->period = VBLNAK_TIMER_PERIOD;
+
        return 0;
 }
index 28d5d32d60177f141979cbe9e2eb5af49d8fdb9b..3136527b7e5cf1f3b30e8f62e56e928b3987a1c4 100644 (file)
@@ -195,6 +195,11 @@ struct intel_gvt_irq_map {
        u32 down_irq_bitmask;
 };
 
+struct intel_gvt_vblank_timer {
+       struct hrtimer timer;
+       u64 period;
+};
+
 /* structure containing device specific IRQ state */
 struct intel_gvt_irq {
        struct intel_gvt_irq_ops *ops;
@@ -203,6 +208,7 @@ struct intel_gvt_irq {
        struct intel_gvt_event_info events[INTEL_GVT_EVENT_MAX];
        DECLARE_BITMAP(pending_events, INTEL_GVT_EVENT_MAX);
        struct intel_gvt_irq_map *irq_map;
+       struct intel_gvt_vblank_timer vblank_timer;
 };
 
 int intel_gvt_init_irq(struct intel_gvt *gvt);
index 2d4aaa781757c598798298053951393ccdd7be62..47ed0a085e4c9667a648cf28f9f3cb8199cb89e0 100644 (file)
@@ -146,6 +146,7 @@ void intel_gvt_destroy_vgpu(struct intel_vgpu *vgpu)
        vgpu->active = false;
        idr_remove(&gvt->vgpu_idr, vgpu->id);
 
+       intel_vgpu_clean_display(vgpu);
        intel_vgpu_clean_opregion(vgpu);
        intel_vgpu_clean_gtt(vgpu);
        intel_gvt_hypervisor_detach_vgpu(vgpu);
@@ -216,11 +217,17 @@ struct intel_vgpu *intel_gvt_create_vgpu(struct intel_gvt *gvt,
                        goto out_clean_gtt;
        }
 
+       ret = intel_vgpu_init_display(vgpu);
+       if (ret)
+               goto out_clean_opregion;
+
        vgpu->active = true;
        mutex_unlock(&gvt->lock);
 
        return vgpu;
 
+out_clean_opregion:
+       intel_vgpu_clean_opregion(vgpu);
 out_clean_gtt:
        intel_vgpu_clean_gtt(vgpu);
 out_detach_hypervisor_vgpu: