intel_lvds.c 28.8 KB
Newer Older
J
Jesse Barnes 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*
 * Copyright © 2006-2007 Intel Corporation
 * Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Authors:
 *	Eric Anholt <eric@anholt.net>
 *      Dave Airlie <airlied@linux.ie>
 *      Jesse Barnes <jesse.barnes@intel.com>
 */

30
#include <acpi/button.h>
31
#include <linux/dmi.h>
J
Jesse Barnes 已提交
32
#include <linux/i2c.h>
33
#include <linux/slab.h>
J
Jesse Barnes 已提交
34 35 36 37 38 39 40
#include "drmP.h"
#include "drm.h"
#include "drm_crtc.h"
#include "drm_edid.h"
#include "intel_drv.h"
#include "i915_drm.h"
#include "i915_drv.h"
41
#include <linux/acpi.h>
J
Jesse Barnes 已提交
42

43
/* Private structure for the integrated LVDS support */
C
Chris Wilson 已提交
44 45
struct intel_lvds {
	struct intel_encoder base;
46

C
Chris Wilson 已提交
47
	struct edid *edid;
48

49 50 51
	int fitting_mode;
	u32 pfit_control;
	u32 pfit_pgm_ratios;
52
	bool pfit_dirty;
53 54

	struct drm_display_mode *fixed_mode;
55 56
};

57
static struct intel_lvds *to_intel_lvds(struct drm_encoder *encoder)
C
Chris Wilson 已提交
58
{
59
	return container_of(encoder, struct intel_lvds, base.base);
C
Chris Wilson 已提交
60 61
}

62 63 64 65 66 67
static struct intel_lvds *intel_attached_lvds(struct drm_connector *connector)
{
	return container_of(intel_attached_encoder(connector),
			    struct intel_lvds, base);
}

J
Jesse Barnes 已提交
68 69 70
/**
 * Sets the power state for the panel.
 */
71
static void intel_lvds_set_power(struct intel_lvds *intel_lvds, bool on)
J
Jesse Barnes 已提交
72
{
73
	struct drm_device *dev = intel_lvds->base.base.dev;
J
Jesse Barnes 已提交
74
	struct drm_i915_private *dev_priv = dev->dev_private;
75
	u32 ctl_reg, lvds_reg;
76

77
	if (HAS_PCH_SPLIT(dev)) {
78
		ctl_reg = PCH_PP_CONTROL;
79
		lvds_reg = PCH_LVDS;
80 81
	} else {
		ctl_reg = PP_CONTROL;
82
		lvds_reg = LVDS;
83
	}
J
Jesse Barnes 已提交
84 85

	if (on) {
86
		I915_WRITE(lvds_reg, I915_READ(lvds_reg) | LVDS_PORT_EN);
87
		I915_WRITE(ctl_reg, I915_READ(ctl_reg) | POWER_TARGET_ON);
88
		intel_panel_set_backlight(dev, dev_priv->backlight_level);
J
Jesse Barnes 已提交
89
	} else {
90 91
		dev_priv->backlight_level = intel_panel_get_backlight(dev);

92
		intel_panel_set_backlight(dev, 0);
93
		I915_WRITE(ctl_reg, I915_READ(ctl_reg) & ~POWER_TARGET_ON);
94 95 96 97 98 99 100 101

		if (intel_lvds->pfit_control) {
			if (wait_for((I915_READ(PP_STATUS) & PP_ON) == 0, 1000))
				DRM_ERROR("timed out waiting for panel to power off\n");
			I915_WRITE(PFIT_CONTROL, 0);
			intel_lvds->pfit_control = 0;
		}

102
		I915_WRITE(lvds_reg, I915_READ(lvds_reg) & ~LVDS_PORT_EN);
J
Jesse Barnes 已提交
103
	}
104
	POSTING_READ(lvds_reg);
J
Jesse Barnes 已提交
105 106 107 108
}

static void intel_lvds_dpms(struct drm_encoder *encoder, int mode)
{
109
	struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
J
Jesse Barnes 已提交
110 111

	if (mode == DRM_MODE_DPMS_ON)
112
		intel_lvds_set_power(intel_lvds, true);
J
Jesse Barnes 已提交
113
	else
114
		intel_lvds_set_power(intel_lvds, false);
J
Jesse Barnes 已提交
115 116 117 118 119 120 121

	/* XXX: We never power down the LVDS pairs. */
}

static int intel_lvds_mode_valid(struct drm_connector *connector,
				 struct drm_display_mode *mode)
{
122 123
	struct intel_lvds *intel_lvds = intel_attached_lvds(connector);
	struct drm_display_mode *fixed_mode = intel_lvds->fixed_mode;
J
Jesse Barnes 已提交
124

125 126 127 128
	if (mode->hdisplay > fixed_mode->hdisplay)
		return MODE_PANEL;
	if (mode->vdisplay > fixed_mode->vdisplay)
		return MODE_PANEL;
J
Jesse Barnes 已提交
129 130 131 132

	return MODE_OK;
}

