1 files changed, 188 insertions, 37 deletions

diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
index 926934a482ec..aa0a8e83142e 100644
--- a/drivers/gpu/drm/i915/intel_hdmi.c
+++ b/drivers/gpu/drm/i915/intel_hdmi.c
@@ -40,12 +40,76 @@
 struct intel_hdmi {
         struct intel_encoder base;
         u32 sdvox_reg;
+        int ddc_bus;
+        uint32_t color_range;
         bool has_hdmi_sink;
+        bool has_audio;
+        int force_audio;
 };
 
 static struct intel_hdmi *enc_to_intel_hdmi(struct drm_encoder *encoder)
 {
-        return container_of(enc_to_intel_encoder(encoder), struct intel_hdmi, base);
+        return container_of(encoder, struct intel_hdmi, base.base);
+}
+
+static struct intel_hdmi *intel_attached_hdmi(struct drm_connector *connector)
+{
+        return container_of(intel_attached_encoder(connector),
+                            struct intel_hdmi, base);
+}
+
+void intel_dip_infoframe_csum(struct dip_infoframe *avi_if)
+{
+        uint8_t *data = (uint8_t *)avi_if;
+        uint8_t sum = 0;
+        unsigned i;
+
+        avi_if->checksum = 0;
+        avi_if->ecc = 0;
+
+        for (i = 0; i < sizeof(*avi_if); i++)
+                sum += data[i];
+
+        avi_if->checksum = 0x100 - sum;
+}
+
+static void intel_hdmi_set_avi_infoframe(struct drm_encoder *encoder)
+{
+        struct dip_infoframe avi_if = {
+                .type = DIP_TYPE_AVI,
+                .ver = DIP_VERSION_AVI,
+                .len = DIP_LEN_AVI,
+        };
+        uint32_t *data = (uint32_t *)&avi_if;
+        struct drm_device *dev = encoder->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
+        u32 port;
+        unsigned i;
+
+        if (!intel_hdmi->has_hdmi_sink)
+                return;
+
+        /* XXX first guess at handling video port, is this corrent? */
+        if (intel_hdmi->sdvox_reg == SDVOB)
+                port = VIDEO_DIP_PORT_B;
+        else if (intel_hdmi->sdvox_reg == SDVOC)
+                port = VIDEO_DIP_PORT_C;
+        else
+                return;
+
+        I915_WRITE(VIDEO_DIP_CTL, VIDEO_DIP_ENABLE | port |
+                   VIDEO_DIP_SELECT_AVI | VIDEO_DIP_FREQ_VSYNC);
+
+        intel_dip_infoframe_csum(&avi_if);
+        for (i = 0; i < sizeof(avi_if); i += 4) {
+                I915_WRITE(VIDEO_DIP_DATA, *data);
+                data++;
+        }
+
+        I915_WRITE(VIDEO_DIP_CTL, VIDEO_DIP_ENABLE | port |
+                   VIDEO_DIP_SELECT_AVI | VIDEO_DIP_FREQ_VSYNC |
+                   VIDEO_DIP_ENABLE_AVI);
 }
 
 static void intel_hdmi_mode_set(struct drm_encoder *encoder,
@@ -60,15 +124,19 @@ static void intel_hdmi_mode_set(struct drm_encoder *encoder,
         u32 sdvox;
 
         sdvox = SDVO_ENCODING_HDMI | SDVO_BORDER_ENABLE;
+        sdvox |= intel_hdmi->color_range;
         if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
                 sdvox |= SDVO_VSYNC_ACTIVE_HIGH;
         if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
                 sdvox |= SDVO_HSYNC_ACTIVE_HIGH;
 
-        if (intel_hdmi->has_hdmi_sink) {
+        /* Required on CPT */
+        if (intel_hdmi->has_hdmi_sink && HAS_PCH_CPT(dev))
+                sdvox |= HDMI_MODE_SELECT;
+
+        if (intel_hdmi->has_audio) {
                 sdvox |= SDVO_AUDIO_ENABLE;
-                if (HAS_PCH_CPT(dev))
-                        sdvox |= HDMI_MODE_SELECT;
+                sdvox |= SDVO_NULL_PACKETS_DURING_VSYNC;
         }
 
         if (intel_crtc->pipe == 1) {
@@ -80,6 +148,8 @@ static void intel_hdmi_mode_set(struct drm_encoder *encoder,
 
         I915_WRITE(intel_hdmi->sdvox_reg, sdvox);
         POSTING_READ(intel_hdmi->sdvox_reg);
+
+        intel_hdmi_set_avi_infoframe(encoder);
 }
 
 static void intel_hdmi_dpms(struct drm_encoder *encoder, int mode)
@@ -123,7 +193,7 @@ static int intel_hdmi_mode_valid(struct drm_connector *connector,
         if (mode->clock > 165000)
                 return MODE_CLOCK_HIGH;
         if (mode->clock < 20000)
-                return MODE_CLOCK_HIGH;
+                return MODE_CLOCK_LOW;
 
         if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
                 return MODE_NO_DBLESCAN;
@@ -141,36 +211,121 @@ static bool intel_hdmi_mode_fixup(struct drm_encoder *encoder,
 static enum drm_connector_status
 intel_hdmi_detect(struct drm_connector *connector, bool force)
 {
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
-        struct edid *edid = NULL;
+        struct intel_hdmi *intel_hdmi = intel_attached_hdmi(connector);
+        struct drm_i915_private *dev_priv = connector->dev->dev_private;
+        struct edid *edid;
         enum drm_connector_status status = connector_status_disconnected;
 
         intel_hdmi->has_hdmi_sink = false;
-        edid = drm_get_edid(connector, intel_hdmi->base.ddc_bus);
+        intel_hdmi->has_audio = false;
+        edid = drm_get_edid(connector,
+                            &dev_priv->gmbus[intel_hdmi->ddc_bus].adapter);
 
         if (edid) {
                 if (edid->input & DRM_EDID_INPUT_DIGITAL) {
                         status = connector_status_connected;
                         intel_hdmi->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
+                        intel_hdmi->has_audio = drm_detect_monitor_audio(edid);
                 }
                 connector->display_info.raw_edid = NULL;
                 kfree(edid);
         }
 
+        if (status == connector_status_connected) {
+                if (intel_hdmi->force_audio)
+                        intel_hdmi->has_audio = intel_hdmi->force_audio > 0;
+        }
+
         return status;
 }
 
 static int intel_hdmi_get_modes(struct drm_connector *connector)
 {
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
+        struct intel_hdmi *intel_hdmi = intel_attached_hdmi(connector);
+        struct drm_i915_private *dev_priv = connector->dev->dev_private;
 
         /* We should parse the EDID data and find out if it's an HDMI sink so
          * we can send audio to it.
          */
 
-        return intel_ddc_get_modes(connector, intel_hdmi->base.ddc_bus);
+        return intel_ddc_get_modes(connector,
+                                   &dev_priv->gmbus[intel_hdmi->ddc_bus].adapter);
+}
+
+static bool
+intel_hdmi_detect_audio(struct drm_connector *connector)
+{
+        struct intel_hdmi *intel_hdmi = intel_attached_hdmi(connector);
+        struct drm_i915_private *dev_priv = connector->dev->dev_private;
+        struct edid *edid;
+        bool has_audio = false;
+
+        edid = drm_get_edid(connector,
+                            &dev_priv->gmbus[intel_hdmi->ddc_bus].adapter);
+        if (edid) {
+                if (edid->input & DRM_EDID_INPUT_DIGITAL)
+                        has_audio = drm_detect_monitor_audio(edid);
+
+                connector->display_info.raw_edid = NULL;
+                kfree(edid);
+        }
+
+        return has_audio;
+}
+
+static int
+intel_hdmi_set_property(struct drm_connector *connector,
+                      struct drm_property *property,
+                      uint64_t val)
+{
+        struct intel_hdmi *intel_hdmi = intel_attached_hdmi(connector);
+        struct drm_i915_private *dev_priv = connector->dev->dev_private;
+        int ret;
+
+        ret = drm_connector_property_set_value(connector, property, val);
+        if (ret)
+                return ret;
+
+        if (property == dev_priv->force_audio_property) {
+                int i = val;
+                bool has_audio;
+
+                if (i == intel_hdmi->force_audio)
+                        return 0;
+
+                intel_hdmi->force_audio = i;
+
+                if (i == 0)
+                        has_audio = intel_hdmi_detect_audio(connector);
+                else
+                        has_audio = i > 0;
+
+                if (has_audio == intel_hdmi->has_audio)
+                        return 0;
+
+                intel_hdmi->has_audio = has_audio;
+                goto done;
+        }
+
+        if (property == dev_priv->broadcast_rgb_property) {
+                if (val == !!intel_hdmi->color_range)
+                        return 0;
+
+                intel_hdmi->color_range = val ? SDVO_COLOR_RANGE_16_235 : 0;
+                goto done;
+        }
+
+        return -EINVAL;
+
+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);
+        }
+
+        return 0;
 }
 
 static void intel_hdmi_destroy(struct drm_connector *connector)
@@ -192,19 +347,27 @@ static const struct drm_connector_funcs intel_hdmi_connector_funcs = {
         .dpms = drm_helper_connector_dpms,
         .detect = intel_hdmi_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
+        .set_property = intel_hdmi_set_property,
         .destroy = intel_hdmi_destroy,
 };
 
 static const struct drm_connector_helper_funcs intel_hdmi_connector_helper_funcs = {
         .get_modes = intel_hdmi_get_modes,
         .mode_valid = intel_hdmi_mode_valid,
-        .best_encoder = intel_attached_encoder,
+        .best_encoder = intel_best_encoder,
 };
 
 static const struct drm_encoder_funcs intel_hdmi_enc_funcs = {
         .destroy = intel_encoder_destroy,
 };
 
+static void
+intel_hdmi_add_properties(struct intel_hdmi *intel_hdmi, struct drm_connector *connector)
+{
+        intel_attach_force_audio_property(connector);
+        intel_attach_broadcast_rgb_property(connector);
+}
+
 void intel_hdmi_init(struct drm_device *dev, int sdvox_reg)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
@@ -224,6 +387,9 @@ void intel_hdmi_init(struct drm_device *dev, int sdvox_reg)
         }
 
         intel_encoder = &intel_hdmi->base;
+        drm_encoder_init(dev, &intel_encoder->base, &intel_hdmi_enc_funcs,
+                         DRM_MODE_ENCODER_TMDS);
+
         connector = &intel_connector->base;
         drm_connector_init(dev, connector, &intel_hdmi_connector_funcs,
                            DRM_MODE_CONNECTOR_HDMIA);
@@ -239,39 +405,33 @@ void intel_hdmi_init(struct drm_device *dev, int sdvox_reg)
         /* Set up the DDC bus. */
         if (sdvox_reg == SDVOB) {
                 intel_encoder->clone_mask = (1 << INTEL_HDMIB_CLONE_BIT);
-                intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOE, "HDMIB");
+                intel_hdmi->ddc_bus = GMBUS_PORT_DPB;
                 dev_priv->hotplug_supported_mask |= HDMIB_HOTPLUG_INT_STATUS;
         } else if (sdvox_reg == SDVOC) {
                 intel_encoder->clone_mask = (1 << INTEL_HDMIC_CLONE_BIT);
-                intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOD, "HDMIC");
+                intel_hdmi->ddc_bus = GMBUS_PORT_DPC;
                 dev_priv->hotplug_supported_mask |= HDMIC_HOTPLUG_INT_STATUS;
         } else if (sdvox_reg == HDMIB) {
                 intel_encoder->clone_mask = (1 << INTEL_HDMID_CLONE_BIT);
-                intel_encoder->ddc_bus = intel_i2c_create(dev, PCH_GPIOE,
-                                                                "HDMIB");
+                intel_hdmi->ddc_bus = GMBUS_PORT_DPB;
                 dev_priv->hotplug_supported_mask |= HDMIB_HOTPLUG_INT_STATUS;
         } else if (sdvox_reg == HDMIC) {
                 intel_encoder->clone_mask = (1 << INTEL_HDMIE_CLONE_BIT);
-                intel_encoder->ddc_bus = intel_i2c_create(dev, PCH_GPIOD,
-                                                                "HDMIC");
+                intel_hdmi->ddc_bus = GMBUS_PORT_DPC;
                 dev_priv->hotplug_supported_mask |= HDMIC_HOTPLUG_INT_STATUS;
         } else if (sdvox_reg == HDMID) {
                 intel_encoder->clone_mask = (1 << INTEL_HDMIF_CLONE_BIT);
-                intel_encoder->ddc_bus = intel_i2c_create(dev, PCH_GPIOF,
-                                                                "HDMID");
+                intel_hdmi->ddc_bus = GMBUS_PORT_DPD;
                 dev_priv->hotplug_supported_mask |= HDMID_HOTPLUG_INT_STATUS;
         }
-        if (!intel_encoder->ddc_bus)
-                goto err_connector;
 
         intel_hdmi->sdvox_reg = sdvox_reg;
 
-        drm_encoder_init(dev, &intel_encoder->enc, &intel_hdmi_enc_funcs,
-                         DRM_MODE_ENCODER_TMDS);
-        drm_encoder_helper_add(&intel_encoder->enc, &intel_hdmi_helper_funcs);
+        drm_encoder_helper_add(&intel_encoder->base, &intel_hdmi_helper_funcs);
+
+        intel_hdmi_add_properties(intel_hdmi, connector);
 
-        drm_mode_connector_attach_encoder(&intel_connector->base,
-                                          &intel_encoder->enc);
+        intel_connector_attach_encoder(intel_connector, intel_encoder);
         drm_sysfs_connector_add(connector);
 
         /* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written
@@ -282,13 +442,4 @@ void intel_hdmi_init(struct drm_device *dev, int sdvox_reg)
                 u32 temp = I915_READ(PEG_BAND_GAP_DATA);
                 I915_WRITE(PEG_BAND_GAP_DATA, (temp & ~0xf) | 0xd);
         }
-
-        return;
-
-err_connector:
-        drm_connector_cleanup(connector);
-        kfree(intel_hdmi);
-        kfree(intel_connector);
-
-        return;
 }