1 files changed, 168 insertions, 139 deletions

diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index 197d4f32585a..0979d8877880 100644
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
@@ -30,10 +30,30 @@
 #include "drm.h"
 #include "drm_crtc.h"
 #include "drm_crtc_helper.h"
+#include "drm_edid.h"
 #include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
 
+/* Here's the desired hotplug mode */
+#define ADPA_HOTPLUG_BITS (ADPA_CRT_HOTPLUG_PERIOD_128 |                \
+                           ADPA_CRT_HOTPLUG_WARMUP_10MS |               \
+                           ADPA_CRT_HOTPLUG_SAMPLE_4S |                 \
+                           ADPA_CRT_HOTPLUG_VOLTAGE_50 |                \
+                           ADPA_CRT_HOTPLUG_VOLREF_325MV |              \
+                           ADPA_CRT_HOTPLUG_ENABLE)
+
+struct intel_crt {
+        struct intel_encoder base;
+        bool force_hotplug_required;
+};
+
+static struct intel_crt *intel_attached_crt(struct drm_connector *connector)
+{
+        return container_of(intel_attached_encoder(connector),
+                            struct intel_crt, base);
+}
+
 static void intel_crt_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
@@ -79,7 +99,7 @@ static int intel_crt_mode_valid(struct drm_connector *connector,
         if (mode->clock < 25000)
                 return MODE_CLOCK_LOW;
 
-        if (!IS_I9XX(dev))
+        if (IS_GEN2(dev))
                 max_clock = 350000;
         else
                 max_clock = 400000;
@@ -109,10 +129,7 @@ static void intel_crt_mode_set(struct drm_encoder *encoder,
         u32 adpa, dpll_md;
         u32 adpa_reg;
 
-        if (intel_crtc->pipe == 0)
-                dpll_md_reg = DPLL_A_MD;
-        else
-                dpll_md_reg = DPLL_B_MD;
+        dpll_md_reg = DPLL_MD(intel_crtc->pipe);
 
         if (HAS_PCH_SPLIT(dev))
                 adpa_reg = PCH_ADPA;
@@ -123,13 +140,13 @@ static void intel_crt_mode_set(struct drm_encoder *encoder,
          * Disable separate mode multiplier used when cloning SDVO to CRT
          * XXX this needs to be adjusted when we really are cloning
          */
-        if (IS_I965G(dev) && !HAS_PCH_SPLIT(dev)) {
+        if (INTEL_INFO(dev)->gen >= 4 && !HAS_PCH_SPLIT(dev)) {
                 dpll_md = I915_READ(dpll_md_reg);
                 I915_WRITE(dpll_md_reg,
                            dpll_md & ~DPLL_MD_UDI_MULTIPLIER_MASK);
         }
 
-        adpa = 0;
+        adpa = ADPA_HOTPLUG_BITS;
         if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
                 adpa |= ADPA_HSYNC_ACTIVE_HIGH;
         if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
@@ -140,69 +157,60 @@ static void intel_crt_mode_set(struct drm_encoder *encoder,
                         adpa |= PORT_TRANS_A_SEL_CPT;
                 else
                         adpa |= ADPA_PIPE_A_SELECT;
-                if (!HAS_PCH_SPLIT(dev))
-                        I915_WRITE(BCLRPAT_A, 0);
         } else {
                 if (HAS_PCH_CPT(dev))
                         adpa |= PORT_TRANS_B_SEL_CPT;
                 else
                         adpa |= ADPA_PIPE_B_SELECT;
-                if (!HAS_PCH_SPLIT(dev))
-                        I915_WRITE(BCLRPAT_B, 0);
         }
 
+        if (!HAS_PCH_SPLIT(dev))
+                I915_WRITE(BCLRPAT(intel_crtc->pipe), 0);
+
         I915_WRITE(adpa_reg, adpa);
 }
 
 static bool intel_ironlake_crt_detect_hotplug(struct drm_connector *connector)
 {
         struct drm_device *dev = connector->dev;
+        struct intel_crt *crt = intel_attached_crt(connector);
         struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 adpa, temp;
+        u32 adpa;
         bool ret;
-        bool turn_off_dac = false;
 
-        temp = adpa = I915_READ(PCH_ADPA);
+        /* The first time through, trigger an explicit detection cycle */
+        if (crt->force_hotplug_required) {
+                bool turn_off_dac = HAS_PCH_SPLIT(dev);
+                u32 save_adpa;
 
-        if (HAS_PCH_SPLIT(dev))
-                turn_off_dac = true;
-
-        adpa &= ~ADPA_CRT_HOTPLUG_MASK;
-        if (turn_off_dac)
-                adpa &= ~ADPA_DAC_ENABLE;
-
-        /* disable HPD first */
-        I915_WRITE(PCH_ADPA, adpa);
-        (void)I915_READ(PCH_ADPA);
-
-        adpa |= (ADPA_CRT_HOTPLUG_PERIOD_128 |
-                        ADPA_CRT_HOTPLUG_WARMUP_10MS |
-                        ADPA_CRT_HOTPLUG_SAMPLE_4S |
-                        ADPA_CRT_HOTPLUG_VOLTAGE_50 | /* default */
-                        ADPA_CRT_HOTPLUG_VOLREF_325MV |
-                        ADPA_CRT_HOTPLUG_ENABLE |
-                        ADPA_CRT_HOTPLUG_FORCE_TRIGGER);
-
-        DRM_DEBUG_KMS("pch crt adpa 0x%x", adpa);
-        I915_WRITE(PCH_ADPA, adpa);
-
-        if (wait_for((I915_READ(PCH_ADPA) & ADPA_CRT_HOTPLUG_FORCE_TRIGGER) == 0,
-                     1000, 1))
-                DRM_DEBUG_KMS("timed out waiting for FORCE_TRIGGER");
-
-        if (turn_off_dac) {
-                I915_WRITE(PCH_ADPA, temp);
-                (void)I915_READ(PCH_ADPA);
+                crt->force_hotplug_required = 0;
+
+                save_adpa = adpa = I915_READ(PCH_ADPA);
+                DRM_DEBUG_KMS("trigger hotplug detect cycle: adpa=0x%x\n", adpa);
+
+                adpa |= ADPA_CRT_HOTPLUG_FORCE_TRIGGER;
+                if (turn_off_dac)
+                        adpa &= ~ADPA_DAC_ENABLE;
+
+                I915_WRITE(PCH_ADPA, adpa);
+
+                if (wait_for((I915_READ(PCH_ADPA) & ADPA_CRT_HOTPLUG_FORCE_TRIGGER) == 0,
+                             1000))
+                        DRM_DEBUG_KMS("timed out waiting for FORCE_TRIGGER");
+
+                if (turn_off_dac) {
+                        I915_WRITE(PCH_ADPA, save_adpa);
+                        POSTING_READ(PCH_ADPA);
+                }
         }
 
         /* Check the status to see if both blue and green are on now */
         adpa = I915_READ(PCH_ADPA);
-        adpa &= ADPA_CRT_HOTPLUG_MONITOR_MASK;
-        if ((adpa == ADPA_CRT_HOTPLUG_MONITOR_COLOR) ||
-                (adpa == ADPA_CRT_HOTPLUG_MONITOR_MONO))
+        if ((adpa & ADPA_CRT_HOTPLUG_MONITOR_MASK) != 0)
                 ret = true;
         else
                 ret = false;
+        DRM_DEBUG_KMS("ironlake hotplug adpa=0x%x, result %d\n", adpa, ret);
 
         return ret;
 }
@@ -244,7 +252,7 @@ static bool intel_crt_detect_hotplug(struct drm_connector *connector)
                 /* wait for FORCE_DETECT to go off */
                 if (wait_for((I915_READ(PORT_HOTPLUG_EN) &
                               CRT_HOTPLUG_FORCE_DETECT) == 0,
-                             1000, 1))
+                             1000))
                         DRM_DEBUG_KMS("timed out waiting for FORCE_DETECT to go off");
         }
 
@@ -261,25 +269,51 @@ static bool intel_crt_detect_hotplug(struct drm_connector *connector)
         return ret;
 }
 
