2010-08-07 04:01:28 -06:00
|
|
|
/*
|
|
|
|
* Copyright © 2006-2010 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>
|
|
|
|
* Chris Wilson <chris@chris-wilson.co.uk>
|
|
|
|
*/
|
|
|
|
|
2012-03-18 14:00:11 -06:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2012-03-15 08:56:25 -06:00
|
|
|
#include <linux/moduleparam.h>
|
2010-08-07 04:01:28 -06:00
|
|
|
#include "intel_drv.h"
|
|
|
|
|
|
|
|
void
|
2013-09-02 12:13:39 -06:00
|
|
|
intel_fixed_panel_mode(const struct drm_display_mode *fixed_mode,
|
2010-08-07 04:01:28 -06:00
|
|
|
struct drm_display_mode *adjusted_mode)
|
|
|
|
{
|
2013-09-02 12:13:39 -06:00
|
|
|
drm_mode_copy(adjusted_mode, fixed_mode);
|
2013-08-27 03:24:09 -06:00
|
|
|
|
|
|
|
drm_mode_set_crtcinfo(adjusted_mode, 0);
|
2010-08-07 04:01:28 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* adjusted_mode has been preset to be the panel's fixed mode */
|
|
|
|
void
|
2013-04-25 13:55:02 -06:00
|
|
|
intel_pch_panel_fitting(struct intel_crtc *intel_crtc,
|
|
|
|
struct intel_crtc_config *pipe_config,
|
|
|
|
int fitting_mode)
|
2010-08-07 04:01:28 -06:00
|
|
|
{
|
2013-09-04 09:25:28 -06:00
|
|
|
struct drm_display_mode *adjusted_mode;
|
2010-08-07 04:01:28 -06:00
|
|
|
int x, y, width, height;
|
|
|
|
|
2013-04-25 13:55:02 -06:00
|
|
|
adjusted_mode = &pipe_config->adjusted_mode;
|
|
|
|
|
2010-08-07 04:01:28 -06:00
|
|
|
x = y = width = height = 0;
|
|
|
|
|
|
|
|
/* Native modes don't need fitting */
|
2013-09-04 09:25:28 -06:00
|
|
|
if (adjusted_mode->hdisplay == pipe_config->pipe_src_w &&
|
|
|
|
adjusted_mode->vdisplay == pipe_config->pipe_src_h)
|
2010-08-07 04:01:28 -06:00
|
|
|
goto done;
|
|
|
|
|
|
|
|
switch (fitting_mode) {
|
|
|
|
case DRM_MODE_SCALE_CENTER:
|
2013-09-04 09:25:28 -06:00
|
|
|
width = pipe_config->pipe_src_w;
|
|
|
|
height = pipe_config->pipe_src_h;
|
2010-08-07 04:01:28 -06:00
|
|
|
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 */
|
|
|
|
{
|
2013-09-16 15:43:45 -06:00
|
|
|
u32 scaled_width = adjusted_mode->hdisplay
|
|
|
|
* pipe_config->pipe_src_h;
|
|
|
|
u32 scaled_height = pipe_config->pipe_src_w
|
|
|
|
* adjusted_mode->vdisplay;
|
2010-08-07 04:01:28 -06:00
|
|
|
if (scaled_width > scaled_height) { /* pillar */
|
2013-09-04 09:25:28 -06:00
|
|
|
width = scaled_height / pipe_config->pipe_src_h;
|
drm/i915/pch: Fix integer math bugs in panel fitting
Consider a 1600x900 panel, upscaling a 1360x768 mode, full-aspect. The
old math would give you:
scaled_width = 1600 * 768; /* 1228800 */
scaled_height = 1360 * 900; /* 1224000 */
if (scaled_width > scaled_height) { /* pillarbox, and true */
width = 1224000 / 768; /* int(1593.75) = 1593 */
x = (1600 - 1593 + 1) / 2; /* 4 */
y = 0;
height = 768;
} /* ... */
This is broken. The total width of scanout would then be 1593 + 4 + 4,
or 1601, which is wider than the panel itself. The hardware very
dutifully implements this, and you end up with a black 45° diagonal from
the top-left corner to the bottom edge of the screen. It's a cool
effect and all, but not what you wanted. Similar things happen for the
letterbox case.
The problem is that you have an integer number of pixels, which means
it's usually impossible to upscale equally on both axes. 1360/768 is
1.7708, 1600/900 is 1.7777. Since we're constrained on the one axis,
the other one wants to come out as an even number of pixels (the panel
is almost certainly even on both axes, and the x/y offsets will be
applied on both sides). In the math above, if 'width' comes out even,
rounding down is correct; if it's odd, you'd rather round up. So just
increment width/height in those cases.
Tested on a Lenovo T500 (Ironlake).
Signed-off-by: Adam Jackson <ajax@redhat.com>
Tested-By: Daniel Manrique <daniel.manrique@canonical.com>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=38851
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: stable@kernel.org
Signed-off-by: Keith Packard <keithp@keithp.com>
2011-07-13 14:32:32 -06:00
|
|
|
if (width & 1)
|
2011-08-16 13:34:10 -06:00
|
|
|
width++;
|
2010-08-07 04:01:28 -06:00
|
|
|
x = (adjusted_mode->hdisplay - width + 1) / 2;
|
|
|
|
y = 0;
|
|
|
|
height = adjusted_mode->vdisplay;
|
|
|
|
} else if (scaled_width < scaled_height) { /* letter */
|
2013-09-04 09:25:28 -06:00
|
|
|
height = scaled_width / pipe_config->pipe_src_w;
|
drm/i915/pch: Fix integer math bugs in panel fitting
Consider a 1600x900 panel, upscaling a 1360x768 mode, full-aspect. The
old math would give you:
scaled_width = 1600 * 768; /* 1228800 */
scaled_height = 1360 * 900; /* 1224000 */
if (scaled_width > scaled_height) { /* pillarbox, and true */
width = 1224000 / 768; /* int(1593.75) = 1593 */
x = (1600 - 1593 + 1) / 2; /* 4 */
y = 0;
height = 768;
} /* ... */
This is broken. The total width of scanout would then be 1593 + 4 + 4,
or 1601, which is wider than the panel itself. The hardware very
dutifully implements this, and you end up with a black 45° diagonal from
the top-left corner to the bottom edge of the screen. It's a cool
effect and all, but not what you wanted. Similar things happen for the
letterbox case.
The problem is that you have an integer number of pixels, which means
it's usually impossible to upscale equally on both axes. 1360/768 is
1.7708, 1600/900 is 1.7777. Since we're constrained on the one axis,
the other one wants to come out as an even number of pixels (the panel
is almost certainly even on both axes, and the x/y offsets will be
applied on both sides). In the math above, if 'width' comes out even,
rounding down is correct; if it's odd, you'd rather round up. So just
increment width/height in those cases.
Tested on a Lenovo T500 (Ironlake).
Signed-off-by: Adam Jackson <ajax@redhat.com>
Tested-By: Daniel Manrique <daniel.manrique@canonical.com>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=38851
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: stable@kernel.org
Signed-off-by: Keith Packard <keithp@keithp.com>
2011-07-13 14:32:32 -06:00
|
|
|
if (height & 1)
|
|
|
|
height++;
|
2010-08-07 04:01:28 -06:00
|
|
|
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;
|
|
|
|
|
|
|
|
case DRM_MODE_SCALE_FULLSCREEN:
|
|
|
|
x = y = 0;
|
|
|
|
width = adjusted_mode->hdisplay;
|
|
|
|
height = adjusted_mode->vdisplay;
|
|
|
|
break;
|
2013-04-25 13:55:03 -06:00
|
|
|
|
|
|
|
default:
|
|
|
|
WARN(1, "bad panel fit mode: %d\n", fitting_mode);
|
|
|
|
return;
|
2010-08-07 04:01:28 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
2013-04-25 13:55:02 -06:00
|
|
|
pipe_config->pch_pfit.pos = (x << 16) | y;
|
|
|
|
pipe_config->pch_pfit.size = (width << 16) | height;
|
2013-08-27 10:04:17 -06:00
|
|
|
pipe_config->pch_pfit.enabled = pipe_config->pch_pfit.size != 0;
|
2010-08-07 04:01:28 -06:00
|
|
|
}
|
2010-08-22 06:18:16 -06:00
|
|
|
|
2013-04-25 13:55:01 -06:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-09-16 15:43:45 -06:00
|
|
|
static void i965_scale_aspect(struct intel_crtc_config *pipe_config,
|
|
|
|
u32 *pfit_control)
|
|
|
|
{
|
|
|
|
struct drm_display_mode *adjusted_mode = &pipe_config->adjusted_mode;
|
|
|
|
u32 scaled_width = adjusted_mode->hdisplay *
|
|
|
|
pipe_config->pipe_src_h;
|
|
|
|
u32 scaled_height = pipe_config->pipe_src_w *
|
|
|
|
adjusted_mode->vdisplay;
|
|
|
|
|
|
|
|
/* 965+ is easy, it does everything in hw */
|
|
|
|
if (scaled_width > scaled_height)
|
|
|
|
*pfit_control |= PFIT_ENABLE |
|
|
|
|
PFIT_SCALING_PILLAR;
|
|
|
|
else if (scaled_width < scaled_height)
|
|
|
|
*pfit_control |= PFIT_ENABLE |
|
|
|
|
PFIT_SCALING_LETTER;
|
|
|
|
else if (adjusted_mode->hdisplay != pipe_config->pipe_src_w)
|
|
|
|
*pfit_control |= PFIT_ENABLE | PFIT_SCALING_AUTO;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void i9xx_scale_aspect(struct intel_crtc_config *pipe_config,
|
|
|
|
u32 *pfit_control, u32 *pfit_pgm_ratios,
|
|
|
|
u32 *border)
|
|
|
|
{
|
|
|
|
struct drm_display_mode *adjusted_mode = &pipe_config->adjusted_mode;
|
|
|
|
u32 scaled_width = adjusted_mode->hdisplay *
|
|
|
|
pipe_config->pipe_src_h;
|
|
|
|
u32 scaled_height = pipe_config->pipe_src_w *
|
|
|
|
adjusted_mode->vdisplay;
|
|
|
|
u32 bits;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For earlier chips we have to calculate the scaling
|
|
|
|
* ratio by hand and program it into the
|
|
|
|
* PFIT_PGM_RATIO register
|
|
|
|
*/
|
|
|
|
if (scaled_width > scaled_height) { /* pillar */
|
|
|
|
centre_horizontally(adjusted_mode,
|
|
|
|
scaled_height /
|
|
|
|
pipe_config->pipe_src_h);
|
|
|
|
|
|
|
|
*border = LVDS_BORDER_ENABLE;
|
|
|
|
if (pipe_config->pipe_src_h != adjusted_mode->vdisplay) {
|
|
|
|
bits = panel_fitter_scaling(pipe_config->pipe_src_h,
|
|
|
|
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 /
|
|
|
|
pipe_config->pipe_src_w);
|
|
|
|
|
|
|
|
*border = LVDS_BORDER_ENABLE;
|
|
|
|
if (pipe_config->pipe_src_w != adjusted_mode->hdisplay) {
|
|
|
|
bits = panel_fitter_scaling(pipe_config->pipe_src_w,
|
|
|
|
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 |
|
|
|
|
VERT_INTERP_BILINEAR |
|
|
|
|
HORIZ_INTERP_BILINEAR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-25 13:55:01 -06:00
|
|
|
void intel_gmch_panel_fitting(struct intel_crtc *intel_crtc,
|
|
|
|
struct intel_crtc_config *pipe_config,
|
|
|
|
int fitting_mode)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = intel_crtc->base.dev;
|
|
|
|
u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0;
|
2013-09-04 09:25:28 -06:00
|
|
|
struct drm_display_mode *adjusted_mode;
|
2013-04-25 13:55:01 -06:00
|
|
|
|
|
|
|
adjusted_mode = &pipe_config->adjusted_mode;
|
|
|
|
|
|
|
|
/* Native modes don't need fitting */
|
2013-09-04 09:25:28 -06:00
|
|
|
if (adjusted_mode->hdisplay == pipe_config->pipe_src_w &&
|
|
|
|
adjusted_mode->vdisplay == pipe_config->pipe_src_h)
|
2013-04-25 13:55:01 -06:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
switch (fitting_mode) {
|
|
|
|
case DRM_MODE_SCALE_CENTER:
|
|
|
|
/*
|
|
|
|
* For centered modes, we have to calculate border widths &
|
|
|
|
* heights and modify the values programmed into the CRTC.
|
|
|
|
*/
|
2013-09-04 09:25:28 -06:00
|
|
|
centre_horizontally(adjusted_mode, pipe_config->pipe_src_w);
|
|
|
|
centre_vertically(adjusted_mode, pipe_config->pipe_src_h);
|
2013-04-25 13:55:01 -06:00
|
|
|
border = LVDS_BORDER_ENABLE;
|
|
|
|
break;
|
|
|
|
case DRM_MODE_SCALE_ASPECT:
|
|
|
|
/* Scale but preserve the aspect ratio */
|
2013-09-16 15:43:45 -06:00
|
|
|
if (INTEL_INFO(dev)->gen >= 4)
|
|
|
|
i965_scale_aspect(pipe_config, &pfit_control);
|
|
|
|
else
|
|
|
|
i9xx_scale_aspect(pipe_config, &pfit_control,
|
|
|
|
&pfit_pgm_ratios, &border);
|
2013-04-25 13:55:01 -06:00
|
|
|
break;
|
|
|
|
case DRM_MODE_SCALE_FULLSCREEN:
|
|
|
|
/*
|
|
|
|
* Full scaling, even if it changes the aspect ratio.
|
|
|
|
* Fortunately this is all done for us in hw.
|
|
|
|
*/
|
2013-09-04 09:25:28 -06:00
|
|
|
if (pipe_config->pipe_src_h != adjusted_mode->vdisplay ||
|
|
|
|
pipe_config->pipe_src_w != adjusted_mode->hdisplay) {
|
2013-04-25 13:55:01 -06:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
break;
|
2013-04-25 13:55:03 -06:00
|
|
|
default:
|
|
|
|
WARN(1, "bad panel fit mode: %d\n", fitting_mode);
|
|
|
|
return;
|
2013-04-25 13:55:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 965+ wants fuzzy fitting */
|
|
|
|
/* FIXME: handle multiple panels by failing gracefully */
|
|
|
|
if (INTEL_INFO(dev)->gen >= 4)
|
|
|
|
pfit_control |= ((intel_crtc->pipe << PFIT_PIPE_SHIFT) |
|
|
|
|
PFIT_FILTER_FUZZY);
|
|
|
|
|
|
|
|
out:
|
|
|
|
if ((pfit_control & PFIT_ENABLE) == 0) {
|
|
|
|
pfit_control = 0;
|
|
|
|
pfit_pgm_ratios = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure pre-965 set dither correctly for 18bpp panels. */
|
|
|
|
if (INTEL_INFO(dev)->gen < 4 && pipe_config->pipe_bpp == 18)
|
|
|
|
pfit_control |= PANEL_8TO6_DITHER_ENABLE;
|
|
|
|
|
2013-04-25 14:52:17 -06:00
|
|
|
pipe_config->gmch_pfit.control = pfit_control;
|
|
|
|
pipe_config->gmch_pfit.pgm_ratios = pfit_pgm_ratios;
|
2013-04-25 14:52:16 -06:00
|
|
|
pipe_config->gmch_pfit.lvds_border_bits = border;
|
2013-04-25 13:55:01 -06:00
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
static u32 intel_panel_compute_brightness(struct intel_connector *connector,
|
|
|
|
u32 val)
|
2012-03-15 08:56:25 -06:00
|
|
|
{
|
2013-11-08 07:48:56 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
2012-03-15 08:56:26 -06:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:49:00 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
|
|
|
|
|
|
|
WARN_ON(panel->backlight.max == 0);
|
2012-03-15 08:56:26 -06:00
|
|
|
|
2014-01-21 02:24:25 -07:00
|
|
|
if (i915.invert_brightness < 0)
|
2012-03-15 08:56:26 -06:00
|
|
|
return val;
|
|
|
|
|
2014-01-21 02:24:25 -07:00
|
|
|
if (i915.invert_brightness > 0 ||
|
2013-04-12 06:18:36 -06:00
|
|
|
dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS) {
|
2013-11-08 07:49:00 -07:00
|
|
|
return panel->backlight.max - val;
|
2013-04-12 06:18:36 -06:00
|
|
|
}
|
2012-03-15 08:56:25 -06:00
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2013-11-14 07:17:41 -07:00
|
|
|
static u32 bdw_get_backlight(struct intel_connector *connector)
|
2010-11-23 02:45:50 -07:00
|
|
|
{
|
2013-11-14 07:17:41 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
2012-12-04 07:36:28 -07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-11-23 02:45:50 -07:00
|
|
|
|
2013-11-14 07:17:41 -07:00
|
|
|
return I915_READ(BLC_PWM_PCH_CTL2) & BACKLIGHT_DUTY_CYCLE_MASK;
|
|
|
|
}
|
2013-10-31 10:55:50 -06:00
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
static u32 pch_get_backlight(struct intel_connector *connector)
|
2010-08-22 06:18:16 -06:00
|
|
|
{
|
2013-11-08 07:48:56 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
2010-08-22 06:18:16 -06:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-04-12 06:18:37 -06:00
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
return I915_READ(BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
|
|
|
|
}
|
2010-08-22 06:18:16 -06:00
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
static u32 i9xx_get_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:49:02 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-11-08 07:48:56 -07:00
|
|
|
u32 val;
|
2013-10-31 10:55:50 -06:00
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
val = I915_READ(BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
|
|
|
|
if (INTEL_INFO(dev)->gen < 4)
|
|
|
|
val >>= 1;
|
2011-03-10 06:02:12 -07:00
|
|
|
|
2013-11-08 07:49:02 -07:00
|
|
|
if (panel->backlight.combination_mode) {
|
2013-11-08 07:48:56 -07:00
|
|
|
u8 lbpc;
|
2011-03-10 06:02:12 -07:00
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
pci_read_config_byte(dev->pdev, PCI_LBPC, &lbpc);
|
|
|
|
val *= lbpc;
|
2010-08-22 06:18:16 -06:00
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 _vlv_get_backlight(struct drm_device *dev, enum pipe pipe)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
|
|
|
return I915_READ(VLV_BLC_PWM_CTL(pipe)) & BACKLIGHT_DUTY_CYCLE_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 vlv_get_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
enum pipe pipe = intel_get_pipe_from_connector(connector);
|
|
|
|
|
|
|
|
return _vlv_get_backlight(dev, pipe);
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 intel_panel_get_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
u32 val;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev_priv->backlight_lock, flags);
|
|
|
|
|
|
|
|
val = dev_priv->display.get_backlight(connector);
|
|
|
|
val = intel_panel_compute_brightness(connector, val);
|
2013-04-12 06:18:37 -06:00
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
spin_unlock_irqrestore(&dev_priv->backlight_lock, flags);
|
2013-04-12 06:18:37 -06:00
|
|
|
|
2010-08-22 06:18:16 -06:00
|
|
|
DRM_DEBUG_DRIVER("get backlight PWM = %d\n", val);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2013-11-14 07:17:41 -07:00
|
|
|
static void bdw_set_backlight(struct intel_connector *connector, u32 level)
|
2013-11-11 02:12:57 -07:00
|
|
|
{
|
2013-11-14 07:17:41 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
2013-11-11 02:12:57 -07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
u32 val = I915_READ(BLC_PWM_PCH_CTL2) & ~BACKLIGHT_DUTY_CYCLE_MASK;
|
|
|
|
I915_WRITE(BLC_PWM_PCH_CTL2, val | level);
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
static void pch_set_backlight(struct intel_connector *connector, u32 level)
|
2010-08-22 06:18:16 -06:00
|
|
|
{
|
2013-11-08 07:48:56 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
2010-08-22 06:18:16 -06:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:56 -07:00
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
tmp = I915_READ(BLC_PWM_CPU_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK;
|
|
|
|
I915_WRITE(BLC_PWM_CPU_CTL, tmp | level);
|
2010-08-22 06:18:16 -06:00
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
static void i9xx_set_backlight(struct intel_connector *connector, u32 level)
|
2010-08-22 06:18:16 -06:00
|
|
|
{
|
2013-11-08 07:48:56 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
2010-08-22 06:18:16 -06:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:49:00 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-11-08 07:48:57 -07:00
|
|
|
u32 tmp, mask;
|
2011-03-10 06:02:12 -07:00
|
|
|
|
2013-11-08 07:49:00 -07:00
|
|
|
WARN_ON(panel->backlight.max == 0);
|
|
|
|
|
2013-11-08 07:49:02 -07:00
|
|
|
if (panel->backlight.combination_mode) {
|
2011-03-10 06:02:12 -07:00
|
|
|
u8 lbpc;
|
|
|
|
|
2013-11-08 07:49:00 -07:00
|
|
|
lbpc = level * 0xfe / panel->backlight.max + 1;
|
2011-03-10 06:02:12 -07:00
|
|
|
level /= lbpc;
|
|
|
|
pci_write_config_byte(dev->pdev, PCI_LBPC, lbpc);
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:57 -07:00
|
|
|
if (IS_GEN4(dev)) {
|
|
|
|
mask = BACKLIGHT_DUTY_CYCLE_MASK;
|
|
|
|
} else {
|
2010-08-22 06:18:16 -06:00
|
|
|
level <<= 1;
|
2013-11-08 07:48:57 -07:00
|
|
|
mask = BACKLIGHT_DUTY_CYCLE_MASK_PNV;
|
|
|
|
}
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-08 07:48:57 -07:00
|
|
|
tmp = I915_READ(BLC_PWM_CTL) & ~mask;
|
2013-11-08 07:48:56 -07:00
|
|
|
I915_WRITE(BLC_PWM_CTL, tmp | level);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vlv_set_backlight(struct intel_connector *connector, u32 level)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
enum pipe pipe = intel_get_pipe_from_connector(connector);
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
tmp = I915_READ(VLV_BLC_PWM_CTL(pipe)) & ~BACKLIGHT_DUTY_CYCLE_MASK;
|
|
|
|
I915_WRITE(VLV_BLC_PWM_CTL(pipe), tmp | level);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
intel_panel_actually_set_backlight(struct intel_connector *connector, u32 level)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
|
|
|
DRM_DEBUG_DRIVER("set backlight PWM = %d\n", level);
|
|
|
|
|
|
|
|
level = intel_panel_compute_brightness(connector, level);
|
|
|
|
dev_priv->display.set_backlight(connector, level);
|
2010-08-22 06:18:16 -06:00
|
|
|
}
|
2011-01-11 10:06:04 -07:00
|
|
|
|
2013-04-12 06:18:36 -06:00
|
|
|
/* set backlight brightness to level in range [0..max] */
|
2013-10-31 10:55:49 -06:00
|
|
|
void intel_panel_set_backlight(struct intel_connector *connector, u32 level,
|
|
|
|
u32 max)
|
2011-01-11 10:06:04 -07:00
|
|
|
{
|
2013-10-31 10:55:49 -06:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
2011-01-11 10:06:04 -07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:54 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-10-31 10:55:49 -06:00
|
|
|
enum pipe pipe = intel_get_pipe_from_connector(connector);
|
2013-04-12 06:18:36 -06:00
|
|
|
u32 freq;
|
2013-04-12 06:18:37 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
2014-01-16 09:27:15 -07:00
|
|
|
if (!panel->backlight.present || pipe == INVALID_PIPE)
|
2013-10-31 10:55:49 -06:00
|
|
|
return;
|
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
spin_lock_irqsave(&dev_priv->backlight_lock, flags);
|
2013-04-12 06:18:36 -06:00
|
|
|
|
2013-11-08 07:49:00 -07:00
|
|
|
WARN_ON(panel->backlight.max == 0);
|
2013-04-12 06:18:36 -06:00
|
|
|
|
2013-11-08 07:49:00 -07:00
|
|
|
/* scale to hardware max, but be careful to not overflow */
|
|
|
|
freq = panel->backlight.max;
|
2013-08-01 19:16:03 -06:00
|
|
|
if (freq < max)
|
|
|
|
level = level * freq / max;
|
|
|
|
else
|
|
|
|
level = freq / max * level;
|
2011-01-11 10:06:04 -07:00
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
panel->backlight.level = level;
|
|
|
|
if (panel->backlight.device)
|
|
|
|
panel->backlight.device->props.brightness = level;
|
2013-03-12 03:44:15 -06:00
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
if (panel->backlight.enabled)
|
2013-11-08 07:48:56 -07:00
|
|
|
intel_panel_actually_set_backlight(connector, level);
|
2013-11-08 07:49:00 -07:00
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
spin_unlock_irqrestore(&dev_priv->backlight_lock, flags);
|
2011-10-14 03:45:40 -06:00
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
static void pch_disable_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
u32 tmp;
|
|
|
|
|
2013-11-08 07:48:59 -07:00
|
|
|
intel_panel_actually_set_backlight(connector, 0);
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
tmp = I915_READ(BLC_PWM_CPU_CTL2);
|
|
|
|
I915_WRITE(BLC_PWM_CPU_CTL2, tmp & ~BLM_PWM_ENABLE);
|
|
|
|
|
|
|
|
tmp = I915_READ(BLC_PWM_PCH_CTL1);
|
|
|
|
I915_WRITE(BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE);
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:59 -07:00
|
|
|
static void i9xx_disable_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
intel_panel_actually_set_backlight(connector, 0);
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
static void i965_disable_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
u32 tmp;
|
|
|
|
|
2013-11-08 07:48:59 -07:00
|
|
|
intel_panel_actually_set_backlight(connector, 0);
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
tmp = I915_READ(BLC_PWM_CTL2);
|
|
|
|
I915_WRITE(BLC_PWM_CTL2, tmp & ~BLM_PWM_ENABLE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vlv_disable_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
enum pipe pipe = intel_get_pipe_from_connector(connector);
|
|
|
|
u32 tmp;
|
|
|
|
|
2013-11-08 07:48:59 -07:00
|
|
|
intel_panel_actually_set_backlight(connector, 0);
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
tmp = I915_READ(VLV_BLC_PWM_CTL2(pipe));
|
|
|
|
I915_WRITE(VLV_BLC_PWM_CTL2(pipe), tmp & ~BLM_PWM_ENABLE);
|
|
|
|
}
|
|
|
|
|
2013-10-31 10:55:49 -06:00
|
|
|
void intel_panel_disable_backlight(struct intel_connector *connector)
|
2011-10-14 03:45:40 -06:00
|
|
|
{
|
2013-10-31 10:55:49 -06:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
2011-10-14 03:45:40 -06:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:54 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-10-31 10:55:49 -06:00
|
|
|
enum pipe pipe = intel_get_pipe_from_connector(connector);
|
2013-04-12 06:18:37 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
2014-01-16 09:27:15 -07:00
|
|
|
if (!panel->backlight.present || pipe == INVALID_PIPE)
|
2013-10-31 10:55:49 -06:00
|
|
|
return;
|
|
|
|
|
2013-07-25 05:31:30 -06:00
|
|
|
/*
|
|
|
|
* Do not disable backlight on the vgaswitcheroo path. When switching
|
|
|
|
* away from i915, the other client may depend on i915 to handle the
|
|
|
|
* backlight. This will leave the backlight on unnecessarily when
|
|
|
|
* another client is not activated.
|
|
|
|
*/
|
|
|
|
if (dev->switch_power_state == DRM_SWITCH_POWER_CHANGING) {
|
|
|
|
DRM_DEBUG_DRIVER("Skipping backlight disable on vga switch\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
spin_lock_irqsave(&dev_priv->backlight_lock, flags);
|
2011-01-11 10:06:04 -07:00
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
panel->backlight.enabled = false;
|
2013-11-08 07:48:59 -07:00
|
|
|
dev_priv->display.disable_backlight(connector);
|
2012-06-05 04:14:54 -06:00
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
spin_unlock_irqrestore(&dev_priv->backlight_lock, flags);
|
|
|
|
}
|
2012-06-05 04:14:54 -06:00
|
|
|
|
2013-11-14 07:17:41 -07:00
|
|
|
static void bdw_enable_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct intel_panel *panel = &connector->panel;
|
|
|
|
u32 pch_ctl1, pch_ctl2;
|
|
|
|
|
|
|
|
pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1);
|
|
|
|
if (pch_ctl1 & BLM_PCH_PWM_ENABLE) {
|
|
|
|
DRM_DEBUG_KMS("pch backlight already enabled\n");
|
|
|
|
pch_ctl1 &= ~BLM_PCH_PWM_ENABLE;
|
|
|
|
I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1);
|
|
|
|
}
|
2012-06-05 04:14:54 -06:00
|
|
|
|
2013-11-14 07:17:41 -07:00
|
|
|
pch_ctl2 = panel->backlight.max << 16;
|
|
|
|
I915_WRITE(BLC_PWM_PCH_CTL2, pch_ctl2);
|
2012-07-14 08:57:12 -06:00
|
|
|
|
2013-11-14 07:17:41 -07:00
|
|
|
pch_ctl1 = 0;
|
|
|
|
if (panel->backlight.active_low_pwm)
|
|
|
|
pch_ctl1 |= BLM_PCH_POLARITY;
|
2013-04-12 06:18:37 -06:00
|
|
|
|
2013-11-14 07:17:41 -07:00
|
|
|
/* BDW always uses the pch pwm controls. */
|
|
|
|
pch_ctl1 |= BLM_PCH_OVERRIDE_ENABLE;
|
|
|
|
|
|
|
|
I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1);
|
|
|
|
POSTING_READ(BLC_PWM_PCH_CTL1);
|
|
|
|
I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1 | BLM_PCH_PWM_ENABLE);
|
|
|
|
|
|
|
|
/* This won't stick until the above enable. */
|
|
|
|
intel_panel_actually_set_backlight(connector, panel->backlight.level);
|
2011-01-11 10:06:04 -07:00
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
static void pch_enable_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:59 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-11-08 07:48:56 -07:00
|
|
|
enum pipe pipe = intel_get_pipe_from_connector(connector);
|
|
|
|
enum transcoder cpu_transcoder =
|
|
|
|
intel_pipe_to_cpu_transcoder(dev_priv, pipe);
|
2013-11-14 03:13:41 -07:00
|
|
|
u32 cpu_ctl2, pch_ctl1, pch_ctl2;
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
cpu_ctl2 = I915_READ(BLC_PWM_CPU_CTL2);
|
|
|
|
if (cpu_ctl2 & BLM_PWM_ENABLE) {
|
|
|
|
WARN(1, "cpu backlight already enabled\n");
|
|
|
|
cpu_ctl2 &= ~BLM_PWM_ENABLE;
|
|
|
|
I915_WRITE(BLC_PWM_CPU_CTL2, cpu_ctl2);
|
|
|
|
}
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1);
|
|
|
|
if (pch_ctl1 & BLM_PCH_PWM_ENABLE) {
|
|
|
|
DRM_DEBUG_KMS("pch backlight already enabled\n");
|
|
|
|
pch_ctl1 &= ~BLM_PCH_PWM_ENABLE;
|
|
|
|
I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1);
|
|
|
|
}
|
2013-11-08 07:48:56 -07:00
|
|
|
|
|
|
|
if (cpu_transcoder == TRANSCODER_EDP)
|
2013-11-14 03:13:41 -07:00
|
|
|
cpu_ctl2 = BLM_TRANSCODER_EDP;
|
2013-11-08 07:48:56 -07:00
|
|
|
else
|
2013-11-14 03:13:41 -07:00
|
|
|
cpu_ctl2 = BLM_PIPE(cpu_transcoder);
|
|
|
|
I915_WRITE(BLC_PWM_CPU_CTL2, cpu_ctl2);
|
2013-11-08 07:48:56 -07:00
|
|
|
POSTING_READ(BLC_PWM_CPU_CTL2);
|
2013-11-14 03:13:41 -07:00
|
|
|
I915_WRITE(BLC_PWM_CPU_CTL2, cpu_ctl2 | BLM_PWM_ENABLE);
|
2013-11-08 07:48:59 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
/* This won't stick until the above enable. */
|
2013-11-08 07:48:59 -07:00
|
|
|
intel_panel_actually_set_backlight(connector, panel->backlight.level);
|
2013-11-14 03:13:41 -07:00
|
|
|
|
|
|
|
pch_ctl2 = panel->backlight.max << 16;
|
|
|
|
I915_WRITE(BLC_PWM_PCH_CTL2, pch_ctl2);
|
|
|
|
|
|
|
|
pch_ctl1 = 0;
|
|
|
|
if (panel->backlight.active_low_pwm)
|
|
|
|
pch_ctl1 |= BLM_PCH_POLARITY;
|
2013-11-14 07:17:41 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1);
|
|
|
|
POSTING_READ(BLC_PWM_PCH_CTL1);
|
|
|
|
I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1 | BLM_PCH_PWM_ENABLE);
|
2013-11-08 07:48:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void i9xx_enable_backlight(struct intel_connector *connector)
|
|
|
|
{
|
2013-11-14 03:13:41 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:59 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-11-14 03:13:41 -07:00
|
|
|
u32 ctl, freq;
|
|
|
|
|
|
|
|
ctl = I915_READ(BLC_PWM_CTL);
|
|
|
|
if (ctl & BACKLIGHT_DUTY_CYCLE_MASK_PNV) {
|
|
|
|
WARN(1, "backlight already enabled\n");
|
|
|
|
I915_WRITE(BLC_PWM_CTL, 0);
|
|
|
|
}
|
2013-11-08 07:48:59 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
freq = panel->backlight.max;
|
|
|
|
if (panel->backlight.combination_mode)
|
|
|
|
freq /= 0xff;
|
|
|
|
|
|
|
|
ctl = freq << 17;
|
|
|
|
if (IS_GEN2(dev) && panel->backlight.combination_mode)
|
|
|
|
ctl |= BLM_LEGACY_MODE;
|
|
|
|
if (IS_PINEVIEW(dev) && panel->backlight.active_low_pwm)
|
|
|
|
ctl |= BLM_POLARITY_PNV;
|
|
|
|
|
|
|
|
I915_WRITE(BLC_PWM_CTL, ctl);
|
|
|
|
POSTING_READ(BLC_PWM_CTL);
|
|
|
|
|
|
|
|
/* XXX: combine this into above write? */
|
2013-11-08 07:48:59 -07:00
|
|
|
intel_panel_actually_set_backlight(connector, panel->backlight.level);
|
2013-11-08 07:48:56 -07:00
|
|
|
}
|
2013-04-12 06:18:37 -06:00
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
static void i965_enable_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:59 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-11-08 07:48:56 -07:00
|
|
|
enum pipe pipe = intel_get_pipe_from_connector(connector);
|
2013-11-14 03:13:41 -07:00
|
|
|
u32 ctl, ctl2, freq;
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
ctl2 = I915_READ(BLC_PWM_CTL2);
|
|
|
|
if (ctl2 & BLM_PWM_ENABLE) {
|
|
|
|
WARN(1, "backlight already enabled\n");
|
|
|
|
ctl2 &= ~BLM_PWM_ENABLE;
|
|
|
|
I915_WRITE(BLC_PWM_CTL2, ctl2);
|
|
|
|
}
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
freq = panel->backlight.max;
|
|
|
|
if (panel->backlight.combination_mode)
|
|
|
|
freq /= 0xff;
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
ctl = freq << 16;
|
|
|
|
I915_WRITE(BLC_PWM_CTL, ctl);
|
2013-11-08 07:48:59 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
/* XXX: combine this into above write? */
|
2013-11-08 07:48:59 -07:00
|
|
|
intel_panel_actually_set_backlight(connector, panel->backlight.level);
|
2013-11-14 03:13:41 -07:00
|
|
|
|
|
|
|
ctl2 = BLM_PIPE(pipe);
|
|
|
|
if (panel->backlight.combination_mode)
|
|
|
|
ctl2 |= BLM_COMBINATION_MODE;
|
|
|
|
if (panel->backlight.active_low_pwm)
|
|
|
|
ctl2 |= BLM_POLARITY_I965;
|
|
|
|
I915_WRITE(BLC_PWM_CTL2, ctl2);
|
|
|
|
POSTING_READ(BLC_PWM_CTL2);
|
|
|
|
I915_WRITE(BLC_PWM_CTL2, ctl2 | BLM_PWM_ENABLE);
|
2013-11-08 07:48:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vlv_enable_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:59 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-11-08 07:48:56 -07:00
|
|
|
enum pipe pipe = intel_get_pipe_from_connector(connector);
|
2013-11-14 03:13:41 -07:00
|
|
|
u32 ctl, ctl2;
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
ctl2 = I915_READ(VLV_BLC_PWM_CTL2(pipe));
|
|
|
|
if (ctl2 & BLM_PWM_ENABLE) {
|
|
|
|
WARN(1, "backlight already enabled\n");
|
|
|
|
ctl2 &= ~BLM_PWM_ENABLE;
|
|
|
|
I915_WRITE(VLV_BLC_PWM_CTL2(pipe), ctl2);
|
|
|
|
}
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
ctl = panel->backlight.max << 16;
|
|
|
|
I915_WRITE(VLV_BLC_PWM_CTL(pipe), ctl);
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
/* XXX: combine this into above write? */
|
|
|
|
intel_panel_actually_set_backlight(connector, panel->backlight.level);
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-14 03:13:41 -07:00
|
|
|
ctl2 = 0;
|
|
|
|
if (panel->backlight.active_low_pwm)
|
|
|
|
ctl2 |= BLM_POLARITY_I965;
|
|
|
|
I915_WRITE(VLV_BLC_PWM_CTL2(pipe), ctl2);
|
2013-11-08 07:48:56 -07:00
|
|
|
POSTING_READ(VLV_BLC_PWM_CTL2(pipe));
|
2013-11-14 03:13:41 -07:00
|
|
|
I915_WRITE(VLV_BLC_PWM_CTL2(pipe), ctl2 | BLM_PWM_ENABLE);
|
2011-01-11 10:06:04 -07:00
|
|
|
}
|
|
|
|
|
2013-10-31 10:55:49 -06:00
|
|
|
void intel_panel_enable_backlight(struct intel_connector *connector)
|
2011-01-11 10:06:04 -07:00
|
|
|
{
|
2013-10-31 10:55:49 -06:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
2011-01-11 10:06:04 -07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:54 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-10-31 10:55:49 -06:00
|
|
|
enum pipe pipe = intel_get_pipe_from_connector(connector);
|
2013-04-12 06:18:37 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
2014-01-16 09:27:15 -07:00
|
|
|
if (!panel->backlight.present || pipe == INVALID_PIPE)
|
2013-10-31 10:55:49 -06:00
|
|
|
return;
|
|
|
|
|
2013-10-16 05:29:54 -06:00
|
|
|
DRM_DEBUG_KMS("pipe %c\n", pipe_name(pipe));
|
2013-10-13 05:56:31 -06:00
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
spin_lock_irqsave(&dev_priv->backlight_lock, flags);
|
2011-01-11 10:06:04 -07:00
|
|
|
|
2013-11-08 07:49:00 -07:00
|
|
|
WARN_ON(panel->backlight.max == 0);
|
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
if (panel->backlight.level == 0) {
|
2013-11-08 07:49:00 -07:00
|
|
|
panel->backlight.level = panel->backlight.max;
|
2013-11-08 07:48:54 -07:00
|
|
|
if (panel->backlight.device)
|
|
|
|
panel->backlight.device->props.brightness =
|
|
|
|
panel->backlight.level;
|
2013-03-12 03:44:15 -06:00
|
|
|
}
|
2011-01-11 10:06:04 -07:00
|
|
|
|
2013-11-08 07:48:59 -07:00
|
|
|
dev_priv->display.enable_backlight(connector);
|
2013-11-08 07:48:54 -07:00
|
|
|
panel->backlight.enabled = true;
|
2013-04-12 06:18:37 -06:00
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
spin_unlock_irqrestore(&dev_priv->backlight_lock, flags);
|
2011-01-11 10:06:04 -07:00
|
|
|
}
|
|
|
|
|
2011-02-12 03:29:38 -07:00
|
|
|
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... */
|
2014-01-21 02:24:25 -07:00
|
|
|
if (!i915.panel_ignore_lid && dev_priv->opregion.lid_state) {
|
2011-02-12 03:29:38 -07:00
|
|
|
return ioread32(dev_priv->opregion.lid_state) & 0x1 ?
|
|
|
|
connector_status_connected :
|
|
|
|
connector_status_disconnected;
|
2012-11-20 06:50:08 -07:00
|
|
|
}
|
2011-02-12 03:29:38 -07:00
|
|
|
|
2014-01-21 02:24:25 -07:00
|
|
|
switch (i915.panel_ignore_lid) {
|
2012-11-20 06:50:08 -07:00
|
|
|
case -2:
|
|
|
|
return connector_status_connected;
|
|
|
|
case -1:
|
|
|
|
return connector_status_disconnected;
|
|
|
|
default:
|
|
|
|
return connector_status_unknown;
|
|
|
|
}
|
2011-02-12 03:29:38 -07:00
|
|
|
}
|
2011-08-12 04:11:33 -06:00
|
|
|
|
2013-09-18 08:19:45 -06:00
|
|
|
#if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)
|
2013-11-08 07:48:53 -07:00
|
|
|
static int intel_backlight_device_update_status(struct backlight_device *bd)
|
2011-08-12 04:11:33 -06:00
|
|
|
{
|
2013-10-31 10:55:49 -06:00
|
|
|
struct intel_connector *connector = bl_get_data(bd);
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.mutex);
|
2013-10-13 05:56:31 -06:00
|
|
|
DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n",
|
|
|
|
bd->props.brightness, bd->props.max_brightness);
|
2013-10-31 10:55:49 -06:00
|
|
|
intel_panel_set_backlight(connector, bd->props.brightness,
|
2013-04-12 06:18:36 -06:00
|
|
|
bd->props.max_brightness);
|
2013-10-31 10:55:49 -06:00
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
2011-08-12 04:11:33 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:53 -07:00
|
|
|
static int intel_backlight_device_get_brightness(struct backlight_device *bd)
|
2011-08-12 04:11:33 -06:00
|
|
|
{
|
2013-10-31 10:55:49 -06:00
|
|
|
struct intel_connector *connector = bl_get_data(bd);
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
2013-11-27 13:21:54 -07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:56 -07:00
|
|
|
int ret;
|
2013-10-31 10:55:49 -06:00
|
|
|
|
2013-11-27 13:21:54 -07:00
|
|
|
intel_runtime_pm_get(dev_priv);
|
2013-10-31 10:55:49 -06:00
|
|
|
mutex_lock(&dev->mode_config.mutex);
|
2013-11-08 07:48:56 -07:00
|
|
|
ret = intel_panel_get_backlight(connector);
|
2013-10-31 10:55:49 -06:00
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
2013-11-27 13:21:54 -07:00
|
|
|
intel_runtime_pm_put(dev_priv);
|
2013-10-31 10:55:49 -06:00
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
return ret;
|
2011-08-12 04:11:33 -06:00
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:53 -07:00
|
|
|
static const struct backlight_ops intel_backlight_device_ops = {
|
|
|
|
.update_status = intel_backlight_device_update_status,
|
|
|
|
.get_brightness = intel_backlight_device_get_brightness,
|
2011-08-12 04:11:33 -06:00
|
|
|
};
|
|
|
|
|
2013-11-08 07:48:53 -07:00
|
|
|
static int intel_backlight_device_register(struct intel_connector *connector)
|
2011-08-12 04:11:33 -06:00
|
|
|
{
|
2013-11-08 07:48:54 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2011-08-12 04:11:33 -06:00
|
|
|
struct backlight_properties props;
|
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
if (WARN_ON(panel->backlight.device))
|
2013-04-12 06:18:38 -06:00
|
|
|
return -ENODEV;
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
BUG_ON(panel->backlight.max == 0);
|
|
|
|
|
2012-05-22 03:29:46 -06:00
|
|
|
memset(&props, 0, sizeof(props));
|
2011-08-12 04:11:33 -06:00
|
|
|
props.type = BACKLIGHT_RAW;
|
2013-11-08 07:48:54 -07:00
|
|
|
props.brightness = panel->backlight.level;
|
2013-11-08 07:48:56 -07:00
|
|
|
props.max_brightness = panel->backlight.max;
|
2013-11-08 07:48:54 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: using the same name independent of the connector prevents
|
|
|
|
* registration of multiple backlight devices in the driver.
|
|
|
|
*/
|
|
|
|
panel->backlight.device =
|
2011-08-12 04:11:33 -06:00
|
|
|
backlight_device_register("intel_backlight",
|
2013-11-08 07:48:53 -07:00
|
|
|
connector->base.kdev,
|
|
|
|
connector,
|
|
|
|
&intel_backlight_device_ops, &props);
|
2011-08-12 04:11:33 -06:00
|
|
|
|
2013-11-08 07:48:54 -07:00
|
|
|
if (IS_ERR(panel->backlight.device)) {
|
2011-08-12 04:11:33 -06:00
|
|
|
DRM_ERROR("Failed to register backlight: %ld\n",
|
2013-11-08 07:48:54 -07:00
|
|
|
PTR_ERR(panel->backlight.device));
|
|
|
|
panel->backlight.device = NULL;
|
2011-08-12 04:11:33 -06:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:53 -07:00
|
|
|
static void intel_backlight_device_unregister(struct intel_connector *connector)
|
2011-08-12 04:11:33 -06:00
|
|
|
{
|
2013-11-08 07:48:54 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
|
|
|
|
|
|
|
if (panel->backlight.device) {
|
|
|
|
backlight_device_unregister(panel->backlight.device);
|
|
|
|
panel->backlight.device = NULL;
|
2013-04-12 06:18:38 -06:00
|
|
|
}
|
2011-08-12 04:11:33 -06:00
|
|
|
}
|
2013-11-08 07:48:53 -07:00
|
|
|
#else /* CONFIG_BACKLIGHT_CLASS_DEVICE */
|
|
|
|
static int intel_backlight_device_register(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
static void intel_backlight_device_unregister(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
|
|
|
|
|
2013-11-08 07:49:00 -07:00
|
|
|
/*
|
|
|
|
* Note: The setup hooks can't assume pipe is set!
|
|
|
|
*
|
|
|
|
* XXX: Query mode clock or hardware clock and program PWM modulation frequency
|
|
|
|
* appropriately when it's 0. Use VBT and/or sane defaults.
|
|
|
|
*/
|
2013-11-14 07:17:41 -07:00
|
|
|
static int bdw_setup_backlight(struct intel_connector *connector)
|
2011-08-12 04:11:33 -06:00
|
|
|
{
|
2013-11-14 07:17:41 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
2011-08-12 04:11:33 -06:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-14 07:17:41 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
|
|
|
u32 pch_ctl1, pch_ctl2, val;
|
|
|
|
|
|
|
|
pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1);
|
|
|
|
panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY;
|
|
|
|
|
|
|
|
pch_ctl2 = I915_READ(BLC_PWM_PCH_CTL2);
|
|
|
|
panel->backlight.max = pch_ctl2 >> 16;
|
|
|
|
if (!panel->backlight.max)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
val = bdw_get_backlight(connector);
|
|
|
|
panel->backlight.level = intel_panel_compute_brightness(connector, val);
|
|
|
|
|
|
|
|
panel->backlight.enabled = (pch_ctl1 & BLM_PCH_PWM_ENABLE) &&
|
|
|
|
panel->backlight.level != 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
static int pch_setup_backlight(struct intel_connector *connector)
|
|
|
|
{
|
2013-11-08 07:49:02 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:56 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-11-08 07:49:02 -07:00
|
|
|
u32 cpu_ctl2, pch_ctl1, pch_ctl2, val;
|
2013-11-08 07:48:56 -07:00
|
|
|
|
2013-11-08 07:49:02 -07:00
|
|
|
pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1);
|
|
|
|
panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY;
|
|
|
|
|
|
|
|
pch_ctl2 = I915_READ(BLC_PWM_PCH_CTL2);
|
|
|
|
panel->backlight.max = pch_ctl2 >> 16;
|
2013-11-08 07:48:56 -07:00
|
|
|
if (!panel->backlight.max)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
val = pch_get_backlight(connector);
|
|
|
|
panel->backlight.level = intel_panel_compute_brightness(connector, val);
|
|
|
|
|
2013-11-08 07:49:02 -07:00
|
|
|
cpu_ctl2 = I915_READ(BLC_PWM_CPU_CTL2);
|
|
|
|
panel->backlight.enabled = (cpu_ctl2 & BLM_PWM_ENABLE) &&
|
|
|
|
(pch_ctl1 & BLM_PCH_PWM_ENABLE) && panel->backlight.level != 0;
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i9xx_setup_backlight(struct intel_connector *connector)
|
|
|
|
{
|
2013-11-08 07:49:02 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:56 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-11-08 07:49:02 -07:00
|
|
|
u32 ctl, val;
|
|
|
|
|
|
|
|
ctl = I915_READ(BLC_PWM_CTL);
|
|
|
|
|
|
|
|
if (IS_GEN2(dev))
|
|
|
|
panel->backlight.combination_mode = ctl & BLM_LEGACY_MODE;
|
|
|
|
|
|
|
|
if (IS_PINEVIEW(dev))
|
|
|
|
panel->backlight.active_low_pwm = ctl & BLM_POLARITY_PNV;
|
|
|
|
|
|
|
|
panel->backlight.max = ctl >> 17;
|
|
|
|
if (panel->backlight.combination_mode)
|
|
|
|
panel->backlight.max *= 0xff;
|
2013-11-08 07:48:56 -07:00
|
|
|
|
|
|
|
if (!panel->backlight.max)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
val = i9xx_get_backlight(connector);
|
|
|
|
panel->backlight.level = intel_panel_compute_brightness(connector, val);
|
|
|
|
|
2013-11-08 07:49:02 -07:00
|
|
|
panel->backlight.enabled = panel->backlight.level != 0;
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i965_setup_backlight(struct intel_connector *connector)
|
|
|
|
{
|
2013-11-08 07:49:02 -07:00
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:56 -07:00
|
|
|
struct intel_panel *panel = &connector->panel;
|
2013-11-08 07:49:02 -07:00
|
|
|
u32 ctl, ctl2, val;
|
|
|
|
|
|
|
|
ctl2 = I915_READ(BLC_PWM_CTL2);
|
|
|
|
panel->backlight.combination_mode = ctl2 & BLM_COMBINATION_MODE;
|
|
|
|
panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
|
|
|
|
|
|
|
|
ctl = I915_READ(BLC_PWM_CTL);
|
|
|
|
panel->backlight.max = ctl >> 16;
|
|
|
|
if (panel->backlight.combination_mode)
|
|
|
|
panel->backlight.max *= 0xff;
|
2013-11-08 07:48:56 -07:00
|
|
|
|
|
|
|
if (!panel->backlight.max)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
val = i9xx_get_backlight(connector);
|
|
|
|
panel->backlight.level = intel_panel_compute_brightness(connector, val);
|
|
|
|
|
2013-11-08 07:49:02 -07:00
|
|
|
panel->backlight.enabled = (ctl2 & BLM_PWM_ENABLE) &&
|
|
|
|
panel->backlight.level != 0;
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vlv_setup_backlight(struct intel_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct intel_panel *panel = &connector->panel;
|
|
|
|
enum pipe pipe;
|
2013-11-08 07:49:02 -07:00
|
|
|
u32 ctl, ctl2, val;
|
2013-11-08 07:48:56 -07:00
|
|
|
|
|
|
|
for_each_pipe(pipe) {
|
|
|
|
u32 cur_val = I915_READ(VLV_BLC_PWM_CTL(pipe));
|
|
|
|
|
|
|
|
/* Skip if the modulation freq is already set */
|
|
|
|
if (cur_val & ~BACKLIGHT_DUTY_CYCLE_MASK)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cur_val &= BACKLIGHT_DUTY_CYCLE_MASK;
|
|
|
|
I915_WRITE(VLV_BLC_PWM_CTL(pipe), (0xf42 << 16) |
|
|
|
|
cur_val);
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:49:02 -07:00
|
|
|
ctl2 = I915_READ(VLV_BLC_PWM_CTL2(PIPE_A));
|
|
|
|
panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
|
|
|
|
|
|
|
|
ctl = I915_READ(VLV_BLC_PWM_CTL(PIPE_A));
|
|
|
|
panel->backlight.max = ctl >> 16;
|
2013-11-08 07:48:56 -07:00
|
|
|
if (!panel->backlight.max)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
val = _vlv_get_backlight(dev, PIPE_A);
|
|
|
|
panel->backlight.level = intel_panel_compute_brightness(connector, val);
|
|
|
|
|
2013-11-08 07:49:02 -07:00
|
|
|
panel->backlight.enabled = (ctl2 & BLM_PWM_ENABLE) &&
|
|
|
|
panel->backlight.level != 0;
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-19 05:51:46 -06:00
|
|
|
int intel_panel_setup_backlight(struct drm_connector *connector)
|
2011-08-12 04:11:33 -06:00
|
|
|
{
|
2013-11-08 07:48:53 -07:00
|
|
|
struct drm_device *dev = connector->dev;
|
2013-11-08 07:48:56 -07:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2013-11-08 07:48:53 -07:00
|
|
|
struct intel_connector *intel_connector = to_intel_connector(connector);
|
2013-11-08 07:48:54 -07:00
|
|
|
struct intel_panel *panel = &intel_connector->panel;
|
2013-11-08 07:48:56 -07:00
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
2013-11-08 07:48:53 -07:00
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
/* set level and max in panel struct */
|
|
|
|
spin_lock_irqsave(&dev_priv->backlight_lock, flags);
|
|
|
|
ret = dev_priv->display.setup_backlight(intel_connector);
|
|
|
|
spin_unlock_irqrestore(&dev_priv->backlight_lock, flags);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
DRM_DEBUG_KMS("failed to setup backlight for connector %s\n",
|
|
|
|
drm_get_connector_name(connector));
|
|
|
|
return ret;
|
|
|
|
}
|
2013-11-08 07:48:53 -07:00
|
|
|
|
|
|
|
intel_backlight_device_register(intel_connector);
|
|
|
|
|
2013-11-08 07:48:55 -07:00
|
|
|
panel->backlight.present = true;
|
|
|
|
|
2013-11-08 07:49:01 -07:00
|
|
|
DRM_DEBUG_KMS("backlight initialized, %s, brightness %u/%u, "
|
|
|
|
"sysfs interface %sregistered\n",
|
|
|
|
panel->backlight.enabled ? "enabled" : "disabled",
|
|
|
|
panel->backlight.level, panel->backlight.max,
|
|
|
|
panel->backlight.device ? "" : "not ");
|
|
|
|
|
2011-08-12 04:11:33 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:53 -07:00
|
|
|
void intel_panel_destroy_backlight(struct drm_connector *connector)
|
2011-08-12 04:11:33 -06:00
|
|
|
{
|
2013-11-08 07:48:53 -07:00
|
|
|
struct intel_connector *intel_connector = to_intel_connector(connector);
|
2013-11-08 07:48:55 -07:00
|
|
|
struct intel_panel *panel = &intel_connector->panel;
|
2013-11-08 07:48:53 -07:00
|
|
|
|
2013-11-08 07:48:55 -07:00
|
|
|
panel->backlight.present = false;
|
2013-11-08 07:48:53 -07:00
|
|
|
intel_backlight_device_unregister(intel_connector);
|
2011-08-12 04:11:33 -06:00
|
|
|
}
|
2012-10-19 05:51:49 -06:00
|
|
|
|
2013-12-10 01:07:36 -07:00
|
|
|
/**
|
|
|
|
* intel_find_panel_downclock - find the reduced downclock for LVDS in EDID
|
|
|
|
* @dev: drm device
|
|
|
|
* @fixed_mode : panel native mode
|
|
|
|
* @connector: LVDS/eDP connector
|
|
|
|
*
|
|
|
|
* Return downclock_avail
|
|
|
|
* Find the reduced downclock for LVDS/eDP in EDID.
|
|
|
|
*/
|
|
|
|
struct drm_display_mode *
|
|
|
|
intel_find_panel_downclock(struct drm_device *dev,
|
|
|
|
struct drm_display_mode *fixed_mode,
|
|
|
|
struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_display_mode *scan, *tmp_mode;
|
|
|
|
int temp_downclock;
|
|
|
|
|
|
|
|
temp_downclock = fixed_mode->clock;
|
|
|
|
tmp_mode = NULL;
|
|
|
|
|
|
|
|
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. In such
|
|
|
|
* case we can set the different FPx0/1 to dynamically select
|
|
|
|
* between low and high frequency.
|
|
|
|
*/
|
|
|
|
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) {
|
|
|
|
if (scan->clock < temp_downclock) {
|
|
|
|
/*
|
|
|
|
* The downclock is already found. But we
|
|
|
|
* expect to find the lower downclock.
|
|
|
|
*/
|
|
|
|
temp_downclock = scan->clock;
|
|
|
|
tmp_mode = scan;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (temp_downclock < fixed_mode->clock)
|
|
|
|
return drm_mode_duplicate(dev, tmp_mode);
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-11-08 07:48:56 -07:00
|
|
|
/* Set up chip specific backlight functions */
|
|
|
|
void intel_panel_init_backlight_funcs(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
2013-11-14 07:17:41 -07:00
|
|
|
if (IS_BROADWELL(dev)) {
|
|
|
|
dev_priv->display.setup_backlight = bdw_setup_backlight;
|
|
|
|
dev_priv->display.enable_backlight = bdw_enable_backlight;
|
|
|
|
dev_priv->display.disable_backlight = pch_disable_backlight;
|
|
|
|
dev_priv->display.set_backlight = bdw_set_backlight;
|
|
|
|
dev_priv->display.get_backlight = bdw_get_backlight;
|
|
|
|
} else if (HAS_PCH_SPLIT(dev)) {
|
2013-11-08 07:48:56 -07:00
|
|
|
dev_priv->display.setup_backlight = pch_setup_backlight;
|
|
|
|
dev_priv->display.enable_backlight = pch_enable_backlight;
|
|
|
|
dev_priv->display.disable_backlight = pch_disable_backlight;
|
|
|
|
dev_priv->display.set_backlight = pch_set_backlight;
|
|
|
|
dev_priv->display.get_backlight = pch_get_backlight;
|
|
|
|
} else if (IS_VALLEYVIEW(dev)) {
|
|
|
|
dev_priv->display.setup_backlight = vlv_setup_backlight;
|
|
|
|
dev_priv->display.enable_backlight = vlv_enable_backlight;
|
|
|
|
dev_priv->display.disable_backlight = vlv_disable_backlight;
|
|
|
|
dev_priv->display.set_backlight = vlv_set_backlight;
|
|
|
|
dev_priv->display.get_backlight = vlv_get_backlight;
|
|
|
|
} else if (IS_GEN4(dev)) {
|
|
|
|
dev_priv->display.setup_backlight = i965_setup_backlight;
|
|
|
|
dev_priv->display.enable_backlight = i965_enable_backlight;
|
|
|
|
dev_priv->display.disable_backlight = i965_disable_backlight;
|
|
|
|
dev_priv->display.set_backlight = i9xx_set_backlight;
|
|
|
|
dev_priv->display.get_backlight = i9xx_get_backlight;
|
|
|
|
} else {
|
|
|
|
dev_priv->display.setup_backlight = i9xx_setup_backlight;
|
2013-11-08 07:48:59 -07:00
|
|
|
dev_priv->display.enable_backlight = i9xx_enable_backlight;
|
|
|
|
dev_priv->display.disable_backlight = i9xx_disable_backlight;
|
2013-11-08 07:48:56 -07:00
|
|
|
dev_priv->display.set_backlight = i9xx_set_backlight;
|
|
|
|
dev_priv->display.get_backlight = i9xx_get_backlight;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-19 05:51:50 -06:00
|
|
|
int intel_panel_init(struct intel_panel *panel,
|
2014-02-11 01:56:36 -07:00
|
|
|
struct drm_display_mode *fixed_mode,
|
|
|
|
struct drm_display_mode *downclock_mode)
|
2012-10-19 05:51:49 -06:00
|
|
|
{
|
2012-10-19 05:51:50 -06:00
|
|
|
panel->fixed_mode = fixed_mode;
|
2014-02-11 01:56:36 -07:00
|
|
|
panel->downclock_mode = downclock_mode;
|
2012-10-19 05:51:50 -06:00
|
|
|
|
2012-10-19 05:51:49 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void intel_panel_fini(struct intel_panel *panel)
|
|
|
|
{
|
2012-10-19 05:51:50 -06:00
|
|
|
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);
|
2013-12-10 01:07:36 -07:00
|
|
|
|
|
|
|
if (panel->downclock_mode)
|
|
|
|
drm_mode_destroy(intel_connector->base.dev,
|
|
|
|
panel->downclock_mode);
|
2012-10-19 05:51:49 -06:00
|
|
|
}
|