intel_lvds.c 30.6 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_enable(struct intel_lvds *intel_lvds)
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
	I915_WRITE(lvds_reg, I915_READ(lvds_reg) | LVDS_PORT_EN);
86

87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
	if (intel_lvds->pfit_dirty) {
		/*
		 * Enable automatic panel scaling so that non-native modes
		 * fill the screen.  The panel fitter should only be
		 * adjusted whilst the pipe is disabled, according to
		 * register description and PRM.
		 */
		DRM_DEBUG_KMS("applying panel-fitter: %x, %x\n",
			      intel_lvds->pfit_control,
			      intel_lvds->pfit_pgm_ratios);
		if (wait_for((I915_READ(PP_STATUS) & PP_ON) == 0, 1000)) {
			DRM_ERROR("timed out waiting for panel to power off\n");
		} else {
			I915_WRITE(PFIT_PGM_RATIOS, intel_lvds->pfit_pgm_ratios);
			I915_WRITE(PFIT_CONTROL, intel_lvds->pfit_control);
102
			intel_lvds->pfit_dirty = false;
103
		}
104 105 106 107 108
	}

	I915_WRITE(ctl_reg, I915_READ(ctl_reg) | POWER_TARGET_ON);
	POSTING_READ(lvds_reg);

109
	intel_panel_enable_backlight(dev);
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
}

static void intel_lvds_disable(struct intel_lvds *intel_lvds)
{
	struct drm_device *dev = intel_lvds->base.base.dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
	u32 ctl_reg, lvds_reg;

	if (HAS_PCH_SPLIT(dev)) {
		ctl_reg = PCH_PP_CONTROL;
		lvds_reg = PCH_LVDS;
	} else {
		ctl_reg = PP_CONTROL;
		lvds_reg = LVDS;
	}

126
	intel_panel_disable_backlight(dev);
127 128 129 130 131 132

	I915_WRITE(ctl_reg, I915_READ(ctl_reg) & ~POWER_TARGET_ON);

	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");
133

134 135
		I915_WRITE(PFIT_CONTROL, 0);
		intel_lvds->pfit_dirty = true;
J
Jesse Barnes 已提交
136
	}
137 138

	I915_WRITE(lvds_reg, I915_READ(lvds_reg) & ~LVDS_PORT_EN);
139
	POSTING_READ(lvds_reg);
J
Jesse Barnes 已提交
140 141 142 143
}

static void intel_lvds_dpms(struct drm_encoder *encoder, int mode)
{
144
	struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
J
Jesse Barnes 已提交
145 146

	if (mode == DRM_MODE_DPMS_ON)
147
		intel_lvds_enable(intel_lvds);
J
Jesse Barnes 已提交
148
	else
149
		intel_lvds_disable(intel_lvds);
J
Jesse Barnes 已提交
150 151 152 153 154 155 156

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

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

160 161 162 163
	if (mode->hdisplay > fixed_mode->hdisplay)
		return MODE_PANEL;
	if (mode->vdisplay > fixed_mode->vdisplay)
		return MODE_PANEL;
J
Jesse Barnes 已提交
164 165 166 167

	return MODE_OK;
}

168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
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 已提交
224 225 226 227 228 229 230
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);
231
	struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
J
Jesse Barnes 已提交
232
	struct drm_encoder *tmp_encoder;
233
	u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0;
J
Jesse Barnes 已提交
234 235

	/* Should never happen!! */
236
	if (INTEL_INFO(dev)->gen < 4 && intel_crtc->pipe == 0) {
237
		DRM_ERROR("Can't support LVDS on pipe A\n");
J
Jesse Barnes 已提交
238 239 240 241 242 243
		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) {
244
			DRM_ERROR("Can't enable LVDS and another "
J
Jesse Barnes 已提交
245 246 247 248
			       "encoder on the same pipe\n");
			return false;
		}
	}
249

J
Jesse Barnes 已提交
250
	/*
251
	 * We have timings from the BIOS for the panel, put them in
J
Jesse Barnes 已提交
252 253 254 255
	 * 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.
	 */
256
	intel_fixed_panel_mode(intel_lvds->fixed_mode, adjusted_mode);
257 258 259 260 261 262

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

264
	/* Make sure pre-965s set dither correctly */
265
	if (INTEL_INFO(dev)->gen < 4) {
266
		if (dev_priv->lvds_dither)
267 268 269 270 271
			pfit_control |= PANEL_8TO6_DITHER_ENABLE;
	}

	/* Native modes don't need fitting */
	if (adjusted_mode->hdisplay == mode->hdisplay &&
272
	    adjusted_mode->vdisplay == mode->vdisplay)
