WebSVN – Kolibri OS – Diff – /drivers/video/drm/i915/intel_panel.c


/*
 * Copyright © 2006-2010 Intel Corporation
 * Copyright (c) 2006 Dave Airlie 
 *
 * 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 
 *      Dave Airlie 
 *      Jesse Barnes 
 *      Chris Wilson 
 */
 
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
#include 
#include "intel_drv.h"
 
#define PCI_LBPC 0xf4 /* legacy/combination backlight modes */
 
void
intel_fixed_panel_mode(struct drm_display_mode *fixed_mode,
		       struct drm_display_mode *adjusted_mode)
{
	adjusted_mode->hdisplay = fixed_mode->hdisplay;
	adjusted_mode->hsync_start = fixed_mode->hsync_start;
	adjusted_mode->hsync_end = fixed_mode->hsync_end;
	adjusted_mode->htotal = fixed_mode->htotal;
 
	adjusted_mode->vdisplay = fixed_mode->vdisplay;
	adjusted_mode->vsync_start = fixed_mode->vsync_start;
	adjusted_mode->vsync_end = fixed_mode->vsync_end;
	adjusted_mode->vtotal = fixed_mode->vtotal;
 
	adjusted_mode->clock = fixed_mode->clock;
}
 
/* adjusted_mode has been preset to be the panel's fixed mode */
void
intel_pch_panel_fitting(struct drm_device *dev,
			int fitting_mode,
			const struct drm_display_mode *mode,
			struct drm_display_mode *adjusted_mode)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	int x, y, width, height;
 
	x = y = width = height = 0;
 
	/* Native modes don't need fitting */
	if (adjusted_mode->hdisplay == mode->hdisplay &&
	    adjusted_mode->vdisplay == mode->vdisplay)
		goto done;
 
	switch (fitting_mode) {
	case DRM_MODE_SCALE_CENTER:
		width = mode->hdisplay;
		height = mode->vdisplay;
		x = (adjusted_mode->hdisplay - width + 1)/2;
		y = (adjusted_mode->vdisplay - height + 1)/2;
		break;
 
	case DRM_MODE_SCALE_ASPECT:
		/* Scale but preserve the aspect ratio */
		{
			u32 scaled_width = adjusted_mode->hdisplay * mode->vdisplay;
			u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;
			if (scaled_width > scaled_height) { /* pillar */
				width = scaled_height / mode->vdisplay;
				if (width & 1)
				    	width++;
				x = (adjusted_mode->hdisplay - width + 1) / 2;
				y = 0;
				height = adjusted_mode->vdisplay;
			} else if (scaled_width < scaled_height) { /* letter */
				height = scaled_width / mode->hdisplay;
				if (height & 1)
				    height++;
				y = (adjusted_mode->vdisplay - height + 1) / 2;
				x = 0;
				width = adjusted_mode->hdisplay;
			} else {
				x = y = 0;
				width = adjusted_mode->hdisplay;
				height = adjusted_mode->vdisplay;
			}
		}
		break;
 
	default:
	case DRM_MODE_SCALE_FULLSCREEN:
		x = y = 0;
		width = adjusted_mode->hdisplay;
		height = adjusted_mode->vdisplay;
		break;
	}
 
done:
	dev_priv->pch_pf_pos = (x << 16) | y;
	dev_priv->pch_pf_size = (width << 16) | height;
}
 
static int is_backlight_combination_mode(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
 
	if (INTEL_INFO(dev)->gen >= 4)
		return I915_READ(BLC_PWM_CTL2) & BLM_COMBINATION_MODE;
 
	if (IS_GEN2(dev))
		return I915_READ(BLC_PWM_CTL) & BLM_LEGACY_MODE;
 
	return 0;
}
 
static u32 i915_read_blc_pwm_ctl(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	u32 val;
 
	/* Restore the CTL value if it lost, e.g. GPU reset */
 
	if (HAS_PCH_SPLIT(dev_priv->dev)) {
		val = I915_READ(BLC_PWM_PCH_CTL2);
		if (dev_priv->regfile.saveBLC_PWM_CTL2 == 0) {
			dev_priv->regfile.saveBLC_PWM_CTL2 = val;
		} else if (val == 0) {
 
			val = dev_priv->regfile.saveBLC_PWM_CTL2;
			I915_WRITE(BLC_PWM_PCH_CTL2, val);
		}
	} else {
		val = I915_READ(BLC_PWM_CTL);
		if (dev_priv->regfile.saveBLC_PWM_CTL == 0) {
			dev_priv->regfile.saveBLC_PWM_CTL = val;
			if (INTEL_INFO(dev)->gen >= 4)
				dev_priv->regfile.saveBLC_PWM_CTL2 =
					I915_READ(BLC_PWM_CTL2);
		} else if (val == 0) {
			val = dev_priv->regfile.saveBLC_PWM_CTL;
			I915_WRITE(BLC_PWM_CTL, val);
			if (INTEL_INFO(dev)->gen >= 4)
			I915_WRITE(BLC_PWM_CTL2,
					   dev_priv->regfile.saveBLC_PWM_CTL2);
 
		}
	}
 
	return val;
}
 
static u32 _intel_panel_get_max_backlight(struct drm_device *dev)
{
 
	u32 max;
 
	max = i915_read_blc_pwm_ctl(dev);
 
	if (HAS_PCH_SPLIT(dev)) {
		max >>= 16;
	} else {
		if (INTEL_INFO(dev)->gen < 4)
			max >>= 17;
		else
			max >>= 16;
 
		if (is_backlight_combination_mode(dev))
			max *= 0xff;
	}
 
	return max;
}
 
u32 intel_panel_get_max_backlight(struct drm_device *dev)
{
	u32 max;
 
	max = _intel_panel_get_max_backlight(dev);
	if (max == 0) {
		/* XXX add code here to query mode clock or hardware clock
		 * and program max PWM appropriately.
		 */
        printk("fixme: max PWM is zero\n");
		return 1;
	}
 
	DRM_DEBUG_DRIVER("max backlight PWM = %d\n", max);
	return max;
}
 
static int i915_panel_invert_brightness;
MODULE_PARM_DESC(invert_brightness, "Invert backlight brightness "
	"(-1 force normal, 0 machine defaults, 1 force inversion), please "
	"report PCI device ID, subsystem vendor and subsystem device ID "
	"to dri-devel@lists.freedesktop.org, if your machine needs it. "
	"It will then be included in an upcoming module version.");
