1 files changed, 152 insertions, 58 deletions

diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index d251d9d7a06c..0007a4d9bf6e 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -96,7 +96,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.
@@ -627,6 +627,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)
 {
@@ -1141,51 +1149,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,
@@ -1250,25 +1339,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;
 
-        return intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT,
-                                    &response, 2) && response[0];
+        if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT,
+                                        &hotplug, sizeof(hotplug)))
+                return 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
@@ -1344,7 +1437,6 @@ intel_sdvo_tmds_sink_detect(struct drm_connector *connector)
                         }
                 } else
                         status = connector_status_disconnected;
-                connector->display_info.raw_edid = NULL;
                 kfree(edid);
         }
 
@@ -1418,7 +1510,6 @@ intel_sdvo_detect(struct drm_connector *connector, bool force)
                         else
                                 ret = connector_status_disconnected;
 
-                        connector->display_info.raw_edid = NULL;
                         kfree(edid);
                 } else
                         ret = connector_status_connected;
@@ -1464,7 +1555,6 @@ static void intel_sdvo_get_ddc_modes(struct drm_connector *connector)
                         drm_add_edid_modes(connector, edid);
                 }
 
-                connector->display_info.raw_edid = NULL;
                 kfree(edid);
         }
 }
@@ -1836,8 +1926,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;
@@ -1845,15 +1935,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,
@@ -2025,6 +2113,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);
@@ -2063,17 +2152,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;
 
@@ -2081,8 +2171,7 @@ intel_sdvo_dvi_init(struct intel_sdvo *intel_sdvo, int device)
                 connector->connector_type = DRM_MODE_CONNECTOR_HDMIA;
                 intel_sdvo->is_hdmi = true;
         }
-        intel_sdvo->base.clone_mask = ((1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
-                                       (1 << INTEL_ANALOG_CLONE_BIT));
+        intel_sdvo->base.cloneable = true;
 
         intel_sdvo_connector_init(intel_sdvo_connector, intel_sdvo);
         if (intel_sdvo->is_hdmi)
@@ -2113,7 +2202,7 @@ intel_sdvo_tv_init(struct intel_sdvo *intel_sdvo, int type)
 
         intel_sdvo->is_tv = true;
         intel_sdvo->base.needs_tv_clock = true;
-        intel_sdvo->base.clone_mask = 1 << INTEL_SDVO_TV_CLONE_BIT;
+        intel_sdvo->base.cloneable = false;
 
         intel_sdvo_connector_init(intel_sdvo_connector, intel_sdvo);
 
@@ -2156,8 +2245,7 @@ intel_sdvo_analog_init(struct intel_sdvo *intel_sdvo, int device)
                 intel_sdvo_connector->output_flag = SDVO_OUTPUT_RGB1;
         }
 
-        intel_sdvo->base.clone_mask = ((1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
-                                       (1 << INTEL_ANALOG_CLONE_BIT));
+        intel_sdvo->base.cloneable = true;
 
         intel_sdvo_connector_init(intel_sdvo_connector,
                                   intel_sdvo);
@@ -2189,8 +2277,10 @@ intel_sdvo_lvds_init(struct intel_sdvo *intel_sdvo, int device)
                 intel_sdvo_connector->output_flag = SDVO_OUTPUT_LVDS1;
         }
 
-        intel_sdvo->base.clone_mask = ((1 << INTEL_ANALOG_CLONE_BIT) |
-                                       (1 << INTEL_SDVO_LVDS_CLONE_BIT));
+        /* SDVO LVDS is cloneable because the SDVO encoder does the upscaling,
+         * as opposed to native LVDS, where we upscale with the panel-fitter
+         * (and hence only the native LVDS resolution could be cloned). */
+        intel_sdvo->base.cloneable = true;
 
         intel_sdvo_connector_init(intel_sdvo_connector, intel_sdvo);
         if (!intel_sdvo_create_enhance_property(intel_sdvo, intel_sdvo_connector))
@@ -2575,6 +2665,10 @@ bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg, bool is_sdvob)
 
         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;
@@ -2589,7 +2683,7 @@ bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg, bool is_sdvob)
         /* Only enable the hotplug irq if we need it, to work around noisy
          * hotplug lines.
          */
-        if (intel_sdvo->hotplug_active[0])
+        if (intel_sdvo->hotplug_active)
                 dev_priv->hotplug_supported_mask |= hotplug_mask;
 
         intel_sdvo_select_ddc_bus(dev_priv, intel_sdvo, sdvo_reg);