133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
static void
centre_horizontally(struct drm_display_mode *mode,
		    int width)
{
	u32 border, sync_pos, blank_width, sync_width;

	/* keep the hsync and hblank widths constant */
	sync_width = mode->crtc_hsync_end - mode->crtc_hsync_start;
	blank_width = mode->crtc_hblank_end - mode->crtc_hblank_start;
	sync_pos = (blank_width - sync_width + 1) / 2;

	border = (mode->hdisplay - width + 1) / 2;
	border += border & 1; /* make the border even */

	mode->crtc_hdisplay = width;
	mode->crtc_hblank_start = width + border;
	mode->crtc_hblank_end = mode->crtc_hblank_start + blank_width;

	mode->crtc_hsync_start = mode->crtc_hblank_start + sync_pos;
	mode->crtc_hsync_end = mode->crtc_hsync_start + sync_width;
}

static void
centre_vertically(struct drm_display_mode *mode,
		  int height)
{
	u32 border, sync_pos, blank_width, sync_width;

	/* keep the vsync and vblank widths constant */
	sync_width = mode->crtc_vsync_end - mode->crtc_vsync_start;
	blank_width = mode->crtc_vblank_end - mode->crtc_vblank_start;
	sync_pos = (blank_width - sync_width + 1) / 2;

	border = (mode->vdisplay - height + 1) / 2;

	mode->crtc_vdisplay = height;
	mode->crtc_vblank_start = height + border;
	mode->crtc_vblank_end = mode->crtc_vblank_start + blank_width;

	mode->crtc_vsync_start = mode->crtc_vblank_start + sync_pos;
	mode->crtc_vsync_end = mode->crtc_vsync_start + sync_width;
}

static inline u32 panel_fitter_scaling(u32 source, u32 target)
{
	/*
	 * Floating point operation is not supported. So the FACTOR
	 * is defined, which can avoid the floating point computation
	 * when calculating the panel ratio.
	 */
#define ACCURACY 12
#define FACTOR (1 << ACCURACY)
	u32 ratio = source * FACTOR / target;
	return (FACTOR * ratio + FACTOR/2) / FACTOR;
}

J
Jesse Barnes 已提交
189 190 191 192 193 194 195
static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
				  struct drm_display_mode *mode,
				  struct drm_display_mode *adjusted_mode)
{
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
196
	struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
J
Jesse Barnes 已提交
197
	struct drm_encoder *tmp_encoder;
198
	u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0;
J
Jesse Barnes 已提交
199 200

	/* Should never happen!! */
201
	if (INTEL_INFO(dev)->gen < 4 && intel_crtc->pipe == 0) {
202
		DRM_ERROR("Can't support LVDS on pipe A\n");
J
Jesse Barnes 已提交
203 204 205 206 207 208
		return false;
	}

	/* Should never happen!! */
	list_for_each_entry(tmp_encoder, &dev->mode_config.encoder_list, head) {
		if (tmp_encoder != encoder && tmp_encoder->crtc == encoder->crtc) {
209
			DRM_ERROR("Can't enable LVDS and another "
J
Jesse Barnes 已提交
210 211 212 213
			       "encoder on the same pipe\n");
			return false;
		}
	}
214

J
Jesse Barnes 已提交
215
	/*
216
	 * We have timings from the BIOS for the panel, put them in
J
Jesse Barnes 已提交
217 218 219 220
	 * to the adjusted mode.  The CRTC will be set up for this mode,
	 * with the panel scaling set up to source from the H/VDisplay
	 * of the original mode.
	 */
221
	intel_fixed_panel_mode(intel_lvds->fixed_mode, adjusted_mode);
222 223 224 225 226 227

	if (HAS_PCH_SPLIT(dev)) {
		intel_pch_panel_fitting(dev, intel_lvds->fitting_mode,
					mode, adjusted_mode);
		return true;
	}
J
Jesse Barnes 已提交
228

229
	/* Make sure pre-965s set dither correctly */
230
	if (INTEL_INFO(dev)->gen < 4) {
231 232 233 234 235 236
		if (dev_priv->panel_wants_dither || dev_priv->lvds_dither)
			pfit_control |= PANEL_8TO6_DITHER_ENABLE;
	}

	/* Native modes don't need fitting */
	if (adjusted_mode->hdisplay == mode->hdisplay &&
237
	    adjusted_mode->vdisplay == mode->vdisplay)
238 239 240
		goto out;