module_param_named(invert_brightness, i915_panel_invert_brightness, int, 0600);
static u32 intel_panel_compute_brightness(struct drm_device *dev, u32 val)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
 
	if (i915_panel_invert_brightness < 0)
		return val;
 
	if (i915_panel_invert_brightness > 0 ||
	    dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS)
		return intel_panel_get_max_backlight(dev) - val;
 
	return val;
}
 
static u32 intel_panel_get_backlight(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	u32 val;
 
	if (HAS_PCH_SPLIT(dev)) {
		val = I915_READ(BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
	} else {
		val = I915_READ(BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
		if (INTEL_INFO(dev)->gen < 4)
			val >>= 1;
 
		if (is_backlight_combination_mode(dev)) {
			u8 lbpc;
 
			pci_read_config_byte(dev->pdev, PCI_LBPC, &lbpc);
			val *= lbpc;
		}
	}
 
	val = intel_panel_compute_brightness(dev, val);
	DRM_DEBUG_DRIVER("get backlight PWM = %d\n", val);
	return val;
}
 
static void intel_pch_panel_set_backlight(struct drm_device *dev, u32 level)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	u32 val = I915_READ(BLC_PWM_CPU_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK;
	I915_WRITE(BLC_PWM_CPU_CTL, val | level);
}
 
static void intel_panel_actually_set_backlight(struct drm_device *dev, u32 level)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	u32 tmp;
 
	DRM_DEBUG_DRIVER("set backlight PWM = %d\n", level);
	level = intel_panel_compute_brightness(dev, level);
 
	if (HAS_PCH_SPLIT(dev))
		return intel_pch_panel_set_backlight(dev, level);
 
	if (is_backlight_combination_mode(dev)) {
		u32 max = intel_panel_get_max_backlight(dev);
		u8 lbpc;
 
		lbpc = level * 0xfe / max + 1;
		level /= lbpc;
		pci_write_config_byte(dev->pdev, PCI_LBPC, lbpc);
	}
 
	tmp = I915_READ(BLC_PWM_CTL);
	if (INTEL_INFO(dev)->gen < 4)
		level <<= 1;
		tmp &= ~BACKLIGHT_DUTY_CYCLE_MASK;
	I915_WRITE(BLC_PWM_CTL, tmp | level);
}
 
void intel_panel_set_backlight(struct drm_device *dev, u32 level)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
 
	dev_priv->backlight_level = level;
	if (dev_priv->backlight_enabled)
		intel_panel_actually_set_backlight(dev, level);
}
 
void intel_panel_disable_backlight(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
 
		dev_priv->backlight_enabled = false;
	intel_panel_actually_set_backlight(dev, 0);
 
	if (INTEL_INFO(dev)->gen >= 4) {
		uint32_t reg, tmp;
 
		reg = HAS_PCH_SPLIT(dev) ? BLC_PWM_CPU_CTL2 : BLC_PWM_CTL2;
 
		I915_WRITE(reg, I915_READ(reg) & ~BLM_PWM_ENABLE);
 
		if (HAS_PCH_SPLIT(dev)) {
			tmp = I915_READ(BLC_PWM_PCH_CTL1);
			tmp &= ~BLM_PCH_PWM_ENABLE;
			I915_WRITE(BLC_PWM_PCH_CTL1, tmp);
		}
	}
}
 
void intel_panel_enable_backlight(struct drm_device *dev,
				  enum pipe pipe)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
 
	if (dev_priv->backlight_level == 0)
		dev_priv->backlight_level = intel_panel_get_max_backlight(dev);
 
	if (INTEL_INFO(dev)->gen >= 4) {
		uint32_t reg, tmp;
 
		reg = HAS_PCH_SPLIT(dev) ? BLC_PWM_CPU_CTL2 : BLC_PWM_CTL2;
 
 
		tmp = I915_READ(reg);
 
		/* Note that this can also get called through dpms changes. And
		 * we don't track the backlight dpms state, hence check whether
		 * we have to do anything first. */
		if (tmp & BLM_PWM_ENABLE)
			goto set_level;
 
		if (dev_priv->num_pipe == 3)
			tmp &= ~BLM_PIPE_SELECT_IVB;
		else
			tmp &= ~BLM_PIPE_SELECT;
 
		tmp |= BLM_PIPE(pipe);
		tmp &= ~BLM_PWM_ENABLE;
 
		I915_WRITE(reg, tmp);
		POSTING_READ(reg);
		I915_WRITE(reg, tmp | BLM_PWM_ENABLE);
 
		if (HAS_PCH_SPLIT(dev)) {
			tmp = I915_READ(BLC_PWM_PCH_CTL1);
			tmp |= BLM_PCH_PWM_ENABLE;
			tmp &= ~BLM_PCH_OVERRIDE_ENABLE;
			I915_WRITE(BLC_PWM_PCH_CTL1, tmp);
		}
	}
 
set_level:
	/* Call below after setting BLC_PWM_CPU_CTL2 and BLC_PWM_PCH_CTL1.
	 * BLC_PWM_CPU_CTL may be cleared to zero automatically when these
	 * registers are set.
	 */
	dev_priv->backlight_enabled = true;
	intel_panel_actually_set_backlight(dev, dev_priv->backlight_level);
}
 
static void intel_panel_init_backlight(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
 
	dev_priv->backlight_level = intel_panel_get_backlight(dev);
	dev_priv->backlight_enabled = dev_priv->backlight_level != 0;
}
 
enum drm_connector_status
intel_panel_detect(struct drm_device *dev)
{
 
	struct drm_i915_private *dev_priv = dev->dev_private;
 
 
 
 
 
 
 
 
 
 
	/* Assume that the BIOS does not lie through the OpRegion... */
	if (!i915_panel_ignore_lid && dev_priv->opregion.lid_state) {
		return ioread32(dev_priv->opregion.lid_state) & 0x1 ?
			connector_status_connected :
			connector_status_disconnected;
	}
 
	switch (i915_panel_ignore_lid) {
	case -2:
		return connector_status_connected;
	case -1:
		return connector_status_disconnected;
	default:
	return connector_status_unknown;
	}
}
 