273 274 275
		goto out;

	/* 965+ wants fuzzy fitting */
276
	if (INTEL_INFO(dev)->gen >= 4)
277 278 279
		pfit_control |= ((intel_crtc->pipe << PFIT_PIPE_SHIFT) |
				 PFIT_FILTER_FUZZY);

280 281 282 283 284 285
	/*
	 * 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
	 */
286 287
	I915_WRITE(BCLRPAT_A, 0);
	I915_WRITE(BCLRPAT_B, 0);
288

C
Chris Wilson 已提交
289
	switch (intel_lvds->fitting_mode) {
290
	case DRM_MODE_SCALE_CENTER:
291 292 293 294
		/*
		 * For centered modes, we have to calculate border widths &
		 * heights and modify the values programmed into the CRTC.
		 */
295 296 297
		centre_horizontally(adjusted_mode, mode->hdisplay);
		centre_vertically(adjusted_mode, mode->vdisplay);
		border = LVDS_BORDER_ENABLE;
298
		break;
299

300
	case DRM_MODE_SCALE_ASPECT:
301
		/* Scale but preserve the aspect ratio */
302
		if (INTEL_INFO(dev)->gen >= 4) {
303 304 305
			u32 scaled_width = adjusted_mode->hdisplay * mode->vdisplay;
			u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;

306
			/* 965+ is easy, it does everything in hw */
307
			if (scaled_width > scaled_height)
308
				pfit_control |= PFIT_ENABLE | PFIT_SCALING_PILLAR;
309
			else if (scaled_width < scaled_height)
310 311 312
				pfit_control |= PFIT_ENABLE | PFIT_SCALING_LETTER;
			else if (adjusted_mode->hdisplay != mode->hdisplay)
				pfit_control |= PFIT_ENABLE | PFIT_SCALING_AUTO;
313
		} else {
314 315
			u32 scaled_width = adjusted_mode->hdisplay * mode->vdisplay;
			u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;
316 317 318 319 320
			/*
			 * For earlier chips we have to calculate the scaling
			 * ratio by hand and program it into the
			 * PFIT_PGM_RATIO register
			 */
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
			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 |
349 350 351 352 353 354 355 356 357 358
						 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.
		 */
359 360 361 362 363 364 365 366 367 368 369
		if (mode->vdisplay != adjusted_mode->vdisplay ||
		    mode->hdisplay != adjusted_mode->hdisplay) {
			pfit_control |= PFIT_ENABLE;
			if (INTEL_INFO(dev)->gen >= 4)
				pfit_control |= PFIT_SCALING_AUTO;
			else
				pfit_control |= (VERT_AUTO_SCALE |
						 VERT_INTERP_BILINEAR |
						 HORIZ_AUTO_SCALE |
						 HORIZ_INTERP_BILINEAR);
		}
370
		break;
371

372 373 374 375 376
	default:
		break;
	}

out:
377 378 379 380
	if ((pfit_control & PFIT_ENABLE) == 0) {
		pfit_control = 0;
		pfit_pgm_ratios = 0;
	}
381 382 383 384 385 386
	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;
	}
387 388
	dev_priv->lvds_border_bits = border;

J
Jesse Barnes 已提交
389 390 391 392 393 394 395 396 397 398 399 400 401
	/*
	 * 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;
402
	struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
J
Jesse Barnes 已提交
403

404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
	/* 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,
420 421
			   (I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS)
			   & ~POWER_TARGET_ON);
422 423 424 425
	} else {
		I915_WRITE(PP_CONTROL,
			   I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
	}
J
Jesse Barnes 已提交
426 427
}

428
static void intel_lvds_commit(struct drm_encoder *encoder)
J
Jesse Barnes 已提交
429 430 431
{
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
432
	struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
J
Jesse Barnes 已提交
433

434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
	/* 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.
	 */
450
	intel_lvds_enable(intel_lvds);
J
Jesse Barnes 已提交
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
}

static void intel_lvds_mode_set(struct drm_encoder *encoder,
				struct drm_display_mode *mode,
				struct drm_display_mode *adjusted_mode)
{
	/*
	 * 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.
	 */
}

/**
 * Detect the LVDS connection.
 *
467 468 469
 * 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 已提交
470
 */