	/* 965+ wants fuzzy fitting */
241
	if (INTEL_INFO(dev)->gen >= 4)
242 243 244
		pfit_control |= ((intel_crtc->pipe << PFIT_PIPE_SHIFT) |
				 PFIT_FILTER_FUZZY);

245 246 247 248 249 250
	/*
	 * Enable automatic panel scaling for non-native modes so that they fill
	 * the screen.  Should be enabled before the pipe is enabled, according
	 * to register description and PRM.
	 * Change the value here to see the borders for debugging
	 */
251 252
	I915_WRITE(BCLRPAT_A, 0);
	I915_WRITE(BCLRPAT_B, 0);
253

C
Chris Wilson 已提交
254
	switch (intel_lvds->fitting_mode) {
255
	case DRM_MODE_SCALE_CENTER:
256 257 258 259
		/*
		 * For centered modes, we have to calculate border widths &
		 * heights and modify the values programmed into the CRTC.
		 */
260 261 262
		centre_horizontally(adjusted_mode, mode->hdisplay);
		centre_vertically(adjusted_mode, mode->vdisplay);
		border = LVDS_BORDER_ENABLE;
263
		break;
264

265
	case DRM_MODE_SCALE_ASPECT:
266
		/* Scale but preserve the aspect ratio */
267
		if (INTEL_INFO(dev)->gen >= 4) {
268 269 270 271
			u32 scaled_width = adjusted_mode->hdisplay * mode->vdisplay;
			u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;

			pfit_control |= PFIT_ENABLE;
272
			/* 965+ is easy, it does everything in hw */
273
			if (scaled_width > scaled_height)
274
				pfit_control |= PFIT_SCALING_PILLAR;
275
			else if (scaled_width < scaled_height)
276 277 278 279
				pfit_control |= PFIT_SCALING_LETTER;
			else
				pfit_control |= PFIT_SCALING_AUTO;
		} else {
280 281
			u32 scaled_width = adjusted_mode->hdisplay * mode->vdisplay;
			u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;
282 283 284 285 286
			/*
			 * For earlier chips we have to calculate the scaling
			 * ratio by hand and program it into the
			 * PFIT_PGM_RATIO register
			 */
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
			if (scaled_width > scaled_height) { /* pillar */
				centre_horizontally(adjusted_mode, scaled_height / mode->vdisplay);

				border = LVDS_BORDER_ENABLE;
				if (mode->vdisplay != adjusted_mode->vdisplay) {
					u32 bits = panel_fitter_scaling(mode->vdisplay, adjusted_mode->vdisplay);
					pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT |
							    bits << PFIT_VERT_SCALE_SHIFT);
					pfit_control |= (PFIT_ENABLE |
							 VERT_INTERP_BILINEAR |
							 HORIZ_INTERP_BILINEAR);
				}
			} else if (scaled_width < scaled_height) { /* letter */
				centre_vertically(adjusted_mode, scaled_width / mode->hdisplay);

				border = LVDS_BORDER_ENABLE;
				if (mode->hdisplay != adjusted_mode->hdisplay) {
					u32 bits = panel_fitter_scaling(mode->hdisplay, adjusted_mode->hdisplay);
					pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT |
							    bits << PFIT_VERT_SCALE_SHIFT);
					pfit_control |= (PFIT_ENABLE |
							 VERT_INTERP_BILINEAR |
							 HORIZ_INTERP_BILINEAR);
				}
			} else
				/* Aspects match, Let hw scale both directions */
				pfit_control |= (PFIT_ENABLE |
						 VERT_AUTO_SCALE | HORIZ_AUTO_SCALE |
315 316 317 318 319 320 321 322 323 324 325
						 VERT_INTERP_BILINEAR |
						 HORIZ_INTERP_BILINEAR);
		}
		break;

	case DRM_MODE_SCALE_FULLSCREEN:
		/*
		 * Full scaling, even if it changes the aspect ratio.
		 * Fortunately this is all done for us in hw.
		 */
		pfit_control |= PFIT_ENABLE;
326
		if (INTEL_INFO(dev)->gen >= 4)
327 328 329 330 331 332
			pfit_control |= PFIT_SCALING_AUTO;
		else
			pfit_control |= (VERT_AUTO_SCALE | HORIZ_AUTO_SCALE |
					 VERT_INTERP_BILINEAR |
					 HORIZ_INTERP_BILINEAR);
		break;
333

334 335 336 337 338
	default:
		break;
	}

out:
339 340 341 342 343 344
	if (pfit_control != intel_lvds->pfit_control ||
	    pfit_pgm_ratios != intel_lvds->pfit_pgm_ratios) {
		intel_lvds->pfit_control = pfit_control;
		intel_lvds->pfit_pgm_ratios = pfit_pgm_ratios;
		intel_lvds->pfit_dirty = true;
	}
345 346
	dev_priv->lvds_border_bits = border;

J
Jesse Barnes 已提交
347 348 349 350 351 352 353 354 355 356 357 358 359
	/*
	 * XXX: It would be nice to support lower refresh rates on the
	 * panels to reduce power consumption, and perhaps match the
	 * user's requested refresh rate.
	 */

	return true;
}