#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
static int intel_panel_update_status(struct backlight_device *bd)
{
	struct drm_device *dev = bl_get_data(bd);
	intel_panel_set_backlight(dev, bd->props.brightness);
	return 0;
}
 
static int intel_panel_get_brightness(struct backlight_device *bd)
{
	struct drm_device *dev = bl_get_data(bd);
	struct drm_i915_private *dev_priv = dev->dev_private;
	return dev_priv->backlight_level;
}
 
static const struct backlight_ops intel_panel_bl_ops = {
	.update_status = intel_panel_update_status,
	.get_brightness = intel_panel_get_brightness,
};
 
int intel_panel_setup_backlight(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
 
	struct backlight_properties props;
 
	intel_panel_init_backlight(dev);
 
 
 
 
 
 
 
 
	memset(&props, 0, sizeof(props));
	props.type = BACKLIGHT_RAW;
	props.max_brightness = _intel_panel_get_max_backlight(dev);
	if (props.max_brightness == 0) {
		DRM_DEBUG_DRIVER("Failed to get maximum backlight value\n");
		return -ENODEV;
	}
	dev_priv->backlight =
		backlight_device_register("intel_backlight",
					  &connector->kdev, dev,
					  &intel_panel_bl_ops, &props);
 
	if (IS_ERR(dev_priv->backlight)) {
		DRM_ERROR("Failed to register backlight: %ld\n",
			  PTR_ERR(dev_priv->backlight));
		dev_priv->backlight = NULL;
		return -ENODEV;
	}
	dev_priv->backlight->props.brightness = intel_panel_get_backlight(dev);
	return 0;
}
 
void intel_panel_destroy_backlight(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	if (dev_priv->backlight)
		backlight_device_unregister(dev_priv->backlight);
}
#else
int intel_panel_setup_backlight(struct drm_connector *connector)
{
	intel_panel_init_backlight(connector->dev);
	return 0;
}
 
void intel_panel_destroy_backlight(struct drm_device *dev)
{
	return;
}
#endif
 
int intel_panel_init(struct intel_panel *panel,
		     struct drm_display_mode *fixed_mode)
{
	panel->fixed_mode = fixed_mode;
 
	return 0;
}
 
void intel_panel_fini(struct intel_panel *panel)
{
	struct intel_connector *intel_connector =
		container_of(panel, struct intel_connector, panel);
 
	if (panel->fixed_mode)
		drm_mode_destroy(intel_connector->base.dev, panel->fixed_mode);
}