471
static enum drm_connector_status
472
intel_lvds_detect(struct drm_connector *connector, bool force)
J
Jesse Barnes 已提交
473
{
474
	struct drm_device *dev = connector->dev;
475
	struct drm_i915_private *dev_priv = dev->dev_private;
476 477
	enum drm_connector_status status = connector_status_connected;

478 479 480 481 482 483
	/* Assume that the BIOS does not lie through the OpRegion... */
	if (dev_priv->opregion.lid_state)
		return ioread32(dev_priv->opregion.lid_state) & 0x1 ?
			connector_status_connected :
			connector_status_disconnected;

484 485 486
	/* ACPI lid methods were generally unreliable in this generation, so
	 * don't even bother.
	 */
487
	if (IS_GEN2(dev) || IS_GEN3(dev))
488 489
		return connector_status_connected;

490
	return status;
J
Jesse Barnes 已提交
491 492 493 494 495 496 497
}

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

502
	if (intel_lvds->edid)
C
Chris Wilson 已提交
503
		return drm_add_edid_modes(connector, intel_lvds->edid);
J
Jesse Barnes 已提交
504

505
	mode = drm_mode_duplicate(dev, intel_lvds->fixed_mode);
C
Chris Wilson 已提交
506
	if (mode == NULL)
507
		return 0;
J
Jesse Barnes 已提交
508

509 510
	drm_mode_probed_add(connector, mode);
	return 1;
J
Jesse Barnes 已提交
511 512
}

513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
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 */
};

533 534 535 536 537 538 539 540 541
/*
 * 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").
 */
542 543 544 545 546 547
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;
548
	struct drm_connector *connector = dev_priv->int_lvds_connector;
549

550 551 552 553 554
	/*
	 * check and update the status of LVDS connector after receiving
	 * the LID nofication event.
	 */
	if (connector)
555
		connector->status = connector->funcs->detect(connector,
556
							     false);
557

558 559 560
	/* Don't force modeset on machines where it causes a GPU lockup */
	if (dmi_check_system(intel_no_modeset_on_lid))
		return NOTIFY_OK;
561 562 563
	if (!acpi_lid_open()) {
		dev_priv->modeset_on_lid = 1;
		return NOTIFY_OK;
564
	}
565

566 567 568 569 570 571 572 573
	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);
574

575 576 577
	return NOTIFY_OK;
}

J
Jesse Barnes 已提交
578 579 580 581 582 583 584 585 586
/**
 * 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)
{
587 588
	struct drm_device *dev = connector->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
J
Jesse Barnes 已提交
589

590 591
	if (dev_priv->lid_notifier.notifier_call)
		acpi_lid_notifier_unregister(&dev_priv->lid_notifier);
J
Jesse Barnes 已提交
592 593 594 595 596
	drm_sysfs_connector_remove(connector);
	drm_connector_cleanup(connector);
	kfree(connector);
}

597 598 599 600
static int intel_lvds_set_property(struct drm_connector *connector,
				   struct drm_property *property,
				   uint64_t value)
{
601
	struct intel_lvds *intel_lvds = intel_attached_lvds(connector);
602 603
	struct drm_device *dev = connector->dev;

604 605
	if (property == dev->mode_config.scaling_mode_property) {
		struct drm_crtc *crtc = intel_lvds->base.base.crtc;
606

607 608
		if (value == DRM_MODE_SCALE_NONE) {
			DRM_DEBUG_KMS("no scaling not supported\n");
609
			return -EINVAL;
610
		}
611

C
Chris Wilson 已提交
612
		if (intel_lvds->fitting_mode == value) {
613 614 615
			/* the LVDS scaling property is not changed */
			return 0;
		}
C
Chris Wilson 已提交
616
		intel_lvds->fitting_mode = value;
617 618 619 620 621 622 623 624 625 626
		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);
		}
	}

627 628 629
	return 0;
}

J
Jesse Barnes 已提交
630 631 632 633 634 635 636 637 638 639 640
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,
641
	.best_encoder = intel_best_encoder,
J
Jesse Barnes 已提交
642 643 644
};

static const struct drm_connector_funcs intel_lvds_connector_funcs = {
645
	.dpms = drm_helper_connector_dpms,
J
Jesse Barnes 已提交
646 647
	.detect = intel_lvds_detect,
	.fill_modes = drm_helper_probe_single_connector_modes,
648
	.set_property = intel_lvds_set_property,
J
Jesse Barnes 已提交
649 650 651 652
	.destroy = intel_lvds_destroy,
};