static void intel_lvds_prepare(struct drm_encoder *encoder)
{
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
360
	struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
J
Jesse Barnes 已提交
361

362
	dev_priv->backlight_level = intel_panel_get_backlight(dev);
J
Jesse Barnes 已提交
363

364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
	/* We try to do the minimum that is necessary in order to unlock
	 * the registers for mode setting.
	 *
	 * On Ironlake, this is quite simple as we just set the unlock key
	 * and ignore all subtleties. (This may cause some issues...)
	 *
	 * Prior to Ironlake, we must disable the pipe if we want to adjust
	 * the panel fitter. However at all other times we can just reset
	 * the registers regardless.
	 */

	if (HAS_PCH_SPLIT(dev)) {
		I915_WRITE(PCH_PP_CONTROL,
			   I915_READ(PCH_PP_CONTROL) | PANEL_UNLOCK_REGS);
	} else if (intel_lvds->pfit_dirty) {
		I915_WRITE(PP_CONTROL,
			   I915_READ(PP_CONTROL) & ~POWER_TARGET_ON);
		I915_WRITE(LVDS, I915_READ(LVDS) & ~LVDS_PORT_EN);
	} else {
		I915_WRITE(PP_CONTROL,
			   I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
	}
J
Jesse Barnes 已提交
386 387
}

388
static void intel_lvds_commit(struct drm_encoder *encoder)
J
Jesse Barnes 已提交
389 390 391
{
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
392
	struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
J
Jesse Barnes 已提交
393

394 395
	if (dev_priv->backlight_level == 0)
		dev_priv->backlight_level = intel_panel_get_max_backlight(dev);
J
Jesse Barnes 已提交
396

397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
	/* Undo any unlocking done in prepare to prevent accidental
	 * adjustment of the registers.
	 */
	if (HAS_PCH_SPLIT(dev)) {
		u32 val = I915_READ(PCH_PP_CONTROL);
		if ((val & PANEL_UNLOCK_REGS) == PANEL_UNLOCK_REGS)
			I915_WRITE(PCH_PP_CONTROL, val & 0x3);
	} else {
		u32 val = I915_READ(PP_CONTROL);
		if ((val & PANEL_UNLOCK_REGS) == PANEL_UNLOCK_REGS)
			I915_WRITE(PP_CONTROL, val & 0x3);
	}

	/* Always do a full power on as we do not know what state
	 * we were left in.
	 */
	intel_lvds_set_power(intel_lvds, true);
J
Jesse Barnes 已提交
414 415 416 417 418 419 420 421
}

static void intel_lvds_mode_set(struct drm_encoder *encoder,
				struct drm_display_mode *mode,
				struct drm_display_mode *adjusted_mode)
{
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
422
	struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
J
Jesse Barnes 已提交
423 424 425 426 427 428 429

	/*
	 * The LVDS pin pair will already have been turned on in the
	 * intel_crtc_mode_set since it has a large impact on the DPLL
	 * settings.
	 */

430
	if (HAS_PCH_SPLIT(dev))
431 432
		return;

433 434 435
	if (!intel_lvds->pfit_dirty)
		return;

J
Jesse Barnes 已提交
436 437 438 439 440
	/*
	 * Enable automatic panel scaling so that non-native modes fill the
	 * screen.  Should be enabled before the pipe is enabled, according to
	 * register description and PRM.
	 */
441 442 443
	if (wait_for((I915_READ(PP_STATUS) & PP_ON) == 0, 1000))
		DRM_ERROR("timed out waiting for panel to power off\n");

C
Chris Wilson 已提交
444 445
	I915_WRITE(PFIT_PGM_RATIOS, intel_lvds->pfit_pgm_ratios);
	I915_WRITE(PFIT_CONTROL, intel_lvds->pfit_control);
446
	intel_lvds->pfit_dirty = false;
J
Jesse Barnes 已提交
447 448 449 450 451
}

/**
 * Detect the LVDS connection.
 *
452 453 454
 * Since LVDS doesn't have hotlug, we use the lid as a proxy.  Open means
 * connected and closed means disconnected.  We also send hotplug events as
 * needed, using lid status notification from the input layer.
J
Jesse Barnes 已提交
455
 */
456
static enum drm_connector_status
457
intel_lvds_detect(struct drm_connector *connector, bool force)
J
Jesse Barnes 已提交
458
{
459
	struct drm_device *dev = connector->dev;
460 461
	enum drm_connector_status status = connector_status_connected;

462 463 464
	/* ACPI lid methods were generally unreliable in this generation, so
	 * don't even bother.
	 */
465
	if (IS_GEN2(dev) || IS_GEN3(dev))
466 467
		return connector_status_connected;

468
	return status;
J
Jesse Barnes 已提交
469 470 471 472 473 474 475
}

/**
 * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
 */
static int intel_lvds_get_modes(struct drm_connector *connector)
{
476
	struct intel_lvds *intel_lvds = intel_attached_lvds(connector);
J
Jesse Barnes 已提交
477
	struct drm_device *dev = connector->dev;
478
	struct drm_display_mode *mode;
J
Jesse Barnes 已提交
479

C
Chris Wilson 已提交
480 481 482 483
	if (intel_lvds->edid) {
		drm_mode_connector_update_edid_property(connector,
							intel_lvds->edid);
		return drm_add_edid_modes(connector, intel_lvds->edid);
484
	}
J
Jesse Barnes 已提交
485

486 487 488
	mode = drm_mode_duplicate(dev, intel_lvds->fixed_mode);
	if (mode == 0)
		return 0;
J
Jesse Barnes 已提交
489

490 491
	drm_mode_probed_add(connector, mode);
	return 1;
J
Jesse Barnes 已提交
492 493
}

494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513
static int intel_no_modeset_on_lid_dmi_callback(const struct dmi_system_id *id)
{
	DRM_DEBUG_KMS("Skipping forced modeset for %s\n", id->ident);
	return 1;
}

/* The GPU hangs up on these systems if modeset is performed on LID open */
static const struct dmi_system_id intel_no_modeset_on_lid[] = {
	{
		.callback = intel_no_modeset_on_lid_dmi_callback,
		.ident = "Toshiba Tecra A11",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
			DMI_MATCH(DMI_PRODUCT_NAME, "TECRA A11"),
		},
	},

	{ }	/* terminating entry */
};

