Merge branch 'for-airlied' of git://people.freedesktop.org/~danvet/drm-intel into drm-next

Daniel writes:
"The big ticket item here is the new i915 modeset infrastructure.
Shockingly it didn't not blow up all over the place (i.e. I've managed to
fix the ugly issues before merging). 1-2 smaller corner cases broke, but
we have patches. Also, there's tons of patches on top of this that clean
out cruft and fix a few bugs that couldn't be fixed with the crtc helper
based stuff. So more stuff to come ;-)

Also a few other things:
- Tiny fix in the fb helper to go through the official dpms interface
  instead of calling the crtc helper code.
- forcewake code frobbery from Ben, code should be more in-line with
  what Windows does now.
- fixes for the render ring flush on hsw (Paulo)
- gpu frequency tracepoint
- vlv forcewake changes to better align it with our understanding of the
  forcewake magic.
- a few smaller cleanups"

+ 2 fixes.

* 'for-airlied' of git://people.freedesktop.org/~danvet/drm-intel: (78 commits)
  drm/i915: fix OOPS in lid_notify
  drm/i915: correctly update crtc->x/y in set_base
  drm/fb helper: don't call drm_helper_connector_dpms directly
  drm/i915: improve modeset state checking after dpms calls
  drm/i915: add tons of modeset state checks
  drm/i915: no longer call drm_helper_resume_force_mode
  drm/i915: disable all crtcs at suspend time
  drm/i915: push commit_output_state past the crtc/encoder preparing
  drm/i915: switch the load detect code to the staged modeset config
  drm/i915: WARN if the pipe won't turn off
  drm/i915: s/intel_encoder_disable/intel_encoder_noop
  drm/i915: push commit_output_state past crtc disabling
  drm/i915: implement new set_mode code flow
  drm/i915: compute masks of crtcs affected in set_mode
  drm/i915: use staged outuput config in lvds->mode_fixup
  drm/i915: use staged outuput config in tv->mode_fixup
  drm/i915: extract adjusted mode computation
  drm/i915: move output commit and crtc disabling into set_mode
  drm/i915: remove crtc disabling special case
  drm/i915: push crtc->fb update into pipe_set_base
  ...

27 files changed, 2257 insertions, 642 deletions

diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index eb79515797d9..b5d05f58c15a 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -330,7 +330,7 @@ static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode)
                 /* Walk the connectors & encoders on this fb turning them on/off */
                 for (j = 0; j < fb_helper->connector_count; j++) {
                         connector = fb_helper->connector_info[j]->connector;
-                        drm_helper_connector_dpms(connector, dpms_mode);
+                        connector->funcs->dpms(connector, dpms_mode);
                         drm_connector_property_set_value(connector,
                                 dev->mode_config.dpms_property, dpms_mode);
                 }
diff --git a/drivers/gpu/drm/i915/dvo.h b/drivers/gpu/drm/i915/dvo.h
index 0fa839e439b3..74b5efccfdb1 100644
--- a/drivers/gpu/drm/i915/dvo.h
+++ b/drivers/gpu/drm/i915/dvo.h
@@ -114,6 +114,12 @@ struct intel_dvo_dev_ops {
          */
         enum drm_connector_status (*detect)(struct intel_dvo_device *dvo);
 
+        /*
+         * Probe the current hw status, returning true if the connected output
+         * is active.
+         */
+        bool (*get_hw_state)(struct intel_dvo_device *dev);
+
         /**
          * Query the device for the modes it provides.
          *
diff --git a/drivers/gpu/drm/i915/dvo_ch7017.c b/drivers/gpu/drm/i915/dvo_ch7017.c
index 71e7650a2994..86b27d1d90c2 100644
--- a/drivers/gpu/drm/i915/dvo_ch7017.c
+++ b/drivers/gpu/drm/i915/dvo_ch7017.c
@@ -359,6 +359,18 @@ static void ch7017_dpms(struct intel_dvo_device *dvo, bool enable)
         msleep(20);
 }
 
+static bool ch7017_get_hw_state(struct intel_dvo_device *dvo)
+{
+        uint8_t val;
+
+        ch7017_read(dvo, CH7017_LVDS_POWER_DOWN, &val);
+
+        if (val & CH7017_LVDS_POWER_DOWN_EN)
+                return false;
+        else
+                return true;
+}
+
 static void ch7017_dump_regs(struct intel_dvo_device *dvo)
 {
         uint8_t val;
@@ -396,6 +408,7 @@ struct intel_dvo_dev_ops ch7017_ops = {
         .mode_valid = ch7017_mode_valid,
         .mode_set = ch7017_mode_set,
         .dpms = ch7017_dpms,
+        .get_hw_state = ch7017_get_hw_state,
         .dump_regs = ch7017_dump_regs,
         .destroy = ch7017_destroy,
 };
diff --git a/drivers/gpu/drm/i915/dvo_ch7xxx.c b/drivers/gpu/drm/i915/dvo_ch7xxx.c
index c1dea5b11f91..38f3a6cb8c7d 100644
--- a/drivers/gpu/drm/i915/dvo_ch7xxx.c
+++ b/drivers/gpu/drm/i915/dvo_ch7xxx.c
@@ -297,6 +297,18 @@ static void ch7xxx_dpms(struct intel_dvo_device *dvo, bool enable)
                 ch7xxx_writeb(dvo, CH7xxx_PM, CH7xxx_PM_FPD);
 }
 
+static bool ch7xxx_get_hw_state(struct intel_dvo_device *dvo)
+{
+        u8 val;
+
+        ch7xxx_readb(dvo, CH7xxx_PM, &val);
+
+        if (val & CH7xxx_PM_FPD)
+                return false;
+        else
+                return true;
+}
+
 static void ch7xxx_dump_regs(struct intel_dvo_device *dvo)
 {
         int i;
@@ -326,6 +338,7 @@ struct intel_dvo_dev_ops ch7xxx_ops = {
         .mode_valid = ch7xxx_mode_valid,
         .mode_set = ch7xxx_mode_set,
         .dpms = ch7xxx_dpms,
+        .get_hw_state = ch7xxx_get_hw_state,
         .dump_regs = ch7xxx_dump_regs,
         .destroy = ch7xxx_destroy,
 };
diff --git a/drivers/gpu/drm/i915/dvo_ivch.c b/drivers/gpu/drm/i915/dvo_ivch.c
index fa8ff6b050fa..baaf65bf0bdd 100644
--- a/drivers/gpu/drm/i915/dvo_ivch.c
+++ b/drivers/gpu/drm/i915/dvo_ivch.c
@@ -323,6 +323,20 @@ static void ivch_dpms(struct intel_dvo_device *dvo, bool enable)
         udelay(16 * 1000);
 }
 
+static bool ivch_get_hw_state(struct intel_dvo_device *dvo)
+{
+        uint16_t vr01;
+
+        /* Set the new power state of the panel. */
+        if (!ivch_read(dvo, VR01, &vr01))
+                return false;
+
+        if (vr01 & VR01_LCD_ENABLE)
+                return true;
+        else
+                return false;
+}
+
 static void ivch_mode_set(struct intel_dvo_device *dvo,
                           struct drm_display_mode *mode,
                           struct drm_display_mode *adjusted_mode)
