DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
|
|
|
|
* Copyright (c) 2007-2008 Intel Corporation
|
|
|
|
* Jesse Barnes <jesse.barnes@intel.com>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
#ifndef __INTEL_DRV_H__
|
|
|
|
#define __INTEL_DRV_H__
|
|
|
|
|
2014-05-29 04:39:03 +07:00
|
|
|
#include <linux/async.h>
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
#include <linux/i2c.h>
|
2013-08-07 02:32:18 +07:00
|
|
|
#include <linux/hdmi.h>
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/i915_drm.h>
|
2009-09-11 05:28:06 +07:00
|
|
|
#include "i915_drv.h"
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/drm_crtc.h>
|
|
|
|
#include <drm/drm_crtc_helper.h>
|
|
|
|
#include <drm/drm_fb_helper.h>
|
2014-05-02 11:02:48 +07:00
|
|
|
#include <drm/drm_dp_mst_helper.h>
|
2014-09-06 03:04:46 +07:00
|
|
|
#include <drm/drm_rect.h>
|
2010-08-07 17:01:35 +07:00
|
|
|
|
2014-09-30 05:49:33 +07:00
|
|
|
#define DIV_ROUND_CLOSEST_ULL(ll, d) \
|
|
|
|
({ unsigned long long _tmp = (ll)+(d)/2; do_div(_tmp, d); _tmp; })
|
|
|
|
|
2013-03-28 06:03:25 +07:00
|
|
|
/**
|
|
|
|
* _wait_for - magic (register) wait macro
|
|
|
|
*
|
|
|
|
* Does the right thing for modeset paths when run under kdgb or similar atomic
|
|
|
|
* contexts. Note that it's important that we check the condition again after
|
|
|
|
* having timed out, since the timeout could be due to preemption or similar and
|
|
|
|
* we've never had a chance to check the condition before the timeout.
|
|
|
|
*/
|
2010-08-23 23:43:35 +07:00
|
|
|
#define _wait_for(COND, MS, W) ({ \
|
2013-03-28 06:03:25 +07:00
|
|
|
unsigned long timeout__ = jiffies + msecs_to_jiffies(MS) + 1; \
|
2010-08-07 17:01:35 +07:00
|
|
|
int ret__ = 0; \
|
2011-08-17 02:34:10 +07:00
|
|
|
while (!(COND)) { \
|
2010-08-07 17:01:35 +07:00
|
|
|
if (time_after(jiffies, timeout__)) { \
|
2013-03-28 06:03:25 +07:00
|
|
|
if (!(COND)) \
|
|
|
|
ret__ = -ETIMEDOUT; \
|
2010-08-07 17:01:35 +07:00
|
|
|
break; \
|
|
|
|
} \
|
2012-09-02 12:59:48 +07:00
|
|
|
if (W && drm_can_sleep()) { \
|
|
|
|
msleep(W); \
|
|
|
|
} else { \
|
|
|
|
cpu_relax(); \
|
|
|
|
} \
|
2010-08-07 17:01:35 +07:00
|
|
|
} \
|
|
|
|
ret__; \
|
|
|
|
})
|
|
|
|
|
2010-08-23 23:43:35 +07:00
|
|
|
#define wait_for(COND, MS) _wait_for(COND, MS, 1)
|
|
|
|
#define wait_for_atomic(COND, MS) _wait_for(COND, MS, 0)
|
2013-03-28 17:31:04 +07:00
|
|
|
#define wait_for_atomic_us(COND, US) _wait_for((COND), \
|
|
|
|
DIV_ROUND_UP((US), 1000), 0)
|
2010-08-23 23:43:35 +07:00
|
|
|
|
2014-01-10 22:10:20 +07:00
|
|
|
#define KHz(x) (1000 * (x))
|
|
|
|
#define MHz(x) KHz(1000 * (x))
|
2010-09-08 02:54:59 +07:00
|
|
|
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
/*
|
|
|
|
* Display related stuff
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* store information about an Ixxx DVO */
|
|
|
|
/* The i830->i865 use multiple DVOs with multiple i2cs */
|
|
|
|
/* the i915, i945 have a single sDVO i2c bus - which is different */
|
|
|
|
#define MAX_OUTPUTS 6
|
|
|
|
/* maximum connectors per crtcs in the mode set */
|
|
|
|
|
2014-03-10 18:36:23 +07:00
|
|
|
/* Maximum cursor sizes */
|
|
|
|
#define GEN2_CURSOR_WIDTH 64
|
|
|
|
#define GEN2_CURSOR_HEIGHT 64
|
2014-03-28 21:17:49 +07:00
|
|
|
#define MAX_CURSOR_WIDTH 256
|
|
|
|
#define MAX_CURSOR_HEIGHT 256
|
2014-03-10 18:36:23 +07:00
|
|
|
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
#define INTEL_I2C_BUS_DVO 1
|
|
|
|
#define INTEL_I2C_BUS_SDVO 2
|
|
|
|
|
|
|
|
/* these are outputs from the chip - integrated only
|
|
|
|
external chips are via DVO or SDVO output */
|
2014-10-28 02:47:52 +07:00
|
|
|
enum intel_output_type {
|
|
|
|
INTEL_OUTPUT_UNUSED = 0,
|
|
|
|
INTEL_OUTPUT_ANALOG = 1,
|
|
|
|
INTEL_OUTPUT_DVO = 2,
|
|
|
|
INTEL_OUTPUT_SDVO = 3,
|
|
|
|
INTEL_OUTPUT_LVDS = 4,
|
|
|
|
INTEL_OUTPUT_TVOUT = 5,
|
|
|
|
INTEL_OUTPUT_HDMI = 6,
|
|
|
|
INTEL_OUTPUT_DISPLAYPORT = 7,
|
|
|
|
INTEL_OUTPUT_EDP = 8,
|
|
|
|
INTEL_OUTPUT_DSI = 9,
|
|
|
|
INTEL_OUTPUT_UNKNOWN = 10,
|
|
|
|
INTEL_OUTPUT_DP_MST = 11,
|
|
|
|
};
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
|
|
|
|
#define INTEL_DVO_CHIP_NONE 0
|
|
|
|
#define INTEL_DVO_CHIP_LVDS 1
|
|
|
|
#define INTEL_DVO_CHIP_TMDS 2
|
|
|
|
#define INTEL_DVO_CHIP_TVOUT 4
|
|
|
|
|
2014-04-14 12:48:24 +07:00
|
|
|
#define INTEL_DSI_VIDEO_MODE 0
|
|
|
|
#define INTEL_DSI_COMMAND_MODE 1
|
2013-08-27 19:12:17 +07:00
|
|
|
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
struct intel_framebuffer {
|
|
|
|
struct drm_framebuffer base;
|
2010-11-09 02:18:58 +07:00
|
|
|
struct drm_i915_gem_object *obj;
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
};
|
|
|
|
|
2010-08-26 04:45:57 +07:00
|
|
|
struct intel_fbdev {
|
|
|
|
struct drm_fb_helper helper;
|
2014-02-08 03:10:38 +07:00
|
|
|
struct intel_framebuffer *fb;
|
2010-08-26 04:45:57 +07:00
|
|
|
struct list_head fbdev_list;
|
|
|
|
struct drm_display_mode *our_mode;
|
2014-03-07 23:57:51 +07:00
|
|
|
int preferred_bpp;
|
2010-08-26 04:45:57 +07:00
|
|
|
};
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
|
2010-03-26 01:11:14 +07:00
|
|
|
struct intel_encoder {
|
2010-09-09 21:14:28 +07:00
|
|
|
struct drm_encoder base;
|
drm/i915: stage modeset output changes
This is the core of the new modeset logic.
The current code which is based upon the crtc helper code first
updates all the link of the new display pipeline and then calls the
lower-level set_mode function to execute the required callbacks to get
there. The issue with this approach is that for disabling we need to
know the _current_ display pipe state, not the new one.
Hence we need to stage the new state of the display pipe and only
update it once we have disabled the current configuration and before we
start to update the hw registers with the new configuration.
This patch here just prepares the ground by switching the new output
state computation to these staging pointers. To make it clearer,
rename the old update_output_state function to stage_output_state.
A few peculiarities:
- We're also calling the set_mode function at various places to update
properties. Hence after a successfule modeset we need to stage the
current configuration (for otherwise we might fall back again). This
happens automatically because as part of the (successful) modeset we
need to copy the staged state to the real one. But for the hw
readout code we need to make sure that this happens, too.
- Teach the new staged output state computation code the required
smarts to handle the disabling of outputs. The current code handles
this in a special case, but to better handle global modeset changes
covering more than one crtc, we want to do this all in the same
low-level modeset code.
- The actual modeset code is still a bit ugly and wants to know the new
crtc->enabled state a bit early. Follow-on patches will clean that
up, for now we have to apply the staged output configuration early,
outside of the set_mode functions.
- Improve/add comments in stage_output_state.
Essentially all that is left to do now is move the disabling code into
set_mode and then move the staged state update code also into
set_mode, at the right place between disabling things and calling the
mode_set callbacks for the new configuration.
v2: Disabling a crtc works by passing in a NULL mode or fb, userspace
doesn't hand in the list of connectors. We therefore need to detect
this case manually and tear down all the output links.
v3: Properly update the output staging pointers after having read out
the hw state.
v4: Simplify the code, add more DRM_DEBUG_KMS output and check a few
assumptions with WARN_ON. Essentially all things that I've noticed
while debugging issues in other places of the code.
v4: Correctly disable the old set of connectors when enabling an
already enabled crtc on a new set of crtc. Reported by Paulo Zanoni.
Reviewed-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-07-06 03:34:27 +07:00
|
|
|
/*
|
|
|
|
* The new crtc this encoder will be driven from. Only differs from
|
|
|
|
* base->crtc while a modeset is in progress.
|
|
|
|
*/
|
|
|
|
struct intel_crtc *new_crtc;
|
|
|
|
|
2014-10-28 02:47:52 +07:00
|
|
|
enum intel_output_type type;
|
2014-03-03 21:15:28 +07:00
|
|
|
unsigned int cloneable;
|
2012-06-30 13:59:56 +07:00
|
|
|
bool connectors_active;
|
2010-03-26 01:11:14 +07:00
|
|
|
void (*hot_plug)(struct intel_encoder *);
|
2013-03-27 06:44:52 +07:00
|
|
|
bool (*compute_config)(struct intel_encoder *,
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *);
|
2012-11-26 23:22:07 +07:00
|
|
|
void (*pre_pll_enable)(struct intel_encoder *);
|
2012-09-07 03:15:40 +07:00
|
|
|
void (*pre_enable)(struct intel_encoder *);
|
2012-06-30 03:40:09 +07:00
|
|
|
void (*enable)(struct intel_encoder *);
|
2013-03-27 06:44:53 +07:00
|
|
|
void (*mode_set)(struct intel_encoder *intel_encoder);
|
2012-06-30 03:40:09 +07:00
|
|
|
void (*disable)(struct intel_encoder *);
|
2012-09-07 03:15:40 +07:00
|
|
|
void (*post_disable)(struct intel_encoder *);
|
2012-07-02 18:10:34 +07:00
|
|
|
/* Read out the current hw state of this connector, returning true if
|
|
|
|
* the encoder is active. If the encoder is enabled it also set the pipe
|
|
|
|
* it is connected to in the pipe parameter. */
|
|
|
|
bool (*get_hw_state)(struct intel_encoder *, enum pipe *pipe);
|
2013-05-15 07:08:26 +07:00
|
|
|
/* Reconstructs the equivalent mode flags for the current hardware
|
2013-06-12 16:47:24 +07:00
|
|
|
* state. This must be called _after_ display->get_pipe_config has
|
2013-06-28 11:59:06 +07:00
|
|
|
* pre-filled the pipe config. Note that intel_encoder->base.crtc must
|
|
|
|
* be set correctly before calling this function. */
|
2013-05-15 07:08:26 +07:00
|
|
|
void (*get_config)(struct intel_encoder *,
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *pipe_config);
|
2014-08-18 18:42:45 +07:00
|
|
|
/*
|
|
|
|
* Called during system suspend after all pending requests for the
|
|
|
|
* encoder are flushed (for example for DP AUX transactions) and
|
|
|
|
* device interrupts are disabled.
|
|
|
|
*/
|
|
|
|
void (*suspend)(struct intel_encoder *);
|
2009-08-24 12:50:24 +07:00
|
|
|
int crtc_mask;
|
2013-02-26 00:06:49 +07:00
|
|
|
enum hpd_pin hpd_pin;
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
};
|
|
|
|
|
2012-10-19 18:51:49 +07:00
|
|
|
struct intel_panel {
|
2012-10-19 18:51:50 +07:00
|
|
|
struct drm_display_mode *fixed_mode;
|
2013-12-10 15:07:36 +07:00
|
|
|
struct drm_display_mode *downclock_mode;
|
2012-10-26 16:03:59 +07:00
|
|
|
int fitting_mode;
|
2013-11-08 21:48:54 +07:00
|
|
|
|
|
|
|
/* backlight */
|
|
|
|
struct {
|
2013-11-08 21:48:55 +07:00
|
|
|
bool present;
|
2013-11-08 21:48:54 +07:00
|
|
|
u32 level;
|
2014-06-24 22:27:40 +07:00
|
|
|
u32 min;
|
2013-11-08 21:48:56 +07:00
|
|
|
u32 max;
|
2013-11-08 21:48:54 +07:00
|
|
|
bool enabled;
|
2013-11-08 21:49:02 +07:00
|
|
|
bool combination_mode; /* gen 2/4 only */
|
|
|
|
bool active_low_pwm;
|
2013-11-08 21:48:54 +07:00
|
|
|
struct backlight_device *device;
|
|
|
|
} backlight;
|
2014-08-13 16:10:12 +07:00
|
|
|
|
|
|
|
void (*backlight_power)(struct intel_connector *, bool enable);
|
2012-10-19 18:51:49 +07:00
|
|
|
};
|
|
|
|
|
2010-03-30 13:39:28 +07:00
|
|
|
struct intel_connector {
|
|
|
|
struct drm_connector base;
|
drm/i915: stage modeset output changes
This is the core of the new modeset logic.
The current code which is based upon the crtc helper code first
updates all the link of the new display pipeline and then calls the
lower-level set_mode function to execute the required callbacks to get
there. The issue with this approach is that for disabling we need to
know the _current_ display pipe state, not the new one.
Hence we need to stage the new state of the display pipe and only
update it once we have disabled the current configuration and before we
start to update the hw registers with the new configuration.
This patch here just prepares the ground by switching the new output
state computation to these staging pointers. To make it clearer,
rename the old update_output_state function to stage_output_state.
A few peculiarities:
- We're also calling the set_mode function at various places to update
properties. Hence after a successfule modeset we need to stage the
current configuration (for otherwise we might fall back again). This
happens automatically because as part of the (successful) modeset we
need to copy the staged state to the real one. But for the hw
readout code we need to make sure that this happens, too.
- Teach the new staged output state computation code the required
smarts to handle the disabling of outputs. The current code handles
this in a special case, but to better handle global modeset changes
covering more than one crtc, we want to do this all in the same
low-level modeset code.
- The actual modeset code is still a bit ugly and wants to know the new
crtc->enabled state a bit early. Follow-on patches will clean that
up, for now we have to apply the staged output configuration early,
outside of the set_mode functions.
- Improve/add comments in stage_output_state.
Essentially all that is left to do now is move the disabling code into
set_mode and then move the staged state update code also into
set_mode, at the right place between disabling things and calling the
mode_set callbacks for the new configuration.
v2: Disabling a crtc works by passing in a NULL mode or fb, userspace
doesn't hand in the list of connectors. We therefore need to detect
this case manually and tear down all the output links.
v3: Properly update the output staging pointers after having read out
the hw state.
v4: Simplify the code, add more DRM_DEBUG_KMS output and check a few
assumptions with WARN_ON. Essentially all things that I've noticed
while debugging issues in other places of the code.
v4: Correctly disable the old set of connectors when enabling an
already enabled crtc on a new set of crtc. Reported by Paulo Zanoni.
Reviewed-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-07-06 03:34:27 +07:00
|
|
|
/*
|
|
|
|
* The fixed encoder this connector is connected to.
|
|
|
|
*/
|
2010-09-09 22:20:55 +07:00
|
|
|
struct intel_encoder *encoder;
|
drm/i915: stage modeset output changes
This is the core of the new modeset logic.
The current code which is based upon the crtc helper code first
updates all the link of the new display pipeline and then calls the
lower-level set_mode function to execute the required callbacks to get
there. The issue with this approach is that for disabling we need to
know the _current_ display pipe state, not the new one.
Hence we need to stage the new state of the display pipe and only
update it once we have disabled the current configuration and before we
start to update the hw registers with the new configuration.
This patch here just prepares the ground by switching the new output
state computation to these staging pointers. To make it clearer,
rename the old update_output_state function to stage_output_state.
A few peculiarities:
- We're also calling the set_mode function at various places to update
properties. Hence after a successfule modeset we need to stage the
current configuration (for otherwise we might fall back again). This
happens automatically because as part of the (successful) modeset we
need to copy the staged state to the real one. But for the hw
readout code we need to make sure that this happens, too.
- Teach the new staged output state computation code the required
smarts to handle the disabling of outputs. The current code handles
this in a special case, but to better handle global modeset changes
covering more than one crtc, we want to do this all in the same
low-level modeset code.
- The actual modeset code is still a bit ugly and wants to know the new
crtc->enabled state a bit early. Follow-on patches will clean that
up, for now we have to apply the staged output configuration early,
outside of the set_mode functions.
- Improve/add comments in stage_output_state.
Essentially all that is left to do now is move the disabling code into
set_mode and then move the staged state update code also into
set_mode, at the right place between disabling things and calling the
mode_set callbacks for the new configuration.
v2: Disabling a crtc works by passing in a NULL mode or fb, userspace
doesn't hand in the list of connectors. We therefore need to detect
this case manually and tear down all the output links.
v3: Properly update the output staging pointers after having read out
the hw state.
v4: Simplify the code, add more DRM_DEBUG_KMS output and check a few
assumptions with WARN_ON. Essentially all things that I've noticed
while debugging issues in other places of the code.
v4: Correctly disable the old set of connectors when enabling an
already enabled crtc on a new set of crtc. Reported by Paulo Zanoni.
Reviewed-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-07-06 03:34:27 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The new encoder this connector will be driven. Only differs from
|
|
|
|
* encoder while a modeset is in progress.
|
|
|
|
*/
|
|
|
|
struct intel_encoder *new_encoder;
|
|
|
|
|
2012-07-02 18:10:34 +07:00
|
|
|
/* Reads out the current hw, returning true if the connector is enabled
|
|
|
|
* and active (i.e. dpms ON state). */
|
|
|
|
bool (*get_hw_state)(struct intel_connector *);
|
2012-10-19 18:51:49 +07:00
|
|
|
|
2014-02-11 22:12:48 +07:00
|
|
|
/*
|
|
|
|
* Removes all interfaces through which the connector is accessible
|
|
|
|
* - like sysfs, debugfs entries -, so that no new operations can be
|
|
|
|
* started on the connector. Also makes sure all currently pending
|
|
|
|
* operations finish before returing.
|
|
|
|
*/
|
|
|
|
void (*unregister)(struct intel_connector *);
|
|
|
|
|
2012-10-19 18:51:49 +07:00
|
|
|
/* Panel info for eDP and LVDS */
|
|
|
|
struct intel_panel panel;
|
2012-10-19 18:51:52 +07:00
|
|
|
|
|
|
|
/* Cached EDID for eDP and LVDS. May hold ERR_PTR for invalid EDID. */
|
|
|
|
struct edid *edid;
|
2014-09-03 02:04:00 +07:00
|
|
|
struct edid *detect_edid;
|
2013-04-16 18:36:55 +07:00
|
|
|
|
|
|
|
/* since POLL and HPD connectors may use the same HPD line keep the native
|
|
|
|
state of connector->polled in case hotplug storm detection changes it */
|
|
|
|
u8 polled;
|
2014-05-02 11:02:48 +07:00
|
|
|
|
|
|
|
void *port; /* store this opaque as its illegal to dereference it */
|
|
|
|
|
|
|
|
struct intel_dp *mst_port;
|
2010-03-30 13:39:28 +07:00
|
|
|
};
|
|
|
|
|
2013-04-19 18:36:51 +07:00
|
|
|
typedef struct dpll {
|
|
|
|
/* given values */
|
|
|
|
int n;
|
|
|
|
int m1, m2;
|
|
|
|
int p1, p2;
|
|
|
|
/* derived values */
|
|
|
|
int dot;
|
|
|
|
int vco;
|
|
|
|
int m;
|
|
|
|
int p;
|
|
|
|
} intel_clock_t;
|
|
|
|
|
2014-09-06 03:04:46 +07:00
|
|
|
struct intel_plane_state {
|
2014-12-02 06:40:13 +07:00
|
|
|
struct drm_plane_state base;
|
2014-09-06 03:04:46 +07:00
|
|
|
struct drm_rect src;
|
|
|
|
struct drm_rect dst;
|
|
|
|
struct drm_rect clip;
|
|
|
|
bool visible;
|
2014-12-24 22:59:06 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* used only for sprite planes to determine when to implicitly
|
|
|
|
* enable/disable the primary plane
|
|
|
|
*/
|
|
|
|
bool hides_primary;
|
2014-09-06 03:04:46 +07:00
|
|
|
};
|
|
|
|
|
2015-01-20 19:51:52 +07:00
|
|
|
struct intel_initial_plane_config {
|
2015-02-06 00:22:18 +07:00
|
|
|
struct intel_framebuffer *fb;
|
2015-01-20 19:51:44 +07:00
|
|
|
unsigned int tiling;
|
2014-03-07 23:57:48 +07:00
|
|
|
int size;
|
|
|
|
u32 base;
|
|
|
|
};
|
|
|
|
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state {
|
2015-01-15 19:55:22 +07:00
|
|
|
struct drm_crtc_state base;
|
|
|
|
|
2013-06-06 19:55:52 +07:00
|
|
|
/**
|
|
|
|
* quirks - bitfield with hw state readout quirks
|
|
|
|
*
|
|
|
|
* For various reasons the hw state readout code might not be able to
|
|
|
|
* completely faithfully read out the current state. These cases are
|
|
|
|
* tracked with quirk flags so that fastboot and state checker can act
|
|
|
|
* accordingly.
|
|
|
|
*/
|
2014-04-13 17:00:33 +07:00
|
|
|
#define PIPE_CONFIG_QUIRK_MODE_SYNC_FLAGS (1<<0) /* unreliable sync mode.flags */
|
|
|
|
#define PIPE_CONFIG_QUIRK_INHERITED_MODE (1<<1) /* mode inherited from firmware */
|
2013-06-06 19:55:52 +07:00
|
|
|
unsigned long quirks;
|
|
|
|
|
2013-09-04 22:25:28 +07:00
|
|
|
/* Pipe source size (ie. panel fitter input size)
|
|
|
|
* All planes will be positioned inside this space,
|
|
|
|
* and get clipped at the edges. */
|
|
|
|
int pipe_src_w, pipe_src_h;
|
|
|
|
|
2013-03-27 06:44:55 +07:00
|
|
|
/* Whether to set up the PCH/FDI. Note that we never allow sharing
|
|
|
|
* between pch encoders and cpu encoders. */
|
|
|
|
bool has_pch_encoder;
|
2013-03-27 06:44:56 +07:00
|
|
|
|
2014-11-06 05:26:08 +07:00
|
|
|
/* Are we sending infoframes on the attached port */
|
|
|
|
bool has_infoframe;
|
|
|
|
|
2013-04-18 01:15:07 +07:00
|
|
|
/* CPU Transcoder for the pipe. Currently this can only differ from the
|
|
|
|
* pipe on Haswell (where we have a special eDP transcoder). */
|
|
|
|
enum transcoder cpu_transcoder;
|
|
|
|
|
2013-03-27 06:44:56 +07:00
|
|
|
/*
|
|
|
|
* Use reduced/limited/broadcast rbg range, compressing from the full
|
|
|
|
* range fed into the crtcs.
|
|
|
|
*/
|
|
|
|
bool limited_color_range;
|
|
|
|
|
2013-04-03 04:42:31 +07:00
|
|
|
/* DP has a bunch of special case unfortunately, so mark the pipe
|
|
|
|
* accordingly. */
|
|
|
|
bool has_dp_encoder;
|
2013-04-25 22:54:44 +07:00
|
|
|
|
2014-04-25 04:54:47 +07:00
|
|
|
/* Whether we should send NULL infoframes. Required for audio. */
|
|
|
|
bool has_hdmi_sink;
|
|
|
|
|
2014-04-25 04:54:52 +07:00
|
|
|
/* Audio enabled on this pipe. Only valid if either has_hdmi_sink or
|
|
|
|
* has_dp_encoder is set. */
|
|
|
|
bool has_audio;
|
|
|
|
|
2013-04-25 22:54:44 +07:00
|
|
|
/*
|
|
|
|
* Enable dithering, used when the selected pipe bpp doesn't match the
|
|
|
|
* plane bpp.
|
|
|
|
*/
|
2013-03-27 06:44:57 +07:00
|
|
|
bool dither;
|
2013-03-28 16:42:02 +07:00
|
|
|
|
|
|
|
/* Controls for the clock computation, to override various stages. */
|
|
|
|
bool clock_set;
|
|
|
|
|
2013-04-30 19:01:45 +07:00
|
|
|
/* SDVO TV has a bunch of special case. To make multifunction encoders
|
|
|
|
* work correctly, we need to track this at runtime.*/
|
|
|
|
bool sdvo_tv_clock;
|
|
|
|
|
drm/i915: implement fdi auto-dithering
So on a bunch of setups we only have 2 fdi lanes available, e.g. hsw
VGA or 3 pipes on ivb. And seemingly a lot of modes don't quite fit
into this, among them the default 1080p mode.
The solution is to dither down the pipe a bit so that everything fits,
which this patch implements.
But ports compute their state under the assumption that the bpp they
pick will be the one selected, e.g. the display port bw computations
won't work otherwise. Now we could adjust our code to again up-dither
to the computed DP link parameters, but that's pointless.
So instead when the pipe needs to adjust parameters we need to retry
the pipe_config computation at the encoder stage. Furthermore we need
to inform encoders that they should not increase bandwidth
requirements if possible. This is required for the hdmi code, which
prefers the pipe to up-dither to either of the two possible hdmi bpc
values.
LVDS has a similar requirement, although that's probably only
theoretical in nature: It's unlikely that we'll ever see an 8bpc
high-res lvds panel (which is required to hit the 2 fdi lane limit).
eDP is the only thing which could increase the pipe_bpp setting again,
even when in the retry-loop. This could hit the WARN. Two reasons for
not bothering:
- On many eDP panels we'll get a black screen if the bpp settings
don't match vbt. So failing the modeset is the right thing to do.
But since that also means it's the only way to light up the panel,
it should work. So we shouldn't be able to hit this WARN.
- There are still opens around the eDP panel handling, and maybe we
need additional tricks. Before that happens it's imo no use trying
to be too clever.
Worst case we just need to kill that WARN or maybe fail the compute
config stage if the eDP connector can't get the bpp setting it wants.
And since this can only happen with an fdi link in between and so for
pch eDP panels it's rather unlikely to blow up, if ever.
v2: Rebased on top of a bikeshed from Paulo.
v3: Improve commit message around eDP handling with the stuff
things with Imre.
Reviewed-by: Imre Deak <imre.deak@intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-02-21 06:00:16 +07:00
|
|
|
/*
|
|
|
|
* crtc bandwidth limit, don't increase pipe bpp or clock if not really
|
|
|
|
* required. This is set in the 2nd loop of calling encoder's
|
|
|
|
* ->compute_config if the first pick doesn't work out.
|
|
|
|
*/
|
|
|
|
bool bw_constrained;
|
|
|
|
|
2013-03-28 16:42:02 +07:00
|
|
|
/* Settings for the intel dpll used on pretty much everything but
|
|
|
|
* haswell. */
|
2013-04-19 18:36:51 +07:00
|
|
|
struct dpll dpll;
|
2013-03-28 16:42:02 +07:00
|
|
|
|
2013-06-08 04:10:32 +07:00
|
|
|
/* Selected dpll when shared or DPLL_ID_PRIVATE. */
|
|
|
|
enum intel_dpll_id shared_dpll;
|
|
|
|
|
2014-11-13 21:55:17 +07:00
|
|
|
/*
|
|
|
|
* - PORT_CLK_SEL for DDI ports on HSW/BDW.
|
|
|
|
* - enum skl_dpll on SKL
|
|
|
|
*/
|
2014-06-26 02:01:54 +07:00
|
|
|
uint32_t ddi_pll_sel;
|
|
|
|
|
2013-06-05 18:34:20 +07:00
|
|
|
/* Actual register state of the dpll, for shared dpll cross-checking. */
|
|
|
|
struct intel_dpll_hw_state dpll_hw_state;
|
|
|
|
|
2013-03-27 06:44:57 +07:00
|
|
|
int pipe_bpp;
|
drm/i915: clear up the fdi/dp set_m_n confusion
There's a rather decent confusion going on around transcoder m_n
values. So let's clarify:
- All dp encoders need this, either on the pch transcoder if it's a
pch port, or on the cpu transcoder/pipe if it's a cpu port.
- fdi links need to have the right m_n values for the fdi link set in
the cpu transcoder.
To handle the pch vs transcoder stuff a bit better, extract transcoder
set_m_n helpers. To make them simpler, set intel_crtc->cpu_transcoder
als in ironlake_crtc_mode_set, so that gen5+ (where the cpu m_n
registers are all at the same offset) can use it.
Haswell modeset is decently confused about dp vs. edp vs. fdi. dp vs.
edp works exactly the same as dp (since there's no pch dp any more),
so use that as a check. And only set up the fdi m_n values if we
really have a pch encoder present (which means we have a VGA encoder).
On ilk+ we've called ironlake_set_m_n both for cpu_edp and for pch
encoders. Now that dp_set_m_n handles all dp links (thanks to the
pch encoder check), we can ditch the cpu_edp stuff from the
fdi_set_m_n function.
Since the dp_m_n values are not readily available, we need to
carefully coax the edp values out of the encoder. Hence we can't (yet)
kill this superflous complexity.
v2: Rebase on top of the ivb fdi B/C check patch - we need to properly
clear intel_crtc->fdi_lane, otherwise those checks will misfire.
v3: Rebased on top of a s/IS_HASWELL/HAS_DDI/ patch from Paulo Zanoni.
v4: Drop the addition of has_dp_encoder, it's in the wrong patch (Jesse).
Reviewed-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-04-03 04:38:10 +07:00
|
|
|
struct intel_link_m_n dp_m_n;
|
2013-06-01 22:16:21 +07:00
|
|
|
|
2014-04-05 13:43:28 +07:00
|
|
|
/* m2_n2 for eDP downclock */
|
|
|
|
struct intel_link_m_n dp_m2_n2;
|
2014-08-05 21:51:22 +07:00
|
|
|
bool has_drrs;
|
2014-04-05 13:43:28 +07:00
|
|
|
|
2013-06-01 22:16:21 +07:00
|
|
|
/*
|
|
|
|
* Frequence the dpll for the port should run at. Differs from the
|
2013-09-07 03:28:59 +07:00
|
|
|
* adjusted dotclock e.g. for DP or 12bpc hdmi mode. This is also
|
|
|
|
* already multiplied by pixel_multiplier.
|
2013-03-28 16:41:58 +07:00
|
|
|
*/
|
2013-06-01 22:16:21 +07:00
|
|
|
int port_clock;
|
|
|
|
|
2013-03-27 06:44:53 +07:00
|
|
|
/* Used by SDVO (and if we ever fix it, HDMI). */
|
|
|
|
unsigned pixel_multiplier;
|
2013-04-26 02:55:01 +07:00
|
|
|
|
|
|
|
/* Panel fitter controls for gen2-gen4 + VLV */
|
2013-04-26 02:55:02 +07:00
|
|
|
struct {
|
|
|
|
u32 control;
|
|
|
|
u32 pgm_ratios;
|
2013-04-26 03:52:16 +07:00
|
|
|
u32 lvds_border_bits;
|
2013-04-26 02:55:02 +07:00
|
|
|
} gmch_pfit;
|
|
|
|
|
|
|
|
/* Panel fitter placement and size for Ironlake+ */
|
|
|
|
struct {
|
|
|
|
u32 pos;
|
|
|
|
u32 size;
|
2013-08-27 23:04:17 +07:00
|
|
|
bool enabled;
|
2014-05-29 19:10:22 +07:00
|
|
|
bool force_thru;
|
2013-04-26 02:55:02 +07:00
|
|
|
} pch_pfit;
|
2013-02-14 00:04:45 +07:00
|
|
|
|
2013-02-14 22:54:22 +07:00
|
|
|
/* FDI configuration, only valid if has_pch_encoder is set. */
|
2013-02-14 00:04:45 +07:00
|
|
|
int fdi_lanes;
|
2013-02-14 22:54:22 +07:00
|
|
|
struct intel_link_m_n fdi_m_n;
|
2013-06-01 02:33:22 +07:00
|
|
|
|
|
|
|
bool ips_enabled;
|
2013-09-04 22:30:02 +07:00
|
|
|
|
|
|
|
bool double_wide;
|
2014-05-02 11:02:48 +07:00
|
|
|
|
|
|
|
bool dp_encoder_is_mst;
|
|
|
|
int pbn;
|
2013-03-27 06:44:50 +07:00
|
|
|
};
|
|
|
|
|
2013-10-09 23:17:55 +07:00
|
|
|
struct intel_pipe_wm {
|
|
|
|
struct intel_wm_level wm[5];
|
|
|
|
uint32_t linetime;
|
|
|
|
bool fbc_wm_enabled;
|
2014-03-07 23:32:09 +07:00
|
|
|
bool pipe_enabled;
|
|
|
|
bool sprites_enabled;
|
|
|
|
bool sprites_scaled;
|
2013-10-09 23:17:55 +07:00
|
|
|
};
|
|
|
|
|
drm/i915: Replaced Blitter ring based flips with MMIO flips
This patch enables the framework for using MMIO based flip calls,
in contrast with the CS based flip calls which are being used currently.
MMIO based flip calls can be enabled on architectures where
Render and Blitter engines reside in different power wells. The
decision to use MMIO flips can be made based on workloads to give
100% residency for Media power well.
v2: The MMIO flips now use the interrupt driven mechanism for issuing the
flips when target seqno is reached. (Incorporating Ville's idea)
v3: Rebasing on latest code. Code restructuring after incorporating
Damien's comments
v4: Addressing Ville's review comments
-general cleanup
-updating only base addr instead of calling update_primary_plane
-extending patch for gen5+ platforms
v5: Addressed Ville's review comments
-Making mmio flip vs cs flip selection based on module parameter
-Adding check for DRIVER_MODESET feature in notify_ring before calling
notify mmio flip.
-Other changes mostly in function arguments
v6: -Having a seperate function to check condition for using mmio flips (Ville)
-propogating error code from i915_gem_check_olr (Ville)
v7: -Adding __must_check with i915_gem_check_olr (Chris)
-Renaming mmio_flip_data to mmio_flip (Chris)
-Rebasing on latest nightly
v8: -Rebasing on latest code
-squash 3rd patch in series(mmio setbase vs page flip race) with this patch
-Added new tiling mode update in intel_do_mmio_flip (Chris)
v9: -check for obj->last_write_seqno being 0 instead of obj->ring being NULL in
intel_postpone_flip, as this is a more restrictive condition (Chris)
v10: -Applied Chris's suggestions for squashing patches 2,3 into this patch.
These patches make the selection of CS vs MMIO flip at the page flip time, and
make the module parameter for using mmio flips as tristate, the states being
'force CS flips', 'force mmio flips', 'driver discretion'.
Changed the logic for driver discretion (Chris)
v11: Minor code cleanup(better readability, fixing whitespace errors, using
lockdep to check mutex locked status in postpone_flip, removal of __must_check
in function definition) (Chris)
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Sourab Gupta <sourab.gupta@intel.com>
Signed-off-by: Akash Goel <akash.goel@intel.com>
Tested-by: Chris Wilson <chris@chris-wilson.co.uk> # snb, ivb
[danvet: Fix up parameter alignement checkpatch spotted.]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-06-02 18:17:17 +07:00
|
|
|
struct intel_mmio_flip {
|
2014-11-25 01:49:34 +07:00
|
|
|
struct drm_i915_gem_request *req;
|
2014-10-28 20:10:14 +07:00
|
|
|
struct work_struct work;
|
drm/i915: Replaced Blitter ring based flips with MMIO flips
This patch enables the framework for using MMIO based flip calls,
in contrast with the CS based flip calls which are being used currently.
MMIO based flip calls can be enabled on architectures where
Render and Blitter engines reside in different power wells. The
decision to use MMIO flips can be made based on workloads to give
100% residency for Media power well.
v2: The MMIO flips now use the interrupt driven mechanism for issuing the
flips when target seqno is reached. (Incorporating Ville's idea)
v3: Rebasing on latest code. Code restructuring after incorporating
Damien's comments
v4: Addressing Ville's review comments
-general cleanup
-updating only base addr instead of calling update_primary_plane
-extending patch for gen5+ platforms
v5: Addressed Ville's review comments
-Making mmio flip vs cs flip selection based on module parameter
-Adding check for DRIVER_MODESET feature in notify_ring before calling
notify mmio flip.
-Other changes mostly in function arguments
v6: -Having a seperate function to check condition for using mmio flips (Ville)
-propogating error code from i915_gem_check_olr (Ville)
v7: -Adding __must_check with i915_gem_check_olr (Chris)
-Renaming mmio_flip_data to mmio_flip (Chris)
-Rebasing on latest nightly
v8: -Rebasing on latest code
-squash 3rd patch in series(mmio setbase vs page flip race) with this patch
-Added new tiling mode update in intel_do_mmio_flip (Chris)
v9: -check for obj->last_write_seqno being 0 instead of obj->ring being NULL in
intel_postpone_flip, as this is a more restrictive condition (Chris)
v10: -Applied Chris's suggestions for squashing patches 2,3 into this patch.
These patches make the selection of CS vs MMIO flip at the page flip time, and
make the module parameter for using mmio flips as tristate, the states being
'force CS flips', 'force mmio flips', 'driver discretion'.
Changed the logic for driver discretion (Chris)
v11: Minor code cleanup(better readability, fixing whitespace errors, using
lockdep to check mutex locked status in postpone_flip, removal of __must_check
in function definition) (Chris)
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Sourab Gupta <sourab.gupta@intel.com>
Signed-off-by: Akash Goel <akash.goel@intel.com>
Tested-by: Chris Wilson <chris@chris-wilson.co.uk> # snb, ivb
[danvet: Fix up parameter alignement checkpatch spotted.]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-06-02 18:17:17 +07:00
|
|
|
};
|
|
|
|
|
2014-11-05 00:06:40 +07:00
|
|
|
struct skl_pipe_wm {
|
|
|
|
struct skl_wm_level wm[8];
|
|
|
|
struct skl_wm_level trans_wm;
|
|
|
|
uint32_t linetime;
|
|
|
|
};
|
|
|
|
|
2014-12-24 22:59:06 +07:00
|
|
|
/*
|
|
|
|
* Tracking of operations that need to be performed at the beginning/end of an
|
|
|
|
* atomic commit, outside the atomic section where interrupts are disabled.
|
|
|
|
* These are generally operations that grab mutexes or might otherwise sleep
|
|
|
|
* and thus can't be run with interrupts disabled.
|
|
|
|
*/
|
|
|
|
struct intel_crtc_atomic_commit {
|
2014-12-24 01:41:50 +07:00
|
|
|
/* vblank evasion */
|
|
|
|
bool evade;
|
|
|
|
unsigned start_vbl_count;
|
|
|
|
|
2014-12-24 22:59:06 +07:00
|
|
|
/* Sleepable operations to perform before commit */
|
|
|
|
bool wait_for_flips;
|
|
|
|
bool disable_fbc;
|
|
|
|
bool pre_disable_primary;
|
|
|
|
bool update_wm;
|
2014-12-24 01:41:52 +07:00
|
|
|
unsigned disabled_planes;
|
2014-12-24 22:59:06 +07:00
|
|
|
|
|
|
|
/* Sleepable operations to perform after commit */
|
|
|
|
unsigned fb_bits;
|
|
|
|
bool wait_vblank;
|
|
|
|
bool update_fbc;
|
|
|
|
bool post_enable_primary;
|
|
|
|
unsigned update_sprite_watermarks;
|
|
|
|
};
|
|
|
|
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
struct intel_crtc {
|
|
|
|
struct drm_crtc base;
|
2009-09-11 05:28:06 +07:00
|
|
|
enum pipe pipe;
|
|
|
|
enum plane plane;
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
u8 lut_r[256], lut_g[256], lut_b[256];
|
2012-07-02 16:43:47 +07:00
|
|
|
/*
|
|
|
|
* Whether the crtc and the connected output pipeline is active. Implies
|
|
|
|
* that crtc->enabled is set, i.e. the current mode configuration has
|
|
|
|
* some outputs connected to this crtc.
|
|
|
|
*/
|
|
|
|
bool active;
|
2013-10-16 21:25:52 +07:00
|
|
|
unsigned long enabled_power_domains;
|
2013-10-09 21:24:58 +07:00
|
|
|
bool primary_enabled; /* is the primary plane (partially) visible? */
|
2009-08-18 03:31:43 +07:00
|
|
|
bool lowfreq_avail;
|
2009-09-16 03:57:34 +07:00
|
|
|
struct intel_overlay *overlay;
|
2009-11-18 23:25:18 +07:00
|
|
|
struct intel_unpin_work *unpin_work;
|
2010-07-09 14:45:04 +07:00
|
|
|
|
2012-11-01 16:26:26 +07:00
|
|
|
atomic_t unpin_work_count;
|
|
|
|
|
2012-07-05 17:17:29 +07:00
|
|
|
/* Display surface base address adjustement for pageflips. Note that on
|
|
|
|
* gen4+ this only adjusts up to a tile, offsets within a tile are
|
|
|
|
* handled in the hw itself (with the TILEOFF register). */
|
|
|
|
unsigned long dspaddr_offset;
|
|
|
|
|
2010-11-09 02:18:58 +07:00
|
|
|
struct drm_i915_gem_object *cursor_bo;
|
2010-07-09 14:45:04 +07:00
|
|
|
uint32_t cursor_addr;
|
2014-05-30 20:35:26 +07:00
|
|
|
uint32_t cursor_cntl;
|
2014-08-13 15:57:05 +07:00
|
|
|
uint32_t cursor_size;
|
2014-05-30 20:35:26 +07:00
|
|
|
uint32_t cursor_base;
|
2011-10-12 23:51:31 +07:00
|
|
|
|
2015-01-20 19:51:52 +07:00
|
|
|
struct intel_initial_plane_config plane_config;
|
2015-01-15 19:55:25 +07:00
|
|
|
struct intel_crtc_state *config;
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *new_config;
|
2014-01-10 16:28:06 +07:00
|
|
|
bool new_enabled;
|
2013-03-27 06:44:50 +07:00
|
|
|
|
2013-01-29 23:13:34 +07:00
|
|
|
/* reset counter value when the last flip was submitted */
|
|
|
|
unsigned int reset_counter;
|
drm/i915: report Gen5+ CPU and PCH FIFO underruns
In this commit we enable both CPU and PCH FIFO underrun reporting and
start reporting them. We follow a few rules:
- after we receive one of these errors, we mask the interrupt, so
we won't get an "interrupt storm" and we also won't flood dmesg;
- at each mode set we enable the interrupts again, so we'll see each
message at most once per mode set;
- in the specific places where we need to ignore the errors, we
completely mask the interrupts.
The downside of this patch is that since we're completely disabling
(masking) the interrupts instead of just not printing error messages,
we will mask more than just what we want on IVB/HSW CPU interrupts
(due to GEN7_ERR_INT) and on CPT/PPT/LPT PCHs (due to SERR_INT). So
when we decide to mask PCH FIFO underruns for pipe A on CPT, we'll
also be masking PCH FIFO underruns for pipe B, because both are
reported by SERR_INT, which has to be either completely enabled or
completely disabled (in othe words, there's no way to disable/enable
specific bits of GEN7_ERR_INT and SERR_INT).
V2: Rename some functions and variables, downgrade messages to
DRM_DEBUG_DRIVER and rebase.
Signed-off-by: Paulo Zanoni <paulo.r.zanoni@intel.com>
Reviewed-by: Imre Deak <imre.deak@intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-04-13 03:57:57 +07:00
|
|
|
|
|
|
|
/* Access to these should be protected by dev_priv->irq_lock. */
|
|
|
|
bool cpu_fifo_underrun_disabled;
|
|
|
|
bool pch_fifo_underrun_disabled;
|
2013-10-09 23:17:55 +07:00
|
|
|
|
|
|
|
/* per-pipe watermark state */
|
|
|
|
struct {
|
|
|
|
/* watermarks currently being used */
|
|
|
|
struct intel_pipe_wm active;
|
2014-11-05 00:06:40 +07:00
|
|
|
/* SKL wm values currently in use */
|
|
|
|
struct skl_pipe_wm skl_active;
|
2013-10-09 23:17:55 +07:00
|
|
|
} wm;
|
2014-04-29 17:35:46 +07:00
|
|
|
|
2014-05-16 00:23:23 +07:00
|
|
|
int scanline_offset;
|
drm/i915: Replaced Blitter ring based flips with MMIO flips
This patch enables the framework for using MMIO based flip calls,
in contrast with the CS based flip calls which are being used currently.
MMIO based flip calls can be enabled on architectures where
Render and Blitter engines reside in different power wells. The
decision to use MMIO flips can be made based on workloads to give
100% residency for Media power well.
v2: The MMIO flips now use the interrupt driven mechanism for issuing the
flips when target seqno is reached. (Incorporating Ville's idea)
v3: Rebasing on latest code. Code restructuring after incorporating
Damien's comments
v4: Addressing Ville's review comments
-general cleanup
-updating only base addr instead of calling update_primary_plane
-extending patch for gen5+ platforms
v5: Addressed Ville's review comments
-Making mmio flip vs cs flip selection based on module parameter
-Adding check for DRIVER_MODESET feature in notify_ring before calling
notify mmio flip.
-Other changes mostly in function arguments
v6: -Having a seperate function to check condition for using mmio flips (Ville)
-propogating error code from i915_gem_check_olr (Ville)
v7: -Adding __must_check with i915_gem_check_olr (Chris)
-Renaming mmio_flip_data to mmio_flip (Chris)
-Rebasing on latest nightly
v8: -Rebasing on latest code
-squash 3rd patch in series(mmio setbase vs page flip race) with this patch
-Added new tiling mode update in intel_do_mmio_flip (Chris)
v9: -check for obj->last_write_seqno being 0 instead of obj->ring being NULL in
intel_postpone_flip, as this is a more restrictive condition (Chris)
v10: -Applied Chris's suggestions for squashing patches 2,3 into this patch.
These patches make the selection of CS vs MMIO flip at the page flip time, and
make the module parameter for using mmio flips as tristate, the states being
'force CS flips', 'force mmio flips', 'driver discretion'.
Changed the logic for driver discretion (Chris)
v11: Minor code cleanup(better readability, fixing whitespace errors, using
lockdep to check mutex locked status in postpone_flip, removal of __must_check
in function definition) (Chris)
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Sourab Gupta <sourab.gupta@intel.com>
Signed-off-by: Akash Goel <akash.goel@intel.com>
Tested-by: Chris Wilson <chris@chris-wilson.co.uk> # snb, ivb
[danvet: Fix up parameter alignement checkpatch spotted.]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-06-02 18:17:17 +07:00
|
|
|
struct intel_mmio_flip mmio_flip;
|
2014-12-24 22:59:06 +07:00
|
|
|
|
|
|
|
struct intel_crtc_atomic_commit atomic;
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
};
|
|
|
|
|
2013-08-07 17:29:50 +07:00
|
|
|
struct intel_plane_wm_parameters {
|
|
|
|
uint32_t horiz_pixels;
|
2014-07-15 14:21:24 +07:00
|
|
|
uint32_t vert_pixels;
|
2013-08-07 17:29:50 +07:00
|
|
|
uint8_t bytes_per_pixel;
|
|
|
|
bool enabled;
|
|
|
|
bool scaled;
|
2015-02-27 22:12:35 +07:00
|
|
|
u64 tiling;
|
2013-08-07 17:29:50 +07:00
|
|
|
};
|
|
|
|
|
2011-12-14 04:19:38 +07:00
|
|
|
struct intel_plane {
|
|
|
|
struct drm_plane base;
|
2013-04-03 01:22:20 +07:00
|
|
|
int plane;
|
2011-12-14 04:19:38 +07:00
|
|
|
enum pipe pipe;
|
|
|
|
struct drm_i915_gem_object *obj;
|
2012-10-23 00:19:27 +07:00
|
|
|
bool can_scale;
|
2011-12-14 04:19:38 +07:00
|
|
|
int max_downscale;
|
2013-05-24 21:59:18 +07:00
|
|
|
|
|
|
|
/* Since we need to change the watermarks before/after
|
|
|
|
* enabling/disabling the planes, we need to store the parameters here
|
|
|
|
* as the other pieces of the struct may not reflect the values we want
|
|
|
|
* for the watermark calculations. Currently only Haswell uses this.
|
|
|
|
*/
|
2013-08-07 17:29:50 +07:00
|
|
|
struct intel_plane_wm_parameters wm;
|
2013-05-24 21:59:18 +07:00
|
|
|
|
2015-01-22 07:35:41 +07:00
|
|
|
/*
|
|
|
|
* NOTE: Do not place new plane state fields here (e.g., when adding
|
|
|
|
* new plane properties). New runtime state should now be placed in
|
|
|
|
* the intel_plane_state structure and accessed via drm_plane->state.
|
|
|
|
*/
|
|
|
|
|
2011-12-14 04:19:38 +07:00
|
|
|
void (*update_plane)(struct drm_plane *plane,
|
2013-08-07 02:24:09 +07:00
|
|
|
struct drm_crtc *crtc,
|
2011-12-14 04:19:38 +07:00
|
|
|
struct drm_framebuffer *fb,
|
|
|
|
struct drm_i915_gem_object *obj,
|
|
|
|
int crtc_x, int crtc_y,
|
|
|
|
unsigned int crtc_w, unsigned int crtc_h,
|
|
|
|
uint32_t x, uint32_t y,
|
|
|
|
uint32_t src_w, uint32_t src_h);
|
2013-08-07 02:24:09 +07:00
|
|
|
void (*disable_plane)(struct drm_plane *plane,
|
|
|
|
struct drm_crtc *crtc);
|
2014-12-02 06:40:16 +07:00
|
|
|
int (*check_plane)(struct drm_plane *plane,
|
|
|
|
struct intel_plane_state *state);
|
|
|
|
void (*commit_plane)(struct drm_plane *plane,
|
|
|
|
struct intel_plane_state *state);
|
2012-01-03 23:05:39 +07:00
|
|
|
int (*update_colorkey)(struct drm_plane *plane,
|
|
|
|
struct drm_intel_sprite_colorkey *key);
|
|
|
|
void (*get_colorkey)(struct drm_plane *plane,
|
|
|
|
struct drm_intel_sprite_colorkey *key);
|
2011-12-14 04:19:38 +07:00
|
|
|
};
|
|
|
|
|
2012-04-17 08:20:35 +07:00
|
|
|
struct intel_watermark_params {
|
|
|
|
unsigned long fifo_size;
|
|
|
|
unsigned long max_wm;
|
|
|
|
unsigned long default_wm;
|
|
|
|
unsigned long guard_size;
|
|
|
|
unsigned long cacheline_size;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct cxsr_latency {
|
|
|
|
int is_desktop;
|
|
|
|
int is_ddr3;
|
|
|
|
unsigned long fsb_freq;
|
|
|
|
unsigned long mem_freq;
|
|
|
|
unsigned long display_sr;
|
|
|
|
unsigned long display_hpll_disable;
|
|
|
|
unsigned long cursor_sr;
|
|
|
|
unsigned long cursor_hpll_disable;
|
|
|
|
};
|
|
|
|
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
#define to_intel_crtc(x) container_of(x, struct intel_crtc, base)
|
2010-03-30 13:39:28 +07:00
|
|
|
#define to_intel_connector(x) container_of(x, struct intel_connector, base)
|
2010-09-09 21:14:28 +07:00
|
|
|
#define to_intel_encoder(x) container_of(x, struct intel_encoder, base)
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
#define to_intel_framebuffer(x) container_of(x, struct intel_framebuffer, base)
|
2011-12-14 04:19:38 +07:00
|
|
|
#define to_intel_plane(x) container_of(x, struct intel_plane, base)
|
2014-12-24 01:41:52 +07:00
|
|
|
#define to_intel_plane_state(x) container_of(x, struct intel_plane_state, base)
|
2014-07-08 08:21:47 +07:00
|
|
|
#define intel_fb_obj(x) (x ? to_intel_framebuffer(x)->obj : NULL)
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
|
2012-05-10 01:37:30 +07:00
|
|
|
struct intel_hdmi {
|
2013-02-19 05:00:26 +07:00
|
|
|
u32 hdmi_reg;
|
2012-05-10 01:37:30 +07:00
|
|
|
int ddc_bus;
|
|
|
|
uint32_t color_range;
|
2013-01-17 21:31:29 +07:00
|
|
|
bool color_range_auto;
|
2012-05-10 01:37:30 +07:00
|
|
|
bool has_hdmi_sink;
|
|
|
|
bool has_audio;
|
|
|
|
enum hdmi_force_audio force_audio;
|
2013-01-17 21:31:31 +07:00
|
|
|
bool rgb_quant_range_selectable;
|
2014-06-11 12:36:01 +07:00
|
|
|
enum hdmi_picture_aspect aspect_ratio;
|
2012-05-10 01:37:30 +07:00
|
|
|
void (*write_infoframe)(struct drm_encoder *encoder,
|
2013-08-07 02:32:18 +07:00
|
|
|
enum hdmi_infoframe_type type,
|
2013-12-10 20:19:08 +07:00
|
|
|
const void *frame, ssize_t len);
|
2012-05-29 02:42:48 +07:00
|
|
|
void (*set_infoframes)(struct drm_encoder *encoder,
|
2014-04-25 04:54:47 +07:00
|
|
|
bool enable,
|
2012-05-29 02:42:48 +07:00
|
|
|
struct drm_display_mode *adjusted_mode);
|
2014-11-06 05:26:08 +07:00
|
|
|
bool (*infoframe_enabled)(struct drm_encoder *encoder);
|
2012-05-10 01:37:30 +07:00
|
|
|
};
|
|
|
|
|
2014-05-02 11:02:48 +07:00
|
|
|
struct intel_dp_mst_encoder;
|
2012-09-18 21:58:49 +07:00
|
|
|
#define DP_MAX_DOWNSTREAM_PORTS 0x10
|
2012-06-30 02:03:35 +07:00
|
|
|
|
2015-02-13 17:02:59 +07:00
|
|
|
/*
|
|
|
|
* enum link_m_n_set:
|
|
|
|
* When platform provides two set of M_N registers for dp, we can
|
|
|
|
* program them and switch between them incase of DRRS.
|
|
|
|
* But When only one such register is provided, we have to program the
|
|
|
|
* required divider value on that registers itself based on the DRRS state.
|
|
|
|
*
|
|
|
|
* M1_N1 : Program dp_m_n on M1_N1 registers
|
|
|
|
* dp_m2_n2 on M2_N2 registers (If supported)
|
|
|
|
*
|
|
|
|
* M2_N2 : Program dp_m2_n2 on M1_N1 registers
|
|
|
|
* M2_N2 registers are not supported
|
|
|
|
*/
|
|
|
|
|
|
|
|
enum link_m_n_set {
|
|
|
|
/* Sets the m1_n1 and m2_n2 */
|
|
|
|
M1_N1 = 0,
|
|
|
|
M2_N2
|
|
|
|
};
|
|
|
|
|
2012-06-30 02:03:35 +07:00
|
|
|
struct intel_dp {
|
|
|
|
uint32_t output_reg;
|
2013-02-19 05:00:25 +07:00
|
|
|
uint32_t aux_ch_ctl_reg;
|
2012-06-30 02:03:35 +07:00
|
|
|
uint32_t DP;
|
|
|
|
bool has_audio;
|
|
|
|
enum hdmi_force_audio force_audio;
|
|
|
|
uint32_t color_range;
|
2013-01-17 21:31:29 +07:00
|
|
|
bool color_range_auto;
|
2012-06-30 02:03:35 +07:00
|
|
|
uint8_t link_bw;
|
2015-03-05 11:32:30 +07:00
|
|
|
uint8_t rate_select;
|
2012-06-30 02:03:35 +07:00
|
|
|
uint8_t lane_count;
|
|
|
|
uint8_t dpcd[DP_RECEIVER_CAP_SIZE];
|
2013-07-12 04:44:56 +07:00
|
|
|
uint8_t psr_dpcd[EDP_PSR_RECEIVER_CAP_SIZE];
|
2012-09-18 21:58:49 +07:00
|
|
|
uint8_t downstream_ports[DP_MAX_DOWNSTREAM_PORTS];
|
2015-03-14 00:40:31 +07:00
|
|
|
/* sink rates as reported by DP_SUPPORTED_LINK_RATES */
|
|
|
|
uint8_t num_sink_rates;
|
|
|
|
int sink_rates[DP_MAX_SUPPORTED_RATES];
|
2014-03-14 21:51:15 +07:00
|
|
|
struct drm_dp_aux aux;
|
2012-06-30 02:03:35 +07:00
|
|
|
uint8_t train_set[4];
|
|
|
|
int panel_power_up_delay;
|
|
|
|
int panel_power_down_delay;
|
|
|
|
int panel_power_cycle_delay;
|
|
|
|
int backlight_on_delay;
|
|
|
|
int backlight_off_delay;
|
|
|
|
struct delayed_work panel_vdd_work;
|
|
|
|
bool want_panel_vdd;
|
2013-12-19 23:29:40 +07:00
|
|
|
unsigned long last_power_cycle;
|
|
|
|
unsigned long last_power_on;
|
|
|
|
unsigned long last_backlight_off;
|
2014-08-05 06:04:59 +07:00
|
|
|
|
2014-07-08 03:01:46 +07:00
|
|
|
struct notifier_block edp_notifier;
|
|
|
|
|
2014-09-04 18:54:20 +07:00
|
|
|
/*
|
|
|
|
* Pipe whose power sequencer is currently locked into
|
|
|
|
* this port. Only relevant on VLV/CHV.
|
|
|
|
*/
|
|
|
|
enum pipe pps_pipe;
|
2014-10-17 01:27:30 +07:00
|
|
|
struct edp_power_seq pps_delays;
|
2014-09-04 18:54:20 +07:00
|
|
|
|
2014-01-21 00:19:39 +07:00
|
|
|
bool use_tps3;
|
2014-05-02 11:02:48 +07:00
|
|
|
bool can_mst; /* this port supports mst */
|
|
|
|
bool is_mst;
|
|
|
|
int active_mst_links;
|
|
|
|
/* connector directly attached - won't be use for modeset in mst world */
|
2012-10-19 18:51:50 +07:00
|
|
|
struct intel_connector *attached_connector;
|
2014-01-21 20:35:39 +07:00
|
|
|
|
2014-05-02 11:02:48 +07:00
|
|
|
/* mst connector list */
|
|
|
|
struct intel_dp_mst_encoder *mst_encoders[I915_MAX_PIPES];
|
|
|
|
struct drm_dp_mst_topology_mgr mst_mgr;
|
|
|
|
|
2014-01-21 20:35:39 +07:00
|
|
|
uint32_t (*get_aux_clock_divider)(struct intel_dp *dp, int index);
|
2014-01-21 20:37:15 +07:00
|
|
|
/*
|
|
|
|
* This function returns the value we have to program the AUX_CTL
|
|
|
|
* register with to kick off an AUX transaction.
|
|
|
|
*/
|
|
|
|
uint32_t (*get_aux_send_ctl)(struct intel_dp *dp,
|
|
|
|
bool has_aux_irq,
|
|
|
|
int send_bytes,
|
|
|
|
uint32_t aux_clock_divider);
|
2012-06-30 02:03:35 +07:00
|
|
|
};
|
|
|
|
|
2012-10-27 04:05:46 +07:00
|
|
|
struct intel_digital_port {
|
|
|
|
struct intel_encoder base;
|
2012-10-27 04:05:50 +07:00
|
|
|
enum port port;
|
2013-07-13 03:54:41 +07:00
|
|
|
u32 saved_port_bits;
|
2012-10-27 04:05:46 +07:00
|
|
|
struct intel_dp dp;
|
|
|
|
struct intel_hdmi hdmi;
|
2015-01-23 12:00:31 +07:00
|
|
|
enum irqreturn (*hpd_pulse)(struct intel_digital_port *, bool);
|
2012-10-27 04:05:46 +07:00
|
|
|
};
|
|
|
|
|
2014-05-02 11:02:48 +07:00
|
|
|
struct intel_dp_mst_encoder {
|
|
|
|
struct intel_encoder base;
|
|
|
|
enum pipe pipe;
|
|
|
|
struct intel_digital_port *primary;
|
|
|
|
void *port; /* store this opaque as its illegal to dereference it */
|
|
|
|
};
|
|
|
|
|
2013-04-19 04:51:36 +07:00
|
|
|
static inline int
|
|
|
|
vlv_dport_to_channel(struct intel_digital_port *dport)
|
|
|
|
{
|
|
|
|
switch (dport->port) {
|
|
|
|
case PORT_B:
|
2014-04-09 17:28:15 +07:00
|
|
|
case PORT_D:
|
2013-11-06 13:36:35 +07:00
|
|
|
return DPIO_CH0;
|
2013-04-19 04:51:36 +07:00
|
|
|
case PORT_C:
|
2013-11-06 13:36:35 +07:00
|
|
|
return DPIO_CH1;
|
2013-04-19 04:51:36 +07:00
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-09 17:28:16 +07:00
|
|
|
static inline int
|
|
|
|
vlv_pipe_to_channel(enum pipe pipe)
|
|
|
|
{
|
|
|
|
switch (pipe) {
|
|
|
|
case PIPE_A:
|
|
|
|
case PIPE_C:
|
|
|
|
return DPIO_CH0;
|
|
|
|
case PIPE_B:
|
|
|
|
return DPIO_CH1;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-09 21:44:14 +07:00
|
|
|
static inline struct drm_crtc *
|
|
|
|
intel_get_crtc_for_pipe(struct drm_device *dev, int pipe)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
return dev_priv->pipe_to_crtc_mapping[pipe];
|
|
|
|
}
|
|
|
|
|
2011-01-19 22:04:42 +07:00
|
|
|
static inline struct drm_crtc *
|
|
|
|
intel_get_crtc_for_plane(struct drm_device *dev, int plane)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
return dev_priv->plane_to_crtc_mapping[plane];
|
|
|
|
}
|
|
|
|
|
2010-09-01 23:47:52 +07:00
|
|
|
struct intel_unpin_work {
|
|
|
|
struct work_struct work;
|
2012-11-01 16:26:26 +07:00
|
|
|
struct drm_crtc *crtc;
|
2015-02-02 22:44:15 +07:00
|
|
|
struct drm_framebuffer *old_fb;
|
2010-11-09 02:18:58 +07:00
|
|
|
struct drm_i915_gem_object *pending_flip_obj;
|
2010-09-01 23:47:52 +07:00
|
|
|
struct drm_pending_vblank_event *event;
|
2012-12-03 18:36:30 +07:00
|
|
|
atomic_t pending;
|
|
|
|
#define INTEL_FLIP_INACTIVE 0
|
|
|
|
#define INTEL_FLIP_PENDING 1
|
|
|
|
#define INTEL_FLIP_COMPLETE 2
|
drm/i915: Fix mmio vs. CS flip race on ILK+
Starting from ILK, mmio flips also cause a flip done interrupt to be
signalled. This means if we first do a set_base and follow it
immediately with the CS flip, we might mistake the flip done interrupt
caused by the set_base as the flip done interrupt caused by the CS
flip.
The hardware has a flip counter which increments every time a mmio or
CS flip is issued. It basically counts the number of DSPSURF register
writes. This means we can sample the counter before we put the CS
flip into the ring, and then when we get a flip done interrupt we can
check whether the CS flip has actually performed the surface address
update, or if the interrupt was caused by a previous but yet
unfinished mmio flip.
Even with the flip counter we still have a race condition of the CS flip
base address update happens after the mmio flip done interrupt was
raised but not yet processed by the driver. When the interrupt is
eventually processed, the flip counter will already indicate that the
CS flip has been executed, but it would not actually complete until the
next start of vblank. We can use the DSPSURFLIVE register to check
whether the hardware is actually scanning out of the buffer we expect,
or if we managed hit this race window.
This covers all the cases where the CS flip actually changes the base
address. If the base address remains unchanged, we might still complete
the CS flip before it has actually completed. But since the address
didn't change anyway, the premature flip completion can't result in
userspace overwriting data that's still being scanned out.
CTG already has the flip counter and DSPSURFLIVE registers, and
although the flip done interrupt is still limited to CS flips alone,
the code now also checks the flip counter on CTG as well.
v2: s/dspsurf/gtt_offset/ (Chris)
Testcase: igt/kms_mmio_vs_cs_flip/setcrtc_vs_cs_flip
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=73027
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Rodrigo Vivi <rodrigo.vivi@gmail.com>
[danvet: Add g4x_ prefix to flip_count_after_eq.]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-04-16 01:41:34 +07:00
|
|
|
u32 flip_count;
|
|
|
|
u32 gtt_offset;
|
2014-11-25 01:49:37 +07:00
|
|
|
struct drm_i915_gem_request *flip_queued_req;
|
drm/i915: Check for a stalled page flip after each vblank
Long ago, back in the racy haydays of 915gm interrupt handling, page
flips would occasionally go astray and leave the hardware stuck, and the
display not updating. This annoyed people who relied on their systems
being able to display continuously updating information 24/7, and so
some code to detect when the driver missed the page flip completion
signal was added. Until recently, it was presumed that the interrupt
handling was now flawless, but once again Simon Farnsworth has found a
system whose display will stall. Reinstate the pageflip stall detection,
which works by checking to see if the hardware has been updated to the
new framebuffer address following each vblank. If the hardware is
scanning out from the new framebuffer, but we still think the flip is
pending, then we kick our driver into submision.
This is a continuation of the effort started with
commit 4e5359cd053bfb7d8dabe4a63624a5726848ffbc
Author: Simon Farnsworth <simon.farnsworth@onelan.co.uk>
Date: Wed Sep 1 17:47:52 2010 +0100
drm/i915: Avoid pageflipping freeze when we miss the flip prepare interrupt
This now includes a belt-and-braces approach to make sure the driver
(or the hardware) doesn't miss an interrupt and cause us to stop
updating the display should the unthinkable happen and the pageflip fail - i.e.
that the user is able to continue submitting flips.
v2: Cleanup, refactor, and rename
v3: Only start counting vblanks after the flip command has been seen by
the hardware.
v4: Record the seqno after we touch the ring, or else there may be no
seqno allocated yet.
v5: Rebase on mmio-flip.
v6: Rebase, rebase.
Reported-by: Simon Farnsworth <simon@farnz.org.uk>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=75502
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com> [v4]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-09-05 13:13:24 +07:00
|
|
|
int flip_queued_vblank;
|
|
|
|
int flip_ready_vblank;
|
2010-09-01 23:47:52 +07:00
|
|
|
bool enable_stall_check;
|
|
|
|
};
|
|
|
|
|
2012-07-05 03:16:09 +07:00
|
|
|
struct intel_set_config {
|
2012-07-05 21:20:48 +07:00
|
|
|
struct drm_encoder **save_connector_encoders;
|
|
|
|
struct drm_crtc **save_encoder_crtcs;
|
2014-01-10 16:28:06 +07:00
|
|
|
bool *save_crtc_enabled;
|
2012-07-05 03:41:29 +07:00
|
|
|
|
|
|
|
bool fb_changed;
|
|
|
|
bool mode_changed;
|
2012-07-05 03:16:09 +07:00
|
|
|
};
|
|
|
|
|
2013-09-24 23:52:53 +07:00
|
|
|
struct intel_load_detect_pipe {
|
|
|
|
struct drm_framebuffer *release_fb;
|
|
|
|
bool load_detect_temp;
|
|
|
|
int dpms_mode;
|
|
|
|
};
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
|
2013-09-24 23:52:53 +07:00
|
|
|
static inline struct intel_encoder *
|
|
|
|
intel_attached_encoder(struct drm_connector *connector)
|
2010-09-09 22:20:55 +07:00
|
|
|
{
|
|
|
|
return to_intel_connector(connector)->encoder;
|
|
|
|
}
|
|
|
|
|
2012-10-27 04:05:46 +07:00
|
|
|
static inline struct intel_digital_port *
|
|
|
|
enc_to_dig_port(struct drm_encoder *encoder)
|
|
|
|
{
|
|
|
|
return container_of(encoder, struct intel_digital_port, base.base);
|
2013-05-08 17:14:02 +07:00
|
|
|
}
|
|
|
|
|
2014-05-02 11:02:48 +07:00
|
|
|
static inline struct intel_dp_mst_encoder *
|
|
|
|
enc_to_mst(struct drm_encoder *encoder)
|
|
|
|
{
|
|
|
|
return container_of(encoder, struct intel_dp_mst_encoder, base.base);
|
|
|
|
}
|
|
|
|
|
2013-05-08 17:14:02 +07:00
|
|
|
static inline struct intel_dp *enc_to_intel_dp(struct drm_encoder *encoder)
|
|
|
|
{
|
|
|
|
return &enc_to_dig_port(encoder)->dp;
|
2012-10-27 04:05:46 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct intel_digital_port *
|
|
|
|
dp_to_dig_port(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
return container_of(intel_dp, struct intel_digital_port, dp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct intel_digital_port *
|
|
|
|
hdmi_to_dig_port(struct intel_hdmi *intel_hdmi)
|
|
|
|
{
|
|
|
|
return container_of(intel_hdmi, struct intel_digital_port, hdmi);
|
2012-10-16 01:51:29 +07:00
|
|
|
}
|
|
|
|
|
2014-03-28 01:48:33 +07:00
|
|
|
/*
|
|
|
|
* Returns the number of planes for this pipe, ie the number of sprites + 1
|
|
|
|
* (primary plane). This doesn't count the cursor plane then.
|
|
|
|
*/
|
|
|
|
static inline unsigned int intel_num_planes(struct intel_crtc *crtc)
|
|
|
|
{
|
|
|
|
return INTEL_INFO(crtc->base.dev)->num_sprites[crtc->pipe] + 1;
|
|
|
|
}
|
2013-09-24 23:52:53 +07:00
|
|
|
|
2014-09-30 15:56:46 +07:00
|
|
|
/* intel_fifo_underrun.c */
|
2014-09-30 15:56:47 +07:00
|
|
|
bool intel_set_cpu_fifo_underrun_reporting(struct drm_i915_private *dev_priv,
|
2013-09-25 01:48:31 +07:00
|
|
|
enum pipe pipe, bool enable);
|
2014-09-30 15:56:47 +07:00
|
|
|
bool intel_set_pch_fifo_underrun_reporting(struct drm_i915_private *dev_priv,
|
2013-09-25 01:48:31 +07:00
|
|
|
enum transcoder pch_transcoder,
|
|
|
|
bool enable);
|
2014-09-30 15:56:48 +07:00
|
|
|
void intel_cpu_fifo_underrun_irq_handler(struct drm_i915_private *dev_priv,
|
|
|
|
enum pipe pipe);
|
|
|
|
void intel_pch_fifo_underrun_irq_handler(struct drm_i915_private *dev_priv,
|
|
|
|
enum transcoder pch_transcoder);
|
2014-09-30 15:56:47 +07:00
|
|
|
void i9xx_check_fifo_underruns(struct drm_i915_private *dev_priv);
|
2014-09-30 15:56:46 +07:00
|
|
|
|
|
|
|
/* i915_irq.c */
|
2014-07-16 14:49:40 +07:00
|
|
|
void gen5_enable_gt_irq(struct drm_i915_private *dev_priv, uint32_t mask);
|
|
|
|
void gen5_disable_gt_irq(struct drm_i915_private *dev_priv, uint32_t mask);
|
|
|
|
void gen6_enable_pm_irq(struct drm_i915_private *dev_priv, uint32_t mask);
|
|
|
|
void gen6_disable_pm_irq(struct drm_i915_private *dev_priv, uint32_t mask);
|
2014-11-19 20:30:03 +07:00
|
|
|
void gen6_reset_rps_interrupts(struct drm_device *dev);
|
2014-11-06 01:48:48 +07:00
|
|
|
void gen6_enable_rps_interrupts(struct drm_device *dev);
|
|
|
|
void gen6_disable_rps_interrupts(struct drm_device *dev);
|
2014-12-20 00:33:26 +07:00
|
|
|
u32 gen6_sanitize_rps_pm_mask(struct drm_i915_private *dev_priv, u32 mask);
|
2014-09-30 15:56:44 +07:00
|
|
|
void intel_runtime_pm_disable_interrupts(struct drm_i915_private *dev_priv);
|
|
|
|
void intel_runtime_pm_enable_interrupts(struct drm_i915_private *dev_priv);
|
2014-06-20 23:29:20 +07:00
|
|
|
static inline bool intel_irqs_enabled(struct drm_i915_private *dev_priv)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We only use drm_irq_uninstall() at unload and VT switch, so
|
|
|
|
* this is the only thing we need to check.
|
|
|
|
*/
|
2014-09-30 15:56:43 +07:00
|
|
|
return dev_priv->pm.irqs_enabled;
|
2014-06-20 23:29:20 +07:00
|
|
|
}
|
|
|
|
|
2014-04-29 17:35:45 +07:00
|
|
|
int intel_get_crtc_scanline(struct intel_crtc *crtc);
|
2015-03-07 01:50:48 +07:00
|
|
|
void gen8_irq_power_well_post_enable(struct drm_i915_private *dev_priv,
|
|
|
|
unsigned int pipe_mask);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
|
|
|
/* intel_crt.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_crt_init(struct drm_device *dev);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
|
|
|
|
|
|
|
/* intel_ddi.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_prepare_ddi(struct drm_device *dev);
|
|
|
|
void hsw_fdi_link_train(struct drm_crtc *crtc);
|
|
|
|
void intel_ddi_init(struct drm_device *dev, enum port port);
|
|
|
|
enum port intel_ddi_get_encoder_port(struct intel_encoder *intel_encoder);
|
|
|
|
bool intel_ddi_get_hw_state(struct intel_encoder *encoder, enum pipe *pipe);
|
|
|
|
int intel_ddi_get_cdclk_freq(struct drm_i915_private *dev_priv);
|
|
|
|
void intel_ddi_pll_init(struct drm_device *dev);
|
|
|
|
void intel_ddi_enable_transcoder_func(struct drm_crtc *crtc);
|
|
|
|
void intel_ddi_disable_transcoder_func(struct drm_i915_private *dev_priv,
|
|
|
|
enum transcoder cpu_transcoder);
|
|
|
|
void intel_ddi_enable_pipe_clock(struct intel_crtc *intel_crtc);
|
|
|
|
void intel_ddi_disable_pipe_clock(struct intel_crtc *intel_crtc);
|
2015-01-15 19:55:23 +07:00
|
|
|
bool intel_ddi_pll_select(struct intel_crtc *crtc,
|
|
|
|
struct intel_crtc_state *crtc_state);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_ddi_set_pipe_settings(struct drm_crtc *crtc);
|
|
|
|
void intel_ddi_prepare_link_retrain(struct drm_encoder *encoder);
|
|
|
|
bool intel_ddi_connector_get_hw_state(struct intel_connector *intel_connector);
|
|
|
|
void intel_ddi_fdi_disable(struct drm_crtc *crtc);
|
|
|
|
void intel_ddi_get_config(struct intel_encoder *encoder,
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *pipe_config);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
2014-05-02 10:36:43 +07:00
|
|
|
void intel_ddi_init_dp_buf_reg(struct intel_encoder *encoder);
|
2014-05-02 11:02:48 +07:00
|
|
|
void intel_ddi_clock_get(struct intel_encoder *encoder,
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *pipe_config);
|
2014-05-02 11:02:48 +07:00
|
|
|
void intel_ddi_set_vc_payload_alloc(struct drm_crtc *crtc, bool state);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
2014-09-19 23:27:27 +07:00
|
|
|
/* intel_frontbuffer.c */
|
drm/i915: Track frontbuffer invalidation/flushing
So these are the guts of the new beast. This tracks when a frontbuffer
gets invalidated (due to frontbuffer rendering) and hence should be
constantly scaned out, and when it's flushed again and can be
compressed/one-shot-upload.
Rules for flushing are simple: The frontbuffer needs one more full
upload starting from the next vblank. Which means that the flushing
can _only_ be called once the frontbuffer update has been latched.
But this poses a problem for pageflips: We can't just delay the
flushing until the pageflip is latched, since that would pose the risk
that we override frontbuffer rendering that has been scheduled
in-between the pageflip ioctl and the actual latching.
To handle this track asynchronous invalidations (and also pageflip)
state per-ring and delay any in-between flushing until the rendering
has completed. And also cancel any delayed flushing if we get a new
invalidation request (whether delayed or not).
Also call intel_mark_fb_busy in both cases in all cases to make sure
that we keep the screen at the highest refresh rate both on flips,
synchronous plane updates and for frontbuffer rendering.
v2: Lots of improvements
Suggestions from Chris:
- Move invalidate/flush in flush_*_domain and set_to_*_domain.
- Drop the flush in busy_ioctl since it's redundant. Was a leftover
from an earlier concept to track flips/delayed flushes.
- Don't forget about the initial modeset enable/final disable.
Suggested by Chris.
Track flips accurately, too. Since flips complete independently of
rendering we need to track pending flips in a separate mask. Again if
an invalidate happens we need to cancel the evenutal flush to avoid
races.
v3:
Provide correct header declarations for flip functions. Currently not
needed outside of intel_display.c, but part of the proper interface.
v4: Add proper domain management to fbcon so that the fbcon buffer is
also tracked correctly.
v5: Fixup locking around the fbcon set_to_gtt_domain call.
v6: More comments from Chris:
- Split out fbcon changes.
- Drop superflous checks for potential scanout before calling intel_fb
functions - we can micro-optimize this later.
- s/intel_fb_/intel_fb_obj_/ to make it clear that this deals in gem
object. We already have precedence for fb_obj in the pin_and_fence
functions.
v7: Clarify the semantics of the flip flush handling by renaming
things a bit:
- Don't go through a gem object but take the relevant frontbuffer bits
directly. These functions center on the plane, the actual object is
irrelevant - even a flip to the same object as already active should
cause a flush.
- Add a new intel_frontbuffer_flip for synchronous plane updates. It
currently just calls intel_frontbuffer_flush since the implemenation
differs.
This way we achieve a clear split between one-shot update events on
one side and frontbuffer rendering with potentially a very long delay
between the invalidate and flush.
Chris and I also had some discussions about mark_busy and whether it
is appropriate to call from flush. But mark busy is a state which
should be derived from the 3 events (invalidate, flush, flip) we now
have by the users, like psr does by tracking relevant information in
psr.busy_frontbuffer_bits. DRRS (the only real use of mark_busy for
frontbuffer) needs to have similar logic. With that the overall
mark_busy in the core could be removed.
v8: Only when retiring gpu buffers only flush frontbuffer bits we
actually invalidated in a batch. Just for safety since before any
additional usage/invalidate we should always retire current rendering.
Suggested by Chris Wilson.
v9: Actually use intel_frontbuffer_flip in all appropriate places.
Spotted by Chris.
v10: Address more comments from Chris:
- Don't call _flip in set_base when the crtc is inactive, avoids redunancy
in the modeset case with the initial enabling of all planes.
- Add comments explaining that the initial/final plane enable/disable
still has work left to do before it's fully generic.
v11: Only invalidate for gtt/cpu access when writing. Spotted by Chris.
v12: s/_flush/_flip/ in intel_overlay.c per Chris' comment.
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-06-19 21:01:59 +07:00
|
|
|
void intel_fb_obj_invalidate(struct drm_i915_gem_object *obj,
|
2015-02-14 02:23:44 +07:00
|
|
|
struct intel_engine_cs *ring,
|
|
|
|
enum fb_op_origin origin);
|
drm/i915: Track frontbuffer invalidation/flushing
So these are the guts of the new beast. This tracks when a frontbuffer
gets invalidated (due to frontbuffer rendering) and hence should be
constantly scaned out, and when it's flushed again and can be
compressed/one-shot-upload.
Rules for flushing are simple: The frontbuffer needs one more full
upload starting from the next vblank. Which means that the flushing
can _only_ be called once the frontbuffer update has been latched.
But this poses a problem for pageflips: We can't just delay the
flushing until the pageflip is latched, since that would pose the risk
that we override frontbuffer rendering that has been scheduled
in-between the pageflip ioctl and the actual latching.
To handle this track asynchronous invalidations (and also pageflip)
state per-ring and delay any in-between flushing until the rendering
has completed. And also cancel any delayed flushing if we get a new
invalidation request (whether delayed or not).
Also call intel_mark_fb_busy in both cases in all cases to make sure
that we keep the screen at the highest refresh rate both on flips,
synchronous plane updates and for frontbuffer rendering.
v2: Lots of improvements
Suggestions from Chris:
- Move invalidate/flush in flush_*_domain and set_to_*_domain.
- Drop the flush in busy_ioctl since it's redundant. Was a leftover
from an earlier concept to track flips/delayed flushes.
- Don't forget about the initial modeset enable/final disable.
Suggested by Chris.
Track flips accurately, too. Since flips complete independently of
rendering we need to track pending flips in a separate mask. Again if
an invalidate happens we need to cancel the evenutal flush to avoid
races.
v3:
Provide correct header declarations for flip functions. Currently not
needed outside of intel_display.c, but part of the proper interface.
v4: Add proper domain management to fbcon so that the fbcon buffer is
also tracked correctly.
v5: Fixup locking around the fbcon set_to_gtt_domain call.
v6: More comments from Chris:
- Split out fbcon changes.
- Drop superflous checks for potential scanout before calling intel_fb
functions - we can micro-optimize this later.
- s/intel_fb_/intel_fb_obj_/ to make it clear that this deals in gem
object. We already have precedence for fb_obj in the pin_and_fence
functions.
v7: Clarify the semantics of the flip flush handling by renaming
things a bit:
- Don't go through a gem object but take the relevant frontbuffer bits
directly. These functions center on the plane, the actual object is
irrelevant - even a flip to the same object as already active should
cause a flush.
- Add a new intel_frontbuffer_flip for synchronous plane updates. It
currently just calls intel_frontbuffer_flush since the implemenation
differs.
This way we achieve a clear split between one-shot update events on
one side and frontbuffer rendering with potentially a very long delay
between the invalidate and flush.
Chris and I also had some discussions about mark_busy and whether it
is appropriate to call from flush. But mark busy is a state which
should be derived from the 3 events (invalidate, flush, flip) we now
have by the users, like psr does by tracking relevant information in
psr.busy_frontbuffer_bits. DRRS (the only real use of mark_busy for
frontbuffer) needs to have similar logic. With that the overall
mark_busy in the core could be removed.
v8: Only when retiring gpu buffers only flush frontbuffer bits we
actually invalidated in a batch. Just for safety since before any
additional usage/invalidate we should always retire current rendering.
Suggested by Chris Wilson.
v9: Actually use intel_frontbuffer_flip in all appropriate places.
Spotted by Chris.
v10: Address more comments from Chris:
- Don't call _flip in set_base when the crtc is inactive, avoids redunancy
in the modeset case with the initial enabling of all planes.
- Add comments explaining that the initial/final plane enable/disable
still has work left to do before it's fully generic.
v11: Only invalidate for gtt/cpu access when writing. Spotted by Chris.
v12: s/_flush/_flip/ in intel_overlay.c per Chris' comment.
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-06-19 21:01:59 +07:00
|
|
|
void intel_frontbuffer_flip_prepare(struct drm_device *dev,
|
|
|
|
unsigned frontbuffer_bits);
|
|
|
|
void intel_frontbuffer_flip_complete(struct drm_device *dev,
|
|
|
|
unsigned frontbuffer_bits);
|
|
|
|
void intel_frontbuffer_flush(struct drm_device *dev,
|
|
|
|
unsigned frontbuffer_bits);
|
|
|
|
/**
|
2014-10-01 03:10:53 +07:00
|
|
|
* intel_frontbuffer_flip - synchronous frontbuffer flip
|
drm/i915: Track frontbuffer invalidation/flushing
So these are the guts of the new beast. This tracks when a frontbuffer
gets invalidated (due to frontbuffer rendering) and hence should be
constantly scaned out, and when it's flushed again and can be
compressed/one-shot-upload.
Rules for flushing are simple: The frontbuffer needs one more full
upload starting from the next vblank. Which means that the flushing
can _only_ be called once the frontbuffer update has been latched.
But this poses a problem for pageflips: We can't just delay the
flushing until the pageflip is latched, since that would pose the risk
that we override frontbuffer rendering that has been scheduled
in-between the pageflip ioctl and the actual latching.
To handle this track asynchronous invalidations (and also pageflip)
state per-ring and delay any in-between flushing until the rendering
has completed. And also cancel any delayed flushing if we get a new
invalidation request (whether delayed or not).
Also call intel_mark_fb_busy in both cases in all cases to make sure
that we keep the screen at the highest refresh rate both on flips,
synchronous plane updates and for frontbuffer rendering.
v2: Lots of improvements
Suggestions from Chris:
- Move invalidate/flush in flush_*_domain and set_to_*_domain.
- Drop the flush in busy_ioctl since it's redundant. Was a leftover
from an earlier concept to track flips/delayed flushes.
- Don't forget about the initial modeset enable/final disable.
Suggested by Chris.
Track flips accurately, too. Since flips complete independently of
rendering we need to track pending flips in a separate mask. Again if
an invalidate happens we need to cancel the evenutal flush to avoid
races.
v3:
Provide correct header declarations for flip functions. Currently not
needed outside of intel_display.c, but part of the proper interface.
v4: Add proper domain management to fbcon so that the fbcon buffer is
also tracked correctly.
v5: Fixup locking around the fbcon set_to_gtt_domain call.
v6: More comments from Chris:
- Split out fbcon changes.
- Drop superflous checks for potential scanout before calling intel_fb
functions - we can micro-optimize this later.
- s/intel_fb_/intel_fb_obj_/ to make it clear that this deals in gem
object. We already have precedence for fb_obj in the pin_and_fence
functions.
v7: Clarify the semantics of the flip flush handling by renaming
things a bit:
- Don't go through a gem object but take the relevant frontbuffer bits
directly. These functions center on the plane, the actual object is
irrelevant - even a flip to the same object as already active should
cause a flush.
- Add a new intel_frontbuffer_flip for synchronous plane updates. It
currently just calls intel_frontbuffer_flush since the implemenation
differs.
This way we achieve a clear split between one-shot update events on
one side and frontbuffer rendering with potentially a very long delay
between the invalidate and flush.
Chris and I also had some discussions about mark_busy and whether it
is appropriate to call from flush. But mark busy is a state which
should be derived from the 3 events (invalidate, flush, flip) we now
have by the users, like psr does by tracking relevant information in
psr.busy_frontbuffer_bits. DRRS (the only real use of mark_busy for
frontbuffer) needs to have similar logic. With that the overall
mark_busy in the core could be removed.
v8: Only when retiring gpu buffers only flush frontbuffer bits we
actually invalidated in a batch. Just for safety since before any
additional usage/invalidate we should always retire current rendering.
Suggested by Chris Wilson.
v9: Actually use intel_frontbuffer_flip in all appropriate places.
Spotted by Chris.
v10: Address more comments from Chris:
- Don't call _flip in set_base when the crtc is inactive, avoids redunancy
in the modeset case with the initial enabling of all planes.
- Add comments explaining that the initial/final plane enable/disable
still has work left to do before it's fully generic.
v11: Only invalidate for gtt/cpu access when writing. Spotted by Chris.
v12: s/_flush/_flip/ in intel_overlay.c per Chris' comment.
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-06-19 21:01:59 +07:00
|
|
|
* @dev: DRM device
|
|
|
|
* @frontbuffer_bits: frontbuffer plane tracking bits
|
|
|
|
*
|
|
|
|
* This function gets called after scheduling a flip on @obj. This is for
|
|
|
|
* synchronous plane updates which will happen on the next vblank and which will
|
|
|
|
* not get delayed by pending gpu rendering.
|
|
|
|
*
|
|
|
|
* Can be called without any locks held.
|
|
|
|
*/
|
|
|
|
static inline
|
|
|
|
void intel_frontbuffer_flip(struct drm_device *dev,
|
|
|
|
unsigned frontbuffer_bits)
|
|
|
|
{
|
|
|
|
intel_frontbuffer_flush(dev, frontbuffer_bits);
|
|
|
|
}
|
|
|
|
|
2015-01-20 19:51:45 +07:00
|
|
|
int intel_fb_align_height(struct drm_device *dev, int height,
|
2015-02-11 00:16:10 +07:00
|
|
|
uint32_t pixel_format,
|
|
|
|
uint64_t fb_format_modifier);
|
drm/i915: Track frontbuffer invalidation/flushing
So these are the guts of the new beast. This tracks when a frontbuffer
gets invalidated (due to frontbuffer rendering) and hence should be
constantly scaned out, and when it's flushed again and can be
compressed/one-shot-upload.
Rules for flushing are simple: The frontbuffer needs one more full
upload starting from the next vblank. Which means that the flushing
can _only_ be called once the frontbuffer update has been latched.
But this poses a problem for pageflips: We can't just delay the
flushing until the pageflip is latched, since that would pose the risk
that we override frontbuffer rendering that has been scheduled
in-between the pageflip ioctl and the actual latching.
To handle this track asynchronous invalidations (and also pageflip)
state per-ring and delay any in-between flushing until the rendering
has completed. And also cancel any delayed flushing if we get a new
invalidation request (whether delayed or not).
Also call intel_mark_fb_busy in both cases in all cases to make sure
that we keep the screen at the highest refresh rate both on flips,
synchronous plane updates and for frontbuffer rendering.
v2: Lots of improvements
Suggestions from Chris:
- Move invalidate/flush in flush_*_domain and set_to_*_domain.
- Drop the flush in busy_ioctl since it's redundant. Was a leftover
from an earlier concept to track flips/delayed flushes.
- Don't forget about the initial modeset enable/final disable.
Suggested by Chris.
Track flips accurately, too. Since flips complete independently of
rendering we need to track pending flips in a separate mask. Again if
an invalidate happens we need to cancel the evenutal flush to avoid
races.
v3:
Provide correct header declarations for flip functions. Currently not
needed outside of intel_display.c, but part of the proper interface.
v4: Add proper domain management to fbcon so that the fbcon buffer is
also tracked correctly.
v5: Fixup locking around the fbcon set_to_gtt_domain call.
v6: More comments from Chris:
- Split out fbcon changes.
- Drop superflous checks for potential scanout before calling intel_fb
functions - we can micro-optimize this later.
- s/intel_fb_/intel_fb_obj_/ to make it clear that this deals in gem
object. We already have precedence for fb_obj in the pin_and_fence
functions.
v7: Clarify the semantics of the flip flush handling by renaming
things a bit:
- Don't go through a gem object but take the relevant frontbuffer bits
directly. These functions center on the plane, the actual object is
irrelevant - even a flip to the same object as already active should
cause a flush.
- Add a new intel_frontbuffer_flip for synchronous plane updates. It
currently just calls intel_frontbuffer_flush since the implemenation
differs.
This way we achieve a clear split between one-shot update events on
one side and frontbuffer rendering with potentially a very long delay
between the invalidate and flush.
Chris and I also had some discussions about mark_busy and whether it
is appropriate to call from flush. But mark busy is a state which
should be derived from the 3 events (invalidate, flush, flip) we now
have by the users, like psr does by tracking relevant information in
psr.busy_frontbuffer_bits. DRRS (the only real use of mark_busy for
frontbuffer) needs to have similar logic. With that the overall
mark_busy in the core could be removed.
v8: Only when retiring gpu buffers only flush frontbuffer bits we
actually invalidated in a batch. Just for safety since before any
additional usage/invalidate we should always retire current rendering.
Suggested by Chris Wilson.
v9: Actually use intel_frontbuffer_flip in all appropriate places.
Spotted by Chris.
v10: Address more comments from Chris:
- Don't call _flip in set_base when the crtc is inactive, avoids redunancy
in the modeset case with the initial enabling of all planes.
- Add comments explaining that the initial/final plane enable/disable
still has work left to do before it's fully generic.
v11: Only invalidate for gtt/cpu access when writing. Spotted by Chris.
v12: s/_flush/_flip/ in intel_overlay.c per Chris' comment.
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-06-19 21:01:59 +07:00
|
|
|
void intel_fb_obj_flush(struct drm_i915_gem_object *obj, bool retire);
|
2014-09-19 23:27:27 +07:00
|
|
|
|
2015-02-27 18:15:18 +07:00
|
|
|
u32 intel_fb_stride_alignment(struct drm_device *dev, uint64_t fb_modifier,
|
|
|
|
uint32_t pixel_format);
|
2014-09-19 23:27:27 +07:00
|
|
|
|
2014-10-27 21:26:43 +07:00
|
|
|
/* intel_audio.c */
|
|
|
|
void intel_init_audio(struct drm_device *dev);
|
2014-10-27 21:26:50 +07:00
|
|
|
void intel_audio_codec_enable(struct intel_encoder *encoder);
|
|
|
|
void intel_audio_codec_disable(struct intel_encoder *encoder);
|
2015-01-08 22:54:14 +07:00
|
|
|
void i915_audio_component_init(struct drm_i915_private *dev_priv);
|
|
|
|
void i915_audio_component_cleanup(struct drm_i915_private *dev_priv);
|
2014-10-27 21:26:43 +07:00
|
|
|
|
2014-09-19 23:27:27 +07:00
|
|
|
/* intel_display.c */
|
2015-01-22 07:35:42 +07:00
|
|
|
extern const struct drm_plane_funcs intel_plane_funcs;
|
2014-09-19 23:27:27 +07:00
|
|
|
bool intel_has_pending_fb_unpin(struct drm_device *dev);
|
|
|
|
int intel_pch_rawclk(struct drm_device *dev);
|
|
|
|
void intel_mark_busy(struct drm_device *dev);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_mark_idle(struct drm_device *dev);
|
|
|
|
void intel_crtc_restore_mode(struct drm_crtc *crtc);
|
2014-07-12 11:32:27 +07:00
|
|
|
void intel_crtc_control(struct drm_crtc *crtc, bool enable);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_crtc_update_dpms(struct drm_crtc *crtc);
|
|
|
|
void intel_encoder_destroy(struct drm_encoder *encoder);
|
|
|
|
void intel_connector_dpms(struct drm_connector *, int mode);
|
|
|
|
bool intel_connector_get_hw_state(struct intel_connector *connector);
|
|
|
|
void intel_modeset_check_state(struct drm_device *dev);
|
2012-12-13 23:09:00 +07:00
|
|
|
bool ibx_digital_port_connected(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *port);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_connector_attach_encoder(struct intel_connector *connector,
|
|
|
|
struct intel_encoder *encoder);
|
|
|
|
struct drm_encoder *intel_best_encoder(struct drm_connector *connector);
|
|
|
|
struct drm_display_mode *intel_crtc_mode_get(struct drm_device *dev,
|
|
|
|
struct drm_crtc *crtc);
|
2013-10-31 23:55:49 +07:00
|
|
|
enum pipe intel_get_pipe_from_connector(struct intel_connector *connector);
|
2009-04-30 04:43:54 +07:00
|
|
|
int intel_get_pipe_from_crtc_id(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2013-09-25 01:48:31 +07:00
|
|
|
enum transcoder intel_pipe_to_cpu_transcoder(struct drm_i915_private *dev_priv,
|
|
|
|
enum pipe pipe);
|
2014-10-29 18:16:59 +07:00
|
|
|
bool intel_pipe_has_type(struct intel_crtc *crtc, enum intel_output_type type);
|
2014-09-15 19:12:21 +07:00
|
|
|
static inline void
|
|
|
|
intel_wait_for_vblank(struct drm_device *dev, int pipe)
|
|
|
|
{
|
|
|
|
drm_wait_one_vblank(dev, pipe);
|
|
|
|
}
|
2013-09-25 01:48:31 +07:00
|
|
|
int ironlake_get_lanes_required(int target_clock, int link_bw, int bpp);
|
2013-11-06 13:36:35 +07:00
|
|
|
void vlv_wait_port_ready(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *dport);
|
2013-09-25 01:48:31 +07:00
|
|
|
bool intel_get_load_detect_pipe(struct drm_connector *connector,
|
|
|
|
struct drm_display_mode *mode,
|
2013-11-20 00:10:12 +07:00
|
|
|
struct intel_load_detect_pipe *old,
|
|
|
|
struct drm_modeset_acquire_ctx *ctx);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_release_load_detect_pipe(struct drm_connector *connector,
|
2014-08-11 17:15:35 +07:00
|
|
|
struct intel_load_detect_pipe *old);
|
2014-10-30 23:39:38 +07:00
|
|
|
int intel_pin_and_fence_fb_obj(struct drm_plane *plane,
|
|
|
|
struct drm_framebuffer *fb,
|
2014-05-22 20:13:33 +07:00
|
|
|
struct intel_engine_cs *pipelined);
|
2014-02-11 00:00:39 +07:00
|
|
|
struct drm_framebuffer *
|
|
|
|
__intel_framebuffer_create(struct drm_device *dev,
|
2013-09-25 01:48:31 +07:00
|
|
|
struct drm_mode_fb_cmd2 *mode_cmd,
|
|
|
|
struct drm_i915_gem_object *obj);
|
|
|
|
void intel_prepare_page_flip(struct drm_device *dev, int plane);
|
|
|
|
void intel_finish_page_flip(struct drm_device *dev, int pipe);
|
|
|
|
void intel_finish_page_flip_plane(struct drm_device *dev, int plane);
|
drm/i915: Check for a stalled page flip after each vblank
Long ago, back in the racy haydays of 915gm interrupt handling, page
flips would occasionally go astray and leave the hardware stuck, and the
display not updating. This annoyed people who relied on their systems
being able to display continuously updating information 24/7, and so
some code to detect when the driver missed the page flip completion
signal was added. Until recently, it was presumed that the interrupt
handling was now flawless, but once again Simon Farnsworth has found a
system whose display will stall. Reinstate the pageflip stall detection,
which works by checking to see if the hardware has been updated to the
new framebuffer address following each vblank. If the hardware is
scanning out from the new framebuffer, but we still think the flip is
pending, then we kick our driver into submision.
This is a continuation of the effort started with
commit 4e5359cd053bfb7d8dabe4a63624a5726848ffbc
Author: Simon Farnsworth <simon.farnsworth@onelan.co.uk>
Date: Wed Sep 1 17:47:52 2010 +0100
drm/i915: Avoid pageflipping freeze when we miss the flip prepare interrupt
This now includes a belt-and-braces approach to make sure the driver
(or the hardware) doesn't miss an interrupt and cause us to stop
updating the display should the unthinkable happen and the pageflip fail - i.e.
that the user is able to continue submitting flips.
v2: Cleanup, refactor, and rename
v3: Only start counting vblanks after the flip command has been seen by
the hardware.
v4: Record the seqno after we touch the ring, or else there may be no
seqno allocated yet.
v5: Rebase on mmio-flip.
v6: Rebase, rebase.
Reported-by: Simon Farnsworth <simon@farnz.org.uk>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=75502
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com> [v4]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-09-05 13:13:24 +07:00
|
|
|
void intel_check_page_flip(struct drm_device *dev, int pipe);
|
2014-12-02 06:40:14 +07:00
|
|
|
int intel_prepare_plane_fb(struct drm_plane *plane,
|
2015-03-03 21:22:31 +07:00
|
|
|
struct drm_framebuffer *fb,
|
|
|
|
const struct drm_plane_state *new_state);
|
2014-12-02 22:45:25 +07:00
|
|
|
void intel_cleanup_plane_fb(struct drm_plane *plane,
|
2015-03-03 21:22:31 +07:00
|
|
|
struct drm_framebuffer *fb,
|
|
|
|
const struct drm_plane_state *old_state);
|
2015-01-22 07:35:43 +07:00
|
|
|
int intel_plane_atomic_get_property(struct drm_plane *plane,
|
|
|
|
const struct drm_plane_state *state,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t *val);
|
|
|
|
int intel_plane_atomic_set_property(struct drm_plane *plane,
|
|
|
|
struct drm_plane_state *state,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t val);
|
2014-06-26 02:02:02 +07:00
|
|
|
|
|
|
|
/* shared dpll functions */
|
2013-09-24 23:52:53 +07:00
|
|
|
struct intel_shared_dpll *intel_crtc_to_shared_dpll(struct intel_crtc *crtc);
|
2013-06-17 02:42:39 +07:00
|
|
|
void assert_shared_dpll(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_shared_dpll *pll,
|
|
|
|
bool state);
|
|
|
|
#define assert_shared_dpll_enabled(d, p) assert_shared_dpll(d, p, true)
|
|
|
|
#define assert_shared_dpll_disabled(d, p) assert_shared_dpll(d, p, false)
|
2015-01-15 19:55:23 +07:00
|
|
|
struct intel_shared_dpll *intel_get_shared_dpll(struct intel_crtc *crtc,
|
|
|
|
struct intel_crtc_state *state);
|
2014-06-26 02:02:02 +07:00
|
|
|
void intel_put_shared_dpll(struct intel_crtc *crtc);
|
|
|
|
|
2014-10-28 18:20:22 +07:00
|
|
|
void vlv_force_pll_on(struct drm_device *dev, enum pipe pipe,
|
|
|
|
const struct dpll *dpll);
|
|
|
|
void vlv_force_pll_off(struct drm_device *dev, enum pipe pipe);
|
|
|
|
|
2014-06-26 02:02:02 +07:00
|
|
|
/* modesetting asserts */
|
2014-09-19 23:27:27 +07:00
|
|
|
void assert_panel_unlocked(struct drm_i915_private *dev_priv,
|
|
|
|
enum pipe pipe);
|
2013-06-17 02:42:39 +07:00
|
|
|
void assert_pll(struct drm_i915_private *dev_priv,
|
|
|
|
enum pipe pipe, bool state);
|
|
|
|
#define assert_pll_enabled(d, p) assert_pll(d, p, true)
|
|
|
|
#define assert_pll_disabled(d, p) assert_pll(d, p, false)
|
|
|
|
void assert_fdi_rx_pll(struct drm_i915_private *dev_priv,
|
|
|
|
enum pipe pipe, bool state);
|
|
|
|
#define assert_fdi_rx_pll_enabled(d, p) assert_fdi_rx_pll(d, p, true)
|
|
|
|
#define assert_fdi_rx_pll_disabled(d, p) assert_fdi_rx_pll(d, p, false)
|
2013-09-25 01:48:31 +07:00
|
|
|
void assert_pipe(struct drm_i915_private *dev_priv, enum pipe pipe, bool state);
|
2011-12-14 04:19:38 +07:00
|
|
|
#define assert_pipe_enabled(d, p) assert_pipe(d, p, true)
|
|
|
|
#define assert_pipe_disabled(d, p) assert_pipe(d, p, false)
|
2013-09-25 01:48:31 +07:00
|
|
|
unsigned long intel_gen4_compute_page_offset(int *x, int *y,
|
|
|
|
unsigned int tiling_mode,
|
|
|
|
unsigned int bpp,
|
|
|
|
unsigned int pitch);
|
2014-11-24 23:28:11 +07:00
|
|
|
void intel_prepare_reset(struct drm_device *dev);
|
|
|
|
void intel_finish_reset(struct drm_device *dev);
|
2014-03-08 06:08:17 +07:00
|
|
|
void hsw_enable_pc8(struct drm_i915_private *dev_priv);
|
|
|
|
void hsw_disable_pc8(struct drm_i915_private *dev_priv);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_dp_get_m_n(struct intel_crtc *crtc,
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *pipe_config);
|
2015-02-13 17:02:59 +07:00
|
|
|
void intel_dp_set_m_n(struct intel_crtc *crtc, enum link_m_n_set m_n);
|
2013-09-25 01:48:31 +07:00
|
|
|
int intel_dotclock_calculate(int link_freq, const struct intel_link_m_n *m_n);
|
|
|
|
void
|
2015-01-15 19:55:21 +07:00
|
|
|
ironlake_check_encoder_dotclock(const struct intel_crtc_state *pipe_config,
|
2013-09-24 23:52:53 +07:00
|
|
|
int dotclock);
|
2013-09-25 01:48:31 +07:00
|
|
|
bool intel_crtc_active(struct drm_crtc *crtc);
|
2013-10-01 22:02:17 +07:00
|
|
|
void hsw_enable_ips(struct intel_crtc *crtc);
|
|
|
|
void hsw_disable_ips(struct intel_crtc *crtc);
|
2014-03-05 00:22:57 +07:00
|
|
|
enum intel_display_power_domain
|
|
|
|
intel_display_port_power_domain(struct intel_encoder *intel_encoder);
|
2014-02-12 06:28:57 +07:00
|
|
|
void intel_mode_from_pipe_config(struct drm_display_mode *mode,
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *pipe_config);
|
2014-05-21 18:04:46 +07:00
|
|
|
void intel_crtc_wait_for_pending_flips(struct drm_crtc *crtc);
|
2014-08-06 18:02:51 +07:00
|
|
|
void intel_modeset_preclose(struct drm_device *dev, struct drm_file *file);
|
2012-01-03 23:05:39 +07:00
|
|
|
|
2013-09-24 23:52:53 +07:00
|
|
|
/* intel_dp.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_dp_init(struct drm_device *dev, int output_reg, enum port port);
|
|
|
|
bool intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
|
|
|
|
struct intel_connector *intel_connector);
|
|
|
|
void intel_dp_start_link_train(struct intel_dp *intel_dp);
|
|
|
|
void intel_dp_complete_link_train(struct intel_dp *intel_dp);
|
|
|
|
void intel_dp_stop_link_train(struct intel_dp *intel_dp);
|
|
|
|
void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode);
|
|
|
|
void intel_dp_encoder_destroy(struct drm_encoder *encoder);
|
2014-01-24 22:36:17 +07:00
|
|
|
int intel_dp_sink_crc(struct intel_dp *intel_dp, u8 *crc);
|
2013-09-25 01:48:31 +07:00
|
|
|
bool intel_dp_compute_config(struct intel_encoder *encoder,
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *pipe_config);
|
2013-11-01 23:22:39 +07:00
|
|
|
bool intel_dp_is_edp(struct drm_device *dev, enum port port);
|
2015-01-23 12:00:31 +07:00
|
|
|
enum irqreturn intel_dp_hpd_pulse(struct intel_digital_port *intel_dig_port,
|
|
|
|
bool long_hpd);
|
2014-01-17 20:39:48 +07:00
|
|
|
void intel_edp_backlight_on(struct intel_dp *intel_dp);
|
|
|
|
void intel_edp_backlight_off(struct intel_dp *intel_dp);
|
2014-03-17 21:43:36 +07:00
|
|
|
void intel_edp_panel_vdd_on(struct intel_dp *intel_dp);
|
2014-01-17 20:39:48 +07:00
|
|
|
void intel_edp_panel_on(struct intel_dp *intel_dp);
|
|
|
|
void intel_edp_panel_off(struct intel_dp *intel_dp);
|
2014-05-02 11:02:48 +07:00
|
|
|
void intel_dp_add_properties(struct intel_dp *intel_dp, struct drm_connector *connector);
|
|
|
|
void intel_dp_mst_suspend(struct drm_device *dev);
|
|
|
|
void intel_dp_mst_resume(struct drm_device *dev);
|
2015-03-12 22:10:34 +07:00
|
|
|
int intel_dp_max_link_rate(struct intel_dp *intel_dp);
|
2015-03-12 22:10:36 +07:00
|
|
|
int intel_dp_rate_select(struct intel_dp *intel_dp, int rate);
|
2014-05-02 11:02:48 +07:00
|
|
|
void intel_dp_hot_plug(struct intel_encoder *intel_encoder);
|
2014-09-04 18:54:56 +07:00
|
|
|
void vlv_power_sequencer_reset(struct drm_i915_private *dev_priv);
|
2014-11-14 23:52:28 +07:00
|
|
|
uint32_t intel_dp_pack_aux(const uint8_t *src, int src_bytes);
|
2014-12-24 01:41:51 +07:00
|
|
|
void intel_plane_destroy(struct drm_plane *plane);
|
2015-01-22 16:47:40 +07:00
|
|
|
void intel_edp_drrs_enable(struct intel_dp *intel_dp);
|
|
|
|
void intel_edp_drrs_disable(struct intel_dp *intel_dp);
|
2015-01-10 03:55:59 +07:00
|
|
|
void intel_edp_drrs_invalidate(struct drm_device *dev,
|
|
|
|
unsigned frontbuffer_bits);
|
|
|
|
void intel_edp_drrs_flush(struct drm_device *dev, unsigned frontbuffer_bits);
|
2014-11-14 23:52:28 +07:00
|
|
|
|
2014-05-02 11:02:48 +07:00
|
|
|
/* intel_dp_mst.c */
|
|
|
|
int intel_dp_mst_encoder_init(struct intel_digital_port *intel_dig_port, int conn_id);
|
|
|
|
void intel_dp_mst_encoder_cleanup(struct intel_digital_port *intel_dig_port);
|
2013-09-24 23:52:53 +07:00
|
|
|
/* intel_dsi.c */
|
2014-05-28 18:30:56 +07:00
|
|
|
void intel_dsi_init(struct drm_device *dev);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
|
|
|
|
|
|
|
/* intel_dvo.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_dvo_init(struct drm_device *dev);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
|
|
|
|
2013-10-08 22:44:49 +07:00
|
|
|
/* legacy fbdev emulation in intel_fbdev.c */
|
2013-10-09 14:18:51 +07:00
|
|
|
#ifdef CONFIG_DRM_I915_FBDEV
|
|
|
|
extern int intel_fbdev_init(struct drm_device *dev);
|
2014-05-29 04:39:03 +07:00
|
|
|
extern void intel_fbdev_initial_config(void *data, async_cookie_t cookie);
|
2013-10-09 14:18:51 +07:00
|
|
|
extern void intel_fbdev_fini(struct drm_device *dev);
|
2014-08-13 19:09:46 +07:00
|
|
|
extern void intel_fbdev_set_suspend(struct drm_device *dev, int state, bool synchronous);
|
2013-10-08 22:44:49 +07:00
|
|
|
extern void intel_fbdev_output_poll_changed(struct drm_device *dev);
|
|
|
|
extern void intel_fbdev_restore_mode(struct drm_device *dev);
|
2013-10-09 14:18:51 +07:00
|
|
|
#else
|
|
|
|
static inline int intel_fbdev_init(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2013-09-24 23:52:53 +07:00
|
|
|
|
2014-05-29 04:39:03 +07:00
|
|
|
static inline void intel_fbdev_initial_config(void *data, async_cookie_t cookie)
|
2013-10-09 14:18:51 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void intel_fbdev_fini(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-08-13 19:09:46 +07:00
|
|
|
static inline void intel_fbdev_set_suspend(struct drm_device *dev, int state, bool synchronous)
|
2013-10-09 14:18:51 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-10-08 22:44:49 +07:00
|
|
|
static inline void intel_fbdev_restore_mode(struct drm_device *dev)
|
2013-10-09 14:18:51 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
2013-09-24 23:52:53 +07:00
|
|
|
|
2014-12-08 23:09:10 +07:00
|
|
|
/* intel_fbc.c */
|
|
|
|
bool intel_fbc_enabled(struct drm_device *dev);
|
|
|
|
void intel_fbc_update(struct drm_device *dev);
|
|
|
|
void intel_fbc_init(struct drm_i915_private *dev_priv);
|
|
|
|
void intel_fbc_disable(struct drm_device *dev);
|
2015-02-14 02:23:46 +07:00
|
|
|
void intel_fbc_invalidate(struct drm_i915_private *dev_priv,
|
|
|
|
unsigned int frontbuffer_bits,
|
|
|
|
enum fb_op_origin origin);
|
|
|
|
void intel_fbc_flush(struct drm_i915_private *dev_priv,
|
|
|
|
unsigned int frontbuffer_bits);
|
2014-12-08 23:09:10 +07:00
|
|
|
|
2013-09-24 23:52:53 +07:00
|
|
|
/* intel_hdmi.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_hdmi_init(struct drm_device *dev, int hdmi_reg, enum port port);
|
|
|
|
void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
|
|
|
|
struct intel_connector *intel_connector);
|
|
|
|
struct intel_hdmi *enc_to_intel_hdmi(struct drm_encoder *encoder);
|
|
|
|
bool intel_hdmi_compute_config(struct intel_encoder *encoder,
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *pipe_config);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
|
|
|
|
|
|
|
/* intel_lvds.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_lvds_init(struct drm_device *dev);
|
|
|
|
bool intel_is_dual_link_lvds(struct drm_device *dev);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
|
|
|
|
|
|
|
/* intel_modes.c */
|
|
|
|
int intel_connector_update_modes(struct drm_connector *connector,
|
2013-09-25 01:48:31 +07:00
|
|
|
struct edid *edid);
|
2013-09-24 23:52:53 +07:00
|
|
|
int intel_ddc_get_modes(struct drm_connector *c, struct i2c_adapter *adapter);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_attach_force_audio_property(struct drm_connector *connector);
|
|
|
|
void intel_attach_broadcast_rgb_property(struct drm_connector *connector);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
|
|
|
|
|
|
|
/* intel_overlay.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_setup_overlay(struct drm_device *dev);
|
|
|
|
void intel_cleanup_overlay(struct drm_device *dev);
|
|
|
|
int intel_overlay_switch_off(struct intel_overlay *overlay);
|
|
|
|
int intel_overlay_put_image(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
int intel_overlay_attrs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2014-11-26 22:07:29 +07:00
|
|
|
void intel_overlay_reset(struct drm_i915_private *dev_priv);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
|
|
|
|
|
|
|
/* intel_panel.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
int intel_panel_init(struct intel_panel *panel,
|
2014-02-11 15:56:36 +07:00
|
|
|
struct drm_display_mode *fixed_mode,
|
|
|
|
struct drm_display_mode *downclock_mode);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_panel_fini(struct intel_panel *panel);
|
|
|
|
void intel_fixed_panel_mode(const struct drm_display_mode *fixed_mode,
|
|
|
|
struct drm_display_mode *adjusted_mode);
|
|
|
|
void intel_pch_panel_fitting(struct intel_crtc *crtc,
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *pipe_config,
|
2013-09-25 01:48:31 +07:00
|
|
|
int fitting_mode);
|
|
|
|
void intel_gmch_panel_fitting(struct intel_crtc *crtc,
|
2015-01-15 19:55:21 +07:00
|
|
|
struct intel_crtc_state *pipe_config,
|
2013-09-25 01:48:31 +07:00
|
|
|
int fitting_mode);
|
2014-06-24 22:27:40 +07:00
|
|
|
void intel_panel_set_backlight_acpi(struct intel_connector *connector,
|
|
|
|
u32 level, u32 max);
|
2014-11-07 16:16:02 +07:00
|
|
|
int intel_panel_setup_backlight(struct drm_connector *connector, enum pipe pipe);
|
2013-10-31 23:55:49 +07:00
|
|
|
void intel_panel_enable_backlight(struct intel_connector *connector);
|
|
|
|
void intel_panel_disable_backlight(struct intel_connector *connector);
|
2013-11-08 21:48:53 +07:00
|
|
|
void intel_panel_destroy_backlight(struct drm_connector *connector);
|
2013-11-08 21:48:56 +07:00
|
|
|
void intel_panel_init_backlight_funcs(struct drm_device *dev);
|
2013-09-25 01:48:31 +07:00
|
|
|
enum drm_connector_status intel_panel_detect(struct drm_device *dev);
|
2013-12-10 15:07:36 +07:00
|
|
|
extern struct drm_display_mode *intel_find_panel_downclock(
|
|
|
|
struct drm_device *dev,
|
|
|
|
struct drm_display_mode *fixed_mode,
|
|
|
|
struct drm_connector *connector);
|
2014-11-07 20:19:46 +07:00
|
|
|
void intel_backlight_register(struct drm_device *dev);
|
|
|
|
void intel_backlight_unregister(struct drm_device *dev);
|
|
|
|
|
2013-09-24 23:52:53 +07:00
|
|
|
|
2014-11-14 23:52:28 +07:00
|
|
|
/* intel_psr.c */
|
|
|
|
void intel_psr_enable(struct intel_dp *intel_dp);
|
|
|
|
void intel_psr_disable(struct intel_dp *intel_dp);
|
|
|
|
void intel_psr_invalidate(struct drm_device *dev,
|
|
|
|
unsigned frontbuffer_bits);
|
|
|
|
void intel_psr_flush(struct drm_device *dev,
|
|
|
|
unsigned frontbuffer_bits);
|
|
|
|
void intel_psr_init(struct drm_device *dev);
|
|
|
|
|
2014-09-30 15:56:38 +07:00
|
|
|
/* intel_runtime_pm.c */
|
|
|
|
int intel_power_domains_init(struct drm_i915_private *);
|
2014-09-30 15:56:39 +07:00
|
|
|
void intel_power_domains_fini(struct drm_i915_private *);
|
2014-09-30 15:56:38 +07:00
|
|
|
void intel_power_domains_init_hw(struct drm_i915_private *dev_priv);
|
2014-09-30 15:56:39 +07:00
|
|
|
void intel_runtime_pm_enable(struct drm_i915_private *dev_priv);
|
2014-09-30 15:56:38 +07:00
|
|
|
|
2014-09-30 15:56:39 +07:00
|
|
|
bool intel_display_power_is_enabled(struct drm_i915_private *dev_priv,
|
|
|
|
enum intel_display_power_domain domain);
|
|
|
|
bool __intel_display_power_is_enabled(struct drm_i915_private *dev_priv,
|
|
|
|
enum intel_display_power_domain domain);
|
2014-09-30 15:56:38 +07:00
|
|
|
void intel_display_power_get(struct drm_i915_private *dev_priv,
|
|
|
|
enum intel_display_power_domain domain);
|
|
|
|
void intel_display_power_put(struct drm_i915_private *dev_priv,
|
|
|
|
enum intel_display_power_domain domain);
|
|
|
|
void intel_aux_display_runtime_get(struct drm_i915_private *dev_priv);
|
|
|
|
void intel_aux_display_runtime_put(struct drm_i915_private *dev_priv);
|
|
|
|
void intel_runtime_pm_get(struct drm_i915_private *dev_priv);
|
|
|
|
void intel_runtime_pm_get_noresume(struct drm_i915_private *dev_priv);
|
|
|
|
void intel_runtime_pm_put(struct drm_i915_private *dev_priv);
|
|
|
|
|
2014-09-30 15:56:40 +07:00
|
|
|
void intel_display_set_init_power(struct drm_i915_private *dev, bool enable);
|
|
|
|
|
2013-09-24 23:52:53 +07:00
|
|
|
/* intel_pm.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_init_clock_gating(struct drm_device *dev);
|
|
|
|
void intel_suspend_hw(struct drm_device *dev);
|
2014-05-13 21:30:26 +07:00
|
|
|
int ilk_wm_max_level(const struct drm_device *dev);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_update_watermarks(struct drm_crtc *crtc);
|
|
|
|
void intel_update_sprite_watermarks(struct drm_plane *plane,
|
|
|
|
struct drm_crtc *crtc,
|
2014-07-15 14:21:24 +07:00
|
|
|
uint32_t sprite_width,
|
|
|
|
uint32_t sprite_height,
|
|
|
|
int pixel_size,
|
2013-09-25 01:48:31 +07:00
|
|
|
bool enabled, bool scaled);
|
|
|
|
void intel_init_pm(struct drm_device *dev);
|
2013-12-06 16:17:53 +07:00
|
|
|
void intel_pm_setup(struct drm_device *dev);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_gpu_ips_init(struct drm_i915_private *dev_priv);
|
|
|
|
void intel_gpu_ips_teardown(void);
|
2014-03-31 19:10:44 +07:00
|
|
|
void intel_init_gt_powersave(struct drm_device *dev);
|
|
|
|
void intel_cleanup_gt_powersave(struct drm_device *dev);
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_enable_gt_powersave(struct drm_device *dev);
|
|
|
|
void intel_disable_gt_powersave(struct drm_device *dev);
|
2014-06-12 22:35:45 +07:00
|
|
|
void intel_suspend_gt_powersave(struct drm_device *dev);
|
2014-04-15 00:24:29 +07:00
|
|
|
void intel_reset_gt_powersave(struct drm_device *dev);
|
2013-08-19 23:18:09 +07:00
|
|
|
void gen6_update_ring_freq(struct drm_device *dev);
|
2013-10-09 00:39:29 +07:00
|
|
|
void gen6_rps_idle(struct drm_i915_private *dev_priv);
|
|
|
|
void gen6_rps_boost(struct drm_i915_private *dev_priv);
|
2013-10-14 18:55:24 +07:00
|
|
|
void ilk_wm_get_hw_state(struct drm_device *dev);
|
2014-11-05 00:06:45 +07:00
|
|
|
void skl_wm_get_hw_state(struct drm_device *dev);
|
2014-11-05 00:06:52 +07:00
|
|
|
void skl_ddb_get_hw_state(struct drm_i915_private *dev_priv,
|
|
|
|
struct skl_ddb_allocation *ddb /* out */);
|
2014-06-13 17:37:56 +07:00
|
|
|
|
2012-05-10 01:37:31 +07:00
|
|
|
|
2013-09-24 23:52:53 +07:00
|
|
|
/* intel_sdvo.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg, bool is_sdvob);
|
2013-02-19 00:08:49 +07:00
|
|
|
|
2013-07-12 04:44:58 +07:00
|
|
|
|
2013-09-24 23:52:53 +07:00
|
|
|
/* intel_sprite.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
int intel_plane_init(struct drm_device *dev, enum pipe pipe, int plane);
|
2013-10-01 22:02:18 +07:00
|
|
|
void intel_flush_primary_plane(struct drm_i915_private *dev_priv,
|
2013-09-25 01:48:31 +07:00
|
|
|
enum plane plane);
|
2014-08-05 12:56:53 +07:00
|
|
|
int intel_plane_restore(struct drm_plane *plane);
|
2013-09-25 01:48:31 +07:00
|
|
|
int intel_sprite_set_colorkey(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
int intel_sprite_get_colorkey(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2014-10-28 20:10:14 +07:00
|
|
|
bool intel_pipe_update_start(struct intel_crtc *crtc,
|
|
|
|
uint32_t *start_vbl_count);
|
|
|
|
void intel_pipe_update_end(struct intel_crtc *crtc, u32 start_vbl_count);
|
2014-12-24 22:59:06 +07:00
|
|
|
void intel_post_enable_primary(struct drm_crtc *crtc);
|
|
|
|
void intel_pre_disable_primary(struct drm_crtc *crtc);
|
2013-09-24 23:52:53 +07:00
|
|
|
|
|
|
|
/* intel_tv.c */
|
2013-09-25 01:48:31 +07:00
|
|
|
void intel_tv_init(struct drm_device *dev);
|
2013-09-04 22:25:25 +07:00
|
|
|
|
2014-12-24 01:41:52 +07:00
|
|
|
/* intel_atomic.c */
|
2015-01-22 07:35:44 +07:00
|
|
|
int intel_atomic_check(struct drm_device *dev,
|
|
|
|
struct drm_atomic_state *state);
|
|
|
|
int intel_atomic_commit(struct drm_device *dev,
|
|
|
|
struct drm_atomic_state *state,
|
|
|
|
bool async);
|
2015-01-23 07:51:27 +07:00
|
|
|
int intel_connector_atomic_get_property(struct drm_connector *connector,
|
|
|
|
const struct drm_connector_state *state,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t *val);
|
2015-01-22 07:35:47 +07:00
|
|
|
struct drm_crtc_state *intel_crtc_duplicate_state(struct drm_crtc *crtc);
|
|
|
|
void intel_crtc_destroy_state(struct drm_crtc *crtc,
|
|
|
|
struct drm_crtc_state *state);
|
2015-01-22 07:35:44 +07:00
|
|
|
|
|
|
|
/* intel_atomic_plane.c */
|
2015-01-22 07:35:41 +07:00
|
|
|
struct intel_plane_state *intel_create_plane_state(struct drm_plane *plane);
|
2014-12-24 01:41:52 +07:00
|
|
|
struct drm_plane_state *intel_plane_duplicate_state(struct drm_plane *plane);
|
|
|
|
void intel_plane_destroy_state(struct drm_plane *plane,
|
|
|
|
struct drm_plane_state *state);
|
|
|
|
extern const struct drm_plane_helper_funcs intel_plane_helper_funcs;
|
|
|
|
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-08 05:24:08 +07:00
|
|
|
#endif /* __INTEL_DRV_H__ */
|