514 515 516 517 518 519 520 521 522
/*
 * Lid events. Note the use of 'modeset_on_lid':
 *  - we set it on lid close, and reset it on open
 *  - we use it as a "only once" bit (ie we ignore
 *    duplicate events where it was already properly
 *    set/reset)
 *  - the suspend/resume paths will also set it to
 *    zero, since they restore the mode ("lid open").
 */
523 524 525 526 527 528
static int intel_lid_notify(struct notifier_block *nb, unsigned long val,
			    void *unused)
{
	struct drm_i915_private *dev_priv =
		container_of(nb, struct drm_i915_private, lid_notifier);
	struct drm_device *dev = dev_priv->dev;
529
	struct drm_connector *connector = dev_priv->int_lvds_connector;
530

531 532 533 534 535
	/*
	 * check and update the status of LVDS connector after receiving
	 * the LID nofication event.
	 */
	if (connector)
536
		connector->status = connector->funcs->detect(connector,
537
							     false);
538

539 540 541
	/* Don't force modeset on machines where it causes a GPU lockup */
	if (dmi_check_system(intel_no_modeset_on_lid))
		return NOTIFY_OK;
542 543 544
	if (!acpi_lid_open()) {
		dev_priv->modeset_on_lid = 1;
		return NOTIFY_OK;
545
	}
546

547 548 549 550 551 552 553 554
	if (!dev_priv->modeset_on_lid)
		return NOTIFY_OK;

	dev_priv->modeset_on_lid = 0;

	mutex_lock(&dev->mode_config.mutex);
	drm_helper_resume_force_mode(dev);
	mutex_unlock(&dev->mode_config.mutex);
555

556 557 558
	return NOTIFY_OK;
}

J
Jesse Barnes 已提交
559 560 561 562 563 564 565 566 567
/**
 * intel_lvds_destroy - unregister and free LVDS structures
 * @connector: connector to free
 *
 * Unregister the DDC bus for this connector then free the driver private
 * structure.
 */
static void intel_lvds_destroy(struct drm_connector *connector)
{
568 569
	struct drm_device *dev = connector->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
J
Jesse Barnes 已提交
570

571 572
	if (dev_priv->lid_notifier.notifier_call)
		acpi_lid_notifier_unregister(&dev_priv->lid_notifier);
J
Jesse Barnes 已提交
573 574 575 576 577
	drm_sysfs_connector_remove(connector);
	drm_connector_cleanup(connector);
	kfree(connector);
}

578 579 580 581
static int intel_lvds_set_property(struct drm_connector *connector,
				   struct drm_property *property,
				   uint64_t value)
{
582
	struct intel_lvds *intel_lvds = intel_attached_lvds(connector);
583 584
	struct drm_device *dev = connector->dev;

585 586
	if (property == dev->mode_config.scaling_mode_property) {
		struct drm_crtc *crtc = intel_lvds->base.base.crtc;
587

588 589
		if (value == DRM_MODE_SCALE_NONE) {
			DRM_DEBUG_KMS("no scaling not supported\n");
590
			return -EINVAL;
591
		}
592

C
Chris Wilson 已提交
593
		if (intel_lvds->fitting_mode == value) {
594 595 596
			/* the LVDS scaling property is not changed */
			return 0;
		}
C
Chris Wilson 已提交
597
		intel_lvds->fitting_mode = value;
598 599 600 601 602 603 604 605 606 607
		if (crtc && crtc->enabled) {
			/*
			 * If the CRTC is enabled, the display will be changed
			 * according to the new panel fitting mode.
			 */
			drm_crtc_helper_set_mode(crtc, &crtc->mode,
				crtc->x, crtc->y, crtc->fb);
		}
	}

608 609 610
	return 0;
}

J
Jesse Barnes 已提交
611 612 613 614 615 616 617 618 619 620 621
static const struct drm_encoder_helper_funcs intel_lvds_helper_funcs = {
	.dpms = intel_lvds_dpms,
	.mode_fixup = intel_lvds_mode_fixup,
	.prepare = intel_lvds_prepare,
	.mode_set = intel_lvds_mode_set,
	.commit = intel_lvds_commit,
};

static const struct drm_connector_helper_funcs intel_lvds_connector_helper_funcs = {
	.get_modes = intel_lvds_get_modes,
	.mode_valid = intel_lvds_mode_valid,
622
	.best_encoder = intel_best_encoder,
J
Jesse Barnes 已提交
623 624 625
};

static const struct drm_connector_funcs intel_lvds_connector_funcs = {
626
	.dpms = drm_helper_connector_dpms,
J
Jesse Barnes 已提交
627 628
	.detect = intel_lvds_detect,
	.fill_modes = drm_helper_probe_single_connector_modes,
629
	.set_property = intel_lvds_set_property,
J
Jesse Barnes 已提交
630 631 632 633
	.destroy = intel_lvds_destroy,
};