-static bool intel_crt_detect_ddc(struct drm_encoder *encoder)
+static bool intel_crt_detect_ddc(struct drm_connector *connector)
 {
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
+        struct intel_crt *crt = intel_attached_crt(connector);
+        struct drm_i915_private *dev_priv = crt->base.base.dev->dev_private;
 
         /* CRT should always be at 0, but check anyway */
-        if (intel_encoder->type != INTEL_OUTPUT_ANALOG)
+        if (crt->base.type != INTEL_OUTPUT_ANALOG)
                 return false;
 
-        return intel_ddc_probe(intel_encoder);
+        if (intel_ddc_probe(&crt->base, dev_priv->crt_ddc_pin)) {
+                struct edid *edid;
+                bool is_digital = false;
+
+                edid = drm_get_edid(connector,
+                        &dev_priv->gmbus[dev_priv->crt_ddc_pin].adapter);
+                /*
+                 * This may be a DVI-I connector with a shared DDC
+                 * link between analog and digital outputs, so we
+                 * have to check the EDID input spec of the attached device.
+                 *
+                 * On the other hand, what should we do if it is a broken EDID?
+                 */
+                if (edid != NULL) {
+                        is_digital = edid->input & DRM_EDID_INPUT_DIGITAL;
+                        connector->display_info.raw_edid = NULL;
+                        kfree(edid);
+                }
+
+                if (!is_digital) {
+                        DRM_DEBUG_KMS("CRT detected via DDC:0x50 [EDID]\n");
+                        return true;
+                } else {
+                        DRM_DEBUG_KMS("CRT not detected via DDC:0x50 [EDID reports a digital panel]\n");
+                }
+        }
+
+        return false;
 }
 
 static enum drm_connector_status