@@ -413,6 +427,7 @@ static void ivch_destroy(struct intel_dvo_device *dvo)
 struct intel_dvo_dev_ops ivch_ops = {
         .init = ivch_init,
         .dpms = ivch_dpms,
+        .get_hw_state = ivch_get_hw_state,
         .mode_valid = ivch_mode_valid,
         .mode_set = ivch_mode_set,
         .detect = ivch_detect,
diff --git a/drivers/gpu/drm/i915/dvo_ns2501.c b/drivers/gpu/drm/i915/dvo_ns2501.c
index c4d9f2f395e6..c4a255be6979 100644
--- a/drivers/gpu/drm/i915/dvo_ns2501.c
+++ b/drivers/gpu/drm/i915/dvo_ns2501.c
@@ -493,6 +493,20 @@ static void ns2501_mode_set(struct intel_dvo_device *dvo,
 }
 
 /* set the NS2501 power state */
+static bool ns2501_get_hw_state(struct intel_dvo_device *dvo)
+{
+        unsigned char ch;
+
+        if (!ns2501_readb(dvo, NS2501_REG8, &ch))
+                return false;
+
+        if (ch & NS2501_8_PD)
+                return true;
+        else
+                return false;
+}
+
+/* set the NS2501 power state */
 static void ns2501_dpms(struct intel_dvo_device *dvo, bool enable)
 {
         bool ok;
@@ -568,6 +582,7 @@ struct intel_dvo_dev_ops ns2501_ops = {
         .mode_valid = ns2501_mode_valid,
         .mode_set = ns2501_mode_set,
         .dpms = ns2501_dpms,
+        .get_hw_state = ns2501_get_hw_state,
         .dump_regs = ns2501_dump_regs,
         .destroy = ns2501_destroy,
 };
diff --git a/drivers/gpu/drm/i915/dvo_sil164.c b/drivers/gpu/drm/i915/dvo_sil164.c
index cc24c1cabecd..4debd32e3e4c 100644
--- a/drivers/gpu/drm/i915/dvo_sil164.c
+++ b/drivers/gpu/drm/i915/dvo_sil164.c
@@ -226,6 +226,21 @@ static void sil164_dpms(struct intel_dvo_device *dvo, bool enable)
         return;
 }
 
+static bool sil164_get_hw_state(struct intel_dvo_device *dvo)
+{
+        int ret;
+        unsigned char ch;
+
+        ret = sil164_readb(dvo, SIL164_REG8, &ch);
+        if (ret == false)
+                return false;
+
+        if (ch & SIL164_8_PD)
+                return true;
+        else
+                return false;
+}
+
 static void sil164_dump_regs(struct intel_dvo_device *dvo)
 {
         uint8_t val;
@@ -258,6 +273,7 @@ struct intel_dvo_dev_ops sil164_ops = {
         .mode_valid = sil164_mode_valid,
         .mode_set = sil164_mode_set,
         .dpms = sil164_dpms,
+        .get_hw_state = sil164_get_hw_state,
         .dump_regs = sil164_dump_regs,
         .destroy = sil164_destroy,
 };
diff --git a/drivers/gpu/drm/i915/dvo_tfp410.c b/drivers/gpu/drm/i915/dvo_tfp410.c
index 097b3e82b00f..e17f1b07e915 100644
--- a/drivers/gpu/drm/i915/dvo_tfp410.c
+++ b/drivers/gpu/drm/i915/dvo_tfp410.c
@@ -249,6 +249,19 @@ static void tfp410_dpms(struct intel_dvo_device *dvo, bool enable)
         tfp410_writeb(dvo, TFP410_CTL_1, ctl1);
 }
 
+static bool tfp410_get_hw_state(struct intel_dvo_device *dvo)
+{
+        uint8_t ctl1;
+
+        if (!tfp410_readb(dvo, TFP410_CTL_1, &ctl1))
+                return false;
+
+        if (ctl1 & TFP410_CTL_1_PD)
+                return true;
+        else
+                return false;
+}
+
 static void tfp410_dump_regs(struct intel_dvo_device *dvo)
 {
         uint8_t val, val2;
@@ -299,6 +312,7 @@ struct intel_dvo_dev_ops tfp410_ops = {
         .mode_valid = tfp410_mode_valid,
         .mode_set = tfp410_mode_set,
         .dpms = tfp410_dpms,
+        .get_hw_state = tfp410_get_hw_state,
         .dump_regs = tfp410_dump_regs,
         .destroy = tfp410_destroy,
 };
diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index 3d886af2aae6..274a3280cdce 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -353,40 +353,22 @@ static int i915_gem_request_info(struct seq_file *m, void *data)
         struct drm_info_node *node = (struct drm_info_node *) m->private;
         struct drm_device *dev = node->minor->dev;
         drm_i915_private_t *dev_priv = dev->dev_private;
+        struct intel_ring_buffer *ring;
         struct drm_i915_gem_request *gem_request;
-        int ret, count;
+        int ret, count, i;
 
         ret = mutex_lock_interruptible(&dev->struct_mutex);
         if (ret)
                 return ret;
 
         count = 0;
-        if (!list_empty(&dev_priv->ring[RCS].request_list)) {
-                seq_printf(m, "Render requests:\n");
-                list_for_each_entry(gem_request,
-                                    &dev_priv->ring[RCS].request_list,
-                                    list) {
-                        seq_printf(m, "    %d @ %d\n",
-                                   gem_request->seqno,
-                                   (int) (jiffies - gem_request->emitted_jiffies));
-                }
-                count++;
-        }
-        if (!list_empty(&dev_priv->ring[VCS].request_list)) {
-                seq_printf(m, "BSD requests:\n");
-                list_for_each_entry(gem_request,
-                                    &dev_priv->ring[VCS].request_list,
-                                    list) {
-                        seq_printf(m, "    %d @ %d\n",
-                                   gem_request->seqno,
-                                   (int) (jiffies - gem_request->emitted_jiffies));
-                }
-                count++;
-        }
-        if (!list_empty(&dev_priv->ring[BCS].request_list)) {
-                seq_printf(m, "BLT requests:\n");
+        for_each_ring(ring, dev_priv, i) {
+                if (list_empty(&ring->request_list))
+                        continue;
+
+                seq_printf(m, "%s requests:\n", ring->name);
                 list_for_each_entry(gem_request,
-                                    &dev_priv->ring[BCS].request_list,
+                                    &ring->request_list,
                                     list) {
                         seq_printf(m, "    %d @ %d\n",
                                    gem_request->seqno,
@@ -416,14 +398,15 @@ static int i915_gem_seqno_info(struct seq_file *m, void *data)
         struct drm_info_node *node = (struct drm_info_node *) m->private;
         struct drm_device *dev = node->minor->dev;
         drm_i915_private_t *dev_priv = dev->dev_private;
+        struct intel_ring_buffer *ring;
         int ret, i;
 
         ret = mutex_lock_interruptible(&dev->struct_mutex);
         if (ret)
                 return ret;
 
-        for (i = 0; i < I915_NUM_RINGS; i++)
-                i915_ring_seqno_info(m, &dev_priv->ring[i]);
+        for_each_ring(ring, dev_priv, i)
+                i915_ring_seqno_info(m, ring);
 
         mutex_unlock(&dev->struct_mutex);
 
@@ -436,6 +419,7 @@ static int i915_interrupt_info(struct seq_file *m, void *data)
         struct drm_info_node *node = (struct drm_info_node *) m->private;
         struct drm_device *dev = node->minor->dev;
         drm_i915_private_t *dev_priv = dev->dev_private;
+        struct intel_ring_buffer *ring;
         int ret, i, pipe;
 
         ret = mutex_lock_interruptible(&dev->struct_mutex);
@@ -513,13 +497,13 @@ static int i915_interrupt_info(struct seq_file *m, void *data)
         }
         seq_printf(m, "Interrupts received: %d\n",
                    atomic_read(&dev_priv->irq_received));
-        for (i = 0; i < I915_NUM_RINGS; i++) {
+        for_each_ring(ring, dev_priv, i) {
                 if (IS_GEN6(dev) || IS_GEN7(dev)) {
-                        seq_printf(m, "Graphics Interrupt mask (%s):    %08x\n",
-                                   dev_priv->ring[i].name,
-                                   I915_READ_IMR(&dev_priv->ring[i]));
+                        seq_printf(m,
+                                   "Graphics Interrupt mask (%s):       %08x\n",
+                                   ring->name, I915_READ_IMR(ring));
                 }
-                i915_ring_seqno_info(m, &dev_priv->ring[i]);
+                i915_ring_seqno_info(m, ring);
         }
         mutex_unlock(&dev->struct_mutex);
 
@@ -1529,9 +1513,7 @@ static int i915_ppgtt_info(struct seq_file *m, void *data)
         if (INTEL_INFO(dev)->gen == 6)
                 seq_printf(m, "GFX_MODE: 0x%08x\n", I915_READ(GFX_MODE));
 
-        for (i = 0; i < I915_NUM_RINGS; i++) {
-                ring = &dev_priv->ring[i];
-
+        for_each_ring(ring, dev_priv, i) {
                 seq_printf(m, "%s\n", ring->name);
                 if (INTEL_INFO(dev)->gen == 7)
                         seq_printf(m, "GFX_MODE: 0x%08x\n", I915_READ(RING_MODE_GEN7(ring)));
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index 7f3863fb138c..a7837e556945 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -470,6 +470,9 @@ static int i915_drm_freeze(struct drm_device *dev)
                                 "GEM idle failed, resume might fail\n");
                         return error;
                 }
+
+                intel_modeset_disable(dev);
+
                 drm_irq_uninstall(dev);
         }
 
@@ -543,13 +546,9 @@ static int i915_drm_thaw(struct drm_device *dev)
                 mutex_unlock(&dev->struct_mutex);
 
                 intel_modeset_init_hw(dev);
+                intel_modeset_setup_hw_state(dev);
                 drm_mode_config_reset(dev);
                 drm_irq_install(dev);
-
-                /* Resume the modeset for every activated CRTC */
-                mutex_lock(&dev->mode_config.mutex);
-                drm_helper_resume_force_mode(dev);
-                mutex_unlock(&dev->mode_config.mutex);
         }
 
         intel_opregion_init(dev);
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 58b43db0a134..26c6959a524a 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -241,7 +241,6 @@ struct drm_i915_error_state {
 };
 
 struct drm_i915_display_funcs {
-        void (*dpms)(struct drm_crtc *crtc, int mode);
         bool (*fbc_enabled)(struct drm_device *dev);
         void (*enable_fbc)(struct drm_crtc *crtc, unsigned long interval);
         void (*disable_fbc)(struct drm_device *dev);
@@ -257,6 +256,8 @@ struct drm_i915_display_funcs {
                              struct drm_display_mode *adjusted_mode,
                              int x, int y,
                              struct drm_framebuffer *old_fb);
+        void (*crtc_enable)(struct drm_crtc *crtc);
+        void (*crtc_disable)(struct drm_crtc *crtc);
         void (*off)(struct drm_crtc *crtc);
         void (*write_eld)(struct drm_connector *connector,
                           struct drm_crtc *crtc);
@@ -839,22 +840,26 @@ typedef struct drm_i915_private {
                 u8 max_delay;
         } rps;
 
+        /* ilk-only ips/rps state. Everything in here is protected by the global
+         * mchdev_lock in intel_pm.c */
+        struct {
+                u8 cur_delay;
+                u8 min_delay;
+                u8 max_delay;
+                u8 fmax;
+                u8 fstart;
 
-        u8 cur_delay;
-        u8 min_delay;
-        u8 max_delay;
-        u8 fmax;
-        u8 fstart;
+                u64 last_count1;
+                unsigned long last_time1;
+                unsigned long chipset_power;
+                u64 last_count2;
+                struct timespec last_time2;
+                unsigned long gfx_power;
+                u8 corr;
 
-        u64 last_count1;
-        unsigned long last_time1;
-        unsigned long chipset_power;
-        u64 last_count2;
-        struct timespec last_time2;
-        unsigned long gfx_power;
-        int c_m;
-        int r_t;
-        u8 corr;
+                int c_m;
+                int r_t;
+        } ips;
 
         enum no_fbc_reason no_fbc_reason;
 
@@ -1546,6 +1551,7 @@ extern void intel_modeset_init(struct drm_device *dev);
 extern void intel_modeset_gem_init(struct drm_device *dev);
 extern void intel_modeset_cleanup(struct drm_device *dev);
 extern int intel_modeset_vga_set_state(struct drm_device *dev, bool state);
+extern void intel_modeset_setup_hw_state(struct drm_device *dev);
 extern bool intel_fbc_enabled(struct drm_device *dev);
 extern void intel_disable_fbc(struct drm_device *dev);
 extern bool ironlake_set_drps(struct drm_device *dev, u8 val);
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index a9f74f3b4073..d6010135e404 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -310,7 +310,7 @@ static void ironlake_handle_rps_change(struct drm_device *dev)
 
         I915_WRITE16(MEMINTRSTS, I915_READ(MEMINTRSTS));
 
-        new_delay = dev_priv->cur_delay;
+        new_delay = dev_priv->ips.cur_delay;
 
         I915_WRITE16(MEMINTRSTS, MEMINT_EVAL_CHG);
         busy_up = I915_READ(RCPREVBSYTUPAVG);
@@ -320,19 +320,19 @@ static void ironlake_handle_rps_change(struct drm_device *dev)
 
         /* Handle RCS change request from hw */
         if (busy_up > max_avg) {
-                if (dev_priv->cur_delay != dev_priv->max_delay)
-                        new_delay = dev_priv->cur_delay - 1;
-                if (new_delay < dev_priv->max_delay)
-                        new_delay = dev_priv->max_delay;
+                if (dev_priv->ips.cur_delay != dev_priv->ips.max_delay)
+                        new_delay = dev_priv->ips.cur_delay - 1;
+                if (new_delay < dev_priv->ips.max_delay)
+                        new_delay = dev_priv->ips.max_delay;
         } else if (busy_down < min_avg) {
-                if (dev_priv->cur_delay != dev_priv->min_delay)
-                        new_delay = dev_priv->cur_delay + 1;
-                if (new_delay > dev_priv->min_delay)
-                        new_delay = dev_priv->min_delay;
+                if (dev_priv->ips.cur_delay != dev_priv->ips.min_delay)
+                        new_delay = dev_priv->ips.cur_delay + 1;
+                if (new_delay > dev_priv->ips.min_delay)
+                        new_delay = dev_priv->ips.min_delay;
         }
 
         if (ironlake_set_drps(dev, new_delay))
-                dev_priv->cur_delay = new_delay;
+                dev_priv->ips.cur_delay = new_delay;
 
         spin_unlock_irqrestore(&mchdev_lock, flags);
 
diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
index 75dcfa4ec5ce..a828e90602b9 100644
--- a/drivers/gpu/drm/i915/i915_reg.h
+++ b/drivers/gpu/drm/i915/i915_reg.h
@@ -4037,6 +4037,8 @@
 #define  PORT_TRANS_C_SEL_CPT   (2<<29)
 #define  PORT_TRANS_SEL_MASK    (3<<29)
 #define  PORT_TRANS_SEL_CPT(pipe)       ((pipe) << 29)
+#define  PORT_TO_PIPE(val)      (((val) & (1<<30)) >> 30)
+#define  PORT_TO_PIPE_CPT(val)  (((val) & PORT_TRANS_SEL_MASK) >> 29)
 
 #define TRANS_DP_CTL_A          0xe0300
 #define TRANS_DP_CTL_B          0xe1300
diff --git a/drivers/gpu/drm/i915/i915_sysfs.c b/drivers/gpu/drm/i915/i915_sysfs.c
index c5ee7ee3b17e..da733a3fe1ef 100644
--- a/drivers/gpu/drm/i915/i915_sysfs.c
+++ b/drivers/gpu/drm/i915/i915_sysfs.c
@@ -93,6 +93,7 @@ static struct attribute_group rc6_attr_group = {
         .name = power_group_name,
         .attrs =  rc6_attrs
 };
+#endif
 
 static int l3_access_valid(struct drm_device *dev, loff_t offset)
 {
@@ -206,13 +207,14 @@ void i915_setup_sysfs(struct drm_device *dev)
 {
         int ret;
 
+#ifdef CONFIG_PM
         if (INTEL_INFO(dev)->gen >= 6) {
                 ret = sysfs_merge_group(&dev->primary->kdev.kobj,
                                         &rc6_attr_group);
                 if (ret)
                         DRM_ERROR("RC6 residency sysfs setup failed\n");
         }
-
+#endif
         if (HAS_L3_GPU_CACHE(dev)) {
                 ret = device_create_bin_file(&dev->primary->kdev, &dpf_attrs);
                 if (ret)
@@ -225,14 +227,3 @@ void i915_teardown_sysfs(struct drm_device *dev)
         device_remove_bin_file(&dev->primary->kdev,  &dpf_attrs);
         sysfs_unmerge_group(&dev->primary->kdev.kobj, &rc6_attr_group);
 }
-#else
-void i915_setup_sysfs(struct drm_device *dev)
-{
-        return;
-}
-
-void i915_teardown_sysfs(struct drm_device *dev)
-{
-        return;
-}
-#endif /* CONFIG_PM */
diff --git a/drivers/gpu/drm/i915/i915_trace.h b/drivers/gpu/drm/i915/i915_trace.h
index 3c4093d91f60..8134421b89a6 100644
--- a/drivers/gpu/drm/i915/i915_trace.h
+++ b/drivers/gpu/drm/i915/i915_trace.h
@@ -430,6 +430,21 @@ TRACE_EVENT(i915_reg_rw,
                 (u32)(__entry->val >> 32))
 );
 
+TRACE_EVENT(intel_gpu_freq_change,
+            TP_PROTO(u32 freq),
+            TP_ARGS(freq),
+
+            TP_STRUCT__entry(
+                             __field(u32, freq)
+                             ),
+
+            TP_fast_assign(
+                           __entry->freq = freq;
+                           ),
+
+            TP_printk("new_freq=%u", __entry->freq)
+);
+
 #endif /* _I915_TRACE_H_ */
 
 /* This part must be outside protection */
diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index 236191377b0f..c42b9809f86d 100644
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
@@ -61,42 +61,63 @@ static struct intel_crt *intel_encoder_to_crt(struct intel_encoder *encoder)
         return container_of(encoder, struct intel_crt, base);
 }
 
-static void pch_crt_dpms(struct drm_encoder *encoder, int mode)
+static bool intel_crt_get_hw_state(struct intel_encoder *encoder,
+                                   enum pipe *pipe)
 {
-        struct drm_device *dev = encoder->dev;
+        struct drm_device *dev = encoder->base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_crt *crt = intel_encoder_to_crt(encoder);
+        u32 tmp;
+
+        tmp = I915_READ(crt->adpa_reg);
+
+        if (!(tmp & ADPA_DAC_ENABLE))
+                return false;
+
+        if (HAS_PCH_CPT(dev))
+                *pipe = PORT_TO_PIPE_CPT(tmp);
+        else
+                *pipe = PORT_TO_PIPE(tmp);
+
+        return true;
+}
+
+static void intel_disable_crt(struct intel_encoder *encoder)
+{
+        struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
+        struct intel_crt *crt = intel_encoder_to_crt(encoder);
         u32 temp;
 
-        temp = I915_READ(PCH_ADPA);
+        temp = I915_READ(crt->adpa_reg);
+        temp &= ~(ADPA_HSYNC_CNTL_DISABLE | ADPA_VSYNC_CNTL_DISABLE);
         temp &= ~ADPA_DAC_ENABLE;
+        I915_WRITE(crt->adpa_reg, temp);
+}
 
-        switch (mode) {
-        case DRM_MODE_DPMS_ON:
-                temp |= ADPA_DAC_ENABLE;
-                break;
-        case DRM_MODE_DPMS_STANDBY:
-        case DRM_MODE_DPMS_SUSPEND:
-        case DRM_MODE_DPMS_OFF:
-                /* Just leave port enable cleared */
-                break;
-        }
+static void intel_enable_crt(struct intel_encoder *encoder)
+{
+        struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
+        struct intel_crt *crt = intel_encoder_to_crt(encoder);
+        u32 temp;
 
-        I915_WRITE(PCH_ADPA, temp);
+        temp = I915_READ(crt->adpa_reg);
+        temp |= ADPA_DAC_ENABLE;
+        I915_WRITE(crt->adpa_reg, temp);
 }
 
-static void gmch_crt_dpms(struct drm_encoder *encoder, int mode)
+/* Note: The caller is required to filter out dpms modes not supported by the
+ * platform. */
+static void intel_crt_set_dpms(struct intel_encoder *encoder, int mode)
 {
-        struct drm_device *dev = encoder->dev;
+        struct drm_device *dev = encoder->base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_crt *crt = intel_encoder_to_crt(encoder);
         u32 temp;
 
-        temp = I915_READ(ADPA);
+        temp = I915_READ(crt->adpa_reg);
         temp &= ~(ADPA_HSYNC_CNTL_DISABLE | ADPA_VSYNC_CNTL_DISABLE);
         temp &= ~ADPA_DAC_ENABLE;
 
-        if (IS_VALLEYVIEW(dev) && mode != DRM_MODE_DPMS_ON)
-                mode = DRM_MODE_DPMS_OFF;
-
         switch (mode) {
         case DRM_MODE_DPMS_ON:
                 temp |= ADPA_DAC_ENABLE;
@@ -112,7 +133,51 @@ static void gmch_crt_dpms(struct drm_encoder *encoder, int mode)
                 break;
         }
 
-        I915_WRITE(ADPA, temp);
+        I915_WRITE(crt->adpa_reg, temp);
+}
+
+static void intel_crt_dpms(struct drm_connector *connector, int mode)
+{
+        struct drm_device *dev = connector->dev;
+        struct intel_encoder *encoder = intel_attached_encoder(connector);
+        struct drm_crtc *crtc;
+        int old_dpms;
+
+        /* PCH platforms and VLV only support on/off. */
+        if (INTEL_INFO(dev)->gen < 5 && mode != DRM_MODE_DPMS_ON)
+                mode = DRM_MODE_DPMS_OFF;
+
+        if (mode == connector->dpms)
+                return;
+
+        old_dpms = connector->dpms;
+        connector->dpms = mode;
+
+        /* Only need to change hw state when actually enabled */
+        crtc = encoder->base.crtc;
+        if (!crtc) {
+                encoder->connectors_active = false;
+                return;
+        }
+
+        /* We need the pipe to run for anything but OFF. */
+        if (mode == DRM_MODE_DPMS_OFF)
+                encoder->connectors_active = false;
+        else
+                encoder->connectors_active = true;
+
+        if (mode < old_dpms) {
+                /* From off to on, enable the pipe first. */
+                intel_crtc_update_dpms(crtc);
+
+                intel_crt_set_dpms(encoder, mode);
+        } else {
+                intel_crt_set_dpms(encoder, mode);
+
+                intel_crtc_update_dpms(crtc);
+        }
+
+        intel_modeset_check_state(connector->dev);
 }
 
 static int intel_crt_mode_valid(struct drm_connector *connector,
@@ -603,25 +668,15 @@ static void intel_crt_reset(struct drm_connector *connector)
  * Routines for controlling stuff on the analog port
  */
 
-static const struct drm_encoder_helper_funcs pch_encoder_funcs = {
+static const struct drm_encoder_helper_funcs crt_encoder_funcs = {
         .mode_fixup = intel_crt_mode_fixup,
-        .prepare = intel_encoder_prepare,
-        .commit = intel_encoder_commit,
         .mode_set = intel_crt_mode_set,
-        .dpms = pch_crt_dpms,
-};
-
-static const struct drm_encoder_helper_funcs gmch_encoder_funcs = {
-        .mode_fixup = intel_crt_mode_fixup,
-        .prepare = intel_encoder_prepare,
-        .commit = intel_encoder_commit,
-        .mode_set = intel_crt_mode_set,
-        .dpms = gmch_crt_dpms,
+        .disable = intel_encoder_noop,
 };
 
 static const struct drm_connector_funcs intel_crt_connector_funcs = {
         .reset = intel_crt_reset,
-        .dpms = drm_helper_connector_dpms,
+        .dpms = intel_crt_dpms,
         .detect = intel_crt_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .destroy = intel_crt_destroy,
@@ -662,7 +717,6 @@ void intel_crt_init(struct drm_device *dev)
         struct intel_crt *crt;
         struct intel_connector *intel_connector;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        const struct drm_encoder_helper_funcs *encoder_helper_funcs;
 
         /* Skip machines without VGA that falsely report hotplug events */
         if (dmi_check_system(intel_no_crt))
@@ -701,18 +755,18 @@ void intel_crt_init(struct drm_device *dev)
         connector->doublescan_allowed = 0;
 
         if (HAS_PCH_SPLIT(dev))
-                encoder_helper_funcs = &pch_encoder_funcs;
-        else
-                encoder_helper_funcs = &gmch_encoder_funcs;
-
-        if (HAS_PCH_SPLIT(dev))
                 crt->adpa_reg = PCH_ADPA;
         else if (IS_VALLEYVIEW(dev))
                 crt->adpa_reg = VLV_ADPA;
         else
                 crt->adpa_reg = ADPA;
 
-        drm_encoder_helper_add(&crt->base.base, encoder_helper_funcs);
+        crt->base.disable = intel_disable_crt;
+        crt->base.enable = intel_enable_crt;
+        crt->base.get_hw_state = intel_crt_get_hw_state;
+        intel_connector->get_hw_state = intel_connector_get_hw_state;
+
+        drm_encoder_helper_add(&crt->base.base, &crt_encoder_funcs);
         drm_connector_helper_add(connector, &intel_crt_connector_helper_funcs);
 
         drm_sysfs_connector_add(connector);
diff --git a/drivers/gpu/drm/i915/intel_ddi.c b/drivers/gpu/drm/i915/intel_ddi.c
index 170e3861aa4e..bfe375466a0e 100644
--- a/drivers/gpu/drm/i915/intel_ddi.c
+++ b/drivers/gpu/drm/i915/intel_ddi.c
@@ -757,26 +757,63 @@ void intel_ddi_mode_set(struct drm_encoder *encoder,
         intel_hdmi->set_infoframes(encoder, adjusted_mode);
 }
 
-void intel_ddi_dpms(struct drm_encoder *encoder, int mode)
+bool intel_ddi_get_hw_state(struct intel_encoder *encoder,
+                            enum pipe *pipe)
 {
-        struct drm_device *dev = encoder->dev;
+        struct drm_device *dev = encoder->base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(&encoder->base);
+        u32 tmp;
+        int i;
+
+        tmp = I915_READ(DDI_BUF_CTL(intel_hdmi->ddi_port));
+
+        if (!(tmp & DDI_BUF_CTL_ENABLE))
+                return false;
+
+        for_each_pipe(i) {
+                tmp = I915_READ(DDI_FUNC_CTL(i));
+
+                if ((tmp & PIPE_DDI_PORT_MASK)
+                    == PIPE_DDI_SELECT_PORT(intel_hdmi->ddi_port)) {
+                        *pipe = i;
+                        return true;
+                }
+        }
+
+        DRM_DEBUG_KMS("No pipe for ddi port %i found\n", intel_hdmi->ddi_port);
+
+        return true;
+}
+
+void intel_enable_ddi(struct intel_encoder *encoder)
+{
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(&encoder->base);
         int port = intel_hdmi->ddi_port;
         u32 temp;
 
         temp = I915_READ(DDI_BUF_CTL(port));
-
-        if (mode != DRM_MODE_DPMS_ON) {
-                temp &= ~DDI_BUF_CTL_ENABLE;
-        } else {
-                temp |= DDI_BUF_CTL_ENABLE;
-        }
+        temp |= DDI_BUF_CTL_ENABLE;
 
         /* Enable DDI_BUF_CTL. In HDMI/DVI mode, the port width,
          * and swing/emphasis values are ignored so nothing special needs
          * to be done besides enabling the port.
          */
-        I915_WRITE(DDI_BUF_CTL(port),
-                        temp);
+        I915_WRITE(DDI_BUF_CTL(port), temp);
+}
+
+void intel_disable_ddi(struct intel_encoder *encoder)
+{
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(&encoder->base);
+        int port = intel_hdmi->ddi_port;
+        u32 temp;
+
+        temp = I915_READ(DDI_BUF_CTL(port));
+        temp &= ~DDI_BUF_CTL_ENABLE;
+
+        I915_WRITE(DDI_BUF_CTL(port), temp);
 }
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 778cbb88bddc..5576b7c695ed 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -1006,7 +1006,7 @@ void intel_wait_for_pipe_off(struct drm_device *dev, int pipe)
                 /* Wait for the Pipe State to go off */
                 if (wait_for((I915_READ(reg) & I965_PIPECONF_ACTIVE) == 0,
                              100))
-                        DRM_DEBUG_KMS("pipe_off wait timed out\n");
+                        WARN(1, "pipe_off wait timed out\n");
         } else {
                 u32 last_line, line_mask;
                 int reg = PIPEDSL(pipe);
@@ -1024,7 +1024,7 @@ void intel_wait_for_pipe_off(struct drm_device *dev, int pipe)
                 } while (((I915_READ(reg) & line_mask) != last_line) &&
                          time_after(timeout, jiffies));
                 if (time_after(jiffies, timeout))
-                        DRM_DEBUG_KMS("pipe_off wait timed out\n");
+                        WARN(1, "pipe_off wait timed out\n");
         }
 }
 
@@ -2201,16 +2201,17 @@ intel_finish_fb(struct drm_framebuffer *old_fb)
 
 static int
 intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
-                    struct drm_framebuffer *old_fb)
+                    struct drm_framebuffer *fb)
 {
         struct drm_device *dev = crtc->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_i915_master_private *master_priv;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        struct drm_framebuffer *old_fb;
         int ret;
 
         /* no fb bound */
-        if (!crtc->fb) {
+        if (!fb) {
                 DRM_ERROR("No FB bound\n");
                 return 0;
         }
@@ -2224,7 +2225,7 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
 
         mutex_lock(&dev->struct_mutex);
         ret = intel_pin_and_fence_fb_obj(dev,
-                                         to_intel_framebuffer(crtc->fb)->obj,
+                                         to_intel_framebuffer(fb)->obj,
                                          NULL);
         if (ret != 0) {
                 mutex_unlock(&dev->struct_mutex);
@@ -2232,17 +2233,22 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
                 return ret;
         }
 
-        if (old_fb)
-                intel_finish_fb(old_fb);
+        if (crtc->fb)
+                intel_finish_fb(crtc->fb);
 
-        ret = dev_priv->display.update_plane(crtc, crtc->fb, x, y);
+        ret = dev_priv->display.update_plane(crtc, fb, x, y);
         if (ret) {
-                intel_unpin_fb_obj(to_intel_framebuffer(crtc->fb)->obj);
+                intel_unpin_fb_obj(to_intel_framebuffer(fb)->obj);
                 mutex_unlock(&dev->struct_mutex);
                 DRM_ERROR("failed to update base address\n");
                 return ret;
         }
 
+        old_fb = crtc->fb;
+        crtc->fb = fb;
+        crtc->x = x;
+        crtc->y = y;
+
         if (old_fb) {
                 intel_wait_for_vblank(dev, intel_crtc->pipe);
                 intel_unpin_fb_obj(to_intel_framebuffer(old_fb)->obj);
@@ -3209,11 +3215,14 @@ static void ironlake_crtc_enable(struct drm_crtc *crtc)
         struct drm_device *dev = crtc->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        struct intel_encoder *encoder;
         int pipe = intel_crtc->pipe;
         int plane = intel_crtc->plane;
         u32 temp;
         bool is_pch_port;
 
+        WARN_ON(!crtc->enabled);
+
         if (intel_crtc->active)
                 return;
 
@@ -3262,6 +3271,12 @@ static void ironlake_crtc_enable(struct drm_crtc *crtc)
         mutex_unlock(&dev->struct_mutex);
 
         intel_crtc_update_cursor(crtc, true);
+
+        for_each_encoder_on_crtc(dev, crtc, encoder)
+                encoder->enable(encoder);
+
+        if (HAS_PCH_CPT(dev))
+                intel_cpt_verify_modeset(dev, intel_crtc->pipe);
 }
 
 static void ironlake_crtc_disable(struct drm_crtc *crtc)
@@ -3269,13 +3284,18 @@ static void ironlake_crtc_disable(struct drm_crtc *crtc)
         struct drm_device *dev = crtc->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        struct intel_encoder *encoder;
         int pipe = intel_crtc->pipe;
         int plane = intel_crtc->plane;
         u32 reg, temp;
 
+
         if (!intel_crtc->active)
                 return;
 
+        for_each_encoder_on_crtc(dev, crtc, encoder)
+                encoder->disable(encoder);
+
         intel_crtc_wait_for_pending_flips(crtc);
         drm_vblank_off(dev, pipe);
         intel_crtc_update_cursor(crtc, false);
@@ -3342,30 +3362,6 @@ static void ironlake_crtc_disable(struct drm_crtc *crtc)
         mutex_unlock(&dev->struct_mutex);
 }
 
-static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
-{
-        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
-        int pipe = intel_crtc->pipe;
-        int plane = intel_crtc->plane;
-
-        /* XXX: When our outputs are all unaware of DPMS modes other than off
-         * and on, we should map those modes to DRM_MODE_DPMS_OFF in the CRTC.
-         */
-        switch (mode) {
-        case DRM_MODE_DPMS_ON:
-        case DRM_MODE_DPMS_STANDBY:
-        case DRM_MODE_DPMS_SUSPEND:
-                DRM_DEBUG_KMS("crtc %d/%d dpms on\n", pipe, plane);
-                ironlake_crtc_enable(crtc);
-                break;
-
-        case DRM_MODE_DPMS_OFF:
-                DRM_DEBUG_KMS("crtc %d/%d dpms off\n", pipe, plane);
-                ironlake_crtc_disable(crtc);
-                break;
-        }
-}
-
 static void ironlake_crtc_off(struct drm_crtc *crtc)
 {
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
@@ -3395,9 +3391,12 @@ static void i9xx_crtc_enable(struct drm_crtc *crtc)
         struct drm_device *dev = crtc->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        struct intel_encoder *encoder;
         int pipe = intel_crtc->pipe;
         int plane = intel_crtc->plane;
 
+        WARN_ON(!crtc->enabled);
+
         if (intel_crtc->active)
                 return;
 
@@ -3414,6 +3413,9 @@ static void i9xx_crtc_enable(struct drm_crtc *crtc)
         /* Give the overlay scaler a chance to enable if it's on this pipe */
         intel_crtc_dpms_overlay(intel_crtc, true);
         intel_crtc_update_cursor(crtc, true);
+
+        for_each_encoder_on_crtc(dev, crtc, encoder)
+                encoder->enable(encoder);
 }
 
 static void i9xx_crtc_disable(struct drm_crtc *crtc)
@@ -3421,12 +3423,17 @@ static void i9xx_crtc_disable(struct drm_crtc *crtc)
         struct drm_device *dev = crtc->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        struct intel_encoder *encoder;
         int pipe = intel_crtc->pipe;
         int plane = intel_crtc->plane;
 
+
         if (!intel_crtc->active)
                 return;
 
+        for_each_encoder_on_crtc(dev, crtc, encoder)
+                encoder->disable(encoder);
+
         /* Give the overlay scaler a chance to disable if it's on this pipe */
         intel_crtc_wait_for_pending_flips(crtc);
         drm_vblank_off(dev, pipe);
@@ -3445,45 +3452,17 @@ static void i9xx_crtc_disable(struct drm_crtc *crtc)
         intel_update_watermarks(dev);
 }
 
-static void i9xx_crtc_dpms(struct drm_crtc *crtc, int mode)
-{
-        /* XXX: When our outputs are all unaware of DPMS modes other than off
-         * and on, we should map those modes to DRM_MODE_DPMS_OFF in the CRTC.
-         */
-        switch (mode) {
-        case DRM_MODE_DPMS_ON:
-        case DRM_MODE_DPMS_STANDBY:
-        case DRM_MODE_DPMS_SUSPEND:
-                i9xx_crtc_enable(crtc);
-                break;
-        case DRM_MODE_DPMS_OFF:
-                i9xx_crtc_disable(crtc);
-                break;
-        }
-}
-
 static void i9xx_crtc_off(struct drm_crtc *crtc)
 {
 }
 
-/**
- * Sets the power management mode of the pipe and plane.
- */
-static void intel_crtc_dpms(struct drm_crtc *crtc, int mode)
+static void intel_crtc_update_sarea(struct drm_crtc *crtc,
+                                    bool enabled)
 {
         struct drm_device *dev = crtc->dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_i915_master_private *master_priv;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
         int pipe = intel_crtc->pipe;
-        bool enabled;
-
-        if (intel_crtc->dpms_mode == mode)
-                return;
-
-        intel_crtc->dpms_mode = mode;
-
-        dev_priv->display.dpms(crtc, mode);
 
         if (!dev->primary->master)
                 return;
@@ -3492,8 +3471,6 @@ static void intel_crtc_dpms(struct drm_crtc *crtc, int mode)
         if (!master_priv->sarea_priv)
                 return;
 
-        enabled = crtc->enabled && mode != DRM_MODE_DPMS_OFF;
-
         switch (pipe) {
         case 0:
                 master_priv->sarea_priv->pipeA_w = enabled ? crtc->mode.hdisplay : 0;
@@ -3509,13 +3486,42 @@ static void intel_crtc_dpms(struct drm_crtc *crtc, int mode)
         }
 }
 
+/**
+ * Sets the power management mode of the pipe and plane.
+ */
+void intel_crtc_update_dpms(struct drm_crtc *crtc)
+{
+        struct drm_device *dev = crtc->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_encoder *intel_encoder;
+        bool enable = false;
+
+        for_each_encoder_on_crtc(dev, crtc, intel_encoder)
+                enable |= intel_encoder->connectors_active;
+
+        if (enable)
+                dev_priv->display.crtc_enable(crtc);
+        else
+                dev_priv->display.crtc_disable(crtc);
+
+        intel_crtc_update_sarea(crtc, enable);
+}
+
+static void intel_crtc_noop(struct drm_crtc *crtc)
+{
+}
+
 static void intel_crtc_disable(struct drm_crtc *crtc)
 {
-        struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
         struct drm_device *dev = crtc->dev;
+        struct drm_connector *connector;
         struct drm_i915_private *dev_priv = dev->dev_private;
 
-        crtc_funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
+        /* crtc should still be enabled when we disable it. */
+        WARN_ON(!crtc->enabled);
+
+        dev_priv->display.crtc_disable(crtc);
+        intel_crtc_update_sarea(crtc, false);
         dev_priv->display.off(crtc);
 
         assert_plane_disabled(dev->dev_private, to_intel_crtc(crtc)->plane);
@@ -3525,63 +3531,128 @@ static void intel_crtc_disable(struct drm_crtc *crtc)
                 mutex_lock(&dev->struct_mutex);
                 intel_unpin_fb_obj(to_intel_framebuffer(crtc->fb)->obj);
                 mutex_unlock(&dev->struct_mutex);
+                crtc->fb = NULL;
+        }
+
+        /* Update computed state. */
+        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                if (!connector->encoder || !connector->encoder->crtc)
+                        continue;
+
+                if (connector->encoder->crtc != crtc)
+                        continue;
+
+                connector->dpms = DRM_MODE_DPMS_OFF;
+                to_intel_encoder(connector->encoder)->connectors_active = false;
         }
 }
 
-/* Prepare for a mode set.
- *
- * Note we could be a lot smarter here.  We need to figure out which outputs
- * will be enabled, which disabled (in short, how the config will changes)
- * and perform the minimum necessary steps to accomplish that, e.g. updating
- * watermarks, FBC configuration, making sure PLLs are programmed correctly,
- * panel fitting is in the proper state, etc.
- */
-static void i9xx_crtc_prepare(struct drm_crtc *crtc)
+void intel_modeset_disable(struct drm_device *dev)
 {
-        i9xx_crtc_disable(crtc);
+        struct drm_crtc *crtc;
+
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+                if (crtc->enabled)
+                        intel_crtc_disable(crtc);
+        }
 }
 