static const struct drm_encoder_funcs intel_lvds_enc_funcs = {
C
Chris Wilson 已提交
634
	.destroy = intel_encoder_destroy,
J
Jesse Barnes 已提交
635 636
};

637 638
static int __init intel_no_lvds_dmi_callback(const struct dmi_system_id *id)
{
639
	DRM_DEBUG_KMS("Skipping LVDS initialization for %s\n", id->ident);
640 641
	return 1;
}
J
Jesse Barnes 已提交
642

643
/* These systems claim to have LVDS, but really don't */
644
static const struct dmi_system_id intel_no_lvds[] = {
645 646 647 648
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Apple Mac Mini (Core series)",
		.matches = {
649
			DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
650 651 652 653 654 655 656
			DMI_MATCH(DMI_PRODUCT_NAME, "Macmini1,1"),
		},
	},
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Apple Mac Mini (Core 2 series)",
		.matches = {
657
			DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
			DMI_MATCH(DMI_PRODUCT_NAME, "Macmini2,1"),
		},
	},
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "MSI IM-945GSE-A",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "MSI"),
			DMI_MATCH(DMI_PRODUCT_NAME, "A9830IMS"),
		},
	},
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Dell Studio Hybrid",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
			DMI_MATCH(DMI_PRODUCT_NAME, "Studio Hybrid 140g"),
		},
	},
677 678 679 680 681 682 683 684
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "AOpen Mini PC",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "AOpen"),
			DMI_MATCH(DMI_PRODUCT_NAME, "i965GMx-IF"),
		},
	},
685 686 687 688 689 690 691 692
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "AOpen Mini PC MP915",
		.matches = {
			DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
			DMI_MATCH(DMI_BOARD_NAME, "i915GMx-F"),
		},
	},
693 694 695 696 697 698 699
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Aopen i945GTt-VFA",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_VERSION, "AO00001JW"),
		},
	},
700 701 702 703 704 705 706 707
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Clientron U800",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Clientron"),
			DMI_MATCH(DMI_PRODUCT_NAME, "U800"),
		},
	},
708 709 710

	{ }	/* terminating entry */
};
J
Jesse Barnes 已提交
711

712 713 714 715 716 717 718 719
/**
 * intel_find_lvds_downclock - find the reduced downclock for LVDS in EDID
 * @dev: drm device
 * @connector: LVDS connector
 *
 * Find the reduced downclock for LVDS in EDID.
 */
static void intel_find_lvds_downclock(struct drm_device *dev,
720 721
				      struct drm_display_mode *fixed_mode,
				      struct drm_connector *connector)
722 723
{
	struct drm_i915_private *dev_priv = dev->dev_private;
724
	struct drm_display_mode *scan;
725 726
	int temp_downclock;

727
	temp_downclock = fixed_mode->clock;
728 729 730 731 732 733 734 735
	list_for_each_entry(scan, &connector->probed_modes, head) {
		/*
		 * If one mode has the same resolution with the fixed_panel
		 * mode while they have the different refresh rate, it means
		 * that the reduced downclock is found for the LVDS. In such
		 * case we can set the different FPx0/1 to dynamically select
		 * between low and high frequency.
		 */
736 737 738 739 740 741 742 743
		if (scan->hdisplay == fixed_mode->hdisplay &&
		    scan->hsync_start == fixed_mode->hsync_start &&
		    scan->hsync_end == fixed_mode->hsync_end &&
		    scan->htotal == fixed_mode->htotal &&
		    scan->vdisplay == fixed_mode->vdisplay &&
		    scan->vsync_start == fixed_mode->vsync_start &&
		    scan->vsync_end == fixed_mode->vsync_end &&
		    scan->vtotal == fixed_mode->vtotal) {
744 745 746 747 748 749 750 751 752
			if (scan->clock < temp_downclock) {
				/*
				 * The downclock is already found. But we
				 * expect to find the lower downclock.
				 */
				temp_downclock = scan->clock;
			}
		}
	}
753
	if (temp_downclock < fixed_mode->clock && i915_lvds_downclock) {
754 755 756 757
		/* We found the downclock for LVDS. */
		dev_priv->lvds_downclock_avail = 1;
		dev_priv->lvds_downclock = temp_downclock;
		DRM_DEBUG_KMS("LVDS downclock is found in EDID. "
758 759
			      "Normal clock %dKhz, downclock %dKhz\n",
			      fixed_mode->clock, temp_downclock);
760 761 762
	}
}

763 764 765 766 767 768 769
/*
 * Enumerate the child dev array parsed from VBT to check whether
 * the LVDS is present.
 * If it is present, return 1.
 * If it is not present, return false.
 * If no child dev is parsed from VBT, it assumes that the LVDS is present.
 */
