blob: 61348eae2f0436a05f7b5d88fec4242db918655d [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;
95
96 if (HAS_PCH_SPLIT(dev))
97 lvds_reg = PCH_LVDS;
98 else
99 lvds_reg = LVDS;
100
101 tmp = I915_READ(lvds_reg);
102 if (tmp & LVDS_HSYNC_POLARITY)
103 flags |= DRM_MODE_FLAG_NHSYNC;
104 else
105 flags |= DRM_MODE_FLAG_PHSYNC;
106 if (tmp & LVDS_VSYNC_POLARITY)
107 flags |= DRM_MODE_FLAG_NVSYNC;
108 else
109 flags |= DRM_MODE_FLAG_PVSYNC;
110
111 pipe_config->adjusted_mode.flags |= flags;
Daniel Vetter06922822013-07-11 13:35:40 +0200112
113 /* gen2/3 store dither state in pfit control, needs to match */
114 if (INTEL_INFO(dev)->gen < 4) {
115 tmp = I915_READ(PFIT_CONTROL);
116
117 pipe_config->gmch_pfit.control |= tmp & PANEL_8TO6_DITHER_ENABLE;
118 }
Jesse Barnes045ac3b2013-05-14 17:08:26 -0700119}
120
Daniel Vetterfc683092012-11-26 17:22:12 +0100121/* The LVDS pin pair needs to be on before the DPLLs are enabled.
122 * This is an exception to the general rule that mode_set doesn't turn
123 * things on.
124 */
125static void intel_pre_pll_enable_lvds(struct intel_encoder *encoder)
126{
127 struct intel_lvds_encoder *lvds_encoder = to_lvds_encoder(&encoder->base);
128 struct drm_device *dev = encoder->base.dev;
129 struct drm_i915_private *dev_priv = dev->dev_private;
130 struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
131 struct drm_display_mode *fixed_mode =
132 lvds_encoder->attached_connector->base.panel.fixed_mode;
133 int pipe = intel_crtc->pipe;
134 u32 temp;
135
Daniel Vetterfc683092012-11-26 17:22:12 +0100136 temp = I915_READ(lvds_encoder->reg);
137 temp |= LVDS_PORT_EN | LVDS_A0A2_CLKA_POWER_UP;
Daniel Vetter62810e52012-11-26 17:22:13 +0100138
139 if (HAS_PCH_CPT(dev)) {
140 temp &= ~PORT_TRANS_SEL_MASK;
141 temp |= PORT_TRANS_SEL_CPT(pipe);
Daniel Vetterfc683092012-11-26 17:22:12 +0100142 } else {
Daniel Vetter62810e52012-11-26 17:22:13 +0100143 if (pipe == 1) {
144 temp |= LVDS_PIPEB_SELECT;
145 } else {
146 temp &= ~LVDS_PIPEB_SELECT;
147 }
Daniel Vetterfc683092012-11-26 17:22:12 +0100148 }
Daniel Vetter62810e52012-11-26 17:22:13 +0100149
Daniel Vetterfc683092012-11-26 17:22:12 +0100150 /* set the corresponsding LVDS_BORDER bit */
Daniel Vetter2fa2fe92013-05-07 23:34:16 +0200151 temp &= ~LVDS_BORDER_ENABLE;
Daniel Vetter68fc8742013-04-25 22:52:16 +0200152 temp |= intel_crtc->config.gmch_pfit.lvds_border_bits;
Daniel Vetterfc683092012-11-26 17:22:12 +0100153 /* Set the B0-B3 data pairs corresponding to whether we're going to
154 * set the DPLLs for dual-channel mode or not.
155 */
156 if (lvds_encoder->is_dual_link)
157 temp |= LVDS_B0B3_POWER_UP | LVDS_CLKB_POWER_UP;
158 else
159 temp &= ~(LVDS_B0B3_POWER_UP | LVDS_CLKB_POWER_UP);
160
161 /* It would be nice to set 24 vs 18-bit mode (LVDS_A3_POWER_UP)
162 * appropriately here, but we need to look more thoroughly into how
163 * panels behave in the two modes.
164 */
Daniel Vetter62810e52012-11-26 17:22:13 +0100165
166 /* Set the dithering flag on LVDS as needed, note that there is no
167 * special lvds dither control bit on pch-split platforms, dithering is
168 * only controlled through the PIPECONF reg. */
169 if (INTEL_INFO(dev)->gen == 4) {
Daniel Vetterd8b32242013-04-25 17:54:44 +0200170 /* Bspec wording suggests that LVDS port dithering only exists
171 * for 18bpp panels. */
172 if (intel_crtc->config.dither &&
173 intel_crtc->config.pipe_bpp == 18)
Daniel Vetterfc683092012-11-26 17:22:12 +0100174 temp |= LVDS_ENABLE_DITHER;
175 else
176 temp &= ~LVDS_ENABLE_DITHER;
177 }
178 temp &= ~(LVDS_HSYNC_POLARITY | LVDS_VSYNC_POLARITY);
179 if (fixed_mode->flags & DRM_MODE_FLAG_NHSYNC)
180 temp |= LVDS_HSYNC_POLARITY;
181 if (fixed_mode->flags & DRM_MODE_FLAG_NVSYNC)
182 temp |= LVDS_VSYNC_POLARITY;
183
184 I915_WRITE(lvds_encoder->reg, temp);
185}
186
Jesse Barnes79e53942008-11-07 14:24:08 -0800187/**
Jesse Barnes79e53942008-11-07 14:24:08 -0800188 * Sets the power state for the panel.
189 */
Daniel Vetterc22834e2012-06-30 15:31:28 +0200190static void intel_enable_lvds(struct intel_encoder *encoder)
Jesse Barnes79e53942008-11-07 14:24:08 -0800191{
Daniel Vetterc22834e2012-06-30 15:31:28 +0200192 struct drm_device *dev = encoder->base.dev;
Jani Nikula29b99b42012-10-19 14:51:43 +0300193 struct intel_lvds_encoder *lvds_encoder = to_lvds_encoder(&encoder->base);
Daniel Vetterc22834e2012-06-30 15:31:28 +0200194 struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
Jesse Barnes79e53942008-11-07 14:24:08 -0800195 struct drm_i915_private *dev_priv = dev->dev_private;
Daniel Vetter7dec0602012-09-11 14:12:25 +0200196 u32 ctl_reg, stat_reg;
Zhenyu Wang541998a2009-06-05 15:38:44 +0800197
Eric Anholtc619eed2010-01-28 16:45:52 -0800198 if (HAS_PCH_SPLIT(dev)) {
Zhenyu Wang541998a2009-06-05 15:38:44 +0800199 ctl_reg = PCH_PP_CONTROL;
Keith Packardde842ef2011-08-06 10:30:45 -0700200 stat_reg = PCH_PP_STATUS;
Zhenyu Wang541998a2009-06-05 15:38:44 +0800201 } else {
202 ctl_reg = PP_CONTROL;
Keith Packardde842ef2011-08-06 10:30:45 -0700203 stat_reg = PP_STATUS;
Zhenyu Wang541998a2009-06-05 15:38:44 +0800204 }
Jesse Barnes79e53942008-11-07 14:24:08 -0800205
Daniel Vetter7dec0602012-09-11 14:12:25 +0200206 I915_WRITE(lvds_encoder->reg, I915_READ(lvds_encoder->reg) | LVDS_PORT_EN);
Chris Wilsone9e331a2010-09-13 01:16:10 +0100207
Chris Wilson2a1292f2010-12-05 19:21:18 +0000208 I915_WRITE(ctl_reg, I915_READ(ctl_reg) | POWER_TARGET_ON);
Daniel Vetter7dec0602012-09-11 14:12:25 +0200209 POSTING_READ(lvds_encoder->reg);
Keith Packardde842ef2011-08-06 10:30:45 -0700210 if (wait_for((I915_READ(stat_reg) & PP_ON) != 0, 1000))
211 DRM_ERROR("timed out waiting for panel to power on\n");
Chris Wilson2a1292f2010-12-05 19:21:18 +0000212
Daniel Vetter24ded202012-06-05 12:14:54 +0200213 intel_panel_enable_backlight(dev, intel_crtc->pipe);
Chris Wilson2a1292f2010-12-05 19:21:18 +0000214}
215
Daniel Vetterc22834e2012-06-30 15:31:28 +0200216static void intel_disable_lvds(struct intel_encoder *encoder)
Chris Wilson2a1292f2010-12-05 19:21:18 +0000217{
Daniel Vetterc22834e2012-06-30 15:31:28 +0200218 struct drm_device *dev = encoder->base.dev;
Jani Nikula29b99b42012-10-19 14:51:43 +0300219 struct intel_lvds_encoder *lvds_encoder = to_lvds_encoder(&encoder->base);
Chris Wilson2a1292f2010-12-05 19:21:18 +0000220 struct drm_i915_private *dev_priv = dev->dev_private;
Daniel Vetter7dec0602012-09-11 14:12:25 +0200221 u32 ctl_reg, stat_reg;
Chris Wilson2a1292f2010-12-05 19:21:18 +0000222
223 if (HAS_PCH_SPLIT(dev)) {
224 ctl_reg = PCH_PP_CONTROL;
Keith Packardde842ef2011-08-06 10:30:45 -0700225 stat_reg = PCH_PP_STATUS;
Chris Wilson2a1292f2010-12-05 19:21:18 +0000226 } else {
227 ctl_reg = PP_CONTROL;
Keith Packardde842ef2011-08-06 10:30:45 -0700228 stat_reg = PP_STATUS;
Chris Wilson2a1292f2010-12-05 19:21:18 +0000229 }
230
Chris Wilson47356eb2011-01-11 17:06:04 +0000231 intel_panel_disable_backlight(dev);
Chris Wilson2a1292f2010-12-05 19:21:18 +0000232
233 I915_WRITE(ctl_reg, I915_READ(ctl_reg) & ~POWER_TARGET_ON);
Keith Packardde842ef2011-08-06 10:30:45 -0700234 if (wait_for((I915_READ(stat_reg) & PP_ON) == 0, 1000))
235 DRM_ERROR("timed out waiting for panel to power off\n");
Chris Wilson2a1292f2010-12-05 19:21:18 +0000236
Daniel Vetter7dec0602012-09-11 14:12:25 +0200237 I915_WRITE(lvds_encoder->reg, I915_READ(lvds_encoder->reg) & ~LVDS_PORT_EN);
238 POSTING_READ(lvds_encoder->reg);
Jesse Barnes79e53942008-11-07 14:24:08 -0800239}
240
Jesse Barnes79e53942008-11-07 14:24:08 -0800241static int intel_lvds_mode_valid(struct drm_connector *connector,
242 struct drm_display_mode *mode)
243{
Jani Nikuladd06f902012-10-19 14:51:50 +0300244 struct intel_connector *intel_connector = to_intel_connector(connector);
245 struct drm_display_mode *fixed_mode = intel_connector->panel.fixed_mode;
Jesse Barnes79e53942008-11-07 14:24:08 -0800246
Chris Wilson788319d2010-09-12 17:34:41 +0100247 if (mode->hdisplay > fixed_mode->hdisplay)
248 return MODE_PANEL;
249 if (mode->vdisplay > fixed_mode->vdisplay)
250 return MODE_PANEL;
Jesse Barnes79e53942008-11-07 14:24:08 -0800251
252 return MODE_OK;
253}
254
Daniel Vetter7ae89232013-03-27 00:44:52 +0100255static bool intel_lvds_compute_config(struct intel_encoder *intel_encoder,
256 struct intel_crtc_config *pipe_config)
Jesse Barnes79e53942008-11-07 14:24:08 -0800257{
Daniel Vetter7ae89232013-03-27 00:44:52 +0100258 struct drm_device *dev = intel_encoder->base.dev;
Jesse Barnes79e53942008-11-07 14:24:08 -0800259 struct drm_i915_private *dev_priv = dev->dev_private;
Daniel Vetter7ae89232013-03-27 00:44:52 +0100260 struct intel_lvds_encoder *lvds_encoder =
261 to_lvds_encoder(&intel_encoder->base);
Jani Nikula4d891522012-10-26 12:03:59 +0300262 struct intel_connector *intel_connector =
263 &lvds_encoder->attached_connector->base;
Daniel Vetter7ae89232013-03-27 00:44:52 +0100264 struct drm_display_mode *adjusted_mode = &pipe_config->adjusted_mode;
Jani Nikula29b99b42012-10-19 14:51:43 +0300265 struct intel_crtc *intel_crtc = lvds_encoder->base.new_crtc;
Daniel Vetter4e53c2e2013-03-27 00:44:58 +0100266 unsigned int lvds_bpp;
Jesse Barnes79e53942008-11-07 14:24:08 -0800267
268 /* Should never happen!! */
Chris Wilsona6c45cf2010-09-17 00:32:17 +0100269 if (INTEL_INFO(dev)->gen < 4 && intel_crtc->pipe == 0) {
Keith Packard1ae8c0a2009-06-28 15:42:17 -0700270 DRM_ERROR("Can't support LVDS on pipe A\n");
Jesse Barnes79e53942008-11-07 14:24:08 -0800271 return false;
272 }
273
Daniel Vetter4e53c2e2013-03-27 00:44:58 +0100274 if ((I915_READ(lvds_encoder->reg) & LVDS_A3_POWER_MASK) ==
275 LVDS_A3_POWER_UP)
276 lvds_bpp = 8*3;
277 else
278 lvds_bpp = 6*3;
279
Daniel Vettere29c22c2013-02-21 00:00:16 +0100280 if (lvds_bpp != pipe_config->pipe_bpp && !pipe_config->bw_constrained) {
Daniel Vetter4e53c2e2013-03-27 00:44:58 +0100281 DRM_DEBUG_KMS("forcing display bpp (was %d) to LVDS (%d)\n",
282 pipe_config->pipe_bpp, lvds_bpp);
283 pipe_config->pipe_bpp = lvds_bpp;
284 }
Daniel Vetterd8b32242013-04-25 17:54:44 +0200285
Jesse Barnes79e53942008-11-07 14:24:08 -0800286 /*
Chris Wilson71677042010-07-17 13:38:43 +0100287 * We have timings from the BIOS for the panel, put them in
Jesse Barnes79e53942008-11-07 14:24:08 -0800288 * to the adjusted mode. The CRTC will be set up for this mode,
289 * with the panel scaling set up to source from the H/VDisplay
290 * of the original mode.
291 */
Jani Nikula4d891522012-10-26 12:03:59 +0300292 intel_fixed_panel_mode(intel_connector->panel.fixed_mode,
Jani Nikuladd06f902012-10-19 14:51:50 +0300293 adjusted_mode);
Chris Wilson1d8e1c72010-08-07 11:01:28 +0100294
295 if (HAS_PCH_SPLIT(dev)) {
Daniel Vetter5bfe2ac2013-03-27 00:44:55 +0100296 pipe_config->has_pch_encoder = true;
297
Jesse Barnesb074cec2013-04-25 12:55:02 -0700298 intel_pch_panel_fitting(intel_crtc, pipe_config,
299 intel_connector->panel.fitting_mode);
Jesse Barnes2dd24552013-04-25 12:55:01 -0700300 } else {
301 intel_gmch_panel_fitting(intel_crtc, pipe_config,
302 intel_connector->panel.fitting_mode);
Jesse Barnes79e53942008-11-07 14:24:08 -0800303
Daniel Vetter21d8a472013-07-12 08:07:30 +0200304 }
Daniel Vetterf9bef082012-04-15 19:53:19 +0200305
Zhao Yakuia3e17eb2009-10-10 10:42:37 +0800306 /*
Jesse Barnes79e53942008-11-07 14:24:08 -0800307 * XXX: It would be nice to support lower refresh rates on the
308 * panels to reduce power consumption, and perhaps match the
309 * user's requested refresh rate.
310 */
311
312 return true;
313}
314
Jesse Barnes79e53942008-11-07 14:24:08 -0800315static void intel_lvds_mode_set(struct drm_encoder *encoder,
316 struct drm_display_mode *mode,
317 struct drm_display_mode *adjusted_mode)
318{
Jesse Barnes79e53942008-11-07 14:24:08 -0800319 /*
320 * The LVDS pin pair will already have been turned on in the
321 * intel_crtc_mode_set since it has a large impact on the DPLL
322 * settings.
323 */
Jesse Barnes79e53942008-11-07 14:24:08 -0800324}
325
326/**
327 * Detect the LVDS connection.
328 *
Jesse Barnesb42d4c52009-09-10 15:28:04 -0700329 * Since LVDS doesn't have hotlug, we use the lid as a proxy. Open means
330 * connected and closed means disconnected. We also send hotplug events as
331 * needed, using lid status notification from the input layer.
Jesse Barnes79e53942008-11-07 14:24:08 -0800332 */
Chris Wilson7b334fc2010-09-09 23:51:02 +0100333static enum drm_connector_status
Chris Wilson930a9e22010-09-14 11:07:23 +0100334intel_lvds_detect(struct drm_connector *connector, bool force)
Jesse Barnes79e53942008-11-07 14:24:08 -0800335{
Jesse Barnes7b9c5ab2010-02-12 09:30:00 -0800336 struct drm_device *dev = connector->dev;
Chris Wilson6ee3b5a2011-03-24 13:26:43 +0000337 enum drm_connector_status status;
Jesse Barnesb42d4c52009-09-10 15:28:04 -0700338
Chris Wilsonfe16d942011-02-12 10:29:38 +0000339 status = intel_panel_detect(dev);
340 if (status != connector_status_unknown)
341 return status;
Chris Wilson01fe9db2011-01-16 19:37:30 +0000342
Chris Wilson6ee3b5a2011-03-24 13:26:43 +0000343 return connector_status_connected;
Jesse Barnes79e53942008-11-07 14:24:08 -0800344}
345
346/**
347 * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
348 */
349static int intel_lvds_get_modes(struct drm_connector *connector)
350{
Jani Nikula62165e02012-10-19 14:51:47 +0300351 struct intel_lvds_connector *lvds_connector = to_lvds_connector(connector);
Jesse Barnes79e53942008-11-07 14:24:08 -0800352 struct drm_device *dev = connector->dev;
Chris Wilson788319d2010-09-12 17:34:41 +0100353 struct drm_display_mode *mode;
Jesse Barnes79e53942008-11-07 14:24:08 -0800354
Jani Nikula9cd300e2012-10-19 14:51:52 +0300355 /* use cached edid if we have one */
Chris Wilson2aa4f092012-11-21 16:14:04 +0000356 if (!IS_ERR_OR_NULL(lvds_connector->base.edid))
Jani Nikula9cd300e2012-10-19 14:51:52 +0300357 return drm_add_edid_modes(connector, lvds_connector->base.edid);
Jesse Barnes79e53942008-11-07 14:24:08 -0800358
Jani Nikuladd06f902012-10-19 14:51:50 +0300359 mode = drm_mode_duplicate(dev, lvds_connector->base.panel.fixed_mode);
Chris Wilson311bd682011-01-13 19:06:50 +0000360 if (mode == NULL)
Chris Wilson788319d2010-09-12 17:34:41 +0100361 return 0;
Jesse Barnes79e53942008-11-07 14:24:08 -0800362
Chris Wilson788319d2010-09-12 17:34:41 +0100363 drm_mode_probed_add(connector, mode);
364 return 1;
Jesse Barnes79e53942008-11-07 14:24:08 -0800365}
366
Thomas Bächler0544edf2010-07-02 10:44:23 +0200367static int intel_no_modeset_on_lid_dmi_callback(const struct dmi_system_id *id)
368{
Daniel Vetterbc0daf42012-04-01 13:16:49 +0200369 DRM_INFO("Skipping forced modeset for %s\n", id->ident);
Thomas Bächler0544edf2010-07-02 10:44:23 +0200370 return 1;
371}
372
373/* The GPU hangs up on these systems if modeset is performed on LID open */
374static const struct dmi_system_id intel_no_modeset_on_lid[] = {
375 {
376 .callback = intel_no_modeset_on_lid_dmi_callback,
377 .ident = "Toshiba Tecra A11",
378 .matches = {
379 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
380 DMI_MATCH(DMI_PRODUCT_NAME, "TECRA A11"),
381 },
382 },
383
384 { } /* terminating entry */
385};
386
Linus Torvaldsc9354c82009-11-02 09:29:55 -0800387/*
Zhang Ruib8efb172013-02-05 15:41:53 +0800388 * Lid events. Note the use of 'modeset':
389 * - we set it to MODESET_ON_LID_OPEN on lid close,
390 * and set it to MODESET_DONE on open
Linus Torvaldsc9354c82009-11-02 09:29:55 -0800391 * - we use it as a "only once" bit (ie we ignore
Zhang Ruib8efb172013-02-05 15:41:53 +0800392 * duplicate events where it was already properly set)
393 * - the suspend/resume paths will set it to
394 * MODESET_SUSPENDED and ignore the lid open event,
395 * because they restore the mode ("lid open").
Linus Torvaldsc9354c82009-11-02 09:29:55 -0800396 */
Jesse Barnesc1c7af62009-09-10 15:28:03 -0700397static int intel_lid_notify(struct notifier_block *nb, unsigned long val,
398 void *unused)
399{
Jani Nikuladb1740a2012-10-19 14:51:45 +0300400 struct intel_lvds_connector *lvds_connector =
401 container_of(nb, struct intel_lvds_connector, lid_notifier);
402 struct drm_connector *connector = &lvds_connector->base.base;
403 struct drm_device *dev = connector->dev;
404 struct drm_i915_private *dev_priv = dev->dev_private;
Jesse Barnesc1c7af62009-09-10 15:28:03 -0700405
Alex Williamson2fb4e612011-04-21 16:08:14 -0600406 if (dev->switch_power_state != DRM_SWITCH_POWER_ON)
407 return NOTIFY_OK;
408
Zhang Ruib8efb172013-02-05 15:41:53 +0800409 mutex_lock(&dev_priv->modeset_restore_lock);
410 if (dev_priv->modeset_restore == MODESET_SUSPENDED)
411 goto exit;
Zhao Yakuia2565372009-12-11 09:26:11 +0800412 /*
413 * check and update the status of LVDS connector after receiving
414 * the LID nofication event.
415 */
Jani Nikuladb1740a2012-10-19 14:51:45 +0300416 connector->status = connector->funcs->detect(connector, false);
Chris Wilson7b334fc2010-09-09 23:51:02 +0100417
Thomas Bächler0544edf2010-07-02 10:44:23 +0200418 /* Don't force modeset on machines where it causes a GPU lockup */
419 if (dmi_check_system(intel_no_modeset_on_lid))
Zhang Ruib8efb172013-02-05 15:41:53 +0800420 goto exit;
Linus Torvaldsc9354c82009-11-02 09:29:55 -0800421 if (!acpi_lid_open()) {
Zhang Ruib8efb172013-02-05 15:41:53 +0800422 /* do modeset on next lid open event */
423 dev_priv->modeset_restore = MODESET_ON_LID_OPEN;
424 goto exit;
Jesse Barnes06891e22009-09-14 10:58:48 -0700425 }
Jesse Barnesc1c7af62009-09-10 15:28:03 -0700426
Zhang Ruib8efb172013-02-05 15:41:53 +0800427 if (dev_priv->modeset_restore == MODESET_DONE)
428 goto exit;
Linus Torvaldsc9354c82009-11-02 09:29:55 -0800429
Daniel Vettera0e99e62012-12-02 01:05:46 +0100430 drm_modeset_lock_all(dev);
Daniel Vetter45e2b5f2012-11-23 18:16:34 +0100431 intel_modeset_setup_hw_state(dev, true);
Daniel Vettera0e99e62012-12-02 01:05:46 +0100432 drm_modeset_unlock_all(dev);
Jesse Barnes06324192009-09-10 15:28:05 -0700433
Zhang Ruib8efb172013-02-05 15:41:53 +0800434 dev_priv->modeset_restore = MODESET_DONE;
435
436exit:
437 mutex_unlock(&dev_priv->modeset_restore_lock);
Jesse Barnesc1c7af62009-09-10 15:28:03 -0700438 return NOTIFY_OK;
439}
440
Jesse Barnes79e53942008-11-07 14:24:08 -0800441/**
442 * intel_lvds_destroy - unregister and free LVDS structures
443 * @connector: connector to free
444 *
445 * Unregister the DDC bus for this connector then free the driver private
446 * structure.
447 */
448static void intel_lvds_destroy(struct drm_connector *connector)
449{
Jani Nikuladb1740a2012-10-19 14:51:45 +0300450 struct intel_lvds_connector *lvds_connector =
451 to_lvds_connector(connector);
Jesse Barnes79e53942008-11-07 14:24:08 -0800452
Jani Nikuladb1740a2012-10-19 14:51:45 +0300453 if (lvds_connector->lid_notifier.notifier_call)
454 acpi_lid_notifier_unregister(&lvds_connector->lid_notifier);
Matthew Garrettaaa6fd22011-08-12 12:11:33 +0200455
Jani Nikula9cd300e2012-10-19 14:51:52 +0300456 if (!IS_ERR_OR_NULL(lvds_connector->base.edid))
457 kfree(lvds_connector->base.edid);
458
Jani Nikula1d508702012-10-19 14:51:49 +0300459 intel_panel_fini(&lvds_connector->base.panel);
Jani Nikuladb1740a2012-10-19 14:51:45 +0300460
Jesse Barnes79e53942008-11-07 14:24:08 -0800461 drm_sysfs_connector_remove(connector);
462 drm_connector_cleanup(connector);
463 kfree(connector);
464}
465
Jesse Barnes335041e2009-01-22 22:22:06 +1000466static int intel_lvds_set_property(struct drm_connector *connector,
467 struct drm_property *property,
468 uint64_t value)
469{
Jani Nikula4d891522012-10-26 12:03:59 +0300470 struct intel_connector *intel_connector = to_intel_connector(connector);
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800471 struct drm_device *dev = connector->dev;
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800472
Chris Wilson788319d2010-09-12 17:34:41 +0100473 if (property == dev->mode_config.scaling_mode_property) {
Jani Nikula62165e02012-10-19 14:51:47 +0300474 struct drm_crtc *crtc;
Zhenyu Wangbb8a3562010-03-29 16:40:50 +0800475
Jesse Barnes53bd8382009-07-01 10:04:40 -0700476 if (value == DRM_MODE_SCALE_NONE) {
477 DRM_DEBUG_KMS("no scaling not supported\n");
Chris Wilson788319d2010-09-12 17:34:41 +0100478 return -EINVAL;
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800479 }
Chris Wilson788319d2010-09-12 17:34:41 +0100480
Jani Nikula4d891522012-10-26 12:03:59 +0300481 if (intel_connector->panel.fitting_mode == value) {
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800482 /* the LVDS scaling property is not changed */
483 return 0;
484 }
Jani Nikula4d891522012-10-26 12:03:59 +0300485 intel_connector->panel.fitting_mode = value;
Jani Nikula62165e02012-10-19 14:51:47 +0300486
487 crtc = intel_attached_encoder(connector)->base.crtc;
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800488 if (crtc && crtc->enabled) {
489 /*
490 * If the CRTC is enabled, the display will be changed
491 * according to the new panel fitting mode.
492 */
Chris Wilsonc0c36b942012-12-19 16:08:43 +0000493 intel_crtc_restore_mode(crtc);
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800494 }
495 }
496
Jesse Barnes335041e2009-01-22 22:22:06 +1000497 return 0;
498}
499
Jesse Barnes79e53942008-11-07 14:24:08 -0800500static const struct drm_encoder_helper_funcs intel_lvds_helper_funcs = {
Jesse Barnes79e53942008-11-07 14:24:08 -0800501 .mode_set = intel_lvds_mode_set,
Jesse Barnes79e53942008-11-07 14:24:08 -0800502};
503
504static const struct drm_connector_helper_funcs intel_lvds_connector_helper_funcs = {
505 .get_modes = intel_lvds_get_modes,
506 .mode_valid = intel_lvds_mode_valid,
Chris Wilsondf0e9242010-09-09 16:20:55 +0100507 .best_encoder = intel_best_encoder,
Jesse Barnes79e53942008-11-07 14:24:08 -0800508};
509
510static const struct drm_connector_funcs intel_lvds_connector_funcs = {
Daniel Vetterc22834e2012-06-30 15:31:28 +0200511 .dpms = intel_connector_dpms,
Jesse Barnes79e53942008-11-07 14:24:08 -0800512 .detect = intel_lvds_detect,
513 .fill_modes = drm_helper_probe_single_connector_modes,
Jesse Barnes335041e2009-01-22 22:22:06 +1000514 .set_property = intel_lvds_set_property,
Jesse Barnes79e53942008-11-07 14:24:08 -0800515 .destroy = intel_lvds_destroy,
516};
517
Jesse Barnes79e53942008-11-07 14:24:08 -0800518static const struct drm_encoder_funcs intel_lvds_enc_funcs = {
Chris Wilsonea5b2132010-08-04 13:50:23 +0100519 .destroy = intel_encoder_destroy,
Jesse Barnes79e53942008-11-07 14:24:08 -0800520};
521
Jarod Wilson425d2442009-05-05 10:00:25 -0400522static int __init intel_no_lvds_dmi_callback(const struct dmi_system_id *id)
523{
Daniel Vetterbc0daf42012-04-01 13:16:49 +0200524 DRM_INFO("Skipping LVDS initialization for %s\n", id->ident);
Jarod Wilson425d2442009-05-05 10:00:25 -0400525 return 1;
526}
Jesse Barnes79e53942008-11-07 14:24:08 -0800527
Jarod Wilson425d2442009-05-05 10:00:25 -0400528/* These systems claim to have LVDS, but really don't */
Jaswinder Singh Rajput93c05f22009-06-04 09:41:19 +1000529static const struct dmi_system_id intel_no_lvds[] = {
Jarod Wilson425d2442009-05-05 10:00:25 -0400530 {
531 .callback = intel_no_lvds_dmi_callback,
532 .ident = "Apple Mac Mini (Core series)",
533 .matches = {
Keith Packard98acd462009-06-14 12:31:58 -0700534 DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
Jarod Wilson425d2442009-05-05 10:00:25 -0400535 DMI_MATCH(DMI_PRODUCT_NAME, "Macmini1,1"),
536 },
537 },
538 {
539 .callback = intel_no_lvds_dmi_callback,
540 .ident = "Apple Mac Mini (Core 2 series)",
541 .matches = {
Keith Packard98acd462009-06-14 12:31:58 -0700542 DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
Jarod Wilson425d2442009-05-05 10:00:25 -0400543 DMI_MATCH(DMI_PRODUCT_NAME, "Macmini2,1"),
544 },
545 },
546 {
547 .callback = intel_no_lvds_dmi_callback,
548 .ident = "MSI IM-945GSE-A",
549 .matches = {
550 DMI_MATCH(DMI_SYS_VENDOR, "MSI"),
551 DMI_MATCH(DMI_PRODUCT_NAME, "A9830IMS"),
552 },
553 },
554 {
555 .callback = intel_no_lvds_dmi_callback,
556 .ident = "Dell Studio Hybrid",
557 .matches = {
558 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
559 DMI_MATCH(DMI_PRODUCT_NAME, "Studio Hybrid 140g"),
560 },
561 },
Jarod Wilson70aa96c2009-05-27 17:20:39 -0400562 {
563 .callback = intel_no_lvds_dmi_callback,
Pieterjan Camerlynckb0662542011-07-26 16:23:54 +0200564 .ident = "Dell OptiPlex FX170",
565 .matches = {
566 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
567 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex FX170"),
568 },
569 },
570 {
571 .callback = intel_no_lvds_dmi_callback,
Jarod Wilson70aa96c2009-05-27 17:20:39 -0400572 .ident = "AOpen Mini PC",
573 .matches = {
574 DMI_MATCH(DMI_SYS_VENDOR, "AOpen"),
575 DMI_MATCH(DMI_PRODUCT_NAME, "i965GMx-IF"),
576 },
577 },
Michael Cousinfa0864b2009-06-05 21:16:22 +0200578 {
579 .callback = intel_no_lvds_dmi_callback,
Tormod Voldened8c7542009-07-13 22:26:48 +0200580 .ident = "AOpen Mini PC MP915",
581 .matches = {
582 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
583 DMI_MATCH(DMI_BOARD_NAME, "i915GMx-F"),
584 },
585 },
586 {
587 .callback = intel_no_lvds_dmi_callback,
Knut Petersen22ab70d2011-01-14 15:38:10 +0000588 .ident = "AOpen i915GMm-HFS",
589 .matches = {
590 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
591 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
592 },
593 },
594 {
595 .callback = intel_no_lvds_dmi_callback,
Daniel Vettere57b6882012-02-08 16:42:52 +0100596 .ident = "AOpen i45GMx-I",
597 .matches = {
598 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
599 DMI_MATCH(DMI_BOARD_NAME, "i45GMx-I"),
600 },
601 },
602 {
603 .callback = intel_no_lvds_dmi_callback,
Michael Cousinfa0864b2009-06-05 21:16:22 +0200604 .ident = "Aopen i945GTt-VFA",
605 .matches = {
606 DMI_MATCH(DMI_PRODUCT_VERSION, "AO00001JW"),
607 },
608 },
Stefan Bader9875557ee82010-03-29 17:53:12 +0200609 {
610 .callback = intel_no_lvds_dmi_callback,
611 .ident = "Clientron U800",
612 .matches = {
613 DMI_MATCH(DMI_SYS_VENDOR, "Clientron"),
614 DMI_MATCH(DMI_PRODUCT_NAME, "U800"),
615 },
616 },
Hans de Goede6a574b52011-06-04 15:39:21 +0200617 {
Joel Sass44306ab2012-01-10 13:03:55 -0500618 .callback = intel_no_lvds_dmi_callback,
619 .ident = "Clientron E830",
620 .matches = {
621 DMI_MATCH(DMI_SYS_VENDOR, "Clientron"),
622 DMI_MATCH(DMI_PRODUCT_NAME, "E830"),
623 },
624 },
625 {
Hans de Goede6a574b52011-06-04 15:39:21 +0200626 .callback = intel_no_lvds_dmi_callback,
627 .ident = "Asus EeeBox PC EB1007",
628 .matches = {
629 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer INC."),
630 DMI_MATCH(DMI_PRODUCT_NAME, "EB1007"),
631 },
632 },
Adam Jackson0999bbe2011-11-28 12:22:56 -0500633 {
634 .callback = intel_no_lvds_dmi_callback,
635 .ident = "Asus AT5NM10T-I",
636 .matches = {
637 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
638 DMI_MATCH(DMI_BOARD_NAME, "AT5NM10T-I"),
639 },
640 },
Marc Gariepyf5b8a7e2012-02-09 09:35:21 -0500641 {
642 .callback = intel_no_lvds_dmi_callback,
Ben Mesman45a211d2013-04-16 20:00:28 +0200643 .ident = "Hewlett-Packard HP t5740",
Jan-Benedict Glaw33471112012-05-22 15:21:53 +0200644 .matches = {
645 DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
Ben Mesman45a211d2013-04-16 20:00:28 +0200646 DMI_MATCH(DMI_PRODUCT_NAME, " t5740"),
Jan-Benedict Glaw33471112012-05-22 15:21:53 +0200647 },
648 },
649 {
650 .callback = intel_no_lvds_dmi_callback,
Marc Gariepyf5b8a7e2012-02-09 09:35:21 -0500651 .ident = "Hewlett-Packard t5745",
652 .matches = {
653 DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
Marc Gariepy62004972012-05-01 13:37:57 -0400654 DMI_MATCH(DMI_PRODUCT_NAME, "hp t5745"),
Marc Gariepyf5b8a7e2012-02-09 09:35:21 -0500655 },
656 },
657 {
658 .callback = intel_no_lvds_dmi_callback,
659 .ident = "Hewlett-Packard st5747",
660 .matches = {
661 DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
Marc Gariepy62004972012-05-01 13:37:57 -0400662 DMI_MATCH(DMI_PRODUCT_NAME, "hp st5747"),
Marc Gariepyf5b8a7e2012-02-09 09:35:21 -0500663 },
664 },
Anisse Astier97effad2012-03-07 18:36:35 +0100665 {
666 .callback = intel_no_lvds_dmi_callback,
667 .ident = "MSI Wind Box DC500",
668 .matches = {
669 DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"),
670 DMI_MATCH(DMI_BOARD_NAME, "MS-7469"),
671 },
672 },
Sjoerd Simons9756fe32012-06-22 09:43:07 +0200673 {
674 .callback = intel_no_lvds_dmi_callback,
Calvin Waltona51d4ed2012-08-24 07:56:31 -0400675 .ident = "Gigabyte GA-D525TUD",
676 .matches = {
677 DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
678 DMI_MATCH(DMI_BOARD_NAME, "D525TUD"),
679 },
680 },
Chris Wilsonc31407a2012-10-18 21:07:01 +0100681 {
682 .callback = intel_no_lvds_dmi_callback,
683 .ident = "Supermicro X7SPA-H",
684 .matches = {
685 DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
686 DMI_MATCH(DMI_PRODUCT_NAME, "X7SPA-H"),
687 },
688 },
Christian Lamparter9e9dd0e2013-04-03 14:34:11 +0200689 {
690 .callback = intel_no_lvds_dmi_callback,
691 .ident = "Fujitsu Esprimo Q900",
692 .matches = {
693 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
694 DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Q900"),
695 },
696 },
Chris Wilsone5614f02013-07-03 15:05:03 -0700697 {
698 .callback = intel_no_lvds_dmi_callback,
699 .ident = "Intel D510MO",
700 .matches = {
701 DMI_MATCH(DMI_BOARD_VENDOR, "Intel"),
702 DMI_EXACT_MATCH(DMI_BOARD_NAME, "D510MO"),
703 },
704 },
Jani Nikuladcf6d292013-07-03 15:05:05 -0700705 {
706 .callback = intel_no_lvds_dmi_callback,
707 .ident = "Intel D525MW",
708 .matches = {
709 DMI_MATCH(DMI_BOARD_VENDOR, "Intel"),
710 DMI_EXACT_MATCH(DMI_BOARD_NAME, "D525MW"),
711 },
712 },
Jarod Wilson425d2442009-05-05 10:00:25 -0400713
714 { } /* terminating entry */
715};
Jesse Barnes79e53942008-11-07 14:24:08 -0800716
717/**
Zhao Yakui18f9ed12009-11-20 03:24:16 +0000718 * intel_find_lvds_downclock - find the reduced downclock for LVDS in EDID
719 * @dev: drm device
720 * @connector: LVDS connector
721 *
722 * Find the reduced downclock for LVDS in EDID.
723 */
724static void intel_find_lvds_downclock(struct drm_device *dev,
Chris Wilson788319d2010-09-12 17:34:41 +0100725 struct drm_display_mode *fixed_mode,
726 struct drm_connector *connector)
Zhao Yakui18f9ed12009-11-20 03:24:16 +0000727{
728 struct drm_i915_private *dev_priv = dev->dev_private;
Chris Wilson788319d2010-09-12 17:34:41 +0100729 struct drm_display_mode *scan;
Zhao Yakui18f9ed12009-11-20 03:24:16 +0000730 int temp_downclock;
731
Chris Wilson788319d2010-09-12 17:34:41 +0100732 temp_downclock = fixed_mode->clock;
Zhao Yakui18f9ed12009-11-20 03:24:16 +0000733 list_for_each_entry(scan, &connector->probed_modes, head) {
734 /*
735 * If one mode has the same resolution with the fixed_panel
736 * mode while they have the different refresh rate, it means
737 * that the reduced downclock is found for the LVDS. In such
738 * case we can set the different FPx0/1 to dynamically select
739 * between low and high frequency.
740 */
Chris Wilson788319d2010-09-12 17:34:41 +0100741 if (scan->hdisplay == fixed_mode->hdisplay &&
742 scan->hsync_start == fixed_mode->hsync_start &&
743 scan->hsync_end == fixed_mode->hsync_end &&
744 scan->htotal == fixed_mode->htotal &&
745 scan->vdisplay == fixed_mode->vdisplay &&
746 scan->vsync_start == fixed_mode->vsync_start &&
747 scan->vsync_end == fixed_mode->vsync_end &&
748 scan->vtotal == fixed_mode->vtotal) {
Zhao Yakui18f9ed12009-11-20 03:24:16 +0000749 if (scan->clock < temp_downclock) {
750 /*
751 * The downclock is already found. But we
752 * expect to find the lower downclock.
753 */
754 temp_downclock = scan->clock;
755 }
756 }
757 }
Chris Wilson788319d2010-09-12 17:34:41 +0100758 if (temp_downclock < fixed_mode->clock && i915_lvds_downclock) {
Zhao Yakui18f9ed12009-11-20 03:24:16 +0000759 /* We found the downclock for LVDS. */
760 dev_priv->lvds_downclock_avail = 1;
761 dev_priv->lvds_downclock = temp_downclock;
762 DRM_DEBUG_KMS("LVDS downclock is found in EDID. "
Chris Wilson788319d2010-09-12 17:34:41 +0100763 "Normal clock %dKhz, downclock %dKhz\n",
764 fixed_mode->clock, temp_downclock);
Zhao Yakui18f9ed12009-11-20 03:24:16 +0000765 }
Zhao Yakui18f9ed12009-11-20 03:24:16 +0000766}
767
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800768/*
769 * Enumerate the child dev array parsed from VBT to check whether
770 * the LVDS is present.
771 * If it is present, return 1.
772 * If it is not present, return false.
773 * If no child dev is parsed from VBT, it assumes that the LVDS is present.
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800774 */
Chris Wilson270eea02010-09-24 01:15:02 +0100775static bool lvds_is_present_in_vbt(struct drm_device *dev,
776 u8 *i2c_pin)
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800777{
778 struct drm_i915_private *dev_priv = dev->dev_private;
Chris Wilson425904d2010-08-22 18:21:42 +0100779 int i;
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800780
Rodrigo Vivi41aa3442013-05-09 20:03:18 -0300781 if (!dev_priv->vbt.child_dev_num)
Chris Wilson425904d2010-08-22 18:21:42 +0100782 return true;
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800783
Rodrigo Vivi41aa3442013-05-09 20:03:18 -0300784 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) {
785 struct child_device_config *child = dev_priv->vbt.child_dev + i;
Chris Wilson425904d2010-08-22 18:21:42 +0100786
787 /* If the device type is not LFP, continue.
788 * We have to check both the new identifiers as well as the
789 * old for compatibility with some BIOSes.
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800790 */
Chris Wilson425904d2010-08-22 18:21:42 +0100791 if (child->device_type != DEVICE_TYPE_INT_LFP &&
792 child->device_type != DEVICE_TYPE_LFP)
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800793 continue;
794
Daniel Kurtz3bd7d902012-03-28 02:36:14 +0800795 if (intel_gmbus_is_port_valid(child->i2c_pin))
796 *i2c_pin = child->i2c_pin;
Chris Wilson270eea02010-09-24 01:15:02 +0100797
Chris Wilson425904d2010-08-22 18:21:42 +0100798 /* However, we cannot trust the BIOS writers to populate
799 * the VBT correctly. Since LVDS requires additional
800 * information from AIM blocks, a non-zero addin offset is
801 * a good indicator that the LVDS is actually present.
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800802 */
Chris Wilson425904d2010-08-22 18:21:42 +0100803 if (child->addin_offset)
804 return true;
805
806 /* But even then some BIOS writers perform some black magic
807 * and instantiate the device without reference to any
808 * additional data. Trust that if the VBT was written into
809 * the OpRegion then they have validated the LVDS's existence.
810 */
811 if (dev_priv->opregion.vbt)
812 return true;
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800813 }
Chris Wilson425904d2010-08-22 18:21:42 +0100814
815 return false;
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800816}
817
Daniel Vetter1974cad2012-11-26 17:22:09 +0100818static int intel_dual_link_lvds_callback(const struct dmi_system_id *id)
819{
820 DRM_INFO("Forcing lvds to dual link mode on %s\n", id->ident);
821 return 1;
822}
823
824static const struct dmi_system_id intel_dual_link_lvds[] = {
825 {
826 .callback = intel_dual_link_lvds_callback,
827 .ident = "Apple MacBook Pro (Core i5/i7 Series)",
828 .matches = {
829 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
830 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro8,2"),
831 },
832 },
833 { } /* terminating entry */
834};
835
836bool intel_is_dual_link_lvds(struct drm_device *dev)
837{
Daniel Vetter13c7d872012-11-26 17:22:10 +0100838 struct intel_encoder *encoder;
839 struct intel_lvds_encoder *lvds_encoder;
840
841 list_for_each_entry(encoder, &dev->mode_config.encoder_list,
842 base.head) {
843 if (encoder->type == INTEL_OUTPUT_LVDS) {
844 lvds_encoder = to_lvds_encoder(&encoder->base);
845
846 return lvds_encoder->is_dual_link;
847 }
848 }
849
850 return false;
851}
852
Daniel Vetter7dec0602012-09-11 14:12:25 +0200853static bool compute_is_dual_link_lvds(struct intel_lvds_encoder *lvds_encoder)
Daniel Vetter13c7d872012-11-26 17:22:10 +0100854{
Daniel Vetter7dec0602012-09-11 14:12:25 +0200855 struct drm_device *dev = lvds_encoder->base.base.dev;
Daniel Vetter1974cad2012-11-26 17:22:09 +0100856 unsigned int val;
857 struct drm_i915_private *dev_priv = dev->dev_private;
Daniel Vetter1974cad2012-11-26 17:22:09 +0100858
859 /* use the module option value if specified */
860 if (i915_lvds_channel_mode > 0)
861 return i915_lvds_channel_mode == 2;
862
863 if (dmi_check_system(intel_dual_link_lvds))
864 return true;
865
Daniel Vetter13c7d872012-11-26 17:22:10 +0100866 /* BIOS should set the proper LVDS register value at boot, but
867 * in reality, it doesn't set the value when the lid is closed;
868 * we need to check "the value to be set" in VBT when LVDS
869 * register is uninitialized.
870 */
Daniel Vetter7dec0602012-09-11 14:12:25 +0200871 val = I915_READ(lvds_encoder->reg);
Daniel Vetter13c7d872012-11-26 17:22:10 +0100872 if (!(val & ~(LVDS_PIPE_MASK | LVDS_DETECTED)))
Rodrigo Vivi41aa3442013-05-09 20:03:18 -0300873 val = dev_priv->vbt.bios_lvds_val;
Daniel Vetter13c7d872012-11-26 17:22:10 +0100874
Daniel Vetter1974cad2012-11-26 17:22:09 +0100875 return (val & LVDS_CLKB_POWER_MASK) == LVDS_CLKB_POWER_UP;
876}
877
Chris Wilsonf3cfcba2012-02-09 09:35:53 +0000878static bool intel_lvds_supported(struct drm_device *dev)
879{
880 /* With the introduction of the PCH we gained a dedicated
881 * LVDS presence pin, use it. */
Paulo Zanoni311e3592013-03-06 20:03:19 -0300882 if (HAS_PCH_IBX(dev) || HAS_PCH_CPT(dev))
Chris Wilsonf3cfcba2012-02-09 09:35:53 +0000883 return true;
884
885 /* Otherwise LVDS was only attached to mobile products,
886 * except for the inglorious 830gm */
Paulo Zanoni311e3592013-03-06 20:03:19 -0300887 if (INTEL_INFO(dev)->gen <= 4 && IS_MOBILE(dev) && !IS_I830(dev))
888 return true;
889
890 return false;
Chris Wilsonf3cfcba2012-02-09 09:35:53 +0000891}
892
Zhao Yakui18f9ed12009-11-20 03:24:16 +0000893/**
Jesse Barnes79e53942008-11-07 14:24:08 -0800894 * intel_lvds_init - setup LVDS connectors on this device
895 * @dev: drm device
896 *
897 * Create the connector, register the LVDS DDC bus, and try to figure out what
898 * modes we can display on the LVDS panel (if present).
899 */
Daniel Vetterc9093352013-06-06 22:22:47 +0200900void intel_lvds_init(struct drm_device *dev)
Jesse Barnes79e53942008-11-07 14:24:08 -0800901{
902 struct drm_i915_private *dev_priv = dev->dev_private;
Jani Nikula29b99b42012-10-19 14:51:43 +0300903 struct intel_lvds_encoder *lvds_encoder;
Eric Anholt21d40d32010-03-25 11:11:14 -0700904 struct intel_encoder *intel_encoder;
Jani Nikulac7362c42012-10-19 14:51:44 +0300905 struct intel_lvds_connector *lvds_connector;
Zhenyu Wangbb8a3562010-03-29 16:40:50 +0800906 struct intel_connector *intel_connector;
Jesse Barnes79e53942008-11-07 14:24:08 -0800907 struct drm_connector *connector;
908 struct drm_encoder *encoder;
909 struct drm_display_mode *scan; /* *modes, *bios_mode; */
Jani Nikuladd06f902012-10-19 14:51:50 +0300910 struct drm_display_mode *fixed_mode = NULL;
Jani Nikula9cd300e2012-10-19 14:51:52 +0300911 struct edid *edid;
Jesse Barnes79e53942008-11-07 14:24:08 -0800912 struct drm_crtc *crtc;
913 u32 lvds;
Chris Wilson270eea02010-09-24 01:15:02 +0100914 int pipe;
915 u8 pin;
Jesse Barnes79e53942008-11-07 14:24:08 -0800916
Chris Wilsonf3cfcba2012-02-09 09:35:53 +0000917 if (!intel_lvds_supported(dev))
Daniel Vetterc9093352013-06-06 22:22:47 +0200918 return;
Chris Wilsonf3cfcba2012-02-09 09:35:53 +0000919
Jarod Wilson425d2442009-05-05 10:00:25 -0400920 /* Skip init on machines we know falsely report LVDS */
921 if (dmi_check_system(intel_no_lvds))
Daniel Vetterc9093352013-06-06 22:22:47 +0200922 return;
Paul Collins565dcd42009-02-04 23:05:41 +1300923
Chris Wilson270eea02010-09-24 01:15:02 +0100924 pin = GMBUS_PORT_PANEL;
925 if (!lvds_is_present_in_vbt(dev, &pin)) {
Matthew Garrett11ba1592009-12-15 13:55:24 -0500926 DRM_DEBUG_KMS("LVDS is not present in VBT\n");
Daniel Vetterc9093352013-06-06 22:22:47 +0200927 return;
Zhao Yakui7cf4f692009-11-24 09:48:47 +0800928 }
Zhao Yakuie99da352009-06-26 09:46:18 +0800929
Eric Anholtc619eed2010-01-28 16:45:52 -0800930 if (HAS_PCH_SPLIT(dev)) {
Zhenyu Wang541998a2009-06-05 15:38:44 +0800931 if ((I915_READ(PCH_LVDS) & LVDS_DETECTED) == 0)
Daniel Vetterc9093352013-06-06 22:22:47 +0200932 return;
Rodrigo Vivi41aa3442013-05-09 20:03:18 -0300933 if (dev_priv->vbt.edp_support) {
Zhao Yakui28c97732009-10-09 11:39:41 +0800934 DRM_DEBUG_KMS("disable LVDS for eDP support\n");
Daniel Vetterc9093352013-06-06 22:22:47 +0200935 return;
Zhenyu Wang32f9d652009-07-24 01:00:32 +0800936 }
Zhenyu Wang541998a2009-06-05 15:38:44 +0800937 }
938
Jani Nikula29b99b42012-10-19 14:51:43 +0300939 lvds_encoder = kzalloc(sizeof(struct intel_lvds_encoder), GFP_KERNEL);
940 if (!lvds_encoder)
Daniel Vetterc9093352013-06-06 22:22:47 +0200941 return;
Jesse Barnes79e53942008-11-07 14:24:08 -0800942
Jani Nikulac7362c42012-10-19 14:51:44 +0300943 lvds_connector = kzalloc(sizeof(struct intel_lvds_connector), GFP_KERNEL);
944 if (!lvds_connector) {
Jani Nikula29b99b42012-10-19 14:51:43 +0300945 kfree(lvds_encoder);
Daniel Vetterc9093352013-06-06 22:22:47 +0200946 return;
Jesse Barnes79e53942008-11-07 14:24:08 -0800947 }
948
Jani Nikula62165e02012-10-19 14:51:47 +0300949 lvds_encoder->attached_connector = lvds_connector;
Zhenyu Wangbb8a3562010-03-29 16:40:50 +0800950
Jani Nikula29b99b42012-10-19 14:51:43 +0300951 intel_encoder = &lvds_encoder->base;
Chris Wilson4ef69c72010-09-09 15:14:28 +0100952 encoder = &intel_encoder->base;
Jani Nikulac7362c42012-10-19 14:51:44 +0300953 intel_connector = &lvds_connector->base;
Chris Wilsonea5b2132010-08-04 13:50:23 +0100954 connector = &intel_connector->base;
Zhenyu Wangbb8a3562010-03-29 16:40:50 +0800955 drm_connector_init(dev, &intel_connector->base, &intel_lvds_connector_funcs,
Jesse Barnes79e53942008-11-07 14:24:08 -0800956 DRM_MODE_CONNECTOR_LVDS);
957
Chris Wilson4ef69c72010-09-09 15:14:28 +0100958 drm_encoder_init(dev, &intel_encoder->base, &intel_lvds_enc_funcs,
Jesse Barnes79e53942008-11-07 14:24:08 -0800959 DRM_MODE_ENCODER_LVDS);
960
Daniel Vetterc22834e2012-06-30 15:31:28 +0200961 intel_encoder->enable = intel_enable_lvds;
Daniel Vetterfc683092012-11-26 17:22:12 +0100962 intel_encoder->pre_pll_enable = intel_pre_pll_enable_lvds;
Daniel Vetter7ae89232013-03-27 00:44:52 +0100963 intel_encoder->compute_config = intel_lvds_compute_config;
Daniel Vetterc22834e2012-06-30 15:31:28 +0200964 intel_encoder->disable = intel_disable_lvds;
Daniel Vetterb1dc3322012-07-02 21:09:00 +0200965 intel_encoder->get_hw_state = intel_lvds_get_hw_state;
Jesse Barnes045ac3b2013-05-14 17:08:26 -0700966 intel_encoder->get_config = intel_lvds_get_config;
Daniel Vetterb1dc3322012-07-02 21:09:00 +0200967 intel_connector->get_hw_state = intel_connector_get_hw_state;
Daniel Vetterc22834e2012-06-30 15:31:28 +0200968
Chris Wilsondf0e9242010-09-09 16:20:55 +0100969 intel_connector_attach_encoder(intel_connector, intel_encoder);
Eric Anholt21d40d32010-03-25 11:11:14 -0700970 intel_encoder->type = INTEL_OUTPUT_LVDS;
Jesse Barnes79e53942008-11-07 14:24:08 -0800971
Daniel Vetter66a92782012-07-12 20:08:18 +0200972 intel_encoder->cloneable = false;
Jesse Barnes27f82272011-09-02 12:54:37 -0700973 if (HAS_PCH_SPLIT(dev))
974 intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);
Daniel Vetter0b9f43a2012-06-05 10:07:11 +0200975 else if (IS_GEN4(dev))
976 intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
Jesse Barnes27f82272011-09-02 12:54:37 -0700977 else
978 intel_encoder->crtc_mask = (1 << 1);
979
Jesse Barnes79e53942008-11-07 14:24:08 -0800980 drm_encoder_helper_add(encoder, &intel_lvds_helper_funcs);
981 drm_connector_helper_add(connector, &intel_lvds_connector_helper_funcs);
982 connector->display_info.subpixel_order = SubPixelHorizontalRGB;
983 connector->interlace_allowed = false;
984 connector->doublescan_allowed = false;
985
Daniel Vetter7dec0602012-09-11 14:12:25 +0200986 if (HAS_PCH_SPLIT(dev)) {
987 lvds_encoder->reg = PCH_LVDS;
988 } else {
989 lvds_encoder->reg = LVDS;
990 }
991
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800992 /* create the scaling mode property */
993 drm_mode_create_scaling_mode_property(dev);
Rob Clark662595d2012-10-11 20:36:04 -0500994 drm_object_attach_property(&connector->base,
Zhao Yakui3fbe18d2009-06-22 15:31:25 +0800995 dev->mode_config.scaling_mode_property,
Jesse Barnesdd1ea372010-06-24 11:05:10 -0700996 DRM_MODE_SCALE_ASPECT);
Jani Nikula4d891522012-10-26 12:03:59 +0300997 intel_connector->panel.fitting_mode = DRM_MODE_SCALE_ASPECT;
Jesse Barnes79e53942008-11-07 14:24:08 -0800998 /*
999 * LVDS discovery:
1000 * 1) check for EDID on DDC
1001 * 2) check for VBT data
1002 * 3) check to see if LVDS is already on
1003 * if none of the above, no panel
1004 * 4) make sure lid is open
1005 * if closed, act like it's not there for now
1006 */
1007
Jesse Barnes79e53942008-11-07 14:24:08 -08001008 /*
1009 * Attempt to get the fixed panel mode from DDC. Assume that the
1010 * preferred mode is the right one.
1011 */
Jani Nikula9cd300e2012-10-19 14:51:52 +03001012 edid = drm_get_edid(connector, intel_gmbus_get_adapter(dev_priv, pin));
1013 if (edid) {
1014 if (drm_add_edid_modes(connector, edid)) {
Chris Wilson3f8ff0e2010-11-08 23:20:52 +00001015 drm_mode_connector_update_edid_property(connector,
Jani Nikula9cd300e2012-10-19 14:51:52 +03001016 edid);
Chris Wilson3f8ff0e2010-11-08 23:20:52 +00001017 } else {
Jani Nikula9cd300e2012-10-19 14:51:52 +03001018 kfree(edid);
1019 edid = ERR_PTR(-EINVAL);
Chris Wilson3f8ff0e2010-11-08 23:20:52 +00001020 }
Jani Nikula9cd300e2012-10-19 14:51:52 +03001021 } else {
1022 edid = ERR_PTR(-ENOENT);
Chris Wilson3f8ff0e2010-11-08 23:20:52 +00001023 }
Jani Nikula9cd300e2012-10-19 14:51:52 +03001024 lvds_connector->base.edid = edid;
1025
1026 if (IS_ERR_OR_NULL(edid)) {
Chris Wilson788319d2010-09-12 17:34:41 +01001027 /* Didn't get an EDID, so
1028 * Set wide sync ranges so we get all modes
1029 * handed to valid_mode for checking
1030 */
1031 connector->display_info.min_vfreq = 0;
1032 connector->display_info.max_vfreq = 200;
1033 connector->display_info.min_hfreq = 0;
1034 connector->display_info.max_hfreq = 200;
1035 }
Jesse Barnes79e53942008-11-07 14:24:08 -08001036
1037 list_for_each_entry(scan, &connector->probed_modes, head) {
Jesse Barnes79e53942008-11-07 14:24:08 -08001038 if (scan->type & DRM_MODE_TYPE_PREFERRED) {
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001039 DRM_DEBUG_KMS("using preferred mode from EDID: ");
1040 drm_mode_debug_printmodeline(scan);
1041
Jani Nikuladd06f902012-10-19 14:51:50 +03001042 fixed_mode = drm_mode_duplicate(dev, scan);
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001043 if (fixed_mode) {
1044 intel_find_lvds_downclock(dev, fixed_mode,
1045 connector);
1046 goto out;
1047 }
Jesse Barnes79e53942008-11-07 14:24:08 -08001048 }
Jesse Barnes79e53942008-11-07 14:24:08 -08001049 }
1050
1051 /* Failed to get EDID, what about VBT? */
Rodrigo Vivi41aa3442013-05-09 20:03:18 -03001052 if (dev_priv->vbt.lfp_lvds_vbt_mode) {
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001053 DRM_DEBUG_KMS("using mode from VBT: ");
Rodrigo Vivi41aa3442013-05-09 20:03:18 -03001054 drm_mode_debug_printmodeline(dev_priv->vbt.lfp_lvds_vbt_mode);
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001055
Rodrigo Vivi41aa3442013-05-09 20:03:18 -03001056 fixed_mode = drm_mode_duplicate(dev, dev_priv->vbt.lfp_lvds_vbt_mode);
Jani Nikuladd06f902012-10-19 14:51:50 +03001057 if (fixed_mode) {
1058 fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
Jesse Barnese285f3c2009-01-14 10:53:36 -08001059 goto out;
1060 }
Jesse Barnes79e53942008-11-07 14:24:08 -08001061 }
1062
1063 /*
1064 * If we didn't get EDID, try checking if the panel is already turned
1065 * on. If so, assume that whatever is currently programmed is the
1066 * correct mode.
1067 */
Zhenyu Wang541998a2009-06-05 15:38:44 +08001068
Adam Jacksonf2b115e2009-12-03 17:14:42 -05001069 /* Ironlake: FIXME if still fail, not try pipe mode now */
Eric Anholtc619eed2010-01-28 16:45:52 -08001070 if (HAS_PCH_SPLIT(dev))
Zhenyu Wang541998a2009-06-05 15:38:44 +08001071 goto failed;
1072
Jesse Barnes79e53942008-11-07 14:24:08 -08001073 lvds = I915_READ(LVDS);
1074 pipe = (lvds & LVDS_PIPEB_SELECT) ? 1 : 0;
Chris Wilsonf875c152010-09-09 15:44:14 +01001075 crtc = intel_get_crtc_for_pipe(dev, pipe);
Jesse Barnes79e53942008-11-07 14:24:08 -08001076
1077 if (crtc && (lvds & LVDS_PORT_EN)) {
Jani Nikuladd06f902012-10-19 14:51:50 +03001078 fixed_mode = intel_crtc_mode_get(dev, crtc);
1079 if (fixed_mode) {
Chris Wilson6a9d51b2012-11-21 16:14:03 +00001080 DRM_DEBUG_KMS("using current (BIOS) mode: ");
1081 drm_mode_debug_printmodeline(fixed_mode);
Jani Nikuladd06f902012-10-19 14:51:50 +03001082 fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
Paul Collins565dcd42009-02-04 23:05:41 +13001083 goto out;
Jesse Barnes79e53942008-11-07 14:24:08 -08001084 }
1085 }
1086
1087 /* If we still don't have a mode after all that, give up. */
Jani Nikuladd06f902012-10-19 14:51:50 +03001088 if (!fixed_mode)
Jesse Barnes79e53942008-11-07 14:24:08 -08001089 goto failed;
1090
Jesse Barnes79e53942008-11-07 14:24:08 -08001091out:
Daniel Vetter7dec0602012-09-11 14:12:25 +02001092 lvds_encoder->is_dual_link = compute_is_dual_link_lvds(lvds_encoder);
Daniel Vetter13c7d872012-11-26 17:22:10 +01001093 DRM_DEBUG_KMS("detected %s-link lvds configuration\n",
1094 lvds_encoder->is_dual_link ? "dual" : "single");
1095
Daniel Vetter24ded202012-06-05 12:14:54 +02001096 /*
1097 * Unlock registers and just
1098 * leave them unlocked
1099 */
Eric Anholtc619eed2010-01-28 16:45:52 -08001100 if (HAS_PCH_SPLIT(dev)) {
Keith Packarded10fca2011-08-06 10:33:12 -07001101 I915_WRITE(PCH_PP_CONTROL,
1102 I915_READ(PCH_PP_CONTROL) | PANEL_UNLOCK_REGS);
1103 } else {
Keith Packarded10fca2011-08-06 10:33:12 -07001104 I915_WRITE(PP_CONTROL,
1105 I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
Zhenyu Wang541998a2009-06-05 15:38:44 +08001106 }
Jani Nikuladb1740a2012-10-19 14:51:45 +03001107 lvds_connector->lid_notifier.notifier_call = intel_lid_notify;
1108 if (acpi_lid_notifier_register(&lvds_connector->lid_notifier)) {
Zhao Yakui28c97732009-10-09 11:39:41 +08001109 DRM_DEBUG_KMS("lid notifier registration failed\n");
Jani Nikuladb1740a2012-10-19 14:51:45 +03001110 lvds_connector->lid_notifier.notifier_call = NULL;
Jesse Barnesc1c7af62009-09-10 15:28:03 -07001111 }
Jesse Barnes79e53942008-11-07 14:24:08 -08001112 drm_sysfs_connector_add(connector);
Matthew Garrettaaa6fd22011-08-12 12:11:33 +02001113
Jani Nikuladd06f902012-10-19 14:51:50 +03001114 intel_panel_init(&intel_connector->panel, fixed_mode);
Jani Nikula0657b6b2012-10-19 14:51:46 +03001115 intel_panel_setup_backlight(connector);
Matthew Garrettaaa6fd22011-08-12 12:11:33 +02001116
Daniel Vetterc9093352013-06-06 22:22:47 +02001117 return;
Jesse Barnes79e53942008-11-07 14:24:08 -08001118
1119failed:
Zhao Yakui8a4c47f2009-07-20 13:48:04 +08001120 DRM_DEBUG_KMS("No LVDS modes found, disabling.\n");
Jesse Barnes79e53942008-11-07 14:24:08 -08001121 drm_connector_cleanup(connector);
Shaohua Li1991bdf2009-11-17 17:19:23 +08001122 drm_encoder_cleanup(encoder);
Jani Nikuladd06f902012-10-19 14:51:50 +03001123 if (fixed_mode)
1124 drm_mode_destroy(dev, fixed_mode);
Jani Nikula29b99b42012-10-19 14:51:43 +03001125 kfree(lvds_encoder);
Jani Nikulac7362c42012-10-19 14:51:44 +03001126 kfree(lvds_connector);
Daniel Vetterc9093352013-06-06 22:22:47 +02001127 return;
Jesse Barnes79e53942008-11-07 14:24:08 -08001128}