-static void i9xx_crtc_commit(struct drm_crtc *crtc)
+void intel_encoder_noop(struct drm_encoder *encoder)
 {
-        i9xx_crtc_enable(crtc);
 }
 
-static void ironlake_crtc_prepare(struct drm_crtc *crtc)
+void intel_encoder_destroy(struct drm_encoder *encoder)
 {
-        ironlake_crtc_disable(crtc);
+        struct intel_encoder *intel_encoder = to_intel_encoder(encoder);
+
+        drm_encoder_cleanup(encoder);
+        kfree(intel_encoder);
 }
 
-static void ironlake_crtc_commit(struct drm_crtc *crtc)
+/* Simple dpms helper for encodres with just one connector, no cloning and only
+ * one kind of off state. It clamps all !ON modes to fully OFF and changes the
+ * state of the entire output pipe. */
+void intel_encoder_dpms(struct intel_encoder *encoder, int mode)
 {
-        ironlake_crtc_enable(crtc);
+        if (mode == DRM_MODE_DPMS_ON) {
+                encoder->connectors_active = true;
+
+                intel_crtc_update_dpms(encoder->base.crtc);
+        } else {
+                encoder->connectors_active = false;
+
+                intel_crtc_update_dpms(encoder->base.crtc);
+        }
 }
 
-void intel_encoder_prepare(struct drm_encoder *encoder)
+/* Cross check the actual hw state with our own modeset state tracking (and it's
+ * internal consistency). */
+static void intel_connector_check_state(struct intel_connector *connector)
 {
-        struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
-        /* lvds has its own version of prepare see intel_lvds_prepare */
-        encoder_funcs->dpms(encoder, DRM_MODE_DPMS_OFF);
+        if (connector->get_hw_state(connector)) {
+                struct intel_encoder *encoder = connector->encoder;
+                struct drm_crtc *crtc;
+                bool encoder_enabled;
+                enum pipe pipe;
+
+                DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
+                              connector->base.base.id,
+                              drm_get_connector_name(&connector->base));
+
+                WARN(connector->base.dpms == DRM_MODE_DPMS_OFF,
+                     "wrong connector dpms state\n");
+                WARN(connector->base.encoder != &encoder->base,
+                     "active connector not linked to encoder\n");
+                WARN(!encoder->connectors_active,
+                     "encoder->connectors_active not set\n");
+
+                encoder_enabled = encoder->get_hw_state(encoder, &pipe);
+                WARN(!encoder_enabled, "encoder not enabled\n");
+                if (WARN_ON(!encoder->base.crtc))
+                        return;
+
+                crtc = encoder->base.crtc;
+
+                WARN(!crtc->enabled, "crtc not enabled\n");
+                WARN(!to_intel_crtc(crtc)->active, "crtc not active\n");
+                WARN(pipe != to_intel_crtc(crtc)->pipe,
+                     "encoder active on the wrong pipe\n");
+        }
 }
 
-void intel_encoder_commit(struct drm_encoder *encoder)
+/* Even simpler default implementation, if there's really no special case to
+ * consider. */
+void intel_connector_dpms(struct drm_connector *connector, int mode)
 {
-        struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
-        struct drm_device *dev = encoder->dev;
-        struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
+        struct intel_encoder *encoder = intel_attached_encoder(connector);
 
-        /* lvds has its own version of commit see intel_lvds_commit */
-        encoder_funcs->dpms(encoder, DRM_MODE_DPMS_ON);
+        /* All the simple cases only support two dpms states. */
+        if (mode != DRM_MODE_DPMS_ON)
+                mode = DRM_MODE_DPMS_OFF;
 
-        if (HAS_PCH_CPT(dev))
-                intel_cpt_verify_modeset(dev, intel_crtc->pipe);
+        if (mode == connector->dpms)
+                return;
+
+        connector->dpms = mode;
+
+        /* Only need to change hw state when actually enabled */
+        if (encoder->base.crtc)
+                intel_encoder_dpms(encoder, mode);
+        else
+                WARN_ON(encoder->connectors_active != false);
+
+        intel_modeset_check_state(connector->dev);
 }
 
