intel_lvds.c 28.2 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 47 48 49 50
	int fitting_mode;
	u32 pfit_control;
	u32 pfit_pgm_ratios;
};

C
Chris Wilson 已提交
51 52
static struct intel_lvds *enc_to_intel_lvds(struct drm_encoder *encoder)
{
53
	return container_of(encoder, struct intel_lvds, base.base);
C
Chris Wilson 已提交
54 55
}

56 57 58 59 60 61 62 63 64 65
static void intel_lvds_lock_panel(struct drm_device *dev, bool lock)
{
	struct drm_i915_private *dev_priv = dev->dev_private;

	if (lock)
		I915_WRITE(PP_CONTROL, I915_READ(PP_CONTROL) & 0x3);
	else
		I915_WRITE(PP_CONTROL, I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
}

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

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

	if (on) {
85 86 87
		I915_WRITE(lvds_reg, I915_READ(lvds_reg) | LVDS_PORT_EN);
		POSTING_READ(lvds_reg);

88
		I915_WRITE(ctl_reg, I915_READ(ctl_reg) |
J
Jesse Barnes 已提交
89
			   POWER_TARGET_ON);
90
		if (wait_for(I915_READ(status_reg) & PP_ON, 1000))
91
			DRM_ERROR("timed out waiting to enable LVDS pipe");
J
Jesse Barnes 已提交
92

93
		intel_panel_set_backlight(dev, dev_priv->backlight_level);
J
Jesse Barnes 已提交
94
	} else {
95
		intel_panel_set_backlight(dev, 0);
J
Jesse Barnes 已提交
96

97
		I915_WRITE(ctl_reg, I915_READ(ctl_reg) &
J
Jesse Barnes 已提交
98
			   ~POWER_TARGET_ON);
99
		if (wait_for((I915_READ(status_reg) & PP_ON) == 0, 1000))
100
			DRM_ERROR("timed out waiting for LVDS pipe to turn off");
101 102 103

		I915_WRITE(lvds_reg, I915_READ(lvds_reg) & ~LVDS_PORT_EN);
		POSTING_READ(lvds_reg);
J
Jesse Barnes 已提交
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
	}
}

static void intel_lvds_dpms(struct drm_encoder *encoder, int mode)
{
	struct drm_device *dev = encoder->dev;

	if (mode == DRM_MODE_DPMS_ON)
		intel_lvds_set_power(dev, true);
	else
		intel_lvds_set_power(dev, false);

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

static int intel_lvds_mode_valid(struct drm_connector *connector,
				 struct drm_display_mode *mode)
{
	struct drm_device *dev = connector->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct drm_display_mode *fixed_mode = dev_priv->panel_fixed_mode;

	if (fixed_mode)	{
		if (mode->hdisplay > fixed_mode->hdisplay)
			return MODE_PANEL;
		if (mode->vdisplay > fixed_mode->vdisplay)
			return MODE_PANEL;
	}

	return MODE_OK;
}

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 189 190 191
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 已提交
192 193 194 195 196 197 198
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);
C
Chris Wilson 已提交
199
	struct intel_lvds *intel_lvds = enc_to_intel_lvds(encoder);
J
Jesse Barnes 已提交
200
	struct drm_encoder *tmp_encoder;
201
	u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0;
J
Jesse Barnes 已提交
202 203 204

	/* Should never happen!! */
	if (!IS_I965G(dev) && intel_crtc->pipe == 0) {
205
		DRM_ERROR("Can't support LVDS on pipe A\n");
J
Jesse Barnes 已提交
206 207 208 209 210 211
		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) {
212
			DRM_ERROR("Can't enable LVDS and another "
J
Jesse Barnes 已提交
213 214 215 216
			       "encoder on the same pipe\n");
			return false;
		}
	}
217 218 219
	/* If we don't have a panel mode, there is nothing we can do */
	if (dev_priv->panel_fixed_mode == NULL)
		return true;
220

J
Jesse Barnes 已提交
221
	/*
222
	 * We have timings from the BIOS for the panel, put them in
J
Jesse Barnes 已提交
223 224 225 226
	 * 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.
	 */
