1 files changed, 122 insertions, 110 deletions

diff --git a/drivers/gpu/drm/i915/intel_tv.c b/drivers/gpu/drm/i915/intel_tv.c
index 4a117e318a73..113e4e7264cd 100644
--- a/drivers/gpu/drm/i915/intel_tv.c
+++ b/drivers/gpu/drm/i915/intel_tv.c
@@ -48,7 +48,7 @@ struct intel_tv {
         struct intel_encoder base;
 
         int type;
-        char *tv_format;
+        const char *tv_format;
         int margin[4];
         u32 save_TV_H_CTL_1;
         u32 save_TV_H_CTL_2;
@@ -350,7 +350,7 @@ static const struct video_levels component_levels = {
 
 
 struct tv_mode {
-        char *name;
+        const char *name;
         int clock;
         int refresh; /* in millihertz (for precision) */
         u32 oversample;
@@ -900,7 +900,14 @@ static const struct tv_mode tv_modes[] = {
 
 static struct intel_tv *enc_to_intel_tv(struct drm_encoder *encoder)
 {
-        return container_of(enc_to_intel_encoder(encoder), struct intel_tv, base);
+        return container_of(encoder, struct intel_tv, base.base);
+}
+
+static struct intel_tv *intel_attached_tv(struct drm_connector *connector)
+{
+        return container_of(intel_attached_encoder(connector),
+                            struct intel_tv,
+                            base);
 }
 
 static void
@@ -922,7 +929,7 @@ intel_tv_dpms(struct drm_encoder *encoder, int mode)
 }
 
 static const struct tv_mode *
-intel_tv_mode_lookup (char *tv_format)
+intel_tv_mode_lookup(const char *tv_format)
 {
         int i;
 
@@ -936,22 +943,23 @@ intel_tv_mode_lookup (char *tv_format)
 }
 
 static const struct tv_mode *
-intel_tv_mode_find (struct intel_tv *intel_tv)
+intel_tv_mode_find(struct intel_tv *intel_tv)
 {
         return intel_tv_mode_lookup(intel_tv->tv_format);
 }
 
 static enum drm_mode_status
-intel_tv_mode_valid(struct drm_connector *connector, struct drm_display_mode *mode)
+intel_tv_mode_valid(struct drm_connector *connector,
+                    struct drm_display_mode *mode)
 {
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        struct intel_tv *intel_tv = intel_attached_tv(connector);
         const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
 
         /* Ensure TV refresh is close to desired refresh */
         if (tv_mode && abs(tv_mode->refresh - drm_mode_vrefresh(mode) * 1000)
                                 < 1000)
                 return MODE_OK;
+
         return MODE_CLOCK_RANGE;
 }
 
@@ -998,6 +1006,7 @@ intel_tv_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
         const struct video_levels *video_levels;
         const struct color_conversion *color_conversion;
         bool burst_ena;
+        int pipe = intel_crtc->pipe;
 
         if (!tv_mode)
                 return; /* can't happen (mode_prepare prevents this) */
@@ -1131,7 +1140,7 @@ intel_tv_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
                            color_conversion->av);
         }
 
-        if (IS_I965G(dev))
+        if (INTEL_INFO(dev)->gen >= 4)
                 I915_WRITE(TV_CLR_KNOBS, 0x00404000);
         else
                 I915_WRITE(TV_CLR_KNOBS, 0x00606000);
@@ -1141,14 +1150,11 @@ intel_tv_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
                            ((video_levels->black << TV_BLACK_LEVEL_SHIFT) |
                             (video_levels->blank << TV_BLANK_LEVEL_SHIFT)));
         {
-                int pipeconf_reg = (intel_crtc->pipe == 0) ?
-                        PIPEACONF : PIPEBCONF;
-                int dspcntr_reg = (intel_crtc->plane == 0) ?
-                        DSPACNTR : DSPBCNTR;
+                int pipeconf_reg = PIPECONF(pipe);
+                int dspcntr_reg = DSPCNTR(intel_crtc->plane);
                 int pipeconf = I915_READ(pipeconf_reg);
                 int dspcntr = I915_READ(dspcntr_reg);
-                int dspbase_reg = (intel_crtc->plane == 0) ?
-                        DSPAADDR : DSPBADDR;
+                int dspbase_reg = DSPADDR(intel_crtc->plane);
                 int xpos = 0x0, ypos = 0x0;
                 unsigned int xsize, ysize;
                 /* Pipe must be off here */
@@ -1157,12 +1163,12 @@ intel_tv_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
                 I915_WRITE(dspbase_reg, I915_READ(dspbase_reg));
 
                 /* Wait for vblank for the disable to take effect */
-                if (!IS_I9XX(dev))
+                if (IS_GEN2(dev))
                         intel_wait_for_vblank(dev, intel_crtc->pipe);
 
-                I915_WRITE(pipeconf_reg, pipeconf & ~PIPEACONF_ENABLE);
+                I915_WRITE(pipeconf_reg, pipeconf & ~PIPECONF_ENABLE);
                 /* Wait for vblank for the disable to take effect. */
-                intel_wait_for_vblank(dev, intel_crtc->pipe);
+                intel_wait_for_pipe_off(dev, intel_crtc->pipe);
 
                 /* Filter ctl must be set before TV_WIN_SIZE */
                 I915_WRITE(TV_FILTER_CTL_1, TV_AUTO_SCALE);
@@ -1196,7 +1202,7 @@ intel_tv_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
                 I915_WRITE(TV_V_LUMA_0 + (i<<2), tv_mode->filter_table[j++]);
         for (i = 0; i < 43; i++)
                 I915_WRITE(TV_V_CHROMA_0 + (i<<2), tv_mode->filter_table[j++]);
-        I915_WRITE(TV_DAC, 0);
+        I915_WRITE(TV_DAC, I915_READ(TV_DAC) & TV_DAC_SAVE);
         I915_WRITE(TV_CTL, tv_ctl);
 }
 