-void intel_encoder_destroy(struct drm_encoder *encoder)
+/* Simple connector->get_hw_state implementation for encoders that support only
+ * one connector and no cloning and hence the encoder state determines the state
+ * of the connector. */
+bool intel_connector_get_hw_state(struct intel_connector *connector)
 {
-        struct intel_encoder *intel_encoder = to_intel_encoder(encoder);
+        enum pipe pipe = 0;
+        struct intel_encoder *encoder = connector->encoder;
 
-        drm_encoder_cleanup(encoder);
-        kfree(intel_encoder);
+        return encoder->get_hw_state(encoder, &pipe);
 }
 
 static bool intel_crtc_mode_fixup(struct drm_crtc *crtc,
@@ -3744,6 +3815,7 @@ static inline bool intel_panel_use_ssc(struct drm_i915_private *dev_priv)
  * true if they don't match).
  */
 static bool intel_choose_pipe_bpp_dither(struct drm_crtc *crtc,
+                                         struct drm_framebuffer *fb,
                                          unsigned int *pipe_bpp,
                                          struct drm_display_mode *mode)
 {
@@ -3813,7 +3885,7 @@ static bool intel_choose_pipe_bpp_dither(struct drm_crtc *crtc,
          * also stays within the max display bpc discovered above.
          */
 
-        switch (crtc->fb->depth) {
+        switch (fb->depth) {
         case 8:
                 bpc = 8; /* since we go through a colormap */
                 break;
@@ -4232,7 +4304,7 @@ static int i9xx_crtc_mode_set(struct drm_crtc *crtc,
                               struct drm_display_mode *mode,
                               struct drm_display_mode *adjusted_mode,
                               int x, int y,
-                              struct drm_framebuffer *old_fb)
+                              struct drm_framebuffer *fb)
 {
         struct drm_device *dev = crtc->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
@@ -4422,7 +4494,7 @@ static int i9xx_crtc_mode_set(struct drm_crtc *crtc,
         I915_WRITE(DSPCNTR(plane), dspcntr);
         POSTING_READ(DSPCNTR(plane));
 
-        ret = intel_pipe_set_base(crtc, x, y, old_fb);
+        ret = intel_pipe_set_base(crtc, x, y, fb);
 
         intel_update_watermarks(dev);
 
@@ -4580,7 +4652,7 @@ static int ironlake_crtc_mode_set(struct drm_crtc *crtc,
                                   struct drm_display_mode *mode,
                                   struct drm_display_mode *adjusted_mode,
                                   int x, int y,
-                                  struct drm_framebuffer *old_fb)
+                                  struct drm_framebuffer *fb)
 {
         struct drm_device *dev = crtc->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
@@ -4700,7 +4772,7 @@ static int ironlake_crtc_mode_set(struct drm_crtc *crtc,
         /* determine panel color depth */
         temp = I915_READ(PIPECONF(pipe));
         temp &= ~PIPE_BPC_MASK;
-        dither = intel_choose_pipe_bpp_dither(crtc, &pipe_bpp, mode);
+        dither = intel_choose_pipe_bpp_dither(crtc, fb, &pipe_bpp, mode);
         switch (pipe_bpp) {
         case 18:
                 temp |= PIPE_6BPC;
@@ -4969,7 +5041,7 @@ static int ironlake_crtc_mode_set(struct drm_crtc *crtc,
         I915_WRITE(DSPCNTR(plane), dspcntr);
         POSTING_READ(DSPCNTR(plane));
 
-        ret = intel_pipe_set_base(crtc, x, y, old_fb);
+        ret = intel_pipe_set_base(crtc, x, y, fb);
 
         intel_update_watermarks(dev);
 
@@ -4982,7 +5054,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                                struct drm_display_mode *mode,
                                struct drm_display_mode *adjusted_mode,
                                int x, int y,
-                               struct drm_framebuffer *old_fb)
+                               struct drm_framebuffer *fb)
 {
         struct drm_device *dev = crtc->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
@@ -4993,14 +5065,9 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
         drm_vblank_pre_modeset(dev, pipe);
 
         ret = dev_priv->display.crtc_mode_set(crtc, mode, adjusted_mode,
-                                              x, y, old_fb);
+                                              x, y, fb);
         drm_vblank_post_modeset(dev, pipe);
 
-        if (ret)
-                intel_crtc->dpms_mode = DRM_MODE_DPMS_OFF;
-        else
-                intel_crtc->dpms_mode = DRM_MODE_DPMS_ON;
-
         return ret;
 }
 
@@ -5434,8 +5501,6 @@ static int intel_crtc_cursor_set(struct drm_crtc *crtc,
         uint32_t addr;
         int ret;
 
-        DRM_DEBUG_KMS("\n");
-
         /* if we want to turn off the cursor ignore width and height */
         if (!handle) {
                 DRM_DEBUG_KMS("cursor off\n");
@@ -5692,7 +5757,7 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
         struct drm_encoder *encoder = &intel_encoder->base;
         struct drm_crtc *crtc = NULL;
         struct drm_device *dev = encoder->dev;
-        struct drm_framebuffer *old_fb;
+        struct drm_framebuffer *fb;
         int i = -1;
 
         DRM_DEBUG_KMS("[CONNECTOR:%d:%s], [ENCODER:%d:%s]\n",
@@ -5742,8 +5807,8 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
                 return false;
         }
 
-        encoder->crtc = crtc;
-        connector->encoder = encoder;
+        intel_encoder->new_crtc = to_intel_crtc(crtc);
+        to_intel_connector(connector)->new_encoder = intel_encoder;
 
         intel_crtc = to_intel_crtc(crtc);
         old->dpms_mode = connector->dpms;
@@ -5753,8 +5818,6 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
         if (!mode)
                 mode = &load_detect_mode;
 
-        old_fb = crtc->fb;
-
         /* We need a framebuffer large enough to accommodate all accesses
          * that the plane may generate whilst we perform load detection.
          * We can not rely on the fbcon either being present (we get called
@@ -5762,19 +5825,19 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
          * not even exist) or that it is large enough to satisfy the
          * requested mode.
          */
-        crtc->fb = mode_fits_in_fbdev(dev, mode);
-        if (crtc->fb == NULL) {
+        fb = mode_fits_in_fbdev(dev, mode);
+        if (fb == NULL) {
                 DRM_DEBUG_KMS("creating tmp fb for load-detection\n");
-                crtc->fb = intel_framebuffer_create_for_mode(dev, mode, 24, 32);
-                old->release_fb = crtc->fb;
+                fb = intel_framebuffer_create_for_mode(dev, mode, 24, 32);
+                old->release_fb = fb;
         } else
                 DRM_DEBUG_KMS("reusing fbdev for load-detection framebuffer\n");
-        if (IS_ERR(crtc->fb)) {
+        if (IS_ERR(fb)) {
                 DRM_DEBUG_KMS("failed to allocate framebuffer for load-detection\n");
                 goto fail;
         }
 
-        if (!drm_crtc_helper_set_mode(crtc, mode, 0, 0, old_fb)) {
+        if (!intel_set_mode(crtc, mode, 0, 0, fb)) {
                 DRM_DEBUG_KMS("failed to set mode on load-detect pipe\n");
                 if (old->release_fb)
                         old->release_fb->funcs->destroy(old->release_fb);
@@ -5788,7 +5851,6 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
 fail:
         connector->encoder = NULL;
         encoder->crtc = NULL;
-        crtc->fb = old_fb;
         return false;
 }
 
@@ -5798,16 +5860,17 @@ void intel_release_load_detect_pipe(struct drm_connector *connector,
         struct intel_encoder *intel_encoder =
                 intel_attached_encoder(connector);
         struct drm_encoder *encoder = &intel_encoder->base;
-        struct drm_device *dev = encoder->dev;
 
         DRM_DEBUG_KMS("[CONNECTOR:%d:%s], [ENCODER:%d:%s]\n",
                       connector->base.id, drm_get_connector_name(connector),
                       encoder->base.id, drm_get_encoder_name(encoder));
 
         if (old->load_detect_temp) {
-                connector->encoder = NULL;
-                encoder->crtc = NULL;
-                drm_helper_disable_unused_functions(dev);
+                struct drm_crtc *crtc = encoder->crtc;
+
+                to_intel_connector(connector)->new_encoder = NULL;
+                intel_encoder->new_crtc = NULL;
+                intel_set_mode(crtc, NULL, 0, 0, NULL);
 
                 if (old->release_fb)
                         old->release_fb->funcs->destroy(old->release_fb);
@@ -6529,81 +6592,811 @@ free_work:
         return ret;
 }
 
-static void intel_sanitize_modesetting(struct drm_device *dev,
-                                       int pipe, int plane)
+static struct drm_crtc_helper_funcs intel_helper_funcs = {
+        .mode_set_base_atomic = intel_pipe_set_base_atomic,
+        .load_lut = intel_crtc_load_lut,
+        .disable = intel_crtc_noop,
+};
+
+bool intel_encoder_check_is_cloned(struct intel_encoder *encoder)
 {
-        struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 reg, val;
-        int i;
+        struct intel_encoder *other_encoder;
+        struct drm_crtc *crtc = &encoder->new_crtc->base;
 
-        /* Clear any frame start delays used for debugging left by the BIOS */
-        for_each_pipe(i) {
-                reg = PIPECONF(i);
-                I915_WRITE(reg, I915_READ(reg) & ~PIPECONF_FRAME_START_DELAY_MASK);
+        if (WARN_ON(!crtc))
+                return false;
+
+        list_for_each_entry(other_encoder,
+                            &crtc->dev->mode_config.encoder_list,
+                            base.head) {
+
+                if (&other_encoder->new_crtc->base != crtc ||
+                    encoder == other_encoder)
+                        continue;
+                else
+                        return true;
         }
 
-        if (HAS_PCH_SPLIT(dev))
-                return;
+        return false;
+}
 
-        /* Who knows what state these registers were left in by the BIOS or
-         * grub?
-         *
-         * If we leave the registers in a conflicting state (e.g. with the
-         * display plane reading from the other pipe than the one we intend
-         * to use) then when we attempt to teardown the active mode, we will
-         * not disable the pipes and planes in the correct order -- leaving
-         * a plane reading from a disabled pipe and possibly leading to
-         * undefined behaviour.
+static bool intel_encoder_crtc_ok(struct drm_encoder *encoder,
+                                  struct drm_crtc *crtc)
+{
+        struct drm_device *dev;
+        struct drm_crtc *tmp;
+        int crtc_mask = 1;
+
+        WARN(!crtc, "checking null crtc?\n");
+
+        dev = crtc->dev;
+
+        list_for_each_entry(tmp, &dev->mode_config.crtc_list, head) {
+                if (tmp == crtc)
+                        break;
+                crtc_mask <<= 1;
+        }
+
+        if (encoder->possible_crtcs & crtc_mask)
+                return true;
+        return false;
+}
+
+/**
+ * intel_modeset_update_staged_output_state
+ *
+ * Updates the staged output configuration state, e.g. after we've read out the
+ * current hw state.
+ */
+static void intel_modeset_update_staged_output_state(struct drm_device *dev)
+{
+        struct intel_encoder *encoder;
+        struct intel_connector *connector;
+
+        list_for_each_entry(connector, &dev->mode_config.connector_list,
+                            base.head) {
+                connector->new_encoder =
+                        to_intel_encoder(connector->base.encoder);
+        }
+
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list,
+                            base.head) {
+                encoder->new_crtc =
+                        to_intel_crtc(encoder->base.crtc);
+        }
+}
+
+/**
+ * intel_modeset_commit_output_state
+ *
+ * This function copies the stage display pipe configuration to the real one.
+ */
+static void intel_modeset_commit_output_state(struct drm_device *dev)
+{
+        struct intel_encoder *encoder;
+        struct intel_connector *connector;
+
+        list_for_each_entry(connector, &dev->mode_config.connector_list,
+                            base.head) {
+                connector->base.encoder = &connector->new_encoder->base;
+        }
+
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list,
+                            base.head) {
+                encoder->base.crtc = &encoder->new_crtc->base;
+        }
+}
+
+static struct drm_display_mode *
+intel_modeset_adjusted_mode(struct drm_crtc *crtc,
+                            struct drm_display_mode *mode)
+{
+        struct drm_device *dev = crtc->dev;
+        struct drm_display_mode *adjusted_mode;
+        struct drm_encoder_helper_funcs *encoder_funcs;
+        struct intel_encoder *encoder;
+
+        adjusted_mode = drm_mode_duplicate(dev, mode);
+        if (!adjusted_mode)
+                return ERR_PTR(-ENOMEM);
+
+        /* Pass our mode to the connectors and the CRTC to give them a chance to
+         * adjust it according to limitations or connector properties, and also
+         * a chance to reject the mode entirely.
          */
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list,
+                            base.head) {
 
-        reg = DSPCNTR(plane);
-        val = I915_READ(reg);
+                if (&encoder->new_crtc->base != crtc)
+                        continue;
+                encoder_funcs = encoder->base.helper_private;
+                if (!(encoder_funcs->mode_fixup(&encoder->base, mode,
+                                                adjusted_mode))) {
+                        DRM_DEBUG_KMS("Encoder fixup failed\n");
+                        goto fail;
+                }
+        }
 
-        if ((val & DISPLAY_PLANE_ENABLE) == 0)
-                return;
-        if (!!(val & DISPPLANE_SEL_PIPE_MASK) == pipe)
-                return;
+        if (!(intel_crtc_mode_fixup(crtc, mode, adjusted_mode))) {
+                DRM_DEBUG_KMS("CRTC fixup failed\n");
+                goto fail;
+        }
+        DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
 
-        /* This display plane is active and attached to the other CPU pipe. */
-        pipe = !pipe;
+        return adjusted_mode;
+fail:
+        drm_mode_destroy(dev, adjusted_mode);
+        return ERR_PTR(-EINVAL);
+}
 
-        /* Disable the plane and wait for it to stop reading from the pipe. */
-        intel_disable_plane(dev_priv, plane, pipe);
-        intel_disable_pipe(dev_priv, pipe);
+/* Computes which crtcs are affected and sets the relevant bits in the mask. For
+ * simplicity we use the crtc's pipe number (because it's easier to obtain). */
+static void
+intel_modeset_affected_pipes(struct drm_crtc *crtc, unsigned *modeset_pipes,
+                             unsigned *prepare_pipes, unsigned *disable_pipes)
+{
+        struct intel_crtc *intel_crtc;
+        struct drm_device *dev = crtc->dev;
+        struct intel_encoder *encoder;
+        struct intel_connector *connector;
+        struct drm_crtc *tmp_crtc;
+
+        *disable_pipes = *modeset_pipes = *prepare_pipes = 0;
+
+        /* Check which crtcs have changed outputs connected to them, these need
+         * to be part of the prepare_pipes mask. We don't (yet) support global
+         * modeset across multiple crtcs, so modeset_pipes will only have one
+         * bit set at most. */
+        list_for_each_entry(connector, &dev->mode_config.connector_list,
+                            base.head) {
+                if (connector->base.encoder == &connector->new_encoder->base)
+                        continue;
+
+                if (connector->base.encoder) {
+                        tmp_crtc = connector->base.encoder->crtc;
+
+                        *prepare_pipes |= 1 << to_intel_crtc(tmp_crtc)->pipe;
+                }
+
+                if (connector->new_encoder)
+                        *prepare_pipes |=
+                                1 << connector->new_encoder->new_crtc->pipe;
+        }
+
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list,
+                            base.head) {
+                if (encoder->base.crtc == &encoder->new_crtc->base)
+                        continue;
+
+                if (encoder->base.crtc) {
+                        tmp_crtc = encoder->base.crtc;
+
+                        *prepare_pipes |= 1 << to_intel_crtc(tmp_crtc)->pipe;
+                }
+
+                if (encoder->new_crtc)
+                        *prepare_pipes |= 1 << encoder->new_crtc->pipe;
+        }
+
+        /* Check for any pipes that will be fully disabled ... */
+        list_for_each_entry(intel_crtc, &dev->mode_config.crtc_list,
+                            base.head) {
+                bool used = false;
+
+                /* Don't try to disable disabled crtcs. */
+                if (!intel_crtc->base.enabled)
+                        continue;
+
+                list_for_each_entry(encoder, &dev->mode_config.encoder_list,
+                                    base.head) {
+                        if (encoder->new_crtc == intel_crtc)
+                                used = true;
+                }
+
+                if (!used)
+                        *disable_pipes |= 1 << intel_crtc->pipe;
+        }
+
+
+        /* set_mode is also used to update properties on life display pipes. */
+        intel_crtc = to_intel_crtc(crtc);
+        if (crtc->enabled)
+                *prepare_pipes |= 1 << intel_crtc->pipe;
+
+        /* We only support modeset on one single crtc, hence we need to do that
+         * only for the passed in crtc iff we change anything else than just
+         * disable crtcs.
+         *
+         * This is actually not true, to be fully compatible with the old crtc
+         * helper we automatically disable _any_ output (i.e. doesn't need to be
+         * connected to the crtc we're modesetting on) if it's disconnected.
+         * Which is a rather nutty api (since changed the output configuration
+         * without userspace's explicit request can lead to confusion), but
+         * alas. Hence we currently need to modeset on all pipes we prepare. */
+        if (*prepare_pipes)
+                *modeset_pipes = *prepare_pipes;
+
+        /* ... and mask these out. */
+        *modeset_pipes &= ~(*disable_pipes);
+        *prepare_pipes &= ~(*disable_pipes);
 }
 
-static void intel_crtc_reset(struct drm_crtc *crtc)
+static bool intel_crtc_in_use(struct drm_crtc *crtc)
 {
+        struct drm_encoder *encoder;
         struct drm_device *dev = crtc->dev;
-        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
 
-        /* Reset flags back to the 'unknown' status so that they
-         * will be correctly set on the initial modeset.
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
+                if (encoder->crtc == crtc)
+                        return true;
+
+        return false;
+}
+
+static void
+intel_modeset_update_state(struct drm_device *dev, unsigned prepare_pipes)
+{
+        struct intel_encoder *intel_encoder;
+        struct intel_crtc *intel_crtc;
+        struct drm_connector *connector;
+
+        list_for_each_entry(intel_encoder, &dev->mode_config.encoder_list,
+                            base.head) {
+                if (!intel_encoder->base.crtc)
+                        continue;
+
+                intel_crtc = to_intel_crtc(intel_encoder->base.crtc);
+
+                if (prepare_pipes & (1 << intel_crtc->pipe))
+                        intel_encoder->connectors_active = false;
+        }
+
+        intel_modeset_commit_output_state(dev);
+
+        /* Update computed state. */
+        list_for_each_entry(intel_crtc, &dev->mode_config.crtc_list,
+                            base.head) {
+                intel_crtc->base.enabled = intel_crtc_in_use(&intel_crtc->base);
+        }
+
+        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                if (!connector->encoder || !connector->encoder->crtc)
+                        continue;
+
+                intel_crtc = to_intel_crtc(connector->encoder->crtc);
+
+                if (prepare_pipes & (1 << intel_crtc->pipe)) {
+                        connector->dpms = DRM_MODE_DPMS_ON;
+
+                        intel_encoder = to_intel_encoder(connector->encoder);
+                        intel_encoder->connectors_active = true;
+                }
+        }
+
+}
+
+#define for_each_intel_crtc_masked(dev, mask, intel_crtc) \
+        list_for_each_entry((intel_crtc), \
+                            &(dev)->mode_config.crtc_list, \
+                            base.head) \
+                if (mask & (1 <<(intel_crtc)->pipe)) \
+
+void
+intel_modeset_check_state(struct drm_device *dev)
+{
+        struct intel_crtc *crtc;
+        struct intel_encoder *encoder;
+        struct intel_connector *connector;
+
+        list_for_each_entry(connector, &dev->mode_config.connector_list,
+                            base.head) {
+                /* This also checks the encoder/connector hw state with the
+                 * ->get_hw_state callbacks. */
+                intel_connector_check_state(connector);
+
+                WARN(&connector->new_encoder->base != connector->base.encoder,
+                     "connector's staged encoder doesn't match current encoder\n");
+        }
+
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list,
+                            base.head) {
+                bool enabled = false;
+                bool active = false;
+                enum pipe pipe, tracked_pipe;
+
+                DRM_DEBUG_KMS("[ENCODER:%d:%s]\n",
+                              encoder->base.base.id,
+                              drm_get_encoder_name(&encoder->base));
+
+                WARN(&encoder->new_crtc->base != encoder->base.crtc,
+                     "encoder's stage crtc doesn't match current crtc\n");
+                WARN(encoder->connectors_active && !encoder->base.crtc,
+                     "encoder's active_connectors set, but no crtc\n");
+
+                list_for_each_entry(connector, &dev->mode_config.connector_list,
+                                    base.head) {
+                        if (connector->base.encoder != &encoder->base)
+                                continue;
+                        enabled = true;
+                        if (connector->base.dpms != DRM_MODE_DPMS_OFF)
+                                active = true;
+                }
+                WARN(!!encoder->base.crtc != enabled,
+                     "encoder's enabled state mismatch "
+                     "(expected %i, found %i)\n",
+                     !!encoder->base.crtc, enabled);
+                WARN(active && !encoder->base.crtc,
+                     "active encoder with no crtc\n");
+
+                WARN(encoder->connectors_active != active,
+                     "encoder's computed active state doesn't match tracked active state "
+                     "(expected %i, found %i)\n", active, encoder->connectors_active);
+
+                active = encoder->get_hw_state(encoder, &pipe);
+                WARN(active != encoder->connectors_active,
+                     "encoder's hw state doesn't match sw tracking "
+                     "(expected %i, found %i)\n",
+                     encoder->connectors_active, active);
+
+                if (!encoder->base.crtc)
+                        continue;
+
+                tracked_pipe = to_intel_crtc(encoder->base.crtc)->pipe;
+                WARN(active && pipe != tracked_pipe,
+                     "active encoder's pipe doesn't match"
+                     "(expected %i, found %i)\n",
+                     tracked_pipe, pipe);
+
+        }
+
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list,
+                            base.head) {
+                bool enabled = false;
+                bool active = false;
+
+                DRM_DEBUG_KMS("[CRTC:%d]\n",
+                              crtc->base.base.id);
+
+                WARN(crtc->active && !crtc->base.enabled,
+                     "active crtc, but not enabled in sw tracking\n");
+
+                list_for_each_entry(encoder, &dev->mode_config.encoder_list,
+                                    base.head) {
+                        if (encoder->base.crtc != &crtc->base)
+                                continue;
+                        enabled = true;
+                        if (encoder->connectors_active)
+                                active = true;
+                }
+                WARN(active != crtc->active,
+                     "crtc's computed active state doesn't match tracked active state "
+                     "(expected %i, found %i)\n", active, crtc->active);
+                WARN(enabled != crtc->base.enabled,
+                     "crtc's computed enabled state doesn't match tracked enabled state "
+                     "(expected %i, found %i)\n", enabled, crtc->base.enabled);
+
+                assert_pipe(dev->dev_private, crtc->pipe, crtc->active);
+        }
+}
+
+bool intel_set_mode(struct drm_crtc *crtc,
+                    struct drm_display_mode *mode,
+                    int x, int y, struct drm_framebuffer *fb)
+{
+        struct drm_device *dev = crtc->dev;
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
+        struct drm_encoder_helper_funcs *encoder_funcs;
+        struct drm_encoder *encoder;
+        struct intel_crtc *intel_crtc;
+        unsigned disable_pipes, prepare_pipes, modeset_pipes;
+        bool ret = true;
+
+        intel_modeset_affected_pipes(crtc, &modeset_pipes,
+                                     &prepare_pipes, &disable_pipes);
+
+        DRM_DEBUG_KMS("set mode pipe masks: modeset: %x, prepare: %x, disable: %x\n",
+                      modeset_pipes, prepare_pipes, disable_pipes);
+
+        for_each_intel_crtc_masked(dev, disable_pipes, intel_crtc)
+                intel_crtc_disable(&intel_crtc->base);
+
+        saved_hwmode = crtc->hwmode;
+        saved_mode = crtc->mode;
+
+        /* Hack: Because we don't (yet) support global modeset on multiple
+         * crtcs, we don't keep track of the new mode for more than one crtc.
+         * Hence simply check whether any bit is set in modeset_pipes in all the
+         * pieces of code that are not yet converted to deal with mutliple crtcs
+         * changing their mode at the same time. */
+        adjusted_mode = NULL;
+        if (modeset_pipes) {
+                adjusted_mode = intel_modeset_adjusted_mode(crtc, mode);
+                if (IS_ERR(adjusted_mode)) {
+                        return false;
+                }
+        }
+
+        for_each_intel_crtc_masked(dev, prepare_pipes, intel_crtc) {
+                if (intel_crtc->base.enabled)
+                        dev_priv->display.crtc_disable(&intel_crtc->base);
+        }
+
+        /* crtc->mode is already used by the ->mode_set callbacks, hence we need
+         * to set it here already despite that we pass it down the callchain.
          */
-        intel_crtc->dpms_mode = -1;
+        if (modeset_pipes)
+                crtc->mode = *mode;
 
-        /* We need to fix up any BIOS configuration that conflicts with
-         * our expectations.
+        /* Only after disabling all output pipelines that will be changed can we
+         * update the the output configuration. */
+        intel_modeset_update_state(dev, prepare_pipes);
+
+        /* Set up the DPLL and any encoders state that needs to adjust or depend
+         * on the DPLL.
          */
-        intel_sanitize_modesetting(dev, intel_crtc->pipe, intel_crtc->plane);
+        for_each_intel_crtc_masked(dev, modeset_pipes, intel_crtc) {
+                ret = !intel_crtc_mode_set(&intel_crtc->base,
+                                           mode, adjusted_mode,
+                                           x, y, fb);
+                if (!ret)
+                    goto done;
+
+                list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+
+                        if (encoder->crtc != &intel_crtc->base)
+                                continue;
+
+                        DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
+                                encoder->base.id, drm_get_encoder_name(encoder),
+                                mode->base.id, mode->name);
+                        encoder_funcs = encoder->helper_private;
+                        encoder_funcs->mode_set(encoder, mode, adjusted_mode);
+                }
+        }
+
+        /* Now enable the clocks, plane, pipe, and connectors that we set up. */
+        for_each_intel_crtc_masked(dev, prepare_pipes, intel_crtc)
+                dev_priv->display.crtc_enable(&intel_crtc->base);
+
+        if (modeset_pipes) {
+                /* Store real post-adjustment hardware mode. */
+                crtc->hwmode = *adjusted_mode;
+
+                /* Calculate and store various constants which
+                 * are later needed by vblank and swap-completion
+                 * timestamping. They are derived from true hwmode.
+                 */
+                drm_calc_timestamping_constants(crtc);
+        }
+
+        /* FIXME: add subpixel order */
+done:
+        drm_mode_destroy(dev, adjusted_mode);
+        if (!ret && crtc->enabled) {
+                crtc->hwmode = saved_hwmode;
+                crtc->mode = saved_mode;
+        } else {
+                intel_modeset_check_state(dev);
+        }
+
+        return ret;
 }
 
-static struct drm_crtc_helper_funcs intel_helper_funcs = {
-        .dpms = intel_crtc_dpms,
-        .mode_fixup = intel_crtc_mode_fixup,
-        .mode_set = intel_crtc_mode_set,
-        .mode_set_base = intel_pipe_set_base,
-        .mode_set_base_atomic = intel_pipe_set_base_atomic,
-        .load_lut = intel_crtc_load_lut,
-        .disable = intel_crtc_disable,
-};
+#undef for_each_intel_crtc_masked
+
+static void intel_set_config_free(struct intel_set_config *config)
+{
+        if (!config)
+                return;
+
+        kfree(config->save_connector_encoders);
+        kfree(config->save_encoder_crtcs);
+        kfree(config);
+}
+
+static int intel_set_config_save_state(struct drm_device *dev,
+                                       struct intel_set_config *config)
+{
+        struct drm_encoder *encoder;
+        struct drm_connector *connector;
+        int count;
+
+        config->save_encoder_crtcs =
+                kcalloc(dev->mode_config.num_encoder,
+                        sizeof(struct drm_crtc *), GFP_KERNEL);
+        if (!config->save_encoder_crtcs)
+                return -ENOMEM;
+
+        config->save_connector_encoders =
+                kcalloc(dev->mode_config.num_connector,
+                        sizeof(struct drm_encoder *), GFP_KERNEL);
+        if (!config->save_connector_encoders)
+                return -ENOMEM;
+
+        /* Copy data. Note that driver private data is not affected.
+         * Should anything bad happen only the expected state is
+         * restored, not the drivers personal bookkeeping.
+         */
+        count = 0;
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+                config->save_encoder_crtcs[count++] = encoder->crtc;
+        }
+
+        count = 0;
+        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                config->save_connector_encoders[count++] = connector->encoder;
+        }
+
+        return 0;
+}
+
+static void intel_set_config_restore_state(struct drm_device *dev,
+                                           struct intel_set_config *config)
+{
+        struct intel_encoder *encoder;
+        struct intel_connector *connector;
+        int count;
+
+        count = 0;
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list, base.head) {
+                encoder->new_crtc =
+                        to_intel_crtc(config->save_encoder_crtcs[count++]);
+        }
+
+        count = 0;
+        list_for_each_entry(connector, &dev->mode_config.connector_list, base.head) {
+                connector->new_encoder =
+                        to_intel_encoder(config->save_connector_encoders[count++]);
+        }
+}
+
+static void
+intel_set_config_compute_mode_changes(struct drm_mode_set *set,
+                                      struct intel_set_config *config)
+{
+
+        /* We should be able to check here if the fb has the same properties
+         * and then just flip_or_move it */
+        if (set->crtc->fb != set->fb) {
+                /* If we have no fb then treat it as a full mode set */
+                if (set->crtc->fb == NULL) {
+                        DRM_DEBUG_KMS("crtc has no fb, full mode set\n");
+                        config->mode_changed = true;
+                } else if (set->fb == NULL) {
+                        config->mode_changed = true;
+                } else if (set->fb->depth != set->crtc->fb->depth) {
+                        config->mode_changed = true;
+                } else if (set->fb->bits_per_pixel !=
+                           set->crtc->fb->bits_per_pixel) {
+                        config->mode_changed = true;
+                } else
+                        config->fb_changed = true;
+        }
+
+        if (set->fb && (set->x != set->crtc->x || set->y != set->crtc->y))
+                config->fb_changed = true;
+
+        if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) {
+                DRM_DEBUG_KMS("modes are different, full mode set\n");
+                drm_mode_debug_printmodeline(&set->crtc->mode);
+                drm_mode_debug_printmodeline(set->mode);
+                config->mode_changed = true;
+        }
+}
+
+static int
+intel_modeset_stage_output_state(struct drm_device *dev,
+                                 struct drm_mode_set *set,
+                                 struct intel_set_config *config)
+{
+        struct drm_crtc *new_crtc;
+        struct intel_connector *connector;
+        struct intel_encoder *encoder;
+        int count, ro;
+
+        /* The upper layers ensure that we either disabl a crtc or have a list
+         * of connectors. For paranoia, double-check this. */
+        WARN_ON(!set->fb && (set->num_connectors != 0));
+        WARN_ON(set->fb && (set->num_connectors == 0));
+
+        count = 0;
+        list_for_each_entry(connector, &dev->mode_config.connector_list,
+                            base.head) {
+                /* Otherwise traverse passed in connector list and get encoders
+                 * for them. */
+                for (ro = 0; ro < set->num_connectors; ro++) {
+                        if (set->connectors[ro] == &connector->base) {
+                                connector->new_encoder = connector->encoder;
+                                break;
+                        }
+                }
+
+                /* If we disable the crtc, disable all its connectors. Also, if
+                 * the connector is on the changing crtc but not on the new
+                 * connector list, disable it. */
+                if ((!set->fb || ro == set->num_connectors) &&
+                    connector->base.encoder &&
+                    connector->base.encoder->crtc == set->crtc) {
+                        connector->new_encoder = NULL;
+
+                        DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n",
+                                connector->base.base.id,
+                                drm_get_connector_name(&connector->base));
+                }
+
+
+                if (&connector->new_encoder->base != connector->base.encoder) {
+                        DRM_DEBUG_KMS("encoder changed, full mode switch\n");
+                        config->mode_changed = true;
+                }
+
+                /* Disable all disconnected encoders. */
+                if (connector->base.status == connector_status_disconnected)
+                        connector->new_encoder = NULL;
+        }
+        /* connector->new_encoder is now updated for all connectors. */
+
+        /* Update crtc of enabled connectors. */
+        count = 0;
+        list_for_each_entry(connector, &dev->mode_config.connector_list,
+                            base.head) {
+                if (!connector->new_encoder)
+                        continue;
+
+                new_crtc = connector->new_encoder->base.crtc;
+
+                for (ro = 0; ro < set->num_connectors; ro++) {
+                        if (set->connectors[ro] == &connector->base)
+                                new_crtc = set->crtc;
+                }
+
+                /* Make sure the new CRTC will work with the encoder */
+                if (!intel_encoder_crtc_ok(&connector->new_encoder->base,
+                                           new_crtc)) {
+                        return -EINVAL;
+                }
+                connector->encoder->new_crtc = to_intel_crtc(new_crtc);
+
+                DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d]\n",
+                        connector->base.base.id,
+                        drm_get_connector_name(&connector->base),
+                        new_crtc->base.id);
+        }
+
+        /* Check for any encoders that needs to be disabled. */
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list,
+                            base.head) {
+                list_for_each_entry(connector,
+                                    &dev->mode_config.connector_list,
+                                    base.head) {
+                        if (connector->new_encoder == encoder) {
+                                WARN_ON(!connector->new_encoder->new_crtc);
+
+                                goto next_encoder;
+                        }
+                }
+                encoder->new_crtc = NULL;
+next_encoder:
+                /* Only now check for crtc changes so we don't miss encoders
+                 * that will be disabled. */
+                if (&encoder->new_crtc->base != encoder->base.crtc) {
+                        DRM_DEBUG_KMS("crtc changed, full mode switch\n");
+                        config->mode_changed = true;
+                }
+        }
+        /* Now we've also updated encoder->new_crtc for all encoders. */
+
+        return 0;
+}
+
+static int intel_crtc_set_config(struct drm_mode_set *set)
+{
+        struct drm_device *dev;
+        struct drm_mode_set save_set;
+        struct intel_set_config *config;
+        int ret;
+        int i;
+
+        BUG_ON(!set);
+        BUG_ON(!set->crtc);
+        BUG_ON(!set->crtc->helper_private);
+
+        if (!set->mode)
+                set->fb = NULL;
+
+        /* The fb helper likes to play gross jokes with ->mode_set_config.
+         * Unfortunately the crtc helper doesn't do much at all for this case,
+         * so we have to cope with this madness until the fb helper is fixed up. */
+        if (set->fb && set->num_connectors == 0)
+                return 0;
+
+        if (set->fb) {
+                DRM_DEBUG_KMS("[CRTC:%d] [FB:%d] #connectors=%d (x y) (%i %i)\n",
+                                set->crtc->base.id, set->fb->base.id,
+                                (int)set->num_connectors, set->x, set->y);
+        } else {
+                DRM_DEBUG_KMS("[CRTC:%d] [NOFB]\n", set->crtc->base.id);
+        }
+
+        dev = set->crtc->dev;
+
+        ret = -ENOMEM;
+        config = kzalloc(sizeof(*config), GFP_KERNEL);
+        if (!config)
+                goto out_config;
+
+        ret = intel_set_config_save_state(dev, config);
+        if (ret)
+                goto out_config;
+
+        save_set.crtc = set->crtc;
+        save_set.mode = &set->crtc->mode;
+        save_set.x = set->crtc->x;
+        save_set.y = set->crtc->y;
+        save_set.fb = set->crtc->fb;
+
+        /* Compute whether we need a full modeset, only an fb base update or no
+         * change at all. In the future we might also check whether only the
+         * mode changed, e.g. for LVDS where we only change the panel fitter in
+         * such cases. */
+        intel_set_config_compute_mode_changes(set, config);
+
+        ret = intel_modeset_stage_output_state(dev, set, config);
+        if (ret)
+                goto fail;
+
+        if (config->mode_changed) {
+                if (set->mode) {
+                        DRM_DEBUG_KMS("attempting to set mode from"
+                                        " userspace\n");
+                        drm_mode_debug_printmodeline(set->mode);
+                }
+
+                if (!intel_set_mode(set->crtc, set->mode,
+                                    set->x, set->y, set->fb)) {
+                        DRM_ERROR("failed to set mode on [CRTC:%d]\n",
+                                  set->crtc->base.id);
+                        ret = -EINVAL;
+                        goto fail;
+                }
+
+                if (set->crtc->enabled) {
+                        DRM_DEBUG_KMS("Setting connector DPMS state to on\n");
+                        for (i = 0; i < set->num_connectors; i++) {
+                                DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id,
+                                              drm_get_connector_name(set->connectors[i]));
+                                set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON);
+                        }
+                }
+        } else if (config->fb_changed) {
+                ret = intel_pipe_set_base(set->crtc,
+                                          set->x, set->y, set->fb);
+        }
+
+        intel_set_config_free(config);
+
+        return 0;
+
+fail:
+        intel_set_config_restore_state(dev, config);
+
+        /* Try to restore the config */
+        if (config->mode_changed &&
+            !intel_set_mode(save_set.crtc, save_set.mode,
+                            save_set.x, save_set.y, save_set.fb))
+                DRM_ERROR("failed to restore config after modeset failure\n");
+
+out_config:
+        intel_set_config_free(config);
+        return ret;
+}
 
 static const struct drm_crtc_funcs intel_crtc_funcs = {
-        .reset = intel_crtc_reset,
         .cursor_set = intel_crtc_cursor_set,
         .cursor_move = intel_crtc_cursor_move,
         .gamma_set = intel_crtc_gamma_set,
-        .set_config = drm_crtc_helper_set_config,
+        .set_config = intel_crtc_set_config,
         .destroy = intel_crtc_destroy,
         .page_flip = intel_crtc_page_flip,
 };