227 228 229 230 231 232 233
	intel_fixed_panel_mode(dev_priv->panel_fixed_mode, adjusted_mode);

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

235 236 237 238 239 240 241 242
	/* Make sure pre-965s set dither correctly */
	if (!IS_I965G(dev)) {
		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 &&
243
	    adjusted_mode->vdisplay == mode->vdisplay)
244 245 246 247
		goto out;

	/* 965+ wants fuzzy fitting */
	if (IS_I965G(dev))
248 249 250
		pfit_control |= ((intel_crtc->pipe << PFIT_PIPE_SHIFT) |
				 PFIT_FILTER_FUZZY);

251 252 253 254 255 256
	/*
	 * 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
	 */
257 258
	I915_WRITE(BCLRPAT_A, 0);
	I915_WRITE(BCLRPAT_B, 0);
259

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

271
	case DRM_MODE_SCALE_ASPECT:
272
		/* Scale but preserve the aspect ratio */
273
		if (IS_I965G(dev)) {
274 275 276 277
			u32 scaled_width = adjusted_mode->hdisplay * mode->vdisplay;
			u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;

			pfit_control |= PFIT_ENABLE;
278
			/* 965+ is easy, it does everything in hw */
279
			if (scaled_width > scaled_height)
280
				pfit_control |= PFIT_SCALING_PILLAR;
281
			else if (scaled_width < scaled_height)
282 283 284 285
				pfit_control |= PFIT_SCALING_LETTER;
			else
				pfit_control |= PFIT_SCALING_AUTO;
		} else {
286 287
			u32 scaled_width = adjusted_mode->hdisplay * mode->vdisplay;
			u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;
288 289 290 291 292
			/*
			 * For earlier chips we have to calculate the scaling
			 * ratio by hand and program it into the
			 * PFIT_PGM_RATIO register
			 */
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
			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 |
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
						 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;
		if (IS_I965G(dev))
			pfit_control |= PFIT_SCALING_AUTO;
		else
			pfit_control |= (VERT_AUTO_SCALE | HORIZ_AUTO_SCALE |
					 VERT_INTERP_BILINEAR |
					 HORIZ_INTERP_BILINEAR);
		break;
339

340 341 342 343 344
	default:
		break;
	}

out:
C
Chris Wilson 已提交
345 346
	intel_lvds->pfit_control = pfit_control;
	intel_lvds->pfit_pgm_ratios = pfit_pgm_ratios;
347 348
	dev_priv->lvds_border_bits = border;

J
Jesse Barnes 已提交
349 350 351 352 353 354 355 356 357 358 359 360 361
	/*
	 * 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;
362
	struct intel_lvds *intel_lvds = enc_to_intel_lvds(encoder);
J
Jesse Barnes 已提交
363

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

366 367 368 369
	if (intel_lvds->pfit_control == I915_READ(PFIT_CONTROL))
		intel_lvds_lock_panel(dev, false);
	else
		intel_lvds_set_power(dev, false);
J
Jesse Barnes 已提交
370 371 372 373 374 375 376
}

static void intel_lvds_commit( struct drm_encoder *encoder)
{
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;

377 378
	if (dev_priv->backlight_level == 0)
		dev_priv->backlight_level = intel_panel_get_max_backlight(dev);
J
Jesse Barnes 已提交
379

380 381 382 383
	if ((I915_READ(PP_CONTROL) & PANEL_UNLOCK_REGS) == PANEL_UNLOCK_REGS)
		intel_lvds_lock_panel(dev, true);
	else
		intel_lvds_set_power(dev, true);
J
Jesse Barnes 已提交
384 385 386 387 388 389 390 391
}

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;
C
Chris Wilson 已提交
392
	struct intel_lvds *intel_lvds = enc_to_intel_lvds(encoder);
J
Jesse Barnes 已提交
393 394 395 396 397 398 399

	/*
	 * 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.
	 */

400
	if (HAS_PCH_SPLIT(dev))
401 402
		return;

J
Jesse Barnes 已提交
403 404 405 406 407
	/*
	 * 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.
	 */
C
Chris Wilson 已提交
408 409
	I915_WRITE(PFIT_PGM_RATIOS, intel_lvds->pfit_pgm_ratios);
	I915_WRITE(PFIT_CONTROL, intel_lvds->pfit_control);