@@ -1226,37 +1232,34 @@ static const struct drm_display_mode reported_modes[] = {
  * \return false if TV is disconnected.
  */
 static int
-intel_tv_detect_type (struct intel_tv *intel_tv)
+intel_tv_detect_type (struct intel_tv *intel_tv,
+                      struct drm_connector *connector)
 {
-        struct drm_encoder *encoder = &intel_tv->base.enc;
+        struct drm_encoder *encoder = &intel_tv->base.base;
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         unsigned long irqflags;
         u32 tv_ctl, save_tv_ctl;
         u32 tv_dac, save_tv_dac;
-        int type = DRM_MODE_CONNECTOR_Unknown;
-
-        tv_dac = I915_READ(TV_DAC);
+        int type;
 
         /* Disable TV interrupts around load detect or we'll recurse */
-        spin_lock_irqsave(&dev_priv->user_irq_lock, irqflags);
-        i915_disable_pipestat(dev_priv, 0, PIPE_HOTPLUG_INTERRUPT_ENABLE |
-                              PIPE_HOTPLUG_TV_INTERRUPT_ENABLE);
-        spin_unlock_irqrestore(&dev_priv->user_irq_lock, irqflags);
+        if (connector->polled & DRM_CONNECTOR_POLL_HPD) {
+                spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
+                i915_disable_pipestat(dev_priv, 0,
+                                      PIPE_HOTPLUG_INTERRUPT_ENABLE |
+                                      PIPE_HOTPLUG_TV_INTERRUPT_ENABLE);
+                spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
+        }
 
-        /*
-         * Detect TV by polling)
-         */
-        save_tv_dac = tv_dac;
-        tv_ctl = I915_READ(TV_CTL);
-        save_tv_ctl = tv_ctl;
-        tv_ctl &= ~TV_ENC_ENABLE;
-        tv_ctl &= ~TV_TEST_MODE_MASK;
+        save_tv_dac = tv_dac = I915_READ(TV_DAC);
+        save_tv_ctl = tv_ctl = I915_READ(TV_CTL);
+
+        /* Poll for TV detection */
+        tv_ctl &= ~(TV_ENC_ENABLE | TV_TEST_MODE_MASK);
         tv_ctl |= TV_TEST_MODE_MONITOR_DETECT;
-        tv_dac &= ~TVDAC_SENSE_MASK;
-        tv_dac &= ~DAC_A_MASK;
-        tv_dac &= ~DAC_B_MASK;
-        tv_dac &= ~DAC_C_MASK;
+
+        tv_dac &= ~(TVDAC_SENSE_MASK | DAC_A_MASK | DAC_B_MASK | DAC_C_MASK);
         tv_dac |= (TVDAC_STATE_CHG_EN |
                    TVDAC_A_SENSE_CTL |
                    TVDAC_B_SENSE_CTL |
@@ -1265,42 +1268,48 @@ intel_tv_detect_type (struct intel_tv *intel_tv)
                    DAC_A_0_7_V |
                    DAC_B_0_7_V |
                    DAC_C_0_7_V);
+
         I915_WRITE(TV_CTL, tv_ctl);
         I915_WRITE(TV_DAC, tv_dac);
         POSTING_READ(TV_DAC);
-        msleep(20);
 
-        tv_dac = I915_READ(TV_DAC);
-        I915_WRITE(TV_DAC, save_tv_dac);
-        I915_WRITE(TV_CTL, save_tv_ctl);
-        POSTING_READ(TV_CTL);
-        msleep(20);
+        intel_wait_for_vblank(intel_tv->base.base.dev,
+                              to_intel_crtc(intel_tv->base.base.crtc)->pipe);
 
-        /*
-         *  A B C
-         *  0 1 1 Composite
-         *  1 0 X svideo
-         *  0 0 0 Component
-         */
-        if ((tv_dac & TVDAC_SENSE_MASK) == (TVDAC_B_SENSE | TVDAC_C_SENSE)) {
-                DRM_DEBUG_KMS("Detected Composite TV connection\n");
-                type = DRM_MODE_CONNECTOR_Composite;
-        } else if ((tv_dac & (TVDAC_A_SENSE|TVDAC_B_SENSE)) == TVDAC_A_SENSE) {
-                DRM_DEBUG_KMS("Detected S-Video TV connection\n");
-                type = DRM_MODE_CONNECTOR_SVIDEO;
-        } else if ((tv_dac & TVDAC_SENSE_MASK) == 0) {
-                DRM_DEBUG_KMS("Detected Component TV connection\n");
-                type = DRM_MODE_CONNECTOR_Component;
-        } else {
-                DRM_DEBUG_KMS("No TV connection detected\n");
-                type = -1;
+        type = -1;
+        if (wait_for((tv_dac = I915_READ(TV_DAC)) & TVDAC_STATE_CHG, 20) == 0) {
+                DRM_DEBUG_KMS("TV detected: %x, %x\n", tv_ctl, tv_dac);
+                /*
+                 *  A B C
+                 *  0 1 1 Composite
+                 *  1 0 X svideo
+                 *  0 0 0 Component
+                 */
+                if ((tv_dac & TVDAC_SENSE_MASK) == (TVDAC_B_SENSE | TVDAC_C_SENSE)) {
+                        DRM_DEBUG_KMS("Detected Composite TV connection\n");
+                        type = DRM_MODE_CONNECTOR_Composite;
+                } else if ((tv_dac & (TVDAC_A_SENSE|TVDAC_B_SENSE)) == TVDAC_A_SENSE) {
+                        DRM_DEBUG_KMS("Detected S-Video TV connection\n");
+                        type = DRM_MODE_CONNECTOR_SVIDEO;
+                } else if ((tv_dac & TVDAC_SENSE_MASK) == 0) {
+                        DRM_DEBUG_KMS("Detected Component TV connection\n");
+                        type = DRM_MODE_CONNECTOR_Component;
+                } else {
+                        DRM_DEBUG_KMS("Unrecognised TV connection\n");
+                }
         }
 
+        I915_WRITE(TV_DAC, save_tv_dac & ~TVDAC_STATE_CHG_EN);
+        I915_WRITE(TV_CTL, save_tv_ctl);
+
         /* Restore interrupt config */
-        spin_lock_irqsave(&dev_priv->user_irq_lock, irqflags);
-        i915_enable_pipestat(dev_priv, 0, PIPE_HOTPLUG_INTERRUPT_ENABLE |
-                             PIPE_HOTPLUG_TV_INTERRUPT_ENABLE);
-        spin_unlock_irqrestore(&dev_priv->user_irq_lock, irqflags);
+        if (connector->polled & DRM_CONNECTOR_POLL_HPD) {
+                spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
+                i915_enable_pipestat(dev_priv, 0,
+                                     PIPE_HOTPLUG_INTERRUPT_ENABLE |
+                                     PIPE_HOTPLUG_TV_INTERRUPT_ENABLE);
+                spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
+        }
 
         return type;
 }
@@ -1311,8 +1320,7 @@ intel_tv_detect_type (struct intel_tv *intel_tv)
  */
 static void intel_tv_find_better_format(struct drm_connector *connector)
 {
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        struct intel_tv *intel_tv = intel_attached_tv(connector);
         const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
         int i;
 
@@ -1344,25 +1352,23 @@ static enum drm_connector_status
 intel_tv_detect(struct drm_connector *connector, bool force)
 {
         struct drm_display_mode mode;
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        struct intel_tv *intel_tv = intel_attached_tv(connector);
         int type;
 
         mode = reported_modes[0];
         drm_mode_set_crtcinfo(&mode, CRTC_INTERLACE_HALVE_V);
 
-        if (encoder->crtc && encoder->crtc->enabled) {
-                type = intel_tv_detect_type(intel_tv);
+        if (intel_tv->base.base.crtc && intel_tv->base.base.crtc->enabled) {
+                type = intel_tv_detect_type(intel_tv, connector);
         } else if (force) {
-                struct drm_crtc *crtc;
-                int dpms_mode;
-
-                crtc = intel_get_load_detect_pipe(&intel_tv->base, connector,
-                                                  &mode, &dpms_mode);
-                if (crtc) {
-                        type = intel_tv_detect_type(intel_tv);
-                        intel_release_load_detect_pipe(&intel_tv->base, connector,
-                                                       dpms_mode);
+                struct intel_load_detect_pipe tmp;
+
+                if (intel_get_load_detect_pipe(&intel_tv->base, connector,
+                                               &mode, &tmp)) {
+                        type = intel_tv_detect_type(intel_tv, connector);
+                        intel_release_load_detect_pipe(&intel_tv->base,
+                                                       connector,
+                                                       &tmp);
                 } else
                         return connector_status_unknown;
         } else
@@ -1371,15 +1377,16 @@ intel_tv_detect(struct drm_connector *connector, bool force)
         if (type < 0)
                 return connector_status_disconnected;
 
+        intel_tv->type = type;
         intel_tv_find_better_format(connector);
+
         return connector_status_connected;
 }
 
-static struct input_res {
-        char *name;
+static const struct input_res {
+        const char *name;
         int w, h;
-} input_res_table[] =
-{
+} input_res_table[] = {
         {"640x480", 640, 480},
         {"800x600", 800, 600},
         {"1024x768", 1024, 768},
@@ -1396,8 +1403,7 @@ static void
 intel_tv_chose_preferred_modes(struct drm_connector *connector,
                                struct drm_display_mode *mode_ptr)
 {
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        struct intel_tv *intel_tv = intel_attached_tv(connector);
         const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
 
         if (tv_mode->nbr_end < 480 && mode_ptr->vdisplay == 480)
@@ -1422,15 +1428,14 @@ static int
 intel_tv_get_modes(struct drm_connector *connector)
 {
         struct drm_display_mode *mode_ptr;
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        struct intel_tv *intel_tv = intel_attached_tv(connector);
         const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
         int j, count = 0;
         u64 tmp;
 
         for (j = 0; j < ARRAY_SIZE(input_res_table);
              j++) {
-                struct input_res *input = &input_res_table[j];
+                const struct input_res *input = &input_res_table[j];
                 unsigned int hactive_s = input->w;
                 unsigned int vactive_s = input->h;
 
@@ -1488,9 +1493,8 @@ intel_tv_set_property(struct drm_connector *connector, struct drm_property *prop
                       uint64_t val)
 {
         struct drm_device *dev = connector->dev;
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
-        struct drm_crtc *crtc = encoder->crtc;
+        struct intel_tv *intel_tv = intel_attached_tv(connector);
+        struct drm_crtc *crtc = intel_tv->base.base.crtc;
         int ret = 0;
         bool changed = false;
 
@@ -1555,7 +1559,7 @@ static const struct drm_connector_funcs intel_tv_connector_funcs = {
 static const struct drm_connector_helper_funcs intel_tv_connector_helper_funcs = {
         .mode_valid = intel_tv_mode_valid,
         .get_modes = intel_tv_get_modes,
-        .best_encoder = intel_attached_encoder,
+        .best_encoder = intel_best_encoder,
 };
 
 static const struct drm_encoder_funcs intel_tv_enc_funcs = {
@@ -1607,7 +1611,7 @@ intel_tv_init(struct drm_device *dev)
         struct intel_encoder *intel_encoder;
         struct intel_connector *intel_connector;
         u32 tv_dac_on, tv_dac_off, save_tv_dac;
-        char **tv_format_names;
+        char *tv_format_names[ARRAY_SIZE(tv_modes)];
         int i, initial_mode = 0;
 
         if ((I915_READ(TV_CTL) & TV_FUSE_STATE_MASK) == TV_FUSE_STATE_DISABLED)
@@ -1658,18 +1662,29 @@ intel_tv_init(struct drm_device *dev)
         intel_encoder = &intel_tv->base;
         connector = &intel_connector->base;
 
+        /* The documentation, for the older chipsets at least, recommend
+         * using a polling method rather than hotplug detection for TVs.
+         * This is because in order to perform the hotplug detection, the PLLs
+         * for the TV must be kept alive increasing power drain and starving
+         * bandwidth from other encoders. Notably for instance, it causes
+         * pipe underruns on Crestline when this encoder is supposedly idle.
+         *
+         * More recent chipsets favour HDMI rather than integrated S-Video.
+         */
+        connector->polled = DRM_CONNECTOR_POLL_CONNECT;
+
         drm_connector_init(dev, connector, &intel_tv_connector_funcs,
                            DRM_MODE_CONNECTOR_SVIDEO);
 
-        drm_encoder_init(dev, &intel_encoder->enc, &intel_tv_enc_funcs,
+        drm_encoder_init(dev, &intel_encoder->base, &intel_tv_enc_funcs,
                          DRM_MODE_ENCODER_TVDAC);
 
-        drm_mode_connector_attach_encoder(&intel_connector->base, &intel_encoder->enc);
+        intel_connector_attach_encoder(intel_connector, intel_encoder);
         intel_encoder->type = INTEL_OUTPUT_TVOUT;
         intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
         intel_encoder->clone_mask = (1 << INTEL_TV_CLONE_BIT);
-        intel_encoder->enc.possible_crtcs = ((1 << 0) | (1 << 1));
-        intel_encoder->enc.possible_clones = (1 << INTEL_OUTPUT_TVOUT);
+        intel_encoder->base.possible_crtcs = ((1 << 0) | (1 << 1));
+        intel_encoder->base.possible_clones = (1 << INTEL_OUTPUT_TVOUT);
         intel_tv->type = DRM_MODE_CONNECTOR_Unknown;
 
         /* BIOS margin values */
@@ -1678,21 +1693,19 @@ intel_tv_init(struct drm_device *dev)
         intel_tv->margin[TV_MARGIN_RIGHT] = 46;
         intel_tv->margin[TV_MARGIN_BOTTOM] = 37;
 
-        intel_tv->tv_format = kstrdup(tv_modes[initial_mode].name, GFP_KERNEL);
+        intel_tv->tv_format = tv_modes[initial_mode].name;
 
-        drm_encoder_helper_add(&intel_encoder->enc, &intel_tv_helper_funcs);
+        drm_encoder_helper_add(&intel_encoder->base, &intel_tv_helper_funcs);
         drm_connector_helper_add(connector, &intel_tv_connector_helper_funcs);
         connector->interlace_allowed = false;
         connector->doublescan_allowed = false;
 
         /* Create TV properties then attach current values */
-        tv_format_names = kmalloc(sizeof(char *) * ARRAY_SIZE(tv_modes),
-                                  GFP_KERNEL);
-        if (!tv_format_names)
-                goto out;
         for (i = 0; i < ARRAY_SIZE(tv_modes); i++)
-                tv_format_names[i] = tv_modes[i].name;
-        drm_mode_create_tv_properties(dev, ARRAY_SIZE(tv_modes), tv_format_names);
+                tv_format_names[i] = (char *)tv_modes[i].name;
+        drm_mode_create_tv_properties(dev,
+                                      ARRAY_SIZE(tv_modes),
+                                      tv_format_names);
 
         drm_connector_attach_property(connector, dev->mode_config.tv_mode_property,
                                    initial_mode);
@@ -1708,6 +1721,5 @@ intel_tv_init(struct drm_device *dev)
         drm_connector_attach_property(connector,
                                    dev->mode_config.tv_bottom_margin_property,
                                    intel_tv->margin[TV_MARGIN_BOTTOM]);
-out:
         drm_sysfs_connector_add(connector);
 }