@@ -6657,18 +7450,8 @@ static void intel_crtc_init(struct drm_device *dev, int pipe)
         dev_priv->plane_to_crtc_mapping[intel_crtc->plane] = &intel_crtc->base;
         dev_priv->pipe_to_crtc_mapping[intel_crtc->pipe] = &intel_crtc->base;
 
-        intel_crtc_reset(&intel_crtc->base);
-        intel_crtc->active = true; /* force the pipe off on setup_init_config */
         intel_crtc->bpp = 24; /* default for pre-Ironlake */
 
-        if (HAS_PCH_SPLIT(dev)) {
-                intel_helper_funcs.prepare = ironlake_crtc_prepare;
-                intel_helper_funcs.commit = ironlake_crtc_commit;
-        } else {
-                intel_helper_funcs.prepare = i9xx_crtc_prepare;
-                intel_helper_funcs.commit = i9xx_crtc_commit;
-        }
-
         drm_crtc_helper_add(&intel_crtc->base, &intel_helper_funcs);
 }
 
@@ -6874,9 +7657,6 @@ static void intel_setup_outputs(struct drm_device *dev)
                         intel_encoder_clones(encoder);
         }
 
-        /* disable all the possible outputs/crtcs before entering KMS mode */
-        drm_helper_disable_unused_functions(dev);
-
         if (HAS_PCH_IBX(dev) || HAS_PCH_CPT(dev))
                 ironlake_init_pch_refclk(dev);
 }
@@ -6978,13 +7758,15 @@ static void intel_init_display(struct drm_device *dev)
 
         /* We always want a DPMS function */
         if (HAS_PCH_SPLIT(dev)) {
-                dev_priv->display.dpms = ironlake_crtc_dpms;
                 dev_priv->display.crtc_mode_set = ironlake_crtc_mode_set;
+                dev_priv->display.crtc_enable = ironlake_crtc_enable;
+                dev_priv->display.crtc_disable = ironlake_crtc_disable;
                 dev_priv->display.off = ironlake_crtc_off;
                 dev_priv->display.update_plane = ironlake_update_plane;
         } else {
-                dev_priv->display.dpms = i9xx_crtc_dpms;
                 dev_priv->display.crtc_mode_set = i9xx_crtc_mode_set;
+                dev_priv->display.crtc_enable = i9xx_crtc_enable;
+                dev_priv->display.crtc_disable = i9xx_crtc_disable;
                 dev_priv->display.off = i9xx_crtc_off;
                 dev_priv->display.update_plane = i9xx_update_plane;
         }
@@ -7233,11 +8015,258 @@ void intel_modeset_init(struct drm_device *dev)
         intel_setup_outputs(dev);
 }
 
+static void
+intel_connector_break_all_links(struct intel_connector *connector)
+{
+        connector->base.dpms = DRM_MODE_DPMS_OFF;
+        connector->base.encoder = NULL;
+        connector->encoder->connectors_active = false;
+        connector->encoder->base.crtc = NULL;
+}
+
+static void intel_enable_pipe_a(struct drm_device *dev)
+{
+        struct intel_connector *connector;
+        struct drm_connector *crt = NULL;
+        struct intel_load_detect_pipe load_detect_temp;
+
+        /* We can't just switch on the pipe A, we need to set things up with a
+         * proper mode and output configuration. As a gross hack, enable pipe A
+         * by enabling the load detect pipe once. */
+        list_for_each_entry(connector,
+                            &dev->mode_config.connector_list,
+                            base.head) {
+                if (connector->encoder->type == INTEL_OUTPUT_ANALOG) {
+                        crt = &connector->base;
+                        break;
+                }
+        }
+
+        if (!crt)
+                return;
+
+        if (intel_get_load_detect_pipe(crt, NULL, &load_detect_temp))
+                intel_release_load_detect_pipe(crt, &load_detect_temp);
+
+
+}
+
+static void intel_sanitize_crtc(struct intel_crtc *crtc)
+{
+        struct drm_device *dev = crtc->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 reg, val;
+
+        /* Clear any frame start delays used for debugging left by the BIOS */
+        reg = PIPECONF(crtc->pipe);
+        I915_WRITE(reg, I915_READ(reg) & ~PIPECONF_FRAME_START_DELAY_MASK);
+
+        /* We need to sanitize the plane -> pipe mapping first because this will
+         * disable the crtc (and hence change the state) if it is wrong. */
+        if (!HAS_PCH_SPLIT(dev)) {
+                struct intel_connector *connector;
+                bool plane;
+
+                reg = DSPCNTR(crtc->plane);
+                val = I915_READ(reg);
+
+                if ((val & DISPLAY_PLANE_ENABLE) == 0 &&
+                    (!!(val & DISPPLANE_SEL_PIPE_MASK) == crtc->pipe))
+                        goto ok;
+
+                DRM_DEBUG_KMS("[CRTC:%d] wrong plane connection detected!\n",
+                              crtc->base.base.id);
+
+                /* Pipe has the wrong plane attached and the plane is active.
+                 * Temporarily change the plane mapping and disable everything
+                 * ...  */
+                plane = crtc->plane;
+                crtc->plane = !plane;
+                dev_priv->display.crtc_disable(&crtc->base);
+                crtc->plane = plane;
+
+                /* ... and break all links. */
+                list_for_each_entry(connector, &dev->mode_config.connector_list,
+                                    base.head) {
+                        if (connector->encoder->base.crtc != &crtc->base)
+                                continue;
+
+                        intel_connector_break_all_links(connector);
+                }
+
+                WARN_ON(crtc->active);
+                crtc->base.enabled = false;
+        }
+ok:
+
+        if (dev_priv->quirks & QUIRK_PIPEA_FORCE &&
+            crtc->pipe == PIPE_A && !crtc->active) {
+                /* BIOS forgot to enable pipe A, this mostly happens after
+                 * resume. Force-enable the pipe to fix this, the update_dpms
+                 * call below we restore the pipe to the right state, but leave
+                 * the required bits on. */
+                intel_enable_pipe_a(dev);
+        }
+
+        /* Adjust the state of the output pipe according to whether we
+         * have active connectors/encoders. */
+        intel_crtc_update_dpms(&crtc->base);
+
+        if (crtc->active != crtc->base.enabled) {
+                struct intel_encoder *encoder;
+
+                /* This can happen either due to bugs in the get_hw_state
+                 * functions or because the pipe is force-enabled due to the
+                 * pipe A quirk. */
+                DRM_DEBUG_KMS("[CRTC:%d] hw state adjusted, was %s, now %s\n",
+                              crtc->base.base.id,
+                              crtc->base.enabled ? "enabled" : "disabled",
+                              crtc->active ? "enabled" : "disabled");
+
+                crtc->base.enabled = crtc->active;
+
+                /* Because we only establish the connector -> encoder ->
+                 * crtc links if something is active, this means the
+                 * crtc is now deactivated. Break the links. connector
+                 * -> encoder links are only establish when things are
+                 *  actually up, hence no need to break them. */
+                WARN_ON(crtc->active);
+
+                for_each_encoder_on_crtc(dev, &crtc->base, encoder) {
+                        WARN_ON(encoder->connectors_active);
+                        encoder->base.crtc = NULL;
+                }
+        }
+}
+
+static void intel_sanitize_encoder(struct intel_encoder *encoder)
+{
+        struct intel_connector *connector;
+        struct drm_device *dev = encoder->base.dev;
+
+        /* We need to check both for a crtc link (meaning that the
+         * encoder is active and trying to read from a pipe) and the
+         * pipe itself being active. */
+        bool has_active_crtc = encoder->base.crtc &&
+                to_intel_crtc(encoder->base.crtc)->active;
+
+        if (encoder->connectors_active && !has_active_crtc) {
+                DRM_DEBUG_KMS("[ENCODER:%d:%s] has active connectors but no active pipe!\n",
+                              encoder->base.base.id,
+                              drm_get_encoder_name(&encoder->base));
+
+                /* Connector is active, but has no active pipe. This is
+                 * fallout from our resume register restoring. Disable
+                 * the encoder manually again. */
+                if (encoder->base.crtc) {
+                        DRM_DEBUG_KMS("[ENCODER:%d:%s] manually disabled\n",
+                                      encoder->base.base.id,
+                                      drm_get_encoder_name(&encoder->base));
+                        encoder->disable(encoder);
+                }
+
+                /* Inconsistent output/port/pipe state happens presumably due to
+                 * a bug in one of the get_hw_state functions. Or someplace else
+                 * in our code, like the register restore mess on resume. Clamp
+                 * things to off as a safer default. */
+                list_for_each_entry(connector,
+                                    &dev->mode_config.connector_list,
+                                    base.head) {
+                        if (connector->encoder != encoder)
+                                continue;
+
+                        intel_connector_break_all_links(connector);
+                }
+        }
+        /* Enabled encoders without active connectors will be fixed in
+         * the crtc fixup. */
+}
+
+/* Scan out the current hw modeset state, sanitizes it and maps it into the drm
+ * and i915 state tracking structures. */
+void intel_modeset_setup_hw_state(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        enum pipe pipe;
+        u32 tmp;
+        struct intel_crtc *crtc;
+        struct intel_encoder *encoder;
+        struct intel_connector *connector;
+
+        for_each_pipe(pipe) {
+                crtc = to_intel_crtc(dev_priv->pipe_to_crtc_mapping[pipe]);
+
+                tmp = I915_READ(PIPECONF(pipe));
+                if (tmp & PIPECONF_ENABLE)
+                        crtc->active = true;
+                else
+                        crtc->active = false;
+
+                crtc->base.enabled = crtc->active;
+
+                DRM_DEBUG_KMS("[CRTC:%d] hw state readout: %s\n",
+                              crtc->base.base.id,
+                              crtc->active ? "enabled" : "disabled");
+        }
+
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list,
+                            base.head) {
+                pipe = 0;
+
+                if (encoder->get_hw_state(encoder, &pipe)) {
+                        encoder->base.crtc =
+                                dev_priv->pipe_to_crtc_mapping[pipe];
+                } else {
+                        encoder->base.crtc = NULL;
+                }
+
+                encoder->connectors_active = false;
+                DRM_DEBUG_KMS("[ENCODER:%d:%s] hw state readout: %s, pipe=%i\n",
+                              encoder->base.base.id,
+                              drm_get_encoder_name(&encoder->base),
+                              encoder->base.crtc ? "enabled" : "disabled",
+                              pipe);
+        }
+
+        list_for_each_entry(connector, &dev->mode_config.connector_list,
+                            base.head) {
+                if (connector->get_hw_state(connector)) {
+                        connector->base.dpms = DRM_MODE_DPMS_ON;
+                        connector->encoder->connectors_active = true;
+                        connector->base.encoder = &connector->encoder->base;
+                } else {
+                        connector->base.dpms = DRM_MODE_DPMS_OFF;
+                        connector->base.encoder = NULL;
+                }
+                DRM_DEBUG_KMS("[CONNECTOR:%d:%s] hw state readout: %s\n",
+                              connector->base.base.id,
+                              drm_get_connector_name(&connector->base),
+                              connector->base.encoder ? "enabled" : "disabled");
+        }
+
+        /* HW state is read out, now we need to sanitize this mess. */
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list,
+                            base.head) {
+                intel_sanitize_encoder(encoder);
+        }
+
+        for_each_pipe(pipe) {
+                crtc = to_intel_crtc(dev_priv->pipe_to_crtc_mapping[pipe]);
+                intel_sanitize_crtc(crtc);
+        }
+
+        intel_modeset_update_staged_output_state(dev);
+
+        intel_modeset_check_state(dev);
+}
+
 void intel_modeset_gem_init(struct drm_device *dev)
 {
         intel_modeset_init_hw(dev);
 
         intel_setup_overlay(dev);
+
+        intel_modeset_setup_hw_state(dev);
 }
 
 void intel_modeset_cleanup(struct drm_device *dev)
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index 143d19c26752..c59710db653e 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -1248,10 +1248,57 @@ static void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode)
         }
 }
 
-static void intel_dp_prepare(struct drm_encoder *encoder)
+static bool intel_dp_get_hw_state(struct intel_encoder *encoder,
+                                  enum pipe *pipe)
 {
-        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
+        struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 tmp = I915_READ(intel_dp->output_reg);
+
+        if (!(tmp & DP_PORT_EN))
+                return false;
 
+        if (is_cpu_edp(intel_dp) && IS_GEN7(dev)) {
+                *pipe = PORT_TO_PIPE_CPT(tmp);
+        } else if (!HAS_PCH_CPT(dev) || is_cpu_edp(intel_dp)) {
+                *pipe = PORT_TO_PIPE(tmp);
+        } else {
+                u32 trans_sel;
+                u32 trans_dp;
+                int i;
+
+                switch (intel_dp->output_reg) {
+                case PCH_DP_B:
+                        trans_sel = TRANS_DP_PORT_SEL_B;
+                        break;
+                case PCH_DP_C:
+                        trans_sel = TRANS_DP_PORT_SEL_C;
+                        break;
+                case PCH_DP_D:
+                        trans_sel = TRANS_DP_PORT_SEL_D;
+                        break;
+                default:
+                        return true;
+                }
+
+                for_each_pipe(i) {
+                        trans_dp = I915_READ(TRANS_DP_CTL(i));
+                        if ((trans_dp & TRANS_DP_PORT_SEL_MASK) == trans_sel) {
+                                *pipe = i;
+                                return true;
+                        }
+                }
+        }
+
+        DRM_DEBUG_KMS("No pipe for dp port 0x%x found\n", intel_dp->output_reg);
+
+        return true;
+}
+
+static void intel_disable_dp(struct intel_encoder *encoder)
+{
+        struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
 
         /* Make sure the panel is off before trying to change the mode. But also
          * ensure that we have vdd while we switch off the panel. */
@@ -1262,60 +1309,58 @@ static void intel_dp_prepare(struct drm_encoder *encoder)
         intel_dp_link_down(intel_dp);
 }
 
-static void intel_dp_commit(struct drm_encoder *encoder)
+static void intel_enable_dp(struct intel_encoder *encoder)
 {
-        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
-        struct drm_device *dev = encoder->dev;
-        struct intel_crtc *intel_crtc = to_intel_crtc(intel_dp->base.base.crtc);
+        struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t dp_reg = I915_READ(intel_dp->output_reg);
 
         ironlake_edp_panel_vdd_on(intel_dp);
         intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_ON);
-        intel_dp_start_link_train(intel_dp);
-        ironlake_edp_panel_on(intel_dp);
-        ironlake_edp_panel_vdd_off(intel_dp, true);
-        intel_dp_complete_link_train(intel_dp);
+        if (!(dp_reg & DP_PORT_EN)) {
+                intel_dp_start_link_train(intel_dp);
+                ironlake_edp_panel_on(intel_dp);
+                ironlake_edp_panel_vdd_off(intel_dp, true);
+                intel_dp_complete_link_train(intel_dp);
+        } else
+                ironlake_edp_panel_vdd_off(intel_dp, false);
         ironlake_edp_backlight_on(intel_dp);
-
-        intel_dp->dpms_mode = DRM_MODE_DPMS_ON;
-
-        if (HAS_PCH_CPT(dev))
-                intel_cpt_verify_modeset(dev, intel_crtc->pipe);
 }
 
 static void
-intel_dp_dpms(struct drm_encoder *encoder, int mode)
+intel_dp_dpms(struct drm_connector *connector, int mode)
 {
-        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
-        struct drm_device *dev = encoder->dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
-        uint32_t dp_reg = I915_READ(intel_dp->output_reg);
+        struct intel_dp *intel_dp = intel_attached_dp(connector);
+
+        /* DP supports only 2 dpms states. */
+        if (mode != DRM_MODE_DPMS_ON)
+                mode = DRM_MODE_DPMS_OFF;
+
+        if (mode == connector->dpms)
+                return;
+
+        connector->dpms = mode;
+
+        /* Only need to change hw state when actually enabled */
+        if (!intel_dp->base.base.crtc) {
+                intel_dp->base.connectors_active = false;
+                return;
+        }
 
         if (mode != DRM_MODE_DPMS_ON) {
-                /* Switching the panel off requires vdd. */
-                ironlake_edp_panel_vdd_on(intel_dp);
-                ironlake_edp_backlight_off(intel_dp);
-                intel_dp_sink_dpms(intel_dp, mode);
-                ironlake_edp_panel_off(intel_dp);
-                intel_dp_link_down(intel_dp);
+                intel_encoder_dpms(&intel_dp->base, mode);
 
                 if (is_cpu_edp(intel_dp))
-                        ironlake_edp_pll_off(encoder);
+                        ironlake_edp_pll_off(&intel_dp->base.base);
         } else {
                 if (is_cpu_edp(intel_dp))
-                        ironlake_edp_pll_on(encoder);
+                        ironlake_edp_pll_on(&intel_dp->base.base);
 
-                ironlake_edp_panel_vdd_on(intel_dp);
-                intel_dp_sink_dpms(intel_dp, mode);
-                if (!(dp_reg & DP_PORT_EN)) {
-                        intel_dp_start_link_train(intel_dp);
-                        ironlake_edp_panel_on(intel_dp);
-                        ironlake_edp_panel_vdd_off(intel_dp, true);
-                        intel_dp_complete_link_train(intel_dp);
-                } else
-                        ironlake_edp_panel_vdd_off(intel_dp, false);
-                ironlake_edp_backlight_on(intel_dp);
+                intel_encoder_dpms(&intel_dp->base, mode);
         }
-        intel_dp->dpms_mode = mode;
+
+        intel_modeset_check_state(connector->dev);
 }
 
 /*
@@ -2016,10 +2061,10 @@ intel_dp_check_link_status(struct intel_dp *intel_dp)
         u8 sink_irq_vector;
         u8 link_status[DP_LINK_STATUS_SIZE];
 
-        if (intel_dp->dpms_mode != DRM_MODE_DPMS_ON)
+        if (!intel_dp->base.connectors_active)
                 return;
 
-        if (!intel_dp->base.base.crtc)
+        if (WARN_ON(!intel_dp->base.base.crtc))
                 return;
 
         /* Try to read receiver status if the link appears to be up */