J
Jesse Barnes 已提交
410 411 412 413 414
}

/**
 * Detect the LVDS connection.
 *
415 416 417
 * 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 已提交
418 419 420
 */
static enum drm_connector_status intel_lvds_detect(struct drm_connector *connector)
{
421
	struct drm_device *dev = connector->dev;
422 423
	enum drm_connector_status status = connector_status_connected;

424 425 426
	/* ACPI lid methods were generally unreliable in this generation, so
	 * don't even bother.
	 */
427
	if (IS_GEN2(dev) || IS_GEN3(dev))
428 429
		return connector_status_connected;

430
	return status;
J
Jesse Barnes 已提交
431 432 433 434 435 436 437 438
}

/**
 * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
 */
static int intel_lvds_get_modes(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
439
	struct drm_encoder *encoder = intel_attached_encoder(connector);
440
	struct intel_encoder *intel_encoder = to_intel_encoder(encoder);
J
Jesse Barnes 已提交
441 442 443
	struct drm_i915_private *dev_priv = dev->dev_private;
	int ret = 0;

444
	if (dev_priv->lvds_edid_good) {
445
		ret = intel_ddc_get_modes(connector, intel_encoder->ddc_bus);
J
Jesse Barnes 已提交
446

447 448 449
		if (ret)
			return ret;
	}
J
Jesse Barnes 已提交
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471

	/* 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;

	if (dev_priv->panel_fixed_mode != NULL) {
		struct drm_display_mode *mode;

		mode = drm_mode_duplicate(dev, dev_priv->panel_fixed_mode);
		drm_mode_probed_add(connector, mode);

		return 1;
	}

	return 0;
}

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
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 */
};

492 493 494 495 496 497 498 499 500
/*
 * 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").
 */
501 502 503 504 505 506
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;
507
	struct drm_connector *connector = dev_priv->int_lvds_connector;
508

509 510 511 512 513 514
	/*
	 * check and update the status of LVDS connector after receiving
	 * the LID nofication event.
	 */
	if (connector)
		connector->status = connector->funcs->detect(connector);
515 516 517
	/* Don't force modeset on machines where it causes a GPU lockup */
	if (dmi_check_system(intel_no_modeset_on_lid))
		return NOTIFY_OK;
518 519 520
	if (!acpi_lid_open()) {
		dev_priv->modeset_on_lid = 1;
		return NOTIFY_OK;
521
	}
522

523 524 525 526 527 528 529 530
	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);
531

532 533 534
	return NOTIFY_OK;
}

J
Jesse Barnes 已提交
535 536 537 538 539 540 541 542 543
/**
 * 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)
{
544 545
	struct drm_device *dev = connector->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
J
Jesse Barnes 已提交
546

547 548
	if (dev_priv->lid_notifier.notifier_call)
		acpi_lid_notifier_unregister(&dev_priv->lid_notifier);
J
Jesse Barnes 已提交
549 550 551 552 553
	drm_sysfs_connector_remove(connector);
	drm_connector_cleanup(connector);
	kfree(connector);
}

554 555 556 557
static int intel_lvds_set_property(struct drm_connector *connector,
				   struct drm_property *property,
				   uint64_t value)
{
558 559 560 561 562
	struct drm_device *dev = connector->dev;

	if (property == dev->mode_config.scaling_mode_property &&
				connector->encoder) {
		struct drm_crtc *crtc = connector->encoder->crtc;
563
		struct drm_encoder *encoder = connector->encoder;
C
Chris Wilson 已提交
564
		struct intel_lvds *intel_lvds = enc_to_intel_lvds(encoder);
565

566 567
		if (value == DRM_MODE_SCALE_NONE) {
			DRM_DEBUG_KMS("no scaling not supported\n");
568 569
			return 0;
		}
C
Chris Wilson 已提交
570
		if (intel_lvds->fitting_mode == value) {
571 572 573
			/* the LVDS scaling property is not changed */
			return 0;
		}
C
Chris Wilson 已提交
574
		intel_lvds->fitting_mode = value;