static const struct drm_encoder_funcs intel_lvds_enc_funcs = {
C
Chris Wilson 已提交
653
	.destroy = intel_encoder_destroy,
J
Jesse Barnes 已提交
654 655
};

656 657
static int __init intel_no_lvds_dmi_callback(const struct dmi_system_id *id)
{
658
	DRM_DEBUG_KMS("Skipping LVDS initialization for %s\n", id->ident);
659 660
	return 1;
}
J
Jesse Barnes 已提交
661

662
/* These systems claim to have LVDS, but really don't */
663
static const struct dmi_system_id intel_no_lvds[] = {
664 665 666 667
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Apple Mac Mini (Core series)",
		.matches = {
668
			DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
669 670 671 672 673 674 675
			DMI_MATCH(DMI_PRODUCT_NAME, "Macmini1,1"),
		},
	},
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Apple Mac Mini (Core 2 series)",
		.matches = {
676
			DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
			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"),
		},
	},
696 697 698 699 700 701 702 703
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "AOpen Mini PC",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "AOpen"),
			DMI_MATCH(DMI_PRODUCT_NAME, "i965GMx-IF"),
		},
	},
704 705 706 707 708 709 710 711
	{
		.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"),
		},
	},
712 713 714 715 716 717 718 719
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "AOpen i915GMm-HFS",
		.matches = {
			DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
			DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
		},
	},
720 721 722 723 724 725 726
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Aopen i945GTt-VFA",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_VERSION, "AO00001JW"),
		},
	},
727 728 729 730 731 732 733 734
	{
		.callback = intel_no_lvds_dmi_callback,
		.ident = "Clientron U800",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Clientron"),
			DMI_MATCH(DMI_PRODUCT_NAME, "U800"),
		},
	},
735 736 737

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

739 740 741 742 743 744 745 746
/**
 * 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,
747 748
				      struct drm_display_mode *fixed_mode,
				      struct drm_connector *connector)
749 750
{
	struct drm_i915_private *dev_priv = dev->dev_private;
751
	struct drm_display_mode *scan;
752 753
	int temp_downclock;

754
	temp_downclock = fixed_mode->clock;
755 756 757 758 759 760 761 762
	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.
		 */
763 764 765 766 767 768 769 770
		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) {
771 772 773 774 775 776 777 778 779
			if (scan->clock < temp_downclock) {
				/*
				 * The downclock is already found. But we
				 * expect to find the lower downclock.
				 */
				temp_downclock = scan->clock;
			}
		}
	}
780
	if (temp_downclock < fixed_mode->clock && i915_lvds_downclock) {
781 782 783 784
		/* 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. "
785 786
			      "Normal clock %dKhz, downclock %dKhz\n",
			      fixed_mode->clock, temp_downclock);
787 788 789
	}
}

790 791 792 793 794 795 796
/*
 * 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.
 */
797 798
static bool lvds_is_present_in_vbt(struct drm_device *dev,
				   u8 *i2c_pin)
799 800
{
	struct drm_i915_private *dev_priv = dev->dev_private;
801
	int i;
802 803

	if (!dev_priv->child_dev_num)
804
		return true;
805 806

	for (i = 0; i < dev_priv->child_dev_num; i++) {
807 808 809 810 811
		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.
812
		 */
813 814
		if (child->device_type != DEVICE_TYPE_INT_LFP &&
		    child->device_type != DEVICE_TYPE_LFP)
815 816
			continue;

817 818 819
		if (child->i2c_pin)
		    *i2c_pin = child->i2c_pin;

820 821 822 823
		/* 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.
824
		 */
825 826 827 828 829 830 831 832 833 834
		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;
835
	}
836 837

	return false;
838 839
}

840
static bool intel_lvds_ddc_probe(struct drm_device *dev, u8 pin)
841 842 843 844 845 846 847 848 849 850 851
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	u8 buf = 0;
	struct i2c_msg msgs[] = {
		{
			.addr = 0xA0,
			.flags = 0,
			.len = 1,
			.buf = &buf,
		},
	};
852
	struct i2c_adapter *i2c = &dev_priv->gmbus[pin].adapter;
853 854 855
	/* XXX this only appears to work when using GMBUS */
	if (intel_gmbus_is_forced_bit(i2c))
		return true;
856 857 858
	return i2c_transfer(i2c, msgs, 1) == 1;
}

J
Jesse Barnes 已提交
859 860 861 862 863 864 865
/**
 * 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).
 */