@@ -2305,9 +2350,8 @@ intel_dp_set_property(struct drm_connector *connector,
 done:
         if (intel_dp->base.base.crtc) {
                 struct drm_crtc *crtc = intel_dp->base.base.crtc;
-                drm_crtc_helper_set_mode(crtc, &crtc->mode,
-                                         crtc->x, crtc->y,
-                                         crtc->fb);
+                intel_set_mode(crtc, &crtc->mode,
+                               crtc->x, crtc->y, crtc->fb);
         }
 
         return 0;
@@ -2341,15 +2385,13 @@ static void intel_dp_encoder_destroy(struct drm_encoder *encoder)
 }
 
 static const struct drm_encoder_helper_funcs intel_dp_helper_funcs = {
-        .dpms = intel_dp_dpms,
         .mode_fixup = intel_dp_mode_fixup,
-        .prepare = intel_dp_prepare,
         .mode_set = intel_dp_mode_set,
-        .commit = intel_dp_commit,
+        .disable = intel_encoder_noop,
 };
 
 static const struct drm_connector_funcs intel_dp_connector_funcs = {
-        .dpms = drm_helper_connector_dpms,
+        .dpms = intel_dp_dpms,
         .detect = intel_dp_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .set_property = intel_dp_set_property,
@@ -2436,7 +2478,6 @@ intel_dp_init(struct drm_device *dev, int output_reg, enum port port)
 
         intel_dp->output_reg = output_reg;
         intel_dp->port = port;
-        intel_dp->dpms_mode = -1;
 
         intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
         if (!intel_connector) {
@@ -2480,6 +2521,11 @@ intel_dp_init(struct drm_device *dev, int output_reg, enum port port)
         intel_connector_attach_encoder(intel_connector, intel_encoder);
         drm_sysfs_connector_add(connector);
 
+        intel_encoder->enable = intel_enable_dp;
+        intel_encoder->disable = intel_disable_dp;
+        intel_encoder->get_hw_state = intel_dp_get_hw_state;
+        intel_connector->get_hw_state = intel_connector_get_hw_state;
+
         /* Set up the DDC bus. */
         switch (port) {
         case PORT_A:
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index ee0beb4833fb..4f2b2d6a2489 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -41,7 +41,11 @@
                         ret__ = -ETIMEDOUT;                             \
                         break;                                          \
                 }                                                       \
-                if (W && drm_can_sleep()) msleep(W);    \
+                if (W && drm_can_sleep())  {                            \
+                        msleep(W);                                      \
+                } else {                                                \
+                        cpu_relax();                                    \
+                }                                                       \
         }                                                               \
         ret__;                                                          \
 })
@@ -133,6 +137,12 @@ struct intel_fbdev {
 
 struct intel_encoder {
         struct drm_encoder base;
+        /*
+         * The new crtc this encoder will be driven from. Only differs from
+         * base->crtc while a modeset is in progress.
+         */
+        struct intel_crtc *new_crtc;
+
         int type;
         bool needs_tv_clock;
         /*
@@ -140,13 +150,33 @@ struct intel_encoder {
          * simple flag is enough to compute the possible_clones mask.
          */
         bool cloneable;
+        bool connectors_active;
         void (*hot_plug)(struct intel_encoder *);
+        void (*enable)(struct intel_encoder *);
+        void (*disable)(struct intel_encoder *);
+        /* Read out the current hw state of this connector, returning true if
+         * the encoder is active. If the encoder is enabled it also set the pipe
+         * it is connected to in the pipe parameter. */
+        bool (*get_hw_state)(struct intel_encoder *, enum pipe *pipe);
         int crtc_mask;
 };
 
 struct intel_connector {
         struct drm_connector base;
+        /*
+         * The fixed encoder this connector is connected to.
+         */
         struct intel_encoder *encoder;
+
+        /*
+         * The new encoder this connector will be driven. Only differs from
+         * encoder while a modeset is in progress.
+         */
+        struct intel_encoder *new_encoder;
+
+        /* Reads out the current hw, returning true if the connector is enabled
+         * and active (i.e. dpms ON state). */
+        bool (*get_hw_state)(struct intel_connector *);
 };
 
 struct intel_crtc {
@@ -154,8 +184,12 @@ struct intel_crtc {
         enum pipe pipe;
         enum plane plane;
         u8 lut_r[256], lut_g[256], lut_b[256];
-        int dpms_mode;
-        bool active; /* is the crtc on? independent of the dpms mode */
+        /*
+         * Whether the crtc and the connected output pipeline is active. Implies
+         * that crtc->enabled is set, i.e. the current mode configuration has
+         * some outputs connected to this crtc.
+         */
+        bool active;
         bool primary_disabled; /* is the crtc obscured by a plane? */
         bool lowfreq_avail;
         struct intel_overlay *overlay;
@@ -307,7 +341,6 @@ struct intel_dp {
         enum hdmi_force_audio force_audio;
         enum port port;
         uint32_t color_range;
-        int dpms_mode;
         uint8_t link_bw;
         uint8_t lane_count;
         uint8_t dpcd[DP_RECEIVER_CAP_SIZE];
@@ -409,10 +442,27 @@ extern void intel_panel_disable_backlight(struct drm_device *dev);
 extern void intel_panel_destroy_backlight(struct drm_device *dev);
 extern enum drm_connector_status intel_panel_detect(struct drm_device *dev);
 
+struct intel_set_config {
+        struct drm_encoder **save_connector_encoders;
+        struct drm_crtc **save_encoder_crtcs;
+
+        bool fb_changed;
+        bool mode_changed;
+};
+
+extern bool intel_set_mode(struct drm_crtc *crtc, struct drm_display_mode *mode,
+                           int x, int y, struct drm_framebuffer *old_fb);
+extern void intel_modeset_disable(struct drm_device *dev);
 extern void intel_crtc_load_lut(struct drm_crtc *crtc);
-extern void intel_encoder_prepare(struct drm_encoder *encoder);
-extern void intel_encoder_commit(struct drm_encoder *encoder);
+extern void intel_crtc_update_dpms(struct drm_crtc *crtc);
+extern void intel_encoder_noop(struct drm_encoder *encoder);
 extern void intel_encoder_destroy(struct drm_encoder *encoder);
+extern void intel_encoder_dpms(struct intel_encoder *encoder, int mode);
+extern bool intel_encoder_check_is_cloned(struct intel_encoder *encoder);
+extern void intel_connector_dpms(struct drm_connector *, int mode);
+extern bool intel_connector_get_hw_state(struct intel_connector *connector);
+extern void intel_modeset_check_state(struct drm_device *dev);
+
 
 static inline struct intel_encoder *intel_attached_encoder(struct drm_connector *connector)
 {
@@ -519,7 +569,10 @@ extern void intel_disable_gt_powersave(struct drm_device *dev);
 extern void gen6_gt_check_fifodbg(struct drm_i915_private *dev_priv);
 extern void ironlake_teardown_rc6(struct drm_device *dev);
 
-extern void intel_ddi_dpms(struct drm_encoder *encoder, int mode);
+extern void intel_enable_ddi(struct intel_encoder *encoder);
+extern void intel_disable_ddi(struct intel_encoder *encoder);
+extern bool intel_ddi_get_hw_state(struct intel_encoder *encoder,
+                                   enum pipe *pipe);
 extern void intel_ddi_mode_set(struct drm_encoder *encoder,
                                 struct drm_display_mode *mode,
                                 struct drm_display_mode *adjusted_mode);
diff --git a/drivers/gpu/drm/i915/intel_dvo.c b/drivers/gpu/drm/i915/intel_dvo.c
index 227551f12d25..4f1fdcc44005 100644
--- a/drivers/gpu/drm/i915/intel_dvo.c
+++ b/drivers/gpu/drm/i915/intel_dvo.c
@@ -105,22 +105,91 @@ static struct intel_dvo *intel_attached_dvo(struct drm_connector *connector)
                             struct intel_dvo, base);
 }
 
-static void intel_dvo_dpms(struct drm_encoder *encoder, int mode)
+static bool intel_dvo_connector_get_hw_state(struct intel_connector *connector)
 {
-        struct drm_i915_private *dev_priv = encoder->dev->dev_private;
-        struct intel_dvo *intel_dvo = enc_to_intel_dvo(encoder);
+        struct intel_dvo *intel_dvo = intel_attached_dvo(&connector->base);
+
+        return intel_dvo->dev.dev_ops->get_hw_state(&intel_dvo->dev);
+}
+
+static bool intel_dvo_get_hw_state(struct intel_encoder *encoder,
+                                   enum pipe *pipe)
+{
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(&encoder->base);
+        u32 tmp;
+
+        tmp = I915_READ(intel_dvo->dev.dvo_reg);
+
+        if (!(tmp & DVO_ENABLE))
+                return false;
+
+        *pipe = PORT_TO_PIPE(tmp);
+
+        return true;
+}
+
+static void intel_disable_dvo(struct intel_encoder *encoder)
+{
+        struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(&encoder->base);
+        u32 dvo_reg = intel_dvo->dev.dvo_reg;
+        u32 temp = I915_READ(dvo_reg);
+
+        intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, false);
+        I915_WRITE(dvo_reg, temp & ~DVO_ENABLE);
+        I915_READ(dvo_reg);
+}
+
+static void intel_enable_dvo(struct intel_encoder *encoder)
+{
+        struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(&encoder->base);
         u32 dvo_reg = intel_dvo->dev.dvo_reg;
         u32 temp = I915_READ(dvo_reg);
 
+        I915_WRITE(dvo_reg, temp | DVO_ENABLE);
+        I915_READ(dvo_reg);
+        intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, true);
+}
+
+static void intel_dvo_dpms(struct drm_connector *connector, int mode)
+{
+        struct intel_dvo *intel_dvo = intel_attached_dvo(connector);
+        struct drm_crtc *crtc;
+
+        /* dvo supports only 2 dpms states. */
+        if (mode != DRM_MODE_DPMS_ON)
+                mode = DRM_MODE_DPMS_OFF;
+
+        if (mode == connector->dpms)
+                return;
+
+        connector->dpms = mode;
+
+        /* Only need to change hw state when actually enabled */
+        crtc = intel_dvo->base.base.crtc;
+        if (!crtc) {
+                intel_dvo->base.connectors_active = false;
+                return;
+        }
+
         if (mode == DRM_MODE_DPMS_ON) {
-                I915_WRITE(dvo_reg, temp | DVO_ENABLE);
-                I915_READ(dvo_reg);
+                intel_dvo->base.connectors_active = true;
+
+                intel_crtc_update_dpms(crtc);
+
                 intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, true);
         } else {
                 intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, false);
-                I915_WRITE(dvo_reg, temp & ~DVO_ENABLE);
-                I915_READ(dvo_reg);
+
+                intel_dvo->base.connectors_active = false;
+
+                intel_crtc_update_dpms(crtc);
         }
+
+        intel_modeset_check_state(connector->dev);
 }
 
 static int intel_dvo_mode_valid(struct drm_connector *connector,
@@ -275,15 +344,13 @@ static void intel_dvo_destroy(struct drm_connector *connector)
 }
 
 static const struct drm_encoder_helper_funcs intel_dvo_helper_funcs = {
-        .dpms = intel_dvo_dpms,
         .mode_fixup = intel_dvo_mode_fixup,
-        .prepare = intel_encoder_prepare,
         .mode_set = intel_dvo_mode_set,
-        .commit = intel_encoder_commit,
+        .disable = intel_encoder_noop,
 };
 
 static const struct drm_connector_funcs intel_dvo_connector_funcs = {
-        .dpms = drm_helper_connector_dpms,
+        .dpms = intel_dvo_dpms,
         .detect = intel_dvo_detect,
         .destroy = intel_dvo_destroy,
         .fill_modes = drm_helper_probe_single_connector_modes,
@@ -372,6 +439,11 @@ void intel_dvo_init(struct drm_device *dev)
         drm_encoder_init(dev, &intel_encoder->base,
                          &intel_dvo_enc_funcs, encoder_type);
 
+        intel_encoder->disable = intel_disable_dvo;
+        intel_encoder->enable = intel_enable_dvo;
+        intel_encoder->get_hw_state = intel_dvo_get_hw_state;
+        intel_connector->get_hw_state = intel_dvo_connector_get_hw_state;
+
         /* Now, try to find a controller */
         for (i = 0; i < ARRAY_SIZE(intel_dvo_devices); i++) {
                 struct drm_connector *connector = &intel_connector->base;
diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
index 35a6ee7a8cca..5d02aad0de8e 100644
--- a/drivers/gpu/drm/i915/intel_hdmi.c
+++ b/drivers/gpu/drm/i915/intel_hdmi.c
@@ -601,11 +601,32 @@ static void intel_hdmi_mode_set(struct drm_encoder *encoder,
         intel_hdmi->set_infoframes(encoder, adjusted_mode);
 }
 
-static void intel_hdmi_dpms(struct drm_encoder *encoder, int mode)
+static bool intel_hdmi_get_hw_state(struct intel_encoder *encoder,
+                                    enum pipe *pipe)
 {
-        struct drm_device *dev = encoder->dev;
+        struct drm_device *dev = encoder->base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(&encoder->base);
+        u32 tmp;
+
+        tmp = I915_READ(intel_hdmi->sdvox_reg);
+
+        if (!(tmp & SDVO_ENABLE))
+                return false;
+
+        if (HAS_PCH_CPT(dev))
+                *pipe = PORT_TO_PIPE_CPT(tmp);
+        else
+                *pipe = PORT_TO_PIPE(tmp);
+
+        return true;
+}
+
+static void intel_enable_hdmi(struct intel_encoder *encoder)
+{
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(&encoder->base);
         u32 temp;
         u32 enable_bits = SDVO_ENABLE;
 
@@ -617,31 +638,12 @@ static void intel_hdmi_dpms(struct drm_encoder *encoder, int mode)
         /* HW workaround for IBX, we need to move the port to transcoder A
          * before disabling it. */
         if (HAS_PCH_IBX(dev)) {
-                struct drm_crtc *crtc = encoder->crtc;
+                struct drm_crtc *crtc = encoder->base.crtc;
                 int pipe = crtc ? to_intel_crtc(crtc)->pipe : -1;
 
-                if (mode != DRM_MODE_DPMS_ON) {
-                        if (temp & SDVO_PIPE_B_SELECT) {
-                                temp &= ~SDVO_PIPE_B_SELECT;
-                                I915_WRITE(intel_hdmi->sdvox_reg, temp);
-                                POSTING_READ(intel_hdmi->sdvox_reg);
-
-                                /* Again we need to write this twice. */
-                                I915_WRITE(intel_hdmi->sdvox_reg, temp);
-                                POSTING_READ(intel_hdmi->sdvox_reg);
-
-                                /* Transcoder selection bits only update
-                                 * effectively on vblank. */
-                                if (crtc)
-                                        intel_wait_for_vblank(dev, pipe);
-                                else
-                                        msleep(50);
-                        }
-                } else {
-                        /* Restore the transcoder select bit. */
-                        if (pipe == PIPE_B)
-                                enable_bits |= SDVO_PIPE_B_SELECT;
-                }
+                /* Restore the transcoder select bit. */
+                if (pipe == PIPE_B)
+                        enable_bits |= SDVO_PIPE_B_SELECT;
         }
 
         /* HW workaround, need to toggle enable bit off and on for 12bpc, but
@@ -652,11 +654,66 @@ static void intel_hdmi_dpms(struct drm_encoder *encoder, int mode)
                 POSTING_READ(intel_hdmi->sdvox_reg);
         }
 
-        if (mode != DRM_MODE_DPMS_ON) {
-                temp &= ~enable_bits;
-        } else {
-                temp |= enable_bits;
+        temp |= enable_bits;
+
+        I915_WRITE(intel_hdmi->sdvox_reg, temp);
+        POSTING_READ(intel_hdmi->sdvox_reg);
+
+        /* HW workaround, need to write this twice for issue that may result
+         * in first write getting masked.
+         */
+        if (HAS_PCH_SPLIT(dev)) {
+                I915_WRITE(intel_hdmi->sdvox_reg, temp);
+                POSTING_READ(intel_hdmi->sdvox_reg);
         }
+}
+
+static void intel_disable_hdmi(struct intel_encoder *encoder)
+{
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(&encoder->base);
+        u32 temp;
+        u32 enable_bits = SDVO_ENABLE;
+
+        if (intel_hdmi->has_audio)
+                enable_bits |= SDVO_AUDIO_ENABLE;
+
+        temp = I915_READ(intel_hdmi->sdvox_reg);
+
+        /* HW workaround for IBX, we need to move the port to transcoder A
+         * before disabling it. */
+        if (HAS_PCH_IBX(dev)) {
+                struct drm_crtc *crtc = encoder->base.crtc;
+                int pipe = crtc ? to_intel_crtc(crtc)->pipe : -1;
+
+                if (temp & SDVO_PIPE_B_SELECT) {
+                        temp &= ~SDVO_PIPE_B_SELECT;
+                        I915_WRITE(intel_hdmi->sdvox_reg, temp);
+                        POSTING_READ(intel_hdmi->sdvox_reg);
+
+                        /* Again we need to write this twice. */
+                        I915_WRITE(intel_hdmi->sdvox_reg, temp);
+                        POSTING_READ(intel_hdmi->sdvox_reg);
+
+                        /* Transcoder selection bits only update
+                         * effectively on vblank. */
+                        if (crtc)
+                                intel_wait_for_vblank(dev, pipe);
+                        else
+                                msleep(50);
+                }
+        }
+
+        /* HW workaround, need to toggle enable bit off and on for 12bpc, but
+         * we do this anyway which shows more stable in testing.
+         */
+        if (HAS_PCH_SPLIT(dev)) {
+                I915_WRITE(intel_hdmi->sdvox_reg, temp & ~SDVO_ENABLE);
+                POSTING_READ(intel_hdmi->sdvox_reg);
+        }
+
+        temp &= ~enable_bits;
 
         I915_WRITE(intel_hdmi->sdvox_reg, temp);
         POSTING_READ(intel_hdmi->sdvox_reg);
@@ -830,9 +887,8 @@ intel_hdmi_set_property(struct drm_connector *connector,
 done:
         if (intel_hdmi->base.base.crtc) {
                 struct drm_crtc *crtc = intel_hdmi->base.base.crtc;
-                drm_crtc_helper_set_mode(crtc, &crtc->mode,
-                                         crtc->x, crtc->y,
-                                         crtc->fb);
+                intel_set_mode(crtc, &crtc->mode,
+                               crtc->x, crtc->y, crtc->fb);
         }
 
         return 0;
@@ -846,23 +902,19 @@ static void intel_hdmi_destroy(struct drm_connector *connector)
 }
 
 static const struct drm_encoder_helper_funcs intel_hdmi_helper_funcs_hsw = {
-        .dpms = intel_ddi_dpms,
         .mode_fixup = intel_hdmi_mode_fixup,
-        .prepare = intel_encoder_prepare,
         .mode_set = intel_ddi_mode_set,
-        .commit = intel_encoder_commit,
+        .disable = intel_encoder_noop,
 };
 
 static const struct drm_encoder_helper_funcs intel_hdmi_helper_funcs = {
-        .dpms = intel_hdmi_dpms,
         .mode_fixup = intel_hdmi_mode_fixup,
-        .prepare = intel_encoder_prepare,
         .mode_set = intel_hdmi_mode_set,
-        .commit = intel_encoder_commit,
+        .disable = intel_encoder_noop,
 };
 
 static const struct drm_connector_funcs intel_hdmi_connector_funcs = {
-        .dpms = drm_helper_connector_dpms,
+        .dpms = intel_connector_dpms,
         .detect = intel_hdmi_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .set_property = intel_hdmi_set_property,
@@ -961,10 +1013,21 @@ void intel_hdmi_init(struct drm_device *dev, int sdvox_reg, enum port port)
                 intel_hdmi->set_infoframes = cpt_set_infoframes;
         }
 
-        if (IS_HASWELL(dev))
-                drm_encoder_helper_add(&intel_encoder->base, &intel_hdmi_helper_funcs_hsw);
-        else
-                drm_encoder_helper_add(&intel_encoder->base, &intel_hdmi_helper_funcs);
+        if (IS_HASWELL(dev)) {
+                intel_encoder->enable = intel_enable_ddi;
+                intel_encoder->disable = intel_disable_ddi;
+                intel_encoder->get_hw_state = intel_ddi_get_hw_state;
+                drm_encoder_helper_add(&intel_encoder->base,
+                                       &intel_hdmi_helper_funcs_hsw);
+        } else {
+                intel_encoder->enable = intel_enable_hdmi;
+                intel_encoder->disable = intel_disable_hdmi;
+                intel_encoder->get_hw_state = intel_hdmi_get_hw_state;
+                drm_encoder_helper_add(&intel_encoder->base,
+                                       &intel_hdmi_helper_funcs);
+        }
+        intel_connector->get_hw_state = intel_connector_get_hw_state;
+
 
         intel_hdmi_add_properties(intel_hdmi, connector);
 
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index d789fdad5d37..dc9f9ff34d8c 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -65,13 +65,40 @@ static struct intel_lvds *intel_attached_lvds(struct drm_connector *connector)
                             struct intel_lvds, base);
 }
 
+static bool intel_lvds_get_hw_state(struct intel_encoder *encoder,
+                                    enum pipe *pipe)
+{
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 lvds_reg, tmp;
+
+        if (HAS_PCH_SPLIT(dev)) {
+                lvds_reg = PCH_LVDS;
+        } else {
+                lvds_reg = LVDS;
+        }
+
+        tmp = I915_READ(lvds_reg);
+
+        if (!(tmp & LVDS_PORT_EN))
+                return false;
+
+        if (HAS_PCH_CPT(dev))
+                *pipe = PORT_TO_PIPE_CPT(tmp);
+        else
+                *pipe = PORT_TO_PIPE(tmp);
+
+        return true;
+}
+
 /**
  * Sets the power state for the panel.
  */
-static void intel_lvds_enable(struct intel_lvds *intel_lvds)
+static void intel_enable_lvds(struct intel_encoder *encoder)
 {
-        struct drm_device *dev = intel_lvds->base.base.dev;
-        struct intel_crtc *intel_crtc = to_intel_crtc(intel_lvds->base.base.crtc);
+        struct drm_device *dev = encoder->base.dev;
+        struct intel_lvds *intel_lvds = to_intel_lvds(&encoder->base);
+        struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
         struct drm_i915_private *dev_priv = dev->dev_private;
         u32 ctl_reg, lvds_reg, stat_reg;
 
@@ -111,9 +138,10 @@ static void intel_lvds_enable(struct intel_lvds *intel_lvds)
         intel_panel_enable_backlight(dev, intel_crtc->pipe);
 }
 
-static void intel_lvds_disable(struct intel_lvds *intel_lvds)
+static void intel_disable_lvds(struct intel_encoder *encoder)
 {
-        struct drm_device *dev = intel_lvds->base.base.dev;
+        struct drm_device *dev = encoder->base.dev;
+        struct intel_lvds *intel_lvds = to_intel_lvds(&encoder->base);
         struct drm_i915_private *dev_priv = dev->dev_private;
         u32 ctl_reg, lvds_reg, stat_reg;
 
@@ -142,18 +170,6 @@ static void intel_lvds_disable(struct intel_lvds *intel_lvds)
         POSTING_READ(lvds_reg);
 }
 
-static void intel_lvds_dpms(struct drm_encoder *encoder, int mode)
-{
-        struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
-
-        if (mode == DRM_MODE_DPMS_ON)
-                intel_lvds_enable(intel_lvds);
-        else
-                intel_lvds_disable(intel_lvds);
-
-        /* XXX: We never power down the LVDS pairs. */
-}
-
 static int intel_lvds_mode_valid(struct drm_connector *connector,
                                  struct drm_display_mode *mode)
 {
@@ -234,9 +250,8 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
 {
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
         struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
-        struct intel_encoder *tmp_encoder;
+        struct intel_crtc *intel_crtc = intel_lvds->base.new_crtc;
         u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0;
         int pipe;
 
@@ -246,14 +261,8 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
                 return false;
         }
 
-        /* Should never happen!! */
-        for_each_encoder_on_crtc(dev, encoder->crtc, tmp_encoder) {
-                if (&tmp_encoder->base != encoder) {
-                        DRM_ERROR("Can't enable LVDS and another "
-                               "encoder on the same pipe\n");
-                        return false;
-                }
-        }
+        if (intel_encoder_check_is_cloned(&intel_lvds->base))
+                return false;
 
         /*
          * We have timings from the BIOS for the panel, put them in
@@ -405,23 +414,6 @@ out:
         return true;
 }
 
-static void intel_lvds_prepare(struct drm_encoder *encoder)
-{
-        struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
-
-        intel_lvds_disable(intel_lvds);
-}
-
-static void intel_lvds_commit(struct drm_encoder *encoder)
-{
-        struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
-
-        /* Always do a full power on as we do not know what state
-         * we were left in.
-         */
-        intel_lvds_enable(intel_lvds);
-}
-
 static void intel_lvds_mode_set(struct drm_encoder *encoder,
                                 struct drm_display_mode *mode,
                                 struct drm_display_mode *adjusted_mode)
@@ -535,7 +527,7 @@ static int intel_lid_notify(struct notifier_block *nb, unsigned long val,
         dev_priv->modeset_on_lid = 0;
 
         mutex_lock(&dev->mode_config.mutex);
-        drm_helper_resume_force_mode(dev);
+        intel_modeset_check_state(dev);
         mutex_unlock(&dev->mode_config.mutex);
 
         return NOTIFY_OK;
@@ -587,8 +579,8 @@ static int intel_lvds_set_property(struct drm_connector *connector,
                          * If the CRTC is enabled, the display will be changed
                          * according to the new panel fitting mode.
                          */
-                        drm_crtc_helper_set_mode(crtc, &crtc->mode,
-                                crtc->x, crtc->y, crtc->fb);
+                        intel_set_mode(crtc, &crtc->mode,
+                                       crtc->x, crtc->y, crtc->fb);
                 }
         }
 
@@ -596,11 +588,9 @@ static int intel_lvds_set_property(struct drm_connector *connector,
 }
 
 static const struct drm_encoder_helper_funcs intel_lvds_helper_funcs = {
-        .dpms = intel_lvds_dpms,
         .mode_fixup = intel_lvds_mode_fixup,
-        .prepare = intel_lvds_prepare,
         .mode_set = intel_lvds_mode_set,
-        .commit = intel_lvds_commit,
+        .disable = intel_encoder_noop,
 };
 
 static const struct drm_connector_helper_funcs intel_lvds_connector_helper_funcs = {
@@ -610,7 +600,7 @@ static const struct drm_connector_helper_funcs intel_lvds_connector_helper_funcs
 };
 
 static const struct drm_connector_funcs intel_lvds_connector_funcs = {
-        .dpms = drm_helper_connector_dpms,
+        .dpms = intel_connector_dpms,
         .detect = intel_lvds_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .set_property = intel_lvds_set_property,
@@ -964,6 +954,11 @@ bool intel_lvds_init(struct drm_device *dev)
         drm_encoder_init(dev, &intel_encoder->base, &intel_lvds_enc_funcs,
                          DRM_MODE_ENCODER_LVDS);
 
+        intel_encoder->enable = intel_enable_lvds;
+        intel_encoder->disable = intel_disable_lvds;
+        intel_encoder->get_hw_state = intel_lvds_get_hw_state;
+        intel_connector->get_hw_state = intel_connector_get_hw_state;
+
         intel_connector_attach_encoder(intel_connector, intel_encoder);
         intel_encoder->type = INTEL_OUTPUT_LVDS;
 
diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c
index a465debdfcf7..36c64091bc90 100644
--- a/drivers/gpu/drm/i915/intel_pm.c
+++ b/drivers/gpu/drm/i915/intel_pm.c
@@ -31,6 +31,8 @@
 #include "../../../platform/x86/intel_ips.h"
 #include <linux/module.h>
 
+#define FORCEWAKE_ACK_TIMEOUT_MS 2
+
 /* FBC, or Frame Buffer Compression, is a technique employed to compress the
  * framebuffer contents in-memory, aiming at reducing the required bandwidth
  * during in-memory transfers and, therefore, reduce the power packet.
@@ -593,7 +595,7 @@ static void i915_ironlake_get_mem_freq(struct drm_device *dev)
                 break;
         }
 
-        dev_priv->r_t = dev_priv->mem_freq;
+        dev_priv->ips.r_t = dev_priv->mem_freq;
 
         switch (csipll & 0x3ff) {
         case 0x00c:
@@ -625,11 +627,11 @@ static void i915_ironlake_get_mem_freq(struct drm_device *dev)
         }
 
         if (dev_priv->fsb_freq == 3200) {
-                dev_priv->c_m = 0;
+                dev_priv->ips.c_m = 0;
         } else if (dev_priv->fsb_freq > 3200 && dev_priv->fsb_freq <= 4800) {
-                dev_priv->c_m = 1;
+                dev_priv->ips.c_m = 1;
         } else {
-                dev_priv->c_m = 2;
+                dev_priv->ips.c_m = 2;
         }
 }
 
@@ -2162,12 +2164,6 @@ err_unref:
 
 /**
  * Lock protecting IPS related data structures
- *   - i915_mch_dev
- *   - dev_priv->max_delay
- *   - dev_priv->min_delay
- *   - dev_priv->fmax
- *   - dev_priv->gpu_busy
- *   - dev_priv->gfx_power
  */
 DEFINE_SPINLOCK(mchdev_lock);
 
@@ -2230,12 +2226,12 @@ static void ironlake_enable_drps(struct drm_device *dev)
         vstart = (I915_READ(PXVFREQ_BASE + (fstart * 4)) & PXVFREQ_PX_MASK) >>
                 PXVFREQ_PX_SHIFT;
 
-        dev_priv->fmax = fmax; /* IPS callback will increase this */
-        dev_priv->fstart = fstart;
+        dev_priv->ips.fmax = fmax; /* IPS callback will increase this */
+        dev_priv->ips.fstart = fstart;
 
-        dev_priv->max_delay = fstart;
-        dev_priv->min_delay = fmin;
-        dev_priv->cur_delay = fstart;
+        dev_priv->ips.max_delay = fstart;
+        dev_priv->ips.min_delay = fmin;
+        dev_priv->ips.cur_delay = fstart;
 
         DRM_DEBUG_DRIVER("fmax: %d, fmin: %d, fstart: %d\n",
                          fmax, fmin, fstart);
@@ -2258,11 +2254,11 @@ static void ironlake_enable_drps(struct drm_device *dev)
 
         ironlake_set_drps(dev, fstart);
 
-        dev_priv->last_count1 = I915_READ(0x112e4) + I915_READ(0x112e8) +
+        dev_priv->ips.last_count1 = I915_READ(0x112e4) + I915_READ(0x112e8) +
                 I915_READ(0x112e0);
-        dev_priv->last_time1 = jiffies_to_msecs(jiffies);
-        dev_priv->last_count2 = I915_READ(0x112f4);
-        getrawmonotonic(&dev_priv->last_time2);
+        dev_priv->ips.last_time1 = jiffies_to_msecs(jiffies);
+        dev_priv->ips.last_count2 = I915_READ(0x112f4);
+        getrawmonotonic(&dev_priv->ips.last_time2);
 
         spin_unlock_irq(&mchdev_lock);
 }
@@ -2284,7 +2280,7 @@ static void ironlake_disable_drps(struct drm_device *dev)
         I915_WRITE(DEIMR, I915_READ(DEIMR) | DE_PCU_EVENT);
 
         /* Go back to the starting frequency */
-        ironlake_set_drps(dev, dev_priv->fstart);
+        ironlake_set_drps(dev, dev_priv->ips.fstart);
         mdelay(1);
         rgvswctl |= MEMCTL_CMD_STS;
         I915_WRITE(MEMSWCTL, rgvswctl);
@@ -2343,6 +2339,8 @@ void gen6_set_rps(struct drm_device *dev, u8 val)
         I915_WRITE(GEN6_RP_INTERRUPT_LIMITS, limits);
 
         dev_priv->rps.cur_delay = val;
+
+        trace_intel_gpu_freq_change(val * 50);
 }
 
 static void gen6_disable_rps(struct drm_device *dev)