575 576 577 578 579 580 581 582 583 584
		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);
		}
	}

585 586 587
	return 0;
}

J
Jesse Barnes 已提交
588 589 590 591 592 593 594 595 596 597 598
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,
599
	.best_encoder = intel_attached_encoder,
J
Jesse Barnes 已提交
600 601 602
};

static const struct drm_connector_funcs intel_lvds_connector_funcs = {
603
	.dpms = drm_helper_connector_dpms,
J
Jesse Barnes 已提交
604 605
	.detect = intel_lvds_detect,
	.fill_modes = drm_helper_probe_single_connector_modes,
606
	.set_property = intel_lvds_set_property,
J
Jesse Barnes 已提交
607 608 609 610
	.destroy = intel_lvds_destroy,
};

static const struct drm_encoder_funcs intel_lvds_enc_funcs = {
C
Chris Wilson 已提交
611
	.destroy = intel_encoder_destroy,
J
Jesse Barnes 已提交
612 613
};

614 615
static int __init intel_no_lvds_dmi_callback(const struct dmi_system_id *id)
{
616
	DRM_DEBUG_KMS("Skipping LVDS initialization for %s\n", id->ident);
617 618
	return 1;
}
J
Jesse Barnes 已提交
619

620
/* These systems claim to have LVDS, but really don't */
621
static const struct dmi_system_id intel_no_lvds[] = {
622 623 624 625
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Apple Mac Mini (Core series)",
		.matches = {
626
			DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
627 628 629 630 631 632 633
			DMI_MATCH(DMI_PRODUCT_NAME, "Macmini1,1"),
		},
	},
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Apple Mac Mini (Core 2 series)",
		.matches = {
634
			DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
			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"),
		},
	},
654 655 656 657 658 659 660 661
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "AOpen Mini PC",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "AOpen"),
			DMI_MATCH(DMI_PRODUCT_NAME, "i965GMx-IF"),
		},
	},
662 663 664 665 666 667 668 669
	{
		.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"),
		},
	},
670 671 672 673 674 675 676
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Aopen i945GTt-VFA",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_VERSION, "AO00001JW"),
		},
	},
677 678 679 680 681 682 683 684
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Clientron U800",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Clientron"),
			DMI_MATCH(DMI_PRODUCT_NAME, "U800"),
		},
	},
685 686 687

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

689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
/**
 * 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,
				struct drm_connector *connector)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct drm_display_mode *scan, *panel_fixed_mode;
	int temp_downclock;

	panel_fixed_mode = dev_priv->panel_fixed_mode;
	temp_downclock = panel_fixed_mode->clock;

	mutex_lock(&dev->mode_config.mutex);
	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.
		 */
		if (scan->hdisplay == panel_fixed_mode->hdisplay &&
			scan->hsync_start == panel_fixed_mode->hsync_start &&
			scan->hsync_end == panel_fixed_mode->hsync_end &&
			scan->htotal == panel_fixed_mode->htotal &&
			scan->vdisplay == panel_fixed_mode->vdisplay &&
			scan->vsync_start == panel_fixed_mode->vsync_start &&
			scan->vsync_end == panel_fixed_mode->vsync_end &&
			scan->vtotal == panel_fixed_mode->vtotal) {
			if (scan->clock < temp_downclock) {
				/*
				 * The downclock is already found. But we
				 * expect to find the lower downclock.
				 */
				temp_downclock = scan->clock;
			}
		}
	}
	mutex_unlock(&dev->mode_config.mutex);