-intel_crt_load_detect(struct drm_crtc *crtc, struct intel_encoder *intel_encoder)
+intel_crt_load_detect(struct intel_crt *crt)
 {
-        struct drm_encoder *encoder = &intel_encoder->enc;
-        struct drm_device *dev = encoder->dev;
+        struct drm_device *dev = crt->base.base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
-        uint32_t pipe = intel_crtc->pipe;
+        uint32_t pipe = to_intel_crtc(crt->base.base.crtc)->pipe;
         uint32_t save_bclrpat;
         uint32_t save_vtotal;
         uint32_t vtotal, vactive;
@@ -295,21 +329,14 @@ intel_crt_load_detect(struct drm_crtc *crtc, struct intel_encoder *intel_encoder
         uint8_t st00;
         enum drm_connector_status status;
 
-        if (pipe == 0) {
-                bclrpat_reg = BCLRPAT_A;
-                vtotal_reg = VTOTAL_A;
-                vblank_reg = VBLANK_A;
-                vsync_reg = VSYNC_A;
-                pipeconf_reg = PIPEACONF;
-                pipe_dsl_reg = PIPEADSL;
-        } else {
-                bclrpat_reg = BCLRPAT_B;
-                vtotal_reg = VTOTAL_B;
-                vblank_reg = VBLANK_B;
-                vsync_reg = VSYNC_B;
-                pipeconf_reg = PIPEBCONF;
-                pipe_dsl_reg = PIPEBDSL;
-        }
+        DRM_DEBUG_KMS("starting load-detect on CRT\n");
+
+        bclrpat_reg = BCLRPAT(pipe);
+        vtotal_reg = VTOTAL(pipe);
+        vblank_reg = VBLANK(pipe);
+        vsync_reg = VSYNC(pipe);
+        pipeconf_reg = PIPECONF(pipe);
+        pipe_dsl_reg = PIPEDSL(pipe);
 
         save_bclrpat = I915_READ(bclrpat_reg);
         save_vtotal = I915_READ(vtotal_reg);
@@ -324,9 +351,10 @@ intel_crt_load_detect(struct drm_crtc *crtc, struct intel_encoder *intel_encoder
         /* Set the border color to purple. */
         I915_WRITE(bclrpat_reg, 0x500050);
 
-        if (IS_I9XX(dev)) {
+        if (!IS_GEN2(dev)) {
                 uint32_t pipeconf = I915_READ(pipeconf_reg);
                 I915_WRITE(pipeconf_reg, pipeconf | PIPECONF_FORCE_BORDER);
+                POSTING_READ(pipeconf_reg);
                 /* Wait for next Vblank to substitue
                  * border color for Color info */
                 intel_wait_for_vblank(dev, pipe);
@@ -404,35 +432,41 @@ static enum drm_connector_status
 intel_crt_detect(struct drm_connector *connector, bool force)
 {
         struct drm_device *dev = connector->dev;
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
+        struct intel_crt *crt = intel_attached_crt(connector);
         struct drm_crtc *crtc;
-        int dpms_mode;
         enum drm_connector_status status;
 
-        if (IS_I9XX(dev) && !IS_I915G(dev) && !IS_I915GM(dev)) {
-                if (intel_crt_detect_hotplug(connector))
+        if (I915_HAS_HOTPLUG(dev)) {
+                if (intel_crt_detect_hotplug(connector)) {
+                        DRM_DEBUG_KMS("CRT detected via hotplug\n");
                         return connector_status_connected;
-                else
+                } else {
+                        DRM_DEBUG_KMS("CRT not detected via hotplug\n");
                         return connector_status_disconnected;
+                }
         }
 
-        if (intel_crt_detect_ddc(encoder))
+        if (intel_crt_detect_ddc(connector))
                 return connector_status_connected;
 
         if (!force)
                 return connector->status;
 
         /* for pre-945g platforms use load detect */
-        if (encoder->crtc && encoder->crtc->enabled) {
-                status = intel_crt_load_detect(encoder->crtc, intel_encoder);
+        crtc = crt->base.base.crtc;
+        if (crtc && crtc->enabled) {
+                status = intel_crt_load_detect(crt);
         } else {
-                crtc = intel_get_load_detect_pipe(intel_encoder, connector,
-                                                  NULL, &dpms_mode);
-                if (crtc) {
-                        status = intel_crt_load_detect(crtc, intel_encoder);
-                        intel_release_load_detect_pipe(intel_encoder,
-                                                       connector, dpms_mode);
+                struct intel_load_detect_pipe tmp;
+
+                if (intel_get_load_detect_pipe(&crt->base, connector, NULL,
+                                               &tmp)) {
+                        if (intel_crt_detect_ddc(connector))
+                                status = connector_status_connected;
+                        else
+                                status = intel_crt_load_detect(crt);
+                        intel_release_load_detect_pipe(&crt->base, connector,
+                                                       &tmp);
                 } else
                         status = connector_status_unknown;
         }
@@ -449,32 +483,18 @@ static void intel_crt_destroy(struct drm_connector *connector)
 
 static int intel_crt_get_modes(struct drm_connector *connector)
 {
-        int ret;
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct i2c_adapter *ddc_bus;
         struct drm_device *dev = connector->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        int ret;
 
-
-        ret = intel_ddc_get_modes(connector, intel_encoder->ddc_bus);
+        ret = intel_ddc_get_modes(connector,
+                                 &dev_priv->gmbus[dev_priv->crt_ddc_pin].adapter);
         if (ret || !IS_G4X(dev))
-                goto end;
+                return ret;
 
         /* Try to probe digital port for output in DVI-I -> VGA mode. */
-        ddc_bus = intel_i2c_create(connector->dev, GPIOD, "CRTDDC_D");
-
-        if (!ddc_bus) {
-                dev_printk(KERN_ERR, &connector->dev->pdev->dev,
-                           "DDC bus registration failed for CRTDDC_D.\n");
-                goto end;
-        }
-        /* Try to get modes by GPIOD port */
-        ret = intel_ddc_get_modes(connector, ddc_bus);
-        intel_i2c_destroy(ddc_bus);
-
-end:
-        return ret;
-
+        return intel_ddc_get_modes(connector,
+                                   &dev_priv->gmbus[GMBUS_PORT_DPB].adapter);
 }
 
 static int intel_crt_set_property(struct drm_connector *connector,
@@ -484,6 +504,15 @@ static int intel_crt_set_property(struct drm_connector *connector,
         return 0;
 }
 
+static void intel_crt_reset(struct drm_connector *connector)
+{
+        struct drm_device *dev = connector->dev;
+        struct intel_crt *crt = intel_attached_crt(connector);
+
+        if (HAS_PCH_SPLIT(dev))
+                crt->force_hotplug_required = 1;
+}
+
 /*
  * Routines for controlling stuff on the analog port
  */
@@ -497,6 +526,7 @@ static const struct drm_encoder_helper_funcs intel_crt_helper_funcs = {
 };
 
 static const struct drm_connector_funcs intel_crt_connector_funcs = {
+        .reset = intel_crt_reset,
         .dpms = drm_helper_connector_dpms,
         .detect = intel_crt_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
@@ -507,7 +537,7 @@ static const struct drm_connector_funcs intel_crt_connector_funcs = {
 static const struct drm_connector_helper_funcs intel_crt_connector_helper_funcs = {
         .mode_valid = intel_crt_mode_valid,
         .get_modes = intel_crt_get_modes,
-        .best_encoder = intel_attached_encoder,
+        .best_encoder = intel_best_encoder,
 };
 
 static const struct drm_encoder_funcs intel_crt_enc_funcs = {
@@ -517,18 +547,17 @@ static const struct drm_encoder_funcs intel_crt_enc_funcs = {
 void intel_crt_init(struct drm_device *dev)
 {
         struct drm_connector *connector;
-        struct intel_encoder *intel_encoder;
+        struct intel_crt *crt;
         struct intel_connector *intel_connector;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 i2c_reg;
 
-        intel_encoder = kzalloc(sizeof(struct intel_encoder), GFP_KERNEL);
-        if (!intel_encoder)
+        crt = kzalloc(sizeof(struct intel_crt), GFP_KERNEL);
+        if (!crt)
                 return;
 
         intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
         if (!intel_connector) {
-                kfree(intel_encoder);
+                kfree(crt);
                 return;
         }
 
@@ -536,37 +565,20 @@ void intel_crt_init(struct drm_device *dev)
         drm_connector_init(dev, &intel_connector->base,
                            &intel_crt_connector_funcs, DRM_MODE_CONNECTOR_VGA);
 
-        drm_encoder_init(dev, &intel_encoder->enc, &intel_crt_enc_funcs,
+        drm_encoder_init(dev, &crt->base.base, &intel_crt_enc_funcs,
                          DRM_MODE_ENCODER_DAC);
 
-        drm_mode_connector_attach_encoder(&intel_connector->base,
-                                          &intel_encoder->enc);
+        intel_connector_attach_encoder(intel_connector, &crt->base);
 
-        /* Set up the DDC bus. */
-        if (HAS_PCH_SPLIT(dev))
-                i2c_reg = PCH_GPIOA;
-        else {
-                i2c_reg = GPIOA;
-                /* Use VBT information for CRT DDC if available */
-                if (dev_priv->crt_ddc_bus != 0)
-                        i2c_reg = dev_priv->crt_ddc_bus;
-        }
-        intel_encoder->ddc_bus = intel_i2c_create(dev, i2c_reg, "CRTDDC_A");
-        if (!intel_encoder->ddc_bus) {
-                dev_printk(KERN_ERR, &dev->pdev->dev, "DDC bus registration "
-                           "failed.\n");
-                return;
-        }
-
-        intel_encoder->type = INTEL_OUTPUT_ANALOG;
-        intel_encoder->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
-                                   (1 << INTEL_ANALOG_CLONE_BIT) |
-                                   (1 << INTEL_SDVO_LVDS_CLONE_BIT);
-        intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
+        crt->base.type = INTEL_OUTPUT_ANALOG;
+        crt->base.clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT |
+                                1 << INTEL_ANALOG_CLONE_BIT |
+                                1 << INTEL_SDVO_LVDS_CLONE_BIT);
+        crt->base.crtc_mask = (1 << 0) | (1 << 1);
         connector->interlace_allowed = 1;
         connector->doublescan_allowed = 0;
 
-        drm_encoder_helper_add(&intel_encoder->enc, &intel_crt_helper_funcs);
+        drm_encoder_helper_add(&crt->base.base, &intel_crt_helper_funcs);
         drm_connector_helper_add(connector, &intel_crt_connector_helper_funcs);
 
         drm_sysfs_connector_add(connector);
@@ -576,5 +588,22 @@ void intel_crt_init(struct drm_device *dev)
         else
                 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
 
+        /*
+         * Configure the automatic hotplug detection stuff
+         */
+        crt->force_hotplug_required = 0;
+        if (HAS_PCH_SPLIT(dev)) {
+                u32 adpa;
+
+                adpa = I915_READ(PCH_ADPA);
+                adpa &= ~ADPA_CRT_HOTPLUG_MASK;
+                adpa |= ADPA_HOTPLUG_BITS;
+                I915_WRITE(PCH_ADPA, adpa);
+                POSTING_READ(PCH_ADPA);
+
+                DRM_DEBUG_KMS("pch crt adpa set to 0x%x\n", adpa);
+                crt->force_hotplug_required = 1;
+        }
+
         dev_priv->hotplug_supported_mask |= CRT_HOTPLUG_INT_STATUS;
 }