@@ -2741,7 +2739,7 @@ unsigned long i915_chipset_val(struct drm_i915_private *dev_priv)
 
         assert_spin_locked(&mchdev_lock);
 
-        diff1 = now - dev_priv->last_time1;
+        diff1 = now - dev_priv->ips.last_time1;
 
         /* Prevent division-by-zero if we are asking too fast.
          * Also, we don't get interesting results if we are polling
@@ -2749,7 +2747,7 @@ unsigned long i915_chipset_val(struct drm_i915_private *dev_priv)
          * in such cases.
          */
         if (diff1 <= 10)
-                return dev_priv->chipset_power;
+                return dev_priv->ips.chipset_power;
 
         count1 = I915_READ(DMIEC);
         count2 = I915_READ(DDREC);
@@ -2758,16 +2756,16 @@ unsigned long i915_chipset_val(struct drm_i915_private *dev_priv)
         total_count = count1 + count2 + count3;
 
         /* FIXME: handle per-counter overflow */
-        if (total_count < dev_priv->last_count1) {
-                diff = ~0UL - dev_priv->last_count1;
+        if (total_count < dev_priv->ips.last_count1) {
+                diff = ~0UL - dev_priv->ips.last_count1;
                 diff += total_count;
         } else {
-                diff = total_count - dev_priv->last_count1;
+                diff = total_count - dev_priv->ips.last_count1;
         }
 
         for (i = 0; i < ARRAY_SIZE(cparams); i++) {
-                if (cparams[i].i == dev_priv->c_m &&
-                    cparams[i].t == dev_priv->r_t) {
+                if (cparams[i].i == dev_priv->ips.c_m &&
+                    cparams[i].t == dev_priv->ips.r_t) {
                         m = cparams[i].m;
                         c = cparams[i].c;
                         break;
@@ -2778,10 +2776,10 @@ unsigned long i915_chipset_val(struct drm_i915_private *dev_priv)
         ret = ((m * diff) + c);
         ret = div_u64(ret, 10);
 
-        dev_priv->last_count1 = total_count;
-        dev_priv->last_time1 = now;
+        dev_priv->ips.last_count1 = total_count;
+        dev_priv->ips.last_time1 = now;
 
-        dev_priv->chipset_power = ret;
+        dev_priv->ips.chipset_power = ret;
 
         return ret;
 }
@@ -2952,7 +2950,7 @@ static void __i915_update_gfx_val(struct drm_i915_private *dev_priv)
         assert_spin_locked(&mchdev_lock);
 
         getrawmonotonic(&now);
-        diff1 = timespec_sub(now, dev_priv->last_time2);
+        diff1 = timespec_sub(now, dev_priv->ips.last_time2);
 
         /* Don't divide by 0 */
         diffms = diff1.tv_sec * 1000 + diff1.tv_nsec / 1000000;
@@ -2961,20 +2959,20 @@ static void __i915_update_gfx_val(struct drm_i915_private *dev_priv)
 
         count = I915_READ(GFXEC);
 
-        if (count < dev_priv->last_count2) {
-                diff = ~0UL - dev_priv->last_count2;
+        if (count < dev_priv->ips.last_count2) {
+                diff = ~0UL - dev_priv->ips.last_count2;
                 diff += count;
         } else {
-                diff = count - dev_priv->last_count2;
+                diff = count - dev_priv->ips.last_count2;
         }
 
-        dev_priv->last_count2 = count;
-        dev_priv->last_time2 = now;
+        dev_priv->ips.last_count2 = count;
+        dev_priv->ips.last_time2 = now;
 
         /* More magic constants... */
         diff = diff * 1181;
         diff = div_u64(diff, diffms * 10);
-        dev_priv->gfx_power = diff;
+        dev_priv->ips.gfx_power = diff;
 }
 
 void i915_update_gfx_val(struct drm_i915_private *dev_priv)
@@ -3016,14 +3014,14 @@ unsigned long i915_gfx_val(struct drm_i915_private *dev_priv)
 
         corr = corr * ((150142 * state1) / 10000 - 78642);
         corr /= 100000;
-        corr2 = (corr * dev_priv->corr);
+        corr2 = (corr * dev_priv->ips.corr);
 
         state2 = (corr2 * state1) / 10000;
         state2 /= 100; /* convert to mW */
 
         __i915_update_gfx_val(dev_priv);
 
-        return dev_priv->gfx_power + state2;
+        return dev_priv->ips.gfx_power + state2;
 }
 
 /**
@@ -3071,8 +3069,8 @@ bool i915_gpu_raise(void)
         }
         dev_priv = i915_mch_dev;
 
-        if (dev_priv->max_delay > dev_priv->fmax)
-                dev_priv->max_delay--;
+        if (dev_priv->ips.max_delay > dev_priv->ips.fmax)
+                dev_priv->ips.max_delay--;
 
 out_unlock:
         spin_unlock_irq(&mchdev_lock);
@@ -3099,8 +3097,8 @@ bool i915_gpu_lower(void)
         }
         dev_priv = i915_mch_dev;
 
-        if (dev_priv->max_delay < dev_priv->min_delay)
-                dev_priv->max_delay++;
+        if (dev_priv->ips.max_delay < dev_priv->ips.min_delay)
+                dev_priv->ips.max_delay++;
 
 out_unlock:
         spin_unlock_irq(&mchdev_lock);
@@ -3154,9 +3152,9 @@ bool i915_gpu_turbo_disable(void)
         }
         dev_priv = i915_mch_dev;
 
-        dev_priv->max_delay = dev_priv->fstart;
+        dev_priv->ips.max_delay = dev_priv->ips.fstart;
 
-        if (!ironlake_set_drps(dev_priv->dev, dev_priv->fstart))
+        if (!ironlake_set_drps(dev_priv->dev, dev_priv->ips.fstart))
                 ret = false;
 
 out_unlock:
@@ -3271,7 +3269,7 @@ static void intel_init_emon(struct drm_device *dev)
 
         lcfuse = I915_READ(LCFUSE02);
 
-        dev_priv->corr = (lcfuse & LCFUSE_HIV_MASK);
+        dev_priv->ips.corr = (lcfuse & LCFUSE_HIV_MASK);
 }
 
 void intel_disable_gt_powersave(struct drm_device *dev)
@@ -3966,14 +3964,16 @@ static void __gen6_gt_force_wake_get(struct drm_i915_private *dev_priv)
         else
                 forcewake_ack = FORCEWAKE_ACK;
 
-        if (wait_for_atomic_us((I915_READ_NOTRACE(forcewake_ack) & 1) == 0, 500))
-                DRM_ERROR("Force wake wait timed out\n");
+        if (wait_for_atomic((I915_READ_NOTRACE(forcewake_ack) & 1) == 0,
+                            FORCEWAKE_ACK_TIMEOUT_MS))
+                DRM_ERROR("Timed out waiting for forcewake old ack to clear.\n");
 
         I915_WRITE_NOTRACE(FORCEWAKE, 1);
-        POSTING_READ(FORCEWAKE);
+        POSTING_READ(ECOBUS); /* something from same cacheline, but !FORCEWAKE */
 
-        if (wait_for_atomic_us((I915_READ_NOTRACE(forcewake_ack) & 1), 500))
-                DRM_ERROR("Force wake wait timed out\n");
+        if (wait_for_atomic((I915_READ_NOTRACE(forcewake_ack) & 1),
+                            FORCEWAKE_ACK_TIMEOUT_MS))
+                DRM_ERROR("Timed out waiting for forcewake to ack request.\n");
 
         __gen6_gt_wait_for_thread_c0(dev_priv);
 }
@@ -3987,14 +3987,16 @@ static void __gen6_gt_force_wake_mt_get(struct drm_i915_private *dev_priv)
         else
                 forcewake_ack = FORCEWAKE_MT_ACK;
 
-        if (wait_for_atomic_us((I915_READ_NOTRACE(forcewake_ack) & 1) == 0, 500))
-                DRM_ERROR("Force wake wait timed out\n");
+        if (wait_for_atomic((I915_READ_NOTRACE(forcewake_ack) & 1) == 0,
+                            FORCEWAKE_ACK_TIMEOUT_MS))
+                DRM_ERROR("Timed out waiting for forcewake old ack to clear.\n");
 
         I915_WRITE_NOTRACE(FORCEWAKE_MT, _MASKED_BIT_ENABLE(1));
-        POSTING_READ(FORCEWAKE_MT);
+        POSTING_READ(ECOBUS); /* something from same cacheline, but !FORCEWAKE */
 
-        if (wait_for_atomic_us((I915_READ_NOTRACE(forcewake_ack) & 1), 500))
-                DRM_ERROR("Force wake wait timed out\n");
+        if (wait_for_atomic((I915_READ_NOTRACE(forcewake_ack) & 1),
+                            FORCEWAKE_ACK_TIMEOUT_MS))
+                DRM_ERROR("Timed out waiting for forcewake to ack request.\n");
 
         __gen6_gt_wait_for_thread_c0(dev_priv);
 }
@@ -4027,14 +4029,14 @@ void gen6_gt_check_fifodbg(struct drm_i915_private *dev_priv)
 static void __gen6_gt_force_wake_put(struct drm_i915_private *dev_priv)
 {
         I915_WRITE_NOTRACE(FORCEWAKE, 0);
-        POSTING_READ(FORCEWAKE);
+        /* gen6_gt_check_fifodbg doubles as the POSTING_READ */
         gen6_gt_check_fifodbg(dev_priv);
 }
 
 static void __gen6_gt_force_wake_mt_put(struct drm_i915_private *dev_priv)
 {
         I915_WRITE_NOTRACE(FORCEWAKE_MT, _MASKED_BIT_DISABLE(1));
-        POSTING_READ(FORCEWAKE_MT);
+        /* gen6_gt_check_fifodbg doubles as the POSTING_READ */
         gen6_gt_check_fifodbg(dev_priv);
 }
 
@@ -4073,24 +4075,24 @@ int __gen6_gt_wait_for_fifo(struct drm_i915_private *dev_priv)
 
 static void vlv_force_wake_get(struct drm_i915_private *dev_priv)
 {
-        /* Already awake? */
-        if ((I915_READ(0x130094) & 0xa1) == 0xa1)
-                return;
+        if (wait_for_atomic((I915_READ_NOTRACE(FORCEWAKE_ACK_VLV) & 1) == 0,
+                            FORCEWAKE_ACK_TIMEOUT_MS))
+                DRM_ERROR("Timed out waiting for forcewake old ack to clear.\n");
 
-        I915_WRITE_NOTRACE(FORCEWAKE_VLV, 0xffffffff);
-        POSTING_READ(FORCEWAKE_VLV);
+        I915_WRITE_NOTRACE(FORCEWAKE_VLV, _MASKED_BIT_ENABLE(1));
 
-        if (wait_for_atomic_us((I915_READ_NOTRACE(FORCEWAKE_ACK_VLV) & 1), 500))
-                DRM_ERROR("Force wake wait timed out\n");
+        if (wait_for_atomic((I915_READ_NOTRACE(FORCEWAKE_ACK_VLV) & 1),
+                            FORCEWAKE_ACK_TIMEOUT_MS))
+                DRM_ERROR("Timed out waiting for forcewake to ack request.\n");
 
         __gen6_gt_wait_for_thread_c0(dev_priv);
 }
 
 static void vlv_force_wake_put(struct drm_i915_private *dev_priv)
 {
-        I915_WRITE_NOTRACE(FORCEWAKE_VLV, 0xffff0000);
-        /* FIXME: confirm VLV behavior with Punit folks */
-        POSTING_READ(FORCEWAKE_VLV);
+        I915_WRITE_NOTRACE(FORCEWAKE_VLV, _MASKED_BIT_DISABLE(1));
+        /* The below doubles as a POSTING_READ */
+        gen6_gt_check_fifodbg(dev_priv);
 }
 
 void intel_gt_init(struct drm_device *dev)