770
static bool lvds_is_present_in_vbt(struct drm_device *dev)
771 772
{
	struct drm_i915_private *dev_priv = dev->dev_private;
773
	int i;
774 775

	if (!dev_priv->child_dev_num)
776
		return true;
777 778

	for (i = 0; i < dev_priv->child_dev_num; i++) {
779 780 781 782 783
		struct child_device_config *child = dev_priv->child_dev + i;

		/* If the device type is not LFP, continue.
		 * We have to check both the new identifiers as well as the
		 * old for compatibility with some BIOSes.
784
		 */
785 786
		if (child->device_type != DEVICE_TYPE_INT_LFP &&
		    child->device_type != DEVICE_TYPE_LFP)
787 788
			continue;

789 790 791 792
		/* However, we cannot trust the BIOS writers to populate
		 * the VBT correctly.  Since LVDS requires additional
		 * information from AIM blocks, a non-zero addin offset is
		 * a good indicator that the LVDS is actually present.
793
		 */
794 795 796 797 798 799 800 801 802 803
		if (child->addin_offset)
			return true;

		/* But even then some BIOS writers perform some black magic
		 * and instantiate the device without reference to any
		 * additional data.  Trust that if the VBT was written into
		 * the OpRegion then they have validated the LVDS's existence.
		 */
		if (dev_priv->opregion.vbt)
			return true;
804
	}
805 806

	return false;
807 808
}

J
Jesse Barnes 已提交
809 810 811 812 813 814 815 816 817 818
/**
 * intel_lvds_init - setup LVDS connectors on this device
 * @dev: drm device
 *
 * Create the connector, register the LVDS DDC bus, and try to figure out what
 * modes we can display on the LVDS panel (if present).
 */
