Merge branch 'msm-next' of git://people.freedesktop.org/~robclark/linux into drm-next

Rebase of main pull for 3.20.  There was a mid-air collision between
the bridge changes and msm eDP support.  And atomic dpms support broke
msm somewhat, due to using prepare/commit hooks in a different way.
Compared to the initial pull req, this fixes up a memory leak caused
by the bridge changes, rebases the eDP support on the bridge changes,
and migrates to the atomic dpms hooks to fix the dpms breakage.

Highlights (from original pull req):

1) YUV support for mdp4 and mdp5
2) eDP support
3) hw cursor support for mdp5[*]
4) additional hdmi support for apq8084 (snapdragon 805)
5) few bug fixes

Note that I may have a later pull to enable hdmi hpd irqs.. but
(un)fortunately I seem to have a particularly troublesome monitor..  I
managed to figure out a workaround for spurious hpd disconnect irqs
that works with some of my boards but not others, so holding off on
that patch for now.  There are also patches for HDCP support, but
those are waiting on some scm patches outside of drm so I think
waiting until 3.21 at this point.

* 'msm-next' of git://people.freedesktop.org/~robclark/linux: (22 commits)
  drm/msm: add moduleparam to disable fbdev
  drm/msm: fix build error with W=1
  drm/msm/mdp5: Fix negative SMP block allocation
  drm/msm/hdmi: disallow interlaced
  drm/msm/atomic: fix issue with gnome-shell wayland
  drm/msm/mdp5: Add hardware cursor support
  drm/msm/hdmi: rework hdmi configurations, using dt_match[]
  drm/msm/hdmi: Add HDMI platform config for apq8084
  drm/msm/hdmi: use dynamic allocation for hdmi resources
  drm/msm/mdp5: fix parameter type for mdp5_ctl_set_intf()
  drm/msm/dp: use link power helpers
  drm/msm: Add the eDP connector in msm drm driver (V2)
  drm/msm: Initial add eDP support in msm drm driver (v5)
  drm/msm/mdp4: add YUV format support
  drm/msm/mdp5: add NV12 support for MDP5
  drm/msm/mdp: add common YUV information for MDP4/MDP5
  drm/msm: update generated headers
  drm/msm: Do not BUG_ON(!spin_is_locked()) on UP
  drm/msm/hdmi: fix memory leak after bridge changes
  drm/msm: fix fallout of atomic dpms changes
  ...

53 files changed, 4641 insertions, 722 deletions

diff --git a/Documentation/devicetree/bindings/drm/msm/hdmi.txt b/Documentation/devicetree/bindings/drm/msm/hdmi.txt
index aca917fe2ba7..a29a55f3d937 100644
--- a/Documentation/devicetree/bindings/drm/msm/hdmi.txt
+++ b/Documentation/devicetree/bindings/drm/msm/hdmi.txt
@@ -2,6 +2,8 @@ Qualcomm adreno/snapdragon hdmi output
 
 Required properties:
 - compatible: one of the following
+   * "qcom,hdmi-tx-8084"
+   * "qcom,hdmi-tx-8074"
    * "qcom,hdmi-tx-8660"
    * "qcom,hdmi-tx-8960"
 - reg: Physical base address and length of the controller's registers
diff --git a/drivers/gpu/drm/drm_dp_helper.c b/drivers/gpu/drm/drm_dp_helper.c
index 79968e39c8d0..f1283878ff6d 100644
--- a/drivers/gpu/drm/drm_dp_helper.c
+++ b/drivers/gpu/drm/drm_dp_helper.c
@@ -354,6 +354,37 @@ int drm_dp_link_power_up(struct drm_dp_aux *aux, struct drm_dp_link *link)
 EXPORT_SYMBOL(drm_dp_link_power_up);
 
 /**
+ * drm_dp_link_power_down() - power down a DisplayPort link
+ * @aux: DisplayPort AUX channel
+ * @link: pointer to a structure containing the link configuration
+ *
+ * Returns 0 on success or a negative error code on failure.
+ */
+int drm_dp_link_power_down(struct drm_dp_aux *aux, struct drm_dp_link *link)
+{
+        u8 value;
+        int err;
+
+        /* DP_SET_POWER register is only available on DPCD v1.1 and later */
+        if (link->revision < 0x11)
+                return 0;
+
+        err = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value);
+        if (err < 0)
+                return err;
+
+        value &= ~DP_SET_POWER_MASK;
+        value |= DP_SET_POWER_D3;
+
+        err = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value);
+        if (err < 0)
+                return err;
+
+        return 0;
+}
+EXPORT_SYMBOL(drm_dp_link_power_down);
+
+/**
  * drm_dp_link_configure() - configure a DisplayPort link
  * @aux: DisplayPort AUX channel
  * @link: pointer to a structure containing the link configuration
diff --git a/drivers/gpu/drm/msm/Makefile b/drivers/gpu/drm/msm/Makefile
index 143d988f8add..674a132fd76e 100644
--- a/drivers/gpu/drm/msm/Makefile
+++ b/drivers/gpu/drm/msm/Makefile
@@ -1,7 +1,4 @@
 ccflags-y := -Iinclude/drm -Idrivers/gpu/drm/msm
-ifeq (, $(findstring -W,$(EXTRA_CFLAGS)))
-        ccflags-y += -Werror
-endif
 
 msm-y := \
         adreno/adreno_device.o \
@@ -16,6 +13,12 @@ msm-y := \
         hdmi/hdmi_phy_8960.o \
         hdmi/hdmi_phy_8x60.o \
         hdmi/hdmi_phy_8x74.o \
+        edp/edp.o \
+        edp/edp_aux.o \
+        edp/edp_bridge.o \
+        edp/edp_connector.o \
+        edp/edp_ctrl.o \
+        edp/edp_phy.o \
         mdp/mdp_format.o \
         mdp/mdp_kms.o \
         mdp/mdp4/mdp4_crtc.o \
diff --git a/drivers/gpu/drm/msm/adreno/a2xx.xml.h b/drivers/gpu/drm/msm/adreno/a2xx.xml.h
index 22882cc0a573..edc845fffdf4 100644
--- a/drivers/gpu/drm/msm/adreno/a2xx.xml.h
+++ b/drivers/gpu/drm/msm/adreno/a2xx.xml.h
@@ -12,9 +12,9 @@ The rules-ng-ng source files this header was generated from are:
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml  (   1453 bytes, from 2013-03-31 16:51:27)
 - /home/robclark/src/freedreno/envytools/rnndb/adreno/a2xx.xml          (  32901 bytes, from 2014-06-02 15:21:30)
 - /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_common.xml (  10551 bytes, from 2014-11-13 22:44:30)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_pm4.xml    (  15053 bytes, from 2014-11-09 15:45:47)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/a3xx.xml          (  63169 bytes, from 2014-11-13 22:44:18)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/a4xx.xml          (  49097 bytes, from 2014-11-14 15:38:00)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_pm4.xml    (  15085 bytes, from 2014-12-20 21:49:41)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/a3xx.xml          (  64344 bytes, from 2014-12-12 20:22:26)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/a4xx.xml          (  51069 bytes, from 2014-12-21 15:51:54)
 
 Copyright (C) 2013-2014 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
diff --git a/drivers/gpu/drm/msm/adreno/a3xx.xml.h b/drivers/gpu/drm/msm/adreno/a3xx.xml.h
index 109e9a263daf..e91a739452d7 100644
--- a/drivers/gpu/drm/msm/adreno/a3xx.xml.h
+++ b/drivers/gpu/drm/msm/adreno/a3xx.xml.h
@@ -12,9 +12,9 @@ The rules-ng-ng source files this header was generated from are:
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml  (   1453 bytes, from 2013-03-31 16:51:27)
 - /home/robclark/src/freedreno/envytools/rnndb/adreno/a2xx.xml          (  32901 bytes, from 2014-06-02 15:21:30)
 - /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_common.xml (  10551 bytes, from 2014-11-13 22:44:30)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_pm4.xml    (  15053 bytes, from 2014-11-09 15:45:47)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/a3xx.xml          (  63169 bytes, from 2014-11-13 22:44:18)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/a4xx.xml          (  49097 bytes, from 2014-11-14 15:38:00)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_pm4.xml    (  15085 bytes, from 2014-12-20 21:49:41)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/a3xx.xml          (  64344 bytes, from 2014-12-12 20:22:26)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/a4xx.xml          (  51069 bytes, from 2014-12-21 15:51:54)
 
 Copyright (C) 2013-2014 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
@@ -58,111 +58,130 @@ enum a3xx_cache_opcode {
 };
 
 enum a3xx_vtx_fmt {
-        VFMT_FLOAT_32 = 0,
-        VFMT_FLOAT_32_32 = 1,
-        VFMT_FLOAT_32_32_32 = 2,
-        VFMT_FLOAT_32_32_32_32 = 3,
-        VFMT_FLOAT_16 = 4,
-        VFMT_FLOAT_16_16 = 5,
-        VFMT_FLOAT_16_16_16 = 6,
-        VFMT_FLOAT_16_16_16_16 = 7,
-        VFMT_FIXED_32 = 8,
-        VFMT_FIXED_32_32 = 9,
-        VFMT_FIXED_32_32_32 = 10,
-        VFMT_FIXED_32_32_32_32 = 11,
-        VFMT_SHORT_16 = 16,
-        VFMT_SHORT_16_16 = 17,
-        VFMT_SHORT_16_16_16 = 18,
-        VFMT_SHORT_16_16_16_16 = 19,
-        VFMT_USHORT_16 = 20,
-        VFMT_USHORT_16_16 = 21,
-        VFMT_USHORT_16_16_16 = 22,
-        VFMT_USHORT_16_16_16_16 = 23,
-        VFMT_NORM_SHORT_16 = 24,
-        VFMT_NORM_SHORT_16_16 = 25,
-        VFMT_NORM_SHORT_16_16_16 = 26,
-        VFMT_NORM_SHORT_16_16_16_16 = 27,
-        VFMT_NORM_USHORT_16 = 28,
-        VFMT_NORM_USHORT_16_16 = 29,
-        VFMT_NORM_USHORT_16_16_16 = 30,
-        VFMT_NORM_USHORT_16_16_16_16 = 31,
-        VFMT_UINT_32 = 32,
-        VFMT_UINT_32_32 = 33,
-        VFMT_UINT_32_32_32 = 34,
-        VFMT_UINT_32_32_32_32 = 35,
-        VFMT_INT_32 = 36,
-        VFMT_INT_32_32 = 37,
-        VFMT_INT_32_32_32 = 38,
-        VFMT_INT_32_32_32_32 = 39,
-        VFMT_UBYTE_8 = 40,
-        VFMT_UBYTE_8_8 = 41,
-        VFMT_UBYTE_8_8_8 = 42,
-        VFMT_UBYTE_8_8_8_8 = 43,
-        VFMT_NORM_UBYTE_8 = 44,
-        VFMT_NORM_UBYTE_8_8 = 45,
-        VFMT_NORM_UBYTE_8_8_8 = 46,
-        VFMT_NORM_UBYTE_8_8_8_8 = 47,
-        VFMT_BYTE_8 = 48,
-        VFMT_BYTE_8_8 = 49,
-        VFMT_BYTE_8_8_8 = 50,
-        VFMT_BYTE_8_8_8_8 = 51,
-        VFMT_NORM_BYTE_8 = 52,
-        VFMT_NORM_BYTE_8_8 = 53,
-        VFMT_NORM_BYTE_8_8_8 = 54,
-        VFMT_NORM_BYTE_8_8_8_8 = 55,
-        VFMT_UINT_10_10_10_2 = 60,
-        VFMT_NORM_UINT_10_10_10_2 = 61,
-        VFMT_INT_10_10_10_2 = 62,
-        VFMT_NORM_INT_10_10_10_2 = 63,
+        VFMT_32_FLOAT = 0,
+        VFMT_32_32_FLOAT = 1,
+        VFMT_32_32_32_FLOAT = 2,
+        VFMT_32_32_32_32_FLOAT = 3,
+        VFMT_16_FLOAT = 4,
+        VFMT_16_16_FLOAT = 5,
+        VFMT_16_16_16_FLOAT = 6,
+        VFMT_16_16_16_16_FLOAT = 7,
+        VFMT_32_FIXED = 8,
+        VFMT_32_32_FIXED = 9,
+        VFMT_32_32_32_FIXED = 10,
+        VFMT_32_32_32_32_FIXED = 11,
+        VFMT_16_SINT = 16,
+        VFMT_16_16_SINT = 17,
+        VFMT_16_16_16_SINT = 18,
+        VFMT_16_16_16_16_SINT = 19,
+        VFMT_16_UINT = 20,
+        VFMT_16_16_UINT = 21,
+        VFMT_16_16_16_UINT = 22,
+        VFMT_16_16_16_16_UINT = 23,
+        VFMT_16_SNORM = 24,
+        VFMT_16_16_SNORM = 25,
+        VFMT_16_16_16_SNORM = 26,
+        VFMT_16_16_16_16_SNORM = 27,
+        VFMT_16_UNORM = 28,
+        VFMT_16_16_UNORM = 29,
+        VFMT_16_16_16_UNORM = 30,
+        VFMT_16_16_16_16_UNORM = 31,
+        VFMT_32_UINT = 32,
+        VFMT_32_32_UINT = 33,
+        VFMT_32_32_32_UINT = 34,
+        VFMT_32_32_32_32_UINT = 35,
+        VFMT_32_SINT = 36,
+        VFMT_32_32_SINT = 37,
+        VFMT_32_32_32_SINT = 38,
+        VFMT_32_32_32_32_SINT = 39,
+        VFMT_8_UINT = 40,
+        VFMT_8_8_UINT = 41,
+        VFMT_8_8_8_UINT = 42,
+        VFMT_8_8_8_8_UINT = 43,
+        VFMT_8_UNORM = 44,
+        VFMT_8_8_UNORM = 45,
+        VFMT_8_8_8_UNORM = 46,
+        VFMT_8_8_8_8_UNORM = 47,
+        VFMT_8_SINT = 48,
+        VFMT_8_8_SINT = 49,
+        VFMT_8_8_8_SINT = 50,
+        VFMT_8_8_8_8_SINT = 51,
+        VFMT_8_SNORM = 52,
+        VFMT_8_8_SNORM = 53,
+        VFMT_8_8_8_SNORM = 54,
+        VFMT_8_8_8_8_SNORM = 55,
+        VFMT_10_10_10_2_UINT = 60,
+        VFMT_10_10_10_2_UNORM = 61,
+        VFMT_10_10_10_2_SINT = 62,
+        VFMT_10_10_10_2_SNORM = 63,
 };
 
 enum a3xx_tex_fmt {
-        TFMT_NORM_USHORT_565 = 4,
-        TFMT_NORM_USHORT_5551 = 6,
-        TFMT_NORM_USHORT_4444 = 7,
-        TFMT_NORM_USHORT_Z16 = 9,
-        TFMT_NORM_UINT_X8Z24 = 10,
-        TFMT_FLOAT_Z32 = 11,
-        TFMT_NORM_UINT_NV12_UV_TILED = 17,
-        TFMT_NORM_UINT_NV12_Y_TILED = 19,
-        TFMT_NORM_UINT_NV12_UV = 21,
-        TFMT_NORM_UINT_NV12_Y = 23,
-        TFMT_NORM_UINT_I420_Y = 24,
-        TFMT_NORM_UINT_I420_U = 26,
-        TFMT_NORM_UINT_I420_V = 27,
-        TFMT_NORM_UINT_2_10_10_10 = 41,
-        TFMT_FLOAT_9_9_9_E5 = 42,
-        TFMT_FLOAT_10_11_11 = 43,
-        TFMT_NORM_UINT_A8 = 44,
-        TFMT_NORM_UINT_L8_A8 = 47,
-        TFMT_NORM_UINT_8 = 48,
-        TFMT_NORM_UINT_8_8 = 49,
-        TFMT_NORM_UINT_8_8_8 = 50,
-        TFMT_NORM_UINT_8_8_8_8 = 51,
-        TFMT_NORM_SINT_8_8 = 53,
-        TFMT_NORM_SINT_8_8_8_8 = 55,
-        TFMT_UINT_8_8 = 57,
-        TFMT_UINT_8_8_8_8 = 59,
-        TFMT_SINT_8_8 = 61,
-        TFMT_SINT_8_8_8_8 = 63,
-        TFMT_FLOAT_16 = 64,
-        TFMT_FLOAT_16_16 = 65,
-        TFMT_FLOAT_16_16_16_16 = 67,
-        TFMT_UINT_16 = 68,
-        TFMT_UINT_16_16 = 69,
-        TFMT_UINT_16_16_16_16 = 71,
-        TFMT_SINT_16 = 72,
-        TFMT_SINT_16_16 = 73,
-        TFMT_SINT_16_16_16_16 = 75,
-        TFMT_FLOAT_32 = 84,
-        TFMT_FLOAT_32_32 = 85,
-        TFMT_FLOAT_32_32_32_32 = 87,
-        TFMT_UINT_32 = 88,
-        TFMT_UINT_32_32 = 89,
-        TFMT_UINT_32_32_32_32 = 91,
-        TFMT_SINT_32 = 92,
-        TFMT_SINT_32_32 = 93,
-        TFMT_SINT_32_32_32_32 = 95,
+        TFMT_5_6_5_UNORM = 4,
+        TFMT_5_5_5_1_UNORM = 5,
+        TFMT_4_4_4_4_UNORM = 7,
+        TFMT_Z16_UNORM = 9,
+        TFMT_X8Z24_UNORM = 10,
+        TFMT_Z32_FLOAT = 11,
+        TFMT_NV12_UV_TILED = 17,
+        TFMT_NV12_Y_TILED = 19,
+        TFMT_NV12_UV = 21,
+        TFMT_NV12_Y = 23,
+        TFMT_I420_Y = 24,
+        TFMT_I420_U = 26,
+        TFMT_I420_V = 27,
+        TFMT_DXT1 = 36,
+        TFMT_DXT3 = 37,
+        TFMT_DXT5 = 38,
+        TFMT_10_10_10_2_UNORM = 41,
+        TFMT_9_9_9_E5_FLOAT = 42,
+        TFMT_11_11_10_FLOAT = 43,
+        TFMT_A8_UNORM = 44,
+        TFMT_L8_A8_UNORM = 47,
+        TFMT_8_UNORM = 48,
+        TFMT_8_8_UNORM = 49,
+        TFMT_8_8_8_UNORM = 50,
+        TFMT_8_8_8_8_UNORM = 51,
+        TFMT_8_SNORM = 52,
+        TFMT_8_8_SNORM = 53,
+        TFMT_8_8_8_SNORM = 54,
+        TFMT_8_8_8_8_SNORM = 55,
+        TFMT_8_UINT = 56,
+        TFMT_8_8_UINT = 57,
+        TFMT_8_8_8_UINT = 58,
+        TFMT_8_8_8_8_UINT = 59,
+        TFMT_8_SINT = 60,
+        TFMT_8_8_SINT = 61,
+        TFMT_8_8_8_SINT = 62,
+        TFMT_8_8_8_8_SINT = 63,
+        TFMT_16_FLOAT = 64,
+        TFMT_16_16_FLOAT = 65,
+        TFMT_16_16_16_16_FLOAT = 67,
+        TFMT_16_UINT = 68,
+        TFMT_16_16_UINT = 69,
+        TFMT_16_16_16_16_UINT = 71,
+        TFMT_16_SINT = 72,
+        TFMT_16_16_SINT = 73,
+        TFMT_16_16_16_16_SINT = 75,
+        TFMT_16_UNORM = 76,
+        TFMT_16_16_UNORM = 77,
+        TFMT_16_16_16_16_UNORM = 79,
+        TFMT_16_SNORM = 80,
+        TFMT_16_16_SNORM = 81,
+        TFMT_16_16_16_16_SNORM = 83,
+        TFMT_32_FLOAT = 84,
+        TFMT_32_32_FLOAT = 85,
+        TFMT_32_32_32_32_FLOAT = 87,
+        TFMT_32_UINT = 88,
+        TFMT_32_32_UINT = 89,
+        TFMT_32_32_32_32_UINT = 91,
+        TFMT_32_SINT = 92,
+        TFMT_32_32_SINT = 93,
+        TFMT_32_32_32_32_SINT = 95,
+        TFMT_RGTC2_SNORM = 112,
+        TFMT_RGTC2_UNORM = 113,
+        TFMT_RGTC1_SNORM = 114,
+        TFMT_RGTC1_UNORM = 115,
 };
 
 enum a3xx_tex_fetchsize {
@@ -180,9 +199,11 @@ enum a3xx_color_fmt {
         RB_R4G4B4A4_UNORM = 3,
         RB_R8G8B8_UNORM = 4,
         RB_R8G8B8A8_UNORM = 8,
+        RB_R8G8B8A8_SNORM = 9,
         RB_R8G8B8A8_UINT = 10,
         RB_R8G8B8A8_SINT = 11,
         RB_R8G8_UNORM = 12,
+        RB_R8G8_SNORM = 13,
         RB_R8_UINT = 14,
         RB_R8_SINT = 15,
         RB_R10G10B10A2_UNORM = 16,
@@ -258,6 +279,14 @@ enum a3xx_tex_clamp {
         A3XX_TEX_MIRROR_CLAMP = 4,
 };
 
+enum a3xx_tex_aniso {
+        A3XX_TEX_ANISO_1 = 0,
+        A3XX_TEX_ANISO_2 = 1,
+        A3XX_TEX_ANISO_4 = 2,
+        A3XX_TEX_ANISO_8 = 3,
+        A3XX_TEX_ANISO_16 = 4,
+};
+
 enum a3xx_tex_swiz {
         A3XX_TEX_X = 0,
         A3XX_TEX_Y = 1,
@@ -1563,12 +1592,13 @@ static inline uint32_t A3XX_VFD_FETCH_INSTR_0_FETCHSIZE(uint32_t val)
 {
         return ((val) << A3XX_VFD_FETCH_INSTR_0_FETCHSIZE__SHIFT) & A3XX_VFD_FETCH_INSTR_0_FETCHSIZE__MASK;
 }
-#define A3XX_VFD_FETCH_INSTR_0_BUFSTRIDE__MASK                  0x0001ff80
+#define A3XX_VFD_FETCH_INSTR_0_BUFSTRIDE__MASK                  0x0000ff80
 #define A3XX_VFD_FETCH_INSTR_0_BUFSTRIDE__SHIFT                 7
 static inline uint32_t A3XX_VFD_FETCH_INSTR_0_BUFSTRIDE(uint32_t val)
 {
         return ((val) << A3XX_VFD_FETCH_INSTR_0_BUFSTRIDE__SHIFT) & A3XX_VFD_FETCH_INSTR_0_BUFSTRIDE__MASK;
 }
+#define A3XX_VFD_FETCH_INSTR_0_INSTANCED                        0x00010000
 #define A3XX_VFD_FETCH_INSTR_0_SWITCHNEXT                       0x00020000
 #define A3XX_VFD_FETCH_INSTR_0_INDEXCODE__MASK                  0x00fc0000
 #define A3XX_VFD_FETCH_INSTR_0_INDEXCODE__SHIFT                 18
@@ -2509,6 +2539,12 @@ static inline uint32_t A3XX_TEX_SAMP_0_WRAP_R(enum a3xx_tex_clamp val)
 {
         return ((val) << A3XX_TEX_SAMP_0_WRAP_R__SHIFT) & A3XX_TEX_SAMP_0_WRAP_R__MASK;
 }
+#define A3XX_TEX_SAMP_0_ANISO__MASK                             0x00038000
+#define A3XX_TEX_SAMP_0_ANISO__SHIFT                            15
+static inline uint32_t A3XX_TEX_SAMP_0_ANISO(enum a3xx_tex_aniso val)
+{
+        return ((val) << A3XX_TEX_SAMP_0_ANISO__SHIFT) & A3XX_TEX_SAMP_0_ANISO__MASK;
+}
 #define A3XX_TEX_SAMP_0_COMPARE_FUNC__MASK                      0x00700000
 #define A3XX_TEX_SAMP_0_COMPARE_FUNC__SHIFT                     20
 static inline uint32_t A3XX_TEX_SAMP_0_COMPARE_FUNC(enum adreno_compare_func val)
diff --git a/drivers/gpu/drm/msm/adreno/a4xx.xml.h b/drivers/gpu/drm/msm/adreno/a4xx.xml.h
index 5a24c416d2dd..755723fd8ba5 100644
--- a/drivers/gpu/drm/msm/adreno/a4xx.xml.h
+++ b/drivers/gpu/drm/msm/adreno/a4xx.xml.h
@@ -12,9 +12,9 @@ The rules-ng-ng source files this header was generated from are:
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml  (   1453 bytes, from 2013-03-31 16:51:27)
 - /home/robclark/src/freedreno/envytools/rnndb/adreno/a2xx.xml          (  32901 bytes, from 2014-06-02 15:21:30)
 - /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_common.xml (  10551 bytes, from 2014-11-13 22:44:30)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_pm4.xml    (  15053 bytes, from 2014-11-09 15:45:47)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/a3xx.xml          (  63169 bytes, from 2014-11-13 22:44:18)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/a4xx.xml          (  49097 bytes, from 2014-11-14 15:38:00)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_pm4.xml    (  15085 bytes, from 2014-12-20 21:49:41)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/a3xx.xml          (  64344 bytes, from 2014-12-12 20:22:26)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/a4xx.xml          (  51069 bytes, from 2014-12-21 15:51:54)
 
 Copyright (C) 2013-2014 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
@@ -63,72 +63,82 @@ enum a4xx_rb_blend_opcode {
 };
 
 enum a4xx_vtx_fmt {
-        VFMT4_FLOAT_32 = 1,
-        VFMT4_FLOAT_32_32 = 2,
-        VFMT4_FLOAT_32_32_32 = 3,
-        VFMT4_FLOAT_32_32_32_32 = 4,
-        VFMT4_FLOAT_16 = 5,
-        VFMT4_FLOAT_16_16 = 6,
-        VFMT4_FLOAT_16_16_16 = 7,
-        VFMT4_FLOAT_16_16_16_16 = 8,
-        VFMT4_FIXED_32 = 9,
-        VFMT4_FIXED_32_32 = 10,
-        VFMT4_FIXED_32_32_32 = 11,
-        VFMT4_FIXED_32_32_32_32 = 12,
-        VFMT4_SHORT_16 = 16,
-        VFMT4_SHORT_16_16 = 17,
-        VFMT4_SHORT_16_16_16 = 18,
-        VFMT4_SHORT_16_16_16_16 = 19,
-        VFMT4_USHORT_16 = 20,
-        VFMT4_USHORT_16_16 = 21,
-        VFMT4_USHORT_16_16_16 = 22,
-        VFMT4_USHORT_16_16_16_16 = 23,
-        VFMT4_NORM_SHORT_16 = 24,
-        VFMT4_NORM_SHORT_16_16 = 25,
-        VFMT4_NORM_SHORT_16_16_16 = 26,
-        VFMT4_NORM_SHORT_16_16_16_16 = 27,
-        VFMT4_NORM_USHORT_16 = 28,
-        VFMT4_NORM_USHORT_16_16 = 29,
-        VFMT4_NORM_USHORT_16_16_16 = 30,
-        VFMT4_NORM_USHORT_16_16_16_16 = 31,
-        VFMT4_UBYTE_8 = 40,
-        VFMT4_UBYTE_8_8 = 41,
-        VFMT4_UBYTE_8_8_8 = 42,
-        VFMT4_UBYTE_8_8_8_8 = 43,
-        VFMT4_NORM_UBYTE_8 = 44,
-        VFMT4_NORM_UBYTE_8_8 = 45,
-        VFMT4_NORM_UBYTE_8_8_8 = 46,
-        VFMT4_NORM_UBYTE_8_8_8_8 = 47,
-        VFMT4_BYTE_8 = 48,
-        VFMT4_BYTE_8_8 = 49,
-        VFMT4_BYTE_8_8_8 = 50,
-        VFMT4_BYTE_8_8_8_8 = 51,
-        VFMT4_NORM_BYTE_8 = 52,
-        VFMT4_NORM_BYTE_8_8 = 53,
-        VFMT4_NORM_BYTE_8_8_8 = 54,
-        VFMT4_NORM_BYTE_8_8_8_8 = 55,
-        VFMT4_UINT_10_10_10_2 = 60,
-        VFMT4_NORM_UINT_10_10_10_2 = 61,
-        VFMT4_INT_10_10_10_2 = 62,
-        VFMT4_NORM_INT_10_10_10_2 = 63,
+        VFMT4_32_FLOAT = 1,
+        VFMT4_32_32_FLOAT = 2,
+        VFMT4_32_32_32_FLOAT = 3,
+        VFMT4_32_32_32_32_FLOAT = 4,
+        VFMT4_16_FLOAT = 5,
+        VFMT4_16_16_FLOAT = 6,
+        VFMT4_16_16_16_FLOAT = 7,
+        VFMT4_16_16_16_16_FLOAT = 8,
+        VFMT4_32_FIXED = 9,
+        VFMT4_32_32_FIXED = 10,
+        VFMT4_32_32_32_FIXED = 11,
+        VFMT4_32_32_32_32_FIXED = 12,
+        VFMT4_16_SINT = 16,
+        VFMT4_16_16_SINT = 17,
+        VFMT4_16_16_16_SINT = 18,
+        VFMT4_16_16_16_16_SINT = 19,
+        VFMT4_16_UINT = 20,
+        VFMT4_16_16_UINT = 21,
+        VFMT4_16_16_16_UINT = 22,
+        VFMT4_16_16_16_16_UINT = 23,
+        VFMT4_16_SNORM = 24,
+        VFMT4_16_16_SNORM = 25,
+        VFMT4_16_16_16_SNORM = 26,
+        VFMT4_16_16_16_16_SNORM = 27,
+        VFMT4_16_UNORM = 28,
+        VFMT4_16_16_UNORM = 29,
+        VFMT4_16_16_16_UNORM = 30,
+        VFMT4_16_16_16_16_UNORM = 31,
+        VFMT4_32_32_SINT = 37,
+        VFMT4_8_UINT = 40,
+        VFMT4_8_8_UINT = 41,
+        VFMT4_8_8_8_UINT = 42,
+        VFMT4_8_8_8_8_UINT = 43,
+        VFMT4_8_UNORM = 44,
+        VFMT4_8_8_UNORM = 45,
+        VFMT4_8_8_8_UNORM = 46,
+        VFMT4_8_8_8_8_UNORM = 47,
+        VFMT4_8_SINT = 48,
+        VFMT4_8_8_SINT = 49,
+        VFMT4_8_8_8_SINT = 50,
+        VFMT4_8_8_8_8_SINT = 51,
+        VFMT4_8_SNORM = 52,
+        VFMT4_8_8_SNORM = 53,
+        VFMT4_8_8_8_SNORM = 54,
+        VFMT4_8_8_8_8_SNORM = 55,
+        VFMT4_10_10_10_2_UINT = 60,
+        VFMT4_10_10_10_2_UNORM = 61,
+        VFMT4_10_10_10_2_SINT = 62,
+        VFMT4_10_10_10_2_SNORM = 63,
 };
 
 enum a4xx_tex_fmt {
-        TFMT4_NORM_USHORT_565 = 11,
-        TFMT4_NORM_USHORT_5551 = 10,
-        TFMT4_NORM_USHORT_4444 = 8,
-        TFMT4_NORM_UINT_X8Z24 = 71,
-        TFMT4_NORM_UINT_2_10_10_10 = 33,
-        TFMT4_NORM_UINT_A8 = 3,
-        TFMT4_NORM_UINT_L8_A8 = 13,
-        TFMT4_NORM_UINT_8 = 4,
-        TFMT4_NORM_UINT_8_8_8_8 = 28,
-        TFMT4_FLOAT_16 = 20,
-        TFMT4_FLOAT_16_16 = 40,
-        TFMT4_FLOAT_16_16_16_16 = 53,
-        TFMT4_FLOAT_32 = 43,
-        TFMT4_FLOAT_32_32 = 56,
-        TFMT4_FLOAT_32_32_32_32 = 63,
+        TFMT4_5_6_5_UNORM = 11,
+        TFMT4_5_5_5_1_UNORM = 10,
+        TFMT4_4_4_4_4_UNORM = 8,
+        TFMT4_X8Z24_UNORM = 71,
+        TFMT4_10_10_10_2_UNORM = 33,
+        TFMT4_A8_UNORM = 3,
+        TFMT4_L8_A8_UNORM = 13,
+        TFMT4_8_UNORM = 4,
+        TFMT4_8_8_UNORM = 14,
+        TFMT4_8_8_8_8_UNORM = 28,
+        TFMT4_16_FLOAT = 20,
+        TFMT4_16_16_FLOAT = 40,
+        TFMT4_16_16_16_16_FLOAT = 53,
+        TFMT4_32_FLOAT = 43,
+        TFMT4_32_32_FLOAT = 56,
+        TFMT4_32_32_32_32_FLOAT = 63,
+};
+
+enum a4xx_tex_fetchsize {
+        TFETCH4_1_BYTE = 0,
+        TFETCH4_2_BYTE = 1,
+        TFETCH4_4_BYTE = 2,
+        TFETCH4_8_BYTE = 3,
+        TFETCH4_16_BYTE = 4,
 };
 
 enum a4xx_depth_format {
@@ -264,14 +274,19 @@ static inline uint32_t A4XX_RB_MSAA_CONTROL_SAMPLES(uint32_t val)
         return ((val) << A4XX_RB_MSAA_CONTROL_SAMPLES__SHIFT) & A4XX_RB_MSAA_CONTROL_SAMPLES__MASK;
 }
 
-#define REG_A4XX_RB_MSAA_CONTROL2                               0x000020a3
-#define A4XX_RB_MSAA_CONTROL2_MSAA_SAMPLES__MASK                0x00000380
-#define A4XX_RB_MSAA_CONTROL2_MSAA_SAMPLES__SHIFT               7
-static inline uint32_t A4XX_RB_MSAA_CONTROL2_MSAA_SAMPLES(uint32_t val)
+#define REG_A4XX_RB_RENDER_CONTROL2                             0x000020a3
+#define A4XX_RB_RENDER_CONTROL2_XCOORD                          0x00000001
+#define A4XX_RB_RENDER_CONTROL2_YCOORD                          0x00000002
+#define A4XX_RB_RENDER_CONTROL2_ZCOORD                          0x00000004
+#define A4XX_RB_RENDER_CONTROL2_WCOORD                          0x00000008
+#define A4XX_RB_RENDER_CONTROL2_FACENESS                        0x00000020
+#define A4XX_RB_RENDER_CONTROL2_MSAA_SAMPLES__MASK              0x00000380
+#define A4XX_RB_RENDER_CONTROL2_MSAA_SAMPLES__SHIFT             7
+static inline uint32_t A4XX_RB_RENDER_CONTROL2_MSAA_SAMPLES(uint32_t val)
 {
-        return ((val) << A4XX_RB_MSAA_CONTROL2_MSAA_SAMPLES__SHIFT) & A4XX_RB_MSAA_CONTROL2_MSAA_SAMPLES__MASK;
+        return ((val) << A4XX_RB_RENDER_CONTROL2_MSAA_SAMPLES__SHIFT) & A4XX_RB_RENDER_CONTROL2_MSAA_SAMPLES__MASK;
 }
-#define A4XX_RB_MSAA_CONTROL2_VARYING                           0x00001000
+#define A4XX_RB_RENDER_CONTROL2_VARYING                         0x00001000
 
 static inline uint32_t REG_A4XX_RB_MRT(uint32_t i0) { return 0x000020a4 + 0x5*i0; }
 
@@ -362,7 +377,69 @@ static inline uint32_t A4XX_RB_MRT_BLEND_CONTROL_ALPHA_DEST_FACTOR(enum adreno_r
         return ((val) << A4XX_RB_MRT_BLEND_CONTROL_ALPHA_DEST_FACTOR__SHIFT) & A4XX_RB_MRT_BLEND_CONTROL_ALPHA_DEST_FACTOR__MASK;
 }
 
+#define REG_A4XX_RB_BLEND_RED                                   0x000020f3
+#define A4XX_RB_BLEND_RED_UINT__MASK                            0x00007fff
+#define A4XX_RB_BLEND_RED_UINT__SHIFT                           0
+static inline uint32_t A4XX_RB_BLEND_RED_UINT(uint32_t val)
+{
+        return ((val) << A4XX_RB_BLEND_RED_UINT__SHIFT) & A4XX_RB_BLEND_RED_UINT__MASK;
+}
+#define A4XX_RB_BLEND_RED_FLOAT__MASK                           0xffff0000
+#define A4XX_RB_BLEND_RED_FLOAT__SHIFT                          16
+static inline uint32_t A4XX_RB_BLEND_RED_FLOAT(float val)
+{
+        return ((util_float_to_half(val)) << A4XX_RB_BLEND_RED_FLOAT__SHIFT) & A4XX_RB_BLEND_RED_FLOAT__MASK;
+}
+
+#define REG_A4XX_RB_BLEND_GREEN                                 0x000020f4
+#define A4XX_RB_BLEND_GREEN_UINT__MASK                          0x00007fff
+#define A4XX_RB_BLEND_GREEN_UINT__SHIFT                         0
+static inline uint32_t A4XX_RB_BLEND_GREEN_UINT(uint32_t val)
+{
+        return ((val) << A4XX_RB_BLEND_GREEN_UINT__SHIFT) & A4XX_RB_BLEND_GREEN_UINT__MASK;
+}
+#define A4XX_RB_BLEND_GREEN_FLOAT__MASK                         0xffff0000
+#define A4XX_RB_BLEND_GREEN_FLOAT__SHIFT                        16
+static inline uint32_t A4XX_RB_BLEND_GREEN_FLOAT(float val)
+{
+        return ((util_float_to_half(val)) << A4XX_RB_BLEND_GREEN_FLOAT__SHIFT) & A4XX_RB_BLEND_GREEN_FLOAT__MASK;
+}
+
+#define REG_A4XX_RB_BLEND_BLUE                                  0x000020f5
+#define A4XX_RB_BLEND_BLUE_UINT__MASK                           0x00007fff
+#define A4XX_RB_BLEND_BLUE_UINT__SHIFT                          0
+static inline uint32_t A4XX_RB_BLEND_BLUE_UINT(uint32_t val)
+{
+        return ((val) << A4XX_RB_BLEND_BLUE_UINT__SHIFT) & A4XX_RB_BLEND_BLUE_UINT__MASK;
+}
+#define A4XX_RB_BLEND_BLUE_FLOAT__MASK                          0xffff0000
+#define A4XX_RB_BLEND_BLUE_FLOAT__SHIFT                         16
+static inline uint32_t A4XX_RB_BLEND_BLUE_FLOAT(float val)
+{
+        return ((util_float_to_half(val)) << A4XX_RB_BLEND_BLUE_FLOAT__SHIFT) & A4XX_RB_BLEND_BLUE_FLOAT__MASK;
+}
+
+#define REG_A4XX_RB_BLEND_ALPHA                                 0x000020f6
+#define A4XX_RB_BLEND_ALPHA_UINT__MASK                          0x00007fff
+#define A4XX_RB_BLEND_ALPHA_UINT__SHIFT                         0
+static inline uint32_t A4XX_RB_BLEND_ALPHA_UINT(uint32_t val)
+{
+        return ((val) << A4XX_RB_BLEND_ALPHA_UINT__SHIFT) & A4XX_RB_BLEND_ALPHA_UINT__MASK;
+}
+#define A4XX_RB_BLEND_ALPHA_FLOAT__MASK                         0xffff0000
+#define A4XX_RB_BLEND_ALPHA_FLOAT__SHIFT                        16
+static inline uint32_t A4XX_RB_BLEND_ALPHA_FLOAT(float val)
+{
+        return ((util_float_to_half(val)) << A4XX_RB_BLEND_ALPHA_FLOAT__SHIFT) & A4XX_RB_BLEND_ALPHA_FLOAT__MASK;
+}
+
 #define REG_A4XX_RB_ALPHA_CONTROL                               0x000020f8
+#define A4XX_RB_ALPHA_CONTROL_ALPHA_REF__MASK                   0x000000ff
+#define A4XX_RB_ALPHA_CONTROL_ALPHA_REF__SHIFT                  0
+static inline uint32_t A4XX_RB_ALPHA_CONTROL_ALPHA_REF(uint32_t val)
+{
+        return ((val) << A4XX_RB_ALPHA_CONTROL_ALPHA_REF__SHIFT) & A4XX_RB_ALPHA_CONTROL_ALPHA_REF__MASK;
+}
 #define A4XX_RB_ALPHA_CONTROL_ALPHA_TEST                        0x00000100
 #define A4XX_RB_ALPHA_CONTROL_ALPHA_TEST_FUNC__MASK             0x00000e00
 #define A4XX_RB_ALPHA_CONTROL_ALPHA_TEST_FUNC__SHIFT            9
@@ -372,7 +449,7 @@ static inline uint32_t A4XX_RB_ALPHA_CONTROL_ALPHA_TEST_FUNC(enum adreno_compare
 }
 
 #define REG_A4XX_RB_FS_OUTPUT                                   0x000020f9
-#define A4XX_RB_FS_OUTPUT_ENABLE_COLOR_PIPE                     0x00000001
+#define A4XX_RB_FS_OUTPUT_ENABLE_BLEND                          0x00000001
 #define A4XX_RB_FS_OUTPUT_FAST_CLEAR                            0x00000100
 #define A4XX_RB_FS_OUTPUT_SAMPLE_MASK__MASK                     0xffff0000
 #define A4XX_RB_FS_OUTPUT_SAMPLE_MASK__SHIFT                    16
@@ -416,11 +493,11 @@ static inline uint32_t A4XX_RB_COPY_CONTROL_GMEM_BASE(uint32_t val)
 }
 
 #define REG_A4XX_RB_COPY_DEST_BASE                              0x000020fd
-#define A4XX_RB_COPY_DEST_BASE_BASE__MASK                       0xfffffff0
-#define A4XX_RB_COPY_DEST_BASE_BASE__SHIFT                      4
+#define A4XX_RB_COPY_DEST_BASE_BASE__MASK                       0xffffffe0
+#define A4XX_RB_COPY_DEST_BASE_BASE__SHIFT                      5
 static inline uint32_t A4XX_RB_COPY_DEST_BASE_BASE(uint32_t val)
 {
-        return ((val >> 4) << A4XX_RB_COPY_DEST_BASE_BASE__SHIFT) & A4XX_RB_COPY_DEST_BASE_BASE__MASK;
+        return ((val >> 5) << A4XX_RB_COPY_DEST_BASE_BASE__SHIFT) & A4XX_RB_COPY_DEST_BASE_BASE__MASK;
 }
 
 #define REG_A4XX_RB_COPY_DEST_PITCH                             0x000020fe
@@ -508,7 +585,7 @@ static inline uint32_t A4XX_RB_DEPTH_INFO_DEPTH_BASE(uint32_t val)
 #define A4XX_RB_DEPTH_PITCH__SHIFT                              0
 static inline uint32_t A4XX_RB_DEPTH_PITCH(uint32_t val)
 {
-        return ((val >> 4) << A4XX_RB_DEPTH_PITCH__SHIFT) & A4XX_RB_DEPTH_PITCH__MASK;
+        return ((val >> 5) << A4XX_RB_DEPTH_PITCH__SHIFT) & A4XX_RB_DEPTH_PITCH__MASK;
 }
 
 #define REG_A4XX_RB_DEPTH_PITCH2                                0x00002105
@@ -516,7 +593,7 @@ static inline uint32_t A4XX_RB_DEPTH_PITCH(uint32_t val)
 #define A4XX_RB_DEPTH_PITCH2__SHIFT                             0
 static inline uint32_t A4XX_RB_DEPTH_PITCH2(uint32_t val)
 {
-        return ((val >> 4) << A4XX_RB_DEPTH_PITCH2__SHIFT) & A4XX_RB_DEPTH_PITCH2__MASK;
+        return ((val >> 5) << A4XX_RB_DEPTH_PITCH2__SHIFT) & A4XX_RB_DEPTH_PITCH2__MASK;
 }
 
 #define REG_A4XX_RB_STENCIL_CONTROL                             0x00002106
@@ -630,7 +707,11 @@ static inline uint32_t A4XX_RB_BIN_OFFSET_Y(uint32_t val)
         return ((val) << A4XX_RB_BIN_OFFSET_Y__SHIFT) & A4XX_RB_BIN_OFFSET_Y__MASK;
 }
 
-#define REG_A4XX_RB_VPORT_Z_CLAMP_MAX_15                        0x0000213f
+static inline uint32_t REG_A4XX_RB_VPORT_Z_CLAMP(uint32_t i0) { return 0x00002120 + 0x2*i0; }
+
+static inline uint32_t REG_A4XX_RB_VPORT_Z_CLAMP_MIN(uint32_t i0) { return 0x00002120 + 0x2*i0; }
+
+static inline uint32_t REG_A4XX_RB_VPORT_Z_CLAMP_MAX(uint32_t i0) { return 0x00002121 + 0x2*i0; }
 
 #define REG_A4XX_RBBM_HW_VERSION                                0x00000000
 
@@ -1121,7 +1202,9 @@ static inline uint32_t A4XX_SP_FS_CTRL_REG1_CONSTLENGTH(uint32_t val)
 {
         return ((val) << A4XX_SP_FS_CTRL_REG1_CONSTLENGTH__SHIFT) & A4XX_SP_FS_CTRL_REG1_CONSTLENGTH__MASK;
 }
+#define A4XX_SP_FS_CTRL_REG1_FACENESS                           0x00080000
 #define A4XX_SP_FS_CTRL_REG1_VARYING                            0x00100000
+#define A4XX_SP_FS_CTRL_REG1_FRAGCOORD                          0x00200000
 
 #define REG_A4XX_SP_FS_OBJ_OFFSET_REG                           0x000022ea
 #define A4XX_SP_FS_OBJ_OFFSET_REG_CONSTOBJECTOFFSET__MASK       0x01ff0000
@@ -1384,6 +1467,12 @@ static inline uint32_t A4XX_VFD_CONTROL_1_REGID4INST(uint32_t val)
 #define REG_A4XX_VFD_CONTROL_2                                  0x00002202
 
 #define REG_A4XX_VFD_CONTROL_3                                  0x00002203
+#define A4XX_VFD_CONTROL_3_REGID_VTXCNT__MASK                   0x0000ff00
+#define A4XX_VFD_CONTROL_3_REGID_VTXCNT__SHIFT                  8
+static inline uint32_t A4XX_VFD_CONTROL_3_REGID_VTXCNT(uint32_t val)
+{
+        return ((val) << A4XX_VFD_CONTROL_3_REGID_VTXCNT__SHIFT) & A4XX_VFD_CONTROL_3_REGID_VTXCNT__MASK;
+}
 
 #define REG_A4XX_VFD_CONTROL_4                                  0x00002204
 
@@ -1405,12 +1494,7 @@ static inline uint32_t A4XX_VFD_FETCH_INSTR_0_BUFSTRIDE(uint32_t val)
         return ((val) << A4XX_VFD_FETCH_INSTR_0_BUFSTRIDE__SHIFT) & A4XX_VFD_FETCH_INSTR_0_BUFSTRIDE__MASK;
 }
 #define A4XX_VFD_FETCH_INSTR_0_SWITCHNEXT                       0x00080000
-#define A4XX_VFD_FETCH_INSTR_0_STEPRATE__MASK                   0xff000000
-#define A4XX_VFD_FETCH_INSTR_0_STEPRATE__SHIFT                  24
-static inline uint32_t A4XX_VFD_FETCH_INSTR_0_STEPRATE(uint32_t val)
-{
-        return ((val) << A4XX_VFD_FETCH_INSTR_0_STEPRATE__SHIFT) & A4XX_VFD_FETCH_INSTR_0_STEPRATE__MASK;
-}
+#define A4XX_VFD_FETCH_INSTR_0_INSTANCED                        0x00100000
 
 static inline uint32_t REG_A4XX_VFD_FETCH_INSTR_1(uint32_t i0) { return 0x0000220b + 0x4*i0; }
 
@@ -1423,6 +1507,12 @@ static inline uint32_t A4XX_VFD_FETCH_INSTR_2_SIZE(uint32_t val)
 }
 
 static inline uint32_t REG_A4XX_VFD_FETCH_INSTR_3(uint32_t i0) { return 0x0000220d + 0x4*i0; }
+#define A4XX_VFD_FETCH_INSTR_3_STEPRATE__MASK                   0x000001ff
+#define A4XX_VFD_FETCH_INSTR_3_STEPRATE__SHIFT                  0
+static inline uint32_t A4XX_VFD_FETCH_INSTR_3_STEPRATE(uint32_t val)
+{
+        return ((val) << A4XX_VFD_FETCH_INSTR_3_STEPRATE__SHIFT) & A4XX_VFD_FETCH_INSTR_3_STEPRATE__MASK;
+}
 
 static inline uint32_t REG_A4XX_VFD_DECODE(uint32_t i0) { return 0x0000228a + 0x1*i0; }
 
@@ -1446,6 +1536,7 @@ static inline uint32_t A4XX_VFD_DECODE_INSTR_REGID(uint32_t val)
 {
         return ((val) << A4XX_VFD_DECODE_INSTR_REGID__SHIFT) & A4XX_VFD_DECODE_INSTR_REGID__MASK;
 }
+#define A4XX_VFD_DECODE_INSTR_INT                               0x00100000
 #define A4XX_VFD_DECODE_INSTR_SWAP__MASK                        0x00c00000
 #define A4XX_VFD_DECODE_INSTR_SWAP__SHIFT                       22
 static inline uint32_t A4XX_VFD_DECODE_INSTR_SWAP(enum a3xx_color_swap val)
@@ -1585,7 +1676,47 @@ static inline uint32_t A4XX_GRAS_SU_POLY_OFFSET_OFFSET(float val)
         return ((fui(val)) << A4XX_GRAS_SU_POLY_OFFSET_OFFSET__SHIFT) & A4XX_GRAS_SU_POLY_OFFSET_OFFSET__MASK;
 }
 
-#define REG_A4XX_GRAS_SC_EXTENT_WINDOW_TL                       0x0000209f
+#define REG_A4XX_GRAS_DEPTH_CONTROL                             0x00002077
+#define A4XX_GRAS_DEPTH_CONTROL_FORMAT__MASK                    0x00000003
+#define A4XX_GRAS_DEPTH_CONTROL_FORMAT__SHIFT                   0
+static inline uint32_t A4XX_GRAS_DEPTH_CONTROL_FORMAT(enum a4xx_depth_format val)
+{
+        return ((val) << A4XX_GRAS_DEPTH_CONTROL_FORMAT__SHIFT) & A4XX_GRAS_DEPTH_CONTROL_FORMAT__MASK;
+}
+
+#define REG_A4XX_GRAS_SU_MODE_CONTROL                           0x00002078
+#define A4XX_GRAS_SU_MODE_CONTROL_CULL_FRONT                    0x00000001
+#define A4XX_GRAS_SU_MODE_CONTROL_CULL_BACK                     0x00000002
+#define A4XX_GRAS_SU_MODE_CONTROL_FRONT_CW                      0x00000004
+#define A4XX_GRAS_SU_MODE_CONTROL_LINEHALFWIDTH__MASK           0x000007f8
+#define A4XX_GRAS_SU_MODE_CONTROL_LINEHALFWIDTH__SHIFT          3
+static inline uint32_t A4XX_GRAS_SU_MODE_CONTROL_LINEHALFWIDTH(float val)
+{
+        return ((((int32_t)(val * 4.0))) << A4XX_GRAS_SU_MODE_CONTROL_LINEHALFWIDTH__SHIFT) & A4XX_GRAS_SU_MODE_CONTROL_LINEHALFWIDTH__MASK;
+}
+#define A4XX_GRAS_SU_MODE_CONTROL_POLY_OFFSET                   0x00000800
+#define A4XX_GRAS_SU_MODE_CONTROL_RENDERING_PASS                0x00100000
+
+#define REG_A4XX_GRAS_SC_CONTROL                                0x0000207b
+#define A4XX_GRAS_SC_CONTROL_RENDER_MODE__MASK                  0x0000000c
+#define A4XX_GRAS_SC_CONTROL_RENDER_MODE__SHIFT                 2
+static inline uint32_t A4XX_GRAS_SC_CONTROL_RENDER_MODE(enum a3xx_render_mode val)
+{
+        return ((val) << A4XX_GRAS_SC_CONTROL_RENDER_MODE__SHIFT) & A4XX_GRAS_SC_CONTROL_RENDER_MODE__MASK;
+}
+#define A4XX_GRAS_SC_CONTROL_MSAA_SAMPLES__MASK                 0x00000380
+#define A4XX_GRAS_SC_CONTROL_MSAA_SAMPLES__SHIFT                7
+static inline uint32_t A4XX_GRAS_SC_CONTROL_MSAA_SAMPLES(uint32_t val)
+{
+        return ((val) << A4XX_GRAS_SC_CONTROL_MSAA_SAMPLES__SHIFT) & A4XX_GRAS_SC_CONTROL_MSAA_SAMPLES__MASK;
+}
+#define A4XX_GRAS_SC_CONTROL_MSAA_DISABLE                       0x00000800
+#define A4XX_GRAS_SC_CONTROL_RASTER_MODE__MASK                  0x0000f000
+#define A4XX_GRAS_SC_CONTROL_RASTER_MODE__SHIFT                 12
+static inline uint32_t A4XX_GRAS_SC_CONTROL_RASTER_MODE(uint32_t val)
+{
+        return ((val) << A4XX_GRAS_SC_CONTROL_RASTER_MODE__SHIFT) & A4XX_GRAS_SC_CONTROL_RASTER_MODE__MASK;
+}
 
 #define REG_A4XX_GRAS_SC_SCREEN_SCISSOR_TL                      0x0000207c
 #define A4XX_GRAS_SC_SCREEN_SCISSOR_TL_WINDOW_OFFSET_DISABLE    0x80000000
@@ -1647,46 +1778,34 @@ static inline uint32_t A4XX_GRAS_SC_WINDOW_SCISSOR_TL_Y(uint32_t val)
         return ((val) << A4XX_GRAS_SC_WINDOW_SCISSOR_TL_Y__SHIFT) & A4XX_GRAS_SC_WINDOW_SCISSOR_TL_Y__MASK;
 }
 
-#define REG_A4XX_GRAS_DEPTH_CONTROL                             0x00002077
-#define A4XX_GRAS_DEPTH_CONTROL_FORMAT__MASK                    0x00000003
-#define A4XX_GRAS_DEPTH_CONTROL_FORMAT__SHIFT                   0
-static inline uint32_t A4XX_GRAS_DEPTH_CONTROL_FORMAT(enum a4xx_depth_format val)
+#define REG_A4XX_GRAS_SC_EXTENT_WINDOW_BR                       0x0000209e
+#define A4XX_GRAS_SC_EXTENT_WINDOW_BR_WINDOW_OFFSET_DISABLE     0x80000000
+#define A4XX_GRAS_SC_EXTENT_WINDOW_BR_X__MASK                   0x00007fff
+#define A4XX_GRAS_SC_EXTENT_WINDOW_BR_X__SHIFT                  0
+static inline uint32_t A4XX_GRAS_SC_EXTENT_WINDOW_BR_X(uint32_t val)
 {
-        return ((val) << A4XX_GRAS_DEPTH_CONTROL_FORMAT__SHIFT) & A4XX_GRAS_DEPTH_CONTROL_FORMAT__MASK;
+        return ((val) << A4XX_GRAS_SC_EXTENT_WINDOW_BR_X__SHIFT) & A4XX_GRAS_SC_EXTENT_WINDOW_BR_X__MASK;
 }
-
-#define REG_A4XX_GRAS_SU_MODE_CONTROL                           0x00002078
-#define A4XX_GRAS_SU_MODE_CONTROL_CULL_FRONT                    0x00000001
-#define A4XX_GRAS_SU_MODE_CONTROL_CULL_BACK                     0x00000002
-#define A4XX_GRAS_SU_MODE_CONTROL_FRONT_CW                      0x00000004
-#define A4XX_GRAS_SU_MODE_CONTROL_LINEHALFWIDTH__MASK           0x000007f8
-#define A4XX_GRAS_SU_MODE_CONTROL_LINEHALFWIDTH__SHIFT          3
-static inline uint32_t A4XX_GRAS_SU_MODE_CONTROL_LINEHALFWIDTH(float val)
+#define A4XX_GRAS_SC_EXTENT_WINDOW_BR_Y__MASK                   0x7fff0000
+#define A4XX_GRAS_SC_EXTENT_WINDOW_BR_Y__SHIFT                  16
+static inline uint32_t A4XX_GRAS_SC_EXTENT_WINDOW_BR_Y(uint32_t val)
 {
-        return ((((int32_t)(val * 4.0))) << A4XX_GRAS_SU_MODE_CONTROL_LINEHALFWIDTH__SHIFT) & A4XX_GRAS_SU_MODE_CONTROL_LINEHALFWIDTH__MASK;
+        return ((val) << A4XX_GRAS_SC_EXTENT_WINDOW_BR_Y__SHIFT) & A4XX_GRAS_SC_EXTENT_WINDOW_BR_Y__MASK;
 }
-#define A4XX_GRAS_SU_MODE_CONTROL_POLY_OFFSET                   0x00000800
-#define A4XX_GRAS_SU_MODE_CONTROL_RENDERING_PASS                0x00100000
 
-#define REG_A4XX_GRAS_SC_CONTROL                                0x0000207b
-#define A4XX_GRAS_SC_CONTROL_RENDER_MODE__MASK                  0x0000000c
-#define A4XX_GRAS_SC_CONTROL_RENDER_MODE__SHIFT                 2
-static inline uint32_t A4XX_GRAS_SC_CONTROL_RENDER_MODE(enum a3xx_render_mode val)
-{
-        return ((val) << A4XX_GRAS_SC_CONTROL_RENDER_MODE__SHIFT) & A4XX_GRAS_SC_CONTROL_RENDER_MODE__MASK;
-}
-#define A4XX_GRAS_SC_CONTROL_MSAA_SAMPLES__MASK                 0x00000380
-#define A4XX_GRAS_SC_CONTROL_MSAA_SAMPLES__SHIFT                7
-static inline uint32_t A4XX_GRAS_SC_CONTROL_MSAA_SAMPLES(uint32_t val)
+#define REG_A4XX_GRAS_SC_EXTENT_WINDOW_TL                       0x0000209f
+#define A4XX_GRAS_SC_EXTENT_WINDOW_TL_WINDOW_OFFSET_DISABLE     0x80000000
+#define A4XX_GRAS_SC_EXTENT_WINDOW_TL_X__MASK                   0x00007fff
+#define A4XX_GRAS_SC_EXTENT_WINDOW_TL_X__SHIFT                  0
+static inline uint32_t A4XX_GRAS_SC_EXTENT_WINDOW_TL_X(uint32_t val)
 {
-        return ((val) << A4XX_GRAS_SC_CONTROL_MSAA_SAMPLES__SHIFT) & A4XX_GRAS_SC_CONTROL_MSAA_SAMPLES__MASK;
+        return ((val) << A4XX_GRAS_SC_EXTENT_WINDOW_TL_X__SHIFT) & A4XX_GRAS_SC_EXTENT_WINDOW_TL_X__MASK;
 }
-#define A4XX_GRAS_SC_CONTROL_MSAA_DISABLE                       0x00000800
-#define A4XX_GRAS_SC_CONTROL_RASTER_MODE__MASK                  0x0000f000
-#define A4XX_GRAS_SC_CONTROL_RASTER_MODE__SHIFT                 12
-static inline uint32_t A4XX_GRAS_SC_CONTROL_RASTER_MODE(uint32_t val)
+#define A4XX_GRAS_SC_EXTENT_WINDOW_TL_Y__MASK                   0x7fff0000
+#define A4XX_GRAS_SC_EXTENT_WINDOW_TL_Y__SHIFT                  16
+static inline uint32_t A4XX_GRAS_SC_EXTENT_WINDOW_TL_Y(uint32_t val)
 {
-        return ((val) << A4XX_GRAS_SC_CONTROL_RASTER_MODE__SHIFT) & A4XX_GRAS_SC_CONTROL_RASTER_MODE__MASK;
+        return ((val) << A4XX_GRAS_SC_EXTENT_WINDOW_TL_Y__SHIFT) & A4XX_GRAS_SC_EXTENT_WINDOW_TL_Y__MASK;
 }
 
 #define REG_A4XX_UCHE_CACHE_MODE_CONTROL                        0x00000e80
@@ -1742,6 +1861,12 @@ static inline uint32_t A4XX_HLSQ_CONTROL_1_REG_VSTHREADSIZE(enum a3xx_threadsize
 }
 #define A4XX_HLSQ_CONTROL_1_REG_VSSUPERTHREADENABLE             0x00000100
 #define A4XX_HLSQ_CONTROL_1_REG_RESERVED1                       0x00000200
+#define A4XX_HLSQ_CONTROL_1_REG_COORDREGID__MASK                0x00ff0000
+#define A4XX_HLSQ_CONTROL_1_REG_COORDREGID__SHIFT               16
+static inline uint32_t A4XX_HLSQ_CONTROL_1_REG_COORDREGID(uint32_t val)
+{
+        return ((val) << A4XX_HLSQ_CONTROL_1_REG_COORDREGID__SHIFT) & A4XX_HLSQ_CONTROL_1_REG_COORDREGID__MASK;
+}
 #define A4XX_HLSQ_CONTROL_1_REG_ZWCOORD                         0x02000000
 
 #define REG_A4XX_HLSQ_CONTROL_2_REG                             0x000023c2
@@ -1751,6 +1876,12 @@ static inline uint32_t A4XX_HLSQ_CONTROL_2_REG_PRIMALLOCTHRESHOLD(uint32_t val)
 {
         return ((val) << A4XX_HLSQ_CONTROL_2_REG_PRIMALLOCTHRESHOLD__SHIFT) & A4XX_HLSQ_CONTROL_2_REG_PRIMALLOCTHRESHOLD__MASK;
 }
+#define A4XX_HLSQ_CONTROL_2_REG_FACEREGID__MASK                 0x000003fc
+#define A4XX_HLSQ_CONTROL_2_REG_FACEREGID__SHIFT                2
+static inline uint32_t A4XX_HLSQ_CONTROL_2_REG_FACEREGID(uint32_t val)
+{
+        return ((val) << A4XX_HLSQ_CONTROL_2_REG_FACEREGID__SHIFT) & A4XX_HLSQ_CONTROL_2_REG_FACEREGID__MASK;
+}
 
 #define REG_A4XX_HLSQ_CONTROL_3_REG                             0x000023c3
 #define A4XX_HLSQ_CONTROL_3_REG_REGID__MASK                     0x000000ff
@@ -1965,15 +2096,13 @@ static inline uint32_t A4XX_HLSQ_GS_CONTROL_REG_INSTRLENGTH(uint32_t val)
 
 #define REG_A4XX_UNKNOWN_20F2                                   0x000020f2
 
-#define REG_A4XX_UNKNOWN_20F3                                   0x000020f3
-
-#define REG_A4XX_UNKNOWN_20F4                                   0x000020f4
-
-#define REG_A4XX_UNKNOWN_20F5                                   0x000020f5
-
-#define REG_A4XX_UNKNOWN_20F6                                   0x000020f6
-
 #define REG_A4XX_UNKNOWN_20F7                                   0x000020f7
+#define A4XX_UNKNOWN_20F7__MASK                                 0xffffffff
+#define A4XX_UNKNOWN_20F7__SHIFT                                0
+static inline uint32_t A4XX_UNKNOWN_20F7(float val)
+{
+        return ((fui(val)) << A4XX_UNKNOWN_20F7__SHIFT) & A4XX_UNKNOWN_20F7__MASK;
+}
 
 #define REG_A4XX_UNKNOWN_2152                                   0x00002152
 
@@ -2000,6 +2129,7 @@ static inline uint32_t A4XX_HLSQ_GS_CONTROL_REG_INSTRLENGTH(uint32_t val)
 #define REG_A4XX_UNKNOWN_23A0                                   0x000023a0
 
 #define REG_A4XX_TEX_SAMP_0                                     0x00000000
+#define A4XX_TEX_SAMP_0_MIPFILTER_LINEAR_NEAR                   0x00000001
 #define A4XX_TEX_SAMP_0_XY_MAG__MASK                            0x00000006
 #define A4XX_TEX_SAMP_0_XY_MAG__SHIFT                           1
 static inline uint32_t A4XX_TEX_SAMP_0_XY_MAG(enum a4xx_tex_filter val)
@@ -2038,17 +2168,19 @@ static inline uint32_t A4XX_TEX_SAMP_1_COMPARE_FUNC(enum adreno_compare_func val
 {
         return ((val) << A4XX_TEX_SAMP_1_COMPARE_FUNC__SHIFT) & A4XX_TEX_SAMP_1_COMPARE_FUNC__MASK;
 }
+#define A4XX_TEX_SAMP_1_UNNORM_COORDS                           0x00000020
+#define A4XX_TEX_SAMP_1_MIPFILTER_LINEAR_FAR                    0x00000040
 #define A4XX_TEX_SAMP_1_MAX_LOD__MASK                           0x000fff00
 #define A4XX_TEX_SAMP_1_MAX_LOD__SHIFT                          8
 static inline uint32_t A4XX_TEX_SAMP_1_MAX_LOD(float val)
 {
-        return ((((uint32_t)(val * 64.0))) << A4XX_TEX_SAMP_1_MAX_LOD__SHIFT) & A4XX_TEX_SAMP_1_MAX_LOD__MASK;
+        return ((((uint32_t)(val * 256.0))) << A4XX_TEX_SAMP_1_MAX_LOD__SHIFT) & A4XX_TEX_SAMP_1_MAX_LOD__MASK;
 }
 #define A4XX_TEX_SAMP_1_MIN_LOD__MASK                           0xfff00000
 #define A4XX_TEX_SAMP_1_MIN_LOD__SHIFT                          20
 static inline uint32_t A4XX_TEX_SAMP_1_MIN_LOD(float val)
 {
-        return ((((uint32_t)(val * 64.0))) << A4XX_TEX_SAMP_1_MIN_LOD__SHIFT) & A4XX_TEX_SAMP_1_MIN_LOD__MASK;
+        return ((((uint32_t)(val * 256.0))) << A4XX_TEX_SAMP_1_MIN_LOD__SHIFT) & A4XX_TEX_SAMP_1_MIN_LOD__MASK;
 }
 
 #define REG_A4XX_TEX_CONST_0                                    0x00000000
@@ -2077,6 +2209,12 @@ static inline uint32_t A4XX_TEX_CONST_0_SWIZ_W(enum a4xx_tex_swiz val)
 {
         return ((val) << A4XX_TEX_CONST_0_SWIZ_W__SHIFT) & A4XX_TEX_CONST_0_SWIZ_W__MASK;
 }
+#define A4XX_TEX_CONST_0_MIPLVLS__MASK                          0x000f0000
+#define A4XX_TEX_CONST_0_MIPLVLS__SHIFT                         16
+static inline uint32_t A4XX_TEX_CONST_0_MIPLVLS(uint32_t val)
+{
+        return ((val) << A4XX_TEX_CONST_0_MIPLVLS__SHIFT) & A4XX_TEX_CONST_0_MIPLVLS__MASK;
+}
 #define A4XX_TEX_CONST_0_FMT__MASK                              0x1fc00000
 #define A4XX_TEX_CONST_0_FMT__SHIFT                             22
 static inline uint32_t A4XX_TEX_CONST_0_FMT(enum a4xx_tex_fmt val)
@@ -2105,6 +2243,12 @@ static inline uint32_t A4XX_TEX_CONST_1_WIDTH(uint32_t val)
 }
 
 #define REG_A4XX_TEX_CONST_2                                    0x00000002
+#define A4XX_TEX_CONST_2_FETCHSIZE__MASK                        0x0000000f
+#define A4XX_TEX_CONST_2_FETCHSIZE__SHIFT                       0
+static inline uint32_t A4XX_TEX_CONST_2_FETCHSIZE(enum a4xx_tex_fetchsize val)
+{
+        return ((val) << A4XX_TEX_CONST_2_FETCHSIZE__SHIFT) & A4XX_TEX_CONST_2_FETCHSIZE__MASK;
+}
 #define A4XX_TEX_CONST_2_PITCH__MASK                            0x3ffffe00
 #define A4XX_TEX_CONST_2_PITCH__SHIFT                           9
 static inline uint32_t A4XX_TEX_CONST_2_PITCH(uint32_t val)
@@ -2119,19 +2263,31 @@ static inline uint32_t A4XX_TEX_CONST_2_SWAP(enum a3xx_color_swap val)
 }
 
 #define REG_A4XX_TEX_CONST_3                                    0x00000003
-#define A4XX_TEX_CONST_3_LAYERSZ__MASK                          0x0000000f
+#define A4XX_TEX_CONST_3_LAYERSZ__MASK                          0x00003fff
 #define A4XX_TEX_CONST_3_LAYERSZ__SHIFT                         0
 static inline uint32_t A4XX_TEX_CONST_3_LAYERSZ(uint32_t val)
 {
         return ((val >> 12) << A4XX_TEX_CONST_3_LAYERSZ__SHIFT) & A4XX_TEX_CONST_3_LAYERSZ__MASK;
 }
+#define A4XX_TEX_CONST_3_DEPTH__MASK                            0x7ffc0000
+#define A4XX_TEX_CONST_3_DEPTH__SHIFT                           18
+static inline uint32_t A4XX_TEX_CONST_3_DEPTH(uint32_t val)
+{
+        return ((val) << A4XX_TEX_CONST_3_DEPTH__SHIFT) & A4XX_TEX_CONST_3_DEPTH__MASK;
+}
 
 #define REG_A4XX_TEX_CONST_4                                    0x00000004
-#define A4XX_TEX_CONST_4_BASE__MASK                             0xffffffff
-#define A4XX_TEX_CONST_4_BASE__SHIFT                            0
+#define A4XX_TEX_CONST_4_LAYERSZ__MASK                          0x0000000f
+#define A4XX_TEX_CONST_4_LAYERSZ__SHIFT                         0
+static inline uint32_t A4XX_TEX_CONST_4_LAYERSZ(uint32_t val)
+{
+        return ((val >> 12) << A4XX_TEX_CONST_4_LAYERSZ__SHIFT) & A4XX_TEX_CONST_4_LAYERSZ__MASK;
+}
+#define A4XX_TEX_CONST_4_BASE__MASK                             0xffffffe0
+#define A4XX_TEX_CONST_4_BASE__SHIFT                            5
 static inline uint32_t A4XX_TEX_CONST_4_BASE(uint32_t val)
 {
-        return ((val) << A4XX_TEX_CONST_4_BASE__SHIFT) & A4XX_TEX_CONST_4_BASE__MASK;
+        return ((val >> 5) << A4XX_TEX_CONST_4_BASE__SHIFT) & A4XX_TEX_CONST_4_BASE__MASK;
 }
 
 #define REG_A4XX_TEX_CONST_5                                    0x00000005
diff --git a/drivers/gpu/drm/msm/adreno/adreno_common.xml.h b/drivers/gpu/drm/msm/adreno/adreno_common.xml.h
index a4b33af9338d..8531beb982e7 100644
--- a/drivers/gpu/drm/msm/adreno/adreno_common.xml.h
+++ b/drivers/gpu/drm/msm/adreno/adreno_common.xml.h
@@ -12,9 +12,9 @@ The rules-ng-ng source files this header was generated from are:
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml  (   1453 bytes, from 2013-03-31 16:51:27)
 - /home/robclark/src/freedreno/envytools/rnndb/adreno/a2xx.xml          (  32901 bytes, from 2014-06-02 15:21:30)
 - /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_common.xml (  10551 bytes, from 2014-11-13 22:44:30)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_pm4.xml    (  15053 bytes, from 2014-11-09 15:45:47)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/a3xx.xml          (  63169 bytes, from 2014-11-13 22:44:18)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/a4xx.xml          (  49097 bytes, from 2014-11-14 15:38:00)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_pm4.xml    (  15085 bytes, from 2014-12-20 21:49:41)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/a3xx.xml          (  64344 bytes, from 2014-12-12 20:22:26)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/a4xx.xml          (  51069 bytes, from 2014-12-21 15:51:54)
 
 Copyright (C) 2013-2014 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
diff --git a/drivers/gpu/drm/msm/adreno/adreno_pm4.xml.h b/drivers/gpu/drm/msm/adreno/adreno_pm4.xml.h
index 6a75cee94d81..6ffc4f6c8af1 100644
--- a/drivers/gpu/drm/msm/adreno/adreno_pm4.xml.h
+++ b/drivers/gpu/drm/msm/adreno/adreno_pm4.xml.h
@@ -12,9 +12,9 @@ The rules-ng-ng source files this header was generated from are:
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml  (   1453 bytes, from 2013-03-31 16:51:27)
 - /home/robclark/src/freedreno/envytools/rnndb/adreno/a2xx.xml          (  32901 bytes, from 2014-06-02 15:21:30)
 - /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_common.xml (  10551 bytes, from 2014-11-13 22:44:30)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_pm4.xml    (  15053 bytes, from 2014-11-09 15:45:47)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/a3xx.xml          (  63169 bytes, from 2014-11-13 22:44:18)
-- /home/robclark/src/freedreno/envytools/rnndb/adreno/a4xx.xml          (  49097 bytes, from 2014-11-14 15:38:00)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/adreno_pm4.xml    (  15085 bytes, from 2014-12-20 21:49:41)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/a3xx.xml          (  64344 bytes, from 2014-12-12 20:22:26)
+- /home/robclark/src/freedreno/envytools/rnndb/adreno/a4xx.xml          (  51069 bytes, from 2014-12-21 15:51:54)
 
 Copyright (C) 2013-2014 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
@@ -172,7 +172,9 @@ enum adreno_pm4_type3_packets {
         CP_DRAW_INDIRECT = 40,
         CP_DRAW_INDX_INDIRECT = 41,
         CP_DRAW_AUTO = 36,
+        CP_UNKNOWN_19 = 25,
         CP_UNKNOWN_1A = 26,
+        CP_UNKNOWN_4E = 78,
         CP_WIDE_REG_WRITE = 116,
         IN_IB_PREFETCH_END = 23,
         IN_SUBBLK_PREFETCH = 31,
@@ -203,6 +205,12 @@ enum adreno_state_src {
         SS_INDIRECT = 4,
 };
 
+enum a4xx_index_size {
+        INDEX4_SIZE_8_BIT = 0,
+        INDEX4_SIZE_16_BIT = 1,
+        INDEX4_SIZE_32_BIT = 2,
+};
+
 #define REG_CP_LOAD_STATE_0                                     0x00000000
 #define CP_LOAD_STATE_0_DST_OFF__MASK                           0x0000ffff
 #define CP_LOAD_STATE_0_DST_OFF__SHIFT                          0
@@ -374,29 +382,20 @@ static inline uint32_t CP_DRAW_INDX_OFFSET_0_SOURCE_SELECT(enum pc_di_src_sel va
 {
         return ((val) << CP_DRAW_INDX_OFFSET_0_SOURCE_SELECT__SHIFT) & CP_DRAW_INDX_OFFSET_0_SOURCE_SELECT__MASK;
 }
-#define CP_DRAW_INDX_OFFSET_0_VIS_CULL__MASK                    0x00000700
-#define CP_DRAW_INDX_OFFSET_0_VIS_CULL__SHIFT                   8
-static inline uint32_t CP_DRAW_INDX_OFFSET_0_VIS_CULL(enum pc_di_vis_cull_mode val)
-{
-        return ((val) << CP_DRAW_INDX_OFFSET_0_VIS_CULL__SHIFT) & CP_DRAW_INDX_OFFSET_0_VIS_CULL__MASK;
-}
-#define CP_DRAW_INDX_OFFSET_0_INDEX_SIZE__MASK                  0x00000800
-#define CP_DRAW_INDX_OFFSET_0_INDEX_SIZE__SHIFT                 11
-static inline uint32_t CP_DRAW_INDX_OFFSET_0_INDEX_SIZE(enum pc_di_index_size val)
+#define CP_DRAW_INDX_OFFSET_0_INDEX_SIZE__MASK                  0x00000c00
+#define CP_DRAW_INDX_OFFSET_0_INDEX_SIZE__SHIFT                 10
+static inline uint32_t CP_DRAW_INDX_OFFSET_0_INDEX_SIZE(enum a4xx_index_size val)
 {
         return ((val) << CP_DRAW_INDX_OFFSET_0_INDEX_SIZE__SHIFT) & CP_DRAW_INDX_OFFSET_0_INDEX_SIZE__MASK;
 }
-#define CP_DRAW_INDX_OFFSET_0_NOT_EOP                           0x00001000
-#define CP_DRAW_INDX_OFFSET_0_SMALL_INDEX                       0x00002000
-#define CP_DRAW_INDX_OFFSET_0_PRE_DRAW_INITIATOR_ENABLE         0x00004000
-#define CP_DRAW_INDX_OFFSET_0_NUM_INSTANCES__MASK               0xffff0000
-#define CP_DRAW_INDX_OFFSET_0_NUM_INSTANCES__SHIFT              16
-static inline uint32_t CP_DRAW_INDX_OFFSET_0_NUM_INSTANCES(uint32_t val)
-{
-        return ((val) << CP_DRAW_INDX_OFFSET_0_NUM_INSTANCES__SHIFT) & CP_DRAW_INDX_OFFSET_0_NUM_INSTANCES__MASK;
-}
 
 #define REG_CP_DRAW_INDX_OFFSET_1                               0x00000001
+#define CP_DRAW_INDX_OFFSET_1_NUM_INSTANCES__MASK               0xffffffff
+#define CP_DRAW_INDX_OFFSET_1_NUM_INSTANCES__SHIFT              0
+static inline uint32_t CP_DRAW_INDX_OFFSET_1_NUM_INSTANCES(uint32_t val)
+{
+        return ((val) << CP_DRAW_INDX_OFFSET_1_NUM_INSTANCES__SHIFT) & CP_DRAW_INDX_OFFSET_1_NUM_INSTANCES__MASK;
+}
 
 #define REG_CP_DRAW_INDX_OFFSET_2                               0x00000002
 #define CP_DRAW_INDX_OFFSET_2_NUM_INDICES__MASK                 0xffffffff
diff --git a/drivers/gpu/drm/msm/dsi/dsi.xml.h b/drivers/gpu/drm/msm/dsi/dsi.xml.h
index 448438b759b4..abf1bba520bf 100644
--- a/drivers/gpu/drm/msm/dsi/dsi.xml.h
+++ b/drivers/gpu/drm/msm/dsi/dsi.xml.h
@@ -8,16 +8,17 @@ http://github.com/freedreno/envytools/
 git clone https://github.com/freedreno/envytools.git
 
 The rules-ng-ng source files this header was generated from are:
-- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    647 bytes, from 2013-11-30 14:45:35)
+- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    676 bytes, from 2014-12-05 15:34:49)
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml (   1453 bytes, from 2013-03-31 16:51:27)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20136 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   1940 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  23963 bytes, from 2014-10-31 16:51:46)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20908 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   2357 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  27208 bytes, from 2015-01-13 23:56:11)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/dsi.xml             (  11712 bytes, from 2013-08-17 17:13:43)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/sfpb.xml            (    344 bytes, from 2013-08-11 19:26:32)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1686 bytes, from 2014-10-31 16:48:57)
 - /home/robclark/src/freedreno/envytools/rnndb/hdmi/qfprom.xml         (    600 bytes, from 2013-07-05 19:21:12)
-- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  23613 bytes, from 2014-07-17 15:33:30)
+- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  26848 bytes, from 2015-01-13 23:55:57)
+- /home/robclark/src/freedreno/envytools/rnndb/edp/edp.xml             (   8253 bytes, from 2014-12-08 16:13:00)
 
 Copyright (C) 2013 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
diff --git a/drivers/gpu/drm/msm/dsi/mmss_cc.xml.h b/drivers/gpu/drm/msm/dsi/mmss_cc.xml.h
index c102a7f074ac..695f99d4bec2 100644
--- a/drivers/gpu/drm/msm/dsi/mmss_cc.xml.h
+++ b/drivers/gpu/drm/msm/dsi/mmss_cc.xml.h
@@ -8,16 +8,17 @@ http://github.com/freedreno/envytools/
 git clone https://github.com/freedreno/envytools.git
 
 The rules-ng-ng source files this header was generated from are:
-- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    647 bytes, from 2013-11-30 14:45:35)
+- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    676 bytes, from 2014-12-05 15:34:49)
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml (   1453 bytes, from 2013-03-31 16:51:27)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20136 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   1940 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  23963 bytes, from 2014-10-31 16:51:46)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20908 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   2357 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  27208 bytes, from 2015-01-13 23:56:11)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/dsi.xml             (  11712 bytes, from 2013-08-17 17:13:43)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/sfpb.xml            (    344 bytes, from 2013-08-11 19:26:32)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1686 bytes, from 2014-10-31 16:48:57)
 - /home/robclark/src/freedreno/envytools/rnndb/hdmi/qfprom.xml         (    600 bytes, from 2013-07-05 19:21:12)
-- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  23613 bytes, from 2014-07-17 15:33:30)
+- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  26848 bytes, from 2015-01-13 23:55:57)
+- /home/robclark/src/freedreno/envytools/rnndb/edp/edp.xml             (   8253 bytes, from 2014-12-08 16:13:00)
 
 Copyright (C) 2013-2014 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
diff --git a/drivers/gpu/drm/msm/dsi/sfpb.xml.h b/drivers/gpu/drm/msm/dsi/sfpb.xml.h
index a900134bdf33..50ff9851d73d 100644
--- a/drivers/gpu/drm/msm/dsi/sfpb.xml.h
+++ b/drivers/gpu/drm/msm/dsi/sfpb.xml.h
@@ -8,16 +8,17 @@ http://github.com/freedreno/envytools/
 git clone https://github.com/freedreno/envytools.git
 
 The rules-ng-ng source files this header was generated from are:
-- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    647 bytes, from 2013-11-30 14:45:35)
+- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    676 bytes, from 2014-12-05 15:34:49)
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml (   1453 bytes, from 2013-03-31 16:51:27)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20136 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   1940 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  23963 bytes, from 2014-10-31 16:51:46)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20908 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   2357 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  27208 bytes, from 2015-01-13 23:56:11)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/dsi.xml             (  11712 bytes, from 2013-08-17 17:13:43)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/sfpb.xml            (    344 bytes, from 2013-08-11 19:26:32)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1686 bytes, from 2014-10-31 16:48:57)
 - /home/robclark/src/freedreno/envytools/rnndb/hdmi/qfprom.xml         (    600 bytes, from 2013-07-05 19:21:12)
-- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  23613 bytes, from 2014-07-17 15:33:30)
+- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  26848 bytes, from 2015-01-13 23:55:57)
+- /home/robclark/src/freedreno/envytools/rnndb/edp/edp.xml             (   8253 bytes, from 2014-12-08 16:13:00)
 
 Copyright (C) 2013 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
diff --git a/drivers/gpu/drm/msm/edp/edp.c b/drivers/gpu/drm/msm/edp/edp.c
new file mode 100644
index 000000000000..0940e84b2821
--- /dev/null
+++ b/drivers/gpu/drm/msm/edp/edp.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/of_irq.h>
+#include "edp.h"
+
+static irqreturn_t edp_irq(int irq, void *dev_id)
+{
+        struct msm_edp *edp = dev_id;
+
+        /* Process eDP irq */
+        return msm_edp_ctrl_irq(edp->ctrl);
+}
+
+static void edp_destroy(struct platform_device *pdev)
+{
+        struct msm_edp *edp = platform_get_drvdata(pdev);
+
+        if (!edp)
+                return;
+
+        if (edp->ctrl) {
+                msm_edp_ctrl_destroy(edp->ctrl);
+                edp->ctrl = NULL;
+        }
+
+        platform_set_drvdata(pdev, NULL);
+}
+
+/* construct eDP at bind/probe time, grab all the resources. */
+static struct msm_edp *edp_init(struct platform_device *pdev)
+{
+        struct msm_edp *edp = NULL;
+        int ret;
+
+        if (!pdev) {
+                pr_err("no eDP device\n");
+                ret = -ENXIO;
+                goto fail;
+        }
+
+        edp = devm_kzalloc(&pdev->dev, sizeof(*edp), GFP_KERNEL);
+        if (!edp) {
+                ret = -ENOMEM;
+                goto fail;
+        }
+        DBG("eDP probed=%p", edp);
+
+        edp->pdev = pdev;
+        platform_set_drvdata(pdev, edp);
+
+        ret = msm_edp_ctrl_init(edp);
+        if (ret)
+                goto fail;
+
+        return edp;
+
+fail:
+        if (edp)
+                edp_destroy(pdev);
+
+        return ERR_PTR(ret);
+}
+
+static int edp_bind(struct device *dev, struct device *master, void *data)
+{
+        struct drm_device *drm = dev_get_drvdata(master);
+        struct msm_drm_private *priv = drm->dev_private;
+        struct msm_edp *edp;
+
+        DBG("");
+        edp = edp_init(to_platform_device(dev));
+        if (IS_ERR(edp))
+                return PTR_ERR(edp);
+        priv->edp = edp;
+
+        return 0;
+}
+
+static void edp_unbind(struct device *dev, struct device *master, void *data)
+{
+        struct drm_device *drm = dev_get_drvdata(master);
+        struct msm_drm_private *priv = drm->dev_private;
+
+        DBG("");
+        if (priv->edp) {
+                edp_destroy(to_platform_device(dev));
+                priv->edp = NULL;
+        }
+}
+
+static const struct component_ops edp_ops = {
+                .bind   = edp_bind,
+                .unbind = edp_unbind,
+};
+
+static int edp_dev_probe(struct platform_device *pdev)
+{
+        DBG("");
+        return component_add(&pdev->dev, &edp_ops);
+}
+
+static int edp_dev_remove(struct platform_device *pdev)
+{
+        DBG("");
+        component_del(&pdev->dev, &edp_ops);
+        return 0;
+}
+
+static const struct of_device_id dt_match[] = {
+        { .compatible = "qcom,mdss-edp" },
+        {}
+};
+
+static struct platform_driver edp_driver = {
+        .probe = edp_dev_probe,
+        .remove = edp_dev_remove,
+        .driver = {
+                .name = "msm_edp",
+                .of_match_table = dt_match,
+        },
+};
+
+void __init msm_edp_register(void)
+{
+        DBG("");
+        platform_driver_register(&edp_driver);
+}
+
+void __exit msm_edp_unregister(void)
+{
+        DBG("");
+        platform_driver_unregister(&edp_driver);
+}
+
+/* Second part of initialization, the drm/kms level modeset_init */
+int msm_edp_modeset_init(struct msm_edp *edp, struct drm_device *dev,
+                                struct drm_encoder *encoder)
+{
+        struct platform_device *pdev = edp->pdev;
+        struct msm_drm_private *priv = dev->dev_private;
+        int ret;
+
+        edp->encoder = encoder;
+        edp->dev = dev;
+
+        edp->bridge = msm_edp_bridge_init(edp);
+        if (IS_ERR(edp->bridge)) {
+                ret = PTR_ERR(edp->bridge);
+                dev_err(dev->dev, "failed to create eDP bridge: %d\n", ret);
+                edp->bridge = NULL;
+                goto fail;
+        }
+
+        edp->connector = msm_edp_connector_init(edp);
+        if (IS_ERR(edp->connector)) {
+                ret = PTR_ERR(edp->connector);
+                dev_err(dev->dev, "failed to create eDP connector: %d\n", ret);
+                edp->connector = NULL;
+                goto fail;
+        }
+
+        edp->irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
+        if (edp->irq < 0) {
+                ret = edp->irq;
+                dev_err(dev->dev, "failed to get IRQ: %d\n", ret);
+                goto fail;
+        }
+
+        ret = devm_request_irq(&pdev->dev, edp->irq,
+                        edp_irq, IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
+                        "edp_isr", edp);
+        if (ret < 0) {
+                dev_err(dev->dev, "failed to request IRQ%u: %d\n",
+                                edp->irq, ret);
+                goto fail;
+        }
+
+        encoder->bridge = edp->bridge;
+
+        priv->bridges[priv->num_bridges++]       = edp->bridge;
+        priv->connectors[priv->num_connectors++] = edp->connector;
+
+        return 0;
+
+fail:
+        /* bridge/connector are normally destroyed by drm */
+        if (edp->bridge) {
+                edp_bridge_destroy(edp->bridge);
+                edp->bridge = NULL;
+        }
+        if (edp->connector) {
+                edp->connector->funcs->destroy(edp->connector);
+                edp->connector = NULL;
+        }
+
+        return ret;
+}
diff --git a/drivers/gpu/drm/msm/edp/edp.h b/drivers/gpu/drm/msm/edp/edp.h
new file mode 100644
index 000000000000..ba5bedde5241
--- /dev/null
+++ b/drivers/gpu/drm/msm/edp/edp.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __EDP_CONNECTOR_H__
+#define __EDP_CONNECTOR_H__
+
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+
+#include "drm_crtc.h"
+#include "drm_dp_helper.h"
+#include "msm_drv.h"
+
+#define edp_read(offset) msm_readl((offset))
+#define edp_write(offset, data) msm_writel((data), (offset))
+
+struct edp_ctrl;
+struct edp_aux;
+struct edp_phy;
+
+struct msm_edp {
+        struct drm_device *dev;
+        struct platform_device *pdev;
+
+        struct drm_connector *connector;
+        struct drm_bridge *bridge;
+
+        /* the encoder we are hooked to (outside of eDP block) */
+        struct drm_encoder *encoder;
+
+        struct edp_ctrl *ctrl;
+
+        int irq;
+};
+
+/* eDP bridge */
+struct drm_bridge *msm_edp_bridge_init(struct msm_edp *edp);
+void edp_bridge_destroy(struct drm_bridge *bridge);
+
+/* eDP connector */
+struct drm_connector *msm_edp_connector_init(struct msm_edp *edp);
+
+/* AUX */
+void *msm_edp_aux_init(struct device *dev, void __iomem *regbase,
+                        struct drm_dp_aux **drm_aux);
+void msm_edp_aux_destroy(struct device *dev, struct edp_aux *aux);
+irqreturn_t msm_edp_aux_irq(struct edp_aux *aux, u32 isr);
+void msm_edp_aux_ctrl(struct edp_aux *aux, int enable);
+
+/* Phy */
+bool msm_edp_phy_ready(struct edp_phy *phy);
+void msm_edp_phy_ctrl(struct edp_phy *phy, int enable);
+void msm_edp_phy_vm_pe_init(struct edp_phy *phy);
+void msm_edp_phy_vm_pe_cfg(struct edp_phy *phy, u32 v0, u32 v1);
+void msm_edp_phy_lane_power_ctrl(struct edp_phy *phy, bool up, u32 max_lane);
+void *msm_edp_phy_init(struct device *dev, void __iomem *regbase);
+
+/* Ctrl */
+irqreturn_t msm_edp_ctrl_irq(struct edp_ctrl *ctrl);
+void msm_edp_ctrl_power(struct edp_ctrl *ctrl, bool on);
+int msm_edp_ctrl_init(struct msm_edp *edp);
+void msm_edp_ctrl_destroy(struct edp_ctrl *ctrl);
+bool msm_edp_ctrl_panel_connected(struct edp_ctrl *ctrl);
+int msm_edp_ctrl_get_panel_info(struct edp_ctrl *ctrl,
+        struct drm_connector *connector, struct edid **edid);
+int msm_edp_ctrl_timing_cfg(struct edp_ctrl *ctrl,
+                                const struct drm_display_mode *mode,
+                                const struct drm_display_info *info);
+/* @pixel_rate is in kHz */
+bool msm_edp_ctrl_pixel_clock_valid(struct edp_ctrl *ctrl,
+        u32 pixel_rate, u32 *pm, u32 *pn);
+
+#endif /* __EDP_CONNECTOR_H__ */
diff --git a/drivers/gpu/drm/msm/edp/edp.xml.h b/drivers/gpu/drm/msm/edp/edp.xml.h
new file mode 100644
index 000000000000..a29f1df15143
--- /dev/null
+++ b/drivers/gpu/drm/msm/edp/edp.xml.h
@@ -0,0 +1,292 @@
+#ifndef EDP_XML
+#define EDP_XML
+
+/* Autogenerated file, DO NOT EDIT manually!
+
+This file was generated by the rules-ng-ng headergen tool in this git repository:
+http://github.com/freedreno/envytools/
+git clone https://github.com/freedreno/envytools.git
+
+The rules-ng-ng source files this header was generated from are:
+- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    676 bytes, from 2014-12-05 15:34:49)
+- /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml (   1453 bytes, from 2013-03-31 16:51:27)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20908 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   2357 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  27208 bytes, from 2015-01-13 23:56:11)
+- /home/robclark/src/freedreno/envytools/rnndb/dsi/dsi.xml             (  11712 bytes, from 2013-08-17 17:13:43)
+- /home/robclark/src/freedreno/envytools/rnndb/dsi/sfpb.xml            (    344 bytes, from 2013-08-11 19:26:32)
+- /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1686 bytes, from 2014-10-31 16:48:57)
+- /home/robclark/src/freedreno/envytools/rnndb/hdmi/qfprom.xml         (    600 bytes, from 2013-07-05 19:21:12)
+- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  26848 bytes, from 2015-01-13 23:55:57)
+- /home/robclark/src/freedreno/envytools/rnndb/edp/edp.xml             (   8253 bytes, from 2014-12-08 16:13:00)
+
+Copyright (C) 2013-2014 by the following authors:
+- Rob Clark <robdclark@gmail.com> (robclark)
+
+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 COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS 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.
+*/
+
+
+enum edp_color_depth {
+        EDP_6BIT = 0,
+        EDP_8BIT = 1,
+        EDP_10BIT = 2,
+        EDP_12BIT = 3,
+        EDP_16BIT = 4,
+};
+
+enum edp_component_format {
+        EDP_RGB = 0,
+        EDP_YUV422 = 1,
+        EDP_YUV444 = 2,
+};
+
+#define REG_EDP_MAINLINK_CTRL                                   0x00000004
+#define EDP_MAINLINK_CTRL_ENABLE                                0x00000001
+#define EDP_MAINLINK_CTRL_RESET                                 0x00000002
+
+#define REG_EDP_STATE_CTRL                                      0x00000008
+#define EDP_STATE_CTRL_TRAIN_PATTERN_1                          0x00000001
+#define EDP_STATE_CTRL_TRAIN_PATTERN_2                          0x00000002
+#define EDP_STATE_CTRL_TRAIN_PATTERN_3                          0x00000004
+#define EDP_STATE_CTRL_SYMBOL_ERR_RATE_MEAS                     0x00000008
+#define EDP_STATE_CTRL_PRBS7                                    0x00000010
+#define EDP_STATE_CTRL_CUSTOM_80_BIT_PATTERN                    0x00000020
+#define EDP_STATE_CTRL_SEND_VIDEO                               0x00000040
+#define EDP_STATE_CTRL_PUSH_IDLE                                0x00000080
+
+#define REG_EDP_CONFIGURATION_CTRL                              0x0000000c
+#define EDP_CONFIGURATION_CTRL_SYNC_CLK                         0x00000001
+#define EDP_CONFIGURATION_CTRL_STATIC_MVID                      0x00000002
+#define EDP_CONFIGURATION_CTRL_PROGRESSIVE                      0x00000004
+#define EDP_CONFIGURATION_CTRL_LANES__MASK                      0x00000030
+#define EDP_CONFIGURATION_CTRL_LANES__SHIFT                     4
+static inline uint32_t EDP_CONFIGURATION_CTRL_LANES(uint32_t val)
+{
+        return ((val) << EDP_CONFIGURATION_CTRL_LANES__SHIFT) & EDP_CONFIGURATION_CTRL_LANES__MASK;
+}
+#define EDP_CONFIGURATION_CTRL_ENHANCED_FRAMING                 0x00000040
+#define EDP_CONFIGURATION_CTRL_COLOR__MASK                      0x00000100
+#define EDP_CONFIGURATION_CTRL_COLOR__SHIFT                     8
+static inline uint32_t EDP_CONFIGURATION_CTRL_COLOR(enum edp_color_depth val)
+{
+        return ((val) << EDP_CONFIGURATION_CTRL_COLOR__SHIFT) & EDP_CONFIGURATION_CTRL_COLOR__MASK;
+}
+
+#define REG_EDP_SOFTWARE_MVID                                   0x00000014
+
+#define REG_EDP_SOFTWARE_NVID                                   0x00000018
+
+#define REG_EDP_TOTAL_HOR_VER                                   0x0000001c
+#define EDP_TOTAL_HOR_VER_HORIZ__MASK                           0x0000ffff
+#define EDP_TOTAL_HOR_VER_HORIZ__SHIFT                          0
+static inline uint32_t EDP_TOTAL_HOR_VER_HORIZ(uint32_t val)
+{
+        return ((val) << EDP_TOTAL_HOR_VER_HORIZ__SHIFT) & EDP_TOTAL_HOR_VER_HORIZ__MASK;
+}
+#define EDP_TOTAL_HOR_VER_VERT__MASK                            0xffff0000
+#define EDP_TOTAL_HOR_VER_VERT__SHIFT                           16
+static inline uint32_t EDP_TOTAL_HOR_VER_VERT(uint32_t val)
+{
+        return ((val) << EDP_TOTAL_HOR_VER_VERT__SHIFT) & EDP_TOTAL_HOR_VER_VERT__MASK;
+}
+
+#define REG_EDP_START_HOR_VER_FROM_SYNC                         0x00000020
+#define EDP_START_HOR_VER_FROM_SYNC_HORIZ__MASK                 0x0000ffff
+#define EDP_START_HOR_VER_FROM_SYNC_HORIZ__SHIFT                0
+static inline uint32_t EDP_START_HOR_VER_FROM_SYNC_HORIZ(uint32_t val)
+{
+        return ((val) << EDP_START_HOR_VER_FROM_SYNC_HORIZ__SHIFT) & EDP_START_HOR_VER_FROM_SYNC_HORIZ__MASK;
+}
+#define EDP_START_HOR_VER_FROM_SYNC_VERT__MASK                  0xffff0000
+#define EDP_START_HOR_VER_FROM_SYNC_VERT__SHIFT                 16
+static inline uint32_t EDP_START_HOR_VER_FROM_SYNC_VERT(uint32_t val)
+{
+        return ((val) << EDP_START_HOR_VER_FROM_SYNC_VERT__SHIFT) & EDP_START_HOR_VER_FROM_SYNC_VERT__MASK;
+}
+
+#define REG_EDP_HSYNC_VSYNC_WIDTH_POLARITY                      0x00000024
+#define EDP_HSYNC_VSYNC_WIDTH_POLARITY_HORIZ__MASK              0x00007fff
+#define EDP_HSYNC_VSYNC_WIDTH_POLARITY_HORIZ__SHIFT             0
+static inline uint32_t EDP_HSYNC_VSYNC_WIDTH_POLARITY_HORIZ(uint32_t val)
+{
+        return ((val) << EDP_HSYNC_VSYNC_WIDTH_POLARITY_HORIZ__SHIFT) & EDP_HSYNC_VSYNC_WIDTH_POLARITY_HORIZ__MASK;
+}
+#define EDP_HSYNC_VSYNC_WIDTH_POLARITY_NHSYNC                   0x00008000
+#define EDP_HSYNC_VSYNC_WIDTH_POLARITY_VERT__MASK               0x7fff0000
+#define EDP_HSYNC_VSYNC_WIDTH_POLARITY_VERT__SHIFT              16
+static inline uint32_t EDP_HSYNC_VSYNC_WIDTH_POLARITY_VERT(uint32_t val)
+{
+        return ((val) << EDP_HSYNC_VSYNC_WIDTH_POLARITY_VERT__SHIFT) & EDP_HSYNC_VSYNC_WIDTH_POLARITY_VERT__MASK;
+}
+#define EDP_HSYNC_VSYNC_WIDTH_POLARITY_NVSYNC                   0x80000000
+
+#define REG_EDP_ACTIVE_HOR_VER                                  0x00000028
+#define EDP_ACTIVE_HOR_VER_HORIZ__MASK                          0x0000ffff
+#define EDP_ACTIVE_HOR_VER_HORIZ__SHIFT                         0
+static inline uint32_t EDP_ACTIVE_HOR_VER_HORIZ(uint32_t val)
+{
+        return ((val) << EDP_ACTIVE_HOR_VER_HORIZ__SHIFT) & EDP_ACTIVE_HOR_VER_HORIZ__MASK;
+}
+#define EDP_ACTIVE_HOR_VER_VERT__MASK                           0xffff0000
+#define EDP_ACTIVE_HOR_VER_VERT__SHIFT                          16
+static inline uint32_t EDP_ACTIVE_HOR_VER_VERT(uint32_t val)
+{
+        return ((val) << EDP_ACTIVE_HOR_VER_VERT__SHIFT) & EDP_ACTIVE_HOR_VER_VERT__MASK;
+}
+
+#define REG_EDP_MISC1_MISC0                                     0x0000002c
+#define EDP_MISC1_MISC0_MISC0__MASK                             0x000000ff
+#define EDP_MISC1_MISC0_MISC0__SHIFT                            0
+static inline uint32_t EDP_MISC1_MISC0_MISC0(uint32_t val)
+{
+        return ((val) << EDP_MISC1_MISC0_MISC0__SHIFT) & EDP_MISC1_MISC0_MISC0__MASK;
+}
+#define EDP_MISC1_MISC0_SYNC                                    0x00000001
+#define EDP_MISC1_MISC0_COMPONENT_FORMAT__MASK                  0x00000006
+#define EDP_MISC1_MISC0_COMPONENT_FORMAT__SHIFT                 1
+static inline uint32_t EDP_MISC1_MISC0_COMPONENT_FORMAT(enum edp_component_format val)
+{
+        return ((val) << EDP_MISC1_MISC0_COMPONENT_FORMAT__SHIFT) & EDP_MISC1_MISC0_COMPONENT_FORMAT__MASK;
+}
+#define EDP_MISC1_MISC0_CEA                                     0x00000008
+#define EDP_MISC1_MISC0_BT709_5                                 0x00000010
+#define EDP_MISC1_MISC0_COLOR__MASK                             0x000000e0
+#define EDP_MISC1_MISC0_COLOR__SHIFT                            5
+static inline uint32_t EDP_MISC1_MISC0_COLOR(enum edp_color_depth val)
+{
+        return ((val) << EDP_MISC1_MISC0_COLOR__SHIFT) & EDP_MISC1_MISC0_COLOR__MASK;
+}
+#define EDP_MISC1_MISC0_MISC1__MASK                             0x0000ff00
+#define EDP_MISC1_MISC0_MISC1__SHIFT                            8
+static inline uint32_t EDP_MISC1_MISC0_MISC1(uint32_t val)
+{
+        return ((val) << EDP_MISC1_MISC0_MISC1__SHIFT) & EDP_MISC1_MISC0_MISC1__MASK;
+}
+#define EDP_MISC1_MISC0_INTERLACED_ODD                          0x00000100
+#define EDP_MISC1_MISC0_STEREO__MASK                            0x00000600
+#define EDP_MISC1_MISC0_STEREO__SHIFT                           9
+static inline uint32_t EDP_MISC1_MISC0_STEREO(uint32_t val)
+{
+        return ((val) << EDP_MISC1_MISC0_STEREO__SHIFT) & EDP_MISC1_MISC0_STEREO__MASK;
+}
+
+#define REG_EDP_PHY_CTRL                                        0x00000074
+#define EDP_PHY_CTRL_SW_RESET_PLL                               0x00000001
+#define EDP_PHY_CTRL_SW_RESET                                   0x00000004
+
+#define REG_EDP_MAINLINK_READY                                  0x00000084
+#define EDP_MAINLINK_READY_TRAIN_PATTERN_1_READY                0x00000008
+#define EDP_MAINLINK_READY_TRAIN_PATTERN_2_READY                0x00000010
+#define EDP_MAINLINK_READY_TRAIN_PATTERN_3_READY                0x00000020
+
+#define REG_EDP_AUX_CTRL                                        0x00000300
+#define EDP_AUX_CTRL_ENABLE                                     0x00000001
+#define EDP_AUX_CTRL_RESET                                      0x00000002
+
+#define REG_EDP_INTERRUPT_REG_1                                 0x00000308
+#define EDP_INTERRUPT_REG_1_HPD                                 0x00000001
+#define EDP_INTERRUPT_REG_1_HPD_ACK                             0x00000002
+#define EDP_INTERRUPT_REG_1_HPD_EN                              0x00000004
+#define EDP_INTERRUPT_REG_1_AUX_I2C_DONE                        0x00000008
+#define EDP_INTERRUPT_REG_1_AUX_I2C_DONE_ACK                    0x00000010
+#define EDP_INTERRUPT_REG_1_AUX_I2C_DONE_EN                     0x00000020
+#define EDP_INTERRUPT_REG_1_WRONG_ADDR                          0x00000040
+#define EDP_INTERRUPT_REG_1_WRONG_ADDR_ACK                      0x00000080
+#define EDP_INTERRUPT_REG_1_WRONG_ADDR_EN                       0x00000100
+#define EDP_INTERRUPT_REG_1_TIMEOUT                             0x00000200
+#define EDP_INTERRUPT_REG_1_TIMEOUT_ACK                         0x00000400
+#define EDP_INTERRUPT_REG_1_TIMEOUT_EN                          0x00000800
+#define EDP_INTERRUPT_REG_1_NACK_DEFER                          0x00001000
+#define EDP_INTERRUPT_REG_1_NACK_DEFER_ACK                      0x00002000
+#define EDP_INTERRUPT_REG_1_NACK_DEFER_EN                       0x00004000
+#define EDP_INTERRUPT_REG_1_WRONG_DATA_CNT                      0x00008000
+#define EDP_INTERRUPT_REG_1_WRONG_DATA_CNT_ACK                  0x00010000
+#define EDP_INTERRUPT_REG_1_WRONG_DATA_CNT_EN                   0x00020000
+#define EDP_INTERRUPT_REG_1_I2C_NACK                            0x00040000
+#define EDP_INTERRUPT_REG_1_I2C_NACK_ACK                        0x00080000
+#define EDP_INTERRUPT_REG_1_I2C_NACK_EN                         0x00100000
+#define EDP_INTERRUPT_REG_1_I2C_DEFER                           0x00200000
+#define EDP_INTERRUPT_REG_1_I2C_DEFER_ACK                       0x00400000
+#define EDP_INTERRUPT_REG_1_I2C_DEFER_EN                        0x00800000
+#define EDP_INTERRUPT_REG_1_PLL_UNLOCK                          0x01000000
+#define EDP_INTERRUPT_REG_1_PLL_UNLOCK_ACK                      0x02000000
+#define EDP_INTERRUPT_REG_1_PLL_UNLOCK_EN                       0x04000000
+#define EDP_INTERRUPT_REG_1_AUX_ERROR                           0x08000000
+#define EDP_INTERRUPT_REG_1_AUX_ERROR_ACK                       0x10000000
+#define EDP_INTERRUPT_REG_1_AUX_ERROR_EN                        0x20000000
+
+#define REG_EDP_INTERRUPT_REG_2                                 0x0000030c
+#define EDP_INTERRUPT_REG_2_READY_FOR_VIDEO                     0x00000001
+#define EDP_INTERRUPT_REG_2_READY_FOR_VIDEO_ACK                 0x00000002
+#define EDP_INTERRUPT_REG_2_READY_FOR_VIDEO_EN                  0x00000004
+#define EDP_INTERRUPT_REG_2_IDLE_PATTERNs_SENT                  0x00000008
+#define EDP_INTERRUPT_REG_2_IDLE_PATTERNs_SENT_ACK              0x00000010
+#define EDP_INTERRUPT_REG_2_IDLE_PATTERNs_SENT_EN               0x00000020
+#define EDP_INTERRUPT_REG_2_FRAME_END                           0x00000200
+#define EDP_INTERRUPT_REG_2_FRAME_END_ACK                       0x00000080
+#define EDP_INTERRUPT_REG_2_FRAME_END_EN                        0x00000100
+#define EDP_INTERRUPT_REG_2_CRC_UPDATED                         0x00000200
+#define EDP_INTERRUPT_REG_2_CRC_UPDATED_ACK                     0x00000400
+#define EDP_INTERRUPT_REG_2_CRC_UPDATED_EN                      0x00000800
+
+#define REG_EDP_INTERRUPT_TRANS_NUM                             0x00000310
+
+#define REG_EDP_AUX_DATA                                        0x00000314
+#define EDP_AUX_DATA_READ                                       0x00000001
+#define EDP_AUX_DATA_DATA__MASK                                 0x0000ff00
+#define EDP_AUX_DATA_DATA__SHIFT                                8
+static inline uint32_t EDP_AUX_DATA_DATA(uint32_t val)
+{
+        return ((val) << EDP_AUX_DATA_DATA__SHIFT) & EDP_AUX_DATA_DATA__MASK;
+}
+#define EDP_AUX_DATA_INDEX__MASK                                0x00ff0000
+#define EDP_AUX_DATA_INDEX__SHIFT                               16
+static inline uint32_t EDP_AUX_DATA_INDEX(uint32_t val)
+{
+        return ((val) << EDP_AUX_DATA_INDEX__SHIFT) & EDP_AUX_DATA_INDEX__MASK;
+}
+#define EDP_AUX_DATA_INDEX_WRITE                                0x80000000
+
+#define REG_EDP_AUX_TRANS_CTRL                                  0x00000318
+#define EDP_AUX_TRANS_CTRL_I2C                                  0x00000100
+#define EDP_AUX_TRANS_CTRL_GO                                   0x00000200
+
+#define REG_EDP_AUX_STATUS                                      0x00000324
+
+static inline uint32_t REG_EDP_PHY_LN(uint32_t i0) { return 0x00000400 + 0x40*i0; }
+
+static inline uint32_t REG_EDP_PHY_LN_PD_CTL(uint32_t i0) { return 0x00000404 + 0x40*i0; }
+
+#define REG_EDP_PHY_GLB_VM_CFG0                                 0x00000510
+
+#define REG_EDP_PHY_GLB_VM_CFG1                                 0x00000514
+
+#define REG_EDP_PHY_GLB_MISC9                                   0x00000518
+
+#define REG_EDP_PHY_GLB_CFG                                     0x00000528
+
+#define REG_EDP_PHY_GLB_PD_CTL                                  0x0000052c
+
+#define REG_EDP_PHY_GLB_PHY_STATUS                              0x00000598
+
+
+#endif /* EDP_XML */
diff --git a/drivers/gpu/drm/msm/edp/edp_aux.c b/drivers/gpu/drm/msm/edp/edp_aux.c
new file mode 100644
index 000000000000..5f5a84f6074c
--- /dev/null
+++ b/drivers/gpu/drm/msm/edp/edp_aux.c
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "edp.h"
+#include "edp.xml.h"
+
+#define AUX_CMD_FIFO_LEN        144
+#define AUX_CMD_NATIVE_MAX      16
+#define AUX_CMD_I2C_MAX         128
+
+#define EDP_INTR_AUX_I2C_ERR    \
+        (EDP_INTERRUPT_REG_1_WRONG_ADDR | EDP_INTERRUPT_REG_1_TIMEOUT | \
+        EDP_INTERRUPT_REG_1_NACK_DEFER | EDP_INTERRUPT_REG_1_WRONG_DATA_CNT | \
+        EDP_INTERRUPT_REG_1_I2C_NACK | EDP_INTERRUPT_REG_1_I2C_DEFER)
+#define EDP_INTR_TRANS_STATUS   \
+        (EDP_INTERRUPT_REG_1_AUX_I2C_DONE | EDP_INTR_AUX_I2C_ERR)
+
+struct edp_aux {
+        void __iomem *base;
+        bool msg_err;
+
+        struct completion msg_comp;
+
+        /* To prevent the message transaction routine from reentry. */
+        struct mutex msg_mutex;
+
+        struct drm_dp_aux drm_aux;
+};
+#define to_edp_aux(x) container_of(x, struct edp_aux, drm_aux)
+
+static int edp_msg_fifo_tx(struct edp_aux *aux, struct drm_dp_aux_msg *msg)
+{
+        u32 data[4];
+        u32 reg, len;
+        bool native = msg->request & (DP_AUX_NATIVE_WRITE & DP_AUX_NATIVE_READ);
+        bool read = msg->request & (DP_AUX_I2C_READ & DP_AUX_NATIVE_READ);
+        u8 *msgdata = msg->buffer;
+        int i;
+
+        if (read)
+                len = 4;
+        else
+                len = msg->size + 4;
+
+        /*
+         * cmd fifo only has depth of 144 bytes
+         */
+        if (len > AUX_CMD_FIFO_LEN)
+                return -EINVAL;
+
+        /* Pack cmd and write to HW */
+        data[0] = (msg->address >> 16) & 0xf;   /* addr[19:16] */
+        if (read)
+                data[0] |=  BIT(4);             /* R/W */
+
+        data[1] = (msg->address >> 8) & 0xff;   /* addr[15:8] */
+        data[2] = msg->address & 0xff;          /* addr[7:0] */
+        data[3] = (msg->size - 1) & 0xff;       /* len[7:0] */
+
+        for (i = 0; i < len; i++) {
+                reg = (i < 4) ? data[i] : msgdata[i - 4];
+                reg = EDP_AUX_DATA_DATA(reg); /* index = 0, write */
+                if (i == 0)
+                        reg |= EDP_AUX_DATA_INDEX_WRITE;
+                edp_write(aux->base + REG_EDP_AUX_DATA, reg);
+        }
+
+        reg = 0; /* Transaction number is always 1 */
+        if (!native) /* i2c */
+                reg |= EDP_AUX_TRANS_CTRL_I2C;
+
+        reg |= EDP_AUX_TRANS_CTRL_GO;
+        edp_write(aux->base + REG_EDP_AUX_TRANS_CTRL, reg);
+
+        return 0;
+}
+
+static int edp_msg_fifo_rx(struct edp_aux *aux, struct drm_dp_aux_msg *msg)
+{
+        u32 data;
+        u8 *dp;
+        int i;
+        u32 len = msg->size;
+
+        edp_write(aux->base + REG_EDP_AUX_DATA,
+                EDP_AUX_DATA_INDEX_WRITE | EDP_AUX_DATA_READ); /* index = 0 */
+
+        dp = msg->buffer;
+
+        /* discard first byte */
+        data = edp_read(aux->base + REG_EDP_AUX_DATA);
+        for (i = 0; i < len; i++) {
+                data = edp_read(aux->base + REG_EDP_AUX_DATA);
+                dp[i] = (u8)((data >> 8) & 0xff);
+        }
+
+        return 0;
+}
+
+/*
+ * This function does the real job to process an AUX transaction.
+ * It will call msm_edp_aux_ctrl() function to reset the AUX channel,
+ * if the waiting is timeout.
+ * The caller who triggers the transaction should avoid the
+ * msm_edp_aux_ctrl() running concurrently in other threads, i.e.
+ * start transaction only when AUX channel is fully enabled.
+ */
+ssize_t edp_aux_transfer(struct drm_dp_aux *drm_aux, struct drm_dp_aux_msg *msg)
+{
+        struct edp_aux *aux = to_edp_aux(drm_aux);
+        ssize_t ret;
+        bool native = msg->request & (DP_AUX_NATIVE_WRITE & DP_AUX_NATIVE_READ);
+        bool read = msg->request & (DP_AUX_I2C_READ & DP_AUX_NATIVE_READ);
+
+        /* Ignore address only message */
+        if ((msg->size == 0) || (msg->buffer == NULL)) {
+                msg->reply = native ?
+                        DP_AUX_NATIVE_REPLY_ACK : DP_AUX_I2C_REPLY_ACK;
+                return msg->size;
+        }
+
+        /* msg sanity check */
+        if ((native && (msg->size > AUX_CMD_NATIVE_MAX)) ||
+                (msg->size > AUX_CMD_I2C_MAX)) {
+                pr_err("%s: invalid msg: size(%d), request(%x)\n",
+                        __func__, msg->size, msg->request);
+                return -EINVAL;
+        }
+
+        mutex_lock(&aux->msg_mutex);
+
+        aux->msg_err = false;
+        reinit_completion(&aux->msg_comp);
+
+        ret = edp_msg_fifo_tx(aux, msg);
+        if (ret < 0)
+                goto unlock_exit;
+
+        DBG("wait_for_completion");
+        ret = wait_for_completion_timeout(&aux->msg_comp, 300);
+        if (ret <= 0) {
+                /*
+                 * Clear GO and reset AUX channel
+                 * to cancel the current transaction.
+                 */
+                edp_write(aux->base + REG_EDP_AUX_TRANS_CTRL, 0);
+                msm_edp_aux_ctrl(aux, 1);
+                pr_err("%s: aux timeout, %d\n", __func__, ret);
+                goto unlock_exit;
+        }
+        DBG("completion");
+
+        if (!aux->msg_err) {
+                if (read) {
+                        ret = edp_msg_fifo_rx(aux, msg);
+                        if (ret < 0)
+                                goto unlock_exit;
+                }
+
+                msg->reply = native ?
+                        DP_AUX_NATIVE_REPLY_ACK : DP_AUX_I2C_REPLY_ACK;
+        } else {
+                /* Reply defer to retry */
+                msg->reply = native ?
+                        DP_AUX_NATIVE_REPLY_DEFER : DP_AUX_I2C_REPLY_DEFER;
+                /*
+                 * The sleep time in caller is not long enough to make sure
+                 * our H/W completes transactions. Add more defer time here.
+                 */
+                msleep(100);
+        }
+
+        /* Return requested size for success or retry */
+        ret = msg->size;
+
+unlock_exit:
+        mutex_unlock(&aux->msg_mutex);
+        return ret;
+}
+
+void *msm_edp_aux_init(struct device *dev, void __iomem *regbase,
+        struct drm_dp_aux **drm_aux)
+{
+        struct edp_aux *aux = NULL;
+        int ret;
+
+        DBG("");
+        aux = devm_kzalloc(dev, sizeof(*aux), GFP_KERNEL);
+        if (!aux)
+                return NULL;
+
+        aux->base = regbase;
+        mutex_init(&aux->msg_mutex);
+        init_completion(&aux->msg_comp);
+
+        aux->drm_aux.name = "msm_edp_aux";
+        aux->drm_aux.dev = dev;
+        aux->drm_aux.transfer = edp_aux_transfer;
+        ret = drm_dp_aux_register(&aux->drm_aux);
+        if (ret) {
+                pr_err("%s: failed to register drm aux: %d\n", __func__, ret);
+                mutex_destroy(&aux->msg_mutex);
+        }
+
+        if (drm_aux && aux)
+                *drm_aux = &aux->drm_aux;
+
+        return aux;
+}
+
+void msm_edp_aux_destroy(struct device *dev, struct edp_aux *aux)
+{
+        if (aux) {
+                drm_dp_aux_unregister(&aux->drm_aux);
+                mutex_destroy(&aux->msg_mutex);
+        }
+}
+
+irqreturn_t msm_edp_aux_irq(struct edp_aux *aux, u32 isr)
+{
+        if (isr & EDP_INTR_TRANS_STATUS) {
+                DBG("isr=%x", isr);
+                edp_write(aux->base + REG_EDP_AUX_TRANS_CTRL, 0);
+
+                if (isr & EDP_INTR_AUX_I2C_ERR)
+                        aux->msg_err = true;
+                else
+                        aux->msg_err = false;
+
+                complete(&aux->msg_comp);
+        }
+
+        return IRQ_HANDLED;
+}
+
+void msm_edp_aux_ctrl(struct edp_aux *aux, int enable)
+{
+        u32 data;
+
+        DBG("enable=%d", enable);
+        data = edp_read(aux->base + REG_EDP_AUX_CTRL);
+
+        if (enable) {
+                data |= EDP_AUX_CTRL_RESET;
+                edp_write(aux->base + REG_EDP_AUX_CTRL, data);
+                /* Make sure full reset */
+                wmb();
+                usleep_range(500, 1000);
+
+                data &= ~EDP_AUX_CTRL_RESET;
+                data |= EDP_AUX_CTRL_ENABLE;
+                edp_write(aux->base + REG_EDP_AUX_CTRL, data);
+        } else {
+                data &= ~EDP_AUX_CTRL_ENABLE;
+                edp_write(aux->base + REG_EDP_AUX_CTRL, data);
+        }
+}
+
diff --git a/drivers/gpu/drm/msm/edp/edp_bridge.c b/drivers/gpu/drm/msm/edp/edp_bridge.c
new file mode 100644
index 000000000000..2bc73f82f3f5
--- /dev/null
+++ b/drivers/gpu/drm/msm/edp/edp_bridge.c
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "edp.h"
+
+struct edp_bridge {
+        struct drm_bridge base;
+        struct msm_edp *edp;
+};
+#define to_edp_bridge(x) container_of(x, struct edp_bridge, base)
+
+void edp_bridge_destroy(struct drm_bridge *bridge)
+{
+}
+
+static void edp_bridge_pre_enable(struct drm_bridge *bridge)
+{
+        struct edp_bridge *edp_bridge = to_edp_bridge(bridge);
+        struct msm_edp *edp = edp_bridge->edp;
+
+        DBG("");
+        msm_edp_ctrl_power(edp->ctrl, true);
+}
+
+static void edp_bridge_enable(struct drm_bridge *bridge)
+{
+        DBG("");
+}
+
+static void edp_bridge_disable(struct drm_bridge *bridge)
+{
+        DBG("");
+}
+
+static void edp_bridge_post_disable(struct drm_bridge *bridge)
+{
+        struct edp_bridge *edp_bridge = to_edp_bridge(bridge);
+        struct msm_edp *edp = edp_bridge->edp;
+
+        DBG("");
+        msm_edp_ctrl_power(edp->ctrl, false);
+}
+
+static void edp_bridge_mode_set(struct drm_bridge *bridge,
+                struct drm_display_mode *mode,
+                struct drm_display_mode *adjusted_mode)
+{
+        struct drm_device *dev = bridge->dev;
+        struct drm_connector *connector;
+        struct edp_bridge *edp_bridge = to_edp_bridge(bridge);
+        struct msm_edp *edp = edp_bridge->edp;
+
+        DBG("set mode: %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x",
+                        mode->base.id, mode->name,
+                        mode->vrefresh, mode->clock,
+                        mode->hdisplay, mode->hsync_start,
+                        mode->hsync_end, mode->htotal,
+                        mode->vdisplay, mode->vsync_start,
+                        mode->vsync_end, mode->vtotal,
+                        mode->type, mode->flags);
+
+        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                if ((connector->encoder != NULL) &&
+                        (connector->encoder->bridge == bridge)) {
+                        msm_edp_ctrl_timing_cfg(edp->ctrl,
+                                adjusted_mode, &connector->display_info);
+                        break;
+                }
+        }
+}
+
+static const struct drm_bridge_funcs edp_bridge_funcs = {
+        .pre_enable = edp_bridge_pre_enable,
+        .enable = edp_bridge_enable,
+        .disable = edp_bridge_disable,
+        .post_disable = edp_bridge_post_disable,
+        .mode_set = edp_bridge_mode_set,
+};
+
+/* initialize bridge */
+struct drm_bridge *msm_edp_bridge_init(struct msm_edp *edp)
+{
+        struct drm_bridge *bridge = NULL;
+        struct edp_bridge *edp_bridge;
+        int ret;
+
+        edp_bridge = devm_kzalloc(edp->dev->dev,
+                        sizeof(*edp_bridge), GFP_KERNEL);
+        if (!edp_bridge) {
+                ret = -ENOMEM;
+                goto fail;
+        }
+
+        edp_bridge->edp = edp;
+
+        bridge = &edp_bridge->base;
+        bridge->funcs = &edp_bridge_funcs;
+
+        ret = drm_bridge_attach(edp->dev, bridge);
+        if (ret)
+                goto fail;
+
+        return bridge;
+
+fail:
+        if (bridge)
+                edp_bridge_destroy(bridge);
+
+        return ERR_PTR(ret);
+}
diff --git a/drivers/gpu/drm/msm/edp/edp_connector.c b/drivers/gpu/drm/msm/edp/edp_connector.c
new file mode 100644
index 000000000000..d8812e84da54
--- /dev/null
+++ b/drivers/gpu/drm/msm/edp/edp_connector.c
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "drm/drm_edid.h"
+#include "msm_kms.h"
+#include "edp.h"
+
+struct edp_connector {
+        struct drm_connector base;
+        struct msm_edp *edp;
+};
+#define to_edp_connector(x) container_of(x, struct edp_connector, base)
+
+static enum drm_connector_status edp_connector_detect(
+                struct drm_connector *connector, bool force)
+{
+        struct edp_connector *edp_connector = to_edp_connector(connector);
+        struct msm_edp *edp = edp_connector->edp;
+
+        DBG("");
+        return msm_edp_ctrl_panel_connected(edp->ctrl) ?
+                connector_status_connected : connector_status_disconnected;
+}
+
+static void edp_connector_destroy(struct drm_connector *connector)
+{
+        struct edp_connector *edp_connector = to_edp_connector(connector);
+
+        DBG("");
+        drm_connector_unregister(connector);
+        drm_connector_cleanup(connector);
+
+        kfree(edp_connector);
+}
+
+static int edp_connector_get_modes(struct drm_connector *connector)
+{
+        struct edp_connector *edp_connector = to_edp_connector(connector);
+        struct msm_edp *edp = edp_connector->edp;
+
+        struct edid *drm_edid = NULL;
+        int ret = 0;
+
+        DBG("");
+        ret = msm_edp_ctrl_get_panel_info(edp->ctrl, connector, &drm_edid);
+        if (ret)
+                return ret;
+
+        drm_mode_connector_update_edid_property(connector, drm_edid);
+        if (drm_edid)
+                ret = drm_add_edid_modes(connector, drm_edid);
+
+        return ret;
+}
+
+static int edp_connector_mode_valid(struct drm_connector *connector,
+                                 struct drm_display_mode *mode)
+{
+        struct edp_connector *edp_connector = to_edp_connector(connector);
+        struct msm_edp *edp = edp_connector->edp;
+        struct msm_drm_private *priv = connector->dev->dev_private;
+        struct msm_kms *kms = priv->kms;
+        long actual, requested;
+
+        requested = 1000 * mode->clock;
+        actual = kms->funcs->round_pixclk(kms,
+                        requested, edp_connector->edp->encoder);
+
+        DBG("requested=%ld, actual=%ld", requested, actual);
+        if (actual != requested)
+                return MODE_CLOCK_RANGE;
+
+        if (!msm_edp_ctrl_pixel_clock_valid(
+                edp->ctrl, mode->clock, NULL, NULL))
+                return MODE_CLOCK_RANGE;
+
+        /* Invalidate all modes if color format is not supported */
+        if (connector->display_info.bpc > 8)
+                return MODE_BAD;
+
+        return MODE_OK;
+}
+
+static struct drm_encoder *
+edp_connector_best_encoder(struct drm_connector *connector)
+{
+        struct edp_connector *edp_connector = to_edp_connector(connector);
+
+        DBG("");
+        return edp_connector->edp->encoder;
+}
+
+static const struct drm_connector_funcs edp_connector_funcs = {
+        .dpms = drm_atomic_helper_connector_dpms,
+        .detect = edp_connector_detect,
+        .fill_modes = drm_helper_probe_single_connector_modes,
+        .destroy = edp_connector_destroy,
+        .reset = drm_atomic_helper_connector_reset,
+        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
+        .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
+};
+
+static const struct drm_connector_helper_funcs edp_connector_helper_funcs = {
+        .get_modes = edp_connector_get_modes,
+        .mode_valid = edp_connector_mode_valid,
+        .best_encoder = edp_connector_best_encoder,
+};
+
+/* initialize connector */
+struct drm_connector *msm_edp_connector_init(struct msm_edp *edp)
+{
+        struct drm_connector *connector = NULL;
+        struct edp_connector *edp_connector;
+        int ret;
+
+        edp_connector = kzalloc(sizeof(*edp_connector), GFP_KERNEL);
+        if (!edp_connector) {
+                ret = -ENOMEM;
+                goto fail;
+        }
+
+        edp_connector->edp = edp;
+
+        connector = &edp_connector->base;
+
+        ret = drm_connector_init(edp->dev, connector, &edp_connector_funcs,
+                        DRM_MODE_CONNECTOR_eDP);
+        if (ret)
+                goto fail;
+
+        drm_connector_helper_add(connector, &edp_connector_helper_funcs);
+
+        /* We don't support HPD, so only poll status until connected. */
+        connector->polled = DRM_CONNECTOR_POLL_CONNECT;
+
+        /* Display driver doesn't support interlace now. */
+        connector->interlace_allowed = false;
+        connector->doublescan_allowed = false;
+
+        ret = drm_connector_register(connector);
+        if (ret)
+                goto fail;
+
+        return connector;
+
+fail:
+        if (connector)
+                edp_connector_destroy(connector);
+
+        return ERR_PTR(ret);
+}
diff --git a/drivers/gpu/drm/msm/edp/edp_ctrl.c b/drivers/gpu/drm/msm/edp/edp_ctrl.c
new file mode 100644
index 000000000000..3e246210c46f
--- /dev/null
+++ b/drivers/gpu/drm/msm/edp/edp_ctrl.c
@@ -0,0 +1,1373 @@
+/*
+ * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/clk.h>
+#include <linux/gpio/consumer.h>
+#include <linux/regulator/consumer.h>
+
+#include "drm_crtc.h"
+#include "drm_dp_helper.h"
+#include "drm_edid.h"
+#include "edp.h"
+#include "edp.xml.h"
+
+#define VDDA_MIN_UV             1800000 /* uV units */
+#define VDDA_MAX_UV             1800000 /* uV units */
+#define VDDA_UA_ON_LOAD         100000  /* uA units */
+#define VDDA_UA_OFF_LOAD        100     /* uA units */
+
+#define DPCD_LINK_VOLTAGE_MAX           4
+#define DPCD_LINK_PRE_EMPHASIS_MAX      4
+
+#define EDP_LINK_BW_MAX         DP_LINK_BW_2_7
+
+/* Link training return value */
+#define EDP_TRAIN_FAIL          -1
+#define EDP_TRAIN_SUCCESS       0
+#define EDP_TRAIN_RECONFIG      1
+
+#define EDP_CLK_MASK_AHB                BIT(0)
+#define EDP_CLK_MASK_AUX                BIT(1)
+#define EDP_CLK_MASK_LINK               BIT(2)
+#define EDP_CLK_MASK_PIXEL              BIT(3)
+#define EDP_CLK_MASK_MDP_CORE           BIT(4)
+#define EDP_CLK_MASK_LINK_CHAN  (EDP_CLK_MASK_LINK | EDP_CLK_MASK_PIXEL)
+#define EDP_CLK_MASK_AUX_CHAN   \
+        (EDP_CLK_MASK_AHB | EDP_CLK_MASK_AUX | EDP_CLK_MASK_MDP_CORE)
+#define EDP_CLK_MASK_ALL        (EDP_CLK_MASK_AUX_CHAN | EDP_CLK_MASK_LINK_CHAN)
+
+#define EDP_BACKLIGHT_MAX       255
+
+#define EDP_INTR_STATUS1        \
+        (EDP_INTERRUPT_REG_1_HPD | EDP_INTERRUPT_REG_1_AUX_I2C_DONE | \
+        EDP_INTERRUPT_REG_1_WRONG_ADDR | EDP_INTERRUPT_REG_1_TIMEOUT | \
+        EDP_INTERRUPT_REG_1_NACK_DEFER | EDP_INTERRUPT_REG_1_WRONG_DATA_CNT | \
+        EDP_INTERRUPT_REG_1_I2C_NACK | EDP_INTERRUPT_REG_1_I2C_DEFER | \
+        EDP_INTERRUPT_REG_1_PLL_UNLOCK | EDP_INTERRUPT_REG_1_AUX_ERROR)
+#define EDP_INTR_MASK1  (EDP_INTR_STATUS1 << 2)
+#define EDP_INTR_STATUS2        \
+        (EDP_INTERRUPT_REG_2_READY_FOR_VIDEO | \
+        EDP_INTERRUPT_REG_2_IDLE_PATTERNs_SENT | \
+        EDP_INTERRUPT_REG_2_FRAME_END | EDP_INTERRUPT_REG_2_CRC_UPDATED)
+#define EDP_INTR_MASK2  (EDP_INTR_STATUS2 << 2)
+
+struct edp_ctrl {
+        struct platform_device *pdev;
+
+        void __iomem *base;
+
+        /* regulators */
+        struct regulator *vdda_vreg;
+        struct regulator *lvl_vreg;
+
+        /* clocks */
+        struct clk *aux_clk;
+        struct clk *pixel_clk;
+        struct clk *ahb_clk;
+        struct clk *link_clk;
+        struct clk *mdp_core_clk;
+
+        /* gpios */
+        struct gpio_desc *panel_en_gpio;
+        struct gpio_desc *panel_hpd_gpio;
+
+        /* completion and mutex */
+        struct completion idle_comp;
+        struct mutex dev_mutex; /* To protect device power status */
+
+        /* work queue */
+        struct work_struct on_work;
+        struct work_struct off_work;
+        struct workqueue_struct *workqueue;
+
+        /* Interrupt register lock */
+        spinlock_t irq_lock;
+
+        bool edp_connected;
+        bool power_on;
+
+        /* edid raw data */
+        struct edid *edid;
+
+        struct drm_dp_link dp_link;
+        struct drm_dp_aux *drm_aux;
+
+        /* dpcd raw data */
+        u8 dpcd[DP_RECEIVER_CAP_SIZE];
+
+        /* Link status */
+        u8 link_rate;
+        u8 lane_cnt;
+        u8 v_level;
+        u8 p_level;
+
+        /* Timing status */
+        u8 interlaced;
+        u32 pixel_rate; /* in kHz */
+        u32 color_depth;
+
+        struct edp_aux *aux;
+        struct edp_phy *phy;
+};
+
+struct edp_pixel_clk_div {
+        u32 rate; /* in kHz */
+        u32 m;
+        u32 n;
+};
+
+#define EDP_PIXEL_CLK_NUM 8
+static const struct edp_pixel_clk_div clk_divs[2][EDP_PIXEL_CLK_NUM] = {
+        { /* Link clock = 162MHz, source clock = 810MHz */
+                {119000, 31,  211}, /* WSXGA+ 1680x1050@60Hz CVT */
+                {130250, 32,  199}, /* UXGA 1600x1200@60Hz CVT */
+                {148500, 11,  60},  /* FHD 1920x1080@60Hz */
+                {154000, 50,  263}, /* WUXGA 1920x1200@60Hz CVT */
+                {209250, 31,  120}, /* QXGA 2048x1536@60Hz CVT */
+                {268500, 119, 359}, /* WQXGA 2560x1600@60Hz CVT */
+                {138530, 33,  193}, /* AUO B116HAN03.0 Panel */
+                {141400, 48,  275}, /* AUO B133HTN01.2 Panel */
+        },
+        { /* Link clock = 270MHz, source clock = 675MHz */
+                {119000, 52,  295}, /* WSXGA+ 1680x1050@60Hz CVT */
+                {130250, 11,  57},  /* UXGA 1600x1200@60Hz CVT */
+                {148500, 11,  50},  /* FHD 1920x1080@60Hz */
+                {154000, 47,  206}, /* WUXGA 1920x1200@60Hz CVT */
+                {209250, 31,  100}, /* QXGA 2048x1536@60Hz CVT */
+                {268500, 107, 269}, /* WQXGA 2560x1600@60Hz CVT */
+                {138530, 63,  307}, /* AUO B116HAN03.0 Panel */
+                {141400, 53,  253}, /* AUO B133HTN01.2 Panel */
+        },
+};
+
+static int edp_clk_init(struct edp_ctrl *ctrl)
+{
+        struct device *dev = &ctrl->pdev->dev;
+        int ret;
+
+        ctrl->aux_clk = devm_clk_get(dev, "core_clk");
+        if (IS_ERR(ctrl->aux_clk)) {
+                ret = PTR_ERR(ctrl->aux_clk);
+                pr_err("%s: Can't find aux_clk, %d\n", __func__, ret);
+                ctrl->aux_clk = NULL;
+                return ret;
+        }
+
+        ctrl->pixel_clk = devm_clk_get(dev, "pixel_clk");
+        if (IS_ERR(ctrl->pixel_clk)) {
+                ret = PTR_ERR(ctrl->pixel_clk);
+                pr_err("%s: Can't find pixel_clk, %d\n", __func__, ret);
+                ctrl->pixel_clk = NULL;
+                return ret;
+        }
+
+        ctrl->ahb_clk = devm_clk_get(dev, "iface_clk");
+        if (IS_ERR(ctrl->ahb_clk)) {
+                ret = PTR_ERR(ctrl->ahb_clk);
+                pr_err("%s: Can't find ahb_clk, %d\n", __func__, ret);
+                ctrl->ahb_clk = NULL;
+                return ret;
+        }
+
+        ctrl->link_clk = devm_clk_get(dev, "link_clk");
+        if (IS_ERR(ctrl->link_clk)) {
+                ret = PTR_ERR(ctrl->link_clk);
+                pr_err("%s: Can't find link_clk, %d\n", __func__, ret);
+                ctrl->link_clk = NULL;
+                return ret;
+        }
+
+        /* need mdp core clock to receive irq */
+        ctrl->mdp_core_clk = devm_clk_get(dev, "mdp_core_clk");
+        if (IS_ERR(ctrl->mdp_core_clk)) {
+                ret = PTR_ERR(ctrl->mdp_core_clk);
+                pr_err("%s: Can't find mdp_core_clk, %d\n", __func__, ret);
+                ctrl->mdp_core_clk = NULL;
+                return ret;
+        }
+
+        return 0;
+}
+
+static int edp_clk_enable(struct edp_ctrl *ctrl, u32 clk_mask)
+{
+        int ret;
+
+        DBG("mask=%x", clk_mask);
+        /* ahb_clk should be enabled first */
+        if (clk_mask & EDP_CLK_MASK_AHB) {
+                ret = clk_prepare_enable(ctrl->ahb_clk);
+                if (ret) {
+                        pr_err("%s: Failed to enable ahb clk\n", __func__);
+                        goto f0;
+                }
+        }
+        if (clk_mask & EDP_CLK_MASK_AUX) {
+                ret = clk_set_rate(ctrl->aux_clk, 19200000);
+                if (ret) {
+                        pr_err("%s: Failed to set rate aux clk\n", __func__);
+                        goto f1;
+                }
+                ret = clk_prepare_enable(ctrl->aux_clk);
+                if (ret) {
+                        pr_err("%s: Failed to enable aux clk\n", __func__);
+                        goto f1;
+                }
+        }
+        /* Need to set rate and enable link_clk prior to pixel_clk */
+        if (clk_mask & EDP_CLK_MASK_LINK) {
+                DBG("edp->link_clk, set_rate %ld",
+                                (unsigned long)ctrl->link_rate * 27000000);
+                ret = clk_set_rate(ctrl->link_clk,
+                                (unsigned long)ctrl->link_rate * 27000000);
+                if (ret) {
+                        pr_err("%s: Failed to set rate to link clk\n",
+                                __func__);
+                        goto f2;
+                }
+
+                ret = clk_prepare_enable(ctrl->link_clk);
+                if (ret) {
+                        pr_err("%s: Failed to enable link clk\n", __func__);
+                        goto f2;
+                }
+        }
+        if (clk_mask & EDP_CLK_MASK_PIXEL) {
+                DBG("edp->pixel_clk, set_rate %ld",
+                                (unsigned long)ctrl->pixel_rate * 1000);
+                ret = clk_set_rate(ctrl->pixel_clk,
+                                (unsigned long)ctrl->pixel_rate * 1000);
+                if (ret) {
+                        pr_err("%s: Failed to set rate to pixel clk\n",
+                                __func__);
+                        goto f3;
+                }
+
+                ret = clk_prepare_enable(ctrl->pixel_clk);
+                if (ret) {
+                        pr_err("%s: Failed to enable pixel clk\n", __func__);
+                        goto f3;
+                }
+        }
+        if (clk_mask & EDP_CLK_MASK_MDP_CORE) {
+                ret = clk_prepare_enable(ctrl->mdp_core_clk);
+                if (ret) {
+                        pr_err("%s: Failed to enable mdp core clk\n", __func__);
+                        goto f4;
+                }
+        }
+
+        return 0;
+
+f4:
+        if (clk_mask & EDP_CLK_MASK_PIXEL)
+                clk_disable_unprepare(ctrl->pixel_clk);
+f3:
+        if (clk_mask & EDP_CLK_MASK_LINK)
+                clk_disable_unprepare(ctrl->link_clk);
+f2:
+        if (clk_mask & EDP_CLK_MASK_AUX)
+                clk_disable_unprepare(ctrl->aux_clk);
+f1:
+        if (clk_mask & EDP_CLK_MASK_AHB)
+                clk_disable_unprepare(ctrl->ahb_clk);
+f0:
+        return ret;
+}
+
+static void edp_clk_disable(struct edp_ctrl *ctrl, u32 clk_mask)
+{
+        if (clk_mask & EDP_CLK_MASK_MDP_CORE)
+                clk_disable_unprepare(ctrl->mdp_core_clk);
+        if (clk_mask & EDP_CLK_MASK_PIXEL)
+                clk_disable_unprepare(ctrl->pixel_clk);
+        if (clk_mask & EDP_CLK_MASK_LINK)
+                clk_disable_unprepare(ctrl->link_clk);
+        if (clk_mask & EDP_CLK_MASK_AUX)
+                clk_disable_unprepare(ctrl->aux_clk);
+        if (clk_mask & EDP_CLK_MASK_AHB)
+                clk_disable_unprepare(ctrl->ahb_clk);
+}
+
+static int edp_regulator_init(struct edp_ctrl *ctrl)
+{
+        struct device *dev = &ctrl->pdev->dev;
+
+        DBG("");
+        ctrl->vdda_vreg = devm_regulator_get(dev, "vdda");
+        if (IS_ERR(ctrl->vdda_vreg)) {
+                pr_err("%s: Could not get vdda reg, ret = %ld\n", __func__,
+                                PTR_ERR(ctrl->vdda_vreg));
+                ctrl->vdda_vreg = NULL;
+                return PTR_ERR(ctrl->vdda_vreg);
+        }
+        ctrl->lvl_vreg = devm_regulator_get(dev, "lvl-vdd");
+        if (IS_ERR(ctrl->lvl_vreg)) {
+                pr_err("Could not get lvl-vdd reg, %ld",
+                                PTR_ERR(ctrl->lvl_vreg));
+                ctrl->lvl_vreg = NULL;
+                return PTR_ERR(ctrl->lvl_vreg);
+        }
+
+        return 0;
+}
+
+static int edp_regulator_enable(struct edp_ctrl *ctrl)
+{
+        int ret;
+
+        ret = regulator_set_voltage(ctrl->vdda_vreg, VDDA_MIN_UV, VDDA_MAX_UV);
+        if (ret) {
+                pr_err("%s:vdda_vreg set_voltage failed, %d\n", __func__, ret);
+                goto vdda_set_fail;
+        }
+
+        ret = regulator_set_optimum_mode(ctrl->vdda_vreg, VDDA_UA_ON_LOAD);
+        if (ret < 0) {
+                pr_err("%s: vdda_vreg set regulator mode failed.\n", __func__);
+                goto vdda_set_fail;
+        }
+
+        ret = regulator_enable(ctrl->vdda_vreg);
+        if (ret) {
+                pr_err("%s: Failed to enable vdda_vreg regulator.\n", __func__);
+                goto vdda_enable_fail;
+        }
+
+        ret = regulator_enable(ctrl->lvl_vreg);
+        if (ret) {
+                pr_err("Failed to enable lvl-vdd reg regulator, %d", ret);
+                goto lvl_enable_fail;
+        }
+
+        DBG("exit");
+        return 0;
+
+lvl_enable_fail:
+        regulator_disable(ctrl->vdda_vreg);
+vdda_enable_fail:
+        regulator_set_optimum_mode(ctrl->vdda_vreg, VDDA_UA_OFF_LOAD);
+vdda_set_fail:
+        return ret;
+}
+
+static void edp_regulator_disable(struct edp_ctrl *ctrl)
+{
+        regulator_disable(ctrl->lvl_vreg);
+        regulator_disable(ctrl->vdda_vreg);
+        regulator_set_optimum_mode(ctrl->vdda_vreg, VDDA_UA_OFF_LOAD);
+}
+
+static int edp_gpio_config(struct edp_ctrl *ctrl)
+{
+        struct device *dev = &ctrl->pdev->dev;
+        int ret;
+
+        ctrl->panel_hpd_gpio = devm_gpiod_get(dev, "panel-hpd");
+        if (IS_ERR(ctrl->panel_hpd_gpio)) {
+                ret = PTR_ERR(ctrl->panel_hpd_gpio);
+                ctrl->panel_hpd_gpio = NULL;
+                pr_err("%s: cannot get panel-hpd-gpios, %d\n", __func__, ret);
+                return ret;
+        }
+
+        ret = gpiod_direction_input(ctrl->panel_hpd_gpio);
+        if (ret) {
+                pr_err("%s: Set direction for hpd failed, %d\n", __func__, ret);
+                return ret;
+        }
+
+        ctrl->panel_en_gpio = devm_gpiod_get(dev, "panel-en");
+        if (IS_ERR(ctrl->panel_en_gpio)) {
+                ret = PTR_ERR(ctrl->panel_en_gpio);
+                ctrl->panel_en_gpio = NULL;
+                pr_err("%s: cannot get panel-en-gpios, %d\n", __func__, ret);
+                return ret;
+        }
+
+        ret = gpiod_direction_output(ctrl->panel_en_gpio, 0);
+        if (ret) {
+                pr_err("%s: Set direction for panel_en failed, %d\n",
+                                __func__, ret);
+                return ret;
+        }
+
+        DBG("gpio on");
+
+        return 0;
+}
+
+static void edp_ctrl_irq_enable(struct edp_ctrl *ctrl, int enable)
+{
+        unsigned long flags;
+
+        DBG("%d", enable);
+        spin_lock_irqsave(&ctrl->irq_lock, flags);
+        if (enable) {
+                edp_write(ctrl->base + REG_EDP_INTERRUPT_REG_1, EDP_INTR_MASK1);
+                edp_write(ctrl->base + REG_EDP_INTERRUPT_REG_2, EDP_INTR_MASK2);
+        } else {
+                edp_write(ctrl->base + REG_EDP_INTERRUPT_REG_1, 0x0);
+                edp_write(ctrl->base + REG_EDP_INTERRUPT_REG_2, 0x0);
+        }
+        spin_unlock_irqrestore(&ctrl->irq_lock, flags);
+        DBG("exit");
+}
+
+static void edp_fill_link_cfg(struct edp_ctrl *ctrl)
+{
+        u32 prate;
+        u32 lrate;
+        u32 bpp;
+        u8 max_lane = ctrl->dp_link.num_lanes;
+        u8 lane;
+
+        prate = ctrl->pixel_rate;
+        bpp = ctrl->color_depth * 3;
+
+        /*
+         * By default, use the maximum link rate and minimum lane count,
+         * so that we can do rate down shift during link training.
+         */
+        ctrl->link_rate = drm_dp_link_rate_to_bw_code(ctrl->dp_link.rate);
+
+        prate *= bpp;
+        prate /= 8; /* in kByte */
+
+        lrate = 270000; /* in kHz */
+        lrate *= ctrl->link_rate;
+        lrate /= 10; /* in kByte, 10 bits --> 8 bits */
+
+        for (lane = 1; lane <= max_lane; lane <<= 1) {
+                if (lrate >= prate)
+                        break;
+                lrate <<= 1;
+        }
+
+        ctrl->lane_cnt = lane;
+        DBG("rate=%d lane=%d", ctrl->link_rate, ctrl->lane_cnt);
+}
+
+static void edp_config_ctrl(struct edp_ctrl *ctrl)
+{
+        u32 data;
+        enum edp_color_depth depth;
+
+        data = EDP_CONFIGURATION_CTRL_LANES(ctrl->lane_cnt - 1);
+
+        if (ctrl->dp_link.capabilities & DP_LINK_CAP_ENHANCED_FRAMING)
+                data |= EDP_CONFIGURATION_CTRL_ENHANCED_FRAMING;
+
+        depth = EDP_6BIT;
+        if (ctrl->color_depth == 8)
+                depth = EDP_8BIT;
+
+        data |= EDP_CONFIGURATION_CTRL_COLOR(depth);
+
+        if (!ctrl->interlaced)  /* progressive */
+                data |= EDP_CONFIGURATION_CTRL_PROGRESSIVE;
+
+        data |= (EDP_CONFIGURATION_CTRL_SYNC_CLK |
+                EDP_CONFIGURATION_CTRL_STATIC_MVID);
+
+        edp_write(ctrl->base + REG_EDP_CONFIGURATION_CTRL, data);
+}
+
+static void edp_state_ctrl(struct edp_ctrl *ctrl, u32 state)
+{
+        edp_write(ctrl->base + REG_EDP_STATE_CTRL, state);
+        /* Make sure H/W status is set */
+        wmb();
+}
+
+static int edp_lane_set_write(struct edp_ctrl *ctrl,
+        u8 voltage_level, u8 pre_emphasis_level)
+{
+        int i;
+        u8 buf[4];
+
+        if (voltage_level >= DPCD_LINK_VOLTAGE_MAX)
+                voltage_level |= 0x04;
+
+        if (pre_emphasis_level >= DPCD_LINK_PRE_EMPHASIS_MAX)
+                pre_emphasis_level |= 0x04;
+
+        pre_emphasis_level <<= 3;
+
+        for (i = 0; i < 4; i++)
+                buf[i] = voltage_level | pre_emphasis_level;
+
+        DBG("%s: p|v=0x%x", __func__, voltage_level | pre_emphasis_level);
+        if (drm_dp_dpcd_write(ctrl->drm_aux, 0x103, buf, 4) < 4) {
+                pr_err("%s: Set sw/pe to panel failed\n", __func__);
+                return -ENOLINK;
+        }
+
+        return 0;
+}
+
+static int edp_train_pattern_set_write(struct edp_ctrl *ctrl, u8 pattern)
+{
+        u8 p = pattern;
+
+        DBG("pattern=%x", p);
+        if (drm_dp_dpcd_write(ctrl->drm_aux,
+                                DP_TRAINING_PATTERN_SET, &p, 1) < 1) {
+                pr_err("%s: Set training pattern to panel failed\n", __func__);
+                return -ENOLINK;
+        }
+
+        return 0;
+}
+
+static void edp_sink_train_set_adjust(struct edp_ctrl *ctrl,
+        const u8 *link_status)
+{
+        int i;
+        u8 max = 0;
+        u8 data;
+
+        /* use the max level across lanes */
+        for (i = 0; i < ctrl->lane_cnt; i++) {
+                data = drm_dp_get_adjust_request_voltage(link_status, i);
+                DBG("lane=%d req_voltage_swing=0x%x", i, data);
+                if (max < data)
+                        max = data;
+        }
+
+        ctrl->v_level = max >> DP_TRAIN_VOLTAGE_SWING_SHIFT;
+
+        /* use the max level across lanes */
+        max = 0;
+        for (i = 0; i < ctrl->lane_cnt; i++) {
+                data = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
+                DBG("lane=%d req_pre_emphasis=0x%x", i, data);
+                if (max < data)
+                        max = data;
+        }
+
+        ctrl->p_level = max >> DP_TRAIN_PRE_EMPHASIS_SHIFT;
+        DBG("v_level=%d, p_level=%d", ctrl->v_level, ctrl->p_level);
+}
+
+static void edp_host_train_set(struct edp_ctrl *ctrl, u32 train)
+{
+        int cnt = 10;
+        u32 data;
+        u32 shift = train - 1;
+
+        DBG("train=%d", train);
+
+        edp_state_ctrl(ctrl, EDP_STATE_CTRL_TRAIN_PATTERN_1 << shift);
+        while (--cnt) {
+                data = edp_read(ctrl->base + REG_EDP_MAINLINK_READY);
+                if (data & (EDP_MAINLINK_READY_TRAIN_PATTERN_1_READY << shift))
+                        break;
+        }
+
+        if (cnt == 0)
+                pr_err("%s: set link_train=%d failed\n", __func__, train);
+}
+
+static const u8 vm_pre_emphasis[4][4] = {
+        {0x03, 0x06, 0x09, 0x0C},       /* pe0, 0 db */
+        {0x03, 0x06, 0x09, 0xFF},       /* pe1, 3.5 db */
+        {0x03, 0x06, 0xFF, 0xFF},       /* pe2, 6.0 db */
+        {0x03, 0xFF, 0xFF, 0xFF}        /* pe3, 9.5 db */
+};
+
+/* voltage swing, 0.2v and 1.0v are not support */
+static const u8 vm_voltage_swing[4][4] = {
+        {0x14, 0x18, 0x1A, 0x1E}, /* sw0, 0.4v  */
+        {0x18, 0x1A, 0x1E, 0xFF}, /* sw1, 0.6 v */
+        {0x1A, 0x1E, 0xFF, 0xFF}, /* sw1, 0.8 v */
+        {0x1E, 0xFF, 0xFF, 0xFF}  /* sw1, 1.2 v, optional */
+};
+
+static int edp_voltage_pre_emphasise_set(struct edp_ctrl *ctrl)
+{
+        u32 value0;
+        u32 value1;
+
+        DBG("v=%d p=%d", ctrl->v_level, ctrl->p_level);
+
+        value0 = vm_pre_emphasis[(int)(ctrl->v_level)][(int)(ctrl->p_level)];
+        value1 = vm_voltage_swing[(int)(ctrl->v_level)][(int)(ctrl->p_level)];
+
+        /* Configure host and panel only if both values are allowed */
+        if (value0 != 0xFF && value1 != 0xFF) {
+                msm_edp_phy_vm_pe_cfg(ctrl->phy, value0, value1);
+                return edp_lane_set_write(ctrl, ctrl->v_level, ctrl->p_level);
+        }
+
+        return -EINVAL;
+}
+
+static int edp_start_link_train_1(struct edp_ctrl *ctrl)
+{
+        u8 link_status[DP_LINK_STATUS_SIZE];
+        u8 old_v_level;
+        int tries;
+        int ret;
+        int rlen;
+
+        DBG("");
+
+        edp_host_train_set(ctrl, DP_TRAINING_PATTERN_1);
+        ret = edp_voltage_pre_emphasise_set(ctrl);
+        if (ret)
+                return ret;
+        ret = edp_train_pattern_set_write(ctrl,
+                        DP_TRAINING_PATTERN_1 | DP_RECOVERED_CLOCK_OUT_EN);
+        if (ret)
+                return ret;
+
+        tries = 0;
+        old_v_level = ctrl->v_level;
+        while (1) {
+                drm_dp_link_train_clock_recovery_delay(ctrl->dpcd);
+
+                rlen = drm_dp_dpcd_read_link_status(ctrl->drm_aux, link_status);
+                if (rlen < DP_LINK_STATUS_SIZE) {
+                        pr_err("%s: read link status failed\n", __func__);
+                        return -ENOLINK;
+                }
+                if (drm_dp_clock_recovery_ok(link_status, ctrl->lane_cnt)) {
+                        ret = 0;
+                        break;
+                }
+
+                if (ctrl->v_level == DPCD_LINK_VOLTAGE_MAX) {
+                        ret = -1;
+                        break;
+                }
+
+                if (old_v_level == ctrl->v_level) {
+                        tries++;
+                        if (tries >= 5) {
+                                ret = -1;
+                                break;
+                        }
+                } else {
+                        tries = 0;
+                        old_v_level = ctrl->v_level;
+                }
+
+                edp_sink_train_set_adjust(ctrl, link_status);
+                ret = edp_voltage_pre_emphasise_set(ctrl);
+                if (ret)
+                        return ret;
+        }
+
+        return ret;
+}
+
+static int edp_start_link_train_2(struct edp_ctrl *ctrl)
+{
+        u8 link_status[DP_LINK_STATUS_SIZE];
+        int tries = 0;
+        int ret;
+        int rlen;
+
+        DBG("");
+
+        edp_host_train_set(ctrl, DP_TRAINING_PATTERN_2);
+        ret = edp_voltage_pre_emphasise_set(ctrl);
+        if (ret)
+                return ret;
+
+        ret = edp_train_pattern_set_write(ctrl,
+                        DP_TRAINING_PATTERN_2 | DP_RECOVERED_CLOCK_OUT_EN);
+        if (ret)
+                return ret;
+
+        while (1) {
+                drm_dp_link_train_channel_eq_delay(ctrl->dpcd);
+
+                rlen = drm_dp_dpcd_read_link_status(ctrl->drm_aux, link_status);
+                if (rlen < DP_LINK_STATUS_SIZE) {
+                        pr_err("%s: read link status failed\n", __func__);
+                        return -ENOLINK;
+                }
+                if (drm_dp_channel_eq_ok(link_status, ctrl->lane_cnt)) {
+                        ret = 0;
+                        break;
+                }
+
+                tries++;
+                if (tries > 10) {
+                        ret = -1;
+                        break;
+                }
+
+                edp_sink_train_set_adjust(ctrl, link_status);
+                ret = edp_voltage_pre_emphasise_set(ctrl);
+                if (ret)
+                        return ret;
+        }
+
+        return ret;
+}
+
+static int edp_link_rate_down_shift(struct edp_ctrl *ctrl)
+{
+        u32 prate, lrate, bpp;
+        u8 rate, lane, max_lane;
+        int changed = 0;
+
+        rate = ctrl->link_rate;
+        lane = ctrl->lane_cnt;
+        max_lane = ctrl->dp_link.num_lanes;
+
+        bpp = ctrl->color_depth * 3;
+        prate = ctrl->pixel_rate;
+        prate *= bpp;
+        prate /= 8; /* in kByte */
+
+        if (rate > DP_LINK_BW_1_62 && rate <= EDP_LINK_BW_MAX) {
+                rate -= 4;      /* reduce rate */
+                changed++;
+        }
+
+        if (changed) {
+                if (lane >= 1 && lane < max_lane)
+                        lane <<= 1;     /* increase lane */
+
+                lrate = 270000; /* in kHz */
+                lrate *= rate;
+                lrate /= 10; /* kByte, 10 bits --> 8 bits */
+                lrate *= lane;
+
+                DBG("new lrate=%u prate=%u(kHz) rate=%d lane=%d p=%u b=%d",
+                        lrate, prate, rate, lane,
+                        ctrl->pixel_rate,
+                        bpp);
+
+                if (lrate > prate) {
+                        ctrl->link_rate = rate;
+                        ctrl->lane_cnt = lane;
+                        DBG("new rate=%d %d", rate, lane);
+                        return 0;
+                }
+        }
+
+        return -EINVAL;
+}
+
+static int edp_clear_training_pattern(struct edp_ctrl *ctrl)
+{
+        int ret;
+
+        ret = edp_train_pattern_set_write(ctrl, 0);
+
+        drm_dp_link_train_channel_eq_delay(ctrl->dpcd);
+
+        return ret;
+}
+
+static int edp_do_link_train(struct edp_ctrl *ctrl)
+{
+        int ret;
+        struct drm_dp_link dp_link;
+
+        DBG("");
+        /*
+         * Set the current link rate and lane cnt to panel. They may have been
+         * adjusted and the values are different from them in DPCD CAP
+         */
+        dp_link.num_lanes = ctrl->lane_cnt;
+        dp_link.rate = drm_dp_bw_code_to_link_rate(ctrl->link_rate);
+        dp_link.capabilities = ctrl->dp_link.capabilities;
+        if (drm_dp_link_configure(ctrl->drm_aux, &dp_link) < 0)
+                return EDP_TRAIN_FAIL;
+
+        ctrl->v_level = 0; /* start from default level */
+        ctrl->p_level = 0;
+
+        edp_state_ctrl(ctrl, 0);
+        if (edp_clear_training_pattern(ctrl))
+                return EDP_TRAIN_FAIL;
+
+        ret = edp_start_link_train_1(ctrl);
+        if (ret < 0) {
+                if (edp_link_rate_down_shift(ctrl) == 0) {
+                        DBG("link reconfig");
+                        ret = EDP_TRAIN_RECONFIG;
+                        goto clear;
+                } else {
+                        pr_err("%s: Training 1 failed", __func__);
+                        ret = EDP_TRAIN_FAIL;
+                        goto clear;
+                }
+        }
+        DBG("Training 1 completed successfully");
+
+        edp_state_ctrl(ctrl, 0);
+        if (edp_clear_training_pattern(ctrl))
+                return EDP_TRAIN_FAIL;
+
+        ret = edp_start_link_train_2(ctrl);
+        if (ret < 0) {
+                if (edp_link_rate_down_shift(ctrl) == 0) {
+                        DBG("link reconfig");
+                        ret = EDP_TRAIN_RECONFIG;
+                        goto clear;
+                } else {
+                        pr_err("%s: Training 2 failed", __func__);
+                        ret = EDP_TRAIN_FAIL;
+                        goto clear;
+                }
+        }
+        DBG("Training 2 completed successfully");
+
+        edp_state_ctrl(ctrl, EDP_STATE_CTRL_SEND_VIDEO);
+clear:
+        edp_clear_training_pattern(ctrl);
+
+        return ret;
+}
+
+static void edp_clock_synchrous(struct edp_ctrl *ctrl, int sync)
+{
+        u32 data;
+        enum edp_color_depth depth;
+
+        data = edp_read(ctrl->base + REG_EDP_MISC1_MISC0);
+
+        if (sync)
+                data |= EDP_MISC1_MISC0_SYNC;
+        else
+                data &= ~EDP_MISC1_MISC0_SYNC;
+
+        /* only legacy rgb mode supported */
+        depth = EDP_6BIT; /* Default */
+        if (ctrl->color_depth == 8)
+                depth = EDP_8BIT;
+        else if (ctrl->color_depth == 10)
+                depth = EDP_10BIT;
+        else if (ctrl->color_depth == 12)
+                depth = EDP_12BIT;
+        else if (ctrl->color_depth == 16)
+                depth = EDP_16BIT;
+
+        data |= EDP_MISC1_MISC0_COLOR(depth);
+
+        edp_write(ctrl->base + REG_EDP_MISC1_MISC0, data);
+}
+
+static int edp_sw_mvid_nvid(struct edp_ctrl *ctrl, u32 m, u32 n)
+{
+        u32 n_multi, m_multi = 5;
+
+        if (ctrl->link_rate == DP_LINK_BW_1_62) {
+                n_multi = 1;
+        } else if (ctrl->link_rate == DP_LINK_BW_2_7) {
+                n_multi = 2;
+        } else {
+                pr_err("%s: Invalid link rate, %d\n", __func__,
+                        ctrl->link_rate);
+                return -EINVAL;
+        }
+
+        edp_write(ctrl->base + REG_EDP_SOFTWARE_MVID, m * m_multi);
+        edp_write(ctrl->base + REG_EDP_SOFTWARE_NVID, n * n_multi);
+
+        return 0;
+}
+
+static void edp_mainlink_ctrl(struct edp_ctrl *ctrl, int enable)
+{
+        u32 data = 0;
+
+        edp_write(ctrl->base + REG_EDP_MAINLINK_CTRL, EDP_MAINLINK_CTRL_RESET);
+        /* Make sure fully reset */
+        wmb();
+        usleep_range(500, 1000);
+
+        if (enable)
+                data |= EDP_MAINLINK_CTRL_ENABLE;
+
+        edp_write(ctrl->base + REG_EDP_MAINLINK_CTRL, data);
+}
+
+static void edp_ctrl_phy_aux_enable(struct edp_ctrl *ctrl, int enable)
+{
+        if (enable) {
+                edp_regulator_enable(ctrl);
+                edp_clk_enable(ctrl, EDP_CLK_MASK_AUX_CHAN);
+                msm_edp_phy_ctrl(ctrl->phy, 1);
+                msm_edp_aux_ctrl(ctrl->aux, 1);
+                gpiod_set_value(ctrl->panel_en_gpio, 1);
+        } else {
+                gpiod_set_value(ctrl->panel_en_gpio, 0);
+                msm_edp_aux_ctrl(ctrl->aux, 0);
+                msm_edp_phy_ctrl(ctrl->phy, 0);
+                edp_clk_disable(ctrl, EDP_CLK_MASK_AUX_CHAN);
+                edp_regulator_disable(ctrl);
+        }
+}
+
+static void edp_ctrl_link_enable(struct edp_ctrl *ctrl, int enable)
+{
+        u32 m, n;
+
+        if (enable) {
+                /* Enable link channel clocks */
+                edp_clk_enable(ctrl, EDP_CLK_MASK_LINK_CHAN);
+
+                msm_edp_phy_lane_power_ctrl(ctrl->phy, true, ctrl->lane_cnt);
+
+                msm_edp_phy_vm_pe_init(ctrl->phy);
+
+                /* Make sure phy is programed */
+                wmb();
+                msm_edp_phy_ready(ctrl->phy);
+
+                edp_config_ctrl(ctrl);
+                msm_edp_ctrl_pixel_clock_valid(ctrl, ctrl->pixel_rate, &m, &n);
+                edp_sw_mvid_nvid(ctrl, m, n);
+                edp_mainlink_ctrl(ctrl, 1);
+        } else {
+                edp_mainlink_ctrl(ctrl, 0);
+
+                msm_edp_phy_lane_power_ctrl(ctrl->phy, false, 0);
+                edp_clk_disable(ctrl, EDP_CLK_MASK_LINK_CHAN);
+        }
+}
+
+static int edp_ctrl_training(struct edp_ctrl *ctrl)
+{
+        int ret;
+
+        /* Do link training only when power is on */
+        if (!ctrl->power_on)
+                return -EINVAL;
+
+train_start:
+        ret = edp_do_link_train(ctrl);
+        if (ret == EDP_TRAIN_RECONFIG) {
+                /* Re-configure main link */
+                edp_ctrl_irq_enable(ctrl, 0);
+                edp_ctrl_link_enable(ctrl, 0);
+                msm_edp_phy_ctrl(ctrl->phy, 0);
+
+                /* Make sure link is fully disabled */
+                wmb();
+                usleep_range(500, 1000);
+
+                msm_edp_phy_ctrl(ctrl->phy, 1);
+                edp_ctrl_link_enable(ctrl, 1);
+                edp_ctrl_irq_enable(ctrl, 1);
+                goto train_start;
+        }
+
+        return ret;
+}
+
+static void edp_ctrl_on_worker(struct work_struct *work)
+{
+        struct edp_ctrl *ctrl = container_of(
+                                work, struct edp_ctrl, on_work);
+        int ret;
+
+        mutex_lock(&ctrl->dev_mutex);
+
+        if (ctrl->power_on) {
+                DBG("already on");
+                goto unlock_ret;
+        }
+
+        edp_ctrl_phy_aux_enable(ctrl, 1);
+        edp_ctrl_link_enable(ctrl, 1);
+
+        edp_ctrl_irq_enable(ctrl, 1);
+        ret = drm_dp_link_power_up(ctrl->drm_aux, &ctrl->dp_link);
+        if (ret)
+                goto fail;
+
+        ctrl->power_on = true;
+
+        /* Start link training */
+        ret = edp_ctrl_training(ctrl);
+        if (ret != EDP_TRAIN_SUCCESS)
+                goto fail;
+
+        DBG("DONE");
+        goto unlock_ret;
+
+fail:
+        edp_ctrl_irq_enable(ctrl, 0);
+        edp_ctrl_link_enable(ctrl, 0);
+        edp_ctrl_phy_aux_enable(ctrl, 0);
+        ctrl->power_on = false;
+unlock_ret:
+        mutex_unlock(&ctrl->dev_mutex);
+}
+
+static void edp_ctrl_off_worker(struct work_struct *work)
+{
+        struct edp_ctrl *ctrl = container_of(
+                                work, struct edp_ctrl, off_work);
+        int ret;
+
+        mutex_lock(&ctrl->dev_mutex);
+
+        if (!ctrl->power_on) {
+                DBG("already off");
+                goto unlock_ret;
+        }
+
+        reinit_completion(&ctrl->idle_comp);
+        edp_state_ctrl(ctrl, EDP_STATE_CTRL_PUSH_IDLE);
+
+        ret = wait_for_completion_timeout(&ctrl->idle_comp,
+                                                msecs_to_jiffies(500));
+        if (ret <= 0)
+                DBG("%s: idle pattern timedout, %d\n",
+                                __func__, ret);
+
+        edp_state_ctrl(ctrl, 0);
+
+        drm_dp_link_power_down(ctrl->drm_aux, &ctrl->dp_link);
+
+        edp_ctrl_irq_enable(ctrl, 0);
+
+        edp_ctrl_link_enable(ctrl, 0);
+
+        edp_ctrl_phy_aux_enable(ctrl, 0);
+
+        ctrl->power_on = false;
+
+unlock_ret:
+        mutex_unlock(&ctrl->dev_mutex);
+}
+
+irqreturn_t msm_edp_ctrl_irq(struct edp_ctrl *ctrl)
+{
+        u32 isr1, isr2, mask1, mask2;
+        u32 ack;
+
+        DBG("");
+        spin_lock(&ctrl->irq_lock);
+        isr1 = edp_read(ctrl->base + REG_EDP_INTERRUPT_REG_1);
+        isr2 = edp_read(ctrl->base + REG_EDP_INTERRUPT_REG_2);
+
+        mask1 = isr1 & EDP_INTR_MASK1;
+        mask2 = isr2 & EDP_INTR_MASK2;
+
+        isr1 &= ~mask1; /* remove masks bit */
+        isr2 &= ~mask2;
+
+        DBG("isr=%x mask=%x isr2=%x mask2=%x",
+                        isr1, mask1, isr2, mask2);
+
+        ack = isr1 & EDP_INTR_STATUS1;
+        ack <<= 1;      /* ack bits */
+        ack |= mask1;
+        edp_write(ctrl->base + REG_EDP_INTERRUPT_REG_1, ack);
+
+        ack = isr2 & EDP_INTR_STATUS2;
+        ack <<= 1;      /* ack bits */
+        ack |= mask2;
+        edp_write(ctrl->base + REG_EDP_INTERRUPT_REG_2, ack);
+        spin_unlock(&ctrl->irq_lock);
+
+        if (isr1 & EDP_INTERRUPT_REG_1_HPD)
+                DBG("edp_hpd");
+
+        if (isr2 & EDP_INTERRUPT_REG_2_READY_FOR_VIDEO)
+                DBG("edp_video_ready");
+
+        if (isr2 & EDP_INTERRUPT_REG_2_IDLE_PATTERNs_SENT) {
+                DBG("idle_patterns_sent");
+                complete(&ctrl->idle_comp);
+        }
+
+        msm_edp_aux_irq(ctrl->aux, isr1);
+
+        return IRQ_HANDLED;
+}
+
+void msm_edp_ctrl_power(struct edp_ctrl *ctrl, bool on)
+{
+        if (on)
+                queue_work(ctrl->workqueue, &ctrl->on_work);
+        else
+                queue_work(ctrl->workqueue, &ctrl->off_work);
+}
+
+int msm_edp_ctrl_init(struct msm_edp *edp)
+{
+        struct edp_ctrl *ctrl = NULL;
+        struct device *dev = &edp->pdev->dev;
+        int ret;
+
+        if (!edp) {
+                pr_err("%s: edp is NULL!\n", __func__);
+                return -EINVAL;
+        }
+
+        ctrl = devm_kzalloc(dev, sizeof(*ctrl), GFP_KERNEL);
+        if (!ctrl)
+                return -ENOMEM;
+
+        edp->ctrl = ctrl;
+        ctrl->pdev = edp->pdev;
+
+        ctrl->base = msm_ioremap(ctrl->pdev, "edp", "eDP");
+        if (IS_ERR(ctrl->base))
+                return PTR_ERR(ctrl->base);
+
+        /* Get regulator, clock, gpio, pwm */
+        ret = edp_regulator_init(ctrl);
+        if (ret) {
+                pr_err("%s:regulator init fail\n", __func__);
+                return ret;
+        }
+        ret = edp_clk_init(ctrl);
+        if (ret) {
+                pr_err("%s:clk init fail\n", __func__);
+                return ret;
+        }
+        ret = edp_gpio_config(ctrl);
+        if (ret) {
+                pr_err("%s:failed to configure GPIOs: %d", __func__, ret);
+                return ret;
+        }
+
+        /* Init aux and phy */
+        ctrl->aux = msm_edp_aux_init(dev, ctrl->base, &ctrl->drm_aux);
+        if (!ctrl->aux || !ctrl->drm_aux) {
+                pr_err("%s:failed to init aux\n", __func__);
+                return ret;
+        }
+
+        ctrl->phy = msm_edp_phy_init(dev, ctrl->base);
+        if (!ctrl->phy) {
+                pr_err("%s:failed to init phy\n", __func__);
+                goto err_destory_aux;
+        }
+
+        spin_lock_init(&ctrl->irq_lock);
+        mutex_init(&ctrl->dev_mutex);
+        init_completion(&ctrl->idle_comp);
+
+        /* setup workqueue */
+        ctrl->workqueue = alloc_ordered_workqueue("edp_drm_work", 0);
+        INIT_WORK(&ctrl->on_work, edp_ctrl_on_worker);
+        INIT_WORK(&ctrl->off_work, edp_ctrl_off_worker);
+
+        return 0;
+
+err_destory_aux:
+        msm_edp_aux_destroy(dev, ctrl->aux);
+        ctrl->aux = NULL;
+        return ret;
+}
+
+void msm_edp_ctrl_destroy(struct edp_ctrl *ctrl)
+{
+        if (!ctrl)
+                return;
+
+        if (ctrl->workqueue) {
+                flush_workqueue(ctrl->workqueue);
+                destroy_workqueue(ctrl->workqueue);
+                ctrl->workqueue = NULL;
+        }
+
+        if (ctrl->aux) {
+                msm_edp_aux_destroy(&ctrl->pdev->dev, ctrl->aux);
+                ctrl->aux = NULL;
+        }
+
+        kfree(ctrl->edid);
+        ctrl->edid = NULL;
+
+        mutex_destroy(&ctrl->dev_mutex);
+}
+
+bool msm_edp_ctrl_panel_connected(struct edp_ctrl *ctrl)
+{
+        mutex_lock(&ctrl->dev_mutex);
+        DBG("connect status = %d", ctrl->edp_connected);
+        if (ctrl->edp_connected) {
+                mutex_unlock(&ctrl->dev_mutex);
+                return true;
+        }
+
+        if (!ctrl->power_on) {
+                edp_ctrl_phy_aux_enable(ctrl, 1);
+                edp_ctrl_irq_enable(ctrl, 1);
+        }
+
+        if (drm_dp_dpcd_read(ctrl->drm_aux, DP_DPCD_REV, ctrl->dpcd,
+                                DP_RECEIVER_CAP_SIZE) < DP_RECEIVER_CAP_SIZE) {
+                pr_err("%s: AUX channel is NOT ready\n", __func__);
+                memset(ctrl->dpcd, 0, DP_RECEIVER_CAP_SIZE);
+        } else {
+                ctrl->edp_connected = true;
+        }
+
+        if (!ctrl->power_on) {
+                edp_ctrl_irq_enable(ctrl, 0);
+                edp_ctrl_phy_aux_enable(ctrl, 0);
+        }
+
+        DBG("exit: connect status=%d", ctrl->edp_connected);
+
+        mutex_unlock(&ctrl->dev_mutex);
+
+        return ctrl->edp_connected;
+}
+
+int msm_edp_ctrl_get_panel_info(struct edp_ctrl *ctrl,
+                struct drm_connector *connector, struct edid **edid)
+{
+        int ret = 0;
+
+        mutex_lock(&ctrl->dev_mutex);
+
+        if (ctrl->edid) {
+                if (edid) {
+                        DBG("Just return edid buffer");
+                        *edid = ctrl->edid;
+                }
+                goto unlock_ret;
+        }
+
+        if (!ctrl->power_on) {
+                edp_ctrl_phy_aux_enable(ctrl, 1);
+                edp_ctrl_irq_enable(ctrl, 1);
+        }
+
+        ret = drm_dp_link_probe(ctrl->drm_aux, &ctrl->dp_link);
+        if (ret) {
+                pr_err("%s: read dpcd cap failed, %d\n", __func__, ret);
+                goto disable_ret;
+        }
+
+        /* Initialize link rate as panel max link rate */
+        ctrl->link_rate = drm_dp_link_rate_to_bw_code(ctrl->dp_link.rate);
+
+        ctrl->edid = drm_get_edid(connector, &ctrl->drm_aux->ddc);
+        if (!ctrl->edid) {
+                pr_err("%s: edid read fail\n", __func__);
+                goto disable_ret;
+        }
+
+        if (edid)
+                *edid = ctrl->edid;
+
+disable_ret:
+        if (!ctrl->power_on) {
+                edp_ctrl_irq_enable(ctrl, 0);
+                edp_ctrl_phy_aux_enable(ctrl, 0);
+        }
+unlock_ret:
+        mutex_unlock(&ctrl->dev_mutex);
+        return ret;
+}
+
+int msm_edp_ctrl_timing_cfg(struct edp_ctrl *ctrl,
+                                const struct drm_display_mode *mode,
+                                const struct drm_display_info *info)
+{
+        u32 hstart_from_sync, vstart_from_sync;
+        u32 data;
+        int ret = 0;
+
+        mutex_lock(&ctrl->dev_mutex);
+        /*
+         * Need to keep color depth, pixel rate and
+         * interlaced information in ctrl context
+         */
+        ctrl->color_depth = info->bpc;
+        ctrl->pixel_rate = mode->clock;
+        ctrl->interlaced = !!(mode->flags & DRM_MODE_FLAG_INTERLACE);
+
+        /* Fill initial link config based on passed in timing */
+        edp_fill_link_cfg(ctrl);
+
+        if (edp_clk_enable(ctrl, EDP_CLK_MASK_AHB)) {
+                pr_err("%s, fail to prepare enable ahb clk\n", __func__);
+                ret = -EINVAL;
+                goto unlock_ret;
+        }
+        edp_clock_synchrous(ctrl, 1);
+
+        /* Configure eDP timing to HW */
+        edp_write(ctrl->base + REG_EDP_TOTAL_HOR_VER,
+                EDP_TOTAL_HOR_VER_HORIZ(mode->htotal) |
+                EDP_TOTAL_HOR_VER_VERT(mode->vtotal));
+
+        vstart_from_sync = mode->vtotal - mode->vsync_start;
+        hstart_from_sync = mode->htotal - mode->hsync_start;
+        edp_write(ctrl->base + REG_EDP_START_HOR_VER_FROM_SYNC,
+                EDP_START_HOR_VER_FROM_SYNC_HORIZ(hstart_from_sync) |
+                EDP_START_HOR_VER_FROM_SYNC_VERT(vstart_from_sync));
+
+        data = EDP_HSYNC_VSYNC_WIDTH_POLARITY_VERT(
+                        mode->vsync_end - mode->vsync_start);
+        data |= EDP_HSYNC_VSYNC_WIDTH_POLARITY_HORIZ(
+                        mode->hsync_end - mode->hsync_start);
+        if (mode->flags & DRM_MODE_FLAG_NVSYNC)
+                data |= EDP_HSYNC_VSYNC_WIDTH_POLARITY_NVSYNC;
+        if (mode->flags & DRM_MODE_FLAG_NHSYNC)
+                data |= EDP_HSYNC_VSYNC_WIDTH_POLARITY_NHSYNC;
+        edp_write(ctrl->base + REG_EDP_HSYNC_VSYNC_WIDTH_POLARITY, data);
+
+        edp_write(ctrl->base + REG_EDP_ACTIVE_HOR_VER,
+                EDP_ACTIVE_HOR_VER_HORIZ(mode->hdisplay) |
+                EDP_ACTIVE_HOR_VER_VERT(mode->vdisplay));
+
+        edp_clk_disable(ctrl, EDP_CLK_MASK_AHB);
+
+unlock_ret:
+        mutex_unlock(&ctrl->dev_mutex);
+        return ret;
+}
+
+bool msm_edp_ctrl_pixel_clock_valid(struct edp_ctrl *ctrl,
+        u32 pixel_rate, u32 *pm, u32 *pn)
+{
+        const struct edp_pixel_clk_div *divs;
+        u32 err = 1; /* 1% error tolerance */
+        u32 clk_err;
+        int i;
+
+        if (ctrl->link_rate == DP_LINK_BW_1_62) {
+                divs = clk_divs[0];
+        } else if (ctrl->link_rate == DP_LINK_BW_2_7) {
+                divs = clk_divs[1];
+        } else {
+                pr_err("%s: Invalid link rate,%d\n", __func__, ctrl->link_rate);
+                return false;
+        }
+
+        for (i = 0; i < EDP_PIXEL_CLK_NUM; i++) {
+                clk_err = abs(divs[i].rate - pixel_rate);
+                if ((divs[i].rate * err / 100) >= clk_err) {
+                        if (pm)
+                                *pm = divs[i].m;
+                        if (pn)
+                                *pn = divs[i].n;
+                        return true;
+                }
+        }
+
+        DBG("pixel clock %d(kHz) not supported", pixel_rate);
+
+        return false;
+}
+
diff --git a/drivers/gpu/drm/msm/edp/edp_phy.c b/drivers/gpu/drm/msm/edp/edp_phy.c
new file mode 100644
index 000000000000..36bb8933e9ee
--- /dev/null
+++ b/drivers/gpu/drm/msm/edp/edp_phy.c
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "edp.h"
+#include "edp.xml.h"
+
+#define EDP_MAX_LANE    4
+
+struct edp_phy {
+        void __iomem *base;
+};
+
+bool msm_edp_phy_ready(struct edp_phy *phy)
+{
+        u32 status;
+        int cnt = 100;
+
+        while (--cnt) {
+                status = edp_read(phy->base +
+                                REG_EDP_PHY_GLB_PHY_STATUS);
+                if (status & 0x01)
+                        break;
+                usleep_range(500, 1000);
+        }
+
+        if (cnt == 0) {
+                pr_err("%s: PHY NOT ready\n", __func__);
+                return false;
+        } else {
+                return true;
+        }
+}
+
+void msm_edp_phy_ctrl(struct edp_phy *phy, int enable)
+{
+        DBG("enable=%d", enable);
+        if (enable) {
+                /* Reset */
+                edp_write(phy->base + REG_EDP_PHY_CTRL,
+                        EDP_PHY_CTRL_SW_RESET | EDP_PHY_CTRL_SW_RESET_PLL);
+                /* Make sure fully reset */
+                wmb();
+                usleep_range(500, 1000);
+                edp_write(phy->base + REG_EDP_PHY_CTRL, 0x000);
+                edp_write(phy->base + REG_EDP_PHY_GLB_PD_CTL, 0x3f);
+                edp_write(phy->base + REG_EDP_PHY_GLB_CFG, 0x1);
+        } else {
+                edp_write(phy->base + REG_EDP_PHY_GLB_PD_CTL, 0xc0);
+        }
+}
+
+/* voltage mode and pre emphasis cfg */
+void msm_edp_phy_vm_pe_init(struct edp_phy *phy)
+{
+        edp_write(phy->base + REG_EDP_PHY_GLB_VM_CFG0, 0x3);
+        edp_write(phy->base + REG_EDP_PHY_GLB_VM_CFG1, 0x64);
+        edp_write(phy->base + REG_EDP_PHY_GLB_MISC9, 0x6c);
+}
+
+void msm_edp_phy_vm_pe_cfg(struct edp_phy *phy, u32 v0, u32 v1)
+{
+        edp_write(phy->base + REG_EDP_PHY_GLB_VM_CFG0, v0);
+        edp_write(phy->base + REG_EDP_PHY_GLB_VM_CFG1, v1);
+}
+
+void msm_edp_phy_lane_power_ctrl(struct edp_phy *phy, bool up, u32 max_lane)
+{
+        u32 i;
+        u32 data;
+
+        if (up)
+                data = 0;       /* power up */
+        else
+                data = 0x7;     /* power down */
+
+        for (i = 0; i < max_lane; i++)
+                edp_write(phy->base + REG_EDP_PHY_LN_PD_CTL(i) , data);
+
+        /* power down unused lane */
+        data = 0x7;     /* power down */
+        for (i = max_lane; i < EDP_MAX_LANE; i++)
+                edp_write(phy->base + REG_EDP_PHY_LN_PD_CTL(i) , data);
+}
+
+void *msm_edp_phy_init(struct device *dev, void __iomem *regbase)
+{
+        struct edp_phy *phy = NULL;
+
+        phy = devm_kzalloc(dev, sizeof(*phy), GFP_KERNEL);
+        if (!phy)
+                return NULL;
+
+        phy->base = regbase;
+        return phy;
+}
+
diff --git a/drivers/gpu/drm/msm/hdmi/hdmi.c b/drivers/gpu/drm/msm/hdmi/hdmi.c
index 95f7b8d0f3ef..814536202efe 100644
--- a/drivers/gpu/drm/msm/hdmi/hdmi.c
+++ b/drivers/gpu/drm/msm/hdmi/hdmi.c
@@ -1,4 +1,5 @@
 /*
+ * Copyright (c) 2014 The Linux Foundation. All rights reserved.
  * Copyright (C) 2013 Red Hat
  * Author: Rob Clark <robdclark@gmail.com>
  *
@@ -106,7 +107,12 @@ static struct hdmi *hdmi_init(struct platform_device *pdev)
                 goto fail;
         }
 
-        BUG_ON(config->hpd_reg_cnt > ARRAY_SIZE(hdmi->hpd_regs));
+        hdmi->hpd_regs = devm_kzalloc(&pdev->dev, sizeof(hdmi->hpd_regs[0]) *
+                        config->hpd_reg_cnt, GFP_KERNEL);
+        if (!hdmi->hpd_regs) {
+                ret = -ENOMEM;
+                goto fail;
+        }
         for (i = 0; i < config->hpd_reg_cnt; i++) {
                 struct regulator *reg;
 
@@ -122,7 +128,12 @@ static struct hdmi *hdmi_init(struct platform_device *pdev)
                 hdmi->hpd_regs[i] = reg;
         }
 
-        BUG_ON(config->pwr_reg_cnt > ARRAY_SIZE(hdmi->pwr_regs));
+        hdmi->pwr_regs = devm_kzalloc(&pdev->dev, sizeof(hdmi->pwr_regs[0]) *
+                        config->pwr_reg_cnt, GFP_KERNEL);
+        if (!hdmi->pwr_regs) {
+                ret = -ENOMEM;
+                goto fail;
+        }
         for (i = 0; i < config->pwr_reg_cnt; i++) {
                 struct regulator *reg;
 
@@ -138,7 +149,12 @@ static struct hdmi *hdmi_init(struct platform_device *pdev)
                 hdmi->pwr_regs[i] = reg;
         }
 
-        BUG_ON(config->hpd_clk_cnt > ARRAY_SIZE(hdmi->hpd_clks));
+        hdmi->hpd_clks = devm_kzalloc(&pdev->dev, sizeof(hdmi->hpd_clks[0]) *
+                        config->hpd_clk_cnt, GFP_KERNEL);
+        if (!hdmi->hpd_clks) {
+                ret = -ENOMEM;
+                goto fail;
+        }
         for (i = 0; i < config->hpd_clk_cnt; i++) {
                 struct clk *clk;
 
@@ -153,7 +169,12 @@ static struct hdmi *hdmi_init(struct platform_device *pdev)
                 hdmi->hpd_clks[i] = clk;
         }
 
-        BUG_ON(config->pwr_clk_cnt > ARRAY_SIZE(hdmi->pwr_clks));
+        hdmi->pwr_clks = devm_kzalloc(&pdev->dev, sizeof(hdmi->pwr_clks[0]) *
+                        config->pwr_clk_cnt, GFP_KERNEL);
+        if (!hdmi->pwr_clks) {
+                ret = -ENOMEM;
+                goto fail;
+        }
         for (i = 0; i < config->pwr_clk_cnt; i++) {
                 struct clk *clk;
 
@@ -266,6 +287,57 @@ fail:
 
 #include <linux/of_gpio.h>
 
+#define HDMI_CFG(item, entry) \
+        .item ## _names = item ##_names_ ## entry, \
+        .item ## _cnt   = ARRAY_SIZE(item ## _names_ ## entry)
+
+static struct hdmi_platform_config hdmi_tx_8660_config = {
+                .phy_init = hdmi_phy_8x60_init,
+};
+
+static const char *hpd_reg_names_8960[] = {"core-vdda", "hdmi-mux"};
+static const char *hpd_clk_names_8960[] = {"core_clk", "master_iface_clk", "slave_iface_clk"};
+
+static struct hdmi_platform_config hdmi_tx_8960_config = {
+                .phy_init = hdmi_phy_8960_init,
+                HDMI_CFG(hpd_reg, 8960),
+                HDMI_CFG(hpd_clk, 8960),
+};
+
+static const char *pwr_reg_names_8x74[] = {"core-vdda", "core-vcc"};
+static const char *hpd_reg_names_8x74[] = {"hpd-gdsc", "hpd-5v"};
+static const char *pwr_clk_names_8x74[] = {"extp_clk", "alt_iface_clk"};
+static const char *hpd_clk_names_8x74[] = {"iface_clk", "core_clk", "mdp_core_clk"};
+static unsigned long hpd_clk_freq_8x74[] = {0, 19200000, 0};
+
+static struct hdmi_platform_config hdmi_tx_8074_config = {
+                .phy_init = hdmi_phy_8x74_init,
+                HDMI_CFG(pwr_reg, 8x74),
+                HDMI_CFG(hpd_reg, 8x74),
+                HDMI_CFG(pwr_clk, 8x74),
+                HDMI_CFG(hpd_clk, 8x74),
+                .hpd_freq      = hpd_clk_freq_8x74,
+};
+
+static const char *hpd_reg_names_8084[] = {"hpd-gdsc", "hpd-5v", "hpd-5v-en"};
+
+static struct hdmi_platform_config hdmi_tx_8084_config = {
+                .phy_init = hdmi_phy_8x74_init,
+                HDMI_CFG(pwr_reg, 8x74),
+                HDMI_CFG(hpd_reg, 8084),
+                HDMI_CFG(pwr_clk, 8x74),
+                HDMI_CFG(hpd_clk, 8x74),
+                .hpd_freq      = hpd_clk_freq_8x74,
+};
+
+static const struct of_device_id dt_match[] = {
+        { .compatible = "qcom,hdmi-tx-8084", .data = &hdmi_tx_8084_config },
+        { .compatible = "qcom,hdmi-tx-8074", .data = &hdmi_tx_8074_config },
+        { .compatible = "qcom,hdmi-tx-8960", .data = &hdmi_tx_8960_config },
+        { .compatible = "qcom,hdmi-tx-8660", .data = &hdmi_tx_8660_config },
+        {}
+};
+
 #ifdef CONFIG_OF
 static int get_gpio(struct device *dev, struct device_node *of_node, const char *name)
 {
@@ -288,50 +360,31 @@ static int hdmi_bind(struct device *dev, struct device *master, void *data)
 {
         struct drm_device *drm = dev_get_drvdata(master);
         struct msm_drm_private *priv = drm->dev_private;
-        static struct hdmi_platform_config config = {};
+        static struct hdmi_platform_config *hdmi_cfg;
         struct hdmi *hdmi;
 #ifdef CONFIG_OF
         struct device_node *of_node = dev->of_node;
+        const struct of_device_id *match;
 
-        if (of_device_is_compatible(of_node, "qcom,hdmi-tx-8074")) {
-                static const char *hpd_reg_names[] = {"hpd-gdsc", "hpd-5v"};
-                static const char *pwr_reg_names[] = {"core-vdda", "core-vcc"};
-                static const char *hpd_clk_names[] = {"iface_clk", "core_clk", "mdp_core_clk"};
-                static unsigned long hpd_clk_freq[] = {0, 19200000, 0};
-                static const char *pwr_clk_names[] = {"extp_clk", "alt_iface_clk"};
-                config.phy_init      = hdmi_phy_8x74_init;
-                config.hpd_reg_names = hpd_reg_names;
-                config.hpd_reg_cnt   = ARRAY_SIZE(hpd_reg_names);
-                config.pwr_reg_names = pwr_reg_names;
-                config.pwr_reg_cnt   = ARRAY_SIZE(pwr_reg_names);
-                config.hpd_clk_names = hpd_clk_names;
-                config.hpd_freq      = hpd_clk_freq;
-                config.hpd_clk_cnt   = ARRAY_SIZE(hpd_clk_names);
-                config.pwr_clk_names = pwr_clk_names;
-                config.pwr_clk_cnt   = ARRAY_SIZE(pwr_clk_names);
-        } else if (of_device_is_compatible(of_node, "qcom,hdmi-tx-8960")) {
-                static const char *hpd_clk_names[] = {"core_clk", "master_iface_clk", "slave_iface_clk"};
-                static const char *hpd_reg_names[] = {"core-vdda", "hdmi-mux"};
-                config.phy_init      = hdmi_phy_8960_init;
-                config.hpd_reg_names = hpd_reg_names;
-                config.hpd_reg_cnt   = ARRAY_SIZE(hpd_reg_names);
-                config.hpd_clk_names = hpd_clk_names;
-                config.hpd_clk_cnt   = ARRAY_SIZE(hpd_clk_names);
-        } else if (of_device_is_compatible(of_node, "qcom,hdmi-tx-8660")) {
-                config.phy_init      = hdmi_phy_8x60_init;
+        match = of_match_node(dt_match, of_node);
+        if (match && match->data) {
+                hdmi_cfg = (struct hdmi_platform_config *)match->data;
+                DBG("hdmi phy: %s", match->compatible);
         } else {
                 dev_err(dev, "unknown phy: %s\n", of_node->name);
+                return -ENXIO;
         }
 
-        config.mmio_name     = "core_physical";
-        config.ddc_clk_gpio  = get_gpio(dev, of_node, "qcom,hdmi-tx-ddc-clk");
-        config.ddc_data_gpio = get_gpio(dev, of_node, "qcom,hdmi-tx-ddc-data");
-        config.hpd_gpio      = get_gpio(dev, of_node, "qcom,hdmi-tx-hpd");
-        config.mux_en_gpio   = get_gpio(dev, of_node, "qcom,hdmi-tx-mux-en");
-        config.mux_sel_gpio  = get_gpio(dev, of_node, "qcom,hdmi-tx-mux-sel");
-        config.mux_lpm_gpio  = get_gpio(dev, of_node, "qcom,hdmi-tx-mux-lpm");
+        hdmi_cfg->mmio_name     = "core_physical";
+        hdmi_cfg->ddc_clk_gpio  = get_gpio(dev, of_node, "qcom,hdmi-tx-ddc-clk");
+        hdmi_cfg->ddc_data_gpio = get_gpio(dev, of_node, "qcom,hdmi-tx-ddc-data");
+        hdmi_cfg->hpd_gpio      = get_gpio(dev, of_node, "qcom,hdmi-tx-hpd");
+        hdmi_cfg->mux_en_gpio   = get_gpio(dev, of_node, "qcom,hdmi-tx-mux-en");
+        hdmi_cfg->mux_sel_gpio  = get_gpio(dev, of_node, "qcom,hdmi-tx-mux-sel");
+        hdmi_cfg->mux_lpm_gpio  = get_gpio(dev, of_node, "qcom,hdmi-tx-mux-lpm");
 
 #else
+        static struct hdmi_platform_config config = {};
         static const char *hpd_clk_names[] = {
                         "core_clk", "master_iface_clk", "slave_iface_clk",
         };
@@ -377,12 +430,15 @@ static int hdmi_bind(struct device *dev, struct device *master, void *data)
                 config.mux_en_gpio   = -1;
                 config.mux_sel_gpio  = -1;
         }
+        hdmi_cfg = &config;
 #endif
-        dev->platform_data = &config;
+        dev->platform_data = hdmi_cfg;
+
         hdmi = hdmi_init(to_platform_device(dev));
         if (IS_ERR(hdmi))
                 return PTR_ERR(hdmi);
         priv->hdmi = hdmi;
+
         return 0;
 }
 
@@ -413,13 +469,6 @@ static int hdmi_dev_remove(struct platform_device *pdev)
         return 0;
 }
 
-static const struct of_device_id dt_match[] = {
-        { .compatible = "qcom,hdmi-tx-8074" },
-        { .compatible = "qcom,hdmi-tx-8960" },
-        { .compatible = "qcom,hdmi-tx-8660" },
-        {}
-};
-
 static struct platform_driver hdmi_driver = {
         .probe = hdmi_dev_probe,
         .remove = hdmi_dev_remove,
diff --git a/drivers/gpu/drm/msm/hdmi/hdmi.h b/drivers/gpu/drm/msm/hdmi/hdmi.h
index 4d4cad42a776..68fdfb3622a5 100644
--- a/drivers/gpu/drm/msm/hdmi/hdmi.h
+++ b/drivers/gpu/drm/msm/hdmi/hdmi.h
@@ -52,10 +52,10 @@ struct hdmi {
 
         void __iomem *mmio;
 
-        struct regulator *hpd_regs[2];
-        struct regulator *pwr_regs[2];
-        struct clk *hpd_clks[3];
-        struct clk *pwr_clks[2];
+        struct regulator **hpd_regs;
+        struct regulator **pwr_regs;
+        struct clk **hpd_clks;
+        struct clk **pwr_clks;
 
         struct hdmi_phy *phy;
         struct i2c_adapter *i2c;
diff --git a/drivers/gpu/drm/msm/hdmi/hdmi.xml.h b/drivers/gpu/drm/msm/hdmi/hdmi.xml.h
index 5b0844befbab..350988740e9f 100644
--- a/drivers/gpu/drm/msm/hdmi/hdmi.xml.h
+++ b/drivers/gpu/drm/msm/hdmi/hdmi.xml.h
@@ -8,18 +8,19 @@ http://github.com/freedreno/envytools/
 git clone https://github.com/freedreno/envytools.git
 
 The rules-ng-ng source files this header was generated from are:
-- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    647 bytes, from 2013-11-30 14:45:35)
+- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    676 bytes, from 2014-12-05 15:34:49)
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml (   1453 bytes, from 2013-03-31 16:51:27)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20136 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   1940 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  23963 bytes, from 2014-10-31 16:51:46)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20908 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   2357 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  27208 bytes, from 2015-01-13 23:56:11)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/dsi.xml             (  11712 bytes, from 2013-08-17 17:13:43)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/sfpb.xml            (    344 bytes, from 2013-08-11 19:26:32)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1686 bytes, from 2014-10-31 16:48:57)
 - /home/robclark/src/freedreno/envytools/rnndb/hdmi/qfprom.xml         (    600 bytes, from 2013-07-05 19:21:12)
-- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  23613 bytes, from 2014-07-17 15:33:30)
+- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  26848 bytes, from 2015-01-13 23:55:57)
+- /home/robclark/src/freedreno/envytools/rnndb/edp/edp.xml             (   8253 bytes, from 2014-12-08 16:13:00)
 
-Copyright (C) 2013-2014 by the following authors:
+Copyright (C) 2013-2015 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
 
 Permission is hereby granted, free of charge, to any person obtaining
@@ -45,12 +46,14 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 
 enum hdmi_hdcp_key_state {
-        NO_KEYS = 0,
-        NOT_CHECKED = 1,
-        CHECKING = 2,
-        KEYS_VALID = 3,
-        AKSV_INVALID = 4,
-        CHECKSUM_MISMATCH = 5,
+        HDCP_KEYS_STATE_NO_KEYS = 0,
+        HDCP_KEYS_STATE_NOT_CHECKED = 1,
+        HDCP_KEYS_STATE_CHECKING = 2,
+        HDCP_KEYS_STATE_VALID = 3,
+        HDCP_KEYS_STATE_AKSV_NOT_VALID = 4,
+        HDCP_KEYS_STATE_CHKSUM_MISMATCH = 5,
+        HDCP_KEYS_STATE_PROD_AKSV = 6,
+        HDCP_KEYS_STATE_RESERVED = 7,
 };
 
 enum hdmi_ddc_read_write {
@@ -199,11 +202,29 @@ static inline uint32_t HDMI_AUDIO_INFO1_LSV(uint32_t val)
 #define HDMI_HDCP_CTRL_ENABLE                                   0x00000001
 #define HDMI_HDCP_CTRL_ENCRYPTION_ENABLE                        0x00000100
 
+#define REG_HDMI_HDCP_DEBUG_CTRL                                0x00000114
+#define HDMI_HDCP_DEBUG_CTRL_RNG_CIPHER                         0x00000004
+
 #define REG_HDMI_HDCP_INT_CTRL                                  0x00000118
+#define HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_INT                     0x00000001
+#define HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_ACK                     0x00000002
+#define HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_MASK                    0x00000004
+#define HDMI_HDCP_INT_CTRL_AUTH_FAIL_INT                        0x00000010
+#define HDMI_HDCP_INT_CTRL_AUTH_FAIL_ACK                        0x00000020
+#define HDMI_HDCP_INT_CTRL_AUTH_FAIL_MASK                       0x00000040
+#define HDMI_HDCP_INT_CTRL_AUTH_FAIL_INFO_ACK                   0x00000080
+#define HDMI_HDCP_INT_CTRL_AUTH_XFER_REQ_INT                    0x00000100
+#define HDMI_HDCP_INT_CTRL_AUTH_XFER_REQ_ACK                    0x00000200
+#define HDMI_HDCP_INT_CTRL_AUTH_XFER_REQ_MASK                   0x00000400
+#define HDMI_HDCP_INT_CTRL_AUTH_XFER_DONE_INT                   0x00001000
+#define HDMI_HDCP_INT_CTRL_AUTH_XFER_DONE_ACK                   0x00002000
+#define HDMI_HDCP_INT_CTRL_AUTH_XFER_DONE_MASK                  0x00004000
 
 #define REG_HDMI_HDCP_LINK0_STATUS                              0x0000011c
 #define HDMI_HDCP_LINK0_STATUS_AN_0_READY                       0x00000100
 #define HDMI_HDCP_LINK0_STATUS_AN_1_READY                       0x00000200
+#define HDMI_HDCP_LINK0_STATUS_RI_MATCHES                       0x00001000
+#define HDMI_HDCP_LINK0_STATUS_V_MATCHES                        0x00100000
 #define HDMI_HDCP_LINK0_STATUS_KEY_STATE__MASK                  0x70000000
 #define HDMI_HDCP_LINK0_STATUS_KEY_STATE__SHIFT                 28
 static inline uint32_t HDMI_HDCP_LINK0_STATUS_KEY_STATE(enum hdmi_hdcp_key_state val)
@@ -211,9 +232,56 @@ static inline uint32_t HDMI_HDCP_LINK0_STATUS_KEY_STATE(enum hdmi_hdcp_key_state
         return ((val) << HDMI_HDCP_LINK0_STATUS_KEY_STATE__SHIFT) & HDMI_HDCP_LINK0_STATUS_KEY_STATE__MASK;
 }
 
+#define REG_HDMI_HDCP_DDC_CTRL_0                                0x00000120
+#define HDMI_HDCP_DDC_CTRL_0_DISABLE                            0x00000001
+
+#define REG_HDMI_HDCP_DDC_CTRL_1                                0x00000124
+#define HDMI_HDCP_DDC_CTRL_1_FAILED_ACK                         0x00000001
+
+#define REG_HDMI_HDCP_DDC_STATUS                                0x00000128
+#define HDMI_HDCP_DDC_STATUS_XFER_REQ                           0x00000010
+#define HDMI_HDCP_DDC_STATUS_XFER_DONE                          0x00000400
+#define HDMI_HDCP_DDC_STATUS_ABORTED                            0x00001000
+#define HDMI_HDCP_DDC_STATUS_TIMEOUT                            0x00002000
+#define HDMI_HDCP_DDC_STATUS_NACK0                              0x00004000
+#define HDMI_HDCP_DDC_STATUS_NACK1                              0x00008000
+#define HDMI_HDCP_DDC_STATUS_FAILED                             0x00010000
+
+#define REG_HDMI_HDCP_ENTROPY_CTRL0                             0x0000012c
+
+#define REG_HDMI_HDCP_ENTROPY_CTRL1                             0x0000025c
+
 #define REG_HDMI_HDCP_RESET                                     0x00000130
 #define HDMI_HDCP_RESET_LINK0_DEAUTHENTICATE                    0x00000001
 
+#define REG_HDMI_HDCP_RCVPORT_DATA0                             0x00000134
+
+#define REG_HDMI_HDCP_RCVPORT_DATA1                             0x00000138
+
+#define REG_HDMI_HDCP_RCVPORT_DATA2_0                           0x0000013c
+
+#define REG_HDMI_HDCP_RCVPORT_DATA2_1                           0x00000140
+
+#define REG_HDMI_HDCP_RCVPORT_DATA3                             0x00000144
+
+#define REG_HDMI_HDCP_RCVPORT_DATA4                             0x00000148
+
+#define REG_HDMI_HDCP_RCVPORT_DATA5                             0x0000014c
+
+#define REG_HDMI_HDCP_RCVPORT_DATA6                             0x00000150
+
+#define REG_HDMI_HDCP_RCVPORT_DATA7                             0x00000154
+
+#define REG_HDMI_HDCP_RCVPORT_DATA8                             0x00000158
+
+#define REG_HDMI_HDCP_RCVPORT_DATA9                             0x0000015c
+
+#define REG_HDMI_HDCP_RCVPORT_DATA10                            0x00000160
+
+#define REG_HDMI_HDCP_RCVPORT_DATA11                            0x00000164
+
+#define REG_HDMI_HDCP_RCVPORT_DATA12                            0x00000168
+
 #define REG_HDMI_VENSPEC_INFO0                                  0x0000016c
 
 #define REG_HDMI_VENSPEC_INFO1                                  0x00000170
@@ -266,6 +334,7 @@ static inline uint32_t HDMI_DDC_CTRL_TRANSACTION_CNT(uint32_t val)
 #define HDMI_DDC_SW_STATUS_NACK3                                0x00008000
 
 #define REG_HDMI_DDC_HW_STATUS                                  0x0000021c
+#define HDMI_DDC_HW_STATUS_DONE                                 0x00000008
 
 #define REG_HDMI_DDC_SPEED                                      0x00000220
 #define HDMI_DDC_SPEED_THRESHOLD__MASK                          0x00000003
@@ -329,6 +398,15 @@ static inline uint32_t HDMI_DDC_DATA_INDEX(uint32_t val)
 }
 #define HDMI_DDC_DATA_INDEX_WRITE                               0x80000000
 
+#define REG_HDMI_HDCP_SHA_CTRL                                  0x0000023c
+
+#define REG_HDMI_HDCP_SHA_STATUS                                0x00000240
+#define HDMI_HDCP_SHA_STATUS_BLOCK_DONE                         0x00000001
+#define HDMI_HDCP_SHA_STATUS_COMP_DONE                          0x00000010
+
+#define REG_HDMI_HDCP_SHA_DATA                                  0x00000244
+#define HDMI_HDCP_SHA_DATA_DONE                                 0x00000001
+
 #define REG_HDMI_HPD_INT_STATUS                                 0x00000250
 #define HDMI_HPD_INT_STATUS_INT                                 0x00000001
 #define HDMI_HPD_INT_STATUS_CABLE_DETECTED                      0x00000002
@@ -359,6 +437,10 @@ static inline uint32_t HDMI_DDC_REF_REFTIMER(uint32_t val)
         return ((val) << HDMI_DDC_REF_REFTIMER__SHIFT) & HDMI_DDC_REF_REFTIMER__MASK;
 }
 
+#define REG_HDMI_HDCP_SW_UPPER_AKSV                             0x00000284
+
+#define REG_HDMI_HDCP_SW_LOWER_AKSV                             0x00000288
+
 #define REG_HDMI_CEC_STATUS                                     0x00000298
 
 #define REG_HDMI_CEC_INT                                        0x0000029c
diff --git a/drivers/gpu/drm/msm/hdmi/hdmi_bridge.c b/drivers/gpu/drm/msm/hdmi/hdmi_bridge.c
index d6f8d5818e18..a7a1d8267cf0 100644
--- a/drivers/gpu/drm/msm/hdmi/hdmi_bridge.c
+++ b/drivers/gpu/drm/msm/hdmi/hdmi_bridge.c
@@ -25,8 +25,6 @@ struct hdmi_bridge {
 
 void hdmi_bridge_destroy(struct drm_bridge *bridge)
 {
-        struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
-        kfree(hdmi_bridge);
 }
 
 static void power_on(struct drm_bridge *bridge)
@@ -209,7 +207,8 @@ struct drm_bridge *hdmi_bridge_init(struct hdmi *hdmi)
         struct hdmi_bridge *hdmi_bridge;
         int ret;
 
-        hdmi_bridge = kzalloc(sizeof(*hdmi_bridge), GFP_KERNEL);
+        hdmi_bridge = devm_kzalloc(hdmi->dev->dev,
+                        sizeof(*hdmi_bridge), GFP_KERNEL);
         if (!hdmi_bridge) {
                 ret = -ENOMEM;
                 goto fail;
@@ -220,7 +219,9 @@ struct drm_bridge *hdmi_bridge_init(struct hdmi *hdmi)
         bridge = &hdmi_bridge->base;
         bridge->funcs = &hdmi_bridge_funcs;
 
-        drm_bridge_attach(hdmi->dev, bridge);
+        ret = drm_bridge_attach(hdmi->dev, bridge);
+        if (ret)
+                goto fail;
 
         return bridge;
 
diff --git a/drivers/gpu/drm/msm/hdmi/hdmi_connector.c b/drivers/gpu/drm/msm/hdmi/hdmi_connector.c
index b4e70e0e3cfa..b62cdb968614 100644
--- a/drivers/gpu/drm/msm/hdmi/hdmi_connector.c
+++ b/drivers/gpu/drm/msm/hdmi/hdmi_connector.c
@@ -386,7 +386,7 @@ hdmi_connector_best_encoder(struct drm_connector *connector)
 }
 
 static const struct drm_connector_funcs hdmi_connector_funcs = {
-        .dpms = drm_helper_connector_dpms,
+        .dpms = drm_atomic_helper_connector_dpms,
         .detect = hdmi_connector_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .destroy = hdmi_connector_destroy,
@@ -426,7 +426,7 @@ struct drm_connector *hdmi_connector_init(struct hdmi *hdmi)
         connector->polled = DRM_CONNECTOR_POLL_CONNECT |
                         DRM_CONNECTOR_POLL_DISCONNECT;
 
-        connector->interlace_allowed = 1;
+        connector->interlace_allowed = 0;
         connector->doublescan_allowed = 0;
 
         drm_connector_register(connector);
diff --git a/drivers/gpu/drm/msm/hdmi/qfprom.xml.h b/drivers/gpu/drm/msm/hdmi/qfprom.xml.h
index 29bd796797de..43bb54a9afbf 100644
--- a/drivers/gpu/drm/msm/hdmi/qfprom.xml.h
+++ b/drivers/gpu/drm/msm/hdmi/qfprom.xml.h
@@ -8,16 +8,17 @@ http://github.com/freedreno/envytools/
 git clone https://github.com/freedreno/envytools.git
 
 The rules-ng-ng source files this header was generated from are:
-- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    647 bytes, from 2013-11-30 14:45:35)
+- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    676 bytes, from 2014-12-05 15:34:49)
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml (   1453 bytes, from 2013-03-31 16:51:27)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20136 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   1940 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  23963 bytes, from 2014-10-31 16:51:46)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20908 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   2357 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  27208 bytes, from 2015-01-13 23:56:11)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/dsi.xml             (  11712 bytes, from 2013-08-17 17:13:43)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/sfpb.xml            (    344 bytes, from 2013-08-11 19:26:32)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1686 bytes, from 2014-10-31 16:48:57)
 - /home/robclark/src/freedreno/envytools/rnndb/hdmi/qfprom.xml         (    600 bytes, from 2013-07-05 19:21:12)
-- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  23613 bytes, from 2014-07-17 15:33:30)
+- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  26848 bytes, from 2015-01-13 23:55:57)
+- /home/robclark/src/freedreno/envytools/rnndb/edp/edp.xml             (   8253 bytes, from 2014-12-08 16:13:00)
 
 Copyright (C) 2013 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
diff --git a/drivers/gpu/drm/msm/mdp/mdp4/mdp4.xml.h b/drivers/gpu/drm/msm/mdp/mdp4/mdp4.xml.h
index a4a7f8c7122a..1d39174d91fb 100644
--- a/drivers/gpu/drm/msm/mdp/mdp4/mdp4.xml.h
+++ b/drivers/gpu/drm/msm/mdp/mdp4/mdp4.xml.h
@@ -8,16 +8,17 @@ http://github.com/freedreno/envytools/
 git clone https://github.com/freedreno/envytools.git
 
 The rules-ng-ng source files this header was generated from are:
-- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    647 bytes, from 2013-11-30 14:45:35)
+- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    676 bytes, from 2014-12-05 15:34:49)
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml (   1453 bytes, from 2013-03-31 16:51:27)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20136 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   1940 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  23963 bytes, from 2014-10-31 16:51:46)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20908 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   2357 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  27208 bytes, from 2015-01-13 23:56:11)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/dsi.xml             (  11712 bytes, from 2013-08-17 17:13:43)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/sfpb.xml            (    344 bytes, from 2013-08-11 19:26:32)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1686 bytes, from 2014-10-31 16:48:57)
 - /home/robclark/src/freedreno/envytools/rnndb/hdmi/qfprom.xml         (    600 bytes, from 2013-07-05 19:21:12)
-- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  23613 bytes, from 2014-07-17 15:33:30)
+- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  26848 bytes, from 2015-01-13 23:55:57)
+- /home/robclark/src/freedreno/envytools/rnndb/edp/edp.xml             (   8253 bytes, from 2014-12-08 16:13:00)
 
 Copyright (C) 2013-2014 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
@@ -72,6 +73,18 @@ enum mdp4_cursor_format {
         CURSOR_XRGB = 2,
 };
 
+enum mdp4_frame_format {
+        FRAME_LINEAR = 0,
+        FRAME_TILE_ARGB_4X4 = 1,
+        FRAME_TILE_YCBCR_420 = 2,
+};
+
+enum mdp4_scale_unit {
+        SCALE_FIR = 0,
+        SCALE_MN_PHASE = 1,
+        SCALE_PIXEL_RPT = 2,
+};
+
 enum mdp4_dma {
         DMA_P = 0,
         DMA_S = 1,
@@ -637,6 +650,8 @@ static inline uint32_t REG_MDP4_PIPE_SRCP1_BASE(enum mdp4_pipe i0) { return 0x00
 
 static inline uint32_t REG_MDP4_PIPE_SRCP2_BASE(enum mdp4_pipe i0) { return 0x00020018 + 0x10000*i0; }
 
+static inline uint32_t REG_MDP4_PIPE_SRCP3_BASE(enum mdp4_pipe i0) { return 0x0002001c + 0x10000*i0; }
+
 static inline uint32_t REG_MDP4_PIPE_SRC_STRIDE_A(enum mdp4_pipe i0) { return 0x00020040 + 0x10000*i0; }
 #define MDP4_PIPE_SRC_STRIDE_A_P0__MASK                         0x0000ffff
 #define MDP4_PIPE_SRC_STRIDE_A_P0__SHIFT                        0
@@ -720,7 +735,25 @@ static inline uint32_t MDP4_PIPE_SRC_FORMAT_UNPACK_COUNT(uint32_t val)
 }
 #define MDP4_PIPE_SRC_FORMAT_UNPACK_TIGHT                       0x00020000
 #define MDP4_PIPE_SRC_FORMAT_UNPACK_ALIGN_MSB                   0x00040000
+#define MDP4_PIPE_SRC_FORMAT_FETCH_PLANES__MASK                 0x00180000
+#define MDP4_PIPE_SRC_FORMAT_FETCH_PLANES__SHIFT                19
+static inline uint32_t MDP4_PIPE_SRC_FORMAT_FETCH_PLANES(uint32_t val)
+{
+        return ((val) << MDP4_PIPE_SRC_FORMAT_FETCH_PLANES__SHIFT) & MDP4_PIPE_SRC_FORMAT_FETCH_PLANES__MASK;
+}
 #define MDP4_PIPE_SRC_FORMAT_SOLID_FILL                         0x00400000
+#define MDP4_PIPE_SRC_FORMAT_CHROMA_SAMP__MASK                  0x0c000000
+#define MDP4_PIPE_SRC_FORMAT_CHROMA_SAMP__SHIFT                 26
+static inline uint32_t MDP4_PIPE_SRC_FORMAT_CHROMA_SAMP(enum mdp_chroma_samp_type val)
+{
+        return ((val) << MDP4_PIPE_SRC_FORMAT_CHROMA_SAMP__SHIFT) & MDP4_PIPE_SRC_FORMAT_CHROMA_SAMP__MASK;
+}
+#define MDP4_PIPE_SRC_FORMAT_FRAME_FORMAT__MASK                 0x60000000
+#define MDP4_PIPE_SRC_FORMAT_FRAME_FORMAT__SHIFT                29
+static inline uint32_t MDP4_PIPE_SRC_FORMAT_FRAME_FORMAT(enum mdp4_frame_format val)
+{
+        return ((val) << MDP4_PIPE_SRC_FORMAT_FRAME_FORMAT__SHIFT) & MDP4_PIPE_SRC_FORMAT_FRAME_FORMAT__MASK;
+}
 
 static inline uint32_t REG_MDP4_PIPE_SRC_UNPACK(enum mdp4_pipe i0) { return 0x00020054 + 0x10000*i0; }
 #define MDP4_PIPE_SRC_UNPACK_ELEM0__MASK                        0x000000ff
@@ -751,6 +784,18 @@ static inline uint32_t MDP4_PIPE_SRC_UNPACK_ELEM3(uint32_t val)
 static inline uint32_t REG_MDP4_PIPE_OP_MODE(enum mdp4_pipe i0) { return 0x00020058 + 0x10000*i0; }
 #define MDP4_PIPE_OP_MODE_SCALEX_EN                             0x00000001
 #define MDP4_PIPE_OP_MODE_SCALEY_EN                             0x00000002
+#define MDP4_PIPE_OP_MODE_SCALEX_UNIT_SEL__MASK                 0x0000000c
+#define MDP4_PIPE_OP_MODE_SCALEX_UNIT_SEL__SHIFT                2
+static inline uint32_t MDP4_PIPE_OP_MODE_SCALEX_UNIT_SEL(enum mdp4_scale_unit val)
+{
+        return ((val) << MDP4_PIPE_OP_MODE_SCALEX_UNIT_SEL__SHIFT) & MDP4_PIPE_OP_MODE_SCALEX_UNIT_SEL__MASK;
+}
+#define MDP4_PIPE_OP_MODE_SCALEY_UNIT_SEL__MASK                 0x00000030
+#define MDP4_PIPE_OP_MODE_SCALEY_UNIT_SEL__SHIFT                4
+static inline uint32_t MDP4_PIPE_OP_MODE_SCALEY_UNIT_SEL(enum mdp4_scale_unit val)
+{
+        return ((val) << MDP4_PIPE_OP_MODE_SCALEY_UNIT_SEL__SHIFT) & MDP4_PIPE_OP_MODE_SCALEY_UNIT_SEL__MASK;
+}
 #define MDP4_PIPE_OP_MODE_SRC_YCBCR                             0x00000200
 #define MDP4_PIPE_OP_MODE_DST_YCBCR                             0x00000400
 #define MDP4_PIPE_OP_MODE_CSC_EN                                0x00000800
diff --git a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_crtc.c b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_crtc.c
index 20ae50385e5b..73afa21822b4 100644
--- a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_crtc.c
+++ b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_crtc.c
@@ -140,26 +140,6 @@ static void mdp4_crtc_destroy(struct drm_crtc *crtc)
         kfree(mdp4_crtc);
 }
 
-static void mdp4_crtc_dpms(struct drm_crtc *crtc, int mode)
-{
-        struct mdp4_crtc *mdp4_crtc = to_mdp4_crtc(crtc);
-        struct mdp4_kms *mdp4_kms = get_kms(crtc);
-        bool enabled = (mode == DRM_MODE_DPMS_ON);
-
-        DBG("%s: mode=%d", mdp4_crtc->name, mode);
-
-        if (enabled != mdp4_crtc->enabled) {
-                if (enabled) {
-                        mdp4_enable(mdp4_kms);
-                        mdp_irq_register(&mdp4_kms->base, &mdp4_crtc->err);
-                } else {
-                        mdp_irq_unregister(&mdp4_kms->base, &mdp4_crtc->err);
-                        mdp4_disable(mdp4_kms);
-                }
-                mdp4_crtc->enabled = enabled;
-        }
-}
-
 static bool mdp4_crtc_mode_fixup(struct drm_crtc *crtc,
                 const struct drm_display_mode *mode,
                 struct drm_display_mode *adjusted_mode)
@@ -304,23 +284,38 @@ static void mdp4_crtc_mode_set_nofb(struct drm_crtc *crtc)
         }
 }
 
-static void mdp4_crtc_prepare(struct drm_crtc *crtc)
+static void mdp4_crtc_disable(struct drm_crtc *crtc)
 {
         struct mdp4_crtc *mdp4_crtc = to_mdp4_crtc(crtc);
+        struct mdp4_kms *mdp4_kms = get_kms(crtc);
+
         DBG("%s", mdp4_crtc->name);
-        /* make sure we hold a ref to mdp clks while setting up mode: */
-        drm_crtc_vblank_get(crtc);
-        mdp4_enable(get_kms(crtc));
-        mdp4_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
+
+        if (WARN_ON(!mdp4_crtc->enabled))
+                return;
+
+        mdp_irq_unregister(&mdp4_kms->base, &mdp4_crtc->err);
+        mdp4_disable(mdp4_kms);
+
+        mdp4_crtc->enabled = false;
 }
 
-static void mdp4_crtc_commit(struct drm_crtc *crtc)
+static void mdp4_crtc_enable(struct drm_crtc *crtc)
 {
-        mdp4_crtc_dpms(crtc, DRM_MODE_DPMS_ON);
+        struct mdp4_crtc *mdp4_crtc = to_mdp4_crtc(crtc);
+        struct mdp4_kms *mdp4_kms = get_kms(crtc);
+
+        DBG("%s", mdp4_crtc->name);
+
+        if (WARN_ON(mdp4_crtc->enabled))
+                return;
+
+        mdp4_enable(mdp4_kms);
+        mdp_irq_register(&mdp4_kms->base, &mdp4_crtc->err);
+
         crtc_flush(crtc);
-        /* drop the ref to mdp clk's that we got in prepare: */
-        mdp4_disable(get_kms(crtc));
-        drm_crtc_vblank_put(crtc);
+
+        mdp4_crtc->enabled = true;
 }
 
 static int mdp4_crtc_atomic_check(struct drm_crtc *crtc,
@@ -504,13 +499,10 @@ static const struct drm_crtc_funcs mdp4_crtc_funcs = {
 };
 
 static const struct drm_crtc_helper_funcs mdp4_crtc_helper_funcs = {
-        .dpms = mdp4_crtc_dpms,
         .mode_fixup = mdp4_crtc_mode_fixup,
         .mode_set_nofb = mdp4_crtc_mode_set_nofb,
-        .mode_set = drm_helper_crtc_mode_set,
-        .mode_set_base = drm_helper_crtc_mode_set_base,
-        .prepare = mdp4_crtc_prepare,
-        .commit = mdp4_crtc_commit,
+        .disable = mdp4_crtc_disable,
+        .enable = mdp4_crtc_enable,
         .atomic_check = mdp4_crtc_atomic_check,
         .atomic_begin = mdp4_crtc_atomic_begin,
         .atomic_flush = mdp4_crtc_atomic_flush,
diff --git a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_dtv_encoder.c b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_dtv_encoder.c
index c3878420180b..7896323b2631 100644
--- a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_dtv_encoder.c
+++ b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_dtv_encoder.c
@@ -94,61 +94,6 @@ static const struct drm_encoder_funcs mdp4_dtv_encoder_funcs = {
         .destroy = mdp4_dtv_encoder_destroy,
 };
 
-static void mdp4_dtv_encoder_dpms(struct drm_encoder *encoder, int mode)
-{
-        struct drm_device *dev = encoder->dev;
-        struct mdp4_dtv_encoder *mdp4_dtv_encoder = to_mdp4_dtv_encoder(encoder);
-        struct mdp4_kms *mdp4_kms = get_kms(encoder);
-        bool enabled = (mode == DRM_MODE_DPMS_ON);
-
-        DBG("mode=%d", mode);
-
-        if (enabled == mdp4_dtv_encoder->enabled)
-                return;
-
-        if (enabled) {
-                unsigned long pc = mdp4_dtv_encoder->pixclock;
-                int ret;
-
-                bs_set(mdp4_dtv_encoder, 1);
-
-                DBG("setting src_clk=%lu", pc);
-
-                ret = clk_set_rate(mdp4_dtv_encoder->src_clk, pc);
-                if (ret)
-                        dev_err(dev->dev, "failed to set src_clk to %lu: %d\n", pc, ret);
-                clk_prepare_enable(mdp4_dtv_encoder->src_clk);
-                ret = clk_prepare_enable(mdp4_dtv_encoder->hdmi_clk);
-                if (ret)
-                        dev_err(dev->dev, "failed to enable hdmi_clk: %d\n", ret);
-                ret = clk_prepare_enable(mdp4_dtv_encoder->mdp_clk);
-                if (ret)
-                        dev_err(dev->dev, "failed to enabled mdp_clk: %d\n", ret);
-
-                mdp4_write(mdp4_kms, REG_MDP4_DTV_ENABLE, 1);
-        } else {
-                mdp4_write(mdp4_kms, REG_MDP4_DTV_ENABLE, 0);
-
-                /*
-                 * Wait for a vsync so we know the ENABLE=0 latched before
-                 * the (connector) source of the vsync's gets disabled,
-                 * otherwise we end up in a funny state if we re-enable
-                 * before the disable latches, which results that some of
-                 * the settings changes for the new modeset (like new
-                 * scanout buffer) don't latch properly..
-                 */
-                mdp_irq_wait(&mdp4_kms->base, MDP4_IRQ_EXTERNAL_VSYNC);
-
-                clk_disable_unprepare(mdp4_dtv_encoder->src_clk);
-                clk_disable_unprepare(mdp4_dtv_encoder->hdmi_clk);
-                clk_disable_unprepare(mdp4_dtv_encoder->mdp_clk);
-
-                bs_set(mdp4_dtv_encoder, 0);
-        }
-
-        mdp4_dtv_encoder->enabled = enabled;
-}
-
 static bool mdp4_dtv_encoder_mode_fixup(struct drm_encoder *encoder,
                 const struct drm_display_mode *mode,
                 struct drm_display_mode *adjusted_mode)
@@ -221,28 +166,78 @@ static void mdp4_dtv_encoder_mode_set(struct drm_encoder *encoder,
         mdp4_write(mdp4_kms, REG_MDP4_DTV_ACTIVE_VEND, 0);
 }
 
-static void mdp4_dtv_encoder_prepare(struct drm_encoder *encoder)
+static void mdp4_dtv_encoder_disable(struct drm_encoder *encoder)
 {
-        mdp4_dtv_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
+        struct mdp4_dtv_encoder *mdp4_dtv_encoder = to_mdp4_dtv_encoder(encoder);
+        struct mdp4_kms *mdp4_kms = get_kms(encoder);
+
+        if (WARN_ON(!mdp4_dtv_encoder->enabled))
+                return;
+
+        mdp4_write(mdp4_kms, REG_MDP4_DTV_ENABLE, 0);
+
+        /*
+         * Wait for a vsync so we know the ENABLE=0 latched before
+         * the (connector) source of the vsync's gets disabled,
+         * otherwise we end up in a funny state if we re-enable
+         * before the disable latches, which results that some of
+         * the settings changes for the new modeset (like new
+         * scanout buffer) don't latch properly..
+         */
+        mdp_irq_wait(&mdp4_kms->base, MDP4_IRQ_EXTERNAL_VSYNC);
+
+        clk_disable_unprepare(mdp4_dtv_encoder->src_clk);
+        clk_disable_unprepare(mdp4_dtv_encoder->hdmi_clk);
+        clk_disable_unprepare(mdp4_dtv_encoder->mdp_clk);
+
+        bs_set(mdp4_dtv_encoder, 0);
+
+        mdp4_dtv_encoder->enabled = false;
 }
 
-static void mdp4_dtv_encoder_commit(struct drm_encoder *encoder)
+static void mdp4_dtv_encoder_enable(struct drm_encoder *encoder)
 {
+        struct drm_device *dev = encoder->dev;
+        struct mdp4_dtv_encoder *mdp4_dtv_encoder = to_mdp4_dtv_encoder(encoder);
+        struct mdp4_kms *mdp4_kms = get_kms(encoder);
+        unsigned long pc = mdp4_dtv_encoder->pixclock;
+        int ret;
+
+        if (WARN_ON(mdp4_dtv_encoder->enabled))
+                return;
+
         mdp4_crtc_set_config(encoder->crtc,
                         MDP4_DMA_CONFIG_R_BPC(BPC8) |
                         MDP4_DMA_CONFIG_G_BPC(BPC8) |
                         MDP4_DMA_CONFIG_B_BPC(BPC8) |
                         MDP4_DMA_CONFIG_PACK(0x21));
         mdp4_crtc_set_intf(encoder->crtc, INTF_LCDC_DTV, 1);
-        mdp4_dtv_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
+
+        bs_set(mdp4_dtv_encoder, 1);
+
+        DBG("setting src_clk=%lu", pc);
+
+        ret = clk_set_rate(mdp4_dtv_encoder->src_clk, pc);
+        if (ret)
+                dev_err(dev->dev, "failed to set src_clk to %lu: %d\n", pc, ret);
+        clk_prepare_enable(mdp4_dtv_encoder->src_clk);
+        ret = clk_prepare_enable(mdp4_dtv_encoder->hdmi_clk);
+        if (ret)
+                dev_err(dev->dev, "failed to enable hdmi_clk: %d\n", ret);
+        ret = clk_prepare_enable(mdp4_dtv_encoder->mdp_clk);
+        if (ret)
+                dev_err(dev->dev, "failed to enabled mdp_clk: %d\n", ret);
+
+        mdp4_write(mdp4_kms, REG_MDP4_DTV_ENABLE, 1);
+
+        mdp4_dtv_encoder->enabled = true;
 }
 
 static const struct drm_encoder_helper_funcs mdp4_dtv_encoder_helper_funcs = {
-        .dpms = mdp4_dtv_encoder_dpms,
         .mode_fixup = mdp4_dtv_encoder_mode_fixup,
         .mode_set = mdp4_dtv_encoder_mode_set,
-        .prepare = mdp4_dtv_encoder_prepare,
-        .commit = mdp4_dtv_encoder_commit,
+        .enable = mdp4_dtv_encoder_enable,
+        .disable = mdp4_dtv_encoder_disable,
 };
 
 long mdp4_dtv_round_pixclk(struct drm_encoder *encoder, unsigned long rate)
diff --git a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.c b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.c
index a62109e4ae0d..d847b9436194 100644
--- a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.c
+++ b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.c
@@ -125,6 +125,38 @@ out:
         return ret;
 }
 
+static void mdp4_prepare_commit(struct msm_kms *kms, struct drm_atomic_state *state)
+{
+        struct mdp4_kms *mdp4_kms = to_mdp4_kms(to_mdp_kms(kms));
+        int i, ncrtcs = state->dev->mode_config.num_crtc;
+
+        mdp4_enable(mdp4_kms);
+
+        /* see 119ecb7fd */
+        for (i = 0; i < ncrtcs; i++) {
+                struct drm_crtc *crtc = state->crtcs[i];
+                if (!crtc)
+                        continue;
+                drm_crtc_vblank_get(crtc);
+        }
+}
+
+static void mdp4_complete_commit(struct msm_kms *kms, struct drm_atomic_state *state)
+{
+        struct mdp4_kms *mdp4_kms = to_mdp4_kms(to_mdp_kms(kms));
+        int i, ncrtcs = state->dev->mode_config.num_crtc;
+
+        /* see 119ecb7fd */
+        for (i = 0; i < ncrtcs; i++) {
+                struct drm_crtc *crtc = state->crtcs[i];
+                if (!crtc)
+                        continue;
+                drm_crtc_vblank_put(crtc);
+        }
+
+        mdp4_disable(mdp4_kms);
+}
+
 static long mdp4_round_pixclk(struct msm_kms *kms, unsigned long rate,
                 struct drm_encoder *encoder)
 {
@@ -161,6 +193,8 @@ static const struct mdp_kms_funcs kms_funcs = {
                 .irq             = mdp4_irq,
                 .enable_vblank   = mdp4_enable_vblank,
                 .disable_vblank  = mdp4_disable_vblank,
+                .prepare_commit  = mdp4_prepare_commit,
+                .complete_commit = mdp4_complete_commit,
                 .get_format      = mdp_get_format,
                 .round_pixclk    = mdp4_round_pixclk,
                 .preclose        = mdp4_preclose,
diff --git a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.h b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.h
index cbd77bc626d5..0a5c58bde7a9 100644
--- a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.h
+++ b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_kms.h
@@ -175,14 +175,25 @@ irqreturn_t mdp4_irq(struct msm_kms *kms);
 int mdp4_enable_vblank(struct msm_kms *kms, struct drm_crtc *crtc);
 void mdp4_disable_vblank(struct msm_kms *kms, struct drm_crtc *crtc);
 
+static inline bool pipe_supports_yuv(enum mdp4_pipe pipe)
+{
+        switch (pipe) {
+        case VG1:
+        case VG2:
+        case VG3:
+        case VG4:
+                return true;
+        default:
+                return false;
+        }
+}
+
 static inline
 uint32_t mdp4_get_formats(enum mdp4_pipe pipe_id, uint32_t *pixel_formats,
                 uint32_t max_formats)
 {
-        /* TODO when we have YUV, we need to filter supported formats
-         * based on pipe_id..
-         */
-        return mdp_get_formats(pixel_formats, max_formats);
+        return mdp_get_formats(pixel_formats, max_formats,
+                                !pipe_supports_yuv(pipe_id));
 }
 
 void mdp4_plane_install_properties(struct drm_plane *plane,
diff --git a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_lcdc_encoder.c b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_lcdc_encoder.c
index 41f6436754fc..60ec8222c9f6 100644
--- a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_lcdc_encoder.c
+++ b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_lcdc_encoder.c
@@ -259,77 +259,6 @@ static void setup_phy(struct drm_encoder *encoder)
         mdp4_write(mdp4_kms, REG_MDP4_LVDS_PHY_CFG0, lvds_phy_cfg0);
 }
 
-static void mdp4_lcdc_encoder_dpms(struct drm_encoder *encoder, int mode)
-{
-        struct drm_device *dev = encoder->dev;
-        struct mdp4_lcdc_encoder *mdp4_lcdc_encoder =
-                        to_mdp4_lcdc_encoder(encoder);
-        struct mdp4_kms *mdp4_kms = get_kms(encoder);
-        struct drm_panel *panel = mdp4_lcdc_encoder->panel;
-        bool enabled = (mode == DRM_MODE_DPMS_ON);
-        int i, ret;
-
-        DBG("mode=%d", mode);
-
-        if (enabled == mdp4_lcdc_encoder->enabled)
-                return;
-
-        if (enabled) {
-                unsigned long pc = mdp4_lcdc_encoder->pixclock;
-                int ret;
-
-                bs_set(mdp4_lcdc_encoder, 1);
-
-                for (i = 0; i < ARRAY_SIZE(mdp4_lcdc_encoder->regs); i++) {
-                        ret = regulator_enable(mdp4_lcdc_encoder->regs[i]);
-                        if (ret)
-                                dev_err(dev->dev, "failed to enable regulator: %d\n", ret);
-                }
-
-                DBG("setting lcdc_clk=%lu", pc);
-                ret = clk_set_rate(mdp4_lcdc_encoder->lcdc_clk, pc);
-                if (ret)
-                        dev_err(dev->dev, "failed to configure lcdc_clk: %d\n", ret);
-                ret = clk_prepare_enable(mdp4_lcdc_encoder->lcdc_clk);
-                if (ret)
-                        dev_err(dev->dev, "failed to enable lcdc_clk: %d\n", ret);
-
-                if (panel)
-                        drm_panel_enable(panel);
-
-                setup_phy(encoder);
-
-                mdp4_write(mdp4_kms, REG_MDP4_LCDC_ENABLE, 1);
-        } else {
-                mdp4_write(mdp4_kms, REG_MDP4_LCDC_ENABLE, 0);
-
-                if (panel)
-                        drm_panel_disable(panel);
-
-                /*
-                 * Wait for a vsync so we know the ENABLE=0 latched before
-                 * the (connector) source of the vsync's gets disabled,
-                 * otherwise we end up in a funny state if we re-enable
-                 * before the disable latches, which results that some of
-                 * the settings changes for the new modeset (like new
-                 * scanout buffer) don't latch properly..
-                 */
-                mdp_irq_wait(&mdp4_kms->base, MDP4_IRQ_PRIMARY_VSYNC);
-
-                clk_disable_unprepare(mdp4_lcdc_encoder->lcdc_clk);
-
-                for (i = 0; i < ARRAY_SIZE(mdp4_lcdc_encoder->regs); i++) {
-                        ret = regulator_disable(mdp4_lcdc_encoder->regs[i]);
-                        if (ret)
-                                dev_err(dev->dev, "failed to disable regulator: %d\n", ret);
-                }
-
-                bs_set(mdp4_lcdc_encoder, 0);
-        }
-
-        mdp4_lcdc_encoder->enabled = enabled;
-}
-
 static bool mdp4_lcdc_encoder_mode_fixup(struct drm_encoder *encoder,
                 const struct drm_display_mode *mode,
                 struct drm_display_mode *adjusted_mode)
@@ -403,13 +332,59 @@ static void mdp4_lcdc_encoder_mode_set(struct drm_encoder *encoder,
         mdp4_write(mdp4_kms, REG_MDP4_LCDC_ACTIVE_VEND, 0);
 }
 
-static void mdp4_lcdc_encoder_prepare(struct drm_encoder *encoder)
+static void mdp4_lcdc_encoder_disable(struct drm_encoder *encoder)
 {
-        mdp4_lcdc_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
+        struct drm_device *dev = encoder->dev;
+        struct mdp4_lcdc_encoder *mdp4_lcdc_encoder =
+                        to_mdp4_lcdc_encoder(encoder);
+        struct mdp4_kms *mdp4_kms = get_kms(encoder);
+        struct drm_panel *panel = mdp4_lcdc_encoder->panel;
+        int i, ret;
+
+        if (WARN_ON(!mdp4_lcdc_encoder->enabled))
+                return;
+
+        mdp4_write(mdp4_kms, REG_MDP4_LCDC_ENABLE, 0);
+
+        if (panel)
+                drm_panel_disable(panel);
+
+        /*
+         * Wait for a vsync so we know the ENABLE=0 latched before
+         * the (connector) source of the vsync's gets disabled,
+         * otherwise we end up in a funny state if we re-enable
+         * before the disable latches, which results that some of
+         * the settings changes for the new modeset (like new
+         * scanout buffer) don't latch properly..
+         */
+        mdp_irq_wait(&mdp4_kms->base, MDP4_IRQ_PRIMARY_VSYNC);
+
+        clk_disable_unprepare(mdp4_lcdc_encoder->lcdc_clk);
+
+        for (i = 0; i < ARRAY_SIZE(mdp4_lcdc_encoder->regs); i++) {
+                ret = regulator_disable(mdp4_lcdc_encoder->regs[i]);
+                if (ret)
+                        dev_err(dev->dev, "failed to disable regulator: %d\n", ret);
+        }
+
+        bs_set(mdp4_lcdc_encoder, 0);
+
+        mdp4_lcdc_encoder->enabled = false;
 }
 
-static void mdp4_lcdc_encoder_commit(struct drm_encoder *encoder)
+static void mdp4_lcdc_encoder_enable(struct drm_encoder *encoder)
 {
+        struct drm_device *dev = encoder->dev;
+        struct mdp4_lcdc_encoder *mdp4_lcdc_encoder =
+                        to_mdp4_lcdc_encoder(encoder);
+        unsigned long pc = mdp4_lcdc_encoder->pixclock;
+        struct mdp4_kms *mdp4_kms = get_kms(encoder);
+        struct drm_panel *panel = mdp4_lcdc_encoder->panel;
+        int i, ret;
+
+        if (WARN_ON(mdp4_lcdc_encoder->enabled))
+                return;
+
         /* TODO: hard-coded for 18bpp: */
         mdp4_crtc_set_config(encoder->crtc,
                         MDP4_DMA_CONFIG_R_BPC(BPC6) |
@@ -420,15 +395,38 @@ static void mdp4_lcdc_encoder_commit(struct drm_encoder *encoder)
                         MDP4_DMA_CONFIG_DEFLKR_EN |
                         MDP4_DMA_CONFIG_DITHER_EN);
         mdp4_crtc_set_intf(encoder->crtc, INTF_LCDC_DTV, 0);
-        mdp4_lcdc_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
+
+        bs_set(mdp4_lcdc_encoder, 1);
+
+        for (i = 0; i < ARRAY_SIZE(mdp4_lcdc_encoder->regs); i++) {
+                ret = regulator_enable(mdp4_lcdc_encoder->regs[i]);
+                if (ret)
+                        dev_err(dev->dev, "failed to enable regulator: %d\n", ret);
+        }
+
+        DBG("setting lcdc_clk=%lu", pc);
+        ret = clk_set_rate(mdp4_lcdc_encoder->lcdc_clk, pc);
+        if (ret)
+                dev_err(dev->dev, "failed to configure lcdc_clk: %d\n", ret);
+        ret = clk_prepare_enable(mdp4_lcdc_encoder->lcdc_clk);
+        if (ret)
+                dev_err(dev->dev, "failed to enable lcdc_clk: %d\n", ret);
+
+        if (panel)
+                drm_panel_enable(panel);
+
+        setup_phy(encoder);
+
+        mdp4_write(mdp4_kms, REG_MDP4_LCDC_ENABLE, 1);
+
+        mdp4_lcdc_encoder->enabled = true;
 }
 
 static const struct drm_encoder_helper_funcs mdp4_lcdc_encoder_helper_funcs = {
-        .dpms = mdp4_lcdc_encoder_dpms,
         .mode_fixup = mdp4_lcdc_encoder_mode_fixup,
         .mode_set = mdp4_lcdc_encoder_mode_set,
-        .prepare = mdp4_lcdc_encoder_prepare,
-        .commit = mdp4_lcdc_encoder_commit,
+        .disable = mdp4_lcdc_encoder_disable,
+        .enable = mdp4_lcdc_encoder_enable,
 };
 
 long mdp4_lcdc_round_pixclk(struct drm_encoder *encoder, unsigned long rate)
diff --git a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_lvds_connector.c b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_lvds_connector.c
index 4ddc28e1275b..921185133d38 100644
--- a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_lvds_connector.c
+++ b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_lvds_connector.c
@@ -94,7 +94,7 @@ mdp4_lvds_connector_best_encoder(struct drm_connector *connector)
 }
 
 static const struct drm_connector_funcs mdp4_lvds_connector_funcs = {
-        .dpms = drm_helper_connector_dpms,
+        .dpms = drm_atomic_helper_connector_dpms,
         .detect = mdp4_lvds_connector_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .destroy = mdp4_lvds_connector_destroy,
diff --git a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_plane.c b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_plane.c
index 1e5ebe83647d..cde25009203a 100644
--- a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_plane.c
+++ b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_plane.c
@@ -17,6 +17,8 @@
 
 #include "mdp4_kms.h"
 
+#define DOWN_SCALE_MAX  8
+#define UP_SCALE_MAX    8
 
 struct mdp4_plane {
         struct drm_plane base;
@@ -136,10 +138,6 @@ static void mdp4_plane_set_scanout(struct drm_plane *plane,
         struct mdp4_plane *mdp4_plane = to_mdp4_plane(plane);
         struct mdp4_kms *mdp4_kms = get_kms(plane);
         enum mdp4_pipe pipe = mdp4_plane->pipe;
-        uint32_t iova = msm_framebuffer_iova(fb, mdp4_kms->id, 0);
-
-        DBG("%s: set_scanout: %08x (%u)", mdp4_plane->name,
-                        iova, fb->pitches[0]);
 
         mdp4_write(mdp4_kms, REG_MDP4_PIPE_SRC_STRIDE_A(pipe),
                         MDP4_PIPE_SRC_STRIDE_A_P0(fb->pitches[0]) |
@@ -149,11 +147,45 @@ static void mdp4_plane_set_scanout(struct drm_plane *plane,
                         MDP4_PIPE_SRC_STRIDE_B_P2(fb->pitches[2]) |
                         MDP4_PIPE_SRC_STRIDE_B_P3(fb->pitches[3]));
 
-        mdp4_write(mdp4_kms, REG_MDP4_PIPE_SRCP0_BASE(pipe), iova);
+        mdp4_write(mdp4_kms, REG_MDP4_PIPE_SRCP0_BASE(pipe),
+                        msm_framebuffer_iova(fb, mdp4_kms->id, 0));
+        mdp4_write(mdp4_kms, REG_MDP4_PIPE_SRCP1_BASE(pipe),
+                        msm_framebuffer_iova(fb, mdp4_kms->id, 1));
+        mdp4_write(mdp4_kms, REG_MDP4_PIPE_SRCP2_BASE(pipe),
+                        msm_framebuffer_iova(fb, mdp4_kms->id, 2));
+        mdp4_write(mdp4_kms, REG_MDP4_PIPE_SRCP3_BASE(pipe),
+                        msm_framebuffer_iova(fb, mdp4_kms->id, 3));
 
         plane->fb = fb;
 }
 
+static void mdp4_write_csc_config(struct mdp4_kms *mdp4_kms,
+                enum mdp4_pipe pipe, struct csc_cfg *csc)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(csc->matrix); i++) {
+                mdp4_write(mdp4_kms, REG_MDP4_PIPE_CSC_MV(pipe, i),
+                                csc->matrix[i]);
+        }
+
+        for (i = 0; i < ARRAY_SIZE(csc->post_bias) ; i++) {
+                mdp4_write(mdp4_kms, REG_MDP4_PIPE_CSC_PRE_BV(pipe, i),
+                                csc->pre_bias[i]);
+
+                mdp4_write(mdp4_kms, REG_MDP4_PIPE_CSC_POST_BV(pipe, i),
+                                csc->post_bias[i]);
+        }
+
+        for (i = 0; i < ARRAY_SIZE(csc->post_clamp) ; i++) {
+                mdp4_write(mdp4_kms, REG_MDP4_PIPE_CSC_PRE_LV(pipe, i),
+                                csc->pre_clamp[i]);
+
+                mdp4_write(mdp4_kms, REG_MDP4_PIPE_CSC_POST_LV(pipe, i),
+                                csc->post_clamp[i]);
+        }
+}
+
 #define MDP4_VG_PHASE_STEP_DEFAULT      0x20000000
 
 static int mdp4_plane_mode_set(struct drm_plane *plane,
@@ -163,6 +195,7 @@ static int mdp4_plane_mode_set(struct drm_plane *plane,
                 uint32_t src_x, uint32_t src_y,
                 uint32_t src_w, uint32_t src_h)
 {
+        struct drm_device *dev = plane->dev;
         struct mdp4_plane *mdp4_plane = to_mdp4_plane(plane);
         struct mdp4_kms *mdp4_kms = get_kms(plane);
         enum mdp4_pipe pipe = mdp4_plane->pipe;
@@ -186,14 +219,59 @@ static int mdp4_plane_mode_set(struct drm_plane *plane,
                         fb->base.id, src_x, src_y, src_w, src_h,
                         crtc->base.id, crtc_x, crtc_y, crtc_w, crtc_h);
 
+        format = to_mdp_format(msm_framebuffer_format(fb));
+
+        if (src_w > (crtc_w * DOWN_SCALE_MAX)) {
+                dev_err(dev->dev, "Width down scaling exceeds limits!\n");
+                return -ERANGE;
+        }
+
+        if (src_h > (crtc_h * DOWN_SCALE_MAX)) {
+                dev_err(dev->dev, "Height down scaling exceeds limits!\n");
+                return -ERANGE;
+        }
+
+        if (crtc_w > (src_w * UP_SCALE_MAX)) {
+                dev_err(dev->dev, "Width up scaling exceeds limits!\n");
+                return -ERANGE;
+        }
+
+        if (crtc_h > (src_h * UP_SCALE_MAX)) {
+                dev_err(dev->dev, "Height up scaling exceeds limits!\n");
+                return -ERANGE;
+        }
+
         if (src_w != crtc_w) {
+                uint32_t sel_unit = SCALE_FIR;
                 op_mode |= MDP4_PIPE_OP_MODE_SCALEX_EN;
-                /* TODO calc phasex_step */
+
+                if (MDP_FORMAT_IS_YUV(format)) {
+                        if (crtc_w > src_w)
+                                sel_unit = SCALE_PIXEL_RPT;
+                        else if (crtc_w <= (src_w / 4))
+                                sel_unit = SCALE_MN_PHASE;
+
+                        op_mode |= MDP4_PIPE_OP_MODE_SCALEX_UNIT_SEL(sel_unit);
+                        phasex_step = mult_frac(MDP4_VG_PHASE_STEP_DEFAULT,
+                                        src_w, crtc_w);
+                }
         }
 
         if (src_h != crtc_h) {
+                uint32_t sel_unit = SCALE_FIR;
                 op_mode |= MDP4_PIPE_OP_MODE_SCALEY_EN;
-                /* TODO calc phasey_step */
+
+                if (MDP_FORMAT_IS_YUV(format)) {
+
+                        if (crtc_h > src_h)
+                                sel_unit = SCALE_PIXEL_RPT;
+                        else if (crtc_h <= (src_h / 4))
+                                sel_unit = SCALE_MN_PHASE;
+
+                        op_mode |= MDP4_PIPE_OP_MODE_SCALEY_UNIT_SEL(sel_unit);
+                        phasey_step = mult_frac(MDP4_VG_PHASE_STEP_DEFAULT,
+                                        src_h, crtc_h);
+                }
         }
 
         mdp4_write(mdp4_kms, REG_MDP4_PIPE_SRC_SIZE(pipe),
@@ -214,8 +292,6 @@ static int mdp4_plane_mode_set(struct drm_plane *plane,
 
         mdp4_plane_set_scanout(plane, fb);
 
-        format = to_mdp_format(msm_framebuffer_format(fb));
-
         mdp4_write(mdp4_kms, REG_MDP4_PIPE_SRC_FORMAT(pipe),
                         MDP4_PIPE_SRC_FORMAT_A_BPC(format->bpc_a) |
                         MDP4_PIPE_SRC_FORMAT_R_BPC(format->bpc_r) |
@@ -224,6 +300,8 @@ static int mdp4_plane_mode_set(struct drm_plane *plane,
                         COND(format->alpha_enable, MDP4_PIPE_SRC_FORMAT_ALPHA_ENABLE) |
                         MDP4_PIPE_SRC_FORMAT_CPP(format->cpp - 1) |
                         MDP4_PIPE_SRC_FORMAT_UNPACK_COUNT(format->unpack_count - 1) |
+                        MDP4_PIPE_SRC_FORMAT_FETCH_PLANES(format->fetch_type) |
+                        MDP4_PIPE_SRC_FORMAT_CHROMA_SAMP(format->chroma_sample) |
                         COND(format->unpack_tight, MDP4_PIPE_SRC_FORMAT_UNPACK_TIGHT));
 
         mdp4_write(mdp4_kms, REG_MDP4_PIPE_SRC_UNPACK(pipe),
@@ -232,6 +310,14 @@ static int mdp4_plane_mode_set(struct drm_plane *plane,
                         MDP4_PIPE_SRC_UNPACK_ELEM2(format->unpack[2]) |
                         MDP4_PIPE_SRC_UNPACK_ELEM3(format->unpack[3]));
 
+        if (MDP_FORMAT_IS_YUV(format)) {
+                struct csc_cfg *csc = mdp_get_default_csc_cfg(CSC_YUV2RGB);
+
+                op_mode |= MDP4_PIPE_OP_MODE_SRC_YCBCR;
+                op_mode |= MDP4_PIPE_OP_MODE_CSC_EN;
+                mdp4_write_csc_config(mdp4_kms, pipe, csc);
+        }
+
         mdp4_write(mdp4_kms, REG_MDP4_PIPE_OP_MODE(pipe), op_mode);
         mdp4_write(mdp4_kms, REG_MDP4_PIPE_PHASEX_STEP(pipe), phasex_step);
         mdp4_write(mdp4_kms, REG_MDP4_PIPE_PHASEY_STEP(pipe), phasey_step);
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5.xml.h b/drivers/gpu/drm/msm/mdp/mdp5/mdp5.xml.h
index e87ef5512cb0..09b4a25eb553 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5.xml.h
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5.xml.h
@@ -8,18 +8,19 @@ http://github.com/freedreno/envytools/
 git clone https://github.com/freedreno/envytools.git
 
 The rules-ng-ng source files this header was generated from are:
-- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    647 bytes, from 2013-11-30 14:45:35)
+- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    676 bytes, from 2014-12-05 15:34:49)
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml (   1453 bytes, from 2013-03-31 16:51:27)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20136 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   1940 bytes, from 2014-10-31 16:51:39)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  23963 bytes, from 2014-10-31 16:51:46)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20908 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   2357 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  27208 bytes, from 2015-01-13 23:56:11)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/dsi.xml             (  11712 bytes, from 2013-08-17 17:13:43)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/sfpb.xml            (    344 bytes, from 2013-08-11 19:26:32)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1686 bytes, from 2014-10-31 16:48:57)
 - /home/robclark/src/freedreno/envytools/rnndb/hdmi/qfprom.xml         (    600 bytes, from 2013-07-05 19:21:12)
-- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  23613 bytes, from 2014-07-17 15:33:30)
+- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  26848 bytes, from 2015-01-13 23:55:57)
+- /home/robclark/src/freedreno/envytools/rnndb/edp/edp.xml             (   8253 bytes, from 2014-12-08 16:13:00)
 
-Copyright (C) 2013-2014 by the following authors:
+Copyright (C) 2013-2015 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
 
 Permission is hereby granted, free of charge, to any person obtaining
@@ -88,13 +89,6 @@ enum mdp5_pack_3d {
         PACK_3D_COL_INT = 3,
 };
 
-enum mdp5_chroma_samp_type {
-        CHROMA_RGB = 0,
-        CHROMA_H2V1 = 1,
-        CHROMA_H1V2 = 2,
-        CHROMA_420 = 3,
-};
-
 enum mdp5_scale_filter {
         SCALE_FILTER_NEAREST = 0,
         SCALE_FILTER_BIL = 1,
@@ -135,6 +129,17 @@ enum mdp5_client_id {
         CID_MAX = 23,
 };
 
+enum mdp5_cursor_format {
+        CURSOR_FMT_ARGB8888 = 0,
+        CURSOR_FMT_ARGB1555 = 2,
+        CURSOR_FMT_ARGB4444 = 4,
+};
+
+enum mdp5_cursor_alpha {
+        CURSOR_ALPHA_CONST = 0,
+        CURSOR_ALPHA_PER_PIXEL = 2,
+};
+
 enum mdp5_igc_type {
         IGC_VIG = 0,
         IGC_RGB = 1,
@@ -142,6 +147,11 @@ enum mdp5_igc_type {
         IGC_DSPP = 3,
 };
 
+enum mdp5_data_format {
+        DATA_FORMAT_RGB = 0,
+        DATA_FORMAT_YUV = 1,
+};
+
 #define MDP5_IRQ_INTF0_WB_ROT_COMP                              0x00000001
 #define MDP5_IRQ_INTF1_WB_ROT_COMP                              0x00000002
 #define MDP5_IRQ_INTF2_WB_ROT_COMP                              0x00000004
@@ -463,12 +473,143 @@ static inline uint32_t __offset_PIPE(enum mdp5_pipe idx)
 }
 static inline uint32_t REG_MDP5_PIPE(enum mdp5_pipe i0) { return 0x00000000 + __offset_PIPE(i0); }
 
+static inline uint32_t REG_MDP5_PIPE_OP_MODE(enum mdp5_pipe i0) { return 0x00000200 + __offset_PIPE(i0); }
+#define MDP5_PIPE_OP_MODE_CSC_DST_DATA_FORMAT__MASK             0x00080000
+#define MDP5_PIPE_OP_MODE_CSC_DST_DATA_FORMAT__SHIFT            19
+static inline uint32_t MDP5_PIPE_OP_MODE_CSC_DST_DATA_FORMAT(enum mdp5_data_format val)
+{
+        return ((val) << MDP5_PIPE_OP_MODE_CSC_DST_DATA_FORMAT__SHIFT) & MDP5_PIPE_OP_MODE_CSC_DST_DATA_FORMAT__MASK;
+}
+#define MDP5_PIPE_OP_MODE_CSC_SRC_DATA_FORMAT__MASK             0x00040000
+#define MDP5_PIPE_OP_MODE_CSC_SRC_DATA_FORMAT__SHIFT            18
+static inline uint32_t MDP5_PIPE_OP_MODE_CSC_SRC_DATA_FORMAT(enum mdp5_data_format val)
+{
+        return ((val) << MDP5_PIPE_OP_MODE_CSC_SRC_DATA_FORMAT__SHIFT) & MDP5_PIPE_OP_MODE_CSC_SRC_DATA_FORMAT__MASK;
+}
+#define MDP5_PIPE_OP_MODE_CSC_1_EN                              0x00020000
+
 static inline uint32_t REG_MDP5_PIPE_HIST_CTL_BASE(enum mdp5_pipe i0) { return 0x000002c4 + __offset_PIPE(i0); }
 
 static inline uint32_t REG_MDP5_PIPE_HIST_LUT_BASE(enum mdp5_pipe i0) { return 0x000002f0 + __offset_PIPE(i0); }
 
 static inline uint32_t REG_MDP5_PIPE_HIST_LUT_SWAP(enum mdp5_pipe i0) { return 0x00000300 + __offset_PIPE(i0); }
 
+static inline uint32_t REG_MDP5_PIPE_CSC_1_MATRIX_COEFF_0(enum mdp5_pipe i0) { return 0x00000320 + __offset_PIPE(i0); }
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_11__MASK           0x00001fff
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_11__SHIFT          0
+static inline uint32_t MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_11(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_11__SHIFT) & MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_11__MASK;
+}
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_12__MASK           0x1fff0000
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_12__SHIFT          16
+static inline uint32_t MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_12(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_12__SHIFT) & MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_12__MASK;
+}
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_MATRIX_COEFF_1(enum mdp5_pipe i0) { return 0x00000324 + __offset_PIPE(i0); }
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_13__MASK           0x00001fff
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_13__SHIFT          0
+static inline uint32_t MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_13(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_13__SHIFT) & MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_13__MASK;
+}
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_21__MASK           0x1fff0000
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_21__SHIFT          16
+static inline uint32_t MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_21(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_21__SHIFT) & MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_21__MASK;
+}
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_MATRIX_COEFF_2(enum mdp5_pipe i0) { return 0x00000328 + __offset_PIPE(i0); }
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_22__MASK           0x00001fff
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_22__SHIFT          0
+static inline uint32_t MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_22(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_22__SHIFT) & MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_22__MASK;
+}
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_23__MASK           0x1fff0000
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_23__SHIFT          16
+static inline uint32_t MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_23(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_23__SHIFT) & MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_23__MASK;
+}
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_MATRIX_COEFF_3(enum mdp5_pipe i0) { return 0x0000032c + __offset_PIPE(i0); }
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_31__MASK           0x00001fff
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_31__SHIFT          0
+static inline uint32_t MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_31(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_31__SHIFT) & MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_31__MASK;
+}
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_32__MASK           0x1fff0000
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_32__SHIFT          16
+static inline uint32_t MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_32(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_32__SHIFT) & MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_32__MASK;
+}
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_MATRIX_COEFF_4(enum mdp5_pipe i0) { return 0x00000330 + __offset_PIPE(i0); }
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_4_COEFF_33__MASK           0x00001fff
+#define MDP5_PIPE_CSC_1_MATRIX_COEFF_4_COEFF_33__SHIFT          0
+static inline uint32_t MDP5_PIPE_CSC_1_MATRIX_COEFF_4_COEFF_33(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_MATRIX_COEFF_4_COEFF_33__SHIFT) & MDP5_PIPE_CSC_1_MATRIX_COEFF_4_COEFF_33__MASK;
+}
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_PRE_CLAMP(enum mdp5_pipe i0, uint32_t i1) { return 0x00000334 + __offset_PIPE(i0) + 0x4*i1; }
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_PRE_CLAMP_REG(enum mdp5_pipe i0, uint32_t i1) { return 0x00000334 + __offset_PIPE(i0) + 0x4*i1; }
+#define MDP5_PIPE_CSC_1_PRE_CLAMP_REG_HIGH__MASK                0x000000ff
+#define MDP5_PIPE_CSC_1_PRE_CLAMP_REG_HIGH__SHIFT               0
+static inline uint32_t MDP5_PIPE_CSC_1_PRE_CLAMP_REG_HIGH(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_PRE_CLAMP_REG_HIGH__SHIFT) & MDP5_PIPE_CSC_1_PRE_CLAMP_REG_HIGH__MASK;
+}
+#define MDP5_PIPE_CSC_1_PRE_CLAMP_REG_LOW__MASK                 0x0000ff00
+#define MDP5_PIPE_CSC_1_PRE_CLAMP_REG_LOW__SHIFT                8
+static inline uint32_t MDP5_PIPE_CSC_1_PRE_CLAMP_REG_LOW(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_PRE_CLAMP_REG_LOW__SHIFT) & MDP5_PIPE_CSC_1_PRE_CLAMP_REG_LOW__MASK;
+}
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_POST_CLAMP(enum mdp5_pipe i0, uint32_t i1) { return 0x00000340 + __offset_PIPE(i0) + 0x4*i1; }
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_POST_CLAMP_REG(enum mdp5_pipe i0, uint32_t i1) { return 0x00000340 + __offset_PIPE(i0) + 0x4*i1; }
+#define MDP5_PIPE_CSC_1_POST_CLAMP_REG_HIGH__MASK               0x000000ff
+#define MDP5_PIPE_CSC_1_POST_CLAMP_REG_HIGH__SHIFT              0
+static inline uint32_t MDP5_PIPE_CSC_1_POST_CLAMP_REG_HIGH(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_POST_CLAMP_REG_HIGH__SHIFT) & MDP5_PIPE_CSC_1_POST_CLAMP_REG_HIGH__MASK;
+}
+#define MDP5_PIPE_CSC_1_POST_CLAMP_REG_LOW__MASK                0x0000ff00
+#define MDP5_PIPE_CSC_1_POST_CLAMP_REG_LOW__SHIFT               8
+static inline uint32_t MDP5_PIPE_CSC_1_POST_CLAMP_REG_LOW(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_POST_CLAMP_REG_LOW__SHIFT) & MDP5_PIPE_CSC_1_POST_CLAMP_REG_LOW__MASK;
+}
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_PRE_BIAS(enum mdp5_pipe i0, uint32_t i1) { return 0x0000034c + __offset_PIPE(i0) + 0x4*i1; }
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_PRE_BIAS_REG(enum mdp5_pipe i0, uint32_t i1) { return 0x0000034c + __offset_PIPE(i0) + 0x4*i1; }
+#define MDP5_PIPE_CSC_1_PRE_BIAS_REG_VALUE__MASK                0x000001ff
+#define MDP5_PIPE_CSC_1_PRE_BIAS_REG_VALUE__SHIFT               0
+static inline uint32_t MDP5_PIPE_CSC_1_PRE_BIAS_REG_VALUE(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_PRE_BIAS_REG_VALUE__SHIFT) & MDP5_PIPE_CSC_1_PRE_BIAS_REG_VALUE__MASK;
+}
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_POST_BIAS(enum mdp5_pipe i0, uint32_t i1) { return 0x00000358 + __offset_PIPE(i0) + 0x4*i1; }
+
+static inline uint32_t REG_MDP5_PIPE_CSC_1_POST_BIAS_REG(enum mdp5_pipe i0, uint32_t i1) { return 0x00000358 + __offset_PIPE(i0) + 0x4*i1; }
+#define MDP5_PIPE_CSC_1_POST_BIAS_REG_VALUE__MASK               0x000001ff
+#define MDP5_PIPE_CSC_1_POST_BIAS_REG_VALUE__SHIFT              0
+static inline uint32_t MDP5_PIPE_CSC_1_POST_BIAS_REG_VALUE(uint32_t val)
+{
+        return ((val) << MDP5_PIPE_CSC_1_POST_BIAS_REG_VALUE__SHIFT) & MDP5_PIPE_CSC_1_POST_BIAS_REG_VALUE__MASK;
+}
+
 static inline uint32_t REG_MDP5_PIPE_SRC_SIZE(enum mdp5_pipe i0) { return 0x00000000 + __offset_PIPE(i0); }
 #define MDP5_PIPE_SRC_SIZE_HEIGHT__MASK                         0xffff0000
 #define MDP5_PIPE_SRC_SIZE_HEIGHT__SHIFT                        16
@@ -618,15 +759,15 @@ static inline uint32_t MDP5_PIPE_SRC_FORMAT_UNPACK_COUNT(uint32_t val)
 }
 #define MDP5_PIPE_SRC_FORMAT_UNPACK_TIGHT                       0x00020000
 #define MDP5_PIPE_SRC_FORMAT_UNPACK_ALIGN_MSB                   0x00040000
-#define MDP5_PIPE_SRC_FORMAT_NUM_PLANES__MASK                   0x00780000
+#define MDP5_PIPE_SRC_FORMAT_NUM_PLANES__MASK                   0x00180000
 #define MDP5_PIPE_SRC_FORMAT_NUM_PLANES__SHIFT                  19
-static inline uint32_t MDP5_PIPE_SRC_FORMAT_NUM_PLANES(uint32_t val)
+static inline uint32_t MDP5_PIPE_SRC_FORMAT_NUM_PLANES(enum mdp_sspp_fetch_type val)
 {
         return ((val) << MDP5_PIPE_SRC_FORMAT_NUM_PLANES__SHIFT) & MDP5_PIPE_SRC_FORMAT_NUM_PLANES__MASK;
 }
 #define MDP5_PIPE_SRC_FORMAT_CHROMA_SAMP__MASK                  0x01800000
 #define MDP5_PIPE_SRC_FORMAT_CHROMA_SAMP__SHIFT                 23
-static inline uint32_t MDP5_PIPE_SRC_FORMAT_CHROMA_SAMP(enum mdp5_chroma_samp_type val)
+static inline uint32_t MDP5_PIPE_SRC_FORMAT_CHROMA_SAMP(enum mdp_chroma_samp_type val)
 {
         return ((val) << MDP5_PIPE_SRC_FORMAT_CHROMA_SAMP__SHIFT) & MDP5_PIPE_SRC_FORMAT_CHROMA_SAMP__MASK;
 }
@@ -753,6 +894,10 @@ static inline uint32_t REG_MDP5_PIPE_SCALE_PHASE_STEP_X(enum mdp5_pipe i0) { ret
 
 static inline uint32_t REG_MDP5_PIPE_SCALE_PHASE_STEP_Y(enum mdp5_pipe i0) { return 0x00000214 + __offset_PIPE(i0); }
 
+static inline uint32_t REG_MDP5_PIPE_SCALE_CR_PHASE_STEP_X(enum mdp5_pipe i0) { return 0x00000218 + __offset_PIPE(i0); }
+
+static inline uint32_t REG_MDP5_PIPE_SCALE_CR_PHASE_STEP_Y(enum mdp5_pipe i0) { return 0x0000021c + __offset_PIPE(i0); }
+
 static inline uint32_t REG_MDP5_PIPE_SCALE_INIT_PHASE_X(enum mdp5_pipe i0) { return 0x00000220 + __offset_PIPE(i0); }
 
 static inline uint32_t REG_MDP5_PIPE_SCALE_INIT_PHASE_Y(enum mdp5_pipe i0) { return 0x00000224 + __offset_PIPE(i0); }
@@ -839,20 +984,88 @@ static inline uint32_t REG_MDP5_LM_BLEND_BG_TRANSP_HIGH0(uint32_t i0, uint32_t i
 static inline uint32_t REG_MDP5_LM_BLEND_BG_TRANSP_HIGH1(uint32_t i0, uint32_t i1) { return 0x00000048 + __offset_LM(i0) + 0x30*i1; }
 
 static inline uint32_t REG_MDP5_LM_CURSOR_IMG_SIZE(uint32_t i0) { return 0x000000e0 + __offset_LM(i0); }
+#define MDP5_LM_CURSOR_IMG_SIZE_SRC_W__MASK                     0x0000ffff
+#define MDP5_LM_CURSOR_IMG_SIZE_SRC_W__SHIFT                    0
+static inline uint32_t MDP5_LM_CURSOR_IMG_SIZE_SRC_W(uint32_t val)
+{
+        return ((val) << MDP5_LM_CURSOR_IMG_SIZE_SRC_W__SHIFT) & MDP5_LM_CURSOR_IMG_SIZE_SRC_W__MASK;
+}
+#define MDP5_LM_CURSOR_IMG_SIZE_SRC_H__MASK                     0xffff0000
+#define MDP5_LM_CURSOR_IMG_SIZE_SRC_H__SHIFT                    16
+static inline uint32_t MDP5_LM_CURSOR_IMG_SIZE_SRC_H(uint32_t val)
+{
+        return ((val) << MDP5_LM_CURSOR_IMG_SIZE_SRC_H__SHIFT) & MDP5_LM_CURSOR_IMG_SIZE_SRC_H__MASK;
+}
 
 static inline uint32_t REG_MDP5_LM_CURSOR_SIZE(uint32_t i0) { return 0x000000e4 + __offset_LM(i0); }
+#define MDP5_LM_CURSOR_SIZE_ROI_W__MASK                         0x0000ffff
+#define MDP5_LM_CURSOR_SIZE_ROI_W__SHIFT                        0
+static inline uint32_t MDP5_LM_CURSOR_SIZE_ROI_W(uint32_t val)
+{
+        return ((val) << MDP5_LM_CURSOR_SIZE_ROI_W__SHIFT) & MDP5_LM_CURSOR_SIZE_ROI_W__MASK;
+}
+#define MDP5_LM_CURSOR_SIZE_ROI_H__MASK                         0xffff0000
+#define MDP5_LM_CURSOR_SIZE_ROI_H__SHIFT                        16
+static inline uint32_t MDP5_LM_CURSOR_SIZE_ROI_H(uint32_t val)
+{
+        return ((val) << MDP5_LM_CURSOR_SIZE_ROI_H__SHIFT) & MDP5_LM_CURSOR_SIZE_ROI_H__MASK;
+}
 
 static inline uint32_t REG_MDP5_LM_CURSOR_XY(uint32_t i0) { return 0x000000e8 + __offset_LM(i0); }
+#define MDP5_LM_CURSOR_XY_SRC_X__MASK                           0x0000ffff
+#define MDP5_LM_CURSOR_XY_SRC_X__SHIFT                          0
+static inline uint32_t MDP5_LM_CURSOR_XY_SRC_X(uint32_t val)
+{
+        return ((val) << MDP5_LM_CURSOR_XY_SRC_X__SHIFT) & MDP5_LM_CURSOR_XY_SRC_X__MASK;
+}
+#define MDP5_LM_CURSOR_XY_SRC_Y__MASK                           0xffff0000
+#define MDP5_LM_CURSOR_XY_SRC_Y__SHIFT                          16
+static inline uint32_t MDP5_LM_CURSOR_XY_SRC_Y(uint32_t val)
+{
+        return ((val) << MDP5_LM_CURSOR_XY_SRC_Y__SHIFT) & MDP5_LM_CURSOR_XY_SRC_Y__MASK;
+}
 
 static inline uint32_t REG_MDP5_LM_CURSOR_STRIDE(uint32_t i0) { return 0x000000dc + __offset_LM(i0); }
+#define MDP5_LM_CURSOR_STRIDE_STRIDE__MASK                      0x0000ffff
+#define MDP5_LM_CURSOR_STRIDE_STRIDE__SHIFT                     0
+static inline uint32_t MDP5_LM_CURSOR_STRIDE_STRIDE(uint32_t val)
+{
+        return ((val) << MDP5_LM_CURSOR_STRIDE_STRIDE__SHIFT) & MDP5_LM_CURSOR_STRIDE_STRIDE__MASK;
+}
 
 static inline uint32_t REG_MDP5_LM_CURSOR_FORMAT(uint32_t i0) { return 0x000000ec + __offset_LM(i0); }
+#define MDP5_LM_CURSOR_FORMAT_FORMAT__MASK                      0x00000007
+#define MDP5_LM_CURSOR_FORMAT_FORMAT__SHIFT                     0
+static inline uint32_t MDP5_LM_CURSOR_FORMAT_FORMAT(enum mdp5_cursor_format val)
+{
+        return ((val) << MDP5_LM_CURSOR_FORMAT_FORMAT__SHIFT) & MDP5_LM_CURSOR_FORMAT_FORMAT__MASK;
+}
 
 static inline uint32_t REG_MDP5_LM_CURSOR_BASE_ADDR(uint32_t i0) { return 0x000000f0 + __offset_LM(i0); }
 
 static inline uint32_t REG_MDP5_LM_CURSOR_START_XY(uint32_t i0) { return 0x000000f4 + __offset_LM(i0); }
+#define MDP5_LM_CURSOR_START_XY_X_START__MASK                   0x0000ffff
+#define MDP5_LM_CURSOR_START_XY_X_START__SHIFT                  0
+static inline uint32_t MDP5_LM_CURSOR_START_XY_X_START(uint32_t val)
+{
+        return ((val) << MDP5_LM_CURSOR_START_XY_X_START__SHIFT) & MDP5_LM_CURSOR_START_XY_X_START__MASK;
+}
+#define MDP5_LM_CURSOR_START_XY_Y_START__MASK                   0xffff0000
+#define MDP5_LM_CURSOR_START_XY_Y_START__SHIFT                  16
+static inline uint32_t MDP5_LM_CURSOR_START_XY_Y_START(uint32_t val)
+{
+        return ((val) << MDP5_LM_CURSOR_START_XY_Y_START__SHIFT) & MDP5_LM_CURSOR_START_XY_Y_START__MASK;
+}
 
 static inline uint32_t REG_MDP5_LM_CURSOR_BLEND_CONFIG(uint32_t i0) { return 0x000000f8 + __offset_LM(i0); }
+#define MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_EN                    0x00000001
+#define MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_ALPHA_SEL__MASK       0x00000006
+#define MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_ALPHA_SEL__SHIFT      1
+static inline uint32_t MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_ALPHA_SEL(enum mdp5_cursor_alpha val)
+{
+        return ((val) << MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_ALPHA_SEL__SHIFT) & MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_ALPHA_SEL__MASK;
+}
+#define MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_TRANSP_EN             0x00000008
 
 static inline uint32_t REG_MDP5_LM_CURSOR_BLEND_PARAM(uint32_t i0) { return 0x000000fc + __offset_LM(i0); }
 
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c
index 6b25f9f731ed..46fac545dc2b 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c
@@ -24,6 +24,9 @@
 #include "drm_crtc_helper.h"
 #include "drm_flip_work.h"
 
+#define CURSOR_WIDTH    64
+#define CURSOR_HEIGHT   64
+
 #define SSPP_MAX        (SSPP_RGB3 + 1) /* TODO: Add SSPP_MAX in mdp5.xml.h */
 
 struct mdp5_crtc {
@@ -47,8 +50,21 @@ struct mdp5_crtc {
 #define PENDING_FLIP   0x2
         atomic_t pending;
 
+        /* for unref'ing cursor bo's after scanout completes: */
+        struct drm_flip_work unref_cursor_work;
+
         struct mdp_irq vblank;
         struct mdp_irq err;
+
+        struct {
+                /* protect REG_MDP5_LM_CURSOR* registers and cursor scanout_bo*/
+                spinlock_t lock;
+
+                /* current cursor being scanned out: */
+                struct drm_gem_object *scanout_bo;
+                uint32_t width;
+                uint32_t height;
+        } cursor;
 };
 #define to_mdp5_crtc(x) container_of(x, struct mdp5_crtc, base)
 
@@ -129,37 +145,26 @@ static void complete_flip(struct drm_crtc *crtc, struct drm_file *file)
         }
 }
 
+static void unref_cursor_worker(struct drm_flip_work *work, void *val)
+{
+        struct mdp5_crtc *mdp5_crtc =
+                container_of(work, struct mdp5_crtc, unref_cursor_work);
+        struct mdp5_kms *mdp5_kms = get_kms(&mdp5_crtc->base);
+
+        msm_gem_put_iova(val, mdp5_kms->id);
+        drm_gem_object_unreference_unlocked(val);
+}
+
 static void mdp5_crtc_destroy(struct drm_crtc *crtc)
 {
         struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
 
         drm_crtc_cleanup(crtc);
+        drm_flip_work_cleanup(&mdp5_crtc->unref_cursor_work);
 
         kfree(mdp5_crtc);
 }
 
-static void mdp5_crtc_dpms(struct drm_crtc *crtc, int mode)
-{
-        struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
-        struct mdp5_kms *mdp5_kms = get_kms(crtc);
-        bool enabled = (mode == DRM_MODE_DPMS_ON);
-
-        DBG("%s: mode=%d", mdp5_crtc->name, mode);
-
-        if (enabled != mdp5_crtc->enabled) {
-                if (enabled) {
-                        mdp5_enable(mdp5_kms);
-                        mdp_irq_register(&mdp5_kms->base, &mdp5_crtc->err);
-                } else {
-                        /* set STAGE_UNUSED for all layers */
-                        mdp5_ctl_blend(mdp5_crtc->ctl, mdp5_crtc->lm, 0x00000000);
-                        mdp_irq_unregister(&mdp5_kms->base, &mdp5_crtc->err);
-                        mdp5_disable(mdp5_kms);
-                }
-                mdp5_crtc->enabled = enabled;
-        }
-}
-
 static bool mdp5_crtc_mode_fixup(struct drm_crtc *crtc,
                 const struct drm_display_mode *mode,
                 struct drm_display_mode *adjusted_mode)
@@ -256,23 +261,41 @@ static void mdp5_crtc_mode_set_nofb(struct drm_crtc *crtc)
         spin_unlock_irqrestore(&mdp5_crtc->lm_lock, flags);
 }
 
-static void mdp5_crtc_prepare(struct drm_crtc *crtc)
+static void mdp5_crtc_disable(struct drm_crtc *crtc)
 {
         struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
+        struct mdp5_kms *mdp5_kms = get_kms(crtc);
+
         DBG("%s", mdp5_crtc->name);
-        /* make sure we hold a ref to mdp clks while setting up mode: */
-        mdp5_enable(get_kms(crtc));
-        mdp5_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
+
+        if (WARN_ON(!mdp5_crtc->enabled))
+                return;
+
+        /* set STAGE_UNUSED for all layers */
+        mdp5_ctl_blend(mdp5_crtc->ctl, mdp5_crtc->lm, 0x00000000);
+
+        mdp_irq_unregister(&mdp5_kms->base, &mdp5_crtc->err);
+        mdp5_disable(mdp5_kms);
+
+        mdp5_crtc->enabled = false;
 }
 
-static void mdp5_crtc_commit(struct drm_crtc *crtc)
+static void mdp5_crtc_enable(struct drm_crtc *crtc)
 {
         struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
+        struct mdp5_kms *mdp5_kms = get_kms(crtc);
+
         DBG("%s", mdp5_crtc->name);
-        mdp5_crtc_dpms(crtc, DRM_MODE_DPMS_ON);
+
+        if (WARN_ON(mdp5_crtc->enabled))
+                return;
+
+        mdp5_enable(mdp5_kms);
+        mdp_irq_register(&mdp5_kms->base, &mdp5_crtc->err);
+
         crtc_flush_all(crtc);
-        /* drop the ref to mdp clk's that we got in prepare: */
-        mdp5_disable(get_kms(crtc));
+
+        mdp5_crtc->enabled = true;
 }
 
 struct plane_state {
@@ -380,6 +403,132 @@ static int mdp5_crtc_set_property(struct drm_crtc *crtc,
         return -EINVAL;
 }
 
+static int mdp5_crtc_cursor_set(struct drm_crtc *crtc,
+                struct drm_file *file, uint32_t handle,
+                uint32_t width, uint32_t height)
+{
+        struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
+        struct drm_device *dev = crtc->dev;
+        struct mdp5_kms *mdp5_kms = get_kms(crtc);
+        struct drm_gem_object *cursor_bo, *old_bo;
+        uint32_t blendcfg, cursor_addr, stride;
+        int ret, bpp, lm;
+        unsigned int depth;
+        enum mdp5_cursor_alpha cur_alpha = CURSOR_ALPHA_PER_PIXEL;
+        uint32_t flush_mask = mdp_ctl_flush_mask_cursor(0);
+        unsigned long flags;
+
+        if ((width > CURSOR_WIDTH) || (height > CURSOR_HEIGHT)) {
+                dev_err(dev->dev, "bad cursor size: %dx%d\n", width, height);
+                return -EINVAL;
+        }
+
+        if (NULL == mdp5_crtc->ctl)
+                return -EINVAL;
+
+        if (!handle) {
+                DBG("Cursor off");
+                return mdp5_ctl_set_cursor(mdp5_crtc->ctl, false);
+        }
+
+        cursor_bo = drm_gem_object_lookup(dev, file, handle);
+        if (!cursor_bo)
+                return -ENOENT;
+
+        ret = msm_gem_get_iova(cursor_bo, mdp5_kms->id, &cursor_addr);
+        if (ret)
+                return -EINVAL;
+
+        lm = mdp5_crtc->lm;
+        drm_fb_get_bpp_depth(DRM_FORMAT_ARGB8888, &depth, &bpp);
+        stride = width * (bpp >> 3);
+
+        spin_lock_irqsave(&mdp5_crtc->cursor.lock, flags);
+        old_bo = mdp5_crtc->cursor.scanout_bo;
+
+        mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_STRIDE(lm), stride);
+        mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_FORMAT(lm),
+                        MDP5_LM_CURSOR_FORMAT_FORMAT(CURSOR_FMT_ARGB8888));
+        mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_IMG_SIZE(lm),
+                        MDP5_LM_CURSOR_IMG_SIZE_SRC_H(height) |
+                        MDP5_LM_CURSOR_IMG_SIZE_SRC_W(width));
+        mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_SIZE(lm),
+                        MDP5_LM_CURSOR_SIZE_ROI_H(height) |
+                        MDP5_LM_CURSOR_SIZE_ROI_W(width));
+        mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_BASE_ADDR(lm), cursor_addr);
+
+
+        blendcfg = MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_EN;
+        blendcfg |= MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_TRANSP_EN;
+        blendcfg |= MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_ALPHA_SEL(cur_alpha);
+        mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_BLEND_CONFIG(lm), blendcfg);
+
+        mdp5_crtc->cursor.scanout_bo = cursor_bo;
+        mdp5_crtc->cursor.width = width;
+        mdp5_crtc->cursor.height = height;
+        spin_unlock_irqrestore(&mdp5_crtc->cursor.lock, flags);
+
+        ret = mdp5_ctl_set_cursor(mdp5_crtc->ctl, true);
+        if (ret)
+                goto end;
+
+        flush_mask |= mdp5_ctl_get_flush(mdp5_crtc->ctl);
+        crtc_flush(crtc, flush_mask);
+
+end:
+        if (old_bo) {
+                drm_flip_work_queue(&mdp5_crtc->unref_cursor_work, old_bo);
+                /* enable vblank to complete cursor work: */
+                request_pending(crtc, PENDING_CURSOR);
+        }
+        return ret;
+}
+
+static int mdp5_crtc_cursor_move(struct drm_crtc *crtc, int x, int y)
+{
+        struct mdp5_kms *mdp5_kms = get_kms(crtc);
+        struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
+        uint32_t flush_mask = mdp_ctl_flush_mask_cursor(0);
+        uint32_t xres = crtc->mode.hdisplay;
+        uint32_t yres = crtc->mode.vdisplay;
+        uint32_t roi_w;
+        uint32_t roi_h;
+        unsigned long flags;
+
+        x = (x > 0) ? x : 0;
+        y = (y > 0) ? y : 0;
+
+        /*
+         * Cursor Region Of Interest (ROI) is a plane read from cursor
+         * buffer to render. The ROI region is determined by the visiblity of
+         * the cursor point. In the default Cursor image the cursor point will
+         * be at the top left of the cursor image, unless it is specified
+         * otherwise using hotspot feature.
+         *
+         * If the cursor point reaches the right (xres - x < cursor.width) or
+         * bottom (yres - y < cursor.height) boundary of the screen, then ROI
+         * width and ROI height need to be evaluated to crop the cursor image
+         * accordingly.
+         * (xres-x) will be new cursor width when x > (xres - cursor.width)
+         * (yres-y) will be new cursor height when y > (yres - cursor.height)
+         */
+        roi_w = min(mdp5_crtc->cursor.width, xres - x);
+        roi_h = min(mdp5_crtc->cursor.height, yres - y);
+
+        spin_lock_irqsave(&mdp5_crtc->cursor.lock, flags);
+        mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_SIZE(mdp5_crtc->lm),
+                        MDP5_LM_CURSOR_SIZE_ROI_H(roi_h) |
+                        MDP5_LM_CURSOR_SIZE_ROI_W(roi_w));
+        mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_START_XY(mdp5_crtc->lm),
+                        MDP5_LM_CURSOR_START_XY_Y_START(y) |
+                        MDP5_LM_CURSOR_START_XY_X_START(x));
+        spin_unlock_irqrestore(&mdp5_crtc->cursor.lock, flags);
+
+        crtc_flush(crtc, flush_mask);
+
+        return 0;
+}
+
 static const struct drm_crtc_funcs mdp5_crtc_funcs = {
         .set_config = drm_atomic_helper_set_config,
         .destroy = mdp5_crtc_destroy,
@@ -388,16 +537,15 @@ static const struct drm_crtc_funcs mdp5_crtc_funcs = {
         .reset = drm_atomic_helper_crtc_reset,
         .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
         .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
+        .cursor_set = mdp5_crtc_cursor_set,
+        .cursor_move = mdp5_crtc_cursor_move,
 };
 
 static const struct drm_crtc_helper_funcs mdp5_crtc_helper_funcs = {
-        .dpms = mdp5_crtc_dpms,
         .mode_fixup = mdp5_crtc_mode_fixup,
         .mode_set_nofb = mdp5_crtc_mode_set_nofb,
-        .mode_set = drm_helper_crtc_mode_set,
-        .mode_set_base = drm_helper_crtc_mode_set_base,
-        .prepare = mdp5_crtc_prepare,
-        .commit = mdp5_crtc_commit,
+        .prepare = mdp5_crtc_disable,
+        .commit = mdp5_crtc_enable,
         .atomic_check = mdp5_crtc_atomic_check,
         .atomic_begin = mdp5_crtc_atomic_begin,
         .atomic_flush = mdp5_crtc_atomic_flush,
@@ -407,6 +555,7 @@ static void mdp5_crtc_vblank_irq(struct mdp_irq *irq, uint32_t irqstatus)
 {
         struct mdp5_crtc *mdp5_crtc = container_of(irq, struct mdp5_crtc, vblank);
         struct drm_crtc *crtc = &mdp5_crtc->base;
+        struct msm_drm_private *priv = crtc->dev->dev_private;
         unsigned pending;
 
         mdp_irq_unregister(&get_kms(crtc)->base, &mdp5_crtc->vblank);
@@ -416,6 +565,9 @@ static void mdp5_crtc_vblank_irq(struct mdp_irq *irq, uint32_t irqstatus)
         if (pending & PENDING_FLIP) {
                 complete_flip(crtc, NULL);
         }
+
+        if (pending & PENDING_CURSOR)
+                drm_flip_work_commit(&mdp5_crtc->unref_cursor_work, priv->wq);
 }
 
 static void mdp5_crtc_err_irq(struct mdp_irq *irq, uint32_t irqstatus)
@@ -515,6 +667,7 @@ struct drm_crtc *mdp5_crtc_init(struct drm_device *dev,
         mdp5_crtc->lm = GET_LM_ID(id);
 
         spin_lock_init(&mdp5_crtc->lm_lock);
+        spin_lock_init(&mdp5_crtc->cursor.lock);
 
         mdp5_crtc->vblank.irq = mdp5_crtc_vblank_irq;
         mdp5_crtc->err.irq = mdp5_crtc_err_irq;
@@ -523,6 +676,10 @@ struct drm_crtc *mdp5_crtc_init(struct drm_device *dev,
                         pipe2name(mdp5_plane_pipe(plane)), id);
 
         drm_crtc_init_with_planes(dev, crtc, plane, NULL, &mdp5_crtc_funcs);
+
+        drm_flip_work_init(&mdp5_crtc->unref_cursor_work,
+                        "unref cursor", unref_cursor_worker);
+
         drm_crtc_helper_add(crtc, &mdp5_crtc_helper_funcs);
         plane->crtc = crtc;
 
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_ctl.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_ctl.c
index dea4505ac963..151129032d16 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_ctl.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_ctl.c
@@ -95,7 +95,7 @@ u32 ctl_read(struct mdp5_ctl *ctl, u32 reg)
 }
 
 
-int mdp5_ctl_set_intf(struct mdp5_ctl *ctl, enum mdp5_intf intf)
+int mdp5_ctl_set_intf(struct mdp5_ctl *ctl, int intf)
 {
         unsigned long flags;
         static const enum mdp5_intfnum intfnum[] = {
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_ctl.h b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_ctl.h
index 1018519b6af2..ad48788efeea 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_ctl.h
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_ctl.h
@@ -34,7 +34,7 @@ void mdp5_ctlm_destroy(struct mdp5_ctl_manager *ctlm);
  */
 struct mdp5_ctl *mdp5_ctlm_request(struct mdp5_ctl_manager *ctlm, struct drm_crtc *crtc);
 
-int mdp5_ctl_set_intf(struct mdp5_ctl *ctl, enum mdp5_intf intf);
+int mdp5_ctl_set_intf(struct mdp5_ctl *ctl, int intf);
 
 int mdp5_ctl_set_cursor(struct mdp5_ctl *ctl, bool enable);
 
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_encoder.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_encoder.c
index 0254bfdeb92f..d6a14bb99988 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_encoder.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_encoder.c
@@ -1,4 +1,5 @@
 /*
+ * Copyright (c) 2014, The Linux Foundation. All rights reserved.
  * Copyright (C) 2013 Red Hat
  * Author: Rob Clark <robdclark@gmail.com>
  *
@@ -110,45 +111,6 @@ static const struct drm_encoder_funcs mdp5_encoder_funcs = {
         .destroy = mdp5_encoder_destroy,
 };
 
-static void mdp5_encoder_dpms(struct drm_encoder *encoder, int mode)
-{
-        struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder);
-        struct mdp5_kms *mdp5_kms = get_kms(encoder);
-        int intf = mdp5_encoder->intf;
-        bool enabled = (mode == DRM_MODE_DPMS_ON);
-        unsigned long flags;
-
-        DBG("mode=%d", mode);
-
-        if (enabled == mdp5_encoder->enabled)
-                return;
-
-        if (enabled) {
-                bs_set(mdp5_encoder, 1);
-                spin_lock_irqsave(&mdp5_encoder->intf_lock, flags);
-                mdp5_write(mdp5_kms, REG_MDP5_INTF_TIMING_ENGINE_EN(intf), 1);
-                spin_unlock_irqrestore(&mdp5_encoder->intf_lock, flags);
-        } else {
-                spin_lock_irqsave(&mdp5_encoder->intf_lock, flags);
-                mdp5_write(mdp5_kms, REG_MDP5_INTF_TIMING_ENGINE_EN(intf), 0);
-                spin_unlock_irqrestore(&mdp5_encoder->intf_lock, flags);
-
-                /*
-                 * Wait for a vsync so we know the ENABLE=0 latched before
-                 * the (connector) source of the vsync's gets disabled,
-                 * otherwise we end up in a funny state if we re-enable
-                 * before the disable latches, which results that some of
-                 * the settings changes for the new modeset (like new
-                 * scanout buffer) don't latch properly..
-                 */
-                mdp_irq_wait(&mdp5_kms->base, intf2vblank(intf));
-
-                bs_set(mdp5_encoder, 0);
-        }
-
-        mdp5_encoder->enabled = enabled;
-}
-
 static bool mdp5_encoder_mode_fixup(struct drm_encoder *encoder,
                 const struct drm_display_mode *mode,
                 struct drm_display_mode *adjusted_mode)
@@ -162,11 +124,13 @@ static void mdp5_encoder_mode_set(struct drm_encoder *encoder,
 {
         struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder);
         struct mdp5_kms *mdp5_kms = get_kms(encoder);
+        struct drm_device *dev = encoder->dev;
+        struct drm_connector *connector;
         int intf = mdp5_encoder->intf;
         uint32_t dtv_hsync_skew, vsync_period, vsync_len, ctrl_pol;
         uint32_t display_v_start, display_v_end;
         uint32_t hsync_start_x, hsync_end_x;
-        uint32_t format;
+        uint32_t format = 0x2100;
         unsigned long flags;
 
         mode = adjusted_mode;
@@ -188,7 +152,28 @@ static void mdp5_encoder_mode_set(struct drm_encoder *encoder,
         /* probably need to get DATA_EN polarity from panel.. */
 
         dtv_hsync_skew = 0;  /* get this from panel? */
-        format = 0x213f;     /* get this from panel? */
+
+        /* Get color format from panel, default is 8bpc */
+        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                if (connector->encoder == encoder) {
+                        switch (connector->display_info.bpc) {
+                        case 4:
+                                format |= 0;
+                                break;
+                        case 5:
+                                format |= 0x15;
+                                break;
+                        case 6:
+                                format |= 0x2A;
+                                break;
+                        case 8:
+                        default:
+                                format |= 0x3F;
+                                break;
+                        }
+                        break;
+                }
+        }
 
         hsync_start_x = (mode->htotal - mode->hsync_start);
         hsync_end_x = mode->htotal - (mode->hsync_start - mode->hdisplay) - 1;
@@ -198,6 +183,16 @@ static void mdp5_encoder_mode_set(struct drm_encoder *encoder,
         display_v_start = (mode->vtotal - mode->vsync_start) * mode->htotal + dtv_hsync_skew;
         display_v_end = vsync_period - ((mode->vsync_start - mode->vdisplay) * mode->htotal) + dtv_hsync_skew - 1;
 
+        /*
+         * For edp only:
+         * DISPLAY_V_START = (VBP * HCYCLE) + HBP
+         * DISPLAY_V_END = (VBP + VACTIVE) * HCYCLE - 1 - HFP
+         */
+        if (mdp5_encoder->intf_id == INTF_eDP) {
+                display_v_start += mode->htotal - mode->hsync_start;
+                display_v_end -= mode->hsync_start - mode->hdisplay;
+        }
+
         spin_lock_irqsave(&mdp5_encoder->intf_lock, flags);
 
         mdp5_write(mdp5_kms, REG_MDP5_INTF_HSYNC_CTL(intf),
@@ -225,25 +220,61 @@ static void mdp5_encoder_mode_set(struct drm_encoder *encoder,
         spin_unlock_irqrestore(&mdp5_encoder->intf_lock, flags);
 }
 
-static void mdp5_encoder_prepare(struct drm_encoder *encoder)
+static void mdp5_encoder_disable(struct drm_encoder *encoder)
 {
-        mdp5_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
+        struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder);
+        struct mdp5_kms *mdp5_kms = get_kms(encoder);
+        int intf = mdp5_encoder->intf;
+        unsigned long flags;
+
+        if (WARN_ON(!mdp5_encoder->enabled))
+                return;
+
+        spin_lock_irqsave(&mdp5_encoder->intf_lock, flags);
+        mdp5_write(mdp5_kms, REG_MDP5_INTF_TIMING_ENGINE_EN(intf), 0);
+        spin_unlock_irqrestore(&mdp5_encoder->intf_lock, flags);
+
+        /*
+         * Wait for a vsync so we know the ENABLE=0 latched before
+         * the (connector) source of the vsync's gets disabled,
+         * otherwise we end up in a funny state if we re-enable
+         * before the disable latches, which results that some of
+         * the settings changes for the new modeset (like new
+         * scanout buffer) don't latch properly..
+         */
+        mdp_irq_wait(&mdp5_kms->base, intf2vblank(intf));
+
+        bs_set(mdp5_encoder, 0);
+
+        mdp5_encoder->enabled = false;
 }
 
-static void mdp5_encoder_commit(struct drm_encoder *encoder)
+static void mdp5_encoder_enable(struct drm_encoder *encoder)
 {
         struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder);
+        struct mdp5_kms *mdp5_kms = get_kms(encoder);
+        int intf = mdp5_encoder->intf;
+        unsigned long flags;
+
+        if (WARN_ON(mdp5_encoder->enabled))
+                return;
+
         mdp5_crtc_set_intf(encoder->crtc, mdp5_encoder->intf,
                         mdp5_encoder->intf_id);
-        mdp5_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
+
+        bs_set(mdp5_encoder, 1);
+        spin_lock_irqsave(&mdp5_encoder->intf_lock, flags);
+        mdp5_write(mdp5_kms, REG_MDP5_INTF_TIMING_ENGINE_EN(intf), 1);
+        spin_unlock_irqrestore(&mdp5_encoder->intf_lock, flags);
+
+        mdp5_encoder->enabled = false;
 }
 
 static const struct drm_encoder_helper_funcs mdp5_encoder_helper_funcs = {
-        .dpms = mdp5_encoder_dpms,
         .mode_fixup = mdp5_encoder_mode_fixup,
         .mode_set = mdp5_encoder_mode_set,
-        .prepare = mdp5_encoder_prepare,
-        .commit = mdp5_encoder_commit,
+        .prepare = mdp5_encoder_disable,
+        .commit = mdp5_encoder_enable,
 };
 
 /* initialize encoder */
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c
index 9f01a4f21af2..92b61db5754c 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c
@@ -68,6 +68,18 @@ static int mdp5_hw_init(struct msm_kms *kms)
         return 0;
 }
 
+static void mdp5_prepare_commit(struct msm_kms *kms, struct drm_atomic_state *state)
+{
+        struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms));
+        mdp5_enable(mdp5_kms);
+}
+
+static void mdp5_complete_commit(struct msm_kms *kms, struct drm_atomic_state *state)
+{
+        struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms));
+        mdp5_disable(mdp5_kms);
+}
+
 static long mdp5_round_pixclk(struct msm_kms *kms, unsigned long rate,
                 struct drm_encoder *encoder)
 {
@@ -115,6 +127,8 @@ static const struct mdp_kms_funcs kms_funcs = {
                 .irq             = mdp5_irq,
                 .enable_vblank   = mdp5_enable_vblank,
                 .disable_vblank  = mdp5_disable_vblank,
+                .prepare_commit  = mdp5_prepare_commit,
+                .complete_commit = mdp5_complete_commit,
                 .get_format      = mdp_get_format,
                 .round_pixclk    = mdp5_round_pixclk,
                 .preclose        = mdp5_preclose,
@@ -208,19 +222,18 @@ static int modeset_init(struct mdp5_kms *mdp5_kms)
                 }
         }
 
-        /* Construct encoder for HDMI: */
-        encoder = mdp5_encoder_init(dev, 3, INTF_HDMI);
-        if (IS_ERR(encoder)) {
-                dev_err(dev->dev, "failed to construct encoder\n");
-                ret = PTR_ERR(encoder);
-                goto fail;
-        }
+        if (priv->hdmi) {
+                /* Construct encoder for HDMI: */
+                encoder = mdp5_encoder_init(dev, 3, INTF_HDMI);
+                if (IS_ERR(encoder)) {
+                        dev_err(dev->dev, "failed to construct encoder\n");
+                        ret = PTR_ERR(encoder);
+                        goto fail;
+                }
 
-        encoder->possible_crtcs = (1 << priv->num_crtcs) - 1;;
-        priv->encoders[priv->num_encoders++] = encoder;
+                encoder->possible_crtcs = (1 << priv->num_crtcs) - 1;;
+                priv->encoders[priv->num_encoders++] = encoder;
 
-        /* Construct bridge/connector for HDMI: */
-        if (priv->hdmi) {
                 ret = hdmi_modeset_init(priv->hdmi, dev, encoder);
                 if (ret) {
                         dev_err(dev->dev, "failed to initialize HDMI: %d\n", ret);
@@ -228,6 +241,27 @@ static int modeset_init(struct mdp5_kms *mdp5_kms)
                 }
         }
 
+        if (priv->edp) {
+                /* Construct encoder for eDP: */
+                encoder = mdp5_encoder_init(dev, 0, INTF_eDP);
+                if (IS_ERR(encoder)) {
+                        dev_err(dev->dev, "failed to construct eDP encoder\n");
+                        ret = PTR_ERR(encoder);
+                        goto fail;
+                }
+
+                encoder->possible_crtcs = (1 << priv->num_crtcs) - 1;
+                priv->encoders[priv->num_encoders++] = encoder;
+
+                /* Construct bridge/connector for eDP: */
+                ret = msm_edp_modeset_init(priv->edp, dev, encoder);
+                if (ret) {
+                        dev_err(dev->dev, "failed to initialize eDP: %d\n",
+                                                                        ret);
+                        goto fail;
+                }
+        }
+
         return 0;
 
 fail:
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h
index dd69c77c0d64..49d011e8835b 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h
@@ -165,14 +165,25 @@ void mdp5_disable_vblank(struct msm_kms *kms, struct drm_crtc *crtc);
 int mdp5_irq_domain_init(struct mdp5_kms *mdp5_kms);
 void mdp5_irq_domain_fini(struct mdp5_kms *mdp5_kms);
 
+static inline bool pipe_supports_yuv(enum mdp5_pipe pipe)
+{
+        switch (pipe) {
+        case SSPP_VIG0:
+        case SSPP_VIG1:
+        case SSPP_VIG2:
+        case SSPP_VIG3:
+                return true;
+        default:
+                return false;
+        }
+}
+
 static inline
 uint32_t mdp5_get_formats(enum mdp5_pipe pipe, uint32_t *pixel_formats,
                 uint32_t max_formats)
 {
-        /* TODO when we have YUV, we need to filter supported formats
-         * based on pipe id..
-         */
-        return mdp_get_formats(pixel_formats, max_formats);
+        return mdp_get_formats(pixel_formats, max_formats,
+                                !pipe_supports_yuv(pipe));
 }
 
 void mdp5_plane_install_properties(struct drm_plane *plane,
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
index fc76f630e5b1..05cf9ab2a876 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
@@ -18,8 +18,6 @@
 
 #include "mdp5_kms.h"
 
-#define MAX_PLANE       4
-
 struct mdp5_plane {
         struct drm_plane base;
         const char *name;
@@ -278,6 +276,155 @@ static void set_scanout_locked(struct drm_plane *plane,
         plane->fb = fb;
 }
 
+/* Note: mdp5_plane->pipe_lock must be locked */
+static void csc_disable(struct mdp5_kms *mdp5_kms, enum mdp5_pipe pipe)
+{
+        uint32_t value = mdp5_read(mdp5_kms, REG_MDP5_PIPE_OP_MODE(pipe)) &
+                         ~MDP5_PIPE_OP_MODE_CSC_1_EN;
+
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_OP_MODE(pipe), value);
+}
+
+/* Note: mdp5_plane->pipe_lock must be locked */
+static void csc_enable(struct mdp5_kms *mdp5_kms, enum mdp5_pipe pipe,
+                struct csc_cfg *csc)
+{
+        uint32_t  i, mode = 0; /* RGB, no CSC */
+        uint32_t *matrix;
+
+        if (unlikely(!csc))
+                return;
+
+        if ((csc->type == CSC_YUV2RGB) || (CSC_YUV2YUV == csc->type))
+                mode |= MDP5_PIPE_OP_MODE_CSC_SRC_DATA_FORMAT(DATA_FORMAT_YUV);
+        if ((csc->type == CSC_RGB2YUV) || (CSC_YUV2YUV == csc->type))
+                mode |= MDP5_PIPE_OP_MODE_CSC_DST_DATA_FORMAT(DATA_FORMAT_YUV);
+        mode |= MDP5_PIPE_OP_MODE_CSC_1_EN;
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_OP_MODE(pipe), mode);
+
+        matrix = csc->matrix;
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_CSC_1_MATRIX_COEFF_0(pipe),
+                        MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_11(matrix[0]) |
+                        MDP5_PIPE_CSC_1_MATRIX_COEFF_0_COEFF_12(matrix[1]));
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_CSC_1_MATRIX_COEFF_1(pipe),
+                        MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_13(matrix[2]) |
+                        MDP5_PIPE_CSC_1_MATRIX_COEFF_1_COEFF_21(matrix[3]));
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_CSC_1_MATRIX_COEFF_2(pipe),
+                        MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_22(matrix[4]) |
+                        MDP5_PIPE_CSC_1_MATRIX_COEFF_2_COEFF_23(matrix[5]));
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_CSC_1_MATRIX_COEFF_3(pipe),
+                        MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_31(matrix[6]) |
+                        MDP5_PIPE_CSC_1_MATRIX_COEFF_3_COEFF_32(matrix[7]));
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_CSC_1_MATRIX_COEFF_4(pipe),
+                        MDP5_PIPE_CSC_1_MATRIX_COEFF_4_COEFF_33(matrix[8]));
+
+        for (i = 0; i < ARRAY_SIZE(csc->pre_bias); i++) {
+                uint32_t *pre_clamp = csc->pre_clamp;
+                uint32_t *post_clamp = csc->post_clamp;
+
+                mdp5_write(mdp5_kms, REG_MDP5_PIPE_CSC_1_PRE_CLAMP(pipe, i),
+                        MDP5_PIPE_CSC_1_PRE_CLAMP_REG_HIGH(pre_clamp[2*i+1]) |
+                        MDP5_PIPE_CSC_1_PRE_CLAMP_REG_LOW(pre_clamp[2*i]));
+
+                mdp5_write(mdp5_kms, REG_MDP5_PIPE_CSC_1_POST_CLAMP(pipe, i),
+                        MDP5_PIPE_CSC_1_POST_CLAMP_REG_HIGH(post_clamp[2*i+1]) |
+                        MDP5_PIPE_CSC_1_POST_CLAMP_REG_LOW(post_clamp[2*i]));
+
+                mdp5_write(mdp5_kms, REG_MDP5_PIPE_CSC_1_PRE_BIAS(pipe, i),
+                        MDP5_PIPE_CSC_1_PRE_BIAS_REG_VALUE(csc->pre_bias[i]));
+
+                mdp5_write(mdp5_kms, REG_MDP5_PIPE_CSC_1_POST_BIAS(pipe, i),
+                        MDP5_PIPE_CSC_1_POST_BIAS_REG_VALUE(csc->post_bias[i]));
+        }
+}
+
+#define PHASE_STEP_SHIFT        21
+#define DOWN_SCALE_RATIO_MAX    32      /* 2^(26-21) */
+
+static int calc_phase_step(uint32_t src, uint32_t dst, uint32_t *out_phase)
+{
+        uint32_t unit;
+
+        if (src == 0 || dst == 0)
+                return -EINVAL;
+
+        /*
+         * PHASE_STEP_X/Y is coded on 26 bits (25:0),
+         * where 2^21 represents the unity "1" in fixed-point hardware design.
+         * This leaves 5 bits for the integer part (downscale case):
+         *      -> maximum downscale ratio = 0b1_1111 = 31
+         */
+        if (src > (dst * DOWN_SCALE_RATIO_MAX))
+                return -EOVERFLOW;
+
+        unit = 1 << PHASE_STEP_SHIFT;
+        *out_phase = mult_frac(unit, src, dst);
+
+        return 0;
+}
+
+static int calc_scalex_steps(uint32_t pixel_format, uint32_t src, uint32_t dest,
+                uint32_t phasex_steps[2])
+{
+        uint32_t phasex_step;
+        unsigned int hsub;
+        int ret;
+
+        ret = calc_phase_step(src, dest, &phasex_step);
+        if (ret)
+                return ret;
+
+        hsub = drm_format_horz_chroma_subsampling(pixel_format);
+
+        phasex_steps[0] = phasex_step;
+        phasex_steps[1] = phasex_step / hsub;
+
+        return 0;
+}
+
+static int calc_scaley_steps(uint32_t pixel_format, uint32_t src, uint32_t dest,
+                uint32_t phasey_steps[2])
+{
+        uint32_t phasey_step;
+        unsigned int vsub;
+        int ret;
+
+        ret = calc_phase_step(src, dest, &phasey_step);
+        if (ret)
+                return ret;
+
+        vsub = drm_format_vert_chroma_subsampling(pixel_format);
+
+        phasey_steps[0] = phasey_step;
+        phasey_steps[1] = phasey_step / vsub;
+
+        return 0;
+}
+
+static uint32_t get_scalex_config(uint32_t src, uint32_t dest)
+{
+        uint32_t filter;
+
+        filter = (src <= dest) ? SCALE_FILTER_BIL : SCALE_FILTER_PCMN;
+
+        return  MDP5_PIPE_SCALE_CONFIG_SCALEX_EN |
+                MDP5_PIPE_SCALE_CONFIG_SCALEX_MIN_FILTER(filter) |
+                MDP5_PIPE_SCALE_CONFIG_SCALEX_CR_FILTER(filter)  |
+                MDP5_PIPE_SCALE_CONFIG_SCALEX_MAX_FILTER(filter);
+}
+
+static uint32_t get_scaley_config(uint32_t src, uint32_t dest)
+{
+        uint32_t filter;
+
+        filter = (src <= dest) ? SCALE_FILTER_BIL : SCALE_FILTER_PCMN;
+
+        return  MDP5_PIPE_SCALE_CONFIG_SCALEY_EN |
+                MDP5_PIPE_SCALE_CONFIG_SCALEY_MIN_FILTER(filter) |
+                MDP5_PIPE_SCALE_CONFIG_SCALEY_CR_FILTER(filter)  |
+                MDP5_PIPE_SCALE_CONFIG_SCALEY_MAX_FILTER(filter);
+}
+
 static int mdp5_plane_mode_set(struct drm_plane *plane,
                 struct drm_crtc *crtc, struct drm_framebuffer *fb,
                 int crtc_x, int crtc_y,
@@ -287,11 +434,14 @@ static int mdp5_plane_mode_set(struct drm_plane *plane,
 {
         struct mdp5_plane *mdp5_plane = to_mdp5_plane(plane);
         struct mdp5_kms *mdp5_kms = get_kms(plane);
+        struct device *dev = mdp5_kms->dev->dev;
         enum mdp5_pipe pipe = mdp5_plane->pipe;
         const struct mdp_format *format;
         uint32_t nplanes, config = 0;
-        uint32_t phasex_step = 0, phasey_step = 0;
+        /* below array -> index 0: comp 0/3 ; index 1: comp 1/2 */
+        uint32_t phasex_step[2] = {0,}, phasey_step[2] = {0,};
         uint32_t hdecm = 0, vdecm = 0;
+        uint32_t pix_format;
         unsigned long flags;
         int ret;
 
@@ -301,6 +451,9 @@ static int mdp5_plane_mode_set(struct drm_plane *plane,
         if (WARN_ON(nplanes > pipe2nclients(pipe)))
                 return -EINVAL;
 
+        format = to_mdp_format(msm_framebuffer_format(fb));
+        pix_format = format->base.pixel_format;
+
         /* src values are in Q16 fixed point, convert to integer: */
         src_x = src_x >> 16;
         src_y = src_y >> 16;
@@ -325,14 +478,28 @@ static int mdp5_plane_mode_set(struct drm_plane *plane,
          */
         mdp5_smp_configure(mdp5_kms->smp, pipe);
 
-        if (src_w != crtc_w) {
-                config |= MDP5_PIPE_SCALE_CONFIG_SCALEX_EN;
-                /* TODO calc phasex_step, hdecm */
+        /* SCALE is used to both scale and up-sample chroma components */
+
+        if ((src_w != crtc_w) || MDP_FORMAT_IS_YUV(format)) {
+                /* TODO calc hdecm */
+                ret = calc_scalex_steps(pix_format, src_w, crtc_w, phasex_step);
+                if (ret) {
+                        dev_err(dev, "X scaling (%d -> %d) failed: %d\n",
+                                        src_w, crtc_w, ret);
+                        return ret;
+                }
+                config |= get_scalex_config(src_w, crtc_w);
         }
 
-        if (src_h != crtc_h) {
-                config |= MDP5_PIPE_SCALE_CONFIG_SCALEY_EN;
-                /* TODO calc phasey_step, vdecm */
+        if ((src_h != crtc_h) || MDP_FORMAT_IS_YUV(format)) {
+                /* TODO calc vdecm */
+                ret = calc_scaley_steps(pix_format, src_h, crtc_h, phasey_step);
+                if (ret) {
+                        dev_err(dev, "Y scaling (%d -> %d) failed: %d\n",
+                                        src_h, crtc_h, ret);
+                        return ret;
+                }
+                config |= get_scaley_config(src_h, crtc_h);
         }
 
         spin_lock_irqsave(&mdp5_plane->pipe_lock, flags);
@@ -357,8 +524,6 @@ static int mdp5_plane_mode_set(struct drm_plane *plane,
                         MDP5_PIPE_OUT_XY_X(crtc_x) |
                         MDP5_PIPE_OUT_XY_Y(crtc_y));
 
-        format = to_mdp_format(msm_framebuffer_format(fb));
-
         mdp5_write(mdp5_kms, REG_MDP5_PIPE_SRC_FORMAT(pipe),
                         MDP5_PIPE_SRC_FORMAT_A_BPC(format->bpc_a) |
                         MDP5_PIPE_SRC_FORMAT_R_BPC(format->bpc_r) |
@@ -368,8 +533,8 @@ static int mdp5_plane_mode_set(struct drm_plane *plane,
                         MDP5_PIPE_SRC_FORMAT_CPP(format->cpp - 1) |
                         MDP5_PIPE_SRC_FORMAT_UNPACK_COUNT(format->unpack_count - 1) |
                         COND(format->unpack_tight, MDP5_PIPE_SRC_FORMAT_UNPACK_TIGHT) |
-                        MDP5_PIPE_SRC_FORMAT_NUM_PLANES(nplanes - 1) |
-                        MDP5_PIPE_SRC_FORMAT_CHROMA_SAMP(CHROMA_RGB));
+                        MDP5_PIPE_SRC_FORMAT_NUM_PLANES(format->fetch_type) |
+                        MDP5_PIPE_SRC_FORMAT_CHROMA_SAMP(format->chroma_sample));
 
         mdp5_write(mdp5_kms, REG_MDP5_PIPE_SRC_UNPACK(pipe),
                         MDP5_PIPE_SRC_UNPACK_ELEM0(format->unpack[0]) |
@@ -383,18 +548,24 @@ static int mdp5_plane_mode_set(struct drm_plane *plane,
         /* not using secure mode: */
         mdp5_write(mdp5_kms, REG_MDP5_PIPE_SRC_ADDR_SW_STATUS(pipe), 0);
 
-        mdp5_write(mdp5_kms, REG_MDP5_PIPE_SCALE_PHASE_STEP_X(pipe), phasex_step);
-        mdp5_write(mdp5_kms, REG_MDP5_PIPE_SCALE_PHASE_STEP_Y(pipe), phasey_step);
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_SCALE_PHASE_STEP_X(pipe),
+                        phasex_step[0]);
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_SCALE_PHASE_STEP_Y(pipe),
+                        phasey_step[0]);
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_SCALE_CR_PHASE_STEP_X(pipe),
+                        phasex_step[1]);
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_SCALE_CR_PHASE_STEP_Y(pipe),
+                        phasey_step[1]);
         mdp5_write(mdp5_kms, REG_MDP5_PIPE_DECIMATION(pipe),
                         MDP5_PIPE_DECIMATION_VERT(vdecm) |
                         MDP5_PIPE_DECIMATION_HORZ(hdecm));
-        mdp5_write(mdp5_kms, REG_MDP5_PIPE_SCALE_CONFIG(pipe),
-                        MDP5_PIPE_SCALE_CONFIG_SCALEX_MIN_FILTER(SCALE_FILTER_NEAREST) |
-                        MDP5_PIPE_SCALE_CONFIG_SCALEY_MIN_FILTER(SCALE_FILTER_NEAREST) |
-                        MDP5_PIPE_SCALE_CONFIG_SCALEX_CR_FILTER(SCALE_FILTER_NEAREST) |
-                        MDP5_PIPE_SCALE_CONFIG_SCALEY_CR_FILTER(SCALE_FILTER_NEAREST) |
-                        MDP5_PIPE_SCALE_CONFIG_SCALEX_MAX_FILTER(SCALE_FILTER_NEAREST) |
-                        MDP5_PIPE_SCALE_CONFIG_SCALEY_MAX_FILTER(SCALE_FILTER_NEAREST));
+        mdp5_write(mdp5_kms, REG_MDP5_PIPE_SCALE_CONFIG(pipe), config);
+
+        if (MDP_FORMAT_IS_YUV(format))
+                csc_enable(mdp5_kms, pipe,
+                                mdp_get_default_csc_cfg(CSC_YUV2RGB));
+        else
+                csc_disable(mdp5_kms, pipe);
 
         set_scanout_locked(plane, fb);
 
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.c
index bf551885e019..1f795af89680 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.c
@@ -119,9 +119,10 @@ static int smp_request_block(struct mdp5_smp *smp,
 
         spin_lock_irqsave(&smp->state_lock, flags);
 
-        nblks -= reserved;
-        if (reserved)
+        if (reserved) {
+                nblks = max(0, nblks - reserved);
                 DBG("%d MMBs allocated (%d reserved)", nblks, reserved);
+        }
 
         avail = cnt - bitmap_weight(smp->state, cnt);
         if (nblks > avail) {
diff --git a/drivers/gpu/drm/msm/mdp/mdp_common.xml.h b/drivers/gpu/drm/msm/mdp/mdp_common.xml.h
index 64c1afd6030a..a1d35f162c7f 100644
--- a/drivers/gpu/drm/msm/mdp/mdp_common.xml.h
+++ b/drivers/gpu/drm/msm/mdp/mdp_common.xml.h
@@ -8,18 +8,19 @@ http://github.com/freedreno/envytools/
 git clone https://github.com/freedreno/envytools.git
 
 The rules-ng-ng source files this header was generated from are:
-- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    647 bytes, from 2013-11-30 14:45:35)
+- /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    676 bytes, from 2014-12-05 15:34:49)
 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml (   1453 bytes, from 2013-03-31 16:51:27)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  17996 bytes, from 2013-12-01 19:10:31)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   1615 bytes, from 2013-11-30 15:00:52)
-- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  22517 bytes, from 2014-06-25 12:55:02)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp4.xml            (  20908 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp_common.xml      (   2357 bytes, from 2014-12-08 16:13:00)
+- /home/robclark/src/freedreno/envytools/rnndb/mdp/mdp5.xml            (  27208 bytes, from 2015-01-13 23:56:11)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/dsi.xml             (  11712 bytes, from 2013-08-17 17:13:43)
 - /home/robclark/src/freedreno/envytools/rnndb/dsi/sfpb.xml            (    344 bytes, from 2013-08-11 19:26:32)
-- /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1544 bytes, from 2013-08-16 19:17:05)
+- /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1686 bytes, from 2014-10-31 16:48:57)
 - /home/robclark/src/freedreno/envytools/rnndb/hdmi/qfprom.xml         (    600 bytes, from 2013-07-05 19:21:12)
-- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  23613 bytes, from 2014-06-25 12:53:44)
+- /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  26848 bytes, from 2015-01-13 23:55:57)
+- /home/robclark/src/freedreno/envytools/rnndb/edp/edp.xml             (   8253 bytes, from 2014-12-08 16:13:00)
 
-Copyright (C) 2013 by the following authors:
+Copyright (C) 2013-2014 by the following authors:
 - Rob Clark <robdclark@gmail.com> (robclark)
 
 Permission is hereby granted, free of charge, to any person obtaining
@@ -44,6 +45,19 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 
+enum mdp_chroma_samp_type {
+        CHROMA_RGB = 0,
+        CHROMA_H2V1 = 1,
+        CHROMA_H1V2 = 2,
+        CHROMA_420 = 3,
+};
+
+enum mdp_sspp_fetch_type {
+        MDP_PLANE_INTERLEAVED = 0,
+        MDP_PLANE_PLANAR = 1,
+        MDP_PLANE_PSEUDO_PLANAR = 2,
+};
+
 enum mdp_mixer_stage_id {
         STAGE_UNUSED = 0,
         STAGE_BASE = 1,
diff --git a/drivers/gpu/drm/msm/mdp/mdp_format.c b/drivers/gpu/drm/msm/mdp/mdp_format.c
index e0a6ffbe6ab4..f683433b6727 100644
--- a/drivers/gpu/drm/msm/mdp/mdp_format.c
+++ b/drivers/gpu/drm/msm/mdp/mdp_format.c
@@ -1,4 +1,5 @@
 /*
+ * Copyright (c) 2014 The Linux Foundation. All rights reserved.
  * Copyright (C) 2013 Red Hat
  * Author: Rob Clark <robdclark@gmail.com>
  *
@@ -19,7 +20,58 @@
 #include "msm_drv.h"
 #include "mdp_kms.h"
 
-#define FMT(name, a, r, g, b, e0, e1, e2, e3, alpha, tight, c, cnt) { \
+static struct csc_cfg csc_convert[CSC_MAX] = {
+        [CSC_RGB2RGB] = {
+                .type = CSC_RGB2RGB,
+                .matrix = {
+                        0x0200, 0x0000, 0x0000,
+                        0x0000, 0x0200, 0x0000,
+                        0x0000, 0x0000, 0x0200
+                },
+                .pre_bias =     { 0x0, 0x0, 0x0 },
+                .post_bias =    { 0x0, 0x0, 0x0 },
+                .pre_clamp =    { 0x0, 0xff, 0x0, 0xff, 0x0, 0xff },
+                .post_clamp =   { 0x0, 0xff, 0x0, 0xff, 0x0, 0xff },
+        },
+        [CSC_YUV2RGB] = {
+                .type = CSC_YUV2RGB,
+                .matrix = {
+                        0x0254, 0x0000, 0x0331,
+                        0x0254, 0xff37, 0xfe60,
+                        0x0254, 0x0409, 0x0000
+                },
+                .pre_bias =     { 0xfff0, 0xff80, 0xff80 },
+                .post_bias =    { 0x00, 0x00, 0x00 },
+                .pre_clamp =    { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff },
+                .post_clamp =   { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff },
+        },
+        [CSC_RGB2YUV] = {
+                .type = CSC_RGB2YUV,
+                .matrix = {
+                        0x0083, 0x0102, 0x0032,
+                        0x1fb5, 0x1f6c, 0x00e1,
+                        0x00e1, 0x1f45, 0x1fdc
+                },
+                .pre_bias =     { 0x00, 0x00, 0x00 },
+                .post_bias =    { 0x10, 0x80, 0x80 },
+                .pre_clamp =    { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff },
+                .post_clamp =   { 0x10, 0xeb, 0x10, 0xf0, 0x10, 0xf0 },
+        },
+        [CSC_YUV2YUV] = {
+                .type = CSC_YUV2YUV,
+                .matrix = {
+                        0x0200, 0x0000, 0x0000,
+                        0x0000, 0x0200, 0x0000,
+                        0x0000, 0x0000, 0x0200
+                },
+                .pre_bias =     { 0x00, 0x00, 0x00 },
+                .post_bias =    { 0x00, 0x00, 0x00 },
+                .pre_clamp =    { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff },
+                .post_clamp =   { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff },
+        },
+};
+
+#define FMT(name, a, r, g, b, e0, e1, e2, e3, alpha, tight, c, cnt, fp, cs) { \
                 .base = { .pixel_format = DRM_FORMAT_ ## name }, \
                 .bpc_a = BPC ## a ## A,                          \
                 .bpc_r = BPC ## r,                               \
@@ -30,21 +82,46 @@
                 .unpack_tight = tight,                           \
                 .cpp = c,                                        \
                 .unpack_count = cnt,                             \
-        }
+                .fetch_type = fp,                                \
+                .chroma_sample = cs                              \
+}
 
 #define BPC0A 0
 
+/*
+ * Note: Keep RGB formats 1st, followed by YUV formats to avoid breaking
+ * mdp_get_rgb_formats()'s implementation.
+ */
 static const struct mdp_format formats[] = {
-        /*  name      a  r  g  b   e0 e1 e2 e3  alpha   tight  cpp cnt */
-        FMT(ARGB8888, 8, 8, 8, 8,  1, 0, 2, 3,  true,   true,  4,  4),
-        FMT(XRGB8888, 8, 8, 8, 8,  1, 0, 2, 3,  false,  true,  4,  4),
-        FMT(RGB888,   0, 8, 8, 8,  1, 0, 2, 0,  false,  true,  3,  3),
-        FMT(BGR888,   0, 8, 8, 8,  2, 0, 1, 0,  false,  true,  3,  3),
-        FMT(RGB565,   0, 5, 6, 5,  1, 0, 2, 0,  false,  true,  2,  3),
-        FMT(BGR565,   0, 5, 6, 5,  2, 0, 1, 0,  false,  true,  2,  3),
+        /*  name      a  r  g  b   e0 e1 e2 e3  alpha   tight  cpp cnt ... */
+        FMT(ARGB8888, 8, 8, 8, 8,  1, 0, 2, 3,  true,   true,  4,  4,
+                        MDP_PLANE_INTERLEAVED, CHROMA_RGB),
+        FMT(XRGB8888, 8, 8, 8, 8,  1, 0, 2, 3,  false,  true,  4,  4,
+                        MDP_PLANE_INTERLEAVED, CHROMA_RGB),
+        FMT(RGB888,   0, 8, 8, 8,  1, 0, 2, 0,  false,  true,  3,  3,
+                        MDP_PLANE_INTERLEAVED, CHROMA_RGB),
+        FMT(BGR888,   0, 8, 8, 8,  2, 0, 1, 0,  false,  true,  3,  3,
+                        MDP_PLANE_INTERLEAVED, CHROMA_RGB),
+        FMT(RGB565,   0, 5, 6, 5,  1, 0, 2, 0,  false,  true,  2,  3,
+                        MDP_PLANE_INTERLEAVED, CHROMA_RGB),
+        FMT(BGR565,   0, 5, 6, 5,  2, 0, 1, 0,  false,  true,  2,  3,
+                        MDP_PLANE_INTERLEAVED, CHROMA_RGB),
+
+        /* --- RGB formats above / YUV formats below this line --- */
+
+        FMT(NV12,     0, 8, 8, 8,  1, 2, 0, 0,  false,  true,  2, 2,
+                        MDP_PLANE_PSEUDO_PLANAR, CHROMA_420),
+        FMT(NV21,     0, 8, 8, 8,  2, 1, 0, 0,  false,  true,  2, 2,
+                        MDP_PLANE_PSEUDO_PLANAR, CHROMA_420),
 };
 
-uint32_t mdp_get_formats(uint32_t *pixel_formats, uint32_t max_formats)
+/*
+ * Note:
+ * @rgb_only must be set to true, when requesting
+ * supported formats for RGB pipes.
+ */
+uint32_t mdp_get_formats(uint32_t *pixel_formats, uint32_t max_formats,
+                bool rgb_only)
 {
         uint32_t i;
         for (i = 0; i < ARRAY_SIZE(formats); i++) {
@@ -53,6 +130,9 @@ uint32_t mdp_get_formats(uint32_t *pixel_formats, uint32_t max_formats)
                 if (i == max_formats)
                         break;
 
+                if (rgb_only && MDP_FORMAT_IS_YUV(f))
+                        break;
+
                 pixel_formats[i] = f->base.pixel_format;
         }
 
@@ -69,3 +149,11 @@ const struct msm_format *mdp_get_format(struct msm_kms *kms, uint32_t format)
         }
         return NULL;
 }
+
+struct csc_cfg *mdp_get_default_csc_cfg(enum csc_type type)
+{
+        if (unlikely(WARN_ON(type >= CSC_MAX)))
+                return NULL;
+
+        return &csc_convert[type];
+}
diff --git a/drivers/gpu/drm/msm/mdp/mdp_kms.c b/drivers/gpu/drm/msm/mdp/mdp_kms.c
index 2a731722d840..1988c243f437 100644
--- a/drivers/gpu/drm/msm/mdp/mdp_kms.c
+++ b/drivers/gpu/drm/msm/mdp/mdp_kms.c
@@ -34,7 +34,7 @@ static void update_irq(struct mdp_kms *mdp_kms)
         struct mdp_irq *irq;
         uint32_t irqmask = mdp_kms->vblank_mask;
 
-        BUG_ON(!spin_is_locked(&list_lock));
+        assert_spin_locked(&list_lock);
 
         list_for_each_entry(irq, &mdp_kms->irq_list, node)
                 irqmask |= irq->irqmask;
diff --git a/drivers/gpu/drm/msm/mdp/mdp_kms.h b/drivers/gpu/drm/msm/mdp/mdp_kms.h
index b268ce95d394..5ae4039d68e4 100644
--- a/drivers/gpu/drm/msm/mdp/mdp_kms.h
+++ b/drivers/gpu/drm/msm/mdp/mdp_kms.h
@@ -88,10 +88,32 @@ struct mdp_format {
         uint8_t unpack[4];
         bool alpha_enable, unpack_tight;
         uint8_t cpp, unpack_count;
+        enum mdp_sspp_fetch_type fetch_type;
+        enum mdp_chroma_samp_type chroma_sample;
 };
 #define to_mdp_format(x) container_of(x, struct mdp_format, base)
+#define MDP_FORMAT_IS_YUV(mdp_format) ((mdp_format)->chroma_sample > CHROMA_RGB)
 
-uint32_t mdp_get_formats(uint32_t *formats, uint32_t max_formats);
+uint32_t mdp_get_formats(uint32_t *formats, uint32_t max_formats, bool rgb_only);
 const struct msm_format *mdp_get_format(struct msm_kms *kms, uint32_t format);
 
+enum csc_type {
+        CSC_RGB2RGB = 0,
+        CSC_YUV2RGB,
+        CSC_RGB2YUV,
+        CSC_YUV2YUV,
+        CSC_MAX
+};
+
+struct csc_cfg {
+        enum csc_type type;
+        uint32_t matrix[9];
+        uint32_t pre_bias[3];
+        uint32_t post_bias[3];
+        uint32_t pre_clamp[6];
+        uint32_t post_clamp[6];
+};
+
+struct csc_cfg *mdp_get_default_csc_cfg(enum csc_type);
+
 #endif /* __MDP_KMS_H__ */
diff --git a/drivers/gpu/drm/msm/msm_atomic.c b/drivers/gpu/drm/msm/msm_atomic.c
index 2c396540e279..871aa2108dc6 100644
--- a/drivers/gpu/drm/msm/msm_atomic.c
+++ b/drivers/gpu/drm/msm/msm_atomic.c
@@ -20,6 +20,7 @@
 #include "msm_gem.h"
 
 struct msm_commit {
+        struct drm_device *dev;
         struct drm_atomic_state *state;
         uint32_t fence;
         struct msm_fence_cb fence_cb;
@@ -58,14 +59,16 @@ static void end_atomic(struct msm_drm_private *priv, uint32_t crtc_mask)
         spin_unlock(&priv->pending_crtcs_event.lock);
 }
 
-static struct msm_commit *new_commit(struct drm_atomic_state *state)
+static struct msm_commit *commit_init(struct drm_atomic_state *state)
 {
         struct msm_commit *c = kzalloc(sizeof(*c), GFP_KERNEL);
 
         if (!c)
                 return NULL;
 
+        c->dev = state->dev;
         c->state = state;
+
         /* TODO we might need a way to indicate to run the cb on a
          * different wq so wait_for_vblanks() doesn't block retiring
          * bo's..
@@ -75,6 +78,12 @@ static struct msm_commit *new_commit(struct drm_atomic_state *state)
         return c;
 }
 
+static void commit_destroy(struct msm_commit *c)
+{
+        end_atomic(c->dev->dev_private, c->crtc_mask);
+        kfree(c);
+}
+
 /* The (potentially) asynchronous part of the commit.  At this point
  * nothing can fail short of armageddon.
  */
@@ -82,6 +91,10 @@ static void complete_commit(struct msm_commit *c)
 {
         struct drm_atomic_state *state = c->state;
         struct drm_device *dev = state->dev;
+        struct msm_drm_private *priv = dev->dev_private;
+        struct msm_kms *kms = priv->kms;
+
+        kms->funcs->prepare_commit(kms, state);
 
         drm_atomic_helper_commit_pre_planes(dev, state);
 
@@ -106,11 +119,11 @@ static void complete_commit(struct msm_commit *c)
 
         drm_atomic_helper_cleanup_planes(dev, state);
 
-        drm_atomic_state_free(state);
+        kms->funcs->complete_commit(kms, state);
 
-        end_atomic(dev->dev_private, c->crtc_mask);
+        drm_atomic_state_free(state);
 
-        kfree(c);
+        commit_destroy(c);
 }
 
 static void fence_cb(struct msm_fence_cb *cb)
@@ -165,6 +178,7 @@ int msm_atomic_commit(struct drm_device *dev,
 {
         int nplanes = dev->mode_config.num_total_plane;
         int ncrtcs = dev->mode_config.num_crtc;
+        struct timespec timeout;
         struct msm_commit *c;
         int i, ret;
 
@@ -172,7 +186,7 @@ int msm_atomic_commit(struct drm_device *dev,
         if (ret)
                 return ret;
 
-        c = new_commit(state);
+        c = commit_init(state);
         if (!c)
                 return -ENOMEM;
 
@@ -237,10 +251,12 @@ int msm_atomic_commit(struct drm_device *dev,
                 return 0;
         }
 
-        ret = msm_wait_fence_interruptable(dev, c->fence, NULL);
+        jiffies_to_timespec(jiffies + msecs_to_jiffies(1000), &timeout);
+
+        ret = msm_wait_fence_interruptable(dev, c->fence, &timeout);
         if (ret) {
                 WARN_ON(ret);  // TODO unswap state back?  or??
-                kfree(c);
+                commit_destroy(c);
                 return ret;
         }
 
diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c
index f1ebedde6346..a4269119f9ea 100644
--- a/drivers/gpu/drm/msm/msm_drv.c
+++ b/drivers/gpu/drm/msm/msm_drv.c
@@ -54,6 +54,12 @@ module_param(reglog, bool, 0600);
 #define reglog 0
 #endif
 
+#ifdef CONFIG_DRM_MSM_FBDEV
+static bool fbdev = true;
+MODULE_PARM_DESC(fbdev, "Enable fbdev compat layer");
+module_param(fbdev, bool, 0600);
+#endif
+
 static char *vram = "16m";
 MODULE_PARM_DESC(vram, "Configure VRAM size (for devices without IOMMU/GPUMMU");
 module_param(vram, charp, 0);
@@ -300,7 +306,8 @@ static int msm_load(struct drm_device *dev, unsigned long flags)
         drm_mode_config_reset(dev);
 
 #ifdef CONFIG_DRM_MSM_FBDEV
-        priv->fbdev = msm_fbdev_init(dev);
+        if (fbdev)
+                priv->fbdev = msm_fbdev_init(dev);
 #endif
 
         ret = msm_debugfs_late_init(dev);
@@ -1023,6 +1030,7 @@ static struct platform_driver msm_platform_driver = {
 static int __init msm_drm_register(void)
 {
         DBG("init");
+        msm_edp_register();
         hdmi_register();
         adreno_register();
         return platform_driver_register(&msm_platform_driver);
@@ -1034,6 +1042,7 @@ static void __exit msm_drm_unregister(void)
         platform_driver_unregister(&msm_platform_driver);
         hdmi_unregister();
         adreno_unregister();
+        msm_edp_unregister();
 }
 
 module_init(msm_drm_register);
diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h
index 22e5391a7ce8..9e8d441b61c3 100644
--- a/drivers/gpu/drm/msm/msm_drv.h
+++ b/drivers/gpu/drm/msm/msm_drv.h
@@ -76,6 +76,12 @@ struct msm_drm_private {
          */
         struct hdmi *hdmi;
 
+        /* eDP is for mdp5 only, but kms has not been created
+         * when edp_bind() and edp_init() are called. Here is the only
+         * place to keep the edp instance.
+         */
+        struct msm_edp *edp;
+
         /* when we have more than one 'msm_gpu' these need to be an array: */
         struct msm_gpu *gpu;
         struct msm_file_private *lastctx;
@@ -224,6 +230,12 @@ int hdmi_modeset_init(struct hdmi *hdmi, struct drm_device *dev,
 void __init hdmi_register(void);
 void __exit hdmi_unregister(void);
 
+struct msm_edp;
+void __init msm_edp_register(void);
+void __exit msm_edp_unregister(void);
+int msm_edp_modeset_init(struct msm_edp *edp, struct drm_device *dev,
+                struct drm_encoder *encoder);
+
 #ifdef CONFIG_DEBUG_FS
 void msm_gem_describe(struct drm_gem_object *obj, struct seq_file *m);
 void msm_gem_describe_objects(struct list_head *list, struct seq_file *m);
diff --git a/drivers/gpu/drm/msm/msm_fb.c b/drivers/gpu/drm/msm/msm_fb.c
index 84dec161d836..6b573e612f27 100644
--- a/drivers/gpu/drm/msm/msm_fb.c
+++ b/drivers/gpu/drm/msm/msm_fb.c
@@ -24,7 +24,7 @@
 struct msm_framebuffer {
         struct drm_framebuffer base;
         const struct msm_format *format;
-        struct drm_gem_object *planes[3];
+        struct drm_gem_object *planes[MAX_PLANE];
 };
 #define to_msm_framebuffer(x) container_of(x, struct msm_framebuffer, base)
 
@@ -122,7 +122,7 @@ uint32_t msm_framebuffer_iova(struct drm_framebuffer *fb, int id, int plane)
         struct msm_framebuffer *msm_fb = to_msm_framebuffer(fb);
         if (!msm_fb->planes[plane])
                 return 0;
-        return msm_gem_iova(msm_fb->planes[plane], id);
+        return msm_gem_iova(msm_fb->planes[plane], id) + fb->offsets[plane];
 }
 
 struct drm_gem_object *msm_framebuffer_bo(struct drm_framebuffer *fb, int plane)
diff --git a/drivers/gpu/drm/msm/msm_fbdev.c b/drivers/gpu/drm/msm/msm_fbdev.c
index 115b509a4a00..df60f65728ff 100644
--- a/drivers/gpu/drm/msm/msm_fbdev.c
+++ b/drivers/gpu/drm/msm/msm_fbdev.c
@@ -245,9 +245,6 @@ struct drm_fb_helper *msm_fbdev_init(struct drm_device *dev)
         if (ret)
                 goto fini;
 
-        /* disable all the possible outputs/crtcs before entering KMS mode */
-        drm_helper_disable_unused_functions(dev);
-
         ret = drm_fb_helper_initial_config(helper, 32);
         if (ret)
                 goto fini;
diff --git a/drivers/gpu/drm/msm/msm_kms.h b/drivers/gpu/drm/msm/msm_kms.h
index 06437745bc2c..3a78cb48662b 100644
--- a/drivers/gpu/drm/msm/msm_kms.h
+++ b/drivers/gpu/drm/msm/msm_kms.h
@@ -23,6 +23,8 @@
 
 #include "msm_drv.h"
 
+#define MAX_PLANE       4
+
 /* As there are different display controller blocks depending on the
  * snapdragon version, the kms support is split out and the appropriate
  * implementation is loaded at runtime.  The kms module is responsible
@@ -38,6 +40,9 @@ struct msm_kms_funcs {
         irqreturn_t (*irq)(struct msm_kms *kms);
         int (*enable_vblank)(struct msm_kms *kms, struct drm_crtc *crtc);
         void (*disable_vblank)(struct msm_kms *kms, struct drm_crtc *crtc);
+        /* modeset, bracketing atomic_commit(): */
+        void (*prepare_commit)(struct msm_kms *kms, struct drm_atomic_state *state);
+        void (*complete_commit)(struct msm_kms *kms, struct drm_atomic_state *state);
         /* misc: */
         const struct msm_format *(*get_format)(struct msm_kms *kms, uint32_t format);
         long (*round_pixclk)(struct msm_kms *kms, unsigned long rate,
diff --git a/include/drm/drm_dp_helper.h b/include/drm/drm_dp_helper.h
index 11f8c84f98ce..7e25030a6aa2 100644
--- a/include/drm/drm_dp_helper.h
+++ b/include/drm/drm_dp_helper.h
@@ -586,6 +586,7 @@ struct drm_dp_link {
 
 int drm_dp_link_probe(struct drm_dp_aux *aux, struct drm_dp_link *link);
 int drm_dp_link_power_up(struct drm_dp_aux *aux, struct drm_dp_link *link);
+int drm_dp_link_power_down(struct drm_dp_aux *aux, struct drm_dp_link *link);
 int drm_dp_link_configure(struct drm_dp_aux *aux, struct drm_dp_link *link);
 
 int drm_dp_aux_register(struct drm_dp_aux *aux);