866
bool intel_lvds_init(struct drm_device *dev)
J
Jesse Barnes 已提交
867 868
{
	struct drm_i915_private *dev_priv = dev->dev_private;
C
Chris Wilson 已提交
869
	struct intel_lvds *intel_lvds;
870
	struct intel_encoder *intel_encoder;
871
	struct intel_connector *intel_connector;
J
Jesse Barnes 已提交
872 873 874 875 876
	struct drm_connector *connector;
	struct drm_encoder *encoder;
	struct drm_display_mode *scan; /* *modes, *bios_mode; */
	struct drm_crtc *crtc;
	u32 lvds;
877 878
	int pipe;
	u8 pin;
J
Jesse Barnes 已提交
879

880 881
	/* Skip init on machines we know falsely report LVDS */
	if (dmi_check_system(intel_no_lvds))
882
		return false;
883

884 885
	pin = GMBUS_PORT_PANEL;
	if (!lvds_is_present_in_vbt(dev, &pin)) {
886
		DRM_DEBUG_KMS("LVDS is not present in VBT\n");
887
		return false;
A
Adam Jackson 已提交
888
	}
889

890
	if (HAS_PCH_SPLIT(dev)) {
891
		if ((I915_READ(PCH_LVDS) & LVDS_DETECTED) == 0)
892
			return false;
893
		if (dev_priv->edp.support) {
894
			DRM_DEBUG_KMS("disable LVDS for eDP support\n");
895
			return false;
896
		}
897 898
	}

899
	if (!intel_lvds_ddc_probe(dev, pin)) {
900
		DRM_DEBUG_KMS("LVDS did not respond to DDC probe\n");
901
		return false;
902 903
	}

C
Chris Wilson 已提交
904 905
	intel_lvds = kzalloc(sizeof(struct intel_lvds), GFP_KERNEL);
	if (!intel_lvds) {
906
		return false;
J
Jesse Barnes 已提交
907 908
	}

909 910
	intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
	if (!intel_connector) {
C
Chris Wilson 已提交
911
		kfree(intel_lvds);
912
		return false;
913 914
	}

915 916 917 918
	if (!HAS_PCH_SPLIT(dev)) {
		intel_lvds->pfit_control = I915_READ(PFIT_CONTROL);
	}

C
Chris Wilson 已提交
919
	intel_encoder = &intel_lvds->base;
920
	encoder = &intel_encoder->base;
C
Chris Wilson 已提交
921
	connector = &intel_connector->base;
922
	drm_connector_init(dev, &intel_connector->base, &intel_lvds_connector_funcs,
J
Jesse Barnes 已提交
923 924
			   DRM_MODE_CONNECTOR_LVDS);

925
	drm_encoder_init(dev, &intel_encoder->base, &intel_lvds_enc_funcs,
J
Jesse Barnes 已提交
926 927
			 DRM_MODE_ENCODER_LVDS);

928
	intel_connector_attach_encoder(intel_connector, intel_encoder);
929
	intel_encoder->type = INTEL_OUTPUT_LVDS;
J
Jesse Barnes 已提交
930

931 932
	intel_encoder->clone_mask = (1 << INTEL_LVDS_CLONE_BIT);
	intel_encoder->crtc_mask = (1 << 1);
933 934
	if (INTEL_INFO(dev)->gen >= 5)
		intel_encoder->crtc_mask |= (1 << 0);
J
Jesse Barnes 已提交
935 936 937 938 939 940
	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;

941 942 943 944 945
	/* create the scaling mode property */
	drm_mode_create_scaling_mode_property(dev);
	/*
	 * the initial panel fitting mode will be FULL_SCREEN.
	 */
J
Jesse Barnes 已提交
946

947
	drm_connector_attach_property(&intel_connector->base,
948
				      dev->mode_config.scaling_mode_property,
949
				      DRM_MODE_SCALE_ASPECT);
C
Chris Wilson 已提交
950
	intel_lvds->fitting_mode = DRM_MODE_SCALE_ASPECT;
J
Jesse Barnes 已提交
951 952 953 954 955 956 957 958 959 960 961 962 963 964
	/*
	 * 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 已提交
965
	intel_lvds->edid = drm_get_edid(connector,
966
					&dev_priv->gmbus[pin].adapter);
967 968 969 970 971 972 973 974 975 976
	if (intel_lvds->edid) {
		if (drm_add_edid_modes(connector,
				       intel_lvds->edid)) {
			drm_mode_connector_update_edid_property(connector,
								intel_lvds->edid);
		} else {
			kfree(intel_lvds->edid);
			intel_lvds->edid = NULL;
		}
	}
C
Chris Wilson 已提交
977
	if (!intel_lvds->edid) {
978 979 980 981 982 983 984 985 986
		/* 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 已提交
987 988 989

	list_for_each_entry(scan, &connector->probed_modes, head) {
		if (scan->type & DRM_MODE_TYPE_PREFERRED) {
990
			intel_lvds->fixed_mode =
J
Jesse Barnes 已提交
991
				drm_mode_duplicate(dev, scan);
992 993 994
			intel_find_lvds_downclock(dev,
						  intel_lvds->fixed_mode,
						  connector);
995
			goto out;
J
Jesse Barnes 已提交
996 997 998 999
		}
	}

	/* Failed to get EDID, what about VBT? */
1000
	if (dev_priv->lfp_lvds_vbt_mode) {
1001
		intel_lvds->fixed_mode =
1002
			drm_mode_duplicate(dev, dev_priv->lfp_lvds_vbt_mode);
1003 1004
		if (intel_lvds->fixed_mode) {
			intel_lvds->fixed_mode->type |=
1005 1006 1007
				DRM_MODE_TYPE_PREFERRED;
			goto out;
		}
J
Jesse Barnes 已提交
1008 1009 1010 1011 1012 1013 1014
	}

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

1016
	/* Ironlake: FIXME if still fail, not try pipe mode now */
1017
	if (HAS_PCH_SPLIT(dev))
1018 1019
		goto failed;

J
Jesse Barnes 已提交
1020 1021
	lvds = I915_READ(LVDS);
	pipe = (lvds & LVDS_PIPEB_SELECT) ? 1 : 0;
1022
	crtc = intel_get_crtc_for_pipe(dev, pipe);
J
Jesse Barnes 已提交
1023 1024

	if (crtc && (lvds & LVDS_PORT_EN)) {
1025 1026 1027
		intel_lvds->fixed_mode = intel_crtc_mode_get(dev, crtc);
		if (intel_lvds->fixed_mode) {
			intel_lvds->fixed_mode->type |=
J
Jesse Barnes 已提交
1028
				DRM_MODE_TYPE_PREFERRED;
1029
			goto out;
J
Jesse Barnes 已提交
1030 1031 1032 1033
		}
	}

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

out:
1038
	if (HAS_PCH_SPLIT(dev)) {
1039
		u32 pwm;
1040 1041 1042 1043

		pipe = (I915_READ(PCH_LVDS) & LVDS_PIPEB_SELECT) ? 1 : 0;

		/* make sure PWM is enabled and locked to the LVDS pipe */
1044
		pwm = I915_READ(BLC_PWM_CPU_CTL2);
1045 1046 1047 1048 1049 1050 1051
		if (pipe == 0 && (pwm & PWM_PIPE_B))
			I915_WRITE(BLC_PWM_CPU_CTL2, pwm & ~PWM_ENABLE);
		if (pipe)
			pwm |= PWM_PIPE_B;
		else
			pwm &= ~PWM_PIPE_B;
		I915_WRITE(BLC_PWM_CPU_CTL2, pwm | PWM_ENABLE);
1052 1053 1054 1055 1056

		pwm = I915_READ(BLC_PWM_PCH_CTL1);
		pwm |= PWM_PCH_ENABLE;
		I915_WRITE(BLC_PWM_PCH_CTL1, pwm);
	}
1057 1058
	dev_priv->lid_notifier.notifier_call = intel_lid_notify;
	if (acpi_lid_notifier_register(&dev_priv->lid_notifier)) {
1059
		DRM_DEBUG_KMS("lid notifier registration failed\n");
1060 1061
		dev_priv->lid_notifier.notifier_call = NULL;
	}
1062 1063
	/* keep the LVDS connector */
	dev_priv->int_lvds_connector = connector;
J
Jesse Barnes 已提交
1064
	drm_sysfs_connector_add(connector);
1065
	return true;
J
Jesse Barnes 已提交
1066 1067

failed:
1068
	DRM_DEBUG_KMS("No LVDS modes found, disabling.\n");
J
Jesse Barnes 已提交
1069
	drm_connector_cleanup(connector);
1070
	drm_encoder_cleanup(encoder);
C
Chris Wilson 已提交
1071
	kfree(intel_lvds);
1072
	kfree(intel_connector);
1073
	return false;
J
Jesse Barnes 已提交
1074
}