void intel_lvds_init(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
C
Chris Wilson 已提交
819
	struct intel_lvds *intel_lvds;
820
	struct intel_encoder *intel_encoder;
821
	struct intel_connector *intel_connector;
J
Jesse Barnes 已提交
822 823 824 825 826
	struct drm_connector *connector;
	struct drm_encoder *encoder;
	struct drm_display_mode *scan; /* *modes, *bios_mode; */
	struct drm_crtc *crtc;
	u32 lvds;
827
	int pipe, gpio = GPIOC;
J
Jesse Barnes 已提交
828

829 830
	/* Skip init on machines we know falsely report LVDS */
	if (dmi_check_system(intel_no_lvds))
831 832
		return;

833 834
	if (!lvds_is_present_in_vbt(dev)) {
		DRM_DEBUG_KMS("LVDS is not present in VBT\n");
835
		return;
A
Adam Jackson 已提交
836
	}
837

838
	if (HAS_PCH_SPLIT(dev)) {
839 840
		if ((I915_READ(PCH_LVDS) & LVDS_DETECTED) == 0)
			return;
841
		if (dev_priv->edp_support) {
842
			DRM_DEBUG_KMS("disable LVDS for eDP support\n");
843 844
			return;
		}
845 846 847
		gpio = PCH_GPIOC;
	}

C
Chris Wilson 已提交
848 849
	intel_lvds = kzalloc(sizeof(struct intel_lvds), GFP_KERNEL);
	if (!intel_lvds) {
J
Jesse Barnes 已提交
850 851 852
		return;
	}

853 854
	intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
	if (!intel_connector) {
C
Chris Wilson 已提交
855
		kfree(intel_lvds);
856 857 858
		return;
	}

859 860 861 862
	if (!HAS_PCH_SPLIT(dev)) {
		intel_lvds->pfit_control = I915_READ(PFIT_CONTROL);
	}

C
Chris Wilson 已提交
863
	intel_encoder = &intel_lvds->base;
864
	encoder = &intel_encoder->base;
C
Chris Wilson 已提交
865
	connector = &intel_connector->base;
866
	drm_connector_init(dev, &intel_connector->base, &intel_lvds_connector_funcs,
J
Jesse Barnes 已提交
867 868
			   DRM_MODE_CONNECTOR_LVDS);

869
	drm_encoder_init(dev, &intel_encoder->base, &intel_lvds_enc_funcs,
J
Jesse Barnes 已提交
870 871
			 DRM_MODE_ENCODER_LVDS);

872
	intel_connector_attach_encoder(intel_connector, intel_encoder);
873
	intel_encoder->type = INTEL_OUTPUT_LVDS;
J
Jesse Barnes 已提交
874

875 876
	intel_encoder->clone_mask = (1 << INTEL_LVDS_CLONE_BIT);
	intel_encoder->crtc_mask = (1 << 1);
J
Jesse Barnes 已提交
877 878 879 880 881 882
	drm_encoder_helper_add(encoder, &intel_lvds_helper_funcs);
	drm_connector_helper_add(connector, &intel_lvds_connector_helper_funcs);
	connector->display_info.subpixel_order = SubPixelHorizontalRGB;
	connector->interlace_allowed = false;
	connector->doublescan_allowed = false;

883 884 885 886 887
	/* create the scaling mode property */
	drm_mode_create_scaling_mode_property(dev);
	/*
	 * the initial panel fitting mode will be FULL_SCREEN.
	 */
J
Jesse Barnes 已提交
888

889
	drm_connector_attach_property(&intel_connector->base,
890
				      dev->mode_config.scaling_mode_property,
891
				      DRM_MODE_SCALE_ASPECT);
C
Chris Wilson 已提交
892
	intel_lvds->fitting_mode = DRM_MODE_SCALE_ASPECT;
J
Jesse Barnes 已提交
893 894 895 896 897 898 899 900 901 902 903 904 905 906
	/*
	 * LVDS discovery:
	 * 1) check for EDID on DDC
	 * 2) check for VBT data
	 * 3) check to see if LVDS is already on
	 *    if none of the above, no panel
	 * 4) make sure lid is open
	 *    if closed, act like it's not there for now
	 */

	/*
	 * Attempt to get the fixed panel mode from DDC.  Assume that the
	 * preferred mode is the right one.
	 */
C
Chris Wilson 已提交
907 908
	intel_lvds->edid = drm_get_edid(connector,
					&dev_priv->gmbus[GMBUS_PORT_PANEL].adapter);
909

C
Chris Wilson 已提交
910
	if (!intel_lvds->edid) {
911 912 913 914 915 916 917 918 919
		/* Didn't get an EDID, so
		 * Set wide sync ranges so we get all modes
		 * handed to valid_mode for checking
		 */
		connector->display_info.min_vfreq = 0;
		connector->display_info.max_vfreq = 200;
		connector->display_info.min_hfreq = 0;
		connector->display_info.max_hfreq = 200;
	}
J
Jesse Barnes 已提交
920 921 922

	list_for_each_entry(scan, &connector->probed_modes, head) {
		if (scan->type & DRM_MODE_TYPE_PREFERRED) {
923
			intel_lvds->fixed_mode =
J
Jesse Barnes 已提交
924
				drm_mode_duplicate(dev, scan);
925 926 927
			intel_find_lvds_downclock(dev,
						  intel_lvds->fixed_mode,
						  connector);
928
			goto out;
J
Jesse Barnes 已提交
929 930 931 932
		}
	}

	/* Failed to get EDID, what about VBT? */
933
	if (dev_priv->lfp_lvds_vbt_mode) {
934
		intel_lvds->fixed_mode =
935
			drm_mode_duplicate(dev, dev_priv->lfp_lvds_vbt_mode);
936 937
		if (intel_lvds->fixed_mode) {
			intel_lvds->fixed_mode->type |=
938 939 940
				DRM_MODE_TYPE_PREFERRED;
			goto out;
		}
J
Jesse Barnes 已提交
941 942 943 944 945 946 947
	}

	/*
	 * If we didn't get EDID, try checking if the panel is already turned
	 * on.  If so, assume that whatever is currently programmed is the
	 * correct mode.
	 */
948

949
	/* Ironlake: FIXME if still fail, not try pipe mode now */
950
	if (HAS_PCH_SPLIT(dev))
951 952
		goto failed;

J
Jesse Barnes 已提交
953 954
	lvds = I915_READ(LVDS);
	pipe = (lvds & LVDS_PIPEB_SELECT) ? 1 : 0;
955
	crtc = intel_get_crtc_for_pipe(dev, pipe);
J
Jesse Barnes 已提交
956 957

	if (crtc && (lvds & LVDS_PORT_EN)) {
958 959 960
		intel_lvds->fixed_mode = intel_crtc_mode_get(dev, crtc);
		if (intel_lvds->fixed_mode) {
			intel_lvds->fixed_mode->type |=
J
Jesse Barnes 已提交
961
				DRM_MODE_TYPE_PREFERRED;
962
			goto out;
J
Jesse Barnes 已提交
963 964 965 966
		}
	}

	/* If we still don't have a mode after all that, give up. */
967
	if (!intel_lvds->fixed_mode)
J
Jesse Barnes 已提交
968 969 970
		goto failed;

out:
971
	if (HAS_PCH_SPLIT(dev)) {
972 973 974 975 976 977 978 979 980 981
		u32 pwm;
		/* make sure PWM is enabled */
		pwm = I915_READ(BLC_PWM_CPU_CTL2);
		pwm |= (PWM_ENABLE | PWM_PIPE_B);
		I915_WRITE(BLC_PWM_CPU_CTL2, pwm);

		pwm = I915_READ(BLC_PWM_PCH_CTL1);
		pwm |= PWM_PCH_ENABLE;
		I915_WRITE(BLC_PWM_PCH_CTL1, pwm);
	}
982 983
	dev_priv->lid_notifier.notifier_call = intel_lid_notify;
	if (acpi_lid_notifier_register(&dev_priv->lid_notifier)) {
984
		DRM_DEBUG_KMS("lid notifier registration failed\n");
985 986
		dev_priv->lid_notifier.notifier_call = NULL;
	}
987 988
	/* keep the LVDS connector */
	dev_priv->int_lvds_connector = connector;
J
Jesse Barnes 已提交
989 990 991 992
	drm_sysfs_connector_add(connector);
	return;

failed:
993
	DRM_DEBUG_KMS("No LVDS modes found, disabling.\n");
J
Jesse Barnes 已提交
994
	drm_connector_cleanup(connector);
995
	drm_encoder_cleanup(encoder);
C
Chris Wilson 已提交
996
	kfree(intel_lvds);
997
	kfree(intel_connector);
J
Jesse Barnes 已提交
998
}