733 734
	if (temp_downclock < panel_fixed_mode->clock &&
	    i915_lvds_downclock) {
735 736 737 738 739 740 741 742 743 744
		/* 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. "
				"Normal clock %dKhz, downclock %dKhz\n",
				panel_fixed_mode->clock, temp_downclock);
	}
	return;
}

745 746 747 748 749 750 751
/*
 * 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.
 */
752
static bool lvds_is_present_in_vbt(struct drm_device *dev)
753 754
{
	struct drm_i915_private *dev_priv = dev->dev_private;
755
	int i;
756 757

	if (!dev_priv->child_dev_num)
758
		return true;
759 760

	for (i = 0; i < dev_priv->child_dev_num; i++) {
761 762 763 764 765
		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.
766
		 */
767 768
		if (child->device_type != DEVICE_TYPE_INT_LFP &&
		    child->device_type != DEVICE_TYPE_LFP)
769 770
			continue;

771 772 773 774
		/* 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.
775
		 */
776 777 778 779 780 781 782 783 784 785
		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;
786
	}
787 788

	return false;
789 790
}

J
Jesse Barnes 已提交
791 792 793 794 795 796 797 798 799 800
/**
 * 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 已提交
801
	struct intel_lvds *intel_lvds;
802
	struct intel_encoder *intel_encoder;
803
	struct intel_connector *intel_connector;
J
Jesse Barnes 已提交
804 805 806 807 808
	struct drm_connector *connector;
	struct drm_encoder *encoder;
	struct drm_display_mode *scan; /* *modes, *bios_mode; */
	struct drm_crtc *crtc;
	u32 lvds;
809
	int pipe, gpio = GPIOC;
J
Jesse Barnes 已提交
810

811 812
	/* Skip init on machines we know falsely report LVDS */
	if (dmi_check_system(intel_no_lvds))
813 814
		return;

815 816
	if (!lvds_is_present_in_vbt(dev)) {
		DRM_DEBUG_KMS("LVDS is not present in VBT\n");
817
		return;
A
Adam Jackson 已提交
818
	}
819

820
	if (HAS_PCH_SPLIT(dev)) {
821 822
		if ((I915_READ(PCH_LVDS) & LVDS_DETECTED) == 0)
			return;
823
		if (dev_priv->edp_support) {
824
			DRM_DEBUG_KMS("disable LVDS for eDP support\n");
825 826
			return;
		}
827 828 829
		gpio = PCH_GPIOC;
	}

C
Chris Wilson 已提交
830 831
	intel_lvds = kzalloc(sizeof(struct intel_lvds), GFP_KERNEL);
	if (!intel_lvds) {
J
Jesse Barnes 已提交
832 833 834
		return;
	}

835 836
	intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
	if (!intel_connector) {
C
Chris Wilson 已提交
837
		kfree(intel_lvds);
838 839 840
		return;
	}

C
Chris Wilson 已提交
841
	intel_encoder = &intel_lvds->base;
842
	encoder = &intel_encoder->base;
C
Chris Wilson 已提交
843
	connector = &intel_connector->base;
844
	drm_connector_init(dev, &intel_connector->base, &intel_lvds_connector_funcs,
J
Jesse Barnes 已提交
845 846
			   DRM_MODE_CONNECTOR_LVDS);

847
	drm_encoder_init(dev, &intel_encoder->base, &intel_lvds_enc_funcs,
J
Jesse Barnes 已提交
848 849
			 DRM_MODE_ENCODER_LVDS);

850
	drm_mode_connector_attach_encoder(&intel_connector->base, &intel_encoder->base);
851
	intel_encoder->type = INTEL_OUTPUT_LVDS;
J
Jesse Barnes 已提交
852

853 854
	intel_encoder->clone_mask = (1 << INTEL_LVDS_CLONE_BIT);
	intel_encoder->crtc_mask = (1 << 1);
J
Jesse Barnes 已提交
855 856 857 858 859 860
	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;

861 862 863 864 865
	/* create the scaling mode property */
	drm_mode_create_scaling_mode_property(dev);
	/*
	 * the initial panel fitting mode will be FULL_SCREEN.
	 */
J
Jesse Barnes 已提交
866

867
	drm_connector_attach_property(&intel_connector->base,
868
				      dev->mode_config.scaling_mode_property,
869
				      DRM_MODE_SCALE_ASPECT);
C
Chris Wilson 已提交
870
	intel_lvds->fitting_mode = DRM_MODE_SCALE_ASPECT;
J
Jesse Barnes 已提交
871 872 873 874 875 876 877 878 879 880 881
	/*
	 * 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
	 */

	/* Set up the DDC bus. */
882 883
	intel_encoder->ddc_bus = intel_i2c_create(dev, gpio, "LVDSDDC_C");
	if (!intel_encoder->ddc_bus) {
J
Jesse Barnes 已提交
884 885 886 887 888 889 890 891 892
		dev_printk(KERN_ERR, &dev->pdev->dev, "DDC bus registration "
			   "failed.\n");
		goto failed;
	}

	/*
	 * Attempt to get the fixed panel mode from DDC.  Assume that the
	 * preferred mode is the right one.
	 */
893 894
	dev_priv->lvds_edid_good = true;

895
	if (!intel_ddc_get_modes(connector, intel_encoder->ddc_bus))
896
		dev_priv->lvds_edid_good = false;
J
Jesse Barnes 已提交
897 898 899 900 901 902 903

	list_for_each_entry(scan, &connector->probed_modes, head) {
		mutex_lock(&dev->mode_config.mutex);
		if (scan->type & DRM_MODE_TYPE_PREFERRED) {
			dev_priv->panel_fixed_mode =
				drm_mode_duplicate(dev, scan);
			mutex_unlock(&dev->mode_config.mutex);
904
			intel_find_lvds_downclock(dev, connector);
905
			goto out;
J
Jesse Barnes 已提交
906 907 908 909 910
		}
		mutex_unlock(&dev->mode_config.mutex);
	}

	/* Failed to get EDID, what about VBT? */
911
	if (dev_priv->lfp_lvds_vbt_mode) {
J
Jesse Barnes 已提交
912 913
		mutex_lock(&dev->mode_config.mutex);
		dev_priv->panel_fixed_mode =
914
			drm_mode_duplicate(dev, dev_priv->lfp_lvds_vbt_mode);
J
Jesse Barnes 已提交
915
		mutex_unlock(&dev->mode_config.mutex);
916 917 918 919 920
		if (dev_priv->panel_fixed_mode) {
			dev_priv->panel_fixed_mode->type |=
				DRM_MODE_TYPE_PREFERRED;
			goto out;
		}
J
Jesse Barnes 已提交
921 922 923 924 925 926 927
	}

	/*
	 * 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.
	 */
928

929
	/* Ironlake: FIXME if still fail, not try pipe mode now */
930
	if (HAS_PCH_SPLIT(dev))
931 932
		goto failed;

J
Jesse Barnes 已提交
933 934 935 936 937 938 939 940 941
	lvds = I915_READ(LVDS);
	pipe = (lvds & LVDS_PIPEB_SELECT) ? 1 : 0;
	crtc = intel_get_crtc_from_pipe(dev, pipe);

	if (crtc && (lvds & LVDS_PORT_EN)) {
		dev_priv->panel_fixed_mode = intel_crtc_mode_get(dev, crtc);
		if (dev_priv->panel_fixed_mode) {
			dev_priv->panel_fixed_mode->type |=
				DRM_MODE_TYPE_PREFERRED;
942
			goto out;
J
Jesse Barnes 已提交
943 944 945 946 947 948 949 950
		}
	}

	/* If we still don't have a mode after all that, give up. */
	if (!dev_priv->panel_fixed_mode)
		goto failed;

out:
951
	if (HAS_PCH_SPLIT(dev)) {
952 953 954 955 956 957 958 959 960 961
		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);
	}
962 963
	dev_priv->lid_notifier.notifier_call = intel_lid_notify;
	if (acpi_lid_notifier_register(&dev_priv->lid_notifier)) {
964
		DRM_DEBUG_KMS("lid notifier registration failed\n");
965 966
		dev_priv->lid_notifier.notifier_call = NULL;
	}
967 968
	/* keep the LVDS connector */
	dev_priv->int_lvds_connector = connector;
J
Jesse Barnes 已提交
969 970 971 972
	drm_sysfs_connector_add(connector);
	return;

failed:
973
	DRM_DEBUG_KMS("No LVDS modes found, disabling.\n");
974 975
	if (intel_encoder->ddc_bus)
		intel_i2c_destroy(intel_encoder->ddc_bus);
J
Jesse Barnes 已提交
976
	drm_connector_cleanup(connector);
977
	drm_encoder_cleanup(encoder);
C
Chris Wilson 已提交
978
	kfree(intel_lvds);
979
	kfree(intel_connector);
J
Jesse Barnes 已提交
980
}