Rev 3037	Rev 3243
1	/*	1	/*
2	* Copyright © 2006-2010 Intel Corporation	2	* Copyright © 2006-2010 Intel Corporation
3	* Copyright (c) 2006 Dave Airlie	3	* Copyright (c) 2006 Dave Airlie
4	*	4	*
5	* Permission is hereby granted, free of charge, to any person obtaining a	5	* Permission is hereby granted, free of charge, to any person obtaining a
6	* copy of this software and associated documentation files (the "Software"),	6	* copy of this software and associated documentation files (the "Software"),
7	* to deal in the Software without restriction, including without limitation	7	* to deal in the Software without restriction, including without limitation
8	* the rights to use, copy, modify, merge, publish, distribute, sublicense,	8	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
9	* and/or sell copies of the Software, and to permit persons to whom the	9	* and/or sell copies of the Software, and to permit persons to whom the
10	* Software is furnished to do so, subject to the following conditions:	10	* Software is furnished to do so, subject to the following conditions:
11	*	11	*
12	* The above copyright notice and this permission notice (including the next	12	* The above copyright notice and this permission notice (including the next
13	* paragraph) shall be included in all copies or substantial portions of the	13	* paragraph) shall be included in all copies or substantial portions of the
14	* Software.	14	* Software.
15	*	15	*
16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER	19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER	21	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22	* DEALINGS IN THE SOFTWARE.	22	* DEALINGS IN THE SOFTWARE.
23	*	23	*
24	* Authors:	24	* Authors:
25	* Eric Anholt	25	* Eric Anholt
26	* Dave Airlie	26	* Dave Airlie
27	* Jesse Barnes	27	* Jesse Barnes
28	* Chris Wilson	28	* Chris Wilson
29	*/	29	*/
30		30
31	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt	31	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32		32
33	#include	33	#include
34	#include "intel_drv.h"	34	#include "intel_drv.h"
35		35
36	#define PCI_LBPC 0xf4 /* legacy/combination backlight modes */	36	#define PCI_LBPC 0xf4 /* legacy/combination backlight modes */
37		37
38	void	38	void
39	intel_fixed_panel_mode(struct drm_display_mode *fixed_mode,	39	intel_fixed_panel_mode(struct drm_display_mode *fixed_mode,
40	struct drm_display_mode *adjusted_mode)	40	struct drm_display_mode *adjusted_mode)
41	{	41	{
42	adjusted_mode->hdisplay = fixed_mode->hdisplay;	42	adjusted_mode->hdisplay = fixed_mode->hdisplay;
43	adjusted_mode->hsync_start = fixed_mode->hsync_start;	43	adjusted_mode->hsync_start = fixed_mode->hsync_start;
44	adjusted_mode->hsync_end = fixed_mode->hsync_end;	44	adjusted_mode->hsync_end = fixed_mode->hsync_end;
45	adjusted_mode->htotal = fixed_mode->htotal;	45	adjusted_mode->htotal = fixed_mode->htotal;
46		46
47	adjusted_mode->vdisplay = fixed_mode->vdisplay;	47	adjusted_mode->vdisplay = fixed_mode->vdisplay;
48	adjusted_mode->vsync_start = fixed_mode->vsync_start;	48	adjusted_mode->vsync_start = fixed_mode->vsync_start;
49	adjusted_mode->vsync_end = fixed_mode->vsync_end;	49	adjusted_mode->vsync_end = fixed_mode->vsync_end;
50	adjusted_mode->vtotal = fixed_mode->vtotal;	50	adjusted_mode->vtotal = fixed_mode->vtotal;
51		51
52	adjusted_mode->clock = fixed_mode->clock;	52	adjusted_mode->clock = fixed_mode->clock;
53	}	53	}
54		54
55	/* adjusted_mode has been preset to be the panel's fixed mode */	55	/* adjusted_mode has been preset to be the panel's fixed mode */
56	void	56	void
57	intel_pch_panel_fitting(struct drm_device *dev,	57	intel_pch_panel_fitting(struct drm_device *dev,
58	int fitting_mode,	58	int fitting_mode,
59	const struct drm_display_mode *mode,	59	const struct drm_display_mode *mode,
60	struct drm_display_mode *adjusted_mode)	60	struct drm_display_mode *adjusted_mode)
61	{	61	{
62	struct drm_i915_private *dev_priv = dev->dev_private;	62	struct drm_i915_private *dev_priv = dev->dev_private;
63	int x, y, width, height;	63	int x, y, width, height;
64		64
65	x = y = width = height = 0;	65	x = y = width = height = 0;
66		66
67	/* Native modes don't need fitting */	67	/* Native modes don't need fitting */
68	if (adjusted_mode->hdisplay == mode->hdisplay &&	68	if (adjusted_mode->hdisplay == mode->hdisplay &&
69	adjusted_mode->vdisplay == mode->vdisplay)	69	adjusted_mode->vdisplay == mode->vdisplay)
70	goto done;	70	goto done;
71		71
72	switch (fitting_mode) {	72	switch (fitting_mode) {
73	case DRM_MODE_SCALE_CENTER:	73	case DRM_MODE_SCALE_CENTER:
74	width = mode->hdisplay;	74	width = mode->hdisplay;
75	height = mode->vdisplay;	75	height = mode->vdisplay;
76	x = (adjusted_mode->hdisplay - width + 1)/2;	76	x = (adjusted_mode->hdisplay - width + 1)/2;
77	y = (adjusted_mode->vdisplay - height + 1)/2;	77	y = (adjusted_mode->vdisplay - height + 1)/2;
78	break;	78	break;
79		79
80	case DRM_MODE_SCALE_ASPECT:	80	case DRM_MODE_SCALE_ASPECT:
81	/* Scale but preserve the aspect ratio */	81	/* Scale but preserve the aspect ratio */
82	{	82	{
83	u32 scaled_width = adjusted_mode->hdisplay * mode->vdisplay;	83	u32 scaled_width = adjusted_mode->hdisplay * mode->vdisplay;
84	u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;	84	u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;
85	if (scaled_width > scaled_height) { /* pillar */	85	if (scaled_width > scaled_height) { /* pillar */
86	width = scaled_height / mode->vdisplay;	86	width = scaled_height / mode->vdisplay;
87	if (width & 1)	87	if (width & 1)
88	width++;	88	width++;
89	x = (adjusted_mode->hdisplay - width + 1) / 2;	89	x = (adjusted_mode->hdisplay - width + 1) / 2;
90	y = 0;	90	y = 0;
91	height = adjusted_mode->vdisplay;	91	height = adjusted_mode->vdisplay;
92	} else if (scaled_width < scaled_height) { /* letter */	92	} else if (scaled_width < scaled_height) { /* letter */
93	height = scaled_width / mode->hdisplay;	93	height = scaled_width / mode->hdisplay;
94	if (height & 1)	94	if (height & 1)
95	height++;	95	height++;
96	y = (adjusted_mode->vdisplay - height + 1) / 2;	96	y = (adjusted_mode->vdisplay - height + 1) / 2;
97	x = 0;	97	x = 0;
98	width = adjusted_mode->hdisplay;	98	width = adjusted_mode->hdisplay;
99	} else {	99	} else {
100	x = y = 0;	100	x = y = 0;
101	width = adjusted_mode->hdisplay;	101	width = adjusted_mode->hdisplay;
102	height = adjusted_mode->vdisplay;	102	height = adjusted_mode->vdisplay;
103	}	103	}
104	}	104	}
105	break;	105	break;
106		106
107	default:	107	default:
108	case DRM_MODE_SCALE_FULLSCREEN:	108	case DRM_MODE_SCALE_FULLSCREEN:
109	x = y = 0;	109	x = y = 0;
110	width = adjusted_mode->hdisplay;	110	width = adjusted_mode->hdisplay;
111	height = adjusted_mode->vdisplay;	111	height = adjusted_mode->vdisplay;
112	break;	112	break;
113	}	113	}
114		114
115	done:	115	done:
116	dev_priv->pch_pf_pos = (x << 16) \| y;	116	dev_priv->pch_pf_pos = (x << 16) \| y;
117	dev_priv->pch_pf_size = (width << 16) \| height;	117	dev_priv->pch_pf_size = (width << 16) \| height;
118	}	118	}
119		119
120	static int is_backlight_combination_mode(struct drm_device *dev)	120	static int is_backlight_combination_mode(struct drm_device *dev)
121	{	121	{
122	struct drm_i915_private *dev_priv = dev->dev_private;	122	struct drm_i915_private *dev_priv = dev->dev_private;
123		123
124	if (INTEL_INFO(dev)->gen >= 4)	124	if (INTEL_INFO(dev)->gen >= 4)
125	return I915_READ(BLC_PWM_CTL2) & BLM_COMBINATION_MODE;	125	return I915_READ(BLC_PWM_CTL2) & BLM_COMBINATION_MODE;
126		126
127	if (IS_GEN2(dev))	127	if (IS_GEN2(dev))
128	return I915_READ(BLC_PWM_CTL) & BLM_LEGACY_MODE;	128	return I915_READ(BLC_PWM_CTL) & BLM_LEGACY_MODE;
129		129
130	return 0;	130	return 0;
131	}	131	}
132		132
133	static u32 i915_read_blc_pwm_ctl(struct drm_i915_private *dev_priv)	133	static u32 i915_read_blc_pwm_ctl(struct drm_device *dev)
-		134	{
134	{	135	struct drm_i915_private *dev_priv = dev->dev_private;
135	u32 val;	136	u32 val;
136		137
137	/* Restore the CTL value if it lost, e.g. GPU reset */	138	/* Restore the CTL value if it lost, e.g. GPU reset */
138		139
139	if (HAS_PCH_SPLIT(dev_priv->dev)) {	140	if (HAS_PCH_SPLIT(dev_priv->dev)) {
140	val = I915_READ(BLC_PWM_PCH_CTL2);	141	val = I915_READ(BLC_PWM_PCH_CTL2);
141	if (dev_priv->saveBLC_PWM_CTL2 == 0) {	142	if (dev_priv->regfile.saveBLC_PWM_CTL2 == 0) {
142	dev_priv->saveBLC_PWM_CTL2 = val;	143	dev_priv->regfile.saveBLC_PWM_CTL2 = val;
143	} else if (val == 0) {	144	} else if (val == 0) {
144	I915_WRITE(BLC_PWM_PCH_CTL2,	-
145	dev_priv->saveBLC_PWM_CTL2);	145	val = dev_priv->regfile.saveBLC_PWM_CTL2;
146	val = dev_priv->saveBLC_PWM_CTL2;	146	I915_WRITE(BLC_PWM_PCH_CTL2, val);
147	}	147	}
148	} else {	148	} else {
149	val = I915_READ(BLC_PWM_CTL);	149	val = I915_READ(BLC_PWM_CTL);
150	if (dev_priv->saveBLC_PWM_CTL == 0) {	150	if (dev_priv->regfile.saveBLC_PWM_CTL == 0) {
151	dev_priv->saveBLC_PWM_CTL = val;	151	dev_priv->regfile.saveBLC_PWM_CTL = val;
-		152	if (INTEL_INFO(dev)->gen >= 4)
152	dev_priv->saveBLC_PWM_CTL2 = I915_READ(BLC_PWM_CTL2);	153	dev_priv->regfile.saveBLC_PWM_CTL2 =
-		154	I915_READ(BLC_PWM_CTL2);
153	} else if (val == 0) {	155	} else if (val == 0) {
-		156	val = dev_priv->regfile.saveBLC_PWM_CTL;
154	I915_WRITE(BLC_PWM_CTL,	157	I915_WRITE(BLC_PWM_CTL, val);
155	dev_priv->saveBLC_PWM_CTL);	158	if (INTEL_INFO(dev)->gen >= 4)
156	I915_WRITE(BLC_PWM_CTL2,	159	I915_WRITE(BLC_PWM_CTL2,
157	dev_priv->saveBLC_PWM_CTL2);	160	dev_priv->regfile.saveBLC_PWM_CTL2);
158	val = dev_priv->saveBLC_PWM_CTL;	-
159	}	161	}
160	}	162	}
161		163
162	return val;	164	return val;
163	}	165	}
164		166
165	static u32 _intel_panel_get_max_backlight(struct drm_device *dev)	167	static u32 _intel_panel_get_max_backlight(struct drm_device *dev)
166	{	168	{
167	struct drm_i915_private *dev_priv = dev->dev_private;	-
168	u32 max;	169	u32 max;
169		170
170	max = i915_read_blc_pwm_ctl(dev_priv);	171	max = i915_read_blc_pwm_ctl(dev);
171		172
172	if (HAS_PCH_SPLIT(dev)) {	173	if (HAS_PCH_SPLIT(dev)) {
173	max >>= 16;	174	max >>= 16;
174	} else {	175	} else {
175	if (INTEL_INFO(dev)->gen < 4)	176	if (INTEL_INFO(dev)->gen < 4)
176	max >>= 17;	177	max >>= 17;
177	else	178	else
178	max >>= 16;	179	max >>= 16;
179		180
180	if (is_backlight_combination_mode(dev))	181	if (is_backlight_combination_mode(dev))
181	max *= 0xff;	182	max *= 0xff;
182	}	183	}
183		184
184	return max;	185	return max;
185	}	186	}
186		187
187	u32 intel_panel_get_max_backlight(struct drm_device *dev)	188	u32 intel_panel_get_max_backlight(struct drm_device *dev)
188	{	189	{
189	u32 max;	190	u32 max;
190		191
191	max = _intel_panel_get_max_backlight(dev);	192	max = _intel_panel_get_max_backlight(dev);
192	if (max == 0) {	193	if (max == 0) {
193	/* XXX add code here to query mode clock or hardware clock	194	/* XXX add code here to query mode clock or hardware clock
194	* and program max PWM appropriately.	195	* and program max PWM appropriately.
195	*/	196	*/
196	printk("fixme: max PWM is zero\n");	197	printk("fixme: max PWM is zero\n");
197	return 1;	198	return 1;
198	}	199	}
199		200
200	DRM_DEBUG_DRIVER("max backlight PWM = %d\n", max);	201	DRM_DEBUG_DRIVER("max backlight PWM = %d\n", max);
201	return max;	202	return max;
202	}	203	}
203		204
204	static int i915_panel_invert_brightness;	205	static int i915_panel_invert_brightness;
205	MODULE_PARM_DESC(invert_brightness, "Invert backlight brightness "	206	MODULE_PARM_DESC(invert_brightness, "Invert backlight brightness "
206	"(-1 force normal, 0 machine defaults, 1 force inversion), please "	207	"(-1 force normal, 0 machine defaults, 1 force inversion), please "
207	"report PCI device ID, subsystem vendor and subsystem device ID "	208	"report PCI device ID, subsystem vendor and subsystem device ID "
208	"to dri-devel@lists.freedesktop.org, if your machine needs it. "	209	"to dri-devel@lists.freedesktop.org, if your machine needs it. "
209	"It will then be included in an upcoming module version.");	210	"It will then be included in an upcoming module version.");
210	module_param_named(invert_brightness, i915_panel_invert_brightness, int, 0600);	211	module_param_named(invert_brightness, i915_panel_invert_brightness, int, 0600);
211	static u32 intel_panel_compute_brightness(struct drm_device *dev, u32 val)	212	static u32 intel_panel_compute_brightness(struct drm_device *dev, u32 val)
212	{	213	{
213	struct drm_i915_private *dev_priv = dev->dev_private;	214	struct drm_i915_private *dev_priv = dev->dev_private;
214		215
215	if (i915_panel_invert_brightness < 0)	216	if (i915_panel_invert_brightness < 0)
216	return val;	217	return val;
217		218
218	if (i915_panel_invert_brightness > 0 \|\|	219	if (i915_panel_invert_brightness > 0 \|\|
219	dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS)	220	dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS)
220	return intel_panel_get_max_backlight(dev) - val;	221	return intel_panel_get_max_backlight(dev) - val;
221		222
222	return val;	223	return val;
223	}	224	}
224		225
225	static u32 intel_panel_get_backlight(struct drm_device *dev)	226	static u32 intel_panel_get_backlight(struct drm_device *dev)
226	{	227	{
227	struct drm_i915_private *dev_priv = dev->dev_private;	228	struct drm_i915_private *dev_priv = dev->dev_private;
228	u32 val;	229	u32 val;
229		230
230	if (HAS_PCH_SPLIT(dev)) {	231	if (HAS_PCH_SPLIT(dev)) {
231	val = I915_READ(BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;	232	val = I915_READ(BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
232	} else {	233	} else {
233	val = I915_READ(BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;	234	val = I915_READ(BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
234	if (INTEL_INFO(dev)->gen < 4)	235	if (INTEL_INFO(dev)->gen < 4)
235	val >>= 1;	236	val >>= 1;
236		237
237	if (is_backlight_combination_mode(dev)) {	238	if (is_backlight_combination_mode(dev)) {
238	u8 lbpc;	239	u8 lbpc;
239		240
240	pci_read_config_byte(dev->pdev, PCI_LBPC, &lbpc);	241	pci_read_config_byte(dev->pdev, PCI_LBPC, &lbpc);
241	val *= lbpc;	242	val *= lbpc;
242	}	243	}
243	}	244	}
244		245
245	val = intel_panel_compute_brightness(dev, val);	246	val = intel_panel_compute_brightness(dev, val);
246	DRM_DEBUG_DRIVER("get backlight PWM = %d\n", val);	247	DRM_DEBUG_DRIVER("get backlight PWM = %d\n", val);
247	return val;	248	return val;
248	}	249	}
249		250
250	static void intel_pch_panel_set_backlight(struct drm_device *dev, u32 level)	251	static void intel_pch_panel_set_backlight(struct drm_device *dev, u32 level)
251	{	252	{
252	struct drm_i915_private *dev_priv = dev->dev_private;	253	struct drm_i915_private *dev_priv = dev->dev_private;
253	u32 val = I915_READ(BLC_PWM_CPU_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK;	254	u32 val = I915_READ(BLC_PWM_CPU_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK;
254	I915_WRITE(BLC_PWM_CPU_CTL, val \| level);	255	I915_WRITE(BLC_PWM_CPU_CTL, val \| level);
255	}	256	}
256		257
257	static void intel_panel_actually_set_backlight(struct drm_device *dev, u32 level)	258	static void intel_panel_actually_set_backlight(struct drm_device *dev, u32 level)
258	{	259	{
259	struct drm_i915_private *dev_priv = dev->dev_private;	260	struct drm_i915_private *dev_priv = dev->dev_private;
260	u32 tmp;	261	u32 tmp;
261		262
262	DRM_DEBUG_DRIVER("set backlight PWM = %d\n", level);	263	DRM_DEBUG_DRIVER("set backlight PWM = %d\n", level);
263	level = intel_panel_compute_brightness(dev, level);	264	level = intel_panel_compute_brightness(dev, level);
264		265
265	if (HAS_PCH_SPLIT(dev))	266	if (HAS_PCH_SPLIT(dev))
266	return intel_pch_panel_set_backlight(dev, level);	267	return intel_pch_panel_set_backlight(dev, level);
267		268
268	if (is_backlight_combination_mode(dev)) {	269	if (is_backlight_combination_mode(dev)) {
269	u32 max = intel_panel_get_max_backlight(dev);	270	u32 max = intel_panel_get_max_backlight(dev);
270	u8 lbpc;	271	u8 lbpc;
271		272
272	lbpc = level * 0xfe / max + 1;	273	lbpc = level * 0xfe / max + 1;
273	level /= lbpc;	274	level /= lbpc;
274	pci_write_config_byte(dev->pdev, PCI_LBPC, lbpc);	275	pci_write_config_byte(dev->pdev, PCI_LBPC, lbpc);
275	}	276	}
276		277
277	tmp = I915_READ(BLC_PWM_CTL);	278	tmp = I915_READ(BLC_PWM_CTL);
278	if (INTEL_INFO(dev)->gen < 4)	279	if (INTEL_INFO(dev)->gen < 4)
279	level <<= 1;	280	level <<= 1;
280	tmp &= ~BACKLIGHT_DUTY_CYCLE_MASK;	281	tmp &= ~BACKLIGHT_DUTY_CYCLE_MASK;
281	I915_WRITE(BLC_PWM_CTL, tmp \| level);	282	I915_WRITE(BLC_PWM_CTL, tmp \| level);
282	}	283	}
283		284
284	void intel_panel_set_backlight(struct drm_device *dev, u32 level)	285	void intel_panel_set_backlight(struct drm_device *dev, u32 level)
285	{	286	{
286	struct drm_i915_private *dev_priv = dev->dev_private;	287	struct drm_i915_private *dev_priv = dev->dev_private;
287		288
288	dev_priv->backlight_level = level;	289	dev_priv->backlight_level = level;
289	if (dev_priv->backlight_enabled)	290	if (dev_priv->backlight_enabled)
290	intel_panel_actually_set_backlight(dev, level);	291	intel_panel_actually_set_backlight(dev, level);
291	}	292	}
292		293
293	void intel_panel_disable_backlight(struct drm_device *dev)	294	void intel_panel_disable_backlight(struct drm_device *dev)
294	{	295	{
295	struct drm_i915_private *dev_priv = dev->dev_private;	296	struct drm_i915_private *dev_priv = dev->dev_private;
296		297
297	dev_priv->backlight_enabled = false;	298	dev_priv->backlight_enabled = false;
298	intel_panel_actually_set_backlight(dev, 0);	299	intel_panel_actually_set_backlight(dev, 0);
299		300
300	if (INTEL_INFO(dev)->gen >= 4) {	301	if (INTEL_INFO(dev)->gen >= 4) {
301	uint32_t reg, tmp;	302	uint32_t reg, tmp;
302		303
303	reg = HAS_PCH_SPLIT(dev) ? BLC_PWM_CPU_CTL2 : BLC_PWM_CTL2;	304	reg = HAS_PCH_SPLIT(dev) ? BLC_PWM_CPU_CTL2 : BLC_PWM_CTL2;
304		305
305	I915_WRITE(reg, I915_READ(reg) & ~BLM_PWM_ENABLE);	306	I915_WRITE(reg, I915_READ(reg) & ~BLM_PWM_ENABLE);
306		307
307	if (HAS_PCH_SPLIT(dev)) {	308	if (HAS_PCH_SPLIT(dev)) {
308	tmp = I915_READ(BLC_PWM_PCH_CTL1);	309	tmp = I915_READ(BLC_PWM_PCH_CTL1);
309	tmp &= ~BLM_PCH_PWM_ENABLE;	310	tmp &= ~BLM_PCH_PWM_ENABLE;
310	I915_WRITE(BLC_PWM_PCH_CTL1, tmp);	311	I915_WRITE(BLC_PWM_PCH_CTL1, tmp);
311	}	312	}
312	}	313	}
313	}	314	}
314		315
315	void intel_panel_enable_backlight(struct drm_device *dev,	316	void intel_panel_enable_backlight(struct drm_device *dev,
316	enum pipe pipe)	317	enum pipe pipe)
317	{	318	{
318	struct drm_i915_private *dev_priv = dev->dev_private;	319	struct drm_i915_private *dev_priv = dev->dev_private;
319		320
320	if (dev_priv->backlight_level == 0)	321	if (dev_priv->backlight_level == 0)
321	dev_priv->backlight_level = intel_panel_get_max_backlight(dev);	322	dev_priv->backlight_level = intel_panel_get_max_backlight(dev);
322		323
323	if (INTEL_INFO(dev)->gen >= 4) {	324	if (INTEL_INFO(dev)->gen >= 4) {
324	uint32_t reg, tmp;	325	uint32_t reg, tmp;
325		326
326	reg = HAS_PCH_SPLIT(dev) ? BLC_PWM_CPU_CTL2 : BLC_PWM_CTL2;	327	reg = HAS_PCH_SPLIT(dev) ? BLC_PWM_CPU_CTL2 : BLC_PWM_CTL2;
327		328
328		329
329	tmp = I915_READ(reg);	330	tmp = I915_READ(reg);
330		331
331	/* Note that this can also get called through dpms changes. And	332	/* Note that this can also get called through dpms changes. And
332	* we don't track the backlight dpms state, hence check whether	333	* we don't track the backlight dpms state, hence check whether
333	* we have to do anything first. */	334	* we have to do anything first. */
334	if (tmp & BLM_PWM_ENABLE)	335	if (tmp & BLM_PWM_ENABLE)
335	goto set_level;	336	goto set_level;
336		337
337	if (dev_priv->num_pipe == 3)	338	if (dev_priv->num_pipe == 3)
338	tmp &= ~BLM_PIPE_SELECT_IVB;	339	tmp &= ~BLM_PIPE_SELECT_IVB;
339	else	340	else
340	tmp &= ~BLM_PIPE_SELECT;	341	tmp &= ~BLM_PIPE_SELECT;
341		342
342	tmp \|= BLM_PIPE(pipe);	343	tmp \|= BLM_PIPE(pipe);
343	tmp &= ~BLM_PWM_ENABLE;	344	tmp &= ~BLM_PWM_ENABLE;
344		345
345	I915_WRITE(reg, tmp);	346	I915_WRITE(reg, tmp);
346	POSTING_READ(reg);	347	POSTING_READ(reg);
347	I915_WRITE(reg, tmp \| BLM_PWM_ENABLE);	348	I915_WRITE(reg, tmp \| BLM_PWM_ENABLE);
348		349
349	if (HAS_PCH_SPLIT(dev)) {	350	if (HAS_PCH_SPLIT(dev)) {
350	tmp = I915_READ(BLC_PWM_PCH_CTL1);	351	tmp = I915_READ(BLC_PWM_PCH_CTL1);
351	tmp \|= BLM_PCH_PWM_ENABLE;	352	tmp \|= BLM_PCH_PWM_ENABLE;
352	tmp &= ~BLM_PCH_OVERRIDE_ENABLE;	353	tmp &= ~BLM_PCH_OVERRIDE_ENABLE;
353	I915_WRITE(BLC_PWM_PCH_CTL1, tmp);	354	I915_WRITE(BLC_PWM_PCH_CTL1, tmp);
354	}	355	}
355	}	356	}
356		357
357	set_level:	358	set_level:
358	/* Call below after setting BLC_PWM_CPU_CTL2 and BLC_PWM_PCH_CTL1.	359	/* Call below after setting BLC_PWM_CPU_CTL2 and BLC_PWM_PCH_CTL1.
359	* BLC_PWM_CPU_CTL may be cleared to zero automatically when these	360	* BLC_PWM_CPU_CTL may be cleared to zero automatically when these
360	* registers are set.	361	* registers are set.
361	*/	362	*/
362	dev_priv->backlight_enabled = true;	363	dev_priv->backlight_enabled = true;
363	intel_panel_actually_set_backlight(dev, dev_priv->backlight_level);	364	intel_panel_actually_set_backlight(dev, dev_priv->backlight_level);
364	}	365	}
365		366
366	static void intel_panel_init_backlight(struct drm_device *dev)	367	static void intel_panel_init_backlight(struct drm_device *dev)
367	{	368	{
368	struct drm_i915_private *dev_priv = dev->dev_private;	369	struct drm_i915_private *dev_priv = dev->dev_private;
369		370
370	dev_priv->backlight_level = intel_panel_get_backlight(dev);	371	dev_priv->backlight_level = intel_panel_get_backlight(dev);
371	dev_priv->backlight_enabled = dev_priv->backlight_level != 0;	372	dev_priv->backlight_enabled = dev_priv->backlight_level != 0;
372	}	373	}
373		374
374	enum drm_connector_status	375	enum drm_connector_status
375	intel_panel_detect(struct drm_device *dev)	376	intel_panel_detect(struct drm_device *dev)
376	{	377	{
377	#if 0	-
378	struct drm_i915_private *dev_priv = dev->dev_private;	378	struct drm_i915_private *dev_priv = dev->dev_private;
379	#endif	-
380		-
381	if (i915_panel_ignore_lid)	-
382	return i915_panel_ignore_lid > 0 ?	-
383	connector_status_connected :	-
384	connector_status_disconnected;	-
385		-
386	/* opregion lid state on HP 2540p is wrong at boot up,	-
387	* appears to be either the BIOS or Linux ACPI fault */	-
388	#if 0	379
389	/* Assume that the BIOS does not lie through the OpRegion... */	380	/* Assume that the BIOS does not lie through the OpRegion... */
390	if (dev_priv->opregion.lid_state)	381	if (!i915_panel_ignore_lid && dev_priv->opregion.lid_state) {
391	return ioread32(dev_priv->opregion.lid_state) & 0x1 ?	382	return ioread32(dev_priv->opregion.lid_state) & 0x1 ?
392	connector_status_connected :	383	connector_status_connected :
393	connector_status_disconnected;	384	connector_status_disconnected;
394	#endif	385	}
-		386
-		387	switch (i915_panel_ignore_lid) {
-		388	case -2:
-		389	return connector_status_connected;
-		390	case -1:
-		391	return connector_status_disconnected;
395		392	default:
-		393	return connector_status_unknown;
396	return connector_status_unknown;	394	}
397	}	395	}
398		396
399	#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE	397	#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
400	static int intel_panel_update_status(struct backlight_device *bd)	398	static int intel_panel_update_status(struct backlight_device *bd)
401	{	399	{
402	struct drm_device *dev = bl_get_data(bd);	400	struct drm_device *dev = bl_get_data(bd);
403	intel_panel_set_backlight(dev, bd->props.brightness);	401	intel_panel_set_backlight(dev, bd->props.brightness);
404	return 0;	402	return 0;
405	}	403	}
406		404
407	static int intel_panel_get_brightness(struct backlight_device *bd)	405	static int intel_panel_get_brightness(struct backlight_device *bd)
408	{	406	{
409	struct drm_device *dev = bl_get_data(bd);	407	struct drm_device *dev = bl_get_data(bd);
410	struct drm_i915_private *dev_priv = dev->dev_private;	408	struct drm_i915_private *dev_priv = dev->dev_private;
411	return dev_priv->backlight_level;	409	return dev_priv->backlight_level;
412	}	410	}
413		411
414	static const struct backlight_ops intel_panel_bl_ops = {	412	static const struct backlight_ops intel_panel_bl_ops = {
415	.update_status = intel_panel_update_status,	413	.update_status = intel_panel_update_status,
416	.get_brightness = intel_panel_get_brightness,	414	.get_brightness = intel_panel_get_brightness,
417	};	415	};
418		416
419	int intel_panel_setup_backlight(struct drm_device *dev)	417	int intel_panel_setup_backlight(struct drm_connector *connector)
-		418	{
420	{	419	struct drm_device *dev = connector->dev;
421	struct drm_i915_private *dev_priv = dev->dev_private;	420	struct drm_i915_private *dev_priv = dev->dev_private;
422	struct backlight_properties props;	-
423	struct drm_connector *connector;	421	struct backlight_properties props;
424		422
425	intel_panel_init_backlight(dev);	423	intel_panel_init_backlight(dev);
426		-
427	if (dev_priv->int_lvds_connector)	-
428	connector = dev_priv->int_lvds_connector;	-
429	else if (dev_priv->int_edp_connector)	-
430	connector = dev_priv->int_edp_connector;	-
431	else	-
432	return -ENODEV;	-
433		424
434	memset(&props, 0, sizeof(props));	425	memset(&props, 0, sizeof(props));
435	props.type = BACKLIGHT_RAW;	426	props.type = BACKLIGHT_RAW;
436	props.max_brightness = _intel_panel_get_max_backlight(dev);	427	props.max_brightness = _intel_panel_get_max_backlight(dev);
437	if (props.max_brightness == 0) {	428	if (props.max_brightness == 0) {
438	DRM_DEBUG_DRIVER("Failed to get maximum backlight value\n");	429	DRM_DEBUG_DRIVER("Failed to get maximum backlight value\n");
439	return -ENODEV;	430	return -ENODEV;
440	}	431	}
441	dev_priv->backlight =	432	dev_priv->backlight =
442	backlight_device_register("intel_backlight",	433	backlight_device_register("intel_backlight",
443	&connector->kdev, dev,	434	&connector->kdev, dev,
444	&intel_panel_bl_ops, &props);	435	&intel_panel_bl_ops, &props);
445		436
446	if (IS_ERR(dev_priv->backlight)) {	437	if (IS_ERR(dev_priv->backlight)) {
447	DRM_ERROR("Failed to register backlight: %ld\n",	438	DRM_ERROR("Failed to register backlight: %ld\n",
448	PTR_ERR(dev_priv->backlight));	439	PTR_ERR(dev_priv->backlight));
449	dev_priv->backlight = NULL;	440	dev_priv->backlight = NULL;
450	return -ENODEV;	441	return -ENODEV;
451	}	442	}
452	dev_priv->backlight->props.brightness = intel_panel_get_backlight(dev);	443	dev_priv->backlight->props.brightness = intel_panel_get_backlight(dev);
453	return 0;	444	return 0;
454	}	445	}
455		446
456	void intel_panel_destroy_backlight(struct drm_device *dev)	447	void intel_panel_destroy_backlight(struct drm_device *dev)
457	{	448	{
458	struct drm_i915_private *dev_priv = dev->dev_private;	449	struct drm_i915_private *dev_priv = dev->dev_private;
459	if (dev_priv->backlight)	450	if (dev_priv->backlight)
460	backlight_device_unregister(dev_priv->backlight);	451	backlight_device_unregister(dev_priv->backlight);
461	}	452	}
462	#else	453	#else
463	int intel_panel_setup_backlight(struct drm_device *dev)	454	int intel_panel_setup_backlight(struct drm_connector *connector)
464	{	455	{
465	intel_panel_init_backlight(dev);	456	intel_panel_init_backlight(connector->dev);
466	return 0;	457	return 0;
467	}	458	}
468		459
469	void intel_panel_destroy_backlight(struct drm_device *dev)	460	void intel_panel_destroy_backlight(struct drm_device *dev)
470	{	461	{
471	return;	462	return;
472	}	463	}
473	#endif	464	#endif
-		465
-		466	int intel_panel_init(struct intel_panel *panel,
-		467	struct drm_display_mode *fixed_mode)
-		468	{
-		469	panel->fixed_mode = fixed_mode;
-		470
-		471	return 0;
-		472	}
-		473
-		474	void intel_panel_fini(struct intel_panel *panel)
-		475	{
-		476	struct intel_connector *intel_connector =
-		477	container_of(panel, struct intel_connector, panel);
-		478
-		479	if (panel->fixed_mode)

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/intel_panel.c – Rev 3037 → 3243