blob: fecff3c2b9e18aecc13435262def62312cb60037 [file] [log] [blame]
Jesse Barnes79e53942008-11-07 14:24:08 -08001/*
2 * Copyright © 2006-2007 Intel Corporation
3 * Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Eric Anholt <eric@anholt.net>
26 * Dave Airlie <airlied@linux.ie>
27 * Jesse Barnes <jesse.barnes@intel.com>
28 */
29
Jesse Barnesc1c7af62009-09-10 15:28:03 -070030#include <acpi/button.h>
Paul Collins565dcd42009-02-04 23:05:41 +130031#include <linux/dmi.h>
Jesse Barnes79e53942008-11-07 14:24:08 -080032#include <linux/i2c.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/slab.h>
David Howells760285e2012-10-02 18:01:07 +010034#include <drm/drmP.h>
35#include <drm/drm_crtc.h>
36#include <drm/drm_edid.h>
Jesse Barnes79e53942008-11-07 14:24:08 -080037#include "intel_drv.h"
David Howells760285e2012-10-02 18:01:07 +010038#include <drm/i915_drm.h>
Jesse Barnes79e53942008-11-07 14:24:08 -080039#include "i915_drv.h"
Zhao Yakuie99da352009-06-26 09:46:18 +080040#include <linux/acpi.h>
Jesse Barnes79e53942008-11-07 14:24:08 -080041
Zhao Yakui3fbe18d2009-06-22 15:31:25 +080042/* Private structure for the integrated LVDS support */
Jani Nikulac7362c42012-10-19 14:51:44 +030043struct intel_lvds_connector {
44 struct intel_connector base;
Jani Nikuladb1740a2012-10-19 14:51:45 +030045
46 struct notifier_block lid_notifier;
Jani Nikulac7362c42012-10-19 14:51:44 +030047};
48
Jani Nikula29b99b42012-10-19 14:51:43 +030049struct intel_lvds_encoder {
Chris Wilsonea5b2132010-08-04 13:50:23 +010050 struct intel_encoder base;
Chris Wilson788319d2010-09-12 17:34:41 +010051
Daniel Vetter13c7d872012-11-26 17:22:10 +010052 bool is_dual_link;
Daniel Vetter7dec0602012-09-11 14:12:25 +020053 u32 reg;
Chris Wilson788319d2010-09-12 17:34:41 +010054
Jani Nikula62165e02012-10-19 14:51:47 +030055 struct intel_lvds_connector *attached_connector;
Zhao Yakui3fbe18d2009-06-22 15:31:25 +080056};
57
Jani Nikula29b99b42012-10-19 14:51:43 +030058static struct intel_lvds_encoder *to_lvds_encoder(struct drm_encoder *encoder)
Chris Wilsonea5b2132010-08-04 13:50:23 +010059{
Jani Nikula29b99b42012-10-19 14:51:43 +030060 return container_of(encoder, struct intel_lvds_encoder, base.base);
Chris Wilsonea5b2132010-08-04 13:50:23 +010061}
62
Jani Nikulac7362c42012-10-19 14:51:44 +030063static struct intel_lvds_connector *to_lvds_connector(struct drm_connector *connector)
Chris Wilson788319d2010-09-12 17:34:41 +010064{
Jani Nikulac7362c42012-10-19 14:51:44 +030065 return container_of(connector, struct intel_lvds_connector, base.base);
Chris Wilson788319d2010-09-12 17:34:41 +010066}
67
Daniel Vetterb1dc3322012-07-02 21:09:00 +020068static bool intel_lvds_get_hw_state(struct intel_encoder *encoder,
69 enum pipe *pipe)
70{
71 struct drm_device *dev = encoder->base.dev;
72 struct drm_i915_private *dev_priv = dev->dev_private;
Daniel Vetter7dec0602012-09-11 14:12:25 +020073 struct intel_lvds_encoder *lvds_encoder = to_lvds_encoder(&encoder->base);
74 u32 tmp;
Daniel Vetterb1dc3322012-07-02 21:09:00 +020075
Daniel Vetter7dec0602012-09-11 14:12:25 +020076 tmp = I915_READ(lvds_encoder->reg);
Daniel Vetterb1dc3322012-07-02 21:09:00 +020077
78 if (!(tmp & LVDS_PORT_EN))
79 return false;
80
81 if (HAS_PCH_CPT(dev))
82 *pipe = PORT_TO_PIPE_CPT(tmp);
83 else
84 *pipe = PORT_TO_PIPE(tmp);
85
86 return true;
87}
88
Jesse Barnes045ac3b2013-05-14 17:08:26 -070089static void intel_lvds_get_config(struct intel_encoder *encoder,
90 struct intel_crtc_config *pipe_config)
91{
92 struct drm_device *dev = encoder->base.dev;
93 struct drm_i915_private *dev_priv = dev->dev_private;
94 u32 lvds_reg, tmp, flags = 0;
Ville Syrjälä18442d02013-09-13 16:00:08 +030095 int dotclock;
Jesse Barnes045ac3b2013-05-14 17:08:26 -070096
97 if (HAS_PCH_SPLIT(dev))
98 lvds_reg = PCH_LVDS;
99 else
100 lvds_reg = LVDS;
101
102 tmp = I915_READ(lvds_reg);
103 if (tmp & LVDS_HSYNC_POLARITY)
104 flags |= DRM_MODE_FLAG_NHSYNC;
105 else
106 flags |= DRM_MODE_FLAG_PHSYNC;
107 if (tmp & LVDS_VSYNC_POLARITY)
108 flags |= DRM_MODE_FLAG_NVSYNC;
109 else
110 flags |= DRM_MODE_FLAG_PVSYNC;
111
112 pipe_config->adjusted_mode.flags |= flags;
Daniel Vetter06922822013-07-11 13:35:40 +0200113
114 /* gen2/3 store dither state in pfit control, needs to match */
115 if (INTEL_INFO(dev)->gen < 4) {
116 tmp = I915_READ(PFIT_CONTROL);
117
118 pipe_config->gmch_pfit.control |= tmp & PANEL_8TO6_DITHER_ENABLE;
119 }
Ville Syrjälä18442d02013-09-13 16:00:08 +0300120
121 dotclock = pipe_config->port_clock;
122
123 if (HAS_PCH_SPLIT(dev_priv->dev))
124 ironlake_check_encoder_dotclock(pipe_config, dotclock);
125
Damien Lespiau241bfc32013-09-25 16:45:37 +0100126 pipe_config->adjusted_mode.crtc_clock = dotclock;
Jesse Barnes045ac3b2013-05-14 17:08:26 -0700127}
128
Daniel Vetterfc683092012-11-26 17:22:12 +0100129/* The LVDS pin pair needs to be on before the DPLLs are enabled.
130 * This is an exception to the general rule that mode_set doesn't turn
131 * things on.
132 */
Daniel Vetterf6736a12013-06-05 13:34:30 +0200133static void intel_pre_enable_lvds(struct intel_encoder *encoder)
Daniel Vetterfc683092012-11-26 17:22:12 +0100134{
135 struct intel_lvds_encoder *lvds_encoder = to_lvds_encoder(&encoder->base);
136 struct drm_device *dev = encoder->base.dev;
137 struct drm_i915_private *dev_priv = dev->dev_private;
Daniel Vetter55607e82013-06-16 21:42:39 +0200138 struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
Ville Syrjälä4c6df4b2013-09-02 21:13:39 +0300139 const struct drm_display_mode *adjusted_mode =
140 &crtc->config.adjusted_mode;
Daniel Vetter55607e82013-06-16 21:42:39 +0200141 int pipe = crtc->pipe;
Daniel Vetterfc683092012-11-26 17:22:12 +0100142 u32 temp;
143
Daniel Vetter55607e82013-06-16 21:42:39 +0200144 if (HAS_PCH_SPLIT(dev)) {
145 assert_fdi_rx_pll_disabled(dev_priv, pipe);
146 assert_shared_dpll_disabled(dev_priv,
147 intel_crtc_to_shared_dpll(crtc));
148 } else {
149 assert_pll_disabled(dev_priv, pipe);
150 }
151
Daniel Vetterfc683092012-11-26 17:22:12 +0100152 temp = I915_READ(lvds_encoder->reg);
153 temp |= LVDS_PORT_EN | LVDS_A0A2_CLKA_POWER_UP;
Daniel Vetter62810e52012-11-26 17:22:13 +0100154
155 if (HAS_PCH_CPT(dev)) {
156 temp &= ~PORT_TRANS_SEL_MASK;
157 temp |= PORT_TRANS_SEL_CPT(pipe);
Daniel Vetterfc683092012-11-26 17:22:12 +0100158 } else {
Daniel Vetter62810e52012-11-26 17:22:13 +0100159 if (pipe == 1) {
160 temp |= LVDS_PIPEB_SELECT;
161 } else {
162 temp &= ~LVDS_PIPEB_SELECT;
163 }
Daniel Vetterfc683092012-11-26 17:22:12 +0100164 }
Daniel Vetter62810e52012-11-26 17:22:13 +0100165
Daniel Vetterfc683092012-11-26 17:22:12 +0100166 /* set the corresponsding LVDS_BORDER bit */
Daniel Vetter2fa2fe92013-05-07 23:34:16 +0200167 temp &= ~LVDS_BORDER_ENABLE;
Daniel Vetter55607e82013-06-16 21:42:39 +0200168 temp |= crtc->config.gmch_pfit.lvds_border_bits;
Daniel Vetterfc683092012-11-26 17:22:12 +0100169 /* Set the B0-B3 data pairs corresponding to whether we're going to
170 * set the DPLLs for dual-channel mode or not.
171 */
172 if (lvds_encoder->is_dual_link)
173 temp |= LVDS_B0B3_POWER_UP | LVDS_CLKB_POWER_UP;
174 else
175 temp &= ~(LVDS_B0B3_POWER_UP | LVDS_CLKB_POWER_UP);
176
177 /* It would be nice to set 24 vs 18-bit mode (LVDS_A3_POWER_UP)
178 * appropriately here, but we need to look more thoroughly into how
179 * panels behave in the two modes.
180 */
Daniel Vetter62810e52012-11-26 17:22:13 +0100181
182 /* Set the dithering flag on LVDS as needed, note that there is no
183 * special lvds dither control bit on pch-split platforms, dithering is
184 * only controlled through the PIPECONF reg. */
185 if (INTEL_INFO(dev)->gen == 4) {
Daniel Vetterd8b32242013-04-25 17:54:44 +0200186 /* Bspec wording suggests that LVDS port dithering only exists
187 * for 18bpp panels. */
Daniel Vetter55607e82013-06-16 21:42:39 +0200188 if (crtc->config.dither && crtc->config.pipe_bpp == 18)
Daniel Vetterfc683092012-11-26 17:22:12 +0100189 temp |= LVDS_ENABLE_DITHER;
190 else
191 temp &= ~LVDS_ENABLE_DITHER;
192 }
193 temp &= ~(LVDS_HSYNC_POLARITY | LVDS_VSYNC_POLARITY);
Ville Syrjälä4c6df4b2013-09-02 21:13:39 +0300194 if (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC)
Daniel Vetterfc683092012-11-26 17:22:12 +0100195 temp |= LVDS_HSYNC_POLARITY;
Ville Syrjälä4c6df4b2013-09-02 21:13:39 +0300196 if (adjusted_mode->flags & DRM_MODE_FLAG_NVSYNC)
Daniel Vetterfc683092012-11-26 17:22:12 +0100197 temp |= LVDS_VSYNC_POLARITY;
198
199 I915_WRITE(lvds_encoder->reg, temp);
200}
201
Jesse Barnes79e53942008-11-07 14:24:08 -0800202/**
Jesse Barnes79e53942008-11-07 14:24:08 -0800203 * Sets the power state for the panel.
204 */
Daniel Vetterc22834e2012-06-30 15:31:28 +0200205static void intel_enable_lvds(struct intel_encoder *encoder)
Jesse Barnes79e53942008-11-07 14:24:08 -0800206{
Daniel Vetterc22834e2012-06-30 15:31:28 +0200207 struct drm_device *dev = encoder->base.dev;
Jani Nikula29b99b42012-10-19 14:51:43 +0300208 struct intel_lvds_encoder *lvds_encoder = to_lvds_encoder(&encoder->base);
Jesse Barnes752aa882013-10-31 18:55:49 +0200209 struct intel_connector *intel_connector =
210 &lvds_encoder->attached_connector->base;
Jesse Barnes79e53942008-11-07 14:24:08 -0800211 struct drm_i915_private *dev_priv = dev->dev_private;
Daniel Vetter7dec0602012-09-11 14:12:25 +0200212 u32 ctl_reg, stat_reg;
Zhenyu Wang541998a2009-06-05 15:38:44 +0800213
Eric Anholtc619eed2010-01-28 16:45:52 -0800214 if (HAS_PCH_SPLIT(dev)) {
Zhenyu Wang541998a2009-06-05 15:38:44 +0800215 ctl_reg = PCH_PP_CONTROL;
Keith Packardde842ef2011-08-06 10:30:45 -0700216 stat_reg = PCH_PP_STATUS;
Zhenyu Wang541998a2009-06-05 15:38:44 +0800217 } else {
218 ctl_reg = PP_CONTROL;
Keith Packardde842ef2011-08-06 10:30:45 -0700219 stat_reg = PP_STATUS;
Zhenyu Wang541998a2009-06-05 15:38:44 +0800220 }
Jesse Barnes79e53942008-11-07 14:24:08 -0800221
Daniel Vetter7dec0602012-09-11 14:12:25 +0200222 I915_WRITE(lvds_encoder->reg, I915_READ(lvds_encoder->reg) | LVDS_PORT_EN);
Chris Wilsone9e331a2010-09-13 01:16:10 +0100223
Chris Wilson2a1292f2010-12-05 19:21:18 +0000224 I915_WRITE(ctl_reg, I915_READ(ctl_reg) | POWER_TARGET_ON);
Daniel Vetter7dec0602012-09-11 14:12:25 +0200225 POSTING_READ(lvds_encoder->reg);
Keith Packardde842ef2011-08-06 10:30:45 -0700226 if (wait_for((I915_READ(stat_reg) & PP_ON) != 0, 1000))
227 DRM_ERROR("timed out waiting for panel to power on\n");
Chris Wilson2a1292f2010-12-05 19:21:18 +0000228
Jesse Barnes752aa882013-10-31 18:55:49 +0200229 intel_panel_enable_backlight(intel_connector);
Chris Wilson2a1292f2010-12-05 19:21:18 +0000230}
231
Daniel Vetterc22834e2012-06-30 15:31:28 +0200232static void intel_disable_lvds(struct intel_encoder *encoder)
Chris Wilson2a1292f2010-12-05 19:21:18 +0000233{
Daniel Vetterc22834e2012-06-30 15:31:28 +0200234 struct drm_device *dev = encoder->base.dev;
Jani Nikula29b99b42012-10-19 14:51:43 +0300235 struct intel_lvds_encoder *lvds_encoder = to_lvds_encoder(&encoder->base);
Jesse Barnes752aa882013-10-31 18:55:49 +0200236 struct intel_connector *intel_connector =
237 &lvds_encoder->attached_connector->base;
Chris Wilson2a1292f2010-12-05 19:21:18 +0000238 struct drm_i915_private *dev_priv = dev->dev_private;
Daniel Vetter7dec0602012-09-11 14:12:25 +0200239 u32 ctl_reg, stat_reg;
Chris Wilson2a1292f2010-12-05 19:21:18 +0000240
241 if (HAS_PCH_SPLIT(dev)) {
242 ctl_reg = PCH_PP_CONTROL;
Keith Packardde842ef2011-08-06 10:30:45 -0700243 stat_reg = PCH_PP_STATUS;
Chris Wilson2a1292f2010-12-05 19:21:18 +0000244 } else {
245 ctl_reg = PP_CONTROL;
Keith Packardde842ef2011-08-06 10:30:45 -0700246 stat_reg = PP_STATUS;
Chris Wilson2a1292f2010-12-05 19:21:18 +0000247 }
248
Jesse Barnes752aa882013-10-31 18:55:49 +0200249 intel_panel_disable_backlight(intel_connector);
Chris Wilson2a1292f2010-12-05 19:21:18 +0000250
251 I915_WRITE(ctl_reg, I915_READ(ctl_reg) & ~POWER_TARGET_ON);
Keith Packardde842ef2011-08-06 10:30:45 -0700252 if (wait_for((I915_READ(stat_reg) & PP_ON) == 0, 1000))
253 DRM_ERROR("timed out waiting for panel to power off\n");
Chris Wilson2a1292f2010-12-05 19:21:18 +0000254
Daniel Vetter7dec0602012-09-11 14:12:25 +0200255 I915_WRITE(lvds_encoder->reg, I915_READ(lvds_encoder->reg) & ~LVDS_PORT_EN);
256 POSTING_READ(lvds_encoder->reg);
Jesse Barnes79e53942008-11-07 14:24:08 -0800257}
258
Damien Lespiauc19de8e2013-11-28 15:29:18 +0000259static enum drm_mode_status
260intel_lvds_mode_valid(struct drm_connector *connector,
261 struct drm_display_mode *mode)
Jesse Barnes79e53942008-11-07 14:24:08 -0800262{
Jani Nikuladd06f902012-10-19 14:51:50 +0300263 struct intel_connector *intel_connector = to_intel_connector(connector);
264 struct drm_display_mode *fixed_mode = intel_connector->panel.fixed_mode;
Jesse Barnes79e53942008-11-07 14:24:08 -0800265
Chris Wilson788319d2010-09-12 17:34:41 +0100266 if (mode->hdisplay > fixed_mode->hdisplay)
267 return MODE_PANEL;
268 if (mode->vdisplay > fixed_mode->vdisplay)
269 return MODE_PANEL;
Jesse Barnes79e53942008-11-07 14:24:08 -0800270
271 return MODE_OK;
272}
273
Daniel Vetter7ae89232013-03-27 00:44:52 +0100274static bool intel_lvds_compute_config(struct intel_encoder *intel_encoder,
275 struct intel_crtc_config *pipe_config)
Jesse Barnes79e53942008-11-07 14:24:08 -0800276{
Daniel Vetter7ae89232013-03-27 00:44:52 +0100277 struct drm_device *dev = intel_encoder->base.dev;
Jesse Barnes79e53942008-11-07 14:24:08 -0800278 struct drm_i915_private *dev_priv = dev->dev_private;
Daniel Vetter7ae89232013-03-27 00:44:52 +0100279 struct intel_lvds_encoder *lvds_encoder =
280 to_lvds_encoder(&intel_encoder->base);
Jani Nikula4d891522012-10-26 12:03:59 +0300281 struct intel_connector *intel_connector =
282 &lvds_encoder->attached_connector->base;
Daniel Vetter7ae89232013-03-27 00:44:52 +0100283 struct drm_display_mode *adjusted_mode = &pipe_config->adjusted_mode;
Jani Nikula29b99b42012-10-19 14:51:43 +0300284 struct intel_crtc *intel_crtc = lvds_encoder->base.new_crtc;
Daniel Vetter4e53c2e2013-03-27 00:44:58 +0100285 unsigned int lvds_bpp;
Jesse Barnes79e53942008-11-07 14:24:08 -0800286
287 /* Should never happen!! */
Chris Wilsona6c45cf2010-09-17 00:32:17 +0100288 if (INTEL_INFO(dev)->gen < 4 && intel_crtc->pipe == 0) {
Keith Packard1ae8c0a2009-06-28 15:42:17 -0700289 DRM_ERROR("Can't support LVDS on pipe A\n");
Jesse Barnes79e53942008-11-07 14:24:08 -0800290 return false;
291 }
292
Daniel Vetter4e53c2e2013-03-27 00:44:58 +0100293 if ((I915_READ(lvds_encoder->reg) & LVDS_A3_POWER_MASK) ==
294 LVDS_A3_POWER_UP)
295 lvds_bpp = 8*3;
296 else
297 lvds_bpp = 6*3;
298
Daniel Vettere29c22c2013-02-21 00:00:16 +0100299 if (lvds_bpp != pipe_config->pipe_bpp && !pipe_config->bw_constrained) {
Daniel Vetter4e53c2e2013-03-27 00:44:58 +0100300 DRM_DEBUG_KMS("forcing display bpp (was %d) to LVDS (%d)\n",
301 pipe_config->pipe_bpp, lvds_bpp);
302 pipe_config->pipe_bpp = lvds_bpp;
303 }
Daniel Vetterd8b32242013-04-25 17:54:44 +0200304
Jesse Barnes79e53942008-11-07 14:24:08 -0800305 /*
Chris Wilson71677042010-07-17 13:38:43 +0100306 * We have timings from the BIOS for the panel, put them in
Jesse Barnes79e53942008-11-07 14:24:08 -0800307 * to the adjusted mode. The CRTC will be set up for this mode,
308 * with the panel scaling set up to source from the H/VDisplay
309 * of the original mode.
310 */
Jani Nikula4d891522012-10-26 12:03:59 +0300311 intel_fixed_panel_mode(intel_connector->panel.fixed_mode,
Jani Nikuladd06f902012-10-19 14:51:50 +0300312 adjusted_mode);
Chris Wilson1d8e1c72010-08-07 11:01:28 +0100313
314 if (HAS_PCH_SPLIT(dev)) {
Daniel Vetter5bfe2ac2013-03-27 00:44:55 +0100315 pipe_config->has_pch_encoder = true;
316
Jesse Barnesb074cec2013-04-25 12:55:02 -0700317 intel_pch_panel_fitting(intel_crtc, pipe_config,
318 intel_connector->panel.fitting_mode);
Jesse Barnes2dd24552013-04-25 12:55:01 -0700319 } else {
320 intel_gmch_panel_fitting(intel_crtc, pipe_config,
321 intel_connector->panel.fitting_mode);
Jesse Barnes79e53942008-11-07 14:24:08 -0800322
Daniel Vetter21d8a472013-07-12 08:07:30 +0200323 }
Daniel Vetterf9bef082012-04-15 19:53:19 +0200324
Zhao Yakuia3e17eb2009-10-10 10:42:37 +0800325 /*
Jesse Barnes79e53942008-11-07 14:24:08 -0800326 * XXX: It would be nice to support lower refresh rates on the
327 * panels to reduce power consumption, and perhaps match the
328 * user's requested refresh rate.
329 */
330
331 return true;
332}
333
Daniel Vetter66df24d2013-07-21 21:37:06 +0200334static void intel_lvds_mode_set(struct intel_encoder *encoder)
Jesse Barnes79e53942008-11-07 14:24:08 -0800335{
Jesse Barnes79e53942008-11-07 14:24:08 -0800336 /*
Daniel Vetter66df24d2013-07-21 21:37:06 +0200337 * We don't do anything here, the LVDS port is fully set up in the pre
338 * enable hook - the ordering constraints for enabling the lvds port vs.
339 * enabling the display pll are too strict.
Jesse Barnes79e53942008-11-07 14:24:08 -0800340 */
Jesse Barnes79e53942008-11-07 14:24:08 -0800341}
342
343/**
344 * Detect the LVDS connection.
345 *
Jesse Barnesb42d4c52009-09-10 15:28:04 -0700346 * Since LVDS doesn't have hotlug, we use the lid as a proxy. Open means
347 * connected and closed means disconnected. We also send hotplug events as
348 * needed, using lid status notification from the input layer.
Jesse Barnes79e53942008-11-07 14:24:08 -0800349 */
Chris Wilson7b334fc2010-09-09 23:51:02 +0100350static enum drm_connector_status
Chris Wilson930a9e22010-09-14 11:07:23 +0100351intel_lvds_detect(struct drm_connector *connector, bool force)
Jesse Barnes79e53942008-11-07 14:24:08 -0800352{
Jesse Barnes7b9c5ab2010-02-12 09:30:00 -0800353 struct drm_device *dev = connector->dev;
Chris Wilson6ee3b5a2011-03-24 13:26:43 +0000354 enum drm_connector_status status;
Jesse Barnesb42d4c52009-09-10 15:28:04 -0700355
Chris Wilson164c8592013-07-20 20:27:08 +0100356 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
357 connector->base.id, drm_get_connector_name(connector));
358
Chris Wilsonfe16d942011-02-12 10:29:38 +0000359 status = intel_panel_detect(dev);
360 if (status != connector_status_unknown)
361 return status;
Chris Wilson01fe9db2011-01-16 19:37:30 +0000362
Chris Wilson6ee3b5a2011-03-24 13:26:43 +0000363 return connector_status_connected;
Jesse Barnes79e53942008-11-07 14:24:08 -0800364}
365
366/**
367 * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
368 */
369static int intel_lvds_get_modes(struct drm_connector *connector)
370{
Jani Nikula62165e02012-10-19 14:51:47 +0300371 struct intel_lvds_connector *lvds_connector = to_lvds_connector(connector);
Jesse Barnes79e53942008-11-07 14:24:08 -0800372 struct drm_device *dev = connector->dev;
Chris Wilson788319d2010-09-12 17:34:41 +0100373 struct drm_display_mode *mode;
Jesse Barnes79e53942008-11-07 14:24:08 -0800374
Jani Nikula9cd300e2012-10-19 14:51:52 +0300375 /* use cached edid if we have one */
Chris Wilson2aa4f092012-11-21 16:14:04 +0000376 if (!IS_ERR_OR_NULL(lvds_connector->base.edid))
Jani Nikula9cd300e2012-10-19 14:51:52 +0300377 return drm_add_edid_modes(connector, lvds_connector->base.edid);
Jesse Barnes79e53942008-11-07 14:24:08 -0800378
Jani Nikuladd06f902012-10-19 14:51:50 +0300379 mode = drm_mode_duplicate(dev, lvds_connector->base.panel.fixed_mode);
Chris Wilson311bd682011-01-13 19:06:50 +0000380 if (mode == NULL)
Chris Wilson788319d2010-09-12 17:34:41 +0100381 return 0;
Jesse Barnes79e53942008-11-07 14:24:08 -0800382
Chris Wilson788319d2010-09-12 17:34:41 +0100383 drm_mode_probed_add(connector, mode);
384 return 1;
Jesse Barnes79e53942008-11-07 14:24:08 -0800385}
386
Thomas Bächler0544edf2010-07-02 10:44:23 +0200387static int intel_no_modeset_on_lid_dmi_callback(const struct dmi_system_id *id)
388{
Daniel Vetterbc0daf42012-04-01 13:16:49 +0200389 DRM_INFO("Skipping forced modeset for %s\n", id->ident);
Thomas Bächler0544edf2010-07-02 10:44:23 +0200390 return 1;
391}
392
393/* The GPU hangs up on these systems if modeset is performed on LID open */
394static const struct dmi_system_id intel_no_modeset_on_lid[] = {
395 {
396 .callback = intel_no_modeset_on_lid_dmi_callback,
397 .ident = "Toshiba Tecra A11",
398 .matches = {
399 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
400 DMI_MATCH(DMI_PRODUCT_NAME, "TECRA A11"),
401 },
402 },
403
404 { } /* terminating entry */
405};
406
Linus Torvaldsc9354c82009-11-02 09:29:55 -0800407/*
Zhang Ruib8efb172013-02-05 15:41:53 +0800408 * Lid events. Note the use of 'modeset':
409 * - we set it to MODESET_ON_LID_OPEN on lid close,
410 * and set it to MODESET_DONE on open
Linus Torvaldsc9354c82009-11-02 09:29:55 -0800411 * - we use it as a "only once" bit (ie we ignore
Zhang Ruib8efb172013-02-05 15:41:53 +0800412 * duplicate events where it was already properly set)
413 * - the suspend/resume paths will set it to
414 * MODESET_SUSPENDED and ignore the lid open event,
415 * because they restore the mode ("lid open").
Linus Torvaldsc9354c82009-11-02 09:29:55 -0800416 */
Jesse Barnesc1c7af62009-09-10 15:28:03 -0700417static int intel_lid_notify(struct notifier_block *nb, unsigned long val,
418 void *unused)
419{
Jani Nikuladb1740a2012-10-19 14:51:45 +0300420 struct intel_lvds_connector *lvds_connector =
421 container_of(nb, struct intel_lvds_connector, lid_notifier);
422 struct drm_connector *connector = &lvds_connector->base.base;
423 struct drm_device *dev = connector->dev;
424 struct drm_i915_private *dev_priv = dev->dev_private;
Jesse Barnesc1c7af62009-09-10 15:28:03 -0700425
Alex Williamson2fb4e612011-04-21 16:08:14 -0600426 if (dev->switch_power_state != DRM_SWITCH_POWER_ON)
427 return NOTIFY_OK;
428
Zhang Ruib8efb172013-02-05 15:41:53 +0800429 mutex_lock(&dev_priv->modeset_restore_lock);
430 if (dev_priv->modeset_restore == MODESET_SUSPENDED)
431 goto exit;
Zhao Yakuia2565372009-12-11 09:26:11 +0800432 /*
433 * check and update the status of LVDS connector after receiving
434 * the LID nofication event.
435 */
Jani Nikuladb1740a2012-10-19 14:51:45 +0300436 connector->status = connector->funcs->detect(connector, false);
Chris Wilson7b334fc2010-09-09 23:51:02 +0100437
Thomas Bächler0544edf2010-07-02 10:44:23 +0200438 /* Don't force modeset on machines where it causes a GPU lockup */
439 if (dmi_check_system(intel_no_modeset_on_lid))
Zhang Ruib8efb172013-02-05 15:41:53 +0800440 goto exit;
Linus Torvaldsc9354c82009-11-02 09:29:55 -0800441 if (!acpi_lid_open()) {
Zhang Ruib8efb172013-02-05 15:41:53 +0800442 /* do modeset on next lid open event */
443 dev_priv->modeset_restore = MODESET_ON_LID_OPEN;
444 goto exit;
Jesse Barnes06891e22009-09-14 10:58:48 -0700445 }
Jesse Barnesc1c7af62009-09-10 15:28:03 -0700446
Zhang Ruib8efb172013-02-05 15:41:53 +0800447 if (dev_priv->modeset_restore == MODESET_DONE)
448 goto exit;
Linus Torvaldsc9354c82009-11-02 09:29:55 -0800449
Daniel Vetter5be19d92013-10-09 10:47:12 +0200450 /*
451 * Some old platform's BIOS love to wreak havoc while the lid is closed.
452 * We try to detect this here and undo any damage. The split for PCH
453 * platforms is rather conservative and a bit arbitrary expect that on
454 * those platforms VGA disabling requires actual legacy VGA I/O access,
455 * and as part of the cleanup in the hw state restore we also redisable
456 * the vga plane.
457 */
458 if (!HAS_PCH_SPLIT(dev)) {
459 drm_modeset_lock_all(dev);
460 intel_modeset_setup_hw_state(dev, true);
461 drm_modeset_unlock_all(dev);
462 }
Jesse Barnes06324192009-09-10 15:28:05 -0700463
Zhang Ruib8efb172013-02-05 15:41:53 +0800464 dev_priv->modeset_restore = MODESET_DONE;
465
466exit:
467 mutex_unlock(&dev_priv->modeset_restore_lock);
Jesse Barnesc1c7af62009-09-10 15:28:03 -0700468 return NOTIFY_OK;
469}
470
Jesse Barnes79e53942008-11-07 14:24:08 -0800471/**
472 * intel_lvds_destroy - unregister and free LVDS structures
473 * @connector: connector to free
474 *
475 * Unregister the DDC bus for this connector then free the driver private
476 * structure.
477 */
478static void intel_lvds_destroy(struct drm_connector *connector)
479{
Jani Nikuladb1740a2012-10-19 14:51:45 +0300480 struct intel_lvds_connector *lvds_connector =
481 to_lvds_connector(connector);
Jesse Barnes79e53942008-11-07 14:24:08 -0800482
Jani Nikuladb1740a2012-10-19 14:51:45 +0300483 if (lvds_connector->lid_notifier.notifier_call)
484 acpi_lid_notifier_unregister(&lvds_connector->lid_notifier);
Matthew Garrettaaa6fd22011-08-12 12:11:33 +0200485
Jani Nikula9cd300e2012-10-19 14:51:52 +0300486 if (!IS_ERR_OR_NULL(lvds_connector->base.edid))
487 kfree(lvds_connector->base.edid);
488
Jani Nikula1d508702012-10-19 14:51:49 +0300489 intel_panel_fini(&lvds_connector->base.panel);
Jani Nikuladb1740a2012-10-19 14:51:45 +0300490
Jesse Barnes79e53942008-11-07 14:24:08 -0800491 drm_connector_cleanup(connector);
492 kfree(connector);
493}
494
Jesse Barnes335041e2009-01-22 22:22:06 +1000495static int intel_lvds_set_property(struct drm_connector *connector,
496 struct drm_property *property,
497 uint64_t value)
498{
Jani Nikula4d891522012-10-26 12:03:59 +0300499 struct intel_connector *intel_connector = to_intel_connector(connector);
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800500 struct drm_device *dev = connector->dev;
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800501
Chris Wilson788319d2010-09-12 17:34:41 +0100502 if (property == dev->mode_config.scaling_mode_property) {
Jani Nikula62165e02012-10-19 14:51:47 +0300503 struct drm_crtc *crtc;
Zhenyu Wangbb8a3562010-03-29 16:40:50 +0800504
Jesse Barnes53bd8382009-07-01 10:04:40 -0700505 if (value == DRM_MODE_SCALE_NONE) {
506 DRM_DEBUG_KMS("no scaling not supported\n");
Chris Wilson788319d2010-09-12 17:34:41 +0100507 return -EINVAL;
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800508 }
Chris Wilson788319d2010-09-12 17:34:41 +0100509
Jani Nikula4d891522012-10-26 12:03:59 +0300510 if (intel_connector->panel.fitting_mode == value) {
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800511 /* the LVDS scaling property is not changed */
512 return 0;
513 }
Jani Nikula4d891522012-10-26 12:03:59 +0300514 intel_connector->panel.fitting_mode = value;
Jani Nikula62165e02012-10-19 14:51:47 +0300515
516 crtc = intel_attached_encoder(connector)->base.crtc;
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800517 if (crtc && crtc->enabled) {
518 /*
519 * If the CRTC is enabled, the display will be changed
520 * according to the new panel fitting mode.
521 */
Chris Wilsonc0c36b942012-12-19 16:08:43 +0000522 intel_crtc_restore_mode(crtc);
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800523 }
524 }
525
Jesse Barnes335041e2009-01-22 22:22:06 +1000526 return 0;
527}
528
Jesse Barnes79e53942008-11-07 14:24:08 -0800529static const struct drm_connector_helper_funcs intel_lvds_connector_helper_funcs = {
530 .get_modes = intel_lvds_get_modes,
531 .mode_valid = intel_lvds_mode_valid,
Chris Wilsondf0e9242010-09-09 16:20:55 +0100532 .best_encoder = intel_best_encoder,
Jesse Barnes79e53942008-11-07 14:24:08 -0800533};
534
535static const struct drm_connector_funcs intel_lvds_connector_funcs = {
Daniel Vetterc22834e2012-06-30 15:31:28 +0200536 .dpms = intel_connector_dpms,
Jesse Barnes79e53942008-11-07 14:24:08 -0800537 .detect = intel_lvds_detect,
538 .fill_modes = drm_helper_probe_single_connector_modes,
Jesse Barnes335041e2009-01-22 22:22:06 +1000539 .set_property = intel_lvds_set_property,
Jesse Barnes79e53942008-11-07 14:24:08 -0800540 .destroy = intel_lvds_destroy,
541};
542
Jesse Barnes79e53942008-11-07 14:24:08 -0800543static const struct drm_encoder_funcs intel_lvds_enc_funcs = {
Chris Wilsonea5b2132010-08-04 13:50:23 +0100544 .destroy = intel_encoder_destroy,
Jesse Barnes79e53942008-11-07 14:24:08 -0800545};
546
Jarod Wilson425d2442009-05-05 10:00:25 -0400547static int __init intel_no_lvds_dmi_callback(const struct dmi_system_id *id)
548{
Daniel Vetterbc0daf42012-04-01 13:16:49 +0200549 DRM_INFO("Skipping LVDS initialization for %s\n", id->ident);
Jarod Wilson425d2442009-05-05 10:00:25 -0400550 return 1;
551}
Jesse Barnes79e53942008-11-07 14:24:08 -0800552
Jarod Wilson425d2442009-05-05 10:00:25 -0400553/* These systems claim to have LVDS, but really don't */
Jaswinder Singh Rajput93c05f22009-06-04 09:41:19 +1000554static const struct dmi_system_id intel_no_lvds[] = {
Jarod Wilson425d2442009-05-05 10:00:25 -0400555 {
556 .callback = intel_no_lvds_dmi_callback,
557 .ident = "Apple Mac Mini (Core series)",
558 .matches = {
Keith Packard98acd462009-06-14 12:31:58 -0700559 DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
Jarod Wilson425d2442009-05-05 10:00:25 -0400560 DMI_MATCH(DMI_PRODUCT_NAME, "Macmini1,1"),
561 },
562 },
563 {
564 .callback = intel_no_lvds_dmi_callback,
565 .ident = "Apple Mac Mini (Core 2 series)",
566 .matches = {
Keith Packard98acd462009-06-14 12:31:58 -0700567 DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
Jarod Wilson425d2442009-05-05 10:00:25 -0400568 DMI_MATCH(DMI_PRODUCT_NAME, "Macmini2,1"),
569 },
570 },
571 {
572 .callback = intel_no_lvds_dmi_callback,
573 .ident = "MSI IM-945GSE-A",
574 .matches = {
575 DMI_MATCH(DMI_SYS_VENDOR, "MSI"),
576 DMI_MATCH(DMI_PRODUCT_NAME, "A9830IMS"),
577 },
578 },
579 {
580 .callback = intel_no_lvds_dmi_callback,
581 .ident = "Dell Studio Hybrid",
582 .matches = {
583 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
584 DMI_MATCH(DMI_PRODUCT_NAME, "Studio Hybrid 140g"),
585 },
586 },
Jarod Wilson70aa96c2009-05-27 17:20:39 -0400587 {
588 .callback = intel_no_lvds_dmi_callback,
Pieterjan Camerlynckb0662542011-07-26 16:23:54 +0200589 .ident = "Dell OptiPlex FX170",
590 .matches = {
591 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
592 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex FX170"),
593 },
594 },
595 {
596 .callback = intel_no_lvds_dmi_callback,
Jarod Wilson70aa96c2009-05-27 17:20:39 -0400597 .ident = "AOpen Mini PC",
598 .matches = {
599 DMI_MATCH(DMI_SYS_VENDOR, "AOpen"),
600 DMI_MATCH(DMI_PRODUCT_NAME, "i965GMx-IF"),
601 },
602 },
Michael Cousinfa0864b2009-06-05 21:16:22 +0200603 {
604 .callback = intel_no_lvds_dmi_callback,
Tormod Voldened8c7542009-07-13 22:26:48 +0200605 .ident = "AOpen Mini PC MP915",
606 .matches = {
607 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
608 DMI_MATCH(DMI_BOARD_NAME, "i915GMx-F"),
609 },
610 },
611 {
612 .callback = intel_no_lvds_dmi_callback,
Knut Petersen22ab70d2011-01-14 15:38:10 +0000613 .ident = "AOpen i915GMm-HFS",
614 .matches = {
615 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
616 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
617 },
618 },
619 {
620 .callback = intel_no_lvds_dmi_callback,
Daniel Vettere57b6882012-02-08 16:42:52 +0100621 .ident = "AOpen i45GMx-I",
622 .matches = {
623 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
624 DMI_MATCH(DMI_BOARD_NAME, "i45GMx-I"),
625 },
626 },
627 {
628 .callback = intel_no_lvds_dmi_callback,
Michael Cousinfa0864b2009-06-05 21:16:22 +0200629 .ident = "Aopen i945GTt-VFA",
630 .matches = {
631 DMI_MATCH(DMI_PRODUCT_VERSION, "AO00001JW"),
632 },
633 },
Stefan Bader9875557ee82010-03-29 17:53:12 +0200634 {
635 .callback = intel_no_lvds_dmi_callback,
636 .ident = "Clientron U800",
637 .matches = {
638 DMI_MATCH(DMI_SYS_VENDOR, "Clientron"),
639 DMI_MATCH(DMI_PRODUCT_NAME, "U800"),
640 },
641 },
Hans de Goede6a574b52011-06-04 15:39:21 +0200642 {
Joel Sass44306ab2012-01-10 13:03:55 -0500643 .callback = intel_no_lvds_dmi_callback,
644 .ident = "Clientron E830",
645 .matches = {
646 DMI_MATCH(DMI_SYS_VENDOR, "Clientron"),
647 DMI_MATCH(DMI_PRODUCT_NAME, "E830"),
648 },
649 },
650 {
Hans de Goede6a574b52011-06-04 15:39:21 +0200651 .callback = intel_no_lvds_dmi_callback,
652 .ident = "Asus EeeBox PC EB1007",
653 .matches = {
654 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer INC."),
655 DMI_MATCH(DMI_PRODUCT_NAME, "EB1007"),
656 },
657 },
Adam Jackson0999bbe2011-11-28 12:22:56 -0500658 {
659 .callback = intel_no_lvds_dmi_callback,
660 .ident = "Asus AT5NM10T-I",
661 .matches = {
662 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
663 DMI_MATCH(DMI_BOARD_NAME, "AT5NM10T-I"),
664 },
665 },
Marc Gariepyf5b8a7e2012-02-09 09:35:21 -0500666 {
667 .callback = intel_no_lvds_dmi_callback,
Ben Mesman45a211d2013-04-16 20:00:28 +0200668 .ident = "Hewlett-Packard HP t5740",
Jan-Benedict Glaw33471112012-05-22 15:21:53 +0200669 .matches = {
670 DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
Ben Mesman45a211d2013-04-16 20:00:28 +0200671 DMI_MATCH(DMI_PRODUCT_NAME, " t5740"),
Jan-Benedict Glaw33471112012-05-22 15:21:53 +0200672 },
673 },
674 {
675 .callback = intel_no_lvds_dmi_callback,
Marc Gariepyf5b8a7e2012-02-09 09:35:21 -0500676 .ident = "Hewlett-Packard t5745",
677 .matches = {
678 DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
Marc Gariepy62004972012-05-01 13:37:57 -0400679 DMI_MATCH(DMI_PRODUCT_NAME, "hp t5745"),
Marc Gariepyf5b8a7e2012-02-09 09:35:21 -0500680 },
681 },
682 {
683 .callback = intel_no_lvds_dmi_callback,
684 .ident = "Hewlett-Packard st5747",
685 .matches = {
686 DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
Marc Gariepy62004972012-05-01 13:37:57 -0400687 DMI_MATCH(DMI_PRODUCT_NAME, "hp st5747"),
Marc Gariepyf5b8a7e2012-02-09 09:35:21 -0500688 },
689 },
Anisse Astier97effad2012-03-07 18:36:35 +0100690 {
691 .callback = intel_no_lvds_dmi_callback,
692 .ident = "MSI Wind Box DC500",
693 .matches = {
694 DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"),
695 DMI_MATCH(DMI_BOARD_NAME, "MS-7469"),
696 },
697 },
Sjoerd Simons9756fe32012-06-22 09:43:07 +0200698 {
699 .callback = intel_no_lvds_dmi_callback,
Calvin Waltona51d4ed2012-08-24 07:56:31 -0400700 .ident = "Gigabyte GA-D525TUD",
701 .matches = {
702 DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
703 DMI_MATCH(DMI_BOARD_NAME, "D525TUD"),
704 },
705 },
Chris Wilsonc31407a2012-10-18 21:07:01 +0100706 {
707 .callback = intel_no_lvds_dmi_callback,
708 .ident = "Supermicro X7SPA-H",
709 .matches = {
710 DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
711 DMI_MATCH(DMI_PRODUCT_NAME, "X7SPA-H"),
712 },
713 },
Christian Lamparter9e9dd0e2013-04-03 14:34:11 +0200714 {
715 .callback = intel_no_lvds_dmi_callback,
716 .ident = "Fujitsu Esprimo Q900",
717 .matches = {
718 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
719 DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Q900"),
720 },
721 },
Chris Wilsone5614f02013-07-03 15:05:03 -0700722 {
723 .callback = intel_no_lvds_dmi_callback,
Rob Pearce645378d2013-10-27 16:13:42 +0000724 .ident = "Intel D410PT",
725 .matches = {
726 DMI_MATCH(DMI_BOARD_VENDOR, "Intel"),
727 DMI_MATCH(DMI_BOARD_NAME, "D410PT"),
728 },
729 },
730 {
731 .callback = intel_no_lvds_dmi_callback,
732 .ident = "Intel D425KT",
733 .matches = {
734 DMI_MATCH(DMI_BOARD_VENDOR, "Intel"),
735 DMI_EXACT_MATCH(DMI_BOARD_NAME, "D425KT"),
736 },
737 },
738 {
739 .callback = intel_no_lvds_dmi_callback,
Chris Wilsone5614f02013-07-03 15:05:03 -0700740 .ident = "Intel D510MO",
741 .matches = {
742 DMI_MATCH(DMI_BOARD_VENDOR, "Intel"),
743 DMI_EXACT_MATCH(DMI_BOARD_NAME, "D510MO"),
744 },
745 },
Jani Nikuladcf6d292013-07-03 15:05:05 -0700746 {
747 .callback = intel_no_lvds_dmi_callback,
748 .ident = "Intel D525MW",
749 .matches = {
750 DMI_MATCH(DMI_BOARD_VENDOR, "Intel"),
751 DMI_EXACT_MATCH(DMI_BOARD_NAME, "D525MW"),
752 },
753 },
Jarod Wilson425d2442009-05-05 10:00:25 -0400754
755 { } /* terminating entry */
756};
Jesse Barnes79e53942008-11-07 14:24:08 -0800757
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800758/*
759 * Enumerate the child dev array parsed from VBT to check whether
760 * the LVDS is present.
761 * If it is present, return 1.
762 * If it is not present, return false.
763 * If no child dev is parsed from VBT, it assumes that the LVDS is present.
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800764 */
Chris Wilson270eea02010-09-24 01:15:02 +0100765static bool lvds_is_present_in_vbt(struct drm_device *dev,
766 u8 *i2c_pin)
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800767{
768 struct drm_i915_private *dev_priv = dev->dev_private;
Chris Wilson425904d2010-08-22 18:21:42 +0100769 int i;
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800770
Rodrigo Vivi41aa3442013-05-09 20:03:18 -0300771 if (!dev_priv->vbt.child_dev_num)
Chris Wilson425904d2010-08-22 18:21:42 +0100772 return true;
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800773
Rodrigo Vivi41aa3442013-05-09 20:03:18 -0300774 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) {
Paulo Zanoni768f69c2013-09-11 18:02:47 -0300775 union child_device_config *uchild = dev_priv->vbt.child_dev + i;
776 struct old_child_dev_config *child = &uchild->old;
Chris Wilson425904d2010-08-22 18:21:42 +0100777
778 /* If the device type is not LFP, continue.
779 * We have to check both the new identifiers as well as the
780 * old for compatibility with some BIOSes.
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800781 */
Chris Wilson425904d2010-08-22 18:21:42 +0100782 if (child->device_type != DEVICE_TYPE_INT_LFP &&
783 child->device_type != DEVICE_TYPE_LFP)
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800784 continue;
785
Daniel Kurtz3bd7d902012-03-28 02:36:14 +0800786 if (intel_gmbus_is_port_valid(child->i2c_pin))
787 *i2c_pin = child->i2c_pin;
Chris Wilson270eea02010-09-24 01:15:02 +0100788
Chris Wilson425904d2010-08-22 18:21:42 +0100789 /* However, we cannot trust the BIOS writers to populate
790 * the VBT correctly. Since LVDS requires additional
791 * information from AIM blocks, a non-zero addin offset is
792 * a good indicator that the LVDS is actually present.
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800793 */
Chris Wilson425904d2010-08-22 18:21:42 +0100794 if (child->addin_offset)
795 return true;
796
797 /* But even then some BIOS writers perform some black magic
798 * and instantiate the device without reference to any
799 * additional data. Trust that if the VBT was written into
800 * the OpRegion then they have validated the LVDS's existence.
801 */
802 if (dev_priv->opregion.vbt)
803 return true;
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800804 }
Chris Wilson425904d2010-08-22 18:21:42 +0100805
806 return false;
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800807}
808
Daniel Vetter1974cad2012-11-26 17:22:09 +0100809static int intel_dual_link_lvds_callback(const struct dmi_system_id *id)
810{
811 DRM_INFO("Forcing lvds to dual link mode on %s\n", id->ident);
812 return 1;
813}
814
815static const struct dmi_system_id intel_dual_link_lvds[] = {
816 {
817 .callback = intel_dual_link_lvds_callback,
818 .ident = "Apple MacBook Pro (Core i5/i7 Series)",
819 .matches = {
820 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
821 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro8,2"),
822 },
823 },
824 { } /* terminating entry */
825};
826
827bool intel_is_dual_link_lvds(struct drm_device *dev)
828{
Daniel Vetter13c7d872012-11-26 17:22:10 +0100829 struct intel_encoder *encoder;
830 struct intel_lvds_encoder *lvds_encoder;
831
832 list_for_each_entry(encoder, &dev->mode_config.encoder_list,
833 base.head) {
834 if (encoder->type == INTEL_OUTPUT_LVDS) {
835 lvds_encoder = to_lvds_encoder(&encoder->base);
836
837 return lvds_encoder->is_dual_link;
838 }
839 }
840
841 return false;
842}
843
Daniel Vetter7dec0602012-09-11 14:12:25 +0200844static bool compute_is_dual_link_lvds(struct intel_lvds_encoder *lvds_encoder)
Daniel Vetter13c7d872012-11-26 17:22:10 +0100845{
Daniel Vetter7dec0602012-09-11 14:12:25 +0200846 struct drm_device *dev = lvds_encoder->base.base.dev;
Daniel Vetter1974cad2012-11-26 17:22:09 +0100847 unsigned int val;
848 struct drm_i915_private *dev_priv = dev->dev_private;
Daniel Vetter1974cad2012-11-26 17:22:09 +0100849
850 /* use the module option value if specified */
Jani Nikulad330a952014-01-21 11:24:25 +0200851 if (i915.lvds_channel_mode > 0)
852 return i915.lvds_channel_mode == 2;
Daniel Vetter1974cad2012-11-26 17:22:09 +0100853
854 if (dmi_check_system(intel_dual_link_lvds))
855 return true;
856
Daniel Vetter13c7d872012-11-26 17:22:10 +0100857 /* BIOS should set the proper LVDS register value at boot, but
858 * in reality, it doesn't set the value when the lid is closed;
859 * we need to check "the value to be set" in VBT when LVDS
860 * register is uninitialized.
861 */
Daniel Vetter7dec0602012-09-11 14:12:25 +0200862 val = I915_READ(lvds_encoder->reg);
Daniel Vetter13c7d872012-11-26 17:22:10 +0100863 if (!(val & ~(LVDS_PIPE_MASK | LVDS_DETECTED)))
Rodrigo Vivi41aa3442013-05-09 20:03:18 -0300864 val = dev_priv->vbt.bios_lvds_val;
Daniel Vetter13c7d872012-11-26 17:22:10 +0100865
Daniel Vetter1974cad2012-11-26 17:22:09 +0100866 return (val & LVDS_CLKB_POWER_MASK) == LVDS_CLKB_POWER_UP;
867}
868
Chris Wilsonf3cfcba2012-02-09 09:35:53 +0000869static bool intel_lvds_supported(struct drm_device *dev)
870{
871 /* With the introduction of the PCH we gained a dedicated
872 * LVDS presence pin, use it. */
Paulo Zanoni311e3592013-03-06 20:03:19 -0300873 if (HAS_PCH_IBX(dev) || HAS_PCH_CPT(dev))
Chris Wilsonf3cfcba2012-02-09 09:35:53 +0000874 return true;
875
876 /* Otherwise LVDS was only attached to mobile products,
877 * except for the inglorious 830gm */
Paulo Zanoni311e3592013-03-06 20:03:19 -0300878 if (INTEL_INFO(dev)->gen <= 4 && IS_MOBILE(dev) && !IS_I830(dev))
879 return true;
880
881 return false;
Chris Wilsonf3cfcba2012-02-09 09:35:53 +0000882}
883
Zhao Yakui18f9ed12009-11-20 03:24:16 +0000884/**
Jesse Barnes79e53942008-11-07 14:24:08 -0800885 * intel_lvds_init - setup LVDS connectors on this device
886 * @dev: drm device
887 *
888 * Create the connector, register the LVDS DDC bus, and try to figure out what
889 * modes we can display on the LVDS panel (if present).
890 */
Daniel Vetterc9093352013-06-06 22:22:47 +0200891void intel_lvds_init(struct drm_device *dev)
Jesse Barnes79e53942008-11-07 14:24:08 -0800892{
893 struct drm_i915_private *dev_priv = dev->dev_private;
Jani Nikula29b99b42012-10-19 14:51:43 +0300894 struct intel_lvds_encoder *lvds_encoder;
Eric Anholt21d40d32010-03-25 11:11:14 -0700895 struct intel_encoder *intel_encoder;
Jani Nikulac7362c42012-10-19 14:51:44 +0300896 struct intel_lvds_connector *lvds_connector;
Zhenyu Wangbb8a3562010-03-29 16:40:50 +0800897 struct intel_connector *intel_connector;
Jesse Barnes79e53942008-11-07 14:24:08 -0800898 struct drm_connector *connector;
899 struct drm_encoder *encoder;
900 struct drm_display_mode *scan; /* *modes, *bios_mode; */
Jani Nikuladd06f902012-10-19 14:51:50 +0300901 struct drm_display_mode *fixed_mode = NULL;
Vandana Kannan4b6ed682014-02-11 14:26:36 +0530902 struct drm_display_mode *downclock_mode = NULL;
Jani Nikula9cd300e2012-10-19 14:51:52 +0300903 struct edid *edid;
Jesse Barnes79e53942008-11-07 14:24:08 -0800904 struct drm_crtc *crtc;
905 u32 lvds;
Chris Wilson270eea02010-09-24 01:15:02 +0100906 int pipe;
907 u8 pin;
Jesse Barnes79e53942008-11-07 14:24:08 -0800908
Chris Wilsonf3cfcba2012-02-09 09:35:53 +0000909 if (!intel_lvds_supported(dev))
Daniel Vetterc9093352013-06-06 22:22:47 +0200910 return;
Chris Wilsonf3cfcba2012-02-09 09:35:53 +0000911
Jarod Wilson425d2442009-05-05 10:00:25 -0400912 /* Skip init on machines we know falsely report LVDS */
913 if (dmi_check_system(intel_no_lvds))
Daniel Vetterc9093352013-06-06 22:22:47 +0200914 return;
Paul Collins565dcd42009-02-04 23:05:41 +1300915
Chris Wilson270eea02010-09-24 01:15:02 +0100916 pin = GMBUS_PORT_PANEL;
917 if (!lvds_is_present_in_vbt(dev, &pin)) {
Matthew Garrett11ba1592009-12-15 13:55:24 -0500918 DRM_DEBUG_KMS("LVDS is not present in VBT\n");
Daniel Vetterc9093352013-06-06 22:22:47 +0200919 return;
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800920 }
Zhao Yakuie99da352009-06-26 09:46:18 +0800921
Eric Anholtc619eed2010-01-28 16:45:52 -0800922 if (HAS_PCH_SPLIT(dev)) {
Zhenyu Wang541998a2009-06-05 15:38:44 +0800923 if ((I915_READ(PCH_LVDS) & LVDS_DETECTED) == 0)
Daniel Vetterc9093352013-06-06 22:22:47 +0200924 return;
Rodrigo Vivi41aa3442013-05-09 20:03:18 -0300925 if (dev_priv->vbt.edp_support) {
Zhao Yakui28c97732009-10-09 11:39:41 +0800926 DRM_DEBUG_KMS("disable LVDS for eDP support\n");
Daniel Vetterc9093352013-06-06 22:22:47 +0200927 return;
Zhenyu Wang32f9d652009-07-24 01:00:32 +0800928 }
Zhenyu Wang541998a2009-06-05 15:38:44 +0800929 }
930
Daniel Vetterb14c5672013-09-19 12:18:32 +0200931 lvds_encoder = kzalloc(sizeof(*lvds_encoder), GFP_KERNEL);
Jani Nikula29b99b42012-10-19 14:51:43 +0300932 if (!lvds_encoder)
Daniel Vetterc9093352013-06-06 22:22:47 +0200933 return;
Jesse Barnes79e53942008-11-07 14:24:08 -0800934
Daniel Vetterb14c5672013-09-19 12:18:32 +0200935 lvds_connector = kzalloc(sizeof(*lvds_connector), GFP_KERNEL);
Jani Nikulac7362c42012-10-19 14:51:44 +0300936 if (!lvds_connector) {
Jani Nikula29b99b42012-10-19 14:51:43 +0300937 kfree(lvds_encoder);
Daniel Vetterc9093352013-06-06 22:22:47 +0200938 return;
Jesse Barnes79e53942008-11-07 14:24:08 -0800939 }
940
Jani Nikula62165e02012-10-19 14:51:47 +0300941 lvds_encoder->attached_connector = lvds_connector;
Zhenyu Wangbb8a3562010-03-29 16:40:50 +0800942
Jani Nikula29b99b42012-10-19 14:51:43 +0300943 intel_encoder = &lvds_encoder->base;
Chris Wilson4ef69c72010-09-09 15:14:28 +0100944 encoder = &intel_encoder->base;
Jani Nikulac7362c42012-10-19 14:51:44 +0300945 intel_connector = &lvds_connector->base;
Chris Wilsonea5b2132010-08-04 13:50:23 +0100946 connector = &intel_connector->base;
Zhenyu Wangbb8a3562010-03-29 16:40:50 +0800947 drm_connector_init(dev, &intel_connector->base, &intel_lvds_connector_funcs,
Jesse Barnes79e53942008-11-07 14:24:08 -0800948 DRM_MODE_CONNECTOR_LVDS);
949
Chris Wilson4ef69c72010-09-09 15:14:28 +0100950 drm_encoder_init(dev, &intel_encoder->base, &intel_lvds_enc_funcs,
Jesse Barnes79e53942008-11-07 14:24:08 -0800951 DRM_MODE_ENCODER_LVDS);
952
Daniel Vetterc22834e2012-06-30 15:31:28 +0200953 intel_encoder->enable = intel_enable_lvds;
Daniel Vetterf6736a12013-06-05 13:34:30 +0200954 intel_encoder->pre_enable = intel_pre_enable_lvds;
Daniel Vetter7ae89232013-03-27 00:44:52 +0100955 intel_encoder->compute_config = intel_lvds_compute_config;
Daniel Vetter66df24d2013-07-21 21:37:06 +0200956 intel_encoder->mode_set = intel_lvds_mode_set;
Daniel Vetterc22834e2012-06-30 15:31:28 +0200957 intel_encoder->disable = intel_disable_lvds;
Daniel Vetterb1dc3322012-07-02 21:09:00 +0200958 intel_encoder->get_hw_state = intel_lvds_get_hw_state;
Jesse Barnes045ac3b2013-05-14 17:08:26 -0700959 intel_encoder->get_config = intel_lvds_get_config;
Daniel Vetterb1dc3322012-07-02 21:09:00 +0200960 intel_connector->get_hw_state = intel_connector_get_hw_state;
Imre Deak4932e2c2014-02-11 17:12:48 +0200961 intel_connector->unregister = intel_connector_unregister;
Daniel Vetterc22834e2012-06-30 15:31:28 +0200962
Chris Wilsondf0e9242010-09-09 16:20:55 +0100963 intel_connector_attach_encoder(intel_connector, intel_encoder);
Eric Anholt21d40d32010-03-25 11:11:14 -0700964 intel_encoder->type = INTEL_OUTPUT_LVDS;
Jesse Barnes79e53942008-11-07 14:24:08 -0800965
Daniel Vetter66a92782012-07-12 20:08:18 +0200966 intel_encoder->cloneable = false;
Jesse Barnes27f82272011-09-02 12:54:37 -0700967 if (HAS_PCH_SPLIT(dev))
968 intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);
Daniel Vetter0b9f43a2012-06-05 10:07:11 +0200969 else if (IS_GEN4(dev))
970 intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
Jesse Barnes27f82272011-09-02 12:54:37 -0700971 else
972 intel_encoder->crtc_mask = (1 << 1);
973
Jesse Barnes79e53942008-11-07 14:24:08 -0800974 drm_connector_helper_add(connector, &intel_lvds_connector_helper_funcs);
975 connector->display_info.subpixel_order = SubPixelHorizontalRGB;
976 connector->interlace_allowed = false;
977 connector->doublescan_allowed = false;
978
Daniel Vetter7dec0602012-09-11 14:12:25 +0200979 if (HAS_PCH_SPLIT(dev)) {
980 lvds_encoder->reg = PCH_LVDS;
981 } else {
982 lvds_encoder->reg = LVDS;
983 }
984
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800985 /* create the scaling mode property */
986 drm_mode_create_scaling_mode_property(dev);
Rob Clark662595d2012-10-11 20:36:04 -0500987 drm_object_attach_property(&connector->base,
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800988 dev->mode_config.scaling_mode_property,
Jesse Barnesdd1ea372010-06-24 11:05:10 -0700989 DRM_MODE_SCALE_ASPECT);
Jani Nikula4d891522012-10-26 12:03:59 +0300990 intel_connector->panel.fitting_mode = DRM_MODE_SCALE_ASPECT;
Jesse Barnes79e53942008-11-07 14:24:08 -0800991 /*
992 * LVDS discovery:
993 * 1) check for EDID on DDC
994 * 2) check for VBT data
995 * 3) check to see if LVDS is already on
996 * if none of the above, no panel
997 * 4) make sure lid is open
998 * if closed, act like it's not there for now
999 */
1000
Jesse Barnes79e53942008-11-07 14:24:08 -08001001 /*
1002 * Attempt to get the fixed panel mode from DDC. Assume that the
1003 * preferred mode is the right one.
1004 */
Jani Nikula9cd300e2012-10-19 14:51:52 +03001005 edid = drm_get_edid(connector, intel_gmbus_get_adapter(dev_priv, pin));
1006 if (edid) {
1007 if (drm_add_edid_modes(connector, edid)) {
Chris Wilson3f8ff0e2010-11-08 23:20:52 +00001008 drm_mode_connector_update_edid_property(connector,
Jani Nikula9cd300e2012-10-19 14:51:52 +03001009 edid);
Chris Wilson3f8ff0e2010-11-08 23:20:52 +00001010 } else {
Jani Nikula9cd300e2012-10-19 14:51:52 +03001011 kfree(edid);
1012 edid = ERR_PTR(-EINVAL);
Chris Wilson3f8ff0e2010-11-08 23:20:52 +00001013 }
Jani Nikula9cd300e2012-10-19 14:51:52 +03001014 } else {
1015 edid = ERR_PTR(-ENOENT);
Chris Wilson3f8ff0e2010-11-08 23:20:52 +00001016 }
Jani Nikula9cd300e2012-10-19 14:51:52 +03001017 lvds_connector->base.edid = edid;
1018
1019 if (IS_ERR_OR_NULL(edid)) {
Chris Wilson788319d2010-09-12 17:34:41 +01001020 /* Didn't get an EDID, so
1021 * Set wide sync ranges so we get all modes
1022 * handed to valid_mode for checking
1023 */
1024 connector->display_info.min_vfreq = 0;
1025 connector->display_info.max_vfreq = 200;
1026 connector->display_info.min_hfreq = 0;
1027 connector->display_info.max_hfreq = 200;
1028 }
Jesse Barnes79e53942008-11-07 14:24:08 -08001029
1030 list_for_each_entry(scan, &connector->probed_modes, head) {
Jesse Barnes79e53942008-11-07 14:24:08 -08001031 if (scan->type & DRM_MODE_TYPE_PREFERRED) {
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001032 DRM_DEBUG_KMS("using preferred mode from EDID: ");
1033 drm_mode_debug_printmodeline(scan);
1034
Jani Nikuladd06f902012-10-19 14:51:50 +03001035 fixed_mode = drm_mode_duplicate(dev, scan);
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001036 if (fixed_mode) {
Vandana Kannan4b6ed682014-02-11 14:26:36 +05301037 downclock_mode =
Vandana Kannanec9ed192013-12-10 13:37:36 +05301038 intel_find_panel_downclock(dev,
1039 fixed_mode, connector);
Vandana Kannan4b6ed682014-02-11 14:26:36 +05301040 if (downclock_mode != NULL &&
1041 i915.lvds_downclock) {
Vandana Kannanec9ed192013-12-10 13:37:36 +05301042 /* We found the downclock for LVDS. */
1043 dev_priv->lvds_downclock_avail = true;
1044 dev_priv->lvds_downclock =
Vandana Kannanec9ed192013-12-10 13:37:36 +05301045 downclock_mode->clock;
1046 DRM_DEBUG_KMS("LVDS downclock is found"
1047 " in EDID. Normal clock %dKhz, "
1048 "downclock %dKhz\n",
1049 fixed_mode->clock,
1050 dev_priv->lvds_downclock);
1051 }
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001052 goto out;
1053 }
Jesse Barnes79e53942008-11-07 14:24:08 -08001054 }
Jesse Barnes79e53942008-11-07 14:24:08 -08001055 }
1056
1057 /* Failed to get EDID, what about VBT? */
Rodrigo Vivi41aa3442013-05-09 20:03:18 -03001058 if (dev_priv->vbt.lfp_lvds_vbt_mode) {
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001059 DRM_DEBUG_KMS("using mode from VBT: ");
Rodrigo Vivi41aa3442013-05-09 20:03:18 -03001060 drm_mode_debug_printmodeline(dev_priv->vbt.lfp_lvds_vbt_mode);
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001061
Rodrigo Vivi41aa3442013-05-09 20:03:18 -03001062 fixed_mode = drm_mode_duplicate(dev, dev_priv->vbt.lfp_lvds_vbt_mode);
Jani Nikuladd06f902012-10-19 14:51:50 +03001063 if (fixed_mode) {
1064 fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
Jesse Barnese285f3cd2009-01-14 10:53:36 -08001065 goto out;
1066 }
Jesse Barnes79e53942008-11-07 14:24:08 -08001067 }
1068
1069 /*
1070 * If we didn't get EDID, try checking if the panel is already turned
1071 * on. If so, assume that whatever is currently programmed is the
1072 * correct mode.
1073 */
Zhenyu Wang541998a2009-06-05 15:38:44 +08001074
Adam Jacksonf2b115e2009-12-03 17:14:42 -05001075 /* Ironlake: FIXME if still fail, not try pipe mode now */
Eric Anholtc619eed2010-01-28 16:45:52 -08001076 if (HAS_PCH_SPLIT(dev))
Zhenyu Wang541998a2009-06-05 15:38:44 +08001077 goto failed;
1078
Jesse Barnes79e53942008-11-07 14:24:08 -08001079 lvds = I915_READ(LVDS);
1080 pipe = (lvds & LVDS_PIPEB_SELECT) ? 1 : 0;
Chris Wilsonf875c152010-09-09 15:44:14 +01001081 crtc = intel_get_crtc_for_pipe(dev, pipe);
Jesse Barnes79e53942008-11-07 14:24:08 -08001082
1083 if (crtc && (lvds & LVDS_PORT_EN)) {
Jani Nikuladd06f902012-10-19 14:51:50 +03001084 fixed_mode = intel_crtc_mode_get(dev, crtc);
1085 if (fixed_mode) {
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001086 DRM_DEBUG_KMS("using current (BIOS) mode: ");
1087 drm_mode_debug_printmodeline(fixed_mode);
Jani Nikuladd06f902012-10-19 14:51:50 +03001088 fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
Paul Collins565dcd42009-02-04 23:05:41 +13001089 goto out;
Jesse Barnes79e53942008-11-07 14:24:08 -08001090 }
1091 }
1092
1093 /* If we still don't have a mode after all that, give up. */
Jani Nikuladd06f902012-10-19 14:51:50 +03001094 if (!fixed_mode)
Jesse Barnes79e53942008-11-07 14:24:08 -08001095 goto failed;
1096
Jesse Barnes79e53942008-11-07 14:24:08 -08001097out:
Daniel Vetter7dec0602012-09-11 14:12:25 +02001098 lvds_encoder->is_dual_link = compute_is_dual_link_lvds(lvds_encoder);
Daniel Vetter13c7d872012-11-26 17:22:10 +01001099 DRM_DEBUG_KMS("detected %s-link lvds configuration\n",
1100 lvds_encoder->is_dual_link ? "dual" : "single");
1101
Daniel Vetter24ded202012-06-05 12:14:54 +02001102 /*
1103 * Unlock registers and just
1104 * leave them unlocked
1105 */
Eric Anholtc619eed2010-01-28 16:45:52 -08001106 if (HAS_PCH_SPLIT(dev)) {
Keith Packarded10fca2011-08-06 10:33:12 -07001107 I915_WRITE(PCH_PP_CONTROL,
1108 I915_READ(PCH_PP_CONTROL) | PANEL_UNLOCK_REGS);
1109 } else {
Keith Packarded10fca2011-08-06 10:33:12 -07001110 I915_WRITE(PP_CONTROL,
1111 I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
Zhenyu Wang541998a2009-06-05 15:38:44 +08001112 }
Jani Nikuladb1740a2012-10-19 14:51:45 +03001113 lvds_connector->lid_notifier.notifier_call = intel_lid_notify;
1114 if (acpi_lid_notifier_register(&lvds_connector->lid_notifier)) {
Zhao Yakui28c97732009-10-09 11:39:41 +08001115 DRM_DEBUG_KMS("lid notifier registration failed\n");
Jani Nikuladb1740a2012-10-19 14:51:45 +03001116 lvds_connector->lid_notifier.notifier_call = NULL;
Jesse Barnesc1c7af62009-09-10 15:28:03 -07001117 }
Jesse Barnes79e53942008-11-07 14:24:08 -08001118 drm_sysfs_connector_add(connector);
Matthew Garrettaaa6fd22011-08-12 12:11:33 +02001119
Vandana Kannan4b6ed682014-02-11 14:26:36 +05301120 intel_panel_init(&intel_connector->panel, fixed_mode, downclock_mode);
Jani Nikula0657b6b2012-10-19 14:51:46 +03001121 intel_panel_setup_backlight(connector);
Matthew Garrettaaa6fd22011-08-12 12:11:33 +02001122
Daniel Vetterc9093352013-06-06 22:22:47 +02001123 return;
Jesse Barnes79e53942008-11-07 14:24:08 -08001124
1125failed:
Zhao Yakui8a4c47f2009-07-20 13:48:04 +08001126 DRM_DEBUG_KMS("No LVDS modes found, disabling.\n");
Jesse Barnes79e53942008-11-07 14:24:08 -08001127 drm_connector_cleanup(connector);
Shaohua Li1991bdf2009-11-17 17:19:23 +08001128 drm_encoder_cleanup(encoder);
Jani Nikula29b99b42012-10-19 14:51:43 +03001129 kfree(lvds_encoder);
Jani Nikulac7362c42012-10-19 14:51:44 +03001130 kfree(lvds_connector);
Daniel Vetterc9093352013-06-06 22:22:47 +02001131 return;
Jesse Barnes79e53942008-11-07 14:24:08 -08001132}