diff --git a/drivers/gpu/drm/i915/intel_ringbuffer.c b/drivers/gpu/drm/i915/intel_ringbuffer.c
index ac93643731aa..55cdb4d30a16 100644
--- a/drivers/gpu/drm/i915/intel_ringbuffer.c
+++ b/drivers/gpu/drm/i915/intel_ringbuffer.c
@@ -218,6 +218,11 @@ gen6_render_ring_flush(struct intel_ring_buffer *ring,
         u32 scratch_addr = pc->gtt_offset + 128;
         int ret;
 
+        /* Force SNB workarounds for PIPE_CONTROL flushes */
+        ret = intel_emit_post_sync_nonzero_flush(ring);
+        if (ret)
+                return ret;
+
         /* Just flush everything.  Experiments have shown that reducing the
          * number of bits based on the write domains has little performance
          * impact.
@@ -258,17 +263,80 @@ gen6_render_ring_flush(struct intel_ring_buffer *ring,
 }
 
 static int
-gen6_render_ring_flush__wa(struct intel_ring_buffer *ring,
-                           u32 invalidate_domains, u32 flush_domains)
+gen7_render_ring_cs_stall_wa(struct intel_ring_buffer *ring)
 {
         int ret;
 
-        /* Force SNB workarounds for PIPE_CONTROL flushes */
-        ret = intel_emit_post_sync_nonzero_flush(ring);
+        ret = intel_ring_begin(ring, 4);
         if (ret)
                 return ret;
 
-        return gen6_render_ring_flush(ring, invalidate_domains, flush_domains);
+        intel_ring_emit(ring, GFX_OP_PIPE_CONTROL(4));
+        intel_ring_emit(ring, PIPE_CONTROL_CS_STALL |
+                              PIPE_CONTROL_STALL_AT_SCOREBOARD);
+        intel_ring_emit(ring, 0);
+        intel_ring_emit(ring, 0);
+        intel_ring_advance(ring);
+
+        return 0;
+}
+
+static int
+gen7_render_ring_flush(struct intel_ring_buffer *ring,
+                       u32 invalidate_domains, u32 flush_domains)
+{
+        u32 flags = 0;
+        struct pipe_control *pc = ring->private;
+        u32 scratch_addr = pc->gtt_offset + 128;
+        int ret;
+
+        /*
+         * Ensure that any following seqno writes only happen when the render
+         * cache is indeed flushed.
+         *
+         * Workaround: 4th PIPE_CONTROL command (except the ones with only
+         * read-cache invalidate bits set) must have the CS_STALL bit set. We
+         * don't try to be clever and just set it unconditionally.
+         */
+        flags |= PIPE_CONTROL_CS_STALL;
+
+        /* Just flush everything.  Experiments have shown that reducing the
+         * number of bits based on the write domains has little performance
+         * impact.
+         */
+        if (flush_domains) {
+                flags |= PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH;
+                flags |= PIPE_CONTROL_DEPTH_CACHE_FLUSH;
+        }
+        if (invalidate_domains) {
+                flags |= PIPE_CONTROL_TLB_INVALIDATE;
+                flags |= PIPE_CONTROL_INSTRUCTION_CACHE_INVALIDATE;
+                flags |= PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE;
+                flags |= PIPE_CONTROL_VF_CACHE_INVALIDATE;
+                flags |= PIPE_CONTROL_CONST_CACHE_INVALIDATE;
+                flags |= PIPE_CONTROL_STATE_CACHE_INVALIDATE;
+                /*
+                 * TLB invalidate requires a post-sync write.
+                 */
+                flags |= PIPE_CONTROL_QW_WRITE;
+
+                /* Workaround: we must issue a pipe_control with CS-stall bit
+                 * set before a pipe_control command that has the state cache
+                 * invalidate bit set. */
+                gen7_render_ring_cs_stall_wa(ring);
+        }
+
+        ret = intel_ring_begin(ring, 4);
+        if (ret)
+                return ret;
+
+        intel_ring_emit(ring, GFX_OP_PIPE_CONTROL(4));
+        intel_ring_emit(ring, flags);
+        intel_ring_emit(ring, scratch_addr | PIPE_CONTROL_GLOBAL_GTT);
+        intel_ring_emit(ring, 0);
+        intel_ring_advance(ring);
+
+        return 0;
 }
 
 static void ring_write_tail(struct intel_ring_buffer *ring,
@@ -1385,9 +1453,9 @@ int intel_init_render_ring_buffer(struct drm_device *dev)
 
         if (INTEL_INFO(dev)->gen >= 6) {
                 ring->add_request = gen6_add_request;
-                ring->flush = gen6_render_ring_flush;
+                ring->flush = gen7_render_ring_flush;
                 if (INTEL_INFO(dev)->gen == 6)
-                        ring->flush = gen6_render_ring_flush__wa;
+                        ring->flush = gen6_render_ring_flush;
                 ring->irq_get = gen6_ring_get_irq;
                 ring->irq_put = gen6_ring_put_irq;
                 ring->irq_enable_mask = GT_USER_INTERRUPT;
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index 434b1d1d3c84..39c319827f91 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -97,7 +97,7 @@ struct intel_sdvo {
         /*
          * Hotplug activation bits for this device
          */
-        uint8_t hotplug_active[2];
+        uint16_t hotplug_active;
 
         /**
          * This is used to select the color range of RBG outputs in HDMI mode.
@@ -628,6 +628,14 @@ static bool intel_sdvo_set_active_outputs(struct intel_sdvo *intel_sdvo,
                                     &outputs, sizeof(outputs));
 }
 
+static bool intel_sdvo_get_active_outputs(struct intel_sdvo *intel_sdvo,
+                                          u16 *outputs)
+{
+        return intel_sdvo_get_value(intel_sdvo,
+                                    SDVO_CMD_GET_ACTIVE_OUTPUTS,
+                                    outputs, sizeof(*outputs));
+}
+
 static bool intel_sdvo_set_encoder_power_state(struct intel_sdvo *intel_sdvo,
                                                int mode)
 {
@@ -1142,51 +1150,132 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
         intel_sdvo_write_sdvox(intel_sdvo, sdvox);
 }
 
-static void intel_sdvo_dpms(struct drm_encoder *encoder, int mode)
+static bool intel_sdvo_connector_get_hw_state(struct intel_connector *connector)
 {
-        struct drm_device *dev = encoder->dev;
+        struct intel_sdvo_connector *intel_sdvo_connector =
+                to_intel_sdvo_connector(&connector->base);
+        struct intel_sdvo *intel_sdvo = intel_attached_sdvo(&connector->base);
+        u16 active_outputs;
+
+        intel_sdvo_get_active_outputs(intel_sdvo, &active_outputs);
+
+        if (active_outputs & intel_sdvo_connector->output_flag)
+                return true;
+        else
+                return false;
+}
+
+static bool intel_sdvo_get_hw_state(struct intel_encoder *encoder,
+                                    enum pipe *pipe)
+{
+        struct drm_device *dev = encoder->base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_sdvo *intel_sdvo = to_intel_sdvo(encoder);
-        struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
+        struct intel_sdvo *intel_sdvo = to_intel_sdvo(&encoder->base);
+        u32 tmp;
+
+        tmp = I915_READ(intel_sdvo->sdvo_reg);
+
+        if (!(tmp & SDVO_ENABLE))
+                return false;
+
+        if (HAS_PCH_CPT(dev))
+                *pipe = PORT_TO_PIPE_CPT(tmp);
+        else
+                *pipe = PORT_TO_PIPE(tmp);
+
+        return true;
+}
+
+static void intel_disable_sdvo(struct intel_encoder *encoder)
+{
+        struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
+        struct intel_sdvo *intel_sdvo = to_intel_sdvo(&encoder->base);
+        u32 temp;
+
+        intel_sdvo_set_active_outputs(intel_sdvo, 0);
+        if (0)
+                intel_sdvo_set_encoder_power_state(intel_sdvo,
+                                                   DRM_MODE_DPMS_OFF);
+
+        temp = I915_READ(intel_sdvo->sdvo_reg);
+        if ((temp & SDVO_ENABLE) != 0) {
+                intel_sdvo_write_sdvox(intel_sdvo, temp & ~SDVO_ENABLE);
+        }
+}
+
+static void intel_enable_sdvo(struct intel_encoder *encoder)
+{
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_sdvo *intel_sdvo = to_intel_sdvo(&encoder->base);
+        struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
         u32 temp;
+        bool input1, input2;
+        int i;
+        u8 status;
+
+        temp = I915_READ(intel_sdvo->sdvo_reg);
+        if ((temp & SDVO_ENABLE) == 0)
+                intel_sdvo_write_sdvox(intel_sdvo, temp | SDVO_ENABLE);
+        for (i = 0; i < 2; i++)
+                intel_wait_for_vblank(dev, intel_crtc->pipe);
+
+        status = intel_sdvo_get_trained_inputs(intel_sdvo, &input1, &input2);
+        /* Warn if the device reported failure to sync.
+         * A lot of SDVO devices fail to notify of sync, but it's
+         * a given it the status is a success, we succeeded.
+         */
+        if (status == SDVO_CMD_STATUS_SUCCESS && !input1) {
+                DRM_DEBUG_KMS("First %s output reported failure to "
+                                "sync\n", SDVO_NAME(intel_sdvo));
+        }
+
+        if (0)
+                intel_sdvo_set_encoder_power_state(intel_sdvo,
+                                                   DRM_MODE_DPMS_ON);
+        intel_sdvo_set_active_outputs(intel_sdvo, intel_sdvo->attached_output);
+}
+
+static void intel_sdvo_dpms(struct drm_connector *connector, int mode)
+{
+        struct drm_crtc *crtc;
+        struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
+
+        /* dvo supports only 2 dpms states. */
+        if (mode != DRM_MODE_DPMS_ON)
+                mode = DRM_MODE_DPMS_OFF;
+
+        if (mode == connector->dpms)
+                return;
+
+        connector->dpms = mode;
+
+        /* Only need to change hw state when actually enabled */
+        crtc = intel_sdvo->base.base.crtc;
+        if (!crtc) {
+                intel_sdvo->base.connectors_active = false;
+                return;
+        }
 
         if (mode != DRM_MODE_DPMS_ON) {
                 intel_sdvo_set_active_outputs(intel_sdvo, 0);
                 if (0)
                         intel_sdvo_set_encoder_power_state(intel_sdvo, mode);
 
-                if (mode == DRM_MODE_DPMS_OFF) {
-                        temp = I915_READ(intel_sdvo->sdvo_reg);
-                        if ((temp & SDVO_ENABLE) != 0) {
-                                intel_sdvo_write_sdvox(intel_sdvo, temp & ~SDVO_ENABLE);
-                        }
-                }
+                intel_sdvo->base.connectors_active = false;
+
+                intel_crtc_update_dpms(crtc);
         } else {
-                bool input1, input2;
-                int i;
-                u8 status;
-
-                temp = I915_READ(intel_sdvo->sdvo_reg);
-                if ((temp & SDVO_ENABLE) == 0)
-                        intel_sdvo_write_sdvox(intel_sdvo, temp | SDVO_ENABLE);
-                for (i = 0; i < 2; i++)
-                        intel_wait_for_vblank(dev, intel_crtc->pipe);
-
-                status = intel_sdvo_get_trained_inputs(intel_sdvo, &input1, &input2);
-                /* Warn if the device reported failure to sync.
-                 * A lot of SDVO devices fail to notify of sync, but it's
-                 * a given it the status is a success, we succeeded.
-                 */
-                if (status == SDVO_CMD_STATUS_SUCCESS && !input1) {
-                        DRM_DEBUG_KMS("First %s output reported failure to "
-                                        "sync\n", SDVO_NAME(intel_sdvo));
-                }
+                intel_sdvo->base.connectors_active = true;
+
+                intel_crtc_update_dpms(crtc);
 
                 if (0)
                         intel_sdvo_set_encoder_power_state(intel_sdvo, mode);
                 intel_sdvo_set_active_outputs(intel_sdvo, intel_sdvo->attached_output);
         }
-        return;
+
+        intel_modeset_check_state(connector->dev);
 }
 
 static int intel_sdvo_mode_valid(struct drm_connector *connector,
@@ -1251,25 +1340,29 @@ static bool intel_sdvo_get_capabilities(struct intel_sdvo *intel_sdvo, struct in
         return true;
 }
 
-static int intel_sdvo_supports_hotplug(struct intel_sdvo *intel_sdvo)
+static uint16_t intel_sdvo_get_hotplug_support(struct intel_sdvo *intel_sdvo)
 {
         struct drm_device *dev = intel_sdvo->base.base.dev;
-        u8 response[2];
+        uint16_t hotplug;
 
         /* HW Erratum: SDVO Hotplug is broken on all i945G chips, there's noise
          * on the line. */
         if (IS_I945G(dev) || IS_I945GM(dev))
-                return false;
+                return 0;
+
+        if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT,
+                                        &hotplug, sizeof(hotplug)))
+                return 0;
 
-        return intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT,
-                                    &response, 2) && response[0];
+        return hotplug;
 }
 
 static void intel_sdvo_enable_hotplug(struct intel_encoder *encoder)
 {
         struct intel_sdvo *intel_sdvo = to_intel_sdvo(&encoder->base);
 
-        intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &intel_sdvo->hotplug_active, 2);
+        intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_ACTIVE_HOT_PLUG,
+                        &intel_sdvo->hotplug_active, 2);
 }
 
 static bool
@@ -1834,8 +1927,8 @@ set_value:
 done:
         if (intel_sdvo->base.base.crtc) {
                 struct drm_crtc *crtc = intel_sdvo->base.base.crtc;
-                drm_crtc_helper_set_mode(crtc, &crtc->mode, crtc->x,
-                                         crtc->y, crtc->fb);
+                intel_set_mode(crtc, &crtc->mode,
+                               crtc->x, crtc->y, crtc->fb);
         }
 
         return 0;
@@ -1843,15 +1936,13 @@ done:
 }
 
 static const struct drm_encoder_helper_funcs intel_sdvo_helper_funcs = {
-        .dpms = intel_sdvo_dpms,
         .mode_fixup = intel_sdvo_mode_fixup,
-        .prepare = intel_encoder_prepare,
         .mode_set = intel_sdvo_mode_set,
-        .commit = intel_encoder_commit,
+        .disable = intel_encoder_noop,
 };
 
 static const struct drm_connector_funcs intel_sdvo_connector_funcs = {
-        .dpms = drm_helper_connector_dpms,
+        .dpms = intel_sdvo_dpms,
         .detect = intel_sdvo_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .set_property = intel_sdvo_set_property,
@@ -2023,6 +2114,7 @@ intel_sdvo_connector_init(struct intel_sdvo_connector *connector,
         connector->base.base.interlace_allowed = 1;
         connector->base.base.doublescan_allowed = 0;
         connector->base.base.display_info.subpixel_order = SubPixelHorizontalRGB;
+        connector->base.get_hw_state = intel_sdvo_connector_get_hw_state;
 
         intel_connector_attach_encoder(&connector->base, &encoder->base);
         drm_sysfs_connector_add(&connector->base.base);
@@ -2061,17 +2153,18 @@ intel_sdvo_dvi_init(struct intel_sdvo *intel_sdvo, int device)
 
         intel_connector = &intel_sdvo_connector->base;
         connector = &intel_connector->base;
-        if (intel_sdvo_supports_hotplug(intel_sdvo) & (1 << device)) {
+        if (intel_sdvo_get_hotplug_support(intel_sdvo) &
+                intel_sdvo_connector->output_flag) {
                 connector->polled = DRM_CONNECTOR_POLL_HPD;
-                intel_sdvo->hotplug_active[0] |= 1 << device;
+                intel_sdvo->hotplug_active |= intel_sdvo_connector->output_flag;
                 /* Some SDVO devices have one-shot hotplug interrupts.
                  * Ensure that they get re-enabled when an interrupt happens.
                  */
                 intel_encoder->hot_plug = intel_sdvo_enable_hotplug;
                 intel_sdvo_enable_hotplug(intel_encoder);
-        }
-        else
+        } else {
                 connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT;
+        }
         encoder->encoder_type = DRM_MODE_ENCODER_TMDS;
         connector->connector_type = DRM_MODE_CONNECTOR_DVID;
 
@@ -2570,22 +2663,17 @@ bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg, bool is_sdvob)
                 hotplug_mask = intel_sdvo->is_sdvob ?
                         SDVOB_HOTPLUG_INT_STATUS_I915 : SDVOC_HOTPLUG_INT_STATUS_I915;
         }
-        dev_priv->hotplug_supported_mask |= hotplug_mask;
 
         drm_encoder_helper_add(&intel_encoder->base, &intel_sdvo_helper_funcs);
 
+        intel_encoder->disable = intel_disable_sdvo;
+        intel_encoder->enable = intel_enable_sdvo;
+        intel_encoder->get_hw_state = intel_sdvo_get_hw_state;
+
         /* In default case sdvo lvds is false */
         if (!intel_sdvo_get_capabilities(intel_sdvo, &intel_sdvo->caps))
                 goto err;
 
-        /* Set up hotplug command - note paranoia about contents of reply.
-         * We assume that the hardware is in a sane state, and only touch
-         * the bits we think we understand.
-         */
-        intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_ACTIVE_HOT_PLUG,
-                             &intel_sdvo->hotplug_active, 2);
-        intel_sdvo->hotplug_active[0] &= ~0x3;
-
         if (intel_sdvo_output_setup(intel_sdvo,
                                     intel_sdvo->caps.output_flags) != true) {
                 DRM_DEBUG_KMS("SDVO output failed to setup on %s\n",
@@ -2593,6 +2681,12 @@ bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg, bool is_sdvob)
                 goto err;
         }
 
+        /* Only enable the hotplug irq if we need it, to work around noisy
+         * hotplug lines.
+         */
+        if (intel_sdvo->hotplug_active)
+                dev_priv->hotplug_supported_mask |= hotplug_mask;
+
         intel_sdvo_select_ddc_bus(dev_priv, intel_sdvo, sdvo_reg);
 
         /* Set the input timing to the screen. Assume always input 0. */
diff --git a/drivers/gpu/drm/i915/intel_tv.c b/drivers/gpu/drm/i915/intel_tv.c
index 95653a508987..d2c5c8f3baf3 100644
--- a/drivers/gpu/drm/i915/intel_tv.c
+++ b/drivers/gpu/drm/i915/intel_tv.c
@@ -836,22 +836,37 @@ static struct intel_tv *intel_attached_tv(struct drm_connector *connector)
                             base);
 }
 
+static bool
+intel_tv_get_hw_state(struct intel_encoder *encoder, enum pipe *pipe)
+{
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 tmp = I915_READ(TV_CTL);
+
+        if (!(tmp & TV_ENC_ENABLE))
+                return false;
+
+        *pipe = PORT_TO_PIPE(tmp);
+
+        return true;
+}
+
 static void
-intel_tv_dpms(struct drm_encoder *encoder, int mode)
+intel_enable_tv(struct intel_encoder *encoder)
 {
-        struct drm_device *dev = encoder->dev;
+        struct drm_device *dev = encoder->base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
 
-        switch (mode) {
-        case DRM_MODE_DPMS_ON:
-                I915_WRITE(TV_CTL, I915_READ(TV_CTL) | TV_ENC_ENABLE);
-                break;
-        case DRM_MODE_DPMS_STANDBY:
-        case DRM_MODE_DPMS_SUSPEND:
-        case DRM_MODE_DPMS_OFF:
-                I915_WRITE(TV_CTL, I915_READ(TV_CTL) & ~TV_ENC_ENABLE);
-                break;
-        }
+        I915_WRITE(TV_CTL, I915_READ(TV_CTL) | TV_ENC_ENABLE);
+}
+
+static void
+intel_disable_tv(struct intel_encoder *encoder)
+{
+        struct drm_device *dev = encoder->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
+        I915_WRITE(TV_CTL, I915_READ(TV_CTL) & ~TV_ENC_ENABLE);
 }
 
 static const struct tv_mode *
@@ -895,17 +910,14 @@ intel_tv_mode_fixup(struct drm_encoder *encoder,
                     const struct drm_display_mode *mode,
                     struct drm_display_mode *adjusted_mode)
 {
-        struct drm_device *dev = encoder->dev;
         struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
         const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
-        struct intel_encoder *other_encoder;
 
         if (!tv_mode)
                 return false;
 
-        for_each_encoder_on_crtc(dev, encoder->crtc, other_encoder)
-                if (&other_encoder->base != encoder)
-                        return false;
+        if (intel_encoder_check_is_cloned(&intel_tv->base))
+                return false;
 
         adjusted_mode->clock = tv_mode->clock;
         return true;
@@ -1471,22 +1483,20 @@ intel_tv_set_property(struct drm_connector *connector, struct drm_property *prop
         }
 
         if (changed && crtc)
-                drm_crtc_helper_set_mode(crtc, &crtc->mode, crtc->x,
-                                crtc->y, crtc->fb);
+                intel_set_mode(crtc, &crtc->mode,
+                               crtc->x, crtc->y, crtc->fb);
 out:
         return ret;
 }
 
 static const struct drm_encoder_helper_funcs intel_tv_helper_funcs = {
-        .dpms = intel_tv_dpms,
         .mode_fixup = intel_tv_mode_fixup,
-        .prepare = intel_encoder_prepare,
         .mode_set = intel_tv_mode_set,
-        .commit = intel_encoder_commit,
+        .disable = intel_encoder_noop,
 };
 
 static const struct drm_connector_funcs intel_tv_connector_funcs = {
-        .dpms = drm_helper_connector_dpms,
+        .dpms = intel_connector_dpms,
         .detect = intel_tv_detect,
         .destroy = intel_tv_destroy,
         .set_property = intel_tv_set_property,
@@ -1616,6 +1626,11 @@ intel_tv_init(struct drm_device *dev)
         drm_encoder_init(dev, &intel_encoder->base, &intel_tv_enc_funcs,
                          DRM_MODE_ENCODER_TVDAC);
 
+        intel_encoder->enable = intel_enable_tv;
+        intel_encoder->disable = intel_disable_tv;
+        intel_encoder->get_hw_state = intel_tv_get_hw_state;
+        intel_connector->get_hw_state = intel_connector_get_hw_state;
+
         intel_connector_attach_encoder(intel_connector, intel_encoder);
         intel_encoder->type = INTEL_OUTPUT_TVOUT;
         intel_encoder->crtc_mask = (1 << 0) | (1 << 1);