bool has_dpcd;
        struct drm_display_mode *scan;
        struct edid *edid;
+       enum pipe pipe = INVALID_PIPE;
 
        intel_dp->drrs_state.type = DRRS_NOT_SUPPORTED;
 
        if (IS_VALLEYVIEW(dev)) {
                intel_dp->edp_notifier.notifier_call = edp_notify_handler;
                register_reboot_notifier(&intel_dp->edp_notifier);
+
+               /*
+                * Figure out the current pipe for the initial backlight setup.
+                * If the current pipe isn't valid, try the PPS pipe, and if that
+                * fails just assume pipe A.
+                */
+               if (IS_CHERRYVIEW(dev))
+                       pipe = DP_PORT_TO_PIPE_CHV(intel_dp->DP);
+               else
+                       pipe = PORT_TO_PIPE(intel_dp->DP);
+
+               if (pipe != PIPE_A && pipe != PIPE_B)
+                       pipe = intel_dp->pps_pipe;
+
+               if (pipe != PIPE_A && pipe != PIPE_B)
+                       pipe = PIPE_A;
+
+               DRM_DEBUG_KMS("using pipe %c for initial backlight setup\n",
+                             pipe_name(pipe));
        }
 
        intel_panel_init(&intel_connector->panel, fixed_mode, downclock_mode);
        intel_connector->panel.backlight_power = intel_edp_backlight_power;
-       intel_panel_setup_backlight(connector);
+       intel_panel_setup_backlight(connector, pipe);
 
        return true;
 }
 
                     0, panel->backlight.max);
 }
 
-static int bdw_setup_backlight(struct intel_connector *connector)
+static int bdw_setup_backlight(struct intel_connector *connector, enum pipe unused)
 {
        struct drm_device *dev = connector->base.dev;
        struct drm_i915_private *dev_priv = dev->dev_private;
        return 0;
 }
 
-static int pch_setup_backlight(struct intel_connector *connector)
+static int pch_setup_backlight(struct intel_connector *connector, enum pipe unused)
 {
        struct drm_device *dev = connector->base.dev;
        struct drm_i915_private *dev_priv = dev->dev_private;
        return 0;
 }
 
-static int i9xx_setup_backlight(struct intel_connector *connector)
+static int i9xx_setup_backlight(struct intel_connector *connector, enum pipe unused)
 {
        struct drm_device *dev = connector->base.dev;
        struct drm_i915_private *dev_priv = dev->dev_private;
        return 0;
 }
 
-static int i965_setup_backlight(struct intel_connector *connector)
+static int i965_setup_backlight(struct intel_connector *connector, enum pipe unused)
 {
        struct drm_device *dev = connector->base.dev;
        struct drm_i915_private *dev_priv = dev->dev_private;
        return 0;
 }
 
-static int vlv_setup_backlight(struct intel_connector *connector)
+static int vlv_setup_backlight(struct intel_connector *connector, enum pipe pipe)
 {
        struct drm_device *dev = connector->base.dev;
        struct drm_i915_private *dev_priv = dev->dev_private;
        struct intel_panel *panel = &connector->panel;
-       enum pipe pipe;
+       enum pipe p;
        u32 ctl, ctl2, val;
 
-       for_each_pipe(dev_priv, pipe) {
-               u32 cur_val = I915_READ(VLV_BLC_PWM_CTL(pipe));
+       for_each_pipe(dev_priv, p) {
+               u32 cur_val = I915_READ(VLV_BLC_PWM_CTL(p));
 
                /* Skip if the modulation freq is already set */
                if (cur_val & ~BACKLIGHT_DUTY_CYCLE_MASK)
                        continue;
 
                cur_val &= BACKLIGHT_DUTY_CYCLE_MASK;
-               I915_WRITE(VLV_BLC_PWM_CTL(pipe), (0xf42 << 16) |
+               I915_WRITE(VLV_BLC_PWM_CTL(p), (0xf42 << 16) |
                           cur_val);
        }
 
-       ctl2 = I915_READ(VLV_BLC_PWM_CTL2(PIPE_A));
+       if (WARN_ON(pipe != PIPE_A && pipe != PIPE_B))
+               return -ENODEV;
+
+       ctl2 = I915_READ(VLV_BLC_PWM_CTL2(pipe));
        panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
 
-       ctl = I915_READ(VLV_BLC_PWM_CTL(PIPE_A));
+       ctl = I915_READ(VLV_BLC_PWM_CTL(pipe));
        panel->backlight.max = ctl >> 16;
        if (!panel->backlight.max)
                return -ENODEV;
 
        panel->backlight.min = get_backlight_min_vbt(connector);
 
-       val = _vlv_get_backlight(dev, PIPE_A);
+       val = _vlv_get_backlight(dev, pipe);
        panel->backlight.level = intel_panel_compute_brightness(connector, val);
 
        panel->backlight.enabled = (ctl2 & BLM_PWM_ENABLE) &&
        return 0;
 }
 
-int intel_panel_setup_backlight(struct drm_connector *connector)
+int intel_panel_setup_backlight(struct drm_connector *connector, enum pipe pipe)
 {
        struct drm_device *dev = connector->dev;
        struct drm_i915_private *dev_priv = dev->dev_private;
 
        /* set level and max in panel struct */
        mutex_lock(&dev_priv->backlight_lock);
-       ret = dev_priv->display.setup_backlight(intel_connector);
+       ret = dev_priv->display.setup_backlight(intel_connector, pipe);
        mutex_unlock(&dev_priv->backlight_lock);
 
        if (ret) {