2009-04-08 07:16:42 +08:00
|
|
|
/*
|
|
|
|
* Copyright © 2008 Intel Corporation
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
* IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Keith Packard <keithp@keithp.com>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/i2c.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2011-08-31 06:16:33 +08:00
|
|
|
#include <linux/export.h>
|
2017-01-25 00:21:49 +08:00
|
|
|
#include <linux/types.h>
|
2014-07-08 04:01:46 +08:00
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/reboot.h>
|
2017-01-25 00:21:49 +08:00
|
|
|
#include <asm/byteorder.h>
|
2012-10-03 01:01:07 +08:00
|
|
|
#include <drm/drmP.h>
|
2015-01-23 08:50:32 +08:00
|
|
|
#include <drm/drm_atomic_helper.h>
|
2012-10-03 01:01:07 +08:00
|
|
|
#include <drm/drm_crtc.h>
|
|
|
|
#include <drm/drm_crtc_helper.h>
|
|
|
|
#include <drm/drm_edid.h>
|
2009-04-08 07:16:42 +08:00
|
|
|
#include "intel_drv.h"
|
2012-10-03 01:01:07 +08:00
|
|
|
#include <drm/i915_drm.h>
|
2009-04-08 07:16:42 +08:00
|
|
|
#include "i915_drv.h"
|
|
|
|
|
|
|
|
#define DP_LINK_CHECK_TIMEOUT (10 * 1000)
|
2017-09-19 06:21:39 +08:00
|
|
|
#define DP_DPRX_ESI_LEN 14
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2015-05-04 22:48:20 +08:00
|
|
|
/* Compliance test status bits */
|
|
|
|
#define INTEL_DP_RESOLUTION_SHIFT_MASK 0
|
|
|
|
#define INTEL_DP_RESOLUTION_PREFERRED (1 << INTEL_DP_RESOLUTION_SHIFT_MASK)
|
|
|
|
#define INTEL_DP_RESOLUTION_STANDARD (2 << INTEL_DP_RESOLUTION_SHIFT_MASK)
|
|
|
|
#define INTEL_DP_RESOLUTION_FAILSAFE (3 << INTEL_DP_RESOLUTION_SHIFT_MASK)
|
|
|
|
|
2013-09-04 01:30:37 +08:00
|
|
|
struct dp_link_dpll {
|
2015-08-12 01:21:46 +08:00
|
|
|
int clock;
|
2013-09-04 01:30:37 +08:00
|
|
|
struct dpll dpll;
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct dp_link_dpll gen4_dpll[] = {
|
2015-08-12 01:21:46 +08:00
|
|
|
{ 162000,
|
2013-09-04 01:30:37 +08:00
|
|
|
{ .p1 = 2, .p2 = 10, .n = 2, .m1 = 23, .m2 = 8 } },
|
2015-08-12 01:21:46 +08:00
|
|
|
{ 270000,
|
2013-09-04 01:30:37 +08:00
|
|
|
{ .p1 = 1, .p2 = 10, .n = 1, .m1 = 14, .m2 = 2 } }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct dp_link_dpll pch_dpll[] = {
|
2015-08-12 01:21:46 +08:00
|
|
|
{ 162000,
|
2013-09-04 01:30:37 +08:00
|
|
|
{ .p1 = 2, .p2 = 10, .n = 1, .m1 = 12, .m2 = 9 } },
|
2015-08-12 01:21:46 +08:00
|
|
|
{ 270000,
|
2013-09-04 01:30:37 +08:00
|
|
|
{ .p1 = 1, .p2 = 10, .n = 2, .m1 = 14, .m2 = 8 } }
|
|
|
|
};
|
|
|
|
|
2013-09-04 01:30:38 +08:00
|
|
|
static const struct dp_link_dpll vlv_dpll[] = {
|
2015-08-12 01:21:46 +08:00
|
|
|
{ 162000,
|
2013-09-25 15:47:51 +08:00
|
|
|
{ .p1 = 3, .p2 = 2, .n = 5, .m1 = 3, .m2 = 81 } },
|
2015-08-12 01:21:46 +08:00
|
|
|
{ 270000,
|
2013-09-04 01:30:38 +08:00
|
|
|
{ .p1 = 2, .p2 = 2, .n = 1, .m1 = 2, .m2 = 27 } }
|
|
|
|
};
|
|
|
|
|
2014-04-09 18:28:18 +08:00
|
|
|
/*
|
|
|
|
* CHV supports eDP 1.4 that have more link rates.
|
|
|
|
* Below only provides the fixed rate but exclude variable rate.
|
|
|
|
*/
|
|
|
|
static const struct dp_link_dpll chv_dpll[] = {
|
|
|
|
/*
|
|
|
|
* CHV requires to program fractional division for m2.
|
|
|
|
* m2 is stored in fixed point format using formula below
|
|
|
|
* (m2_int << 22) | m2_fraction
|
|
|
|
*/
|
2015-08-12 01:21:46 +08:00
|
|
|
{ 162000, /* m2_int = 32, m2_fraction = 1677722 */
|
2014-04-09 18:28:18 +08:00
|
|
|
{ .p1 = 4, .p2 = 2, .n = 1, .m1 = 2, .m2 = 0x819999a } },
|
2015-08-12 01:21:46 +08:00
|
|
|
{ 270000, /* m2_int = 27, m2_fraction = 0 */
|
2014-04-09 18:28:18 +08:00
|
|
|
{ .p1 = 4, .p2 = 1, .n = 1, .m1 = 2, .m2 = 0x6c00000 } },
|
2015-08-12 01:21:46 +08:00
|
|
|
{ 540000, /* m2_int = 27, m2_fraction = 0 */
|
2014-04-09 18:28:18 +08:00
|
|
|
{ .p1 = 2, .p2 = 1, .n = 1, .m1 = 2, .m2 = 0x6c00000 } }
|
|
|
|
};
|
2015-05-07 12:22:08 +08:00
|
|
|
|
2015-05-26 20:20:13 +08:00
|
|
|
static const int bxt_rates[] = { 162000, 216000, 243000, 270000,
|
|
|
|
324000, 432000, 540000 };
|
2015-05-07 12:22:08 +08:00
|
|
|
static const int skl_rates[] = { 162000, 216000, 270000,
|
2015-03-12 23:10:27 +08:00
|
|
|
324000, 432000, 540000 };
|
2017-08-11 06:40:08 +08:00
|
|
|
static const int cnl_rates[] = { 162000, 216000, 270000,
|
|
|
|
324000, 432000, 540000,
|
|
|
|
648000, 810000 };
|
2015-03-12 23:10:27 +08:00
|
|
|
static const int default_rates[] = { 162000, 270000, 540000 };
|
2014-04-09 18:28:18 +08:00
|
|
|
|
2010-10-08 07:01:06 +08:00
|
|
|
/**
|
2017-08-18 17:30:20 +08:00
|
|
|
* intel_dp_is_edp - is the given port attached to an eDP panel (either CPU or PCH)
|
2010-10-08 07:01:06 +08:00
|
|
|
* @intel_dp: DP struct
|
|
|
|
*
|
|
|
|
* If a CPU or PCH DP output is attached to an eDP panel, this function
|
|
|
|
* will return true, and false otherwise.
|
|
|
|
*/
|
2017-08-18 17:30:20 +08:00
|
|
|
bool intel_dp_is_edp(struct intel_dp *intel_dp)
|
2010-10-08 07:01:06 +08:00
|
|
|
{
|
2012-10-27 05:05:46 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
|
|
|
|
return intel_dig_port->base.type == INTEL_OUTPUT_EDP;
|
2010-10-08 07:01:06 +08:00
|
|
|
}
|
|
|
|
|
2013-05-08 18:14:06 +08:00
|
|
|
static struct drm_device *intel_dp_to_dev(struct intel_dp *intel_dp)
|
2010-10-08 07:01:06 +08:00
|
|
|
{
|
2013-05-08 18:14:06 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
|
|
|
|
return intel_dig_port->base.base.dev;
|
2010-10-08 07:01:06 +08:00
|
|
|
}
|
|
|
|
|
2010-09-09 23:20:55 +08:00
|
|
|
static struct intel_dp *intel_attached_dp(struct drm_connector *connector)
|
|
|
|
{
|
2012-10-27 05:05:44 +08:00
|
|
|
return enc_to_intel_dp(&intel_attached_encoder(connector)->base);
|
2010-09-09 23:20:55 +08:00
|
|
|
}
|
|
|
|
|
2010-08-04 20:50:23 +08:00
|
|
|
static void intel_dp_link_down(struct intel_dp *intel_dp);
|
2014-08-19 18:24:25 +08:00
|
|
|
static bool edp_panel_vdd_on(struct intel_dp *intel_dp);
|
2014-01-17 21:39:48 +08:00
|
|
|
static void edp_panel_vdd_off(struct intel_dp *intel_dp, bool sync);
|
2014-10-17 02:27:33 +08:00
|
|
|
static void vlv_init_panel_power_sequencer(struct intel_dp *intel_dp);
|
2014-10-17 02:29:59 +08:00
|
|
|
static void vlv_steal_power_sequencer(struct drm_device *dev,
|
|
|
|
enum pipe pipe);
|
2016-03-30 20:35:22 +08:00
|
|
|
static void intel_dp_unset_edid(struct intel_dp *intel_dp);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2017-03-28 22:59:05 +08:00
|
|
|
static int intel_dp_num_rates(u8 link_bw_code)
|
|
|
|
{
|
|
|
|
switch (link_bw_code) {
|
|
|
|
default:
|
|
|
|
WARN(1, "invalid max DP link bw val %x, using 1.62Gbps\n",
|
|
|
|
link_bw_code);
|
|
|
|
case DP_LINK_BW_1_62:
|
|
|
|
return 1;
|
|
|
|
case DP_LINK_BW_2_7:
|
|
|
|
return 2;
|
|
|
|
case DP_LINK_BW_5_4:
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update sink rates from dpcd */
|
|
|
|
static void intel_dp_set_sink_rates(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
int i, num_rates;
|
|
|
|
|
|
|
|
num_rates = intel_dp_num_rates(intel_dp->dpcd[DP_MAX_LINK_RATE]);
|
|
|
|
|
|
|
|
for (i = 0; i < num_rates; i++)
|
|
|
|
intel_dp->sink_rates[i] = default_rates[i];
|
|
|
|
|
|
|
|
intel_dp->num_sink_rates = num_rates;
|
|
|
|
}
|
|
|
|
|
2017-04-06 21:44:13 +08:00
|
|
|
/* Theoretical max between source and sink */
|
|
|
|
static int intel_dp_max_common_rate(struct intel_dp *intel_dp)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2017-04-06 21:44:13 +08:00
|
|
|
return intel_dp->common_rates[intel_dp->num_common_rates - 1];
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2017-04-06 21:44:13 +08:00
|
|
|
/* Theoretical max between source and sink */
|
|
|
|
static int intel_dp_max_common_lane_count(struct intel_dp *intel_dp)
|
2014-05-06 19:56:50 +08:00
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2017-04-06 21:44:13 +08:00
|
|
|
int source_max = intel_dig_port->max_lanes;
|
|
|
|
int sink_max = drm_dp_max_lane_count(intel_dp->dpcd);
|
2014-05-06 19:56:50 +08:00
|
|
|
|
|
|
|
return min(source_max, sink_max);
|
|
|
|
}
|
|
|
|
|
2017-04-06 21:44:14 +08:00
|
|
|
int intel_dp_max_lane_count(struct intel_dp *intel_dp)
|
2017-04-06 21:44:13 +08:00
|
|
|
{
|
|
|
|
return intel_dp->max_link_lane_count;
|
|
|
|
}
|
|
|
|
|
2016-11-16 04:59:06 +08:00
|
|
|
int
|
2012-01-26 00:16:25 +08:00
|
|
|
intel_dp_link_required(int pixel_clock, int bpp)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
drm/i915: Fix DP link rate math
We store DP link rates as link clock frequencies in kHz, just like all
other clock values. But, DP link rates in the DP Spec. are expressed in
Gbps/lane, which seems to have led to some confusion.
E.g., for HBR2
Max. data rate = 5.4 Gbps/lane x 4 lane x 8/10 x 1/8 = 2160000 kBps
where, 8/10 is for channel encoding and 1/8 is for bit to Byte conversion
Using link clock frequency, like we do
Max. data rate = 540000 kHz * 4 lanes = 2160000 kSymbols/s
Because, each symbol has 8 bit of data, this is 2160000 kBps
and there is no need to account for channel encoding here.
But, currently we do 540000 kHz * 4 lanes * (8/10) = 1728000 kBps
Similarly, while computing the required link bandwidth for a mode,
there is a mysterious 1/10 term.
This should simply be pixel_clock kHz * (bpp/8) to give the final result in
kBps
v2: Changed to DIV_ROUND_UP() and comment changes (Ville)
Signed-off-by: Dhinakaran Pandiyan <dhinakaran.pandiyan@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/1479160220-17794-1-git-send-email-dhinakaran.pandiyan@intel.com
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
2016-11-15 05:50:20 +08:00
|
|
|
/* pixel_clock is in kHz, divide bpp by 8 for bit to Byte conversion */
|
|
|
|
return DIV_ROUND_UP(pixel_clock * bpp, 8);
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2016-11-16 04:59:06 +08:00
|
|
|
int
|
2010-06-30 09:46:17 +08:00
|
|
|
intel_dp_max_data_rate(int max_link_clock, int max_lanes)
|
|
|
|
{
|
drm/i915: Fix DP link rate math
We store DP link rates as link clock frequencies in kHz, just like all
other clock values. But, DP link rates in the DP Spec. are expressed in
Gbps/lane, which seems to have led to some confusion.
E.g., for HBR2
Max. data rate = 5.4 Gbps/lane x 4 lane x 8/10 x 1/8 = 2160000 kBps
where, 8/10 is for channel encoding and 1/8 is for bit to Byte conversion
Using link clock frequency, like we do
Max. data rate = 540000 kHz * 4 lanes = 2160000 kSymbols/s
Because, each symbol has 8 bit of data, this is 2160000 kBps
and there is no need to account for channel encoding here.
But, currently we do 540000 kHz * 4 lanes * (8/10) = 1728000 kBps
Similarly, while computing the required link bandwidth for a mode,
there is a mysterious 1/10 term.
This should simply be pixel_clock kHz * (bpp/8) to give the final result in
kBps
v2: Changed to DIV_ROUND_UP() and comment changes (Ville)
Signed-off-by: Dhinakaran Pandiyan <dhinakaran.pandiyan@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/1479160220-17794-1-git-send-email-dhinakaran.pandiyan@intel.com
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
2016-11-15 05:50:20 +08:00
|
|
|
/* max_link_clock is the link symbol clock (LS_Clk) in kHz and not the
|
|
|
|
* link rate that is generally expressed in Gbps. Since, 8 bits of data
|
|
|
|
* is transmitted every LS_Clk per lane, there is no need to account for
|
|
|
|
* the channel encoding that is done in the PHY layer here.
|
|
|
|
*/
|
|
|
|
|
|
|
|
return max_link_clock * max_lanes;
|
2010-06-30 09:46:17 +08:00
|
|
|
}
|
|
|
|
|
2016-09-09 19:10:55 +08:00
|
|
|
static int
|
|
|
|
intel_dp_downstream_max_dotclock(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct intel_encoder *encoder = &intel_dig_port->base;
|
|
|
|
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
|
|
|
int max_dotclk = dev_priv->max_dotclk_freq;
|
|
|
|
int ds_max_dotclk;
|
|
|
|
|
|
|
|
int type = intel_dp->downstream_ports[0] & DP_DS_PORT_TYPE_MASK;
|
|
|
|
|
|
|
|
if (type != DP_DS_PORT_TYPE_VGA)
|
|
|
|
return max_dotclk;
|
|
|
|
|
|
|
|
ds_max_dotclk = drm_dp_downstream_max_clock(intel_dp->dpcd,
|
|
|
|
intel_dp->downstream_ports);
|
|
|
|
|
|
|
|
if (ds_max_dotclk != 0)
|
|
|
|
max_dotclk = min(max_dotclk, ds_max_dotclk);
|
|
|
|
|
|
|
|
return max_dotclk;
|
|
|
|
}
|
|
|
|
|
2017-03-28 22:59:04 +08:00
|
|
|
static void
|
|
|
|
intel_dp_set_source_rates(struct intel_dp *intel_dp)
|
2016-10-27 07:25:55 +08:00
|
|
|
{
|
|
|
|
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
|
2017-08-11 06:40:08 +08:00
|
|
|
enum port port = dig_port->port;
|
2017-03-28 22:59:04 +08:00
|
|
|
const int *source_rates;
|
2016-10-27 07:25:55 +08:00
|
|
|
int size;
|
2017-08-11 06:40:08 +08:00
|
|
|
u32 voltage;
|
2016-10-27 07:25:55 +08:00
|
|
|
|
2017-03-28 22:59:04 +08:00
|
|
|
/* This should only be done once */
|
|
|
|
WARN_ON(intel_dp->source_rates || intel_dp->num_source_rates);
|
|
|
|
|
2016-12-02 16:23:49 +08:00
|
|
|
if (IS_GEN9_LP(dev_priv)) {
|
2017-03-28 22:59:04 +08:00
|
|
|
source_rates = bxt_rates;
|
2016-10-27 07:25:55 +08:00
|
|
|
size = ARRAY_SIZE(bxt_rates);
|
2017-08-11 06:40:08 +08:00
|
|
|
} else if (IS_CANNONLAKE(dev_priv)) {
|
|
|
|
source_rates = cnl_rates;
|
|
|
|
size = ARRAY_SIZE(cnl_rates);
|
|
|
|
voltage = I915_READ(CNL_PORT_COMP_DW3) & VOLTAGE_INFO_MASK;
|
|
|
|
if (port == PORT_A || port == PORT_D ||
|
|
|
|
voltage == VOLTAGE_INFO_0_85V)
|
|
|
|
size -= 2;
|
2017-01-24 02:32:37 +08:00
|
|
|
} else if (IS_GEN9_BC(dev_priv)) {
|
2017-03-28 22:59:04 +08:00
|
|
|
source_rates = skl_rates;
|
2016-10-27 07:25:55 +08:00
|
|
|
size = ARRAY_SIZE(skl_rates);
|
|
|
|
} else {
|
2017-03-28 22:59:04 +08:00
|
|
|
source_rates = default_rates;
|
2016-10-27 07:25:55 +08:00
|
|
|
size = ARRAY_SIZE(default_rates);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This depends on the fact that 5.4 is last value in the array */
|
|
|
|
if (!intel_dp_source_supports_hbr2(intel_dp))
|
|
|
|
size--;
|
|
|
|
|
2017-03-28 22:59:04 +08:00
|
|
|
intel_dp->source_rates = source_rates;
|
|
|
|
intel_dp->num_source_rates = size;
|
2016-10-27 07:25:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int intersect_rates(const int *source_rates, int source_len,
|
|
|
|
const int *sink_rates, int sink_len,
|
|
|
|
int *common_rates)
|
|
|
|
{
|
|
|
|
int i = 0, j = 0, k = 0;
|
|
|
|
|
|
|
|
while (i < source_len && j < sink_len) {
|
|
|
|
if (source_rates[i] == sink_rates[j]) {
|
|
|
|
if (WARN_ON(k >= DP_MAX_SUPPORTED_RATES))
|
|
|
|
return k;
|
|
|
|
common_rates[k] = source_rates[i];
|
|
|
|
++k;
|
|
|
|
++i;
|
|
|
|
++j;
|
|
|
|
} else if (source_rates[i] < sink_rates[j]) {
|
|
|
|
++i;
|
|
|
|
} else {
|
|
|
|
++j;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return k;
|
|
|
|
}
|
|
|
|
|
2017-03-28 22:59:03 +08:00
|
|
|
/* return index of rate in rates array, or -1 if not found */
|
|
|
|
static int intel_dp_rate_index(const int *rates, int len, int rate)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
if (rate == rates[i])
|
|
|
|
return i;
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-04-06 21:44:10 +08:00
|
|
|
static void intel_dp_set_common_rates(struct intel_dp *intel_dp)
|
2016-10-27 07:25:55 +08:00
|
|
|
{
|
2017-04-06 21:44:10 +08:00
|
|
|
WARN_ON(!intel_dp->num_source_rates || !intel_dp->num_sink_rates);
|
2016-10-27 07:25:55 +08:00
|
|
|
|
2017-04-06 21:44:10 +08:00
|
|
|
intel_dp->num_common_rates = intersect_rates(intel_dp->source_rates,
|
|
|
|
intel_dp->num_source_rates,
|
|
|
|
intel_dp->sink_rates,
|
|
|
|
intel_dp->num_sink_rates,
|
|
|
|
intel_dp->common_rates);
|
|
|
|
|
|
|
|
/* Paranoia, there should always be something in common. */
|
|
|
|
if (WARN_ON(intel_dp->num_common_rates == 0)) {
|
|
|
|
intel_dp->common_rates[0] = default_rates[0];
|
|
|
|
intel_dp->num_common_rates = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get length of common rates potentially limited by max_rate */
|
|
|
|
static int intel_dp_common_len_rate_limit(struct intel_dp *intel_dp,
|
|
|
|
int max_rate)
|
|
|
|
{
|
|
|
|
const int *common_rates = intel_dp->common_rates;
|
|
|
|
int i, common_len = intel_dp->num_common_rates;
|
2017-03-28 22:59:05 +08:00
|
|
|
|
|
|
|
/* Limit results by potentially reduced max rate */
|
|
|
|
for (i = 0; i < common_len; i++) {
|
|
|
|
if (common_rates[common_len - i - 1] <= max_rate)
|
|
|
|
return common_len - i;
|
|
|
|
}
|
2016-10-27 07:25:55 +08:00
|
|
|
|
2017-03-28 22:59:05 +08:00
|
|
|
return 0;
|
2016-10-27 07:25:55 +08:00
|
|
|
}
|
|
|
|
|
2017-06-09 04:41:02 +08:00
|
|
|
static bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
|
|
|
|
uint8_t lane_count)
|
2017-04-07 05:00:12 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* FIXME: we need to synchronize the current link parameters with
|
|
|
|
* hardware readout. Currently fast link training doesn't work on
|
|
|
|
* boot-up.
|
|
|
|
*/
|
2017-06-09 04:41:02 +08:00
|
|
|
if (link_rate == 0 ||
|
|
|
|
link_rate > intel_dp->max_link_rate)
|
2017-04-07 05:00:12 +08:00
|
|
|
return false;
|
|
|
|
|
2017-06-09 04:41:02 +08:00
|
|
|
if (lane_count == 0 ||
|
|
|
|
lane_count > intel_dp_max_lane_count(intel_dp))
|
2017-04-07 05:00:12 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-12-09 11:05:12 +08:00
|
|
|
int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,
|
|
|
|
int link_rate, uint8_t lane_count)
|
|
|
|
{
|
2017-04-06 21:44:11 +08:00
|
|
|
int index;
|
2016-12-09 11:05:12 +08:00
|
|
|
|
2017-04-06 21:44:11 +08:00
|
|
|
index = intel_dp_rate_index(intel_dp->common_rates,
|
|
|
|
intel_dp->num_common_rates,
|
|
|
|
link_rate);
|
|
|
|
if (index > 0) {
|
2017-04-06 21:44:12 +08:00
|
|
|
intel_dp->max_link_rate = intel_dp->common_rates[index - 1];
|
|
|
|
intel_dp->max_link_lane_count = lane_count;
|
2016-12-09 11:05:12 +08:00
|
|
|
} else if (lane_count > 1) {
|
2017-04-06 21:44:13 +08:00
|
|
|
intel_dp->max_link_rate = intel_dp_max_common_rate(intel_dp);
|
2017-04-06 21:44:12 +08:00
|
|
|
intel_dp->max_link_lane_count = lane_count >> 1;
|
2016-12-09 11:05:12 +08:00
|
|
|
} else {
|
|
|
|
DRM_ERROR("Link Training Unsuccessful\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-28 23:29:18 +08:00
|
|
|
static enum drm_mode_status
|
2009-04-08 07:16:42 +08:00
|
|
|
intel_dp_mode_valid(struct drm_connector *connector,
|
|
|
|
struct drm_display_mode *mode)
|
|
|
|
{
|
2010-09-09 23:20:55 +08:00
|
|
|
struct intel_dp *intel_dp = intel_attached_dp(connector);
|
2012-10-19 19:51:50 +08:00
|
|
|
struct intel_connector *intel_connector = to_intel_connector(connector);
|
|
|
|
struct drm_display_mode *fixed_mode = intel_connector->panel.fixed_mode;
|
2013-03-27 07:44:59 +08:00
|
|
|
int target_clock = mode->clock;
|
|
|
|
int max_rate, mode_rate, max_lanes, max_link_clock;
|
2016-09-09 19:10:55 +08:00
|
|
|
int max_dotclk;
|
|
|
|
|
|
|
|
max_dotclk = intel_dp_downstream_max_dotclock(intel_dp);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp) && fixed_mode) {
|
2012-10-19 19:51:50 +08:00
|
|
|
if (mode->hdisplay > fixed_mode->hdisplay)
|
2010-07-19 16:43:14 +08:00
|
|
|
return MODE_PANEL;
|
|
|
|
|
2012-10-19 19:51:50 +08:00
|
|
|
if (mode->vdisplay > fixed_mode->vdisplay)
|
2010-07-19 16:43:14 +08:00
|
|
|
return MODE_PANEL;
|
2013-04-03 05:42:31 +08:00
|
|
|
|
|
|
|
target_clock = fixed_mode->clock;
|
2010-07-19 16:43:14 +08:00
|
|
|
}
|
|
|
|
|
2015-03-12 23:10:34 +08:00
|
|
|
max_link_clock = intel_dp_max_link_rate(intel_dp);
|
2014-05-06 19:56:50 +08:00
|
|
|
max_lanes = intel_dp_max_lane_count(intel_dp);
|
2013-03-27 07:44:59 +08:00
|
|
|
|
|
|
|
max_rate = intel_dp_max_data_rate(max_link_clock, max_lanes);
|
|
|
|
mode_rate = intel_dp_link_required(target_clock, 18);
|
|
|
|
|
2016-02-02 21:16:38 +08:00
|
|
|
if (mode_rate > max_rate || target_clock > max_dotclk)
|
2012-04-10 16:42:36 +08:00
|
|
|
return MODE_CLOCK_HIGH;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
|
|
|
if (mode->clock < 10000)
|
|
|
|
return MODE_CLOCK_LOW;
|
|
|
|
|
2012-05-23 17:30:55 +08:00
|
|
|
if (mode->flags & DRM_MODE_FLAG_DBLCLK)
|
|
|
|
return MODE_H_ILLEGAL;
|
|
|
|
|
2009-04-08 07:16:42 +08:00
|
|
|
return MODE_OK;
|
|
|
|
}
|
|
|
|
|
2014-11-15 00:52:27 +08:00
|
|
|
uint32_t intel_dp_pack_aux(const uint8_t *src, int src_bytes)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint32_t v = 0;
|
|
|
|
|
|
|
|
if (src_bytes > 4)
|
|
|
|
src_bytes = 4;
|
|
|
|
for (i = 0; i < src_bytes; i++)
|
|
|
|
v |= ((uint32_t) src[i]) << ((3-i) * 8);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2015-02-11 03:32:23 +08:00
|
|
|
static void intel_dp_unpack_aux(uint32_t src, uint8_t *dst, int dst_bytes)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
if (dst_bytes > 4)
|
|
|
|
dst_bytes = 4;
|
|
|
|
for (i = 0; i < dst_bytes; i++)
|
|
|
|
dst[i] = src >> ((3-i) * 8);
|
|
|
|
}
|
|
|
|
|
2013-09-06 12:40:05 +08:00
|
|
|
static void
|
|
|
|
intel_dp_init_panel_power_sequencer(struct drm_device *dev,
|
2014-10-17 02:27:30 +08:00
|
|
|
struct intel_dp *intel_dp);
|
2013-09-06 12:40:05 +08:00
|
|
|
static void
|
|
|
|
intel_dp_init_panel_power_sequencer_registers(struct drm_device *dev,
|
2016-12-21 00:51:17 +08:00
|
|
|
struct intel_dp *intel_dp,
|
|
|
|
bool force_disable_vdd);
|
2016-08-10 19:07:32 +08:00
|
|
|
static void
|
|
|
|
intel_dp_pps_init(struct drm_device *dev, struct intel_dp *intel_dp);
|
2013-09-06 12:40:05 +08:00
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
static void pps_lock(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct intel_encoder *encoder = &intel_dig_port->base;
|
|
|
|
struct drm_device *dev = encoder->base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-09-04 19:54:56 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* See vlv_power_sequencer_reset() why we need
|
|
|
|
* a power domain reference here.
|
|
|
|
*/
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_get(dev_priv, intel_dp->aux_power_domain);
|
2014-09-04 19:54:56 +08:00
|
|
|
|
|
|
|
mutex_lock(&dev_priv->pps_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pps_unlock(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct intel_encoder *encoder = &intel_dig_port->base;
|
|
|
|
struct drm_device *dev = encoder->base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-09-04 19:54:56 +08:00
|
|
|
|
|
|
|
mutex_unlock(&dev_priv->pps_mutex);
|
|
|
|
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_put(dev_priv, intel_dp->aux_power_domain);
|
2014-09-04 19:54:56 +08:00
|
|
|
}
|
|
|
|
|
2014-10-17 02:29:42 +08:00
|
|
|
static void
|
|
|
|
vlv_power_sequencer_kick(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2016-11-01 04:37:07 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_dig_port->base.base.dev);
|
2014-10-17 02:29:42 +08:00
|
|
|
enum pipe pipe = intel_dp->pps_pipe;
|
2015-07-10 15:56:24 +08:00
|
|
|
bool pll_enabled, release_cl_override = false;
|
|
|
|
enum dpio_phy phy = DPIO_PHY(pipe);
|
|
|
|
enum dpio_channel ch = vlv_pipe_to_channel(pipe);
|
2014-10-17 02:29:42 +08:00
|
|
|
uint32_t DP;
|
|
|
|
|
|
|
|
if (WARN(I915_READ(intel_dp->output_reg) & DP_PORT_EN,
|
|
|
|
"skipping pipe %c power seqeuncer kick due to port %c being active\n",
|
|
|
|
pipe_name(pipe), port_name(intel_dig_port->port)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("kicking pipe %c power sequencer for port %c\n",
|
|
|
|
pipe_name(pipe), port_name(intel_dig_port->port));
|
|
|
|
|
|
|
|
/* Preserve the BIOS-computed detected bit. This is
|
|
|
|
* supposed to be read-only.
|
|
|
|
*/
|
|
|
|
DP = I915_READ(intel_dp->output_reg) & DP_DETECTED;
|
|
|
|
DP |= DP_VOLTAGE_0_4 | DP_PRE_EMPHASIS_0;
|
|
|
|
DP |= DP_PORT_WIDTH(1);
|
|
|
|
DP |= DP_LINK_TRAIN_PAT_1;
|
|
|
|
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_CHERRYVIEW(dev_priv))
|
2014-10-17 02:29:42 +08:00
|
|
|
DP |= DP_PIPE_SELECT_CHV(pipe);
|
|
|
|
else if (pipe == PIPE_B)
|
|
|
|
DP |= DP_PIPEB_SELECT;
|
|
|
|
|
2014-10-28 19:20:22 +08:00
|
|
|
pll_enabled = I915_READ(DPLL(pipe)) & DPLL_VCO_ENABLE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The DPLL for the pipe must be enabled for this to work.
|
|
|
|
* So enable temporarily it if it's not already enabled.
|
|
|
|
*/
|
2015-07-10 15:56:24 +08:00
|
|
|
if (!pll_enabled) {
|
2016-10-14 17:13:44 +08:00
|
|
|
release_cl_override = IS_CHERRYVIEW(dev_priv) &&
|
2015-07-10 15:56:24 +08:00
|
|
|
!chv_phy_powergate_ch(dev_priv, phy, ch, true);
|
|
|
|
|
2016-11-01 04:37:07 +08:00
|
|
|
if (vlv_force_pll_on(dev_priv, pipe, IS_CHERRYVIEW(dev_priv) ?
|
2016-01-19 23:25:17 +08:00
|
|
|
&chv_dpll[0].dpll : &vlv_dpll[0].dpll)) {
|
|
|
|
DRM_ERROR("Failed to force on pll for pipe %c!\n",
|
|
|
|
pipe_name(pipe));
|
|
|
|
return;
|
|
|
|
}
|
2015-07-10 15:56:24 +08:00
|
|
|
}
|
2014-10-28 19:20:22 +08:00
|
|
|
|
2014-10-17 02:29:42 +08:00
|
|
|
/*
|
|
|
|
* Similar magic as in intel_dp_enable_port().
|
|
|
|
* We _must_ do this port enable + disable trick
|
|
|
|
* to make this power seqeuencer lock onto the port.
|
|
|
|
* Otherwise even VDD force bit won't work.
|
|
|
|
*/
|
|
|
|
I915_WRITE(intel_dp->output_reg, DP);
|
|
|
|
POSTING_READ(intel_dp->output_reg);
|
|
|
|
|
|
|
|
I915_WRITE(intel_dp->output_reg, DP | DP_PORT_EN);
|
|
|
|
POSTING_READ(intel_dp->output_reg);
|
|
|
|
|
|
|
|
I915_WRITE(intel_dp->output_reg, DP & ~DP_PORT_EN);
|
|
|
|
POSTING_READ(intel_dp->output_reg);
|
2014-10-28 19:20:22 +08:00
|
|
|
|
2015-07-10 15:56:24 +08:00
|
|
|
if (!pll_enabled) {
|
2016-11-01 04:37:07 +08:00
|
|
|
vlv_force_pll_off(dev_priv, pipe);
|
2015-07-10 15:56:24 +08:00
|
|
|
|
|
|
|
if (release_cl_override)
|
|
|
|
chv_phy_powergate_ch(dev_priv, phy, ch, false);
|
|
|
|
}
|
2014-10-17 02:29:42 +08:00
|
|
|
}
|
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
static enum pipe vlv_find_free_pps(struct drm_i915_private *dev_priv)
|
|
|
|
{
|
|
|
|
struct intel_encoder *encoder;
|
|
|
|
unsigned int pipes = (1 << PIPE_A) | (1 << PIPE_B);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't have power sequencer currently.
|
|
|
|
* Pick one that's not used by other ports.
|
|
|
|
*/
|
|
|
|
for_each_intel_encoder(&dev_priv->drm, encoder) {
|
|
|
|
struct intel_dp *intel_dp;
|
|
|
|
|
|
|
|
if (encoder->type != INTEL_OUTPUT_DP &&
|
|
|
|
encoder->type != INTEL_OUTPUT_EDP)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
intel_dp = enc_to_intel_dp(&encoder->base);
|
|
|
|
|
|
|
|
if (encoder->type == INTEL_OUTPUT_EDP) {
|
|
|
|
WARN_ON(intel_dp->active_pipe != INVALID_PIPE &&
|
|
|
|
intel_dp->active_pipe != intel_dp->pps_pipe);
|
|
|
|
|
|
|
|
if (intel_dp->pps_pipe != INVALID_PIPE)
|
|
|
|
pipes &= ~(1 << intel_dp->pps_pipe);
|
|
|
|
} else {
|
|
|
|
WARN_ON(intel_dp->pps_pipe != INVALID_PIPE);
|
|
|
|
|
|
|
|
if (intel_dp->active_pipe != INVALID_PIPE)
|
|
|
|
pipes &= ~(1 << intel_dp->active_pipe);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pipes == 0)
|
|
|
|
return INVALID_PIPE;
|
|
|
|
|
|
|
|
return ffs(pipes) - 1;
|
|
|
|
}
|
|
|
|
|
2013-09-06 12:40:05 +08:00
|
|
|
static enum pipe
|
|
|
|
vlv_power_sequencer_pipe(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-10-17 02:29:59 +08:00
|
|
|
enum pipe pipe;
|
2013-09-06 12:40:05 +08:00
|
|
|
|
2014-09-04 19:53:14 +08:00
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
2013-09-06 12:40:05 +08:00
|
|
|
|
2014-10-17 02:29:59 +08:00
|
|
|
/* We should never land here with regular DP ports */
|
2017-08-18 17:30:20 +08:00
|
|
|
WARN_ON(!intel_dp_is_edp(intel_dp));
|
2014-10-17 02:29:59 +08:00
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
WARN_ON(intel_dp->active_pipe != INVALID_PIPE &&
|
|
|
|
intel_dp->active_pipe != intel_dp->pps_pipe);
|
|
|
|
|
2014-09-04 19:54:20 +08:00
|
|
|
if (intel_dp->pps_pipe != INVALID_PIPE)
|
|
|
|
return intel_dp->pps_pipe;
|
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
pipe = vlv_find_free_pps(dev_priv);
|
2014-09-04 19:54:20 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Didn't find one. This should not happen since there
|
|
|
|
* are two power sequencers and up to two eDP ports.
|
|
|
|
*/
|
2016-12-15 02:00:23 +08:00
|
|
|
if (WARN_ON(pipe == INVALID_PIPE))
|
2014-10-17 02:29:59 +08:00
|
|
|
pipe = PIPE_A;
|
2014-09-04 19:54:20 +08:00
|
|
|
|
2014-10-17 02:29:59 +08:00
|
|
|
vlv_steal_power_sequencer(dev, pipe);
|
|
|
|
intel_dp->pps_pipe = pipe;
|
2014-09-04 19:54:20 +08:00
|
|
|
|
|
|
|
DRM_DEBUG_KMS("picked pipe %c power sequencer for port %c\n",
|
|
|
|
pipe_name(intel_dp->pps_pipe),
|
|
|
|
port_name(intel_dig_port->port));
|
|
|
|
|
|
|
|
/* init power sequencer on this pipe and port */
|
2014-10-17 02:27:30 +08:00
|
|
|
intel_dp_init_panel_power_sequencer(dev, intel_dp);
|
2016-12-21 00:51:17 +08:00
|
|
|
intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, true);
|
2014-09-04 19:54:20 +08:00
|
|
|
|
2014-10-17 02:29:42 +08:00
|
|
|
/*
|
|
|
|
* Even vdd force doesn't work until we've made
|
|
|
|
* the power sequencer lock in on the port.
|
|
|
|
*/
|
|
|
|
vlv_power_sequencer_kick(intel_dp);
|
2014-09-04 19:54:20 +08:00
|
|
|
|
|
|
|
return intel_dp->pps_pipe;
|
|
|
|
}
|
|
|
|
|
2016-06-16 21:37:20 +08:00
|
|
|
static int
|
|
|
|
bxt_power_sequencer_idx(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2016-06-16 21:37:20 +08:00
|
|
|
|
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
|
|
|
/* We should never land here with regular DP ports */
|
2017-08-18 17:30:20 +08:00
|
|
|
WARN_ON(!intel_dp_is_edp(intel_dp));
|
2016-06-16 21:37:20 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: BXT has 2 PPS instances. The correct port->PPS instance
|
|
|
|
* mapping needs to be retrieved from VBT, for now just hard-code to
|
|
|
|
* use instance #0 always.
|
|
|
|
*/
|
|
|
|
if (!intel_dp->pps_reset)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
intel_dp->pps_reset = false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Only the HW needs to be reprogrammed, the SW state is fixed and
|
|
|
|
* has been setup during connector init.
|
|
|
|
*/
|
2016-12-21 00:51:17 +08:00
|
|
|
intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, false);
|
2016-06-16 21:37:20 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-19 03:16:06 +08:00
|
|
|
typedef bool (*vlv_pipe_check)(struct drm_i915_private *dev_priv,
|
|
|
|
enum pipe pipe);
|
|
|
|
|
|
|
|
static bool vlv_pipe_has_pp_on(struct drm_i915_private *dev_priv,
|
|
|
|
enum pipe pipe)
|
|
|
|
{
|
2016-08-10 19:07:29 +08:00
|
|
|
return I915_READ(PP_STATUS(pipe)) & PP_ON;
|
2014-08-19 03:16:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool vlv_pipe_has_vdd_on(struct drm_i915_private *dev_priv,
|
|
|
|
enum pipe pipe)
|
|
|
|
{
|
2016-08-10 19:07:29 +08:00
|
|
|
return I915_READ(PP_CONTROL(pipe)) & EDP_FORCE_VDD;
|
2014-08-19 03:16:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool vlv_pipe_any(struct drm_i915_private *dev_priv,
|
|
|
|
enum pipe pipe)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2013-09-06 12:40:05 +08:00
|
|
|
|
2014-09-04 19:54:20 +08:00
|
|
|
static enum pipe
|
2014-08-19 03:16:06 +08:00
|
|
|
vlv_initial_pps_pipe(struct drm_i915_private *dev_priv,
|
|
|
|
enum port port,
|
|
|
|
vlv_pipe_check pipe_check)
|
2014-09-04 19:54:20 +08:00
|
|
|
{
|
|
|
|
enum pipe pipe;
|
2013-09-06 12:40:05 +08:00
|
|
|
|
|
|
|
for (pipe = PIPE_A; pipe <= PIPE_B; pipe++) {
|
2016-08-10 19:07:29 +08:00
|
|
|
u32 port_sel = I915_READ(PP_ON_DELAYS(pipe)) &
|
2013-09-06 12:40:05 +08:00
|
|
|
PANEL_PORT_SELECT_MASK;
|
2014-09-04 19:54:20 +08:00
|
|
|
|
|
|
|
if (port_sel != PANEL_PORT_SELECT_VLV(port))
|
|
|
|
continue;
|
|
|
|
|
2014-08-19 03:16:06 +08:00
|
|
|
if (!pipe_check(dev_priv, pipe))
|
|
|
|
continue;
|
|
|
|
|
2014-09-04 19:54:20 +08:00
|
|
|
return pipe;
|
2013-09-06 12:40:05 +08:00
|
|
|
}
|
|
|
|
|
2014-09-04 19:54:20 +08:00
|
|
|
return INVALID_PIPE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
vlv_initial_power_sequencer_setup(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-09-04 19:54:20 +08:00
|
|
|
enum port port = intel_dig_port->port;
|
|
|
|
|
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
|
|
|
/* try to find a pipe with this port selected */
|
2014-08-19 03:16:06 +08:00
|
|
|
/* first pick one where the panel is on */
|
|
|
|
intel_dp->pps_pipe = vlv_initial_pps_pipe(dev_priv, port,
|
|
|
|
vlv_pipe_has_pp_on);
|
|
|
|
/* didn't find one? pick one where vdd is on */
|
|
|
|
if (intel_dp->pps_pipe == INVALID_PIPE)
|
|
|
|
intel_dp->pps_pipe = vlv_initial_pps_pipe(dev_priv, port,
|
|
|
|
vlv_pipe_has_vdd_on);
|
|
|
|
/* didn't find one? pick one with just the correct port */
|
|
|
|
if (intel_dp->pps_pipe == INVALID_PIPE)
|
|
|
|
intel_dp->pps_pipe = vlv_initial_pps_pipe(dev_priv, port,
|
|
|
|
vlv_pipe_any);
|
2014-09-04 19:54:20 +08:00
|
|
|
|
|
|
|
/* didn't find one? just let vlv_power_sequencer_pipe() pick one when needed */
|
|
|
|
if (intel_dp->pps_pipe == INVALID_PIPE) {
|
|
|
|
DRM_DEBUG_KMS("no initial power sequencer for port %c\n",
|
|
|
|
port_name(port));
|
|
|
|
return;
|
2013-09-06 12:40:05 +08:00
|
|
|
}
|
|
|
|
|
2014-09-04 19:54:20 +08:00
|
|
|
DRM_DEBUG_KMS("initial power sequencer for port %c: pipe %c\n",
|
|
|
|
port_name(port), pipe_name(intel_dp->pps_pipe));
|
|
|
|
|
2014-10-17 02:27:30 +08:00
|
|
|
intel_dp_init_panel_power_sequencer(dev, intel_dp);
|
2016-12-21 00:51:17 +08:00
|
|
|
intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, false);
|
2013-09-06 12:40:05 +08:00
|
|
|
}
|
|
|
|
|
2016-06-16 21:37:20 +08:00
|
|
|
void intel_power_sequencer_reset(struct drm_i915_private *dev_priv)
|
2014-09-04 19:54:56 +08:00
|
|
|
{
|
2016-07-05 17:40:23 +08:00
|
|
|
struct drm_device *dev = &dev_priv->drm;
|
2014-09-04 19:54:56 +08:00
|
|
|
struct intel_encoder *encoder;
|
|
|
|
|
2016-10-14 17:13:44 +08:00
|
|
|
if (WARN_ON(!IS_VALLEYVIEW(dev_priv) && !IS_CHERRYVIEW(dev_priv) &&
|
2016-12-02 16:23:49 +08:00
|
|
|
!IS_GEN9_LP(dev_priv)))
|
2014-09-04 19:54:56 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can't grab pps_mutex here due to deadlock with power_domain
|
|
|
|
* mutex when power_domain functions are called while holding pps_mutex.
|
|
|
|
* That also means that in order to use pps_pipe the code needs to
|
|
|
|
* hold both a power domain reference and pps_mutex, and the power domain
|
|
|
|
* reference get/put must be done while _not_ holding pps_mutex.
|
|
|
|
* pps_{lock,unlock}() do these steps in the correct order, so one
|
|
|
|
* should use them always.
|
|
|
|
*/
|
|
|
|
|
2015-12-16 18:48:16 +08:00
|
|
|
for_each_intel_encoder(dev, encoder) {
|
2014-09-04 19:54:56 +08:00
|
|
|
struct intel_dp *intel_dp;
|
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
if (encoder->type != INTEL_OUTPUT_DP &&
|
|
|
|
encoder->type != INTEL_OUTPUT_EDP)
|
2014-09-04 19:54:56 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
intel_dp = enc_to_intel_dp(&encoder->base);
|
2016-12-15 02:00:23 +08:00
|
|
|
|
|
|
|
WARN_ON(intel_dp->active_pipe != INVALID_PIPE);
|
|
|
|
|
|
|
|
if (encoder->type != INTEL_OUTPUT_EDP)
|
|
|
|
continue;
|
|
|
|
|
2016-12-02 16:23:49 +08:00
|
|
|
if (IS_GEN9_LP(dev_priv))
|
2016-06-16 21:37:20 +08:00
|
|
|
intel_dp->pps_reset = true;
|
|
|
|
else
|
|
|
|
intel_dp->pps_pipe = INVALID_PIPE;
|
2014-09-04 19:54:56 +08:00
|
|
|
}
|
2013-09-06 12:40:05 +08:00
|
|
|
}
|
|
|
|
|
2016-06-16 21:37:21 +08:00
|
|
|
struct pps_registers {
|
|
|
|
i915_reg_t pp_ctrl;
|
|
|
|
i915_reg_t pp_stat;
|
|
|
|
i915_reg_t pp_on;
|
|
|
|
i915_reg_t pp_off;
|
|
|
|
i915_reg_t pp_div;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void intel_pps_get_registers(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_dp *intel_dp,
|
|
|
|
struct pps_registers *regs)
|
|
|
|
{
|
2016-08-10 19:07:29 +08:00
|
|
|
int pps_idx = 0;
|
|
|
|
|
2016-06-16 21:37:21 +08:00
|
|
|
memset(regs, 0, sizeof(*regs));
|
|
|
|
|
2016-12-02 16:23:49 +08:00
|
|
|
if (IS_GEN9_LP(dev_priv))
|
2016-08-10 19:07:29 +08:00
|
|
|
pps_idx = bxt_power_sequencer_idx(intel_dp);
|
|
|
|
else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
|
|
|
|
pps_idx = vlv_power_sequencer_pipe(intel_dp);
|
2016-06-16 21:37:21 +08:00
|
|
|
|
2016-08-10 19:07:29 +08:00
|
|
|
regs->pp_ctrl = PP_CONTROL(pps_idx);
|
|
|
|
regs->pp_stat = PP_STATUS(pps_idx);
|
|
|
|
regs->pp_on = PP_ON_DELAYS(pps_idx);
|
|
|
|
regs->pp_off = PP_OFF_DELAYS(pps_idx);
|
2017-06-03 04:06:44 +08:00
|
|
|
if (!IS_GEN9_LP(dev_priv) && !HAS_PCH_CNP(dev_priv))
|
2016-08-10 19:07:29 +08:00
|
|
|
regs->pp_div = PP_DIVISOR(pps_idx);
|
2016-06-16 21:37:21 +08:00
|
|
|
}
|
|
|
|
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
static i915_reg_t
|
|
|
|
_pp_ctrl_reg(struct intel_dp *intel_dp)
|
2013-09-06 12:40:05 +08:00
|
|
|
{
|
2016-06-16 21:37:21 +08:00
|
|
|
struct pps_registers regs;
|
2013-09-06 12:40:05 +08:00
|
|
|
|
2016-06-16 21:37:21 +08:00
|
|
|
intel_pps_get_registers(to_i915(intel_dp_to_dev(intel_dp)), intel_dp,
|
|
|
|
®s);
|
|
|
|
|
|
|
|
return regs.pp_ctrl;
|
2013-09-06 12:40:05 +08:00
|
|
|
}
|
|
|
|
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
static i915_reg_t
|
|
|
|
_pp_stat_reg(struct intel_dp *intel_dp)
|
2013-09-06 12:40:05 +08:00
|
|
|
{
|
2016-06-16 21:37:21 +08:00
|
|
|
struct pps_registers regs;
|
2013-09-06 12:40:05 +08:00
|
|
|
|
2016-06-16 21:37:21 +08:00
|
|
|
intel_pps_get_registers(to_i915(intel_dp_to_dev(intel_dp)), intel_dp,
|
|
|
|
®s);
|
|
|
|
|
|
|
|
return regs.pp_stat;
|
2013-09-06 12:40:05 +08:00
|
|
|
}
|
|
|
|
|
2014-07-08 04:01:46 +08:00
|
|
|
/* Reboot notifier handler to shutdown panel power to guarantee T12 timing
|
|
|
|
This function only applicable when panel PM state is not to be tracked */
|
|
|
|
static int edp_notify_handler(struct notifier_block *this, unsigned long code,
|
|
|
|
void *unused)
|
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = container_of(this, typeof(* intel_dp),
|
|
|
|
edp_notifier);
|
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-07-08 04:01:46 +08:00
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp) || code != SYS_RESTART)
|
2014-07-08 04:01:46 +08:00
|
|
|
return 0;
|
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_lock(intel_dp);
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
|
2014-09-04 19:53:14 +08:00
|
|
|
enum pipe pipe = vlv_power_sequencer_pipe(intel_dp);
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_reg_t pp_ctrl_reg, pp_div_reg;
|
2015-09-23 00:50:01 +08:00
|
|
|
u32 pp_div;
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2016-08-10 19:07:29 +08:00
|
|
|
pp_ctrl_reg = PP_CONTROL(pipe);
|
|
|
|
pp_div_reg = PP_DIVISOR(pipe);
|
2014-07-08 04:01:46 +08:00
|
|
|
pp_div = I915_READ(pp_div_reg);
|
|
|
|
pp_div &= PP_REFERENCE_DIVIDER_MASK;
|
|
|
|
|
|
|
|
/* 0x1F write to PP_DIV_REG sets max cycle delay */
|
|
|
|
I915_WRITE(pp_div_reg, pp_div | 0x1F);
|
|
|
|
I915_WRITE(pp_ctrl_reg, PANEL_UNLOCK_REGS | PANEL_POWER_OFF);
|
|
|
|
msleep(intel_dp->panel_power_cycle_delay);
|
|
|
|
}
|
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2014-07-08 04:01:46 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
static bool edp_have_panel_power(struct intel_dp *intel_dp)
|
2011-09-30 06:53:27 +08:00
|
|
|
{
|
2012-10-27 05:05:45 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2011-09-30 06:53:27 +08:00
|
|
|
|
2014-09-04 19:53:14 +08:00
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
2016-10-14 17:13:44 +08:00
|
|
|
if ((IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) &&
|
2014-10-17 02:29:48 +08:00
|
|
|
intel_dp->pps_pipe == INVALID_PIPE)
|
|
|
|
return false;
|
|
|
|
|
2013-09-06 12:40:05 +08:00
|
|
|
return (I915_READ(_pp_stat_reg(intel_dp)) & PP_ON) != 0;
|
2011-09-30 06:53:27 +08:00
|
|
|
}
|
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
static bool edp_have_panel_vdd(struct intel_dp *intel_dp)
|
2011-09-30 06:53:27 +08:00
|
|
|
{
|
2012-10-27 05:05:45 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2011-09-30 06:53:27 +08:00
|
|
|
|
2014-09-04 19:53:14 +08:00
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
2016-10-14 17:13:44 +08:00
|
|
|
if ((IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) &&
|
2014-10-17 02:29:48 +08:00
|
|
|
intel_dp->pps_pipe == INVALID_PIPE)
|
|
|
|
return false;
|
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
return I915_READ(_pp_ctrl_reg(intel_dp)) & EDP_FORCE_VDD;
|
2011-09-30 06:53:27 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 04:54:47 +08:00
|
|
|
static void
|
|
|
|
intel_dp_check_edp(struct intel_dp *intel_dp)
|
|
|
|
{
|
2012-10-27 05:05:45 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2011-09-30 06:53:27 +08:00
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2011-09-20 04:54:47 +08:00
|
|
|
return;
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
if (!edp_have_panel_power(intel_dp) && !edp_have_panel_vdd(intel_dp)) {
|
2011-09-20 04:54:47 +08:00
|
|
|
WARN(1, "eDP powered off while attempting aux channel communication.\n");
|
|
|
|
DRM_DEBUG_KMS("Status 0x%08x Control 0x%08x\n",
|
2013-09-06 12:40:05 +08:00
|
|
|
I915_READ(_pp_stat_reg(intel_dp)),
|
|
|
|
I915_READ(_pp_ctrl_reg(intel_dp)));
|
2011-09-20 04:54:47 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
static uint32_t
|
|
|
|
intel_dp_aux_wait_done(struct intel_dp *intel_dp, bool has_aux_irq)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_reg_t ch_ctl = intel_dp->aux_ch_ctl_reg;
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
uint32_t status;
|
|
|
|
bool done;
|
|
|
|
|
2012-12-02 04:03:59 +08:00
|
|
|
#define C (((status = I915_READ_NOTRACE(ch_ctl)) & DP_AUX_CH_CTL_SEND_BUSY) == 0)
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
if (has_aux_irq)
|
2013-02-19 06:00:24 +08:00
|
|
|
done = wait_event_timeout(dev_priv->gmbus_wait_queue, C,
|
2013-05-22 01:03:20 +08:00
|
|
|
msecs_to_jiffies_timeout(10));
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
else
|
2016-06-28 18:37:33 +08:00
|
|
|
done = wait_for(C, 10) == 0;
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
if (!done)
|
|
|
|
DRM_ERROR("dp aux hw did not signal timeout (has irq: %i)!\n",
|
|
|
|
has_aux_irq);
|
|
|
|
#undef C
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2016-03-02 23:22:14 +08:00
|
|
|
static uint32_t g4x_get_aux_clock_divider(struct intel_dp *intel_dp, int index)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2012-10-27 05:05:50 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2016-03-02 23:22:13 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_dig_port->base.base.dev);
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
|
2016-03-02 23:22:17 +08:00
|
|
|
if (index)
|
|
|
|
return 0;
|
|
|
|
|
2014-01-21 21:35:39 +08:00
|
|
|
/*
|
|
|
|
* The clock divider is based off the hrawclk, and would like to run at
|
2016-03-02 23:22:17 +08:00
|
|
|
* 2MHz. So, take the hrawclk value and divide by 2000 and use that
|
2009-04-08 07:16:42 +08:00
|
|
|
*/
|
2016-03-02 23:22:17 +08:00
|
|
|
return DIV_ROUND_CLOSEST(dev_priv->rawclk_freq, 2000);
|
2014-01-21 21:35:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t ilk_get_aux_clock_divider(struct intel_dp *intel_dp, int index)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2016-03-02 23:22:17 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_dig_port->base.base.dev);
|
2014-01-21 21:35:39 +08:00
|
|
|
|
|
|
|
if (index)
|
|
|
|
return 0;
|
|
|
|
|
2016-03-02 23:22:17 +08:00
|
|
|
/*
|
|
|
|
* The clock divider is based off the cdclk or PCH rawclk, and would
|
|
|
|
* like to run at 2MHz. So, take the cdclk or PCH rawclk value and
|
|
|
|
* divide by 2000 and use that
|
|
|
|
*/
|
2016-03-02 23:22:13 +08:00
|
|
|
if (intel_dig_port->port == PORT_A)
|
2017-02-08 02:33:45 +08:00
|
|
|
return DIV_ROUND_CLOSEST(dev_priv->cdclk.hw.cdclk, 2000);
|
2016-03-02 23:22:13 +08:00
|
|
|
else
|
|
|
|
return DIV_ROUND_CLOSEST(dev_priv->rawclk_freq, 2000);
|
2014-01-21 21:35:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t hsw_get_aux_clock_divider(struct intel_dp *intel_dp, int index)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2016-03-02 23:22:17 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_dig_port->base.base.dev);
|
2014-01-21 21:35:39 +08:00
|
|
|
|
2016-03-02 23:22:17 +08:00
|
|
|
if (intel_dig_port->port != PORT_A && HAS_PCH_LPT_H(dev_priv)) {
|
2013-04-09 13:11:00 +08:00
|
|
|
/* Workaround for non-ULT HSW */
|
2013-07-21 23:00:03 +08:00
|
|
|
switch (index) {
|
|
|
|
case 0: return 63;
|
|
|
|
case 1: return 72;
|
|
|
|
default: return 0;
|
|
|
|
}
|
2013-04-09 13:11:00 +08:00
|
|
|
}
|
2016-03-02 23:22:17 +08:00
|
|
|
|
|
|
|
return ilk_get_aux_clock_divider(intel_dp, index);
|
2013-07-12 05:44:57 +08:00
|
|
|
}
|
|
|
|
|
2014-01-21 00:00:59 +08:00
|
|
|
static uint32_t skl_get_aux_clock_divider(struct intel_dp *intel_dp, int index)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* SKL doesn't need us to program the AUX clock divider (Hardware will
|
|
|
|
* derive the clock from CDCLK automatically). We still implement the
|
|
|
|
* get_aux_clock_divider vfunc to plug-in into the existing code.
|
|
|
|
*/
|
|
|
|
return index ? 0 : 1;
|
|
|
|
}
|
|
|
|
|
2016-03-02 23:22:14 +08:00
|
|
|
static uint32_t g4x_get_aux_send_ctl(struct intel_dp *intel_dp,
|
|
|
|
bool has_aux_irq,
|
|
|
|
int send_bytes,
|
|
|
|
uint32_t aux_clock_divider)
|
2014-01-20 23:52:30 +08:00
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2016-10-13 18:03:00 +08:00
|
|
|
struct drm_i915_private *dev_priv =
|
|
|
|
to_i915(intel_dig_port->base.base.dev);
|
2014-01-20 23:52:30 +08:00
|
|
|
uint32_t precharge, timeout;
|
|
|
|
|
2016-10-13 18:03:00 +08:00
|
|
|
if (IS_GEN6(dev_priv))
|
2014-01-20 23:52:30 +08:00
|
|
|
precharge = 3;
|
|
|
|
else
|
|
|
|
precharge = 5;
|
|
|
|
|
2016-10-13 18:03:00 +08:00
|
|
|
if (IS_BROADWELL(dev_priv) && intel_dig_port->port == PORT_A)
|
2014-01-20 23:52:30 +08:00
|
|
|
timeout = DP_AUX_CH_CTL_TIME_OUT_600us;
|
|
|
|
else
|
|
|
|
timeout = DP_AUX_CH_CTL_TIME_OUT_400us;
|
|
|
|
|
|
|
|
return DP_AUX_CH_CTL_SEND_BUSY |
|
2014-01-20 23:52:31 +08:00
|
|
|
DP_AUX_CH_CTL_DONE |
|
2014-01-20 23:52:30 +08:00
|
|
|
(has_aux_irq ? DP_AUX_CH_CTL_INTERRUPT : 0) |
|
2014-01-20 23:52:31 +08:00
|
|
|
DP_AUX_CH_CTL_TIME_OUT_ERROR |
|
2014-01-20 23:52:30 +08:00
|
|
|
timeout |
|
2014-01-20 23:52:31 +08:00
|
|
|
DP_AUX_CH_CTL_RECEIVE_ERROR |
|
2014-01-20 23:52:30 +08:00
|
|
|
(send_bytes << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) |
|
|
|
|
(precharge << DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT) |
|
2014-01-20 23:52:31 +08:00
|
|
|
(aux_clock_divider << DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT);
|
2014-01-20 23:52:30 +08:00
|
|
|
}
|
|
|
|
|
2014-01-21 00:01:00 +08:00
|
|
|
static uint32_t skl_get_aux_send_ctl(struct intel_dp *intel_dp,
|
|
|
|
bool has_aux_irq,
|
|
|
|
int send_bytes,
|
|
|
|
uint32_t unused)
|
|
|
|
{
|
|
|
|
return DP_AUX_CH_CTL_SEND_BUSY |
|
|
|
|
DP_AUX_CH_CTL_DONE |
|
|
|
|
(has_aux_irq ? DP_AUX_CH_CTL_INTERRUPT : 0) |
|
|
|
|
DP_AUX_CH_CTL_TIME_OUT_ERROR |
|
|
|
|
DP_AUX_CH_CTL_TIME_OUT_1600us |
|
|
|
|
DP_AUX_CH_CTL_RECEIVE_ERROR |
|
|
|
|
(send_bytes << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) |
|
2016-05-19 00:47:15 +08:00
|
|
|
DP_AUX_CH_CTL_FW_SYNC_PULSE_SKL(32) |
|
2014-01-21 00:01:00 +08:00
|
|
|
DP_AUX_CH_CTL_SYNC_PULSE_SKL(32);
|
|
|
|
}
|
|
|
|
|
2013-07-12 05:44:57 +08:00
|
|
|
static int
|
|
|
|
intel_dp_aux_ch(struct intel_dp *intel_dp,
|
2014-10-02 15:45:35 +08:00
|
|
|
const uint8_t *send, int send_bytes,
|
2013-07-12 05:44:57 +08:00
|
|
|
uint8_t *recv, int recv_size)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2016-11-04 22:42:44 +08:00
|
|
|
struct drm_i915_private *dev_priv =
|
|
|
|
to_i915(intel_dig_port->base.base.dev);
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_reg_t ch_ctl = intel_dp->aux_ch_ctl_reg;
|
2013-07-21 23:00:03 +08:00
|
|
|
uint32_t aux_clock_divider;
|
2013-07-12 05:44:57 +08:00
|
|
|
int i, ret, recv_bytes;
|
|
|
|
uint32_t status;
|
2014-01-20 23:52:30 +08:00
|
|
|
int try, clock = 0;
|
2016-11-04 22:42:44 +08:00
|
|
|
bool has_aux_irq = HAS_AUX_IRQ(dev_priv);
|
2014-03-14 22:51:14 +08:00
|
|
|
bool vdd;
|
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_lock(intel_dp);
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2014-08-19 03:16:00 +08:00
|
|
|
/*
|
|
|
|
* We will be called with VDD already enabled for dpcd/edid/oui reads.
|
|
|
|
* In such cases we want to leave VDD enabled and it's up to upper layers
|
|
|
|
* to turn it off. But for eg. i2c-dev access we need to turn it on/off
|
|
|
|
* ourselves.
|
|
|
|
*/
|
2014-08-19 18:24:25 +08:00
|
|
|
vdd = edp_panel_vdd_on(intel_dp);
|
2013-07-12 05:44:57 +08:00
|
|
|
|
|
|
|
/* dp aux is extremely sensitive to irq latency, hence request the
|
|
|
|
* lowest possible wakeup latency and so prevent the cpu from going into
|
|
|
|
* deep sleep states.
|
|
|
|
*/
|
|
|
|
pm_qos_update_request(&dev_priv->pm_qos, 0);
|
|
|
|
|
|
|
|
intel_dp_check_edp(intel_dp);
|
2009-07-24 01:00:31 +08:00
|
|
|
|
2011-08-02 06:02:20 +08:00
|
|
|
/* Try to wait for any previous AUX channel activity */
|
|
|
|
for (try = 0; try < 3; try++) {
|
2012-12-02 04:03:59 +08:00
|
|
|
status = I915_READ_NOTRACE(ch_ctl);
|
2011-08-02 06:02:20 +08:00
|
|
|
if ((status & DP_AUX_CH_CTL_SEND_BUSY) == 0)
|
|
|
|
break;
|
|
|
|
msleep(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (try == 3) {
|
2015-08-06 21:48:58 +08:00
|
|
|
static u32 last_status = -1;
|
|
|
|
const u32 status = I915_READ(ch_ctl);
|
|
|
|
|
|
|
|
if (status != last_status) {
|
|
|
|
WARN(1, "dp_aux_ch not started status 0x%08x\n",
|
|
|
|
status);
|
|
|
|
last_status = status;
|
|
|
|
}
|
|
|
|
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
2010-08-19 01:12:56 +08:00
|
|
|
}
|
|
|
|
|
2013-09-17 22:14:10 +08:00
|
|
|
/* Only 5 data registers! */
|
|
|
|
if (WARN_ON(send_bytes > 20 || recv_size > 20)) {
|
|
|
|
ret = -E2BIG;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-01-21 21:35:39 +08:00
|
|
|
while ((aux_clock_divider = intel_dp->get_aux_clock_divider(intel_dp, clock++))) {
|
2014-01-21 21:37:15 +08:00
|
|
|
u32 send_ctl = intel_dp->get_aux_send_ctl(intel_dp,
|
|
|
|
has_aux_irq,
|
|
|
|
send_bytes,
|
|
|
|
aux_clock_divider);
|
2014-01-20 23:52:30 +08:00
|
|
|
|
2013-07-21 23:00:03 +08:00
|
|
|
/* Must try at least 3 times according to DP spec */
|
|
|
|
for (try = 0; try < 5; try++) {
|
|
|
|
/* Load the send data into the aux channel data registers */
|
|
|
|
for (i = 0; i < send_bytes; i += 4)
|
2015-11-12 02:34:14 +08:00
|
|
|
I915_WRITE(intel_dp->aux_ch_data_reg[i >> 2],
|
2014-11-15 00:52:27 +08:00
|
|
|
intel_dp_pack_aux(send + i,
|
|
|
|
send_bytes - i));
|
2013-07-21 23:00:03 +08:00
|
|
|
|
|
|
|
/* Send the command and wait for it to complete */
|
2014-01-20 23:52:30 +08:00
|
|
|
I915_WRITE(ch_ctl, send_ctl);
|
2013-07-21 23:00:03 +08:00
|
|
|
|
|
|
|
status = intel_dp_aux_wait_done(intel_dp, has_aux_irq);
|
|
|
|
|
|
|
|
/* Clear done status and any errors */
|
|
|
|
I915_WRITE(ch_ctl,
|
|
|
|
status |
|
|
|
|
DP_AUX_CH_CTL_DONE |
|
|
|
|
DP_AUX_CH_CTL_TIME_OUT_ERROR |
|
|
|
|
DP_AUX_CH_CTL_RECEIVE_ERROR);
|
|
|
|
|
2015-04-15 23:38:41 +08:00
|
|
|
if (status & DP_AUX_CH_CTL_TIME_OUT_ERROR)
|
2013-07-21 23:00:03 +08:00
|
|
|
continue;
|
2015-04-15 23:38:41 +08:00
|
|
|
|
|
|
|
/* DP CTS 1.2 Core Rev 1.1, 4.2.1.1 & 4.2.1.2
|
|
|
|
* 400us delay required for errors and timeouts
|
|
|
|
* Timeout errors from the HW already meet this
|
|
|
|
* requirement so skip to next iteration
|
|
|
|
*/
|
|
|
|
if (status & DP_AUX_CH_CTL_RECEIVE_ERROR) {
|
|
|
|
usleep_range(400, 500);
|
2013-07-21 23:00:03 +08:00
|
|
|
continue;
|
2015-04-15 23:38:41 +08:00
|
|
|
}
|
2013-07-21 23:00:03 +08:00
|
|
|
if (status & DP_AUX_CH_CTL_DONE)
|
2015-05-28 01:21:48 +08:00
|
|
|
goto done;
|
2013-07-21 23:00:03 +08:00
|
|
|
}
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((status & DP_AUX_CH_CTL_DONE) == 0) {
|
2009-06-29 06:42:17 +08:00
|
|
|
DRM_ERROR("dp_aux_ch not done status 0x%08x\n", status);
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2015-05-28 01:21:48 +08:00
|
|
|
done:
|
2009-04-08 07:16:42 +08:00
|
|
|
/* Check for timeout or receive error.
|
|
|
|
* Timeouts occur when the sink is not connected
|
|
|
|
*/
|
2009-06-12 13:30:32 +08:00
|
|
|
if (status & DP_AUX_CH_CTL_RECEIVE_ERROR) {
|
2009-06-29 06:42:17 +08:00
|
|
|
DRM_ERROR("dp_aux_ch receive error status 0x%08x\n", status);
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
2009-06-12 13:30:32 +08:00
|
|
|
}
|
2009-06-29 06:42:17 +08:00
|
|
|
|
|
|
|
/* Timeouts occur when the device isn't connected, so they're
|
|
|
|
* "normal" -- don't fill the kernel log with these */
|
2009-06-12 13:30:32 +08:00
|
|
|
if (status & DP_AUX_CH_CTL_TIME_OUT_ERROR) {
|
2017-02-23 19:51:02 +08:00
|
|
|
DRM_DEBUG_KMS("dp_aux_ch timeout status 0x%08x\n", status);
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
ret = -ETIMEDOUT;
|
|
|
|
goto out;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Unload any bytes sent back from the other side */
|
|
|
|
recv_bytes = ((status & DP_AUX_CH_CTL_MESSAGE_SIZE_MASK) >>
|
|
|
|
DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT);
|
2015-12-11 03:12:27 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* By BSpec: "Message sizes of 0 or >20 are not allowed."
|
|
|
|
* We have no idea of what happened so we return -EBUSY so
|
|
|
|
* drm layer takes care for the necessary retries.
|
|
|
|
*/
|
|
|
|
if (recv_bytes == 0 || recv_bytes > 20) {
|
|
|
|
DRM_DEBUG_KMS("Forbidden recv_bytes = %d on aux transaction\n",
|
|
|
|
recv_bytes);
|
|
|
|
/*
|
|
|
|
* FIXME: This patch was created on top of a series that
|
|
|
|
* organize the retries at drm level. There EBUSY should
|
|
|
|
* also take care for 1ms wait before retrying.
|
|
|
|
* That aux retries re-org is still needed and after that is
|
|
|
|
* merged we remove this sleep from here.
|
|
|
|
*/
|
|
|
|
usleep_range(1000, 1500);
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-04-08 07:16:42 +08:00
|
|
|
if (recv_bytes > recv_size)
|
|
|
|
recv_bytes = recv_size;
|
2011-08-17 03:34:10 +08:00
|
|
|
|
2010-08-19 01:12:56 +08:00
|
|
|
for (i = 0; i < recv_bytes; i += 4)
|
2015-11-12 02:34:14 +08:00
|
|
|
intel_dp_unpack_aux(I915_READ(intel_dp->aux_ch_data_reg[i >> 2]),
|
2014-11-15 00:52:27 +08:00
|
|
|
recv + i, recv_bytes - i);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
ret = recv_bytes;
|
|
|
|
out:
|
|
|
|
pm_qos_update_request(&dev_priv->pm_qos, PM_QOS_DEFAULT_VALUE);
|
|
|
|
|
2014-03-14 22:51:14 +08:00
|
|
|
if (vdd)
|
|
|
|
edp_panel_vdd_off(intel_dp, false);
|
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
2014-09-04 19:53:14 +08:00
|
|
|
|
drm/i915: irq-drive the dp aux communication
At least on the platforms that have a dp aux irq and also have it
enabled - vlvhsw should have one, too. But I don't have a machine to
test this on. Judging from docs there's no dp aux interrupt for gm45.
Also, I only have an ivb cpu edp machine, so the dp aux A code for
snb/ilk is untested.
For dpcd probing when nothing is connected it slashes about 5ms of cpu
time (cpu time is now negligible), which agrees with 3 * 5 400 usec
timeouts.
A previous version of this patch increases the time required to go
through the dp_detect cycle (which includes reading the edid) from
around 33 ms to around 40 ms. Experiments indicated that this is
purely due to the irq latency - the hw doesn't allow us to queue up
dp aux transactions and hence irq latency directly affects throughput.
gmbus is much better, there we have a 8 byte buffer, and we get the
irq once another 4 bytes can be queued up.
But by using the pm_qos interface to request the lowest possible cpu
wake-up latency this slowdown completely disappeared.
Since all our output detection logic is single-threaded with the
mode_config mutex right now anyway, I've decide not ot play fancy and
to just reuse the gmbus wait queue. But this would definitely prep the
way to run dp detection on different ports in parallel
v2: Add a timeout for dp aux transfers when using interrupts - the hw
_does_ prevent this with the hw-based 400 usec timeout, but if the
irq somehow doesn't arrive we're screwed. Lesson learned while
developing this ;-)
v3: While at it also convert the busy-loop to wait_for_atomic, so that
we don't run the risk of an infinite loop any more.
v4: Ensure we have the smallest possible irq latency by using the
pm_qos interface.
v5: Add a comment to the code to explain why we frob pm_qos. Suggested
by Chris Wilson.
v6: Disable dp irq for vlv, that's easier than trying to get at docs
and hw.
v7: Squash in a fix for Haswell that Paulo Zanoni tracked down - the
dp aux registers aren't at a fixed offset any more, but can be on the
PCH while the DP port is on the cpu die.
Reviewed-by: Imre Deak <imre.deak@intel.com> (v6)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 20:53:48 +08:00
|
|
|
return ret;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2014-04-07 17:37:25 +08:00
|
|
|
#define BARE_ADDRESS_SIZE 3
|
|
|
|
#define HEADER_SIZE (BARE_ADDRESS_SIZE + 1)
|
2014-03-14 22:51:15 +08:00
|
|
|
static ssize_t
|
|
|
|
intel_dp_aux_transfer(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2014-03-14 22:51:15 +08:00
|
|
|
struct intel_dp *intel_dp = container_of(aux, struct intel_dp, aux);
|
|
|
|
uint8_t txbuf[20], rxbuf[20];
|
|
|
|
size_t txsize, rxsize;
|
2009-04-08 07:16:42 +08:00
|
|
|
int ret;
|
|
|
|
|
2015-03-19 17:44:06 +08:00
|
|
|
txbuf[0] = (msg->request << 4) |
|
|
|
|
((msg->address >> 16) & 0xf);
|
|
|
|
txbuf[1] = (msg->address >> 8) & 0xff;
|
2014-03-14 22:51:15 +08:00
|
|
|
txbuf[2] = msg->address & 0xff;
|
|
|
|
txbuf[3] = msg->size - 1;
|
2013-09-17 22:14:10 +08:00
|
|
|
|
2014-03-14 22:51:15 +08:00
|
|
|
switch (msg->request & ~DP_AUX_I2C_MOT) {
|
|
|
|
case DP_AUX_NATIVE_WRITE:
|
|
|
|
case DP_AUX_I2C_WRITE:
|
2015-08-27 22:23:27 +08:00
|
|
|
case DP_AUX_I2C_WRITE_STATUS_UPDATE:
|
2014-04-07 17:37:25 +08:00
|
|
|
txsize = msg->size ? HEADER_SIZE + msg->size : BARE_ADDRESS_SIZE;
|
2015-03-17 23:18:54 +08:00
|
|
|
rxsize = 2; /* 0 or 1 data bytes */
|
2014-02-11 17:52:05 +08:00
|
|
|
|
2014-03-14 22:51:15 +08:00
|
|
|
if (WARN_ON(txsize > 20))
|
|
|
|
return -E2BIG;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2016-07-28 22:55:04 +08:00
|
|
|
WARN_ON(!msg->buffer != !msg->size);
|
|
|
|
|
2016-01-29 20:52:26 +08:00
|
|
|
if (msg->buffer)
|
|
|
|
memcpy(txbuf + HEADER_SIZE, msg->buffer, msg->size);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2014-03-14 22:51:15 +08:00
|
|
|
ret = intel_dp_aux_ch(intel_dp, txbuf, txsize, rxbuf, rxsize);
|
|
|
|
if (ret > 0) {
|
|
|
|
msg->reply = rxbuf[0] >> 4;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2015-03-17 23:18:54 +08:00
|
|
|
if (ret > 1) {
|
|
|
|
/* Number of bytes written in a short write. */
|
|
|
|
ret = clamp_t(int, rxbuf[1], 0, msg->size);
|
|
|
|
} else {
|
|
|
|
/* Return payload size. */
|
|
|
|
ret = msg->size;
|
|
|
|
}
|
2014-03-14 22:51:15 +08:00
|
|
|
}
|
|
|
|
break;
|
2013-09-17 22:14:10 +08:00
|
|
|
|
2014-03-14 22:51:15 +08:00
|
|
|
case DP_AUX_NATIVE_READ:
|
|
|
|
case DP_AUX_I2C_READ:
|
2014-04-07 17:37:25 +08:00
|
|
|
txsize = msg->size ? HEADER_SIZE : BARE_ADDRESS_SIZE;
|
2014-03-14 22:51:15 +08:00
|
|
|
rxsize = msg->size + 1;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2014-03-14 22:51:15 +08:00
|
|
|
if (WARN_ON(rxsize > 20))
|
|
|
|
return -E2BIG;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2014-03-14 22:51:15 +08:00
|
|
|
ret = intel_dp_aux_ch(intel_dp, txbuf, txsize, rxbuf, rxsize);
|
|
|
|
if (ret > 0) {
|
|
|
|
msg->reply = rxbuf[0] >> 4;
|
|
|
|
/*
|
|
|
|
* Assume happy day, and copy the data. The caller is
|
|
|
|
* expected to check msg->reply before touching it.
|
|
|
|
*
|
|
|
|
* Return payload size.
|
|
|
|
*/
|
|
|
|
ret--;
|
|
|
|
memcpy(msg->buffer, rxbuf + 1, ret);
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
2014-03-14 22:51:15 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
2014-02-11 17:52:05 +08:00
|
|
|
|
2014-03-14 22:51:15 +08:00
|
|
|
return ret;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2016-10-12 01:52:45 +08:00
|
|
|
static enum port intel_aux_port(struct drm_i915_private *dev_priv,
|
|
|
|
enum port port)
|
|
|
|
{
|
|
|
|
const struct ddi_vbt_port_info *info =
|
|
|
|
&dev_priv->vbt.ddi_port_info[port];
|
|
|
|
enum port aux_port;
|
|
|
|
|
|
|
|
if (!info->alternate_aux_channel) {
|
|
|
|
DRM_DEBUG_KMS("using AUX %c for port %c (platform default)\n",
|
|
|
|
port_name(port), port_name(port));
|
|
|
|
return port;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (info->alternate_aux_channel) {
|
|
|
|
case DP_AUX_A:
|
|
|
|
aux_port = PORT_A;
|
|
|
|
break;
|
|
|
|
case DP_AUX_B:
|
|
|
|
aux_port = PORT_B;
|
|
|
|
break;
|
|
|
|
case DP_AUX_C:
|
|
|
|
aux_port = PORT_C;
|
|
|
|
break;
|
|
|
|
case DP_AUX_D:
|
|
|
|
aux_port = PORT_D;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
MISSING_CASE(info->alternate_aux_channel);
|
|
|
|
aux_port = PORT_A;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("using AUX %c for port %c (VBT)\n",
|
|
|
|
port_name(aux_port), port_name(port));
|
|
|
|
|
|
|
|
return aux_port;
|
|
|
|
}
|
|
|
|
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
static i915_reg_t g4x_aux_ctl_reg(struct drm_i915_private *dev_priv,
|
2016-10-12 01:52:48 +08:00
|
|
|
enum port port)
|
2015-11-12 02:34:13 +08:00
|
|
|
{
|
|
|
|
switch (port) {
|
|
|
|
case PORT_B:
|
|
|
|
case PORT_C:
|
|
|
|
case PORT_D:
|
|
|
|
return DP_AUX_CH_CTL(port);
|
|
|
|
default:
|
|
|
|
MISSING_CASE(port);
|
|
|
|
return DP_AUX_CH_CTL(PORT_B);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
static i915_reg_t g4x_aux_data_reg(struct drm_i915_private *dev_priv,
|
2016-10-12 01:52:48 +08:00
|
|
|
enum port port, int index)
|
2015-11-12 02:34:14 +08:00
|
|
|
{
|
|
|
|
switch (port) {
|
|
|
|
case PORT_B:
|
|
|
|
case PORT_C:
|
|
|
|
case PORT_D:
|
|
|
|
return DP_AUX_CH_DATA(port, index);
|
|
|
|
default:
|
|
|
|
MISSING_CASE(port);
|
|
|
|
return DP_AUX_CH_DATA(PORT_B, index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
static i915_reg_t ilk_aux_ctl_reg(struct drm_i915_private *dev_priv,
|
2016-10-12 01:52:48 +08:00
|
|
|
enum port port)
|
2015-11-12 02:34:13 +08:00
|
|
|
{
|
|
|
|
switch (port) {
|
|
|
|
case PORT_A:
|
|
|
|
return DP_AUX_CH_CTL(port);
|
|
|
|
case PORT_B:
|
|
|
|
case PORT_C:
|
|
|
|
case PORT_D:
|
|
|
|
return PCH_DP_AUX_CH_CTL(port);
|
|
|
|
default:
|
|
|
|
MISSING_CASE(port);
|
|
|
|
return DP_AUX_CH_CTL(PORT_A);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
static i915_reg_t ilk_aux_data_reg(struct drm_i915_private *dev_priv,
|
2016-10-12 01:52:48 +08:00
|
|
|
enum port port, int index)
|
2015-11-12 02:34:14 +08:00
|
|
|
{
|
|
|
|
switch (port) {
|
|
|
|
case PORT_A:
|
|
|
|
return DP_AUX_CH_DATA(port, index);
|
|
|
|
case PORT_B:
|
|
|
|
case PORT_C:
|
|
|
|
case PORT_D:
|
|
|
|
return PCH_DP_AUX_CH_DATA(port, index);
|
|
|
|
default:
|
|
|
|
MISSING_CASE(port);
|
|
|
|
return DP_AUX_CH_DATA(PORT_A, index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
static i915_reg_t skl_aux_ctl_reg(struct drm_i915_private *dev_priv,
|
2016-10-12 01:52:48 +08:00
|
|
|
enum port port)
|
2015-11-12 02:34:13 +08:00
|
|
|
{
|
|
|
|
switch (port) {
|
|
|
|
case PORT_A:
|
|
|
|
case PORT_B:
|
|
|
|
case PORT_C:
|
|
|
|
case PORT_D:
|
|
|
|
return DP_AUX_CH_CTL(port);
|
|
|
|
default:
|
|
|
|
MISSING_CASE(port);
|
|
|
|
return DP_AUX_CH_CTL(PORT_A);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
static i915_reg_t skl_aux_data_reg(struct drm_i915_private *dev_priv,
|
2016-10-12 01:52:48 +08:00
|
|
|
enum port port, int index)
|
2015-11-12 02:34:14 +08:00
|
|
|
{
|
|
|
|
switch (port) {
|
|
|
|
case PORT_A:
|
|
|
|
case PORT_B:
|
|
|
|
case PORT_C:
|
|
|
|
case PORT_D:
|
|
|
|
return DP_AUX_CH_DATA(port, index);
|
|
|
|
default:
|
|
|
|
MISSING_CASE(port);
|
|
|
|
return DP_AUX_CH_DATA(PORT_A, index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
static i915_reg_t intel_aux_ctl_reg(struct drm_i915_private *dev_priv,
|
2016-10-12 01:52:48 +08:00
|
|
|
enum port port)
|
2015-11-12 02:34:14 +08:00
|
|
|
{
|
|
|
|
if (INTEL_INFO(dev_priv)->gen >= 9)
|
|
|
|
return skl_aux_ctl_reg(dev_priv, port);
|
|
|
|
else if (HAS_PCH_SPLIT(dev_priv))
|
|
|
|
return ilk_aux_ctl_reg(dev_priv, port);
|
|
|
|
else
|
|
|
|
return g4x_aux_ctl_reg(dev_priv, port);
|
|
|
|
}
|
|
|
|
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
static i915_reg_t intel_aux_data_reg(struct drm_i915_private *dev_priv,
|
2016-10-12 01:52:48 +08:00
|
|
|
enum port port, int index)
|
2015-11-12 02:34:14 +08:00
|
|
|
{
|
|
|
|
if (INTEL_INFO(dev_priv)->gen >= 9)
|
|
|
|
return skl_aux_data_reg(dev_priv, port, index);
|
|
|
|
else if (HAS_PCH_SPLIT(dev_priv))
|
|
|
|
return ilk_aux_data_reg(dev_priv, port, index);
|
|
|
|
else
|
|
|
|
return g4x_aux_data_reg(dev_priv, port, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_aux_reg_init(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
|
2016-10-12 01:52:45 +08:00
|
|
|
enum port port = intel_aux_port(dev_priv,
|
|
|
|
dp_to_dig_port(intel_dp)->port);
|
2015-11-12 02:34:14 +08:00
|
|
|
int i;
|
|
|
|
|
|
|
|
intel_dp->aux_ch_ctl_reg = intel_aux_ctl_reg(dev_priv, port);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(intel_dp->aux_ch_data_reg); i++)
|
|
|
|
intel_dp->aux_ch_data_reg[i] = intel_aux_data_reg(dev_priv, port, i);
|
|
|
|
}
|
|
|
|
|
2014-03-14 22:51:15 +08:00
|
|
|
static void
|
2015-11-12 02:34:11 +08:00
|
|
|
intel_dp_aux_fini(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
kfree(intel_dp->aux.name);
|
|
|
|
}
|
|
|
|
|
2016-06-24 21:00:14 +08:00
|
|
|
static void
|
2016-09-09 19:10:52 +08:00
|
|
|
intel_dp_aux_init(struct intel_dp *intel_dp)
|
2014-03-14 22:51:15 +08:00
|
|
|
{
|
2014-03-14 22:51:16 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
enum port port = intel_dig_port->port;
|
2009-12-04 08:55:24 +08:00
|
|
|
|
2015-11-12 02:34:14 +08:00
|
|
|
intel_aux_reg_init(intel_dp);
|
2016-06-24 21:00:14 +08:00
|
|
|
drm_dp_aux_init(&intel_dp->aux);
|
2010-12-09 00:10:21 +08:00
|
|
|
|
2016-06-24 21:00:14 +08:00
|
|
|
/* Failure to allocate our preferred name is not critical */
|
2015-11-12 02:34:11 +08:00
|
|
|
intel_dp->aux.name = kasprintf(GFP_KERNEL, "DPDDC-%c", port_name(port));
|
2014-03-14 22:51:15 +08:00
|
|
|
intel_dp->aux.transfer = intel_dp_aux_transfer;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2015-10-23 18:01:50 +08:00
|
|
|
bool intel_dp_source_supports_hbr2(struct intel_dp *intel_dp)
|
2015-08-18 18:00:37 +08:00
|
|
|
{
|
2015-10-23 18:01:50 +08:00
|
|
|
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
2016-09-28 07:36:53 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
|
2015-10-23 18:01:50 +08:00
|
|
|
|
2016-09-28 07:36:53 +08:00
|
|
|
if ((IS_HASWELL(dev_priv) && !IS_HSW_ULX(dev_priv)) ||
|
|
|
|
IS_BROADWELL(dev_priv) || (INTEL_GEN(dev_priv) >= 9))
|
2015-08-18 18:00:37 +08:00
|
|
|
return true;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-04-19 17:14:33 +08:00
|
|
|
static void
|
|
|
|
intel_dp_set_clock(struct intel_encoder *encoder,
|
2015-08-12 01:21:46 +08:00
|
|
|
struct intel_crtc_state *pipe_config)
|
2013-04-19 17:14:33 +08:00
|
|
|
{
|
|
|
|
struct drm_device *dev = encoder->base.dev;
|
2016-10-13 18:02:53 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2013-09-04 01:30:37 +08:00
|
|
|
const struct dp_link_dpll *divisor = NULL;
|
|
|
|
int i, count = 0;
|
2013-04-19 17:14:33 +08:00
|
|
|
|
2016-10-13 18:03:06 +08:00
|
|
|
if (IS_G4X(dev_priv)) {
|
2013-09-04 01:30:37 +08:00
|
|
|
divisor = gen4_dpll;
|
|
|
|
count = ARRAY_SIZE(gen4_dpll);
|
2016-10-13 18:02:53 +08:00
|
|
|
} else if (HAS_PCH_SPLIT(dev_priv)) {
|
2013-09-04 01:30:37 +08:00
|
|
|
divisor = pch_dpll;
|
|
|
|
count = ARRAY_SIZE(pch_dpll);
|
2016-10-14 17:13:44 +08:00
|
|
|
} else if (IS_CHERRYVIEW(dev_priv)) {
|
2014-04-09 18:28:18 +08:00
|
|
|
divisor = chv_dpll;
|
|
|
|
count = ARRAY_SIZE(chv_dpll);
|
2016-10-13 18:03:08 +08:00
|
|
|
} else if (IS_VALLEYVIEW(dev_priv)) {
|
2013-09-04 01:30:38 +08:00
|
|
|
divisor = vlv_dpll;
|
|
|
|
count = ARRAY_SIZE(vlv_dpll);
|
2013-04-19 17:14:33 +08:00
|
|
|
}
|
2013-09-04 01:30:37 +08:00
|
|
|
|
|
|
|
if (divisor && count) {
|
|
|
|
for (i = 0; i < count; i++) {
|
2015-08-12 01:21:46 +08:00
|
|
|
if (pipe_config->port_clock == divisor[i].clock) {
|
2013-09-04 01:30:37 +08:00
|
|
|
pipe_config->dpll = divisor[i].dpll;
|
|
|
|
pipe_config->clock_set = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-04-19 17:14:33 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-12 23:10:39 +08:00
|
|
|
static void snprintf_int_array(char *str, size_t len,
|
|
|
|
const int *array, int nelem)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
str[0] = '\0';
|
|
|
|
|
|
|
|
for (i = 0; i < nelem; i++) {
|
drm/i915/dp: make link rate printing prettier
Turn
[drm:intel_dp_print_rates] source rates: 162000,270000,540000,
[drm:intel_dp_print_rates] sink rates: 162000,270000,
[drm:intel_dp_print_rates] common rates: 162000,270000,
into
[drm:intel_dp_print_rates] source rates: 162000, 270000, 540000
[drm:intel_dp_print_rates] sink rates: 162000, 270000
[drm:intel_dp_print_rates] common rates: 162000, 270000
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Reviewed-by: Damien Lespiau <damien.lespiau@intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-05-18 21:01:45 +08:00
|
|
|
int r = snprintf(str, len, "%s%d", i ? ", " : "", array[i]);
|
2015-03-12 23:10:39 +08:00
|
|
|
if (r >= len)
|
|
|
|
return;
|
|
|
|
str += r;
|
|
|
|
len -= r;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_dp_print_rates(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
char str[128]; /* FIXME: too big for stack? */
|
|
|
|
|
|
|
|
if ((drm_debug & DRM_UT_KMS) == 0)
|
|
|
|
return;
|
|
|
|
|
2017-03-28 22:59:04 +08:00
|
|
|
snprintf_int_array(str, sizeof(str),
|
|
|
|
intel_dp->source_rates, intel_dp->num_source_rates);
|
2015-03-12 23:10:39 +08:00
|
|
|
DRM_DEBUG_KMS("source rates: %s\n", str);
|
|
|
|
|
2017-03-28 22:59:05 +08:00
|
|
|
snprintf_int_array(str, sizeof(str),
|
|
|
|
intel_dp->sink_rates, intel_dp->num_sink_rates);
|
2015-03-12 23:10:39 +08:00
|
|
|
DRM_DEBUG_KMS("sink rates: %s\n", str);
|
|
|
|
|
2017-04-06 21:44:10 +08:00
|
|
|
snprintf_int_array(str, sizeof(str),
|
|
|
|
intel_dp->common_rates, intel_dp->num_common_rates);
|
2015-03-14 01:40:31 +08:00
|
|
|
DRM_DEBUG_KMS("common rates: %s\n", str);
|
2015-03-12 23:10:39 +08:00
|
|
|
}
|
|
|
|
|
2015-03-12 23:10:34 +08:00
|
|
|
int
|
|
|
|
intel_dp_max_link_rate(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
|
2017-04-06 21:44:12 +08:00
|
|
|
len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->max_link_rate);
|
2015-03-12 23:10:34 +08:00
|
|
|
if (WARN_ON(len <= 0))
|
|
|
|
return 162000;
|
|
|
|
|
2017-04-06 21:44:10 +08:00
|
|
|
return intel_dp->common_rates[len - 1];
|
2015-03-12 23:10:34 +08:00
|
|
|
}
|
|
|
|
|
2015-03-12 23:10:36 +08:00
|
|
|
int intel_dp_rate_select(struct intel_dp *intel_dp, int rate)
|
|
|
|
{
|
2017-03-28 22:59:03 +08:00
|
|
|
int i = intel_dp_rate_index(intel_dp->sink_rates,
|
|
|
|
intel_dp->num_sink_rates, rate);
|
2017-03-28 22:59:02 +08:00
|
|
|
|
|
|
|
if (WARN_ON(i < 0))
|
|
|
|
i = 0;
|
|
|
|
|
|
|
|
return i;
|
2015-03-12 23:10:36 +08:00
|
|
|
}
|
|
|
|
|
2015-10-23 18:01:48 +08:00
|
|
|
void intel_dp_compute_rate(struct intel_dp *intel_dp, int port_clock,
|
|
|
|
uint8_t *link_bw, uint8_t *rate_select)
|
2015-07-06 20:10:06 +08:00
|
|
|
{
|
2017-03-28 22:59:05 +08:00
|
|
|
/* eDP 1.4 rate select method. */
|
|
|
|
if (intel_dp->use_rate_select) {
|
2015-07-06 20:10:06 +08:00
|
|
|
*link_bw = 0;
|
|
|
|
*rate_select =
|
|
|
|
intel_dp_rate_select(intel_dp, port_clock);
|
|
|
|
} else {
|
|
|
|
*link_bw = drm_dp_link_rate_to_bw_code(port_clock);
|
|
|
|
*rate_select = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-15 21:28:52 +08:00
|
|
|
static int intel_dp_compute_bpp(struct intel_dp *intel_dp,
|
|
|
|
struct intel_crtc_state *pipe_config)
|
2016-09-09 19:10:56 +08:00
|
|
|
{
|
|
|
|
int bpp, bpc;
|
|
|
|
|
|
|
|
bpp = pipe_config->pipe_bpp;
|
|
|
|
bpc = drm_dp_downstream_max_bpc(intel_dp->dpcd, intel_dp->downstream_ports);
|
|
|
|
|
|
|
|
if (bpc > 0)
|
|
|
|
bpp = min(bpp, 3*bpc);
|
|
|
|
|
2017-01-25 00:21:49 +08:00
|
|
|
/* For DP Compliance we override the computed bpp for the pipe */
|
|
|
|
if (intel_dp->compliance.test_data.bpc != 0) {
|
|
|
|
pipe_config->pipe_bpp = 3*intel_dp->compliance.test_data.bpc;
|
|
|
|
pipe_config->dither_force_disable = pipe_config->pipe_bpp == 6*3;
|
|
|
|
DRM_DEBUG_KMS("Setting pipe_bpp to %d\n",
|
|
|
|
pipe_config->pipe_bpp);
|
|
|
|
}
|
2016-09-09 19:10:56 +08:00
|
|
|
return bpp;
|
|
|
|
}
|
|
|
|
|
2017-08-10 03:48:53 +08:00
|
|
|
static bool intel_edp_compare_alt_mode(struct drm_display_mode *m1,
|
|
|
|
struct drm_display_mode *m2)
|
|
|
|
{
|
|
|
|
bool bres = false;
|
|
|
|
|
|
|
|
if (m1 && m2)
|
|
|
|
bres = (m1->hdisplay == m2->hdisplay &&
|
|
|
|
m1->hsync_start == m2->hsync_start &&
|
|
|
|
m1->hsync_end == m2->hsync_end &&
|
|
|
|
m1->htotal == m2->htotal &&
|
|
|
|
m1->vdisplay == m2->vdisplay &&
|
|
|
|
m1->vsync_start == m2->vsync_start &&
|
|
|
|
m1->vsync_end == m2->vsync_end &&
|
|
|
|
m1->vtotal == m2->vtotal);
|
|
|
|
return bres;
|
|
|
|
}
|
|
|
|
|
2012-10-27 05:05:52 +08:00
|
|
|
bool
|
2013-03-27 07:44:55 +08:00
|
|
|
intel_dp_compute_config(struct intel_encoder *encoder,
|
2016-08-09 23:04:05 +08:00
|
|
|
struct intel_crtc_state *pipe_config,
|
|
|
|
struct drm_connector_state *conn_state)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2016-11-16 16:55:41 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
2015-01-15 20:55:22 +08:00
|
|
|
struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
|
2013-03-27 07:44:55 +08:00
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
2013-05-16 19:40:36 +08:00
|
|
|
enum port port = dp_to_dig_port(intel_dp)->port;
|
2015-03-20 22:18:10 +08:00
|
|
|
struct intel_crtc *intel_crtc = to_intel_crtc(pipe_config->base.crtc);
|
2012-10-19 19:51:50 +08:00
|
|
|
struct intel_connector *intel_connector = intel_dp->attached_connector;
|
2017-05-01 21:38:01 +08:00
|
|
|
struct intel_digital_connector_state *intel_conn_state =
|
|
|
|
to_intel_digital_connector_state(conn_state);
|
2009-04-08 07:16:42 +08:00
|
|
|
int lane_count, clock;
|
2014-05-06 19:56:52 +08:00
|
|
|
int min_lane_count = 1;
|
2014-05-06 19:56:50 +08:00
|
|
|
int max_lane_count = intel_dp_max_lane_count(intel_dp);
|
2014-01-21 01:19:39 +08:00
|
|
|
/* Conveniently, the link BW constants become indices with a shift...*/
|
2014-05-06 19:56:52 +08:00
|
|
|
int min_clock = 0;
|
2015-03-05 12:32:30 +08:00
|
|
|
int max_clock;
|
2012-04-21 02:23:49 +08:00
|
|
|
int bpp, mode_rate;
|
2013-06-01 23:16:21 +08:00
|
|
|
int link_avail, link_clock;
|
2015-03-14 01:40:31 +08:00
|
|
|
int common_len;
|
2015-07-06 20:10:06 +08:00
|
|
|
uint8_t link_bw, rate_select;
|
2017-05-18 19:10:25 +08:00
|
|
|
bool reduce_m_n = drm_dp_has_quirk(&intel_dp->desc,
|
|
|
|
DP_DPCD_QUIRK_LIMITED_M_N);
|
2015-03-05 12:32:30 +08:00
|
|
|
|
2017-04-06 21:44:10 +08:00
|
|
|
common_len = intel_dp_common_len_rate_limit(intel_dp,
|
2017-04-06 21:44:12 +08:00
|
|
|
intel_dp->max_link_rate);
|
2015-03-05 12:32:30 +08:00
|
|
|
|
|
|
|
/* No common link rates between source and sink */
|
2015-03-14 01:40:31 +08:00
|
|
|
WARN_ON(common_len <= 0);
|
2015-03-05 12:32:30 +08:00
|
|
|
|
2015-03-14 01:40:31 +08:00
|
|
|
max_clock = common_len - 1;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2016-10-13 18:02:52 +08:00
|
|
|
if (HAS_PCH_SPLIT(dev_priv) && !HAS_DDI(dev_priv) && port != PORT_A)
|
2013-03-27 07:44:55 +08:00
|
|
|
pipe_config->has_pch_encoder = true;
|
|
|
|
|
2014-08-05 22:51:22 +08:00
|
|
|
pipe_config->has_drrs = false;
|
2017-05-01 21:38:00 +08:00
|
|
|
if (port == PORT_A)
|
|
|
|
pipe_config->has_audio = false;
|
2017-05-01 21:38:01 +08:00
|
|
|
else if (intel_conn_state->force_audio == HDMI_AUDIO_AUTO)
|
2017-05-01 21:38:00 +08:00
|
|
|
pipe_config->has_audio = intel_dp->has_audio;
|
|
|
|
else
|
2017-05-01 21:38:01 +08:00
|
|
|
pipe_config->has_audio = intel_conn_state->force_audio == HDMI_AUDIO_ON;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp) && intel_connector->panel.fixed_mode) {
|
2017-08-10 03:48:53 +08:00
|
|
|
struct drm_display_mode *panel_mode =
|
|
|
|
intel_connector->panel.alt_fixed_mode;
|
|
|
|
struct drm_display_mode *req_mode = &pipe_config->base.mode;
|
|
|
|
|
|
|
|
if (!intel_edp_compare_alt_mode(req_mode, panel_mode))
|
|
|
|
panel_mode = intel_connector->panel.fixed_mode;
|
|
|
|
|
|
|
|
drm_mode_debug_printmodeline(panel_mode);
|
|
|
|
|
|
|
|
intel_fixed_panel_mode(panel_mode, adjusted_mode);
|
2015-04-08 06:28:45 +08:00
|
|
|
|
2016-11-16 16:55:41 +08:00
|
|
|
if (INTEL_GEN(dev_priv) >= 9) {
|
2015-04-08 06:28:45 +08:00
|
|
|
int ret;
|
2015-07-13 22:30:15 +08:00
|
|
|
ret = skl_update_scaler_crtc(pipe_config);
|
2015-04-08 06:28:45 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-10-13 18:02:54 +08:00
|
|
|
if (HAS_GMCH_DISPLAY(dev_priv))
|
2013-04-26 03:55:01 +08:00
|
|
|
intel_gmch_panel_fitting(intel_crtc, pipe_config,
|
2017-05-01 21:37:55 +08:00
|
|
|
conn_state->scaling_mode);
|
2013-04-26 03:55:01 +08:00
|
|
|
else
|
2013-04-26 03:55:02 +08:00
|
|
|
intel_pch_panel_fitting(intel_crtc, pipe_config,
|
2017-05-01 21:37:55 +08:00
|
|
|
conn_state->scaling_mode);
|
2010-07-19 16:43:13 +08:00
|
|
|
}
|
|
|
|
|
2012-06-05 00:39:21 +08:00
|
|
|
if (adjusted_mode->flags & DRM_MODE_FLAG_DBLCLK)
|
2012-05-23 17:30:55 +08:00
|
|
|
return false;
|
|
|
|
|
2017-01-25 00:16:34 +08:00
|
|
|
/* Use values requested by Compliance Test Request */
|
|
|
|
if (intel_dp->compliance.test_type == DP_TEST_LINK_TRAINING) {
|
2017-04-06 21:44:15 +08:00
|
|
|
int index;
|
|
|
|
|
2017-06-09 04:41:03 +08:00
|
|
|
/* Validate the compliance test data since max values
|
|
|
|
* might have changed due to link train fallback.
|
|
|
|
*/
|
|
|
|
if (intel_dp_link_params_valid(intel_dp, intel_dp->compliance.test_link_rate,
|
|
|
|
intel_dp->compliance.test_lane_count)) {
|
|
|
|
index = intel_dp_rate_index(intel_dp->common_rates,
|
|
|
|
intel_dp->num_common_rates,
|
|
|
|
intel_dp->compliance.test_link_rate);
|
|
|
|
if (index >= 0)
|
|
|
|
min_clock = max_clock = index;
|
|
|
|
min_lane_count = max_lane_count = intel_dp->compliance.test_lane_count;
|
|
|
|
}
|
2017-01-25 00:16:34 +08:00
|
|
|
}
|
2012-04-21 02:23:49 +08:00
|
|
|
DRM_DEBUG_KMS("DP link computation with max lane count %i "
|
2015-03-05 12:32:30 +08:00
|
|
|
"max bw %d pixel clock %iKHz\n",
|
2017-04-06 21:44:10 +08:00
|
|
|
max_lane_count, intel_dp->common_rates[max_clock],
|
2013-09-25 23:45:37 +08:00
|
|
|
adjusted_mode->crtc_clock);
|
2012-04-21 02:23:49 +08:00
|
|
|
|
2013-03-27 07:44:59 +08:00
|
|
|
/* Walk through all bpp values. Luckily they're all nicely spaced with 2
|
|
|
|
* bpc in between. */
|
2016-09-09 19:10:56 +08:00
|
|
|
bpp = intel_dp_compute_bpp(intel_dp, pipe_config);
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp)) {
|
2015-07-31 13:35:27 +08:00
|
|
|
|
|
|
|
/* Get bpp from vbt only for panels that dont have bpp in edid */
|
|
|
|
if (intel_connector->base.display_info.bpc == 0 &&
|
2016-03-24 23:50:20 +08:00
|
|
|
(dev_priv->vbt.edp.bpp && dev_priv->vbt.edp.bpp < bpp)) {
|
2014-05-06 19:56:52 +08:00
|
|
|
DRM_DEBUG_KMS("clamping bpp for eDP panel to BIOS-provided %i\n",
|
2016-03-24 23:50:20 +08:00
|
|
|
dev_priv->vbt.edp.bpp);
|
|
|
|
bpp = dev_priv->vbt.edp.bpp;
|
2014-05-06 19:56:52 +08:00
|
|
|
}
|
|
|
|
|
2014-09-09 16:25:13 +08:00
|
|
|
/*
|
|
|
|
* Use the maximum clock and number of lanes the eDP panel
|
|
|
|
* advertizes being capable of. The panels are generally
|
|
|
|
* designed to support only a single clock and lane
|
|
|
|
* configuration, and typically these values correspond to the
|
|
|
|
* native resolution of the panel.
|
|
|
|
*/
|
|
|
|
min_lane_count = max_lane_count;
|
|
|
|
min_clock = max_clock;
|
2013-07-18 22:44:13 +08:00
|
|
|
}
|
2013-05-04 16:09:18 +08:00
|
|
|
|
2013-03-27 07:44:59 +08:00
|
|
|
for (; bpp >= 6*3; bpp -= 2*3) {
|
2013-09-25 23:45:37 +08:00
|
|
|
mode_rate = intel_dp_link_required(adjusted_mode->crtc_clock,
|
|
|
|
bpp);
|
2013-03-27 07:44:59 +08:00
|
|
|
|
2014-07-14 09:04:39 +08:00
|
|
|
for (clock = min_clock; clock <= max_clock; clock++) {
|
2015-03-05 12:32:30 +08:00
|
|
|
for (lane_count = min_lane_count;
|
|
|
|
lane_count <= max_lane_count;
|
|
|
|
lane_count <<= 1) {
|
|
|
|
|
2017-04-06 21:44:10 +08:00
|
|
|
link_clock = intel_dp->common_rates[clock];
|
2013-03-27 07:44:59 +08:00
|
|
|
link_avail = intel_dp_max_data_rate(link_clock,
|
|
|
|
lane_count);
|
|
|
|
|
|
|
|
if (mode_rate <= link_avail) {
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-04-10 16:42:36 +08:00
|
|
|
|
2013-03-27 07:44:59 +08:00
|
|
|
return false;
|
2013-01-17 22:31:28 +08:00
|
|
|
|
2013-03-27 07:44:59 +08:00
|
|
|
found:
|
2017-05-01 21:38:01 +08:00
|
|
|
if (intel_conn_state->broadcast_rgb == INTEL_BROADCAST_RGB_AUTO) {
|
2013-01-17 22:31:29 +08:00
|
|
|
/*
|
|
|
|
* See:
|
|
|
|
* CEA-861-E - 5.1 Default Encoding Parameters
|
|
|
|
* VESA DisplayPort Ver.1.2a - 5.1.1.1 Video Colorimetry
|
|
|
|
*/
|
2015-07-06 20:10:00 +08:00
|
|
|
pipe_config->limited_color_range =
|
2017-01-11 22:18:35 +08:00
|
|
|
bpp != 18 &&
|
|
|
|
drm_default_rgb_quant_range(adjusted_mode) ==
|
|
|
|
HDMI_QUANTIZATION_RANGE_LIMITED;
|
2015-07-06 20:10:00 +08:00
|
|
|
} else {
|
|
|
|
pipe_config->limited_color_range =
|
2017-05-01 21:38:01 +08:00
|
|
|
intel_conn_state->broadcast_rgb == INTEL_BROADCAST_RGB_LIMITED;
|
2013-01-17 22:31:29 +08:00
|
|
|
}
|
|
|
|
|
2015-07-06 21:39:15 +08:00
|
|
|
pipe_config->lane_count = lane_count;
|
2015-03-05 12:32:30 +08:00
|
|
|
|
2013-05-04 16:09:18 +08:00
|
|
|
pipe_config->pipe_bpp = bpp;
|
2017-04-06 21:44:10 +08:00
|
|
|
pipe_config->port_clock = intel_dp->common_rates[clock];
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2015-07-06 20:10:06 +08:00
|
|
|
intel_dp_compute_rate(intel_dp, pipe_config->port_clock,
|
|
|
|
&link_bw, &rate_select);
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("DP link bw %02x rate select %02x lane count %d clock %d bpp %d\n",
|
|
|
|
link_bw, rate_select, pipe_config->lane_count,
|
2013-06-01 23:16:21 +08:00
|
|
|
pipe_config->port_clock, bpp);
|
2013-03-27 07:44:59 +08:00
|
|
|
DRM_DEBUG_KMS("DP link bw required %i available %i\n",
|
|
|
|
mode_rate, link_avail);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2013-04-03 05:42:31 +08:00
|
|
|
intel_link_compute_m_n(bpp, lane_count,
|
2013-09-25 23:45:37 +08:00
|
|
|
adjusted_mode->crtc_clock,
|
|
|
|
pipe_config->port_clock,
|
2017-05-18 19:10:25 +08:00
|
|
|
&pipe_config->dp_m_n,
|
|
|
|
reduce_m_n);
|
2013-03-18 18:25:36 +08:00
|
|
|
|
2014-04-05 14:43:28 +08:00
|
|
|
if (intel_connector->panel.downclock_mode != NULL &&
|
2015-01-10 04:55:56 +08:00
|
|
|
dev_priv->drrs.type == SEAMLESS_DRRS_SUPPORT) {
|
2014-08-05 22:51:22 +08:00
|
|
|
pipe_config->has_drrs = true;
|
2014-04-05 14:43:28 +08:00
|
|
|
intel_link_compute_m_n(bpp, lane_count,
|
|
|
|
intel_connector->panel.downclock_mode->clock,
|
|
|
|
pipe_config->port_clock,
|
2017-05-18 19:10:25 +08:00
|
|
|
&pipe_config->dp_m2_n2,
|
|
|
|
reduce_m_n);
|
2014-04-05 14:43:28 +08:00
|
|
|
}
|
|
|
|
|
2016-05-14 04:41:22 +08:00
|
|
|
/*
|
|
|
|
* DPLL0 VCO may need to be adjusted to get the correct
|
|
|
|
* clock for eDP. This will affect cdclk as well.
|
|
|
|
*/
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp) && IS_GEN9_BC(dev_priv)) {
|
2016-05-14 04:41:22 +08:00
|
|
|
int vco;
|
|
|
|
|
|
|
|
switch (pipe_config->port_clock / 2) {
|
|
|
|
case 108000:
|
|
|
|
case 216000:
|
2016-05-14 04:41:32 +08:00
|
|
|
vco = 8640000;
|
2016-05-14 04:41:22 +08:00
|
|
|
break;
|
|
|
|
default:
|
2016-05-14 04:41:32 +08:00
|
|
|
vco = 8100000;
|
2016-05-14 04:41:22 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-01-21 02:21:59 +08:00
|
|
|
to_intel_atomic_state(pipe_config->base.state)->cdclk.logical.vco = vco;
|
2016-05-14 04:41:22 +08:00
|
|
|
}
|
|
|
|
|
2016-10-13 18:02:52 +08:00
|
|
|
if (!HAS_DDI(dev_priv))
|
2015-08-12 01:21:46 +08:00
|
|
|
intel_dp_set_clock(encoder, pipe_config);
|
2013-04-19 17:14:33 +08:00
|
|
|
|
2013-04-03 05:42:31 +08:00
|
|
|
return true;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2015-08-17 23:05:12 +08:00
|
|
|
void intel_dp_set_link_params(struct intel_dp *intel_dp,
|
2016-09-02 06:08:06 +08:00
|
|
|
int link_rate, uint8_t lane_count,
|
|
|
|
bool link_mst)
|
2015-08-17 23:05:12 +08:00
|
|
|
{
|
2016-09-02 06:08:06 +08:00
|
|
|
intel_dp->link_rate = link_rate;
|
|
|
|
intel_dp->lane_count = lane_count;
|
|
|
|
intel_dp->link_mst = link_mst;
|
2015-08-17 23:05:12 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
static void intel_dp_prepare(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2013-07-22 03:37:05 +08:00
|
|
|
struct drm_device *dev = encoder->base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2013-07-22 03:37:05 +08:00
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
2013-05-16 19:40:36 +08:00
|
|
|
enum port port = dp_to_dig_port(intel_dp)->port;
|
2013-07-22 03:37:05 +08:00
|
|
|
struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
|
2016-08-09 23:04:13 +08:00
|
|
|
const struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2016-09-02 06:08:06 +08:00
|
|
|
intel_dp_set_link_params(intel_dp, pipe_config->port_clock,
|
|
|
|
pipe_config->lane_count,
|
|
|
|
intel_crtc_has_type(pipe_config,
|
|
|
|
INTEL_OUTPUT_DP_MST));
|
2015-08-17 23:05:12 +08:00
|
|
|
|
2011-11-02 10:54:11 +08:00
|
|
|
/*
|
2011-11-17 08:26:07 +08:00
|
|
|
* There are four kinds of DP registers:
|
2011-11-02 10:54:11 +08:00
|
|
|
*
|
|
|
|
* IBX PCH
|
2011-11-17 08:26:07 +08:00
|
|
|
* SNB CPU
|
|
|
|
* IVB CPU
|
2011-11-02 10:54:11 +08:00
|
|
|
* CPT PCH
|
|
|
|
*
|
|
|
|
* IBX PCH and CPU are the same for almost everything,
|
|
|
|
* except that the CPU DP PLL is configured in this
|
|
|
|
* register
|
|
|
|
*
|
|
|
|
* CPT PCH is quite different, having many bits moved
|
|
|
|
* to the TRANS_DP_CTL register instead. That
|
|
|
|
* configuration happens (oddly) in ironlake_pch_enable
|
|
|
|
*/
|
2010-04-06 05:57:59 +08:00
|
|
|
|
2011-11-02 10:54:11 +08:00
|
|
|
/* Preserve the BIOS-computed detected bit. This is
|
|
|
|
* supposed to be read-only.
|
|
|
|
*/
|
|
|
|
intel_dp->DP = I915_READ(intel_dp->output_reg) & DP_DETECTED;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2011-11-02 10:54:11 +08:00
|
|
|
/* Handle DP bits in common between all three register formats */
|
|
|
|
intel_dp->DP |= DP_VOLTAGE_0_4 | DP_PRE_EMPHASIS_0;
|
2016-08-09 23:04:13 +08:00
|
|
|
intel_dp->DP |= DP_PORT_WIDTH(pipe_config->lane_count);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2011-11-02 10:54:11 +08:00
|
|
|
/* Split out the IBX/CPU vs CPT settings */
|
2009-07-24 01:00:32 +08:00
|
|
|
|
2016-10-13 18:03:10 +08:00
|
|
|
if (IS_GEN7(dev_priv) && port == PORT_A) {
|
2011-11-17 08:26:07 +08:00
|
|
|
if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
|
|
|
|
intel_dp->DP |= DP_SYNC_HS_HIGH;
|
|
|
|
if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
|
|
|
|
intel_dp->DP |= DP_SYNC_VS_HIGH;
|
|
|
|
intel_dp->DP |= DP_LINK_TRAIN_OFF_CPT;
|
|
|
|
|
2013-10-04 20:08:10 +08:00
|
|
|
if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
|
2011-11-17 08:26:07 +08:00
|
|
|
intel_dp->DP |= DP_ENHANCED_FRAMING;
|
|
|
|
|
2013-06-01 23:16:20 +08:00
|
|
|
intel_dp->DP |= crtc->pipe << 29;
|
2016-10-13 18:02:53 +08:00
|
|
|
} else if (HAS_PCH_CPT(dev_priv) && port != PORT_A) {
|
2015-05-05 22:17:31 +08:00
|
|
|
u32 trans_dp;
|
|
|
|
|
2015-05-05 22:17:29 +08:00
|
|
|
intel_dp->DP |= DP_LINK_TRAIN_OFF_CPT;
|
2015-05-05 22:17:31 +08:00
|
|
|
|
|
|
|
trans_dp = I915_READ(TRANS_DP_CTL(crtc->pipe));
|
|
|
|
if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
|
|
|
|
trans_dp |= TRANS_DP_ENH_FRAMING;
|
|
|
|
else
|
|
|
|
trans_dp &= ~TRANS_DP_ENH_FRAMING;
|
|
|
|
I915_WRITE(TRANS_DP_CTL(crtc->pipe), trans_dp);
|
2015-05-05 22:17:29 +08:00
|
|
|
} else {
|
2016-11-15 01:44:07 +08:00
|
|
|
if (IS_G4X(dev_priv) && pipe_config->limited_color_range)
|
2015-07-06 20:10:00 +08:00
|
|
|
intel_dp->DP |= DP_COLOR_RANGE_16_235;
|
2011-11-02 10:54:11 +08:00
|
|
|
|
|
|
|
if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
|
|
|
|
intel_dp->DP |= DP_SYNC_HS_HIGH;
|
|
|
|
if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
|
|
|
|
intel_dp->DP |= DP_SYNC_VS_HIGH;
|
|
|
|
intel_dp->DP |= DP_LINK_TRAIN_OFF;
|
|
|
|
|
2013-10-04 20:08:10 +08:00
|
|
|
if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
|
2011-11-02 10:54:11 +08:00
|
|
|
intel_dp->DP |= DP_ENHANCED_FRAMING;
|
|
|
|
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_CHERRYVIEW(dev_priv))
|
2014-04-09 18:28:21 +08:00
|
|
|
intel_dp->DP |= DP_PIPE_SELECT_CHV(crtc->pipe);
|
2015-05-05 22:17:29 +08:00
|
|
|
else if (crtc->pipe == PIPE_B)
|
|
|
|
intel_dp->DP |= DP_PIPEB_SELECT;
|
2009-07-24 01:00:32 +08:00
|
|
|
}
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2013-12-20 00:29:42 +08:00
|
|
|
#define IDLE_ON_MASK (PP_ON | PP_SEQUENCE_MASK | 0 | PP_SEQUENCE_STATE_MASK)
|
|
|
|
#define IDLE_ON_VALUE (PP_ON | PP_SEQUENCE_NONE | 0 | PP_SEQUENCE_STATE_ON_IDLE)
|
2011-11-02 10:57:50 +08:00
|
|
|
|
drm/i915: don't wait for power cycle when waiting for power off
Function ironlake_wait_panel_off should just wait for the power off
delay, while function ironlake_wait_panel_power_cycle should wait for
the panel cycle (that's required after we turn the panel off, before
we enable it again).
The problem is that, currently, ironlake_wait_panel_off is waiting not
just for the panel to be off, but also for the power cycle delay and
the backlight off delay. This function relies on the PP_STATUS bits
3:0, which are not documented and not supposed to be used. A quick
analysis of the values we get while waiting quickly shows that power
off is reached while bits 3:0 are still 0x1, and the time it takes to
become 0x0 is the power cycle delay.
On my system with backlight off delay of 200ms, power down delay of
50ms and power cycle delay of 500ms, this is what I get:
- Start waiting with value 0x80000008, timestamp 6.429364.
- Jumps to 0xa0000003, timestamp 6.431360 (time waited: 0.001996)
- Jumps to 0xa0000002, timestamp 6.631277 (time waited: 0.201913)
- Jumps to 0x08000001, timestamp 6.681258 (time waited: 0.251894)
- Jumps to 0x00000000, timestamp 7.192012 (time waited: 0.762648)
As you can see, ironlake_wait_panel_off is sleeping 760ms instead of
the expected 50ms: the first 200ms matches the backlight off delay
(which we should already have waited for!), then the 50ms for the real
panel off delay, then the 500ms for the panel power cycle.
This patch makes is look just at bits 31 and 29:28, which will ignore
the panel power cycle.
And just to be clear: this saves 500ms on my system every time we
disable the panel. But we can still save 200ms more (the backlight off
delay) on the next patches.
Signed-off-by: Paulo Zanoni <paulo.r.zanoni@intel.com>
Reviewed-by: Jesse Barnes <jbarnes@virtuougseek.org>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-12-20 00:29:43 +08:00
|
|
|
#define IDLE_OFF_MASK (PP_ON | PP_SEQUENCE_MASK | 0 | 0)
|
|
|
|
#define IDLE_OFF_VALUE (0 | PP_SEQUENCE_NONE | 0 | 0)
|
2011-11-02 10:57:50 +08:00
|
|
|
|
2013-12-20 00:29:42 +08:00
|
|
|
#define IDLE_CYCLE_MASK (PP_ON | PP_SEQUENCE_MASK | PP_CYCLE_DELAY_ACTIVE | PP_SEQUENCE_STATE_MASK)
|
|
|
|
#define IDLE_CYCLE_VALUE (0 | PP_SEQUENCE_NONE | 0 | PP_SEQUENCE_STATE_OFF_IDLE)
|
2011-11-02 10:57:50 +08:00
|
|
|
|
2016-06-17 01:01:46 +08:00
|
|
|
static void intel_pps_verify_state(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_dp *intel_dp);
|
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
static void wait_panel_status(struct intel_dp *intel_dp,
|
2011-11-02 10:57:50 +08:00
|
|
|
u32 mask,
|
|
|
|
u32 value)
|
2011-09-19 14:09:52 +08:00
|
|
|
{
|
2012-10-27 05:05:45 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_reg_t pp_stat_reg, pp_ctrl_reg;
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2014-09-04 19:53:14 +08:00
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
2016-06-17 01:01:46 +08:00
|
|
|
intel_pps_verify_state(dev_priv, intel_dp);
|
|
|
|
|
2013-09-06 12:40:05 +08:00
|
|
|
pp_stat_reg = _pp_stat_reg(intel_dp);
|
|
|
|
pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
|
2011-09-30 07:51:26 +08:00
|
|
|
|
2011-11-02 10:57:50 +08:00
|
|
|
DRM_DEBUG_KMS("mask %08x value %08x status %08x control %08x\n",
|
2013-03-29 00:55:41 +08:00
|
|
|
mask, value,
|
|
|
|
I915_READ(pp_stat_reg),
|
|
|
|
I915_READ(pp_ctrl_reg));
|
2011-09-30 07:51:26 +08:00
|
|
|
|
2016-06-30 22:33:09 +08:00
|
|
|
if (intel_wait_for_register(dev_priv,
|
|
|
|
pp_stat_reg, mask, value,
|
|
|
|
5000))
|
2011-11-02 10:57:50 +08:00
|
|
|
DRM_ERROR("Panel status timeout: status %08x control %08x\n",
|
2013-03-29 00:55:41 +08:00
|
|
|
I915_READ(pp_stat_reg),
|
|
|
|
I915_READ(pp_ctrl_reg));
|
2013-12-02 17:57:16 +08:00
|
|
|
|
|
|
|
DRM_DEBUG_KMS("Wait complete\n");
|
2011-11-02 10:57:50 +08:00
|
|
|
}
|
2011-09-30 07:51:26 +08:00
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
static void wait_panel_on(struct intel_dp *intel_dp)
|
2011-11-02 10:57:50 +08:00
|
|
|
{
|
|
|
|
DRM_DEBUG_KMS("Wait for panel power on\n");
|
2014-01-17 21:39:48 +08:00
|
|
|
wait_panel_status(intel_dp, IDLE_ON_MASK, IDLE_ON_VALUE);
|
2011-09-19 14:09:52 +08:00
|
|
|
}
|
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
static void wait_panel_off(struct intel_dp *intel_dp)
|
2011-11-02 10:57:50 +08:00
|
|
|
{
|
|
|
|
DRM_DEBUG_KMS("Wait for panel power off time\n");
|
2014-01-17 21:39:48 +08:00
|
|
|
wait_panel_status(intel_dp, IDLE_OFF_MASK, IDLE_OFF_VALUE);
|
2011-11-02 10:57:50 +08:00
|
|
|
}
|
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
static void wait_panel_power_cycle(struct intel_dp *intel_dp)
|
2011-11-02 10:57:50 +08:00
|
|
|
{
|
2016-01-23 09:39:04 +08:00
|
|
|
ktime_t panel_power_on_time;
|
|
|
|
s64 panel_power_off_duration;
|
|
|
|
|
2011-11-02 10:57:50 +08:00
|
|
|
DRM_DEBUG_KMS("Wait for panel power cycle\n");
|
2013-12-20 00:29:40 +08:00
|
|
|
|
2016-01-23 09:39:04 +08:00
|
|
|
/* take the difference of currrent time and panel power off time
|
|
|
|
* and then make panel wait for t11_t12 if needed. */
|
|
|
|
panel_power_on_time = ktime_get_boottime();
|
|
|
|
panel_power_off_duration = ktime_ms_delta(panel_power_on_time, intel_dp->panel_power_off_time);
|
|
|
|
|
2013-12-20 00:29:40 +08:00
|
|
|
/* When we disable the VDD override bit last we have to do the manual
|
|
|
|
* wait. */
|
2016-01-23 09:39:04 +08:00
|
|
|
if (panel_power_off_duration < (s64)intel_dp->panel_power_cycle_delay)
|
|
|
|
wait_remaining_ms_from_jiffies(jiffies,
|
|
|
|
intel_dp->panel_power_cycle_delay - panel_power_off_duration);
|
2013-12-20 00:29:40 +08:00
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
wait_panel_status(intel_dp, IDLE_CYCLE_MASK, IDLE_CYCLE_VALUE);
|
2011-11-02 10:57:50 +08:00
|
|
|
}
|
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
static void wait_backlight_on(struct intel_dp *intel_dp)
|
2013-12-20 00:29:40 +08:00
|
|
|
{
|
|
|
|
wait_remaining_ms_from_jiffies(intel_dp->last_power_on,
|
|
|
|
intel_dp->backlight_on_delay);
|
|
|
|
}
|
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
static void edp_wait_backlight_off(struct intel_dp *intel_dp)
|
2013-12-20 00:29:40 +08:00
|
|
|
{
|
|
|
|
wait_remaining_ms_from_jiffies(intel_dp->last_backlight_off,
|
|
|
|
intel_dp->backlight_off_delay);
|
|
|
|
}
|
2011-11-02 10:57:50 +08:00
|
|
|
|
2011-11-02 10:34:06 +08:00
|
|
|
/* Read the current pp_control value, unlocking the register if it
|
|
|
|
* is locked
|
|
|
|
*/
|
|
|
|
|
2013-03-29 00:55:41 +08:00
|
|
|
static u32 ironlake_get_pp_control(struct intel_dp *intel_dp)
|
2011-11-02 10:34:06 +08:00
|
|
|
{
|
2013-03-29 00:55:41 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2013-03-29 00:55:41 +08:00
|
|
|
u32 control;
|
2011-11-02 10:34:06 +08:00
|
|
|
|
2014-09-04 19:53:14 +08:00
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
2013-09-06 12:40:05 +08:00
|
|
|
control = I915_READ(_pp_ctrl_reg(intel_dp));
|
2016-08-10 19:07:33 +08:00
|
|
|
if (WARN_ON(!HAS_DDI(dev_priv) &&
|
|
|
|
(control & PANEL_UNLOCK_MASK) != PANEL_UNLOCK_REGS)) {
|
2015-06-18 13:30:55 +08:00
|
|
|
control &= ~PANEL_UNLOCK_MASK;
|
|
|
|
control |= PANEL_UNLOCK_REGS;
|
|
|
|
}
|
2011-11-02 10:34:06 +08:00
|
|
|
return control;
|
2011-09-19 14:09:52 +08:00
|
|
|
}
|
|
|
|
|
2014-09-04 19:55:31 +08:00
|
|
|
/*
|
|
|
|
* Must be paired with edp_panel_vdd_off().
|
|
|
|
* Must hold pps_mutex around the whole on/off sequence.
|
|
|
|
* Can be nested with intel_edp_panel_vdd_{on,off}() calls.
|
|
|
|
*/
|
2014-08-19 18:24:25 +08:00
|
|
|
static bool edp_panel_vdd_on(struct intel_dp *intel_dp)
|
2011-01-25 09:10:54 +08:00
|
|
|
{
|
2012-10-27 05:05:45 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2014-03-27 23:45:11 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2011-01-25 09:10:54 +08:00
|
|
|
u32 pp;
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_reg_t pp_stat_reg, pp_ctrl_reg;
|
2014-03-14 22:51:13 +08:00
|
|
|
bool need_to_disable = !intel_dp->want_panel_vdd;
|
2011-01-25 09:10:54 +08:00
|
|
|
|
2014-09-04 19:53:14 +08:00
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2014-03-14 22:51:13 +08:00
|
|
|
return false;
|
2011-09-19 14:09:52 +08:00
|
|
|
|
2014-11-25 19:54:57 +08:00
|
|
|
cancel_delayed_work(&intel_dp->panel_vdd_work);
|
2011-09-19 14:09:52 +08:00
|
|
|
intel_dp->want_panel_vdd = true;
|
2011-11-02 10:57:50 +08:00
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
if (edp_have_panel_vdd(intel_dp))
|
2014-03-14 22:51:13 +08:00
|
|
|
return need_to_disable;
|
2013-10-31 05:50:27 +08:00
|
|
|
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_get(dev_priv, intel_dp->aux_power_domain);
|
2013-11-21 23:47:23 +08:00
|
|
|
|
2014-10-17 02:30:02 +08:00
|
|
|
DRM_DEBUG_KMS("Turning eDP port %c VDD on\n",
|
|
|
|
port_name(intel_dig_port->port));
|
2011-09-19 14:09:52 +08:00
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
if (!edp_have_panel_power(intel_dp))
|
|
|
|
wait_panel_power_cycle(intel_dp);
|
2011-11-02 10:57:50 +08:00
|
|
|
|
2013-03-29 00:55:41 +08:00
|
|
|
pp = ironlake_get_pp_control(intel_dp);
|
2011-01-25 09:10:54 +08:00
|
|
|
pp |= EDP_FORCE_VDD;
|
2011-09-30 06:53:27 +08:00
|
|
|
|
2013-09-06 12:40:05 +08:00
|
|
|
pp_stat_reg = _pp_stat_reg(intel_dp);
|
|
|
|
pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
|
2013-03-29 00:55:41 +08:00
|
|
|
|
|
|
|
I915_WRITE(pp_ctrl_reg, pp);
|
|
|
|
POSTING_READ(pp_ctrl_reg);
|
|
|
|
DRM_DEBUG_KMS("PP_STATUS: 0x%08x PP_CONTROL: 0x%08x\n",
|
|
|
|
I915_READ(pp_stat_reg), I915_READ(pp_ctrl_reg));
|
2011-09-30 06:53:27 +08:00
|
|
|
/*
|
|
|
|
* If the panel wasn't on, delay before accessing aux channel
|
|
|
|
*/
|
2014-01-17 21:39:48 +08:00
|
|
|
if (!edp_have_panel_power(intel_dp)) {
|
2014-10-17 02:30:02 +08:00
|
|
|
DRM_DEBUG_KMS("eDP port %c panel power wasn't enabled\n",
|
|
|
|
port_name(intel_dig_port->port));
|
drm/i915: Correct eDP panel power sequencing delay computations
Store the panel power sequencing delays in the dp private structure,
rather than the global device structure. Who knows, maybe we'll get
more than one eDP device in the future.
From the eDP spec, we need the following numbers:
T1 + T3 Power on to Aux Channel operation (panel_power_up_delay)
This marks how long it takes the panel to boot up and
get ready to receive aux channel communications.
T8 Video signal to backlight on (backlight_on_delay)
Once a valid video signal is being sent to the device,
it can take a while before the panel is actuall
showing useful data. This delay allows the panel
to get something reasonable up before the backlight
is turned on.
T9 Backlight off to video off (backlight_off_delay)
Turning the backlight off can take a moment, so
this delay makes sure there is still valid video
data on the screen.
T10 Video off to power off (panel_power_down_delay)
Presumably this delay allows the panel to perform
an orderly shutdown of the display.
T11 + T12 Power off to power on (panel_power_cycle_delay)
So, once you turn the panel off, you have to wait a
while before you can turn it back on. This delay is
usually the longest in the entire sequence.
Neither the VBIOS source code nor the hardware documentation has a
clear mapping between the delay values they provide and those required
by the eDP spec. The VBIOS code actually uses two different labels for
the delay values in the five words of the relevant VBT table.
**** MORE LATER ***
Look at both the current hardware register settings and the VBT
specified panel power sequencing timings. Use the maximum of the two
delays, to make sure things work reliably. If there is no VBT data,
then those values will be initialized to zero, so we'll just use the
values as programmed in the hardware. Note that the BIOS just fetches
delays from the VBT table to place in the hardware registers, so we
should get the same values from both places, except for rounding.
VBT doesn't provide any values for T1 or T2, so we'll always just use
the hardware value for that.
The panel power up delay is thus T1 + T2 + T3, which should be
sufficient in all cases.
The panel power down delay is T1 + T2 + T12, using T1+T2 as a proxy
for T11, which isn't available anywhere.
For the backlight delays, the eDP spec says T6 + T8 is the delay from the
end of link training to backlight on and T9 is the delay from
backlight off until video off. The hardware provides a 'backlight on'
delay, which I'm taking to be T6 + T8 while the VBT provides something
called 'T7', which I'm assuming is s
On the macbook air I'm testing with, this yields a power-up delay of
over 200ms and a power-down delay of over 600ms. It all works now, but
we're frobbing these power controls several times during mode setting,
making the whole process take an awfully long time.
Signed-off-by: Keith Packard <keithp@keithp.com>
2011-09-29 07:48:10 +08:00
|
|
|
msleep(intel_dp->panel_power_up_delay);
|
|
|
|
}
|
2014-03-14 22:51:13 +08:00
|
|
|
|
|
|
|
return need_to_disable;
|
|
|
|
}
|
|
|
|
|
2014-09-04 19:55:31 +08:00
|
|
|
/*
|
|
|
|
* Must be paired with intel_edp_panel_vdd_off() or
|
|
|
|
* intel_edp_panel_off().
|
|
|
|
* Nested calls to these functions are not allowed since
|
|
|
|
* we drop the lock. Caller must use some higher level
|
|
|
|
* locking to prevent nested calls from other threads.
|
|
|
|
*/
|
2014-03-19 22:54:37 +08:00
|
|
|
void intel_edp_panel_vdd_on(struct intel_dp *intel_dp)
|
2014-03-14 22:51:13 +08:00
|
|
|
{
|
2014-08-19 03:16:03 +08:00
|
|
|
bool vdd;
|
2014-03-14 22:51:13 +08:00
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2014-08-19 03:16:03 +08:00
|
|
|
return;
|
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_lock(intel_dp);
|
2014-08-19 03:16:03 +08:00
|
|
|
vdd = edp_panel_vdd_on(intel_dp);
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
2014-08-19 03:16:03 +08:00
|
|
|
|
2014-12-16 02:56:32 +08:00
|
|
|
I915_STATE_WARN(!vdd, "eDP port %c VDD already requested on\n",
|
2014-10-17 02:30:02 +08:00
|
|
|
port_name(dp_to_dig_port(intel_dp)->port));
|
2011-01-25 09:10:54 +08:00
|
|
|
}
|
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
static void edp_panel_vdd_off_sync(struct intel_dp *intel_dp)
|
2011-01-25 09:10:54 +08:00
|
|
|
{
|
2012-10-27 05:05:45 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-08-19 03:16:01 +08:00
|
|
|
struct intel_digital_port *intel_dig_port =
|
|
|
|
dp_to_dig_port(intel_dp);
|
2011-01-25 09:10:54 +08:00
|
|
|
u32 pp;
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_reg_t pp_stat_reg, pp_ctrl_reg;
|
2011-01-25 09:10:54 +08:00
|
|
|
|
2014-09-04 19:53:14 +08:00
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
2012-12-02 08:05:46 +08:00
|
|
|
|
2014-08-19 03:16:02 +08:00
|
|
|
WARN_ON(intel_dp->want_panel_vdd);
|
2014-03-27 23:45:11 +08:00
|
|
|
|
2014-08-19 03:16:02 +08:00
|
|
|
if (!edp_have_panel_vdd(intel_dp))
|
2014-08-19 03:16:01 +08:00
|
|
|
return;
|
2013-10-31 05:50:27 +08:00
|
|
|
|
2014-10-17 02:30:02 +08:00
|
|
|
DRM_DEBUG_KMS("Turning eDP port %c VDD off\n",
|
|
|
|
port_name(intel_dig_port->port));
|
2011-09-19 14:09:52 +08:00
|
|
|
|
2014-08-19 03:16:01 +08:00
|
|
|
pp = ironlake_get_pp_control(intel_dp);
|
|
|
|
pp &= ~EDP_FORCE_VDD;
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2014-08-19 03:16:01 +08:00
|
|
|
pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
|
|
|
|
pp_stat_reg = _pp_stat_reg(intel_dp);
|
2011-11-02 10:57:50 +08:00
|
|
|
|
2014-08-19 03:16:01 +08:00
|
|
|
I915_WRITE(pp_ctrl_reg, pp);
|
|
|
|
POSTING_READ(pp_ctrl_reg);
|
2013-12-07 03:32:42 +08:00
|
|
|
|
2014-08-19 03:16:01 +08:00
|
|
|
/* Make sure sequencer is idle before allowing subsequent activity */
|
|
|
|
DRM_DEBUG_KMS("PP_STATUS: 0x%08x PP_CONTROL: 0x%08x\n",
|
|
|
|
I915_READ(pp_stat_reg), I915_READ(pp_ctrl_reg));
|
2013-11-21 23:47:23 +08:00
|
|
|
|
2016-08-10 19:07:30 +08:00
|
|
|
if ((pp & PANEL_POWER_ON) == 0)
|
2016-01-23 09:39:04 +08:00
|
|
|
intel_dp->panel_power_off_time = ktime_get_boottime();
|
2013-11-21 23:47:23 +08:00
|
|
|
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_put(dev_priv, intel_dp->aux_power_domain);
|
2011-09-19 14:09:52 +08:00
|
|
|
}
|
2011-01-25 09:10:54 +08:00
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
static void edp_panel_vdd_work(struct work_struct *__work)
|
2011-09-19 14:09:52 +08:00
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = container_of(to_delayed_work(__work),
|
|
|
|
struct intel_dp, panel_vdd_work);
|
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_lock(intel_dp);
|
2014-08-19 03:16:02 +08:00
|
|
|
if (!intel_dp->want_panel_vdd)
|
|
|
|
edp_panel_vdd_off_sync(intel_dp);
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
2011-09-19 14:09:52 +08:00
|
|
|
}
|
|
|
|
|
2014-07-30 20:57:31 +08:00
|
|
|
static void edp_panel_vdd_schedule_off(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
unsigned long delay;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Queue the timer to fire a long time from now (relative to the power
|
|
|
|
* down delay) to keep the panel power up across a sequence of
|
|
|
|
* operations.
|
|
|
|
*/
|
|
|
|
delay = msecs_to_jiffies(intel_dp->panel_power_cycle_delay * 5);
|
|
|
|
schedule_delayed_work(&intel_dp->panel_vdd_work, delay);
|
|
|
|
}
|
|
|
|
|
2014-09-04 19:55:31 +08:00
|
|
|
/*
|
|
|
|
* Must be paired with edp_panel_vdd_on().
|
|
|
|
* Must hold pps_mutex around the whole on/off sequence.
|
|
|
|
* Can be nested with intel_edp_panel_vdd_{on,off}() calls.
|
|
|
|
*/
|
2014-01-17 21:39:48 +08:00
|
|
|
static void edp_panel_vdd_off(struct intel_dp *intel_dp, bool sync)
|
2011-09-19 14:09:52 +08:00
|
|
|
{
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
|
2014-09-04 19:53:14 +08:00
|
|
|
|
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2011-09-29 07:23:51 +08:00
|
|
|
return;
|
2011-01-25 09:10:54 +08:00
|
|
|
|
2014-12-16 02:56:32 +08:00
|
|
|
I915_STATE_WARN(!intel_dp->want_panel_vdd, "eDP port %c VDD not forced on",
|
2014-10-17 02:30:02 +08:00
|
|
|
port_name(dp_to_dig_port(intel_dp)->port));
|
2011-11-02 11:01:35 +08:00
|
|
|
|
2011-09-19 14:09:52 +08:00
|
|
|
intel_dp->want_panel_vdd = false;
|
|
|
|
|
2014-07-30 20:57:31 +08:00
|
|
|
if (sync)
|
2014-01-17 21:39:48 +08:00
|
|
|
edp_panel_vdd_off_sync(intel_dp);
|
2014-07-30 20:57:31 +08:00
|
|
|
else
|
|
|
|
edp_panel_vdd_schedule_off(intel_dp);
|
2011-01-25 09:10:54 +08:00
|
|
|
}
|
|
|
|
|
2014-10-17 02:27:32 +08:00
|
|
|
static void edp_panel_on(struct intel_dp *intel_dp)
|
2010-07-23 04:18:19 +08:00
|
|
|
{
|
2012-10-27 05:05:45 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2011-11-02 10:57:50 +08:00
|
|
|
u32 pp;
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_reg_t pp_ctrl_reg;
|
2010-07-23 04:18:19 +08:00
|
|
|
|
2014-10-17 02:27:32 +08:00
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2011-09-19 14:09:52 +08:00
|
|
|
return;
|
2011-11-02 10:57:50 +08:00
|
|
|
|
2014-10-17 02:30:02 +08:00
|
|
|
DRM_DEBUG_KMS("Turn eDP port %c panel power on\n",
|
|
|
|
port_name(dp_to_dig_port(intel_dp)->port));
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2014-10-17 02:30:07 +08:00
|
|
|
if (WARN(edp_have_panel_power(intel_dp),
|
|
|
|
"eDP port %c panel power already on\n",
|
|
|
|
port_name(dp_to_dig_port(intel_dp)->port)))
|
2014-10-17 02:27:32 +08:00
|
|
|
return;
|
2010-07-23 04:18:19 +08:00
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
wait_panel_power_cycle(intel_dp);
|
2010-08-12 01:04:43 +08:00
|
|
|
|
2013-09-06 12:40:05 +08:00
|
|
|
pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
|
2013-03-29 00:55:41 +08:00
|
|
|
pp = ironlake_get_pp_control(intel_dp);
|
2016-10-13 18:03:10 +08:00
|
|
|
if (IS_GEN5(dev_priv)) {
|
2011-09-30 07:33:01 +08:00
|
|
|
/* ILK workaround: disable reset around power sequence */
|
|
|
|
pp &= ~PANEL_POWER_RESET;
|
2013-09-06 12:40:05 +08:00
|
|
|
I915_WRITE(pp_ctrl_reg, pp);
|
|
|
|
POSTING_READ(pp_ctrl_reg);
|
2011-09-30 07:33:01 +08:00
|
|
|
}
|
2010-08-12 01:04:43 +08:00
|
|
|
|
2016-08-10 19:07:30 +08:00
|
|
|
pp |= PANEL_POWER_ON;
|
2016-10-13 18:03:10 +08:00
|
|
|
if (!IS_GEN5(dev_priv))
|
2011-11-02 10:57:50 +08:00
|
|
|
pp |= PANEL_POWER_RESET;
|
|
|
|
|
2013-03-29 00:55:41 +08:00
|
|
|
I915_WRITE(pp_ctrl_reg, pp);
|
|
|
|
POSTING_READ(pp_ctrl_reg);
|
2010-07-23 04:18:19 +08:00
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
wait_panel_on(intel_dp);
|
2013-12-20 00:29:40 +08:00
|
|
|
intel_dp->last_power_on = jiffies;
|
2010-07-23 04:18:19 +08:00
|
|
|
|
2016-10-13 18:03:10 +08:00
|
|
|
if (IS_GEN5(dev_priv)) {
|
2011-09-30 07:33:01 +08:00
|
|
|
pp |= PANEL_POWER_RESET; /* restore panel reset bit */
|
2013-09-06 12:40:05 +08:00
|
|
|
I915_WRITE(pp_ctrl_reg, pp);
|
|
|
|
POSTING_READ(pp_ctrl_reg);
|
2011-09-30 07:33:01 +08:00
|
|
|
}
|
2014-10-17 02:27:32 +08:00
|
|
|
}
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2014-10-17 02:27:32 +08:00
|
|
|
void intel_edp_panel_on(struct intel_dp *intel_dp)
|
|
|
|
{
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2014-10-17 02:27:32 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
pps_lock(intel_dp);
|
|
|
|
edp_panel_on(intel_dp);
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
2010-07-23 04:18:19 +08:00
|
|
|
}
|
|
|
|
|
2014-10-17 02:27:32 +08:00
|
|
|
|
|
|
|
static void edp_panel_off(struct intel_dp *intel_dp)
|
2010-07-23 04:18:19 +08:00
|
|
|
{
|
2012-10-27 05:05:45 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2011-11-02 10:57:50 +08:00
|
|
|
u32 pp;
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_reg_t pp_ctrl_reg;
|
2010-07-23 04:18:19 +08:00
|
|
|
|
2014-10-17 02:27:32 +08:00
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2011-09-29 07:23:51 +08:00
|
|
|
return;
|
2010-08-12 01:04:43 +08:00
|
|
|
|
2014-10-17 02:30:02 +08:00
|
|
|
DRM_DEBUG_KMS("Turn eDP port %c panel power off\n",
|
|
|
|
port_name(dp_to_dig_port(intel_dp)->port));
|
2010-08-12 01:04:43 +08:00
|
|
|
|
2014-10-17 02:30:02 +08:00
|
|
|
WARN(!intel_dp->want_panel_vdd, "Need eDP port %c VDD to turn off panel\n",
|
|
|
|
port_name(dp_to_dig_port(intel_dp)->port));
|
2014-03-17 22:43:36 +08:00
|
|
|
|
2013-03-29 00:55:41 +08:00
|
|
|
pp = ironlake_get_pp_control(intel_dp);
|
drm/i915: reorder edp disabling to fix ivb MacBook Air
eDP is tons of fun. It turns out that at least the new MacBook Air 5,1
model absolutely doesn't like the new force vdd dance we've introduced
in
commit 6cb49835da0426f69a2931bc2a0a8156344b0e41
Author: Daniel Vetter <daniel.vetter@ffwll.ch>
Date: Sun May 20 17:14:50 2012 +0200
drm/i915: enable vdd when switching off the eDP panel
But that patch also tried to fix some neat edp sequence issue with the
force_vdd timings. Closer inspection reveals that we've raised
force_vdd only to do the aux channel communication dp_sink_dpms. If we
move the edp_panel_off below that, we don't need any force_vdd for the
disable sequence, which makes the Air happy.
Unfortunately the reporter of the original bug that the above commit
fixed is travelling, so we can't test whether this regresses things.
But my theory is that since we don't check for any power-off ->
force_vdd-on delays in edp_panel_vdd_on, this was the actual
root-cause of this failure. With that force_vdd dance completely
eliminated, I'm hopeful the original bug stays fixed, too.
For reference the old bug, which hopefully doesn't get broken by this:
https://bugzilla.kernel.org/show_bug.cgi?id=43163
In any case, regression fixers win over plain bugfixes, so this needs
to go in asap.
v2: The crucial pieces seems to be to clear the force_vdd flag
uncoditionally, too, in edp_panel_off. Looks like this is left behind
by the firmware somehow.
v3: The Apple firmware seems to switch off the panel on it's own, hence
we still need to keep force_vdd on, but properly clear it when switching
the panel off.
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=45671
Tested-by: Roberto Romer <sildurin@gmail.com>
Tested-by: Daniel Wagner <wagi@monom.org>
Tested-by: Keith Packard <keithp@keithp.com>
Cc: stable@vger.kernel.org
Cc: Keith Packard <keithp@keithp.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-13 04:17:14 +08:00
|
|
|
/* We need to switch off panel power _and_ force vdd, for otherwise some
|
|
|
|
* panels get very unhappy and cease to work. */
|
2016-08-10 19:07:30 +08:00
|
|
|
pp &= ~(PANEL_POWER_ON | PANEL_POWER_RESET | EDP_FORCE_VDD |
|
2014-03-04 07:42:44 +08:00
|
|
|
EDP_BLC_ENABLE);
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2013-09-06 12:40:05 +08:00
|
|
|
pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2014-03-08 07:05:20 +08:00
|
|
|
intel_dp->want_panel_vdd = false;
|
|
|
|
|
2013-03-29 00:55:41 +08:00
|
|
|
I915_WRITE(pp_ctrl_reg, pp);
|
|
|
|
POSTING_READ(pp_ctrl_reg);
|
2010-07-23 04:18:19 +08:00
|
|
|
|
2014-01-17 21:39:48 +08:00
|
|
|
wait_panel_off(intel_dp);
|
2017-10-05 00:48:26 +08:00
|
|
|
intel_dp->panel_power_off_time = ktime_get_boottime();
|
2014-03-08 07:05:20 +08:00
|
|
|
|
|
|
|
/* We got a reference when we enabled the VDD. */
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_put(dev_priv, intel_dp->aux_power_domain);
|
2014-10-17 02:27:32 +08:00
|
|
|
}
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2014-10-17 02:27:32 +08:00
|
|
|
void intel_edp_panel_off(struct intel_dp *intel_dp)
|
|
|
|
{
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2014-10-17 02:27:32 +08:00
|
|
|
return;
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2014-10-17 02:27:32 +08:00
|
|
|
pps_lock(intel_dp);
|
|
|
|
edp_panel_off(intel_dp);
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
2010-07-23 04:18:19 +08:00
|
|
|
}
|
|
|
|
|
2014-08-12 22:11:39 +08:00
|
|
|
/* Enable backlight in the panel power control. */
|
|
|
|
static void _intel_edp_backlight_on(struct intel_dp *intel_dp)
|
2009-07-24 01:00:32 +08:00
|
|
|
{
|
2012-10-27 05:05:46 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2009-07-24 01:00:32 +08:00
|
|
|
u32 pp;
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_reg_t pp_ctrl_reg;
|
2009-07-24 01:00:32 +08:00
|
|
|
|
2010-10-08 07:01:12 +08:00
|
|
|
/*
|
|
|
|
* If we enable the backlight right away following a panel power
|
|
|
|
* on, we may see slight flicker as the panel syncs with the eDP
|
|
|
|
* link. So delay a bit to make sure the image is solid before
|
|
|
|
* allowing it to appear.
|
|
|
|
*/
|
2014-01-17 21:39:48 +08:00
|
|
|
wait_backlight_on(intel_dp);
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_lock(intel_dp);
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2013-03-29 00:55:41 +08:00
|
|
|
pp = ironlake_get_pp_control(intel_dp);
|
2009-07-24 01:00:32 +08:00
|
|
|
pp |= EDP_BLC_ENABLE;
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2013-09-06 12:40:05 +08:00
|
|
|
pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
|
2013-03-29 00:55:41 +08:00
|
|
|
|
|
|
|
I915_WRITE(pp_ctrl_reg, pp);
|
|
|
|
POSTING_READ(pp_ctrl_reg);
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
2009-07-24 01:00:32 +08:00
|
|
|
}
|
|
|
|
|
2014-08-12 22:11:39 +08:00
|
|
|
/* Enable backlight PWM and backlight PP control. */
|
2017-06-12 18:21:13 +08:00
|
|
|
void intel_edp_backlight_on(const struct intel_crtc_state *crtc_state,
|
|
|
|
const struct drm_connector_state *conn_state)
|
2014-08-12 22:11:39 +08:00
|
|
|
{
|
2017-06-12 18:21:13 +08:00
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(conn_state->best_encoder);
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2014-08-12 22:11:39 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("\n");
|
|
|
|
|
2017-06-12 18:21:13 +08:00
|
|
|
intel_panel_enable_backlight(crtc_state, conn_state);
|
2014-08-12 22:11:39 +08:00
|
|
|
_intel_edp_backlight_on(intel_dp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Disable backlight in the panel power control. */
|
|
|
|
static void _intel_edp_backlight_off(struct intel_dp *intel_dp)
|
2009-07-24 01:00:32 +08:00
|
|
|
{
|
2012-10-27 05:05:45 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2009-07-24 01:00:32 +08:00
|
|
|
u32 pp;
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_reg_t pp_ctrl_reg;
|
2009-07-24 01:00:32 +08:00
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
drm/i915: Correct eDP panel power sequencing delay computations
Store the panel power sequencing delays in the dp private structure,
rather than the global device structure. Who knows, maybe we'll get
more than one eDP device in the future.
From the eDP spec, we need the following numbers:
T1 + T3 Power on to Aux Channel operation (panel_power_up_delay)
This marks how long it takes the panel to boot up and
get ready to receive aux channel communications.
T8 Video signal to backlight on (backlight_on_delay)
Once a valid video signal is being sent to the device,
it can take a while before the panel is actuall
showing useful data. This delay allows the panel
to get something reasonable up before the backlight
is turned on.
T9 Backlight off to video off (backlight_off_delay)
Turning the backlight off can take a moment, so
this delay makes sure there is still valid video
data on the screen.
T10 Video off to power off (panel_power_down_delay)
Presumably this delay allows the panel to perform
an orderly shutdown of the display.
T11 + T12 Power off to power on (panel_power_cycle_delay)
So, once you turn the panel off, you have to wait a
while before you can turn it back on. This delay is
usually the longest in the entire sequence.
Neither the VBIOS source code nor the hardware documentation has a
clear mapping between the delay values they provide and those required
by the eDP spec. The VBIOS code actually uses two different labels for
the delay values in the five words of the relevant VBT table.
**** MORE LATER ***
Look at both the current hardware register settings and the VBT
specified panel power sequencing timings. Use the maximum of the two
delays, to make sure things work reliably. If there is no VBT data,
then those values will be initialized to zero, so we'll just use the
values as programmed in the hardware. Note that the BIOS just fetches
delays from the VBT table to place in the hardware registers, so we
should get the same values from both places, except for rounding.
VBT doesn't provide any values for T1 or T2, so we'll always just use
the hardware value for that.
The panel power up delay is thus T1 + T2 + T3, which should be
sufficient in all cases.
The panel power down delay is T1 + T2 + T12, using T1+T2 as a proxy
for T11, which isn't available anywhere.
For the backlight delays, the eDP spec says T6 + T8 is the delay from the
end of link training to backlight on and T9 is the delay from
backlight off until video off. The hardware provides a 'backlight on'
delay, which I'm taking to be T6 + T8 while the VBT provides something
called 'T7', which I'm assuming is s
On the macbook air I'm testing with, this yields a power-up delay of
over 200ms and a power-down delay of over 600ms. It all works now, but
we're frobbing these power controls several times during mode setting,
making the whole process take an awfully long time.
Signed-off-by: Keith Packard <keithp@keithp.com>
2011-09-29 07:48:10 +08:00
|
|
|
return;
|
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_lock(intel_dp);
|
2014-09-04 19:53:14 +08:00
|
|
|
|
2013-03-29 00:55:41 +08:00
|
|
|
pp = ironlake_get_pp_control(intel_dp);
|
2009-07-24 01:00:32 +08:00
|
|
|
pp &= ~EDP_BLC_ENABLE;
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2013-09-06 12:40:05 +08:00
|
|
|
pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
|
2013-03-29 00:55:41 +08:00
|
|
|
|
|
|
|
I915_WRITE(pp_ctrl_reg, pp);
|
|
|
|
POSTING_READ(pp_ctrl_reg);
|
2014-04-01 02:13:56 +08:00
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
2014-09-04 19:53:14 +08:00
|
|
|
|
|
|
|
intel_dp->last_backlight_off = jiffies;
|
2014-04-01 02:13:56 +08:00
|
|
|
edp_wait_backlight_off(intel_dp);
|
2014-08-12 22:11:39 +08:00
|
|
|
}
|
2014-04-01 02:13:56 +08:00
|
|
|
|
2014-08-12 22:11:39 +08:00
|
|
|
/* Disable backlight PP control and backlight PWM. */
|
2017-06-12 18:21:13 +08:00
|
|
|
void intel_edp_backlight_off(const struct drm_connector_state *old_conn_state)
|
2014-08-12 22:11:39 +08:00
|
|
|
{
|
2017-06-12 18:21:13 +08:00
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(old_conn_state->best_encoder);
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2014-08-12 22:11:39 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("\n");
|
2014-04-01 02:13:56 +08:00
|
|
|
|
2014-08-12 22:11:39 +08:00
|
|
|
_intel_edp_backlight_off(intel_dp);
|
2017-06-12 18:21:13 +08:00
|
|
|
intel_panel_disable_backlight(old_conn_state);
|
2009-07-24 01:00:32 +08:00
|
|
|
}
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2014-08-12 22:11:41 +08:00
|
|
|
/*
|
|
|
|
* Hook for controlling the panel power control backlight through the bl_power
|
|
|
|
* sysfs attribute. Take care to handle multiple calls.
|
|
|
|
*/
|
|
|
|
static void intel_edp_backlight_power(struct intel_connector *connector,
|
|
|
|
bool enable)
|
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = intel_attached_dp(&connector->base);
|
2014-09-04 19:53:14 +08:00
|
|
|
bool is_enabled;
|
|
|
|
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_lock(intel_dp);
|
2014-09-04 19:53:14 +08:00
|
|
|
is_enabled = ironlake_get_pp_control(intel_dp) & EDP_BLC_ENABLE;
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
2014-08-12 22:11:41 +08:00
|
|
|
|
|
|
|
if (is_enabled == enable)
|
|
|
|
return;
|
|
|
|
|
2014-08-27 19:08:43 +08:00
|
|
|
DRM_DEBUG_KMS("panel power control backlight %s\n",
|
|
|
|
enable ? "enable" : "disable");
|
2014-08-12 22:11:41 +08:00
|
|
|
|
|
|
|
if (enable)
|
|
|
|
_intel_edp_backlight_on(intel_dp);
|
|
|
|
else
|
|
|
|
_intel_edp_backlight_off(intel_dp);
|
|
|
|
}
|
|
|
|
|
2015-10-30 03:26:01 +08:00
|
|
|
static void assert_dp_port(struct intel_dp *intel_dp, bool state)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
|
|
|
|
bool cur_state = I915_READ(intel_dp->output_reg) & DP_PORT_EN;
|
|
|
|
|
|
|
|
I915_STATE_WARN(cur_state != state,
|
|
|
|
"DP port %c state assertion failure (expected %s, current %s)\n",
|
|
|
|
port_name(dig_port->port),
|
2016-01-14 18:53:34 +08:00
|
|
|
onoff(state), onoff(cur_state));
|
2015-10-30 03:26:01 +08:00
|
|
|
}
|
|
|
|
#define assert_dp_port_disabled(d) assert_dp_port((d), false)
|
|
|
|
|
|
|
|
static void assert_edp_pll(struct drm_i915_private *dev_priv, bool state)
|
|
|
|
{
|
|
|
|
bool cur_state = I915_READ(DP_A) & DP_PLL_ENABLE;
|
|
|
|
|
|
|
|
I915_STATE_WARN(cur_state != state,
|
|
|
|
"eDP PLL state assertion failure (expected %s, current %s)\n",
|
2016-01-14 18:53:34 +08:00
|
|
|
onoff(state), onoff(cur_state));
|
2015-10-30 03:26:01 +08:00
|
|
|
}
|
|
|
|
#define assert_edp_pll_enabled(d) assert_edp_pll((d), true)
|
|
|
|
#define assert_edp_pll_disabled(d) assert_edp_pll((d), false)
|
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
static void ironlake_edp_pll_on(struct intel_dp *intel_dp,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config)
|
2010-08-14 06:43:26 +08:00
|
|
|
{
|
2016-08-09 23:04:13 +08:00
|
|
|
struct intel_crtc *crtc = to_intel_crtc(pipe_config->base.crtc);
|
2015-10-30 03:26:01 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
|
2010-08-14 06:43:26 +08:00
|
|
|
|
2015-10-30 03:26:01 +08:00
|
|
|
assert_pipe_disabled(dev_priv, crtc->pipe);
|
|
|
|
assert_dp_port_disabled(intel_dp);
|
|
|
|
assert_edp_pll_disabled(dev_priv);
|
2012-09-07 04:15:41 +08:00
|
|
|
|
2015-10-30 03:26:03 +08:00
|
|
|
DRM_DEBUG_KMS("enabling eDP PLL for clock %d\n",
|
2016-08-09 23:04:13 +08:00
|
|
|
pipe_config->port_clock);
|
2015-10-30 03:26:03 +08:00
|
|
|
|
|
|
|
intel_dp->DP &= ~DP_PLL_FREQ_MASK;
|
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
if (pipe_config->port_clock == 162000)
|
2015-10-30 03:26:03 +08:00
|
|
|
intel_dp->DP |= DP_PLL_FREQ_162MHZ;
|
|
|
|
else
|
|
|
|
intel_dp->DP |= DP_PLL_FREQ_270MHZ;
|
|
|
|
|
|
|
|
I915_WRITE(DP_A, intel_dp->DP);
|
|
|
|
POSTING_READ(DP_A);
|
|
|
|
udelay(500);
|
|
|
|
|
2016-04-02 02:53:19 +08:00
|
|
|
/*
|
|
|
|
* [DevILK] Work around required when enabling DP PLL
|
|
|
|
* while a pipe is enabled going to FDI:
|
|
|
|
* 1. Wait for the start of vertical blank on the enabled pipe going to FDI
|
|
|
|
* 2. Program DP PLL enable
|
|
|
|
*/
|
|
|
|
if (IS_GEN5(dev_priv))
|
2016-11-01 04:37:06 +08:00
|
|
|
intel_wait_for_vblank_if_active(dev_priv, !crtc->pipe);
|
2016-04-02 02:53:19 +08:00
|
|
|
|
2012-09-07 04:15:42 +08:00
|
|
|
intel_dp->DP |= DP_PLL_ENABLE;
|
2015-11-10 22:16:17 +08:00
|
|
|
|
2012-09-07 04:15:42 +08:00
|
|
|
I915_WRITE(DP_A, intel_dp->DP);
|
2010-10-08 07:01:24 +08:00
|
|
|
POSTING_READ(DP_A);
|
|
|
|
udelay(200);
|
2010-08-14 06:43:26 +08:00
|
|
|
}
|
|
|
|
|
2012-09-07 04:15:41 +08:00
|
|
|
static void ironlake_edp_pll_off(struct intel_dp *intel_dp)
|
2010-08-14 06:43:26 +08:00
|
|
|
{
|
2012-10-27 05:05:46 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2015-10-30 03:26:01 +08:00
|
|
|
struct intel_crtc *crtc = to_intel_crtc(intel_dig_port->base.base.crtc);
|
|
|
|
struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
|
2010-08-14 06:43:26 +08:00
|
|
|
|
2015-10-30 03:26:01 +08:00
|
|
|
assert_pipe_disabled(dev_priv, crtc->pipe);
|
|
|
|
assert_dp_port_disabled(intel_dp);
|
|
|
|
assert_edp_pll_enabled(dev_priv);
|
2012-09-07 04:15:41 +08:00
|
|
|
|
2015-10-30 03:26:03 +08:00
|
|
|
DRM_DEBUG_KMS("disabling eDP PLL\n");
|
|
|
|
|
2015-11-10 22:16:17 +08:00
|
|
|
intel_dp->DP &= ~DP_PLL_ENABLE;
|
2012-09-07 04:15:42 +08:00
|
|
|
|
2015-11-10 22:16:17 +08:00
|
|
|
I915_WRITE(DP_A, intel_dp->DP);
|
2010-09-09 04:07:28 +08:00
|
|
|
POSTING_READ(DP_A);
|
2010-08-14 06:43:26 +08:00
|
|
|
udelay(200);
|
|
|
|
}
|
|
|
|
|
2011-07-08 02:11:03 +08:00
|
|
|
/* If the sink supports it, try to set the power state appropriately */
|
2012-10-16 02:51:41 +08:00
|
|
|
void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode)
|
2011-07-08 02:11:03 +08:00
|
|
|
{
|
|
|
|
int ret, i;
|
|
|
|
|
|
|
|
/* Should have a valid DPCD by this point */
|
|
|
|
if (intel_dp->dpcd[DP_DPCD_REV] < 0x11)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (mode != DRM_MODE_DPMS_ON) {
|
2014-03-14 22:51:15 +08:00
|
|
|
ret = drm_dp_dpcd_writeb(&intel_dp->aux, DP_SET_POWER,
|
|
|
|
DP_SET_POWER_D3);
|
2011-07-08 02:11:03 +08:00
|
|
|
} else {
|
2016-11-22 03:15:06 +08:00
|
|
|
struct intel_lspcon *lspcon = dp_to_lspcon(intel_dp);
|
|
|
|
|
2011-07-08 02:11:03 +08:00
|
|
|
/*
|
|
|
|
* When turning on, we need to retry for 1ms to give the sink
|
|
|
|
* time to wake up.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < 3; i++) {
|
2014-03-14 22:51:15 +08:00
|
|
|
ret = drm_dp_dpcd_writeb(&intel_dp->aux, DP_SET_POWER,
|
|
|
|
DP_SET_POWER_D0);
|
2011-07-08 02:11:03 +08:00
|
|
|
if (ret == 1)
|
|
|
|
break;
|
|
|
|
msleep(1);
|
|
|
|
}
|
2016-11-22 03:15:06 +08:00
|
|
|
|
|
|
|
if (ret == 1 && lspcon->active)
|
|
|
|
lspcon_wait_pcon_mode(lspcon);
|
2011-07-08 02:11:03 +08:00
|
|
|
}
|
2014-09-02 21:33:52 +08:00
|
|
|
|
|
|
|
if (ret != 1)
|
|
|
|
DRM_DEBUG_KMS("failed to %s sink power state\n",
|
|
|
|
mode == DRM_MODE_DPMS_ON ? "enable" : "disable");
|
2011-07-08 02:11:03 +08:00
|
|
|
}
|
|
|
|
|
2012-07-02 19:26:27 +08:00
|
|
|
static bool intel_dp_get_hw_state(struct intel_encoder *encoder,
|
|
|
|
enum pipe *pipe)
|
2010-08-14 06:43:26 +08:00
|
|
|
{
|
2012-07-02 19:26:27 +08:00
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
2013-05-16 19:40:36 +08:00
|
|
|
enum port port = dp_to_dig_port(intel_dp)->port;
|
2012-07-02 19:26:27 +08:00
|
|
|
struct drm_device *dev = encoder->base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-03-05 22:20:54 +08:00
|
|
|
u32 tmp;
|
2016-02-13 00:55:18 +08:00
|
|
|
bool ret;
|
2014-03-05 22:20:54 +08:00
|
|
|
|
2017-02-22 14:34:27 +08:00
|
|
|
if (!intel_display_power_get_if_enabled(dev_priv,
|
|
|
|
encoder->power_domain))
|
2014-03-05 22:20:54 +08:00
|
|
|
return false;
|
|
|
|
|
2016-02-13 00:55:18 +08:00
|
|
|
ret = false;
|
|
|
|
|
2014-03-05 22:20:54 +08:00
|
|
|
tmp = I915_READ(intel_dp->output_reg);
|
2012-07-02 19:26:27 +08:00
|
|
|
|
|
|
|
if (!(tmp & DP_PORT_EN))
|
2016-02-13 00:55:18 +08:00
|
|
|
goto out;
|
2012-07-02 19:26:27 +08:00
|
|
|
|
2016-10-13 18:03:10 +08:00
|
|
|
if (IS_GEN7(dev_priv) && port == PORT_A) {
|
2012-07-02 19:26:27 +08:00
|
|
|
*pipe = PORT_TO_PIPE_CPT(tmp);
|
2016-10-13 18:02:53 +08:00
|
|
|
} else if (HAS_PCH_CPT(dev_priv) && port != PORT_A) {
|
2015-05-05 22:17:30 +08:00
|
|
|
enum pipe p;
|
2012-07-02 19:26:27 +08:00
|
|
|
|
2015-05-05 22:17:30 +08:00
|
|
|
for_each_pipe(dev_priv, p) {
|
|
|
|
u32 trans_dp = I915_READ(TRANS_DP_CTL(p));
|
|
|
|
if (TRANS_DP_PIPE_TO_PORT(trans_dp) == port) {
|
|
|
|
*pipe = p;
|
2016-02-13 00:55:18 +08:00
|
|
|
ret = true;
|
|
|
|
|
|
|
|
goto out;
|
2012-07-02 19:26:27 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-26 16:58:11 +08:00
|
|
|
DRM_DEBUG_KMS("No pipe for dp port 0x%x found\n",
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 21:33:26 +08:00
|
|
|
i915_mmio_reg_offset(intel_dp->output_reg));
|
2016-10-14 17:13:44 +08:00
|
|
|
} else if (IS_CHERRYVIEW(dev_priv)) {
|
2015-05-05 22:17:29 +08:00
|
|
|
*pipe = DP_PORT_TO_PIPE_CHV(tmp);
|
|
|
|
} else {
|
|
|
|
*pipe = PORT_TO_PIPE(tmp);
|
2012-10-26 16:58:11 +08:00
|
|
|
}
|
2010-08-14 06:43:26 +08:00
|
|
|
|
2016-02-13 00:55:18 +08:00
|
|
|
ret = true;
|
|
|
|
|
|
|
|
out:
|
2017-02-22 14:34:27 +08:00
|
|
|
intel_display_power_put(dev_priv, encoder->power_domain);
|
2016-02-13 00:55:18 +08:00
|
|
|
|
|
|
|
return ret;
|
2012-07-02 19:26:27 +08:00
|
|
|
}
|
2010-08-14 06:43:26 +08:00
|
|
|
|
2013-05-15 08:08:26 +08:00
|
|
|
static void intel_dp_get_config(struct intel_encoder *encoder,
|
2015-01-15 20:55:21 +08:00
|
|
|
struct intel_crtc_state *pipe_config)
|
2013-05-15 08:08:26 +08:00
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
|
|
|
u32 tmp, flags = 0;
|
2013-06-28 12:59:06 +08:00
|
|
|
struct drm_device *dev = encoder->base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2013-06-28 12:59:06 +08:00
|
|
|
enum port port = dp_to_dig_port(intel_dp)->port;
|
|
|
|
struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
|
2013-05-15 08:08:26 +08:00
|
|
|
|
2014-04-25 05:54:52 +08:00
|
|
|
tmp = I915_READ(intel_dp->output_reg);
|
2015-05-05 21:32:12 +08:00
|
|
|
|
|
|
|
pipe_config->has_audio = tmp & DP_AUDIO_OUTPUT_ENABLE && port != PORT_A;
|
2014-04-25 05:54:52 +08:00
|
|
|
|
2016-10-13 18:02:53 +08:00
|
|
|
if (HAS_PCH_CPT(dev_priv) && port != PORT_A) {
|
2015-07-06 20:10:03 +08:00
|
|
|
u32 trans_dp = I915_READ(TRANS_DP_CTL(crtc->pipe));
|
|
|
|
|
|
|
|
if (trans_dp & TRANS_DP_HSYNC_ACTIVE_HIGH)
|
2013-06-28 12:59:06 +08:00
|
|
|
flags |= DRM_MODE_FLAG_PHSYNC;
|
|
|
|
else
|
|
|
|
flags |= DRM_MODE_FLAG_NHSYNC;
|
2013-05-15 08:08:26 +08:00
|
|
|
|
2015-07-06 20:10:03 +08:00
|
|
|
if (trans_dp & TRANS_DP_VSYNC_ACTIVE_HIGH)
|
2013-06-28 12:59:06 +08:00
|
|
|
flags |= DRM_MODE_FLAG_PVSYNC;
|
|
|
|
else
|
|
|
|
flags |= DRM_MODE_FLAG_NVSYNC;
|
|
|
|
} else {
|
2015-05-05 22:17:29 +08:00
|
|
|
if (tmp & DP_SYNC_HS_HIGH)
|
2013-06-28 12:59:06 +08:00
|
|
|
flags |= DRM_MODE_FLAG_PHSYNC;
|
|
|
|
else
|
|
|
|
flags |= DRM_MODE_FLAG_NHSYNC;
|
2013-05-15 08:08:26 +08:00
|
|
|
|
2015-05-05 22:17:29 +08:00
|
|
|
if (tmp & DP_SYNC_VS_HIGH)
|
2013-06-28 12:59:06 +08:00
|
|
|
flags |= DRM_MODE_FLAG_PVSYNC;
|
|
|
|
else
|
|
|
|
flags |= DRM_MODE_FLAG_NVSYNC;
|
|
|
|
}
|
2013-05-15 08:08:26 +08:00
|
|
|
|
2015-01-15 20:55:22 +08:00
|
|
|
pipe_config->base.adjusted_mode.flags |= flags;
|
2013-06-27 05:39:25 +08:00
|
|
|
|
2016-11-15 01:44:07 +08:00
|
|
|
if (IS_G4X(dev_priv) && tmp & DP_COLOR_RANGE_16_235)
|
2014-09-12 20:46:29 +08:00
|
|
|
pipe_config->limited_color_range = true;
|
|
|
|
|
2015-07-06 21:39:15 +08:00
|
|
|
pipe_config->lane_count =
|
|
|
|
((tmp & DP_PORT_WIDTH_MASK) >> DP_PORT_WIDTH_SHIFT) + 1;
|
|
|
|
|
2013-09-10 22:02:54 +08:00
|
|
|
intel_dp_get_m_n(crtc, pipe_config);
|
|
|
|
|
2013-09-13 21:00:08 +08:00
|
|
|
if (port == PORT_A) {
|
2015-10-30 03:25:59 +08:00
|
|
|
if ((I915_READ(DP_A) & DP_PLL_FREQ_MASK) == DP_PLL_FREQ_162MHZ)
|
2013-06-27 05:39:25 +08:00
|
|
|
pipe_config->port_clock = 162000;
|
|
|
|
else
|
|
|
|
pipe_config->port_clock = 270000;
|
|
|
|
}
|
2013-09-13 21:00:08 +08:00
|
|
|
|
2016-02-18 03:41:09 +08:00
|
|
|
pipe_config->base.adjusted_mode.crtc_clock =
|
|
|
|
intel_dotclock_calculate(pipe_config->port_clock,
|
|
|
|
&pipe_config->dp_m_n);
|
2013-11-04 23:28:47 +08:00
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp) && dev_priv->vbt.edp.bpp &&
|
2016-03-24 23:50:20 +08:00
|
|
|
pipe_config->pipe_bpp > dev_priv->vbt.edp.bpp) {
|
drm/i915/dp: workaround BIOS eDP bpp clamping issue
This isn't a real fix to the problem, but rather a stopgap measure while
trying to find a proper solution.
There are several laptops out there that fail to light up the eDP panel
in UEFI boot mode. They seem to be mostly IVB machines, including but
apparently not limited to Dell XPS 13, Asus TX300, Asus UX31A, Asus
UX32VD, Acer Aspire S7. They seem to work in CSM or legacy boot.
The difference between UEFI and CSM is that the BIOS provides a
different VBT to the kernel. The UEFI VBT typically specifies 18 bpp and
1.62 GHz link for eDP, while CSM VBT has 24 bpp and 2.7 GHz link. We end
up clamping to 18 bpp in UEFI mode, which we can fit in the 1.62 Ghz
link, and for reasons yet unknown fail to light up the panel.
Dithering from 24 to 18 bpp itself seems to work; if we use 18 bpp with
2.7 GHz link, the eDP panel lights up. So essentially this is a link
speed issue, and *not* a bpp clamping issue.
The bug raised its head since
commit 657445fe8660100ad174600ebfa61536392b7624
Author: Daniel Vetter <daniel.vetter@ffwll.ch>
Date: Sat May 4 10:09:18 2013 +0200
Revert "drm/i915: revert eDP bpp clamping code changes"
which started clamping bpp *before* computing the link requirements, and
thus affecting the required bandwidth. Clamping after the computations
kept the link at 2.7 GHz.
Even though the BIOS tells us to use 18 bpp through the VBT, it happily
boots up at 24 bpp and 2.7 GHz itself! Use this information to
selectively ignore the VBT provided value.
We can't ignore the VBT eDP bpp altogether, as there are other laptops
that do require the clamping to be used due to EDID reporting higher bpp
than the panel can support.
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=59841
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=67950
Tested-by: Ulf Winkelvos <ulf@winkelvos.de>
Tested-by: jkp <jkp@iki.fi>
CC: stable@vger.kernel.org
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-10-21 15:52:07 +08:00
|
|
|
/*
|
|
|
|
* This is a big fat ugly hack.
|
|
|
|
*
|
|
|
|
* Some machines in UEFI boot mode provide us a VBT that has 18
|
|
|
|
* bpp and 1.62 GHz link bandwidth for eDP, which for reasons
|
|
|
|
* unknown we fail to light up. Yet the same BIOS boots up with
|
|
|
|
* 24 bpp and 2.7 GHz link. Use the same bpp as the BIOS uses as
|
|
|
|
* max, not what it tells us to use.
|
|
|
|
*
|
|
|
|
* Note: This will still be broken if the eDP panel is not lit
|
|
|
|
* up by the BIOS, and thus we can't get the mode at module
|
|
|
|
* load.
|
|
|
|
*/
|
|
|
|
DRM_DEBUG_KMS("pipe has %d bpp for eDP panel, overriding BIOS-provided max %d bpp\n",
|
2016-03-24 23:50:20 +08:00
|
|
|
pipe_config->pipe_bpp, dev_priv->vbt.edp.bpp);
|
|
|
|
dev_priv->vbt.edp.bpp = pipe_config->pipe_bpp;
|
drm/i915/dp: workaround BIOS eDP bpp clamping issue
This isn't a real fix to the problem, but rather a stopgap measure while
trying to find a proper solution.
There are several laptops out there that fail to light up the eDP panel
in UEFI boot mode. They seem to be mostly IVB machines, including but
apparently not limited to Dell XPS 13, Asus TX300, Asus UX31A, Asus
UX32VD, Acer Aspire S7. They seem to work in CSM or legacy boot.
The difference between UEFI and CSM is that the BIOS provides a
different VBT to the kernel. The UEFI VBT typically specifies 18 bpp and
1.62 GHz link for eDP, while CSM VBT has 24 bpp and 2.7 GHz link. We end
up clamping to 18 bpp in UEFI mode, which we can fit in the 1.62 Ghz
link, and for reasons yet unknown fail to light up the panel.
Dithering from 24 to 18 bpp itself seems to work; if we use 18 bpp with
2.7 GHz link, the eDP panel lights up. So essentially this is a link
speed issue, and *not* a bpp clamping issue.
The bug raised its head since
commit 657445fe8660100ad174600ebfa61536392b7624
Author: Daniel Vetter <daniel.vetter@ffwll.ch>
Date: Sat May 4 10:09:18 2013 +0200
Revert "drm/i915: revert eDP bpp clamping code changes"
which started clamping bpp *before* computing the link requirements, and
thus affecting the required bandwidth. Clamping after the computations
kept the link at 2.7 GHz.
Even though the BIOS tells us to use 18 bpp through the VBT, it happily
boots up at 24 bpp and 2.7 GHz itself! Use this information to
selectively ignore the VBT provided value.
We can't ignore the VBT eDP bpp altogether, as there are other laptops
that do require the clamping to be used due to EDID reporting higher bpp
than the panel can support.
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=59841
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=67950
Tested-by: Ulf Winkelvos <ulf@winkelvos.de>
Tested-by: jkp <jkp@iki.fi>
CC: stable@vger.kernel.org
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-10-21 15:52:07 +08:00
|
|
|
}
|
2013-05-15 08:08:26 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void intel_disable_dp(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *old_crtc_state,
|
|
|
|
const struct drm_connector_state *old_conn_state)
|
2010-08-14 06:43:26 +08:00
|
|
|
{
|
2012-07-01 19:05:48 +08:00
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
2014-10-27 22:26:55 +08:00
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
if (old_crtc_state->has_audio)
|
2014-10-27 22:26:55 +08:00
|
|
|
intel_audio_codec_disable(encoder);
|
2012-05-20 23:14:50 +08:00
|
|
|
|
|
|
|
/* Make sure the panel is off before trying to change the mode. But also
|
|
|
|
* ensure that we have vdd while we switch off the panel. */
|
2014-03-17 22:43:36 +08:00
|
|
|
intel_edp_panel_vdd_on(intel_dp);
|
2017-06-12 18:21:13 +08:00
|
|
|
intel_edp_backlight_off(old_conn_state);
|
2013-11-12 23:10:13 +08:00
|
|
|
intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_OFF);
|
2014-01-17 21:39:48 +08:00
|
|
|
intel_edp_panel_off(intel_dp);
|
2017-09-20 23:12:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void g4x_disable_dp(struct intel_encoder *encoder,
|
|
|
|
const struct intel_crtc_state *old_crtc_state,
|
|
|
|
const struct drm_connector_state *old_conn_state)
|
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
|
|
|
|
|
|
|
intel_disable_dp(encoder, old_crtc_state, old_conn_state);
|
2012-09-07 04:15:44 +08:00
|
|
|
|
2014-08-19 03:16:09 +08:00
|
|
|
/* disable the port before the pipe on g4x */
|
2017-09-20 23:12:51 +08:00
|
|
|
intel_dp_link_down(intel_dp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ilk_disable_dp(struct intel_encoder *encoder,
|
|
|
|
const struct intel_crtc_state *old_crtc_state,
|
|
|
|
const struct drm_connector_state *old_conn_state)
|
|
|
|
{
|
|
|
|
intel_disable_dp(encoder, old_crtc_state, old_conn_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vlv_disable_dp(struct intel_encoder *encoder,
|
|
|
|
const struct intel_crtc_state *old_crtc_state,
|
|
|
|
const struct drm_connector_state *old_conn_state)
|
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
|
|
|
|
|
|
|
intel_psr_disable(intel_dp, old_crtc_state);
|
|
|
|
|
|
|
|
intel_disable_dp(encoder, old_crtc_state, old_conn_state);
|
2010-08-14 06:43:26 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void ilk_post_disable_dp(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *old_crtc_state,
|
|
|
|
const struct drm_connector_state *old_conn_state)
|
2010-08-14 06:43:26 +08:00
|
|
|
{
|
2012-09-07 04:15:41 +08:00
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
2013-05-24 00:39:40 +08:00
|
|
|
enum port port = dp_to_dig_port(intel_dp)->port;
|
2012-09-07 04:15:41 +08:00
|
|
|
|
2014-03-31 23:21:26 +08:00
|
|
|
intel_dp_link_down(intel_dp);
|
2015-10-30 03:26:03 +08:00
|
|
|
|
|
|
|
/* Only ilk+ has port A */
|
2014-08-19 03:16:09 +08:00
|
|
|
if (port == PORT_A)
|
|
|
|
ironlake_edp_pll_off(intel_dp);
|
2014-03-31 23:21:26 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void vlv_post_disable_dp(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *old_crtc_state,
|
|
|
|
const struct drm_connector_state *old_conn_state)
|
2014-03-31 23:21:26 +08:00
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
|
|
|
|
|
|
|
intel_dp_link_down(intel_dp);
|
2012-09-07 04:15:41 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void chv_post_disable_dp(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *old_crtc_state,
|
|
|
|
const struct drm_connector_state *old_conn_state)
|
2015-07-10 01:14:11 +08:00
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
|
|
|
struct drm_device *dev = encoder->base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-04-09 18:29:02 +08:00
|
|
|
|
2015-07-10 01:14:11 +08:00
|
|
|
intel_dp_link_down(intel_dp);
|
|
|
|
|
|
|
|
mutex_lock(&dev_priv->sb_lock);
|
|
|
|
|
|
|
|
/* Assert data lane reset */
|
|
|
|
chv_data_lane_soft_reset(encoder, true);
|
2014-04-09 18:29:00 +08:00
|
|
|
|
2015-05-27 01:42:30 +08:00
|
|
|
mutex_unlock(&dev_priv->sb_lock);
|
2014-04-09 18:29:00 +08:00
|
|
|
}
|
|
|
|
|
2014-08-19 03:16:08 +08:00
|
|
|
static void
|
|
|
|
_intel_dp_set_link_train(struct intel_dp *intel_dp,
|
|
|
|
uint32_t *DP,
|
|
|
|
uint8_t dp_train_pat)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-08-19 03:16:08 +08:00
|
|
|
enum port port = intel_dig_port->port;
|
|
|
|
|
2016-08-05 04:48:35 +08:00
|
|
|
if (dp_train_pat & DP_TRAINING_PATTERN_MASK)
|
|
|
|
DRM_DEBUG_KMS("Using DP training pattern TPS%d\n",
|
|
|
|
dp_train_pat & DP_TRAINING_PATTERN_MASK);
|
|
|
|
|
2016-10-13 18:02:52 +08:00
|
|
|
if (HAS_DDI(dev_priv)) {
|
2014-08-19 03:16:08 +08:00
|
|
|
uint32_t temp = I915_READ(DP_TP_CTL(port));
|
|
|
|
|
|
|
|
if (dp_train_pat & DP_LINK_SCRAMBLING_DISABLE)
|
|
|
|
temp |= DP_TP_CTL_SCRAMBLE_DISABLE;
|
|
|
|
else
|
|
|
|
temp &= ~DP_TP_CTL_SCRAMBLE_DISABLE;
|
|
|
|
|
|
|
|
temp &= ~DP_TP_CTL_LINK_TRAIN_MASK;
|
|
|
|
switch (dp_train_pat & DP_TRAINING_PATTERN_MASK) {
|
|
|
|
case DP_TRAINING_PATTERN_DISABLE:
|
|
|
|
temp |= DP_TP_CTL_LINK_TRAIN_NORMAL;
|
|
|
|
|
|
|
|
break;
|
|
|
|
case DP_TRAINING_PATTERN_1:
|
|
|
|
temp |= DP_TP_CTL_LINK_TRAIN_PAT1;
|
|
|
|
break;
|
|
|
|
case DP_TRAINING_PATTERN_2:
|
|
|
|
temp |= DP_TP_CTL_LINK_TRAIN_PAT2;
|
|
|
|
break;
|
|
|
|
case DP_TRAINING_PATTERN_3:
|
|
|
|
temp |= DP_TP_CTL_LINK_TRAIN_PAT3;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
I915_WRITE(DP_TP_CTL(port), temp);
|
|
|
|
|
2016-10-13 18:03:10 +08:00
|
|
|
} else if ((IS_GEN7(dev_priv) && port == PORT_A) ||
|
2016-10-13 18:02:53 +08:00
|
|
|
(HAS_PCH_CPT(dev_priv) && port != PORT_A)) {
|
2014-08-19 03:16:08 +08:00
|
|
|
*DP &= ~DP_LINK_TRAIN_MASK_CPT;
|
|
|
|
|
|
|
|
switch (dp_train_pat & DP_TRAINING_PATTERN_MASK) {
|
|
|
|
case DP_TRAINING_PATTERN_DISABLE:
|
|
|
|
*DP |= DP_LINK_TRAIN_OFF_CPT;
|
|
|
|
break;
|
|
|
|
case DP_TRAINING_PATTERN_1:
|
|
|
|
*DP |= DP_LINK_TRAIN_PAT_1_CPT;
|
|
|
|
break;
|
|
|
|
case DP_TRAINING_PATTERN_2:
|
|
|
|
*DP |= DP_LINK_TRAIN_PAT_2_CPT;
|
|
|
|
break;
|
|
|
|
case DP_TRAINING_PATTERN_3:
|
2016-08-05 04:48:35 +08:00
|
|
|
DRM_DEBUG_KMS("TPS3 not supported, using TPS2 instead\n");
|
2014-08-19 03:16:08 +08:00
|
|
|
*DP |= DP_LINK_TRAIN_PAT_2_CPT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_CHERRYVIEW(dev_priv))
|
2014-08-19 03:16:08 +08:00
|
|
|
*DP &= ~DP_LINK_TRAIN_MASK_CHV;
|
|
|
|
else
|
|
|
|
*DP &= ~DP_LINK_TRAIN_MASK;
|
|
|
|
|
|
|
|
switch (dp_train_pat & DP_TRAINING_PATTERN_MASK) {
|
|
|
|
case DP_TRAINING_PATTERN_DISABLE:
|
|
|
|
*DP |= DP_LINK_TRAIN_OFF;
|
|
|
|
break;
|
|
|
|
case DP_TRAINING_PATTERN_1:
|
|
|
|
*DP |= DP_LINK_TRAIN_PAT_1;
|
|
|
|
break;
|
|
|
|
case DP_TRAINING_PATTERN_2:
|
|
|
|
*DP |= DP_LINK_TRAIN_PAT_2;
|
|
|
|
break;
|
|
|
|
case DP_TRAINING_PATTERN_3:
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_CHERRYVIEW(dev_priv)) {
|
2014-08-19 03:16:08 +08:00
|
|
|
*DP |= DP_LINK_TRAIN_PAT_3_CHV;
|
|
|
|
} else {
|
2016-08-05 04:48:35 +08:00
|
|
|
DRM_DEBUG_KMS("TPS3 not supported, using TPS2 instead\n");
|
2014-08-19 03:16:08 +08:00
|
|
|
*DP |= DP_LINK_TRAIN_PAT_2;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
static void intel_dp_enable_port(struct intel_dp *intel_dp,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *old_crtc_state)
|
2014-08-19 03:16:08 +08:00
|
|
|
{
|
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-08-19 03:16:08 +08:00
|
|
|
|
|
|
|
/* enable with pattern 1 (as per spec) */
|
|
|
|
|
2016-08-05 04:48:35 +08:00
|
|
|
intel_dp_program_link_training_pattern(intel_dp, DP_TRAINING_PATTERN_1);
|
2014-10-17 02:27:35 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Magic for VLV/CHV. We _must_ first set up the register
|
|
|
|
* without actually enabling the port, and then do another
|
|
|
|
* write to enable the port. Otherwise link training will
|
|
|
|
* fail when the power sequencer is freshly used for this port.
|
|
|
|
*/
|
|
|
|
intel_dp->DP |= DP_PORT_EN;
|
2016-08-09 23:04:13 +08:00
|
|
|
if (old_crtc_state->has_audio)
|
2015-11-10 22:16:17 +08:00
|
|
|
intel_dp->DP |= DP_AUDIO_OUTPUT_ENABLE;
|
2014-10-17 02:27:35 +08:00
|
|
|
|
|
|
|
I915_WRITE(intel_dp->output_reg, intel_dp->DP);
|
|
|
|
POSTING_READ(intel_dp->output_reg);
|
2014-04-09 18:29:00 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
static void intel_enable_dp(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config,
|
|
|
|
const struct drm_connector_state *conn_state)
|
2010-08-14 06:43:26 +08:00
|
|
|
{
|
2012-07-01 19:05:48 +08:00
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
|
|
|
struct drm_device *dev = encoder->base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-10-27 22:26:56 +08:00
|
|
|
struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
|
2012-07-01 19:05:48 +08:00
|
|
|
uint32_t dp_reg = I915_READ(intel_dp->output_reg);
|
2015-10-30 03:25:58 +08:00
|
|
|
enum pipe pipe = crtc->pipe;
|
2011-01-25 09:10:54 +08:00
|
|
|
|
2012-09-07 04:15:43 +08:00
|
|
|
if (WARN_ON(dp_reg & DP_PORT_EN))
|
|
|
|
return;
|
2011-01-25 09:10:54 +08:00
|
|
|
|
2014-10-17 02:27:33 +08:00
|
|
|
pps_lock(intel_dp);
|
|
|
|
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
|
2014-10-17 02:27:33 +08:00
|
|
|
vlv_init_panel_power_sequencer(intel_dp);
|
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
intel_dp_enable_port(intel_dp, pipe_config);
|
2014-10-17 02:27:33 +08:00
|
|
|
|
|
|
|
edp_panel_vdd_on(intel_dp);
|
|
|
|
edp_panel_on(intel_dp);
|
|
|
|
edp_panel_vdd_off(intel_dp, true);
|
|
|
|
|
|
|
|
pps_unlock(intel_dp);
|
|
|
|
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
|
2015-07-09 04:45:54 +08:00
|
|
|
unsigned int lane_mask = 0x0;
|
|
|
|
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_CHERRYVIEW(dev_priv))
|
2016-08-09 23:04:13 +08:00
|
|
|
lane_mask = intel_dp_unused_lane_mask(pipe_config->lane_count);
|
2015-07-09 04:45:54 +08:00
|
|
|
|
2015-04-10 23:21:31 +08:00
|
|
|
vlv_wait_port_ready(dev_priv, dp_to_dig_port(intel_dp),
|
|
|
|
lane_mask);
|
2015-07-09 04:45:54 +08:00
|
|
|
}
|
2014-10-17 02:27:34 +08:00
|
|
|
|
drm/i915: Correct eDP panel power sequencing delay computations
Store the panel power sequencing delays in the dp private structure,
rather than the global device structure. Who knows, maybe we'll get
more than one eDP device in the future.
From the eDP spec, we need the following numbers:
T1 + T3 Power on to Aux Channel operation (panel_power_up_delay)
This marks how long it takes the panel to boot up and
get ready to receive aux channel communications.
T8 Video signal to backlight on (backlight_on_delay)
Once a valid video signal is being sent to the device,
it can take a while before the panel is actuall
showing useful data. This delay allows the panel
to get something reasonable up before the backlight
is turned on.
T9 Backlight off to video off (backlight_off_delay)
Turning the backlight off can take a moment, so
this delay makes sure there is still valid video
data on the screen.
T10 Video off to power off (panel_power_down_delay)
Presumably this delay allows the panel to perform
an orderly shutdown of the display.
T11 + T12 Power off to power on (panel_power_cycle_delay)
So, once you turn the panel off, you have to wait a
while before you can turn it back on. This delay is
usually the longest in the entire sequence.
Neither the VBIOS source code nor the hardware documentation has a
clear mapping between the delay values they provide and those required
by the eDP spec. The VBIOS code actually uses two different labels for
the delay values in the five words of the relevant VBT table.
**** MORE LATER ***
Look at both the current hardware register settings and the VBT
specified panel power sequencing timings. Use the maximum of the two
delays, to make sure things work reliably. If there is no VBT data,
then those values will be initialized to zero, so we'll just use the
values as programmed in the hardware. Note that the BIOS just fetches
delays from the VBT table to place in the hardware registers, so we
should get the same values from both places, except for rounding.
VBT doesn't provide any values for T1 or T2, so we'll always just use
the hardware value for that.
The panel power up delay is thus T1 + T2 + T3, which should be
sufficient in all cases.
The panel power down delay is T1 + T2 + T12, using T1+T2 as a proxy
for T11, which isn't available anywhere.
For the backlight delays, the eDP spec says T6 + T8 is the delay from the
end of link training to backlight on and T9 is the delay from
backlight off until video off. The hardware provides a 'backlight on'
delay, which I'm taking to be T6 + T8 while the VBT provides something
called 'T7', which I'm assuming is s
On the macbook air I'm testing with, this yields a power-up delay of
over 200ms and a power-down delay of over 600ms. It all works now, but
we're frobbing these power controls several times during mode setting,
making the whole process take an awfully long time.
Signed-off-by: Keith Packard <keithp@keithp.com>
2011-09-29 07:48:10 +08:00
|
|
|
intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_ON);
|
2010-09-09 03:42:02 +08:00
|
|
|
intel_dp_start_link_train(intel_dp);
|
2013-05-03 17:57:41 +08:00
|
|
|
intel_dp_stop_link_train(intel_dp);
|
2014-10-27 22:26:56 +08:00
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
if (pipe_config->has_audio) {
|
2014-10-27 22:26:56 +08:00
|
|
|
DRM_DEBUG_DRIVER("Enabling DP audio on pipe %c\n",
|
2015-10-30 03:25:58 +08:00
|
|
|
pipe_name(pipe));
|
2016-11-08 20:55:38 +08:00
|
|
|
intel_audio_codec_enable(encoder, pipe_config, conn_state);
|
2014-10-27 22:26:56 +08:00
|
|
|
}
|
2013-07-30 17:20:30 +08:00
|
|
|
}
|
2013-04-19 05:51:36 +08:00
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void g4x_enable_dp(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config,
|
|
|
|
const struct drm_connector_state *conn_state)
|
2013-09-06 12:38:29 +08:00
|
|
|
{
|
2016-11-08 20:55:38 +08:00
|
|
|
intel_enable_dp(encoder, pipe_config, conn_state);
|
2017-06-12 18:21:13 +08:00
|
|
|
intel_edp_backlight_on(pipe_config, conn_state);
|
2013-07-30 17:20:30 +08:00
|
|
|
}
|
2013-04-19 05:51:36 +08:00
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void vlv_enable_dp(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config,
|
|
|
|
const struct drm_connector_state *conn_state)
|
2013-07-30 17:20:30 +08:00
|
|
|
{
|
2013-09-05 21:44:45 +08:00
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
|
|
|
|
2017-06-12 18:21:13 +08:00
|
|
|
intel_edp_backlight_on(pipe_config, conn_state);
|
2017-08-18 21:49:56 +08:00
|
|
|
intel_psr_enable(intel_dp, pipe_config);
|
2010-08-14 06:43:26 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void g4x_pre_enable_dp(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config,
|
|
|
|
const struct drm_connector_state *conn_state)
|
2013-07-30 17:20:30 +08:00
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
|
2015-10-30 03:25:58 +08:00
|
|
|
enum port port = dp_to_dig_port(intel_dp)->port;
|
2013-07-30 17:20:30 +08:00
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
intel_dp_prepare(encoder, pipe_config);
|
2014-04-25 05:54:54 +08:00
|
|
|
|
2014-04-25 05:54:53 +08:00
|
|
|
/* Only ilk+ has port A */
|
2015-10-30 03:26:03 +08:00
|
|
|
if (port == PORT_A)
|
2016-08-09 23:04:13 +08:00
|
|
|
ironlake_edp_pll_on(intel_dp, pipe_config);
|
2013-07-30 17:20:30 +08:00
|
|
|
}
|
|
|
|
|
2014-10-17 02:29:51 +08:00
|
|
|
static void vlv_detach_power_sequencer(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_dig_port->base.base.dev);
|
2014-10-17 02:29:51 +08:00
|
|
|
enum pipe pipe = intel_dp->pps_pipe;
|
2016-08-10 19:07:29 +08:00
|
|
|
i915_reg_t pp_on_reg = PP_ON_DELAYS(pipe);
|
2014-10-17 02:29:51 +08:00
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
WARN_ON(intel_dp->active_pipe != INVALID_PIPE);
|
|
|
|
|
2017-02-09 01:52:54 +08:00
|
|
|
if (WARN_ON(pipe != PIPE_A && pipe != PIPE_B))
|
|
|
|
return;
|
|
|
|
|
2014-10-17 02:29:51 +08:00
|
|
|
edp_panel_vdd_off_sync(intel_dp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* VLV seems to get confused when multiple power seqeuencers
|
|
|
|
* have the same port selected (even if only one has power/vdd
|
|
|
|
* enabled). The failure manifests as vlv_wait_port_ready() failing
|
|
|
|
* CHV on the other hand doesn't seem to mind having the same port
|
|
|
|
* selected in multiple power seqeuencers, but let's clear the
|
|
|
|
* port select always when logically disconnecting a power sequencer
|
|
|
|
* from a port.
|
|
|
|
*/
|
|
|
|
DRM_DEBUG_KMS("detaching pipe %c power sequencer from port %c\n",
|
|
|
|
pipe_name(pipe), port_name(intel_dig_port->port));
|
|
|
|
I915_WRITE(pp_on_reg, 0);
|
|
|
|
POSTING_READ(pp_on_reg);
|
|
|
|
|
|
|
|
intel_dp->pps_pipe = INVALID_PIPE;
|
|
|
|
}
|
|
|
|
|
2014-09-04 19:54:20 +08:00
|
|
|
static void vlv_steal_power_sequencer(struct drm_device *dev,
|
|
|
|
enum pipe pipe)
|
|
|
|
{
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-09-04 19:54:20 +08:00
|
|
|
struct intel_encoder *encoder;
|
|
|
|
|
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
2015-12-16 18:48:16 +08:00
|
|
|
for_each_intel_encoder(dev, encoder) {
|
2014-09-04 19:54:20 +08:00
|
|
|
struct intel_dp *intel_dp;
|
2014-09-04 19:54:56 +08:00
|
|
|
enum port port;
|
2014-09-04 19:54:20 +08:00
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
if (encoder->type != INTEL_OUTPUT_DP &&
|
|
|
|
encoder->type != INTEL_OUTPUT_EDP)
|
2014-09-04 19:54:20 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
intel_dp = enc_to_intel_dp(&encoder->base);
|
2014-09-04 19:54:56 +08:00
|
|
|
port = dp_to_dig_port(intel_dp)->port;
|
2014-09-04 19:54:20 +08:00
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
WARN(intel_dp->active_pipe == pipe,
|
|
|
|
"stealing pipe %c power sequencer from active (e)DP port %c\n",
|
|
|
|
pipe_name(pipe), port_name(port));
|
|
|
|
|
2014-09-04 19:54:20 +08:00
|
|
|
if (intel_dp->pps_pipe != pipe)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("stealing pipe %c power sequencer from port %c\n",
|
2014-09-04 19:54:56 +08:00
|
|
|
pipe_name(pipe), port_name(port));
|
2014-09-04 19:54:20 +08:00
|
|
|
|
|
|
|
/* make sure vdd is off before we steal it */
|
2014-10-17 02:29:51 +08:00
|
|
|
vlv_detach_power_sequencer(intel_dp);
|
2014-09-04 19:54:20 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vlv_init_panel_power_sequencer(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct intel_encoder *encoder = &intel_dig_port->base;
|
|
|
|
struct drm_device *dev = encoder->base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-09-04 19:54:20 +08:00
|
|
|
struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
|
|
|
|
|
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
WARN_ON(intel_dp->active_pipe != INVALID_PIPE);
|
2014-10-17 02:27:33 +08:00
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
if (intel_dp->pps_pipe != INVALID_PIPE &&
|
|
|
|
intel_dp->pps_pipe != crtc->pipe) {
|
|
|
|
/*
|
|
|
|
* If another power sequencer was being used on this
|
|
|
|
* port previously make sure to turn off vdd there while
|
|
|
|
* we still have control of it.
|
|
|
|
*/
|
2014-10-17 02:29:51 +08:00
|
|
|
vlv_detach_power_sequencer(intel_dp);
|
2016-12-15 02:00:23 +08:00
|
|
|
}
|
2014-09-04 19:54:20 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We may be stealing the power
|
|
|
|
* sequencer from another port.
|
|
|
|
*/
|
|
|
|
vlv_steal_power_sequencer(dev, crtc->pipe);
|
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
intel_dp->active_pipe = crtc->pipe;
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2016-12-15 02:00:23 +08:00
|
|
|
return;
|
|
|
|
|
2014-09-04 19:54:20 +08:00
|
|
|
/* now it's all ours */
|
|
|
|
intel_dp->pps_pipe = crtc->pipe;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("initializing pipe %c power sequencer for port %c\n",
|
|
|
|
pipe_name(intel_dp->pps_pipe), port_name(intel_dig_port->port));
|
|
|
|
|
|
|
|
/* init power sequencer on this pipe and port */
|
2014-10-17 02:27:30 +08:00
|
|
|
intel_dp_init_panel_power_sequencer(dev, intel_dp);
|
2016-12-21 00:51:17 +08:00
|
|
|
intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, true);
|
2014-09-04 19:54:20 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void vlv_pre_enable_dp(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config,
|
|
|
|
const struct drm_connector_state *conn_state)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2016-04-27 20:44:24 +08:00
|
|
|
vlv_phy_pre_encoder_enable(encoder);
|
2013-07-30 17:20:30 +08:00
|
|
|
|
2016-11-08 20:55:38 +08:00
|
|
|
intel_enable_dp(encoder, pipe_config, conn_state);
|
2013-04-19 05:51:36 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void vlv_dp_pre_pll_enable(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config,
|
|
|
|
const struct drm_connector_state *conn_state)
|
2013-04-19 05:51:36 +08:00
|
|
|
{
|
2016-08-09 23:04:13 +08:00
|
|
|
intel_dp_prepare(encoder, pipe_config);
|
2014-04-25 05:54:54 +08:00
|
|
|
|
2016-04-27 20:44:23 +08:00
|
|
|
vlv_phy_pre_pll_enable(encoder);
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void chv_pre_enable_dp(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config,
|
|
|
|
const struct drm_connector_state *conn_state)
|
2014-04-09 18:28:20 +08:00
|
|
|
{
|
2016-04-27 20:44:20 +08:00
|
|
|
chv_phy_pre_encoder_enable(encoder);
|
2014-04-09 18:28:20 +08:00
|
|
|
|
2016-11-08 20:55:38 +08:00
|
|
|
intel_enable_dp(encoder, pipe_config, conn_state);
|
drm/i915: Trick CL2 into life on CHV when using pipe B with port B
Normmally the common lane in a PHY channel gets powered up when some
of the data lanes get powered up. But when we're driving port B with
pipe B we don't want to enabled any of the data lanes, and just want
the DPLL in the common lane to be active.
To make that happens we have to temporarily enable some data lanes
after which we can access the DPLL registers in the common lane. Once
the pipe is up and running we can drop the power override on the data
lanes allowing them to shut down. From this point forward the common
lane will in fact stay powered on until the data lanes in the other
channel get powered down.
Ville's extended explanation from the review thread:
On Wed, Aug 19, 2015 at 07:47:41AM +0530, Deepak wrote:
> One Q, why only for port B? Port C is also in same common lane right?
Port B is in the first PHY channel which also houses CL1. CL1 always
powers up whenever any lanes in either PHY channel are powered up.
CL2 only powers up if lanes in the second channel (ie. the one with
port C) powers up.
So in this scenario (pipe B->port B) we want the DPLL from CL2, but
ideally we only want to power up the lanes for port B. Powering up
port B lanes will only power up CL1, but as we need CL2 instead we
need to, temporarily, power up some lanes in port C as well.
Crossing the streams the other way (pipe A->port C) is not a problem
since CL1 powers up whenever anything else powers up. So powering up
some port C lanes is enough on its own to make the CL1 DPLL
operational, even though CL1 and the lanes live in separate channels.
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Deepak S <deepak.s@linux.intel.com>
[danvet: Amend commit message with extended explanation.]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-07-09 04:45:55 +08:00
|
|
|
|
|
|
|
/* Second common lane will stay alive on its own now */
|
2016-04-27 20:44:20 +08:00
|
|
|
chv_phy_release_cl2_override(encoder);
|
2014-04-09 18:28:20 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void chv_dp_pre_pll_enable(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config,
|
|
|
|
const struct drm_connector_state *conn_state)
|
2014-04-09 18:29:05 +08:00
|
|
|
{
|
2016-08-09 23:04:13 +08:00
|
|
|
intel_dp_prepare(encoder, pipe_config);
|
2014-06-28 07:04:02 +08:00
|
|
|
|
2016-04-27 20:44:19 +08:00
|
|
|
chv_phy_pre_pll_enable(encoder);
|
2014-04-09 18:29:05 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:04 +08:00
|
|
|
static void chv_dp_post_pll_disable(struct intel_encoder *encoder,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *pipe_config,
|
|
|
|
const struct drm_connector_state *conn_state)
|
2015-07-09 04:45:49 +08:00
|
|
|
{
|
2016-04-27 20:44:21 +08:00
|
|
|
chv_phy_post_pll_disable(encoder);
|
2015-07-09 04:45:49 +08:00
|
|
|
}
|
|
|
|
|
2009-04-08 07:16:42 +08:00
|
|
|
/*
|
|
|
|
* Fetch AUX CH registers 0x202 - 0x207 which contain
|
|
|
|
* link status information
|
|
|
|
*/
|
2015-10-23 18:01:48 +08:00
|
|
|
bool
|
2011-11-02 10:45:03 +08:00
|
|
|
intel_dp_get_link_status(struct intel_dp *intel_dp, uint8_t link_status[DP_LINK_STATUS_SIZE])
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2016-04-13 22:58:33 +08:00
|
|
|
return drm_dp_dpcd_read(&intel_dp->aux, DP_LANE0_1_STATUS, link_status,
|
|
|
|
DP_LINK_STATUS_SIZE) == DP_LINK_STATUS_SIZE;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2017-01-02 19:30:55 +08:00
|
|
|
static bool intel_dp_get_y_cord_status(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
uint8_t psr_caps = 0;
|
|
|
|
|
2017-05-10 17:21:48 +08:00
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux, DP_PSR_CAPS, &psr_caps) != 1)
|
|
|
|
return false;
|
2017-01-02 19:30:55 +08:00
|
|
|
return psr_caps & DP_PSR2_SU_Y_COORDINATE_REQUIRED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool intel_dp_get_colorimetry_status(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
uint8_t dprx = 0;
|
|
|
|
|
2017-05-10 17:21:48 +08:00
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux, DP_DPRX_FEATURE_ENUMERATION_LIST,
|
|
|
|
&dprx) != 1)
|
|
|
|
return false;
|
2017-01-02 19:30:55 +08:00
|
|
|
return dprx & DP_VSC_SDP_EXT_FOR_COLORIMETRY_SUPPORTED;
|
|
|
|
}
|
|
|
|
|
2017-01-14 18:51:13 +08:00
|
|
|
static bool intel_dp_get_alpm_status(struct intel_dp *intel_dp)
|
2017-01-02 19:30:58 +08:00
|
|
|
{
|
|
|
|
uint8_t alpm_caps = 0;
|
|
|
|
|
2017-05-10 17:21:48 +08:00
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux, DP_RECEIVER_ALPM_CAP,
|
|
|
|
&alpm_caps) != 1)
|
|
|
|
return false;
|
2017-01-02 19:30:58 +08:00
|
|
|
return alpm_caps & DP_ALPM_CAP;
|
|
|
|
}
|
|
|
|
|
2014-06-14 05:45:41 +08:00
|
|
|
/* These are source-specific values. */
|
2015-10-23 18:01:48 +08:00
|
|
|
uint8_t
|
2011-11-17 08:26:07 +08:00
|
|
|
intel_dp_voltage_max(struct intel_dp *intel_dp)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2016-11-16 16:55:41 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
|
2013-05-16 19:40:36 +08:00
|
|
|
enum port port = dp_to_dig_port(intel_dp)->port;
|
2011-11-17 08:26:07 +08:00
|
|
|
|
2016-12-02 16:23:49 +08:00
|
|
|
if (IS_GEN9_LP(dev_priv))
|
2014-11-18 18:15:29 +08:00
|
|
|
return DP_TRAIN_VOLTAGE_SWING_LEVEL_3;
|
2016-11-16 16:55:41 +08:00
|
|
|
else if (INTEL_GEN(dev_priv) >= 9) {
|
2017-02-24 01:49:01 +08:00
|
|
|
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
|
|
|
return intel_ddi_dp_voltage_max(encoder);
|
2016-10-14 17:13:44 +08:00
|
|
|
} else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
|
2014-08-08 18:53:41 +08:00
|
|
|
return DP_TRAIN_VOLTAGE_SWING_LEVEL_3;
|
2016-10-13 18:03:10 +08:00
|
|
|
else if (IS_GEN7(dev_priv) && port == PORT_A)
|
2014-08-08 18:53:41 +08:00
|
|
|
return DP_TRAIN_VOLTAGE_SWING_LEVEL_2;
|
2016-10-13 18:02:53 +08:00
|
|
|
else if (HAS_PCH_CPT(dev_priv) && port != PORT_A)
|
2014-08-08 18:53:41 +08:00
|
|
|
return DP_TRAIN_VOLTAGE_SWING_LEVEL_3;
|
2011-11-17 08:26:07 +08:00
|
|
|
else
|
2014-08-08 18:53:41 +08:00
|
|
|
return DP_TRAIN_VOLTAGE_SWING_LEVEL_2;
|
2011-11-17 08:26:07 +08:00
|
|
|
}
|
|
|
|
|
2015-10-23 18:01:48 +08:00
|
|
|
uint8_t
|
2011-11-17 08:26:07 +08:00
|
|
|
intel_dp_pre_emphasis_max(struct intel_dp *intel_dp, uint8_t voltage_swing)
|
|
|
|
{
|
2016-10-13 18:03:00 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
|
2013-05-16 19:40:36 +08:00
|
|
|
enum port port = dp_to_dig_port(intel_dp)->port;
|
2011-11-17 08:26:07 +08:00
|
|
|
|
2016-10-13 18:03:00 +08:00
|
|
|
if (INTEL_GEN(dev_priv) >= 9) {
|
2013-12-03 21:56:26 +08:00
|
|
|
switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_3;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_2;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_1;
|
2015-02-25 12:59:12 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_3:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_0;
|
2013-12-03 21:56:26 +08:00
|
|
|
default:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_0;
|
|
|
|
}
|
2016-10-13 18:03:00 +08:00
|
|
|
} else if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) {
|
2012-10-16 02:51:34 +08:00
|
|
|
switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_3;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_2;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_1;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_3:
|
2012-10-16 02:51:34 +08:00
|
|
|
default:
|
2014-08-08 18:53:41 +08:00
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_0;
|
2012-10-16 02:51:34 +08:00
|
|
|
}
|
2016-10-13 18:03:00 +08:00
|
|
|
} else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
|
2013-04-19 05:44:28 +08:00
|
|
|
switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_3;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_2;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_1;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_3:
|
2013-04-19 05:44:28 +08:00
|
|
|
default:
|
2014-08-08 18:53:41 +08:00
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_0;
|
2013-04-19 05:44:28 +08:00
|
|
|
}
|
2016-10-13 18:03:00 +08:00
|
|
|
} else if (IS_GEN7(dev_priv) && port == PORT_A) {
|
2011-11-17 08:26:07 +08:00
|
|
|
switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_2;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_1;
|
2011-11-17 08:26:07 +08:00
|
|
|
default:
|
2014-08-08 18:53:41 +08:00
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_0;
|
2011-11-17 08:26:07 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_2;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_2;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2:
|
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_1;
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_3:
|
2011-11-17 08:26:07 +08:00
|
|
|
default:
|
2014-08-08 18:53:41 +08:00
|
|
|
return DP_TRAIN_PRE_EMPH_LEVEL_0;
|
2011-11-17 08:26:07 +08:00
|
|
|
}
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-16 17:36:52 +08:00
|
|
|
static uint32_t vlv_signal_levels(struct intel_dp *intel_dp)
|
2013-04-19 05:44:28 +08:00
|
|
|
{
|
2016-04-27 20:44:22 +08:00
|
|
|
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
2013-04-19 05:44:28 +08:00
|
|
|
unsigned long demph_reg_value, preemph_reg_value,
|
|
|
|
uniqtranscale_reg_value;
|
|
|
|
uint8_t train_set = intel_dp->train_set[0];
|
|
|
|
|
|
|
|
switch (train_set & DP_TRAIN_PRE_EMPHASIS_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_0:
|
2013-04-19 05:44:28 +08:00
|
|
|
preemph_reg_value = 0x0004000;
|
|
|
|
switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
2013-04-19 05:44:28 +08:00
|
|
|
demph_reg_value = 0x2B405555;
|
|
|
|
uniqtranscale_reg_value = 0x552AB83A;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
2013-04-19 05:44:28 +08:00
|
|
|
demph_reg_value = 0x2B404040;
|
|
|
|
uniqtranscale_reg_value = 0x5548B83A;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2:
|
2013-04-19 05:44:28 +08:00
|
|
|
demph_reg_value = 0x2B245555;
|
|
|
|
uniqtranscale_reg_value = 0x5560B83A;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_3:
|
2013-04-19 05:44:28 +08:00
|
|
|
demph_reg_value = 0x2B405555;
|
|
|
|
uniqtranscale_reg_value = 0x5598DA3A;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_1:
|
2013-04-19 05:44:28 +08:00
|
|
|
preemph_reg_value = 0x0002000;
|
|
|
|
switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
2013-04-19 05:44:28 +08:00
|
|
|
demph_reg_value = 0x2B404040;
|
|
|
|
uniqtranscale_reg_value = 0x5552B83A;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
2013-04-19 05:44:28 +08:00
|
|
|
demph_reg_value = 0x2B404848;
|
|
|
|
uniqtranscale_reg_value = 0x5580B83A;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2:
|
2013-04-19 05:44:28 +08:00
|
|
|
demph_reg_value = 0x2B404040;
|
|
|
|
uniqtranscale_reg_value = 0x55ADDA3A;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_2:
|
2013-04-19 05:44:28 +08:00
|
|
|
preemph_reg_value = 0x0000000;
|
|
|
|
switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
2013-04-19 05:44:28 +08:00
|
|
|
demph_reg_value = 0x2B305555;
|
|
|
|
uniqtranscale_reg_value = 0x5570B83A;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
2013-04-19 05:44:28 +08:00
|
|
|
demph_reg_value = 0x2B2B4040;
|
|
|
|
uniqtranscale_reg_value = 0x55ADDA3A;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_3:
|
2013-04-19 05:44:28 +08:00
|
|
|
preemph_reg_value = 0x0006000;
|
|
|
|
switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
2013-04-19 05:44:28 +08:00
|
|
|
demph_reg_value = 0x1B405555;
|
|
|
|
uniqtranscale_reg_value = 0x55ADDA3A;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-27 20:44:22 +08:00
|
|
|
vlv_set_phy_signal_level(encoder, demph_reg_value, preemph_reg_value,
|
|
|
|
uniqtranscale_reg_value, 0);
|
2013-04-19 05:44:28 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-04-16 17:36:52 +08:00
|
|
|
static uint32_t chv_signal_levels(struct intel_dp *intel_dp)
|
2014-04-09 18:28:20 +08:00
|
|
|
{
|
2016-04-27 20:44:17 +08:00
|
|
|
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
|
|
|
u32 deemph_reg_value, margin_reg_value;
|
|
|
|
bool uniq_trans_scale = false;
|
2014-04-09 18:28:20 +08:00
|
|
|
uint8_t train_set = intel_dp->train_set[0];
|
|
|
|
|
|
|
|
switch (train_set & DP_TRAIN_PRE_EMPHASIS_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_0:
|
2014-04-09 18:28:20 +08:00
|
|
|
switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
2014-04-09 18:28:20 +08:00
|
|
|
deemph_reg_value = 128;
|
|
|
|
margin_reg_value = 52;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
2014-04-09 18:28:20 +08:00
|
|
|
deemph_reg_value = 128;
|
|
|
|
margin_reg_value = 77;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2:
|
2014-04-09 18:28:20 +08:00
|
|
|
deemph_reg_value = 128;
|
|
|
|
margin_reg_value = 102;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_3:
|
2014-04-09 18:28:20 +08:00
|
|
|
deemph_reg_value = 128;
|
|
|
|
margin_reg_value = 154;
|
2016-04-27 20:44:17 +08:00
|
|
|
uniq_trans_scale = true;
|
2014-04-09 18:28:20 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_1:
|
2014-04-09 18:28:20 +08:00
|
|
|
switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
2014-04-09 18:28:20 +08:00
|
|
|
deemph_reg_value = 85;
|
|
|
|
margin_reg_value = 78;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
2014-04-09 18:28:20 +08:00
|
|
|
deemph_reg_value = 85;
|
|
|
|
margin_reg_value = 116;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2:
|
2014-04-09 18:28:20 +08:00
|
|
|
deemph_reg_value = 85;
|
|
|
|
margin_reg_value = 154;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_2:
|
2014-04-09 18:28:20 +08:00
|
|
|
switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
2014-04-09 18:28:20 +08:00
|
|
|
deemph_reg_value = 64;
|
|
|
|
margin_reg_value = 104;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
2014-04-09 18:28:20 +08:00
|
|
|
deemph_reg_value = 64;
|
|
|
|
margin_reg_value = 154;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_3:
|
2014-04-09 18:28:20 +08:00
|
|
|
switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
2014-04-09 18:28:20 +08:00
|
|
|
deemph_reg_value = 43;
|
|
|
|
margin_reg_value = 154;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-27 20:44:17 +08:00
|
|
|
chv_set_phy_signal_level(encoder, deemph_reg_value,
|
|
|
|
margin_reg_value, uniq_trans_scale);
|
2014-04-09 18:28:20 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-08 07:16:42 +08:00
|
|
|
static uint32_t
|
2015-04-16 17:36:52 +08:00
|
|
|
gen4_signal_levels(uint8_t train_set)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2010-11-29 18:09:55 +08:00
|
|
|
uint32_t signal_levels = 0;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2010-11-29 18:09:55 +08:00
|
|
|
switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0:
|
2009-04-08 07:16:42 +08:00
|
|
|
default:
|
|
|
|
signal_levels |= DP_VOLTAGE_0_4;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1:
|
2009-04-08 07:16:42 +08:00
|
|
|
signal_levels |= DP_VOLTAGE_0_6;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2:
|
2009-04-08 07:16:42 +08:00
|
|
|
signal_levels |= DP_VOLTAGE_0_8;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_3:
|
2009-04-08 07:16:42 +08:00
|
|
|
signal_levels |= DP_VOLTAGE_1_2;
|
|
|
|
break;
|
|
|
|
}
|
2010-11-29 18:09:55 +08:00
|
|
|
switch (train_set & DP_TRAIN_PRE_EMPHASIS_MASK) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_0:
|
2009-04-08 07:16:42 +08:00
|
|
|
default:
|
|
|
|
signal_levels |= DP_PRE_EMPHASIS_0;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_1:
|
2009-04-08 07:16:42 +08:00
|
|
|
signal_levels |= DP_PRE_EMPHASIS_3_5;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_2:
|
2009-04-08 07:16:42 +08:00
|
|
|
signal_levels |= DP_PRE_EMPHASIS_6;
|
|
|
|
break;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_PRE_EMPH_LEVEL_3:
|
2009-04-08 07:16:42 +08:00
|
|
|
signal_levels |= DP_PRE_EMPHASIS_9_5;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return signal_levels;
|
|
|
|
}
|
|
|
|
|
2010-04-08 09:43:27 +08:00
|
|
|
/* Gen6's DP voltage swing and pre-emphasis control */
|
|
|
|
static uint32_t
|
2015-04-16 17:36:52 +08:00
|
|
|
gen6_edp_signal_levels(uint8_t train_set)
|
2010-04-08 09:43:27 +08:00
|
|
|
{
|
2011-01-06 18:26:08 +08:00
|
|
|
int signal_levels = train_set & (DP_TRAIN_VOLTAGE_SWING_MASK |
|
|
|
|
DP_TRAIN_PRE_EMPHASIS_MASK);
|
|
|
|
switch (signal_levels) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_0:
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_0:
|
2011-01-06 18:26:08 +08:00
|
|
|
return EDP_LINK_TRAIN_400_600MV_0DB_SNB_B;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_1:
|
2011-01-06 18:26:08 +08:00
|
|
|
return EDP_LINK_TRAIN_400MV_3_5DB_SNB_B;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_2:
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_2:
|
2011-01-06 18:26:08 +08:00
|
|
|
return EDP_LINK_TRAIN_400_600MV_6DB_SNB_B;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_1:
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_1:
|
2011-01-06 18:26:08 +08:00
|
|
|
return EDP_LINK_TRAIN_600_800MV_3_5DB_SNB_B;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_0:
|
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_3 | DP_TRAIN_PRE_EMPH_LEVEL_0:
|
2011-01-06 18:26:08 +08:00
|
|
|
return EDP_LINK_TRAIN_800_1200MV_0DB_SNB_B;
|
2010-04-08 09:43:27 +08:00
|
|
|
default:
|
2011-01-06 18:26:08 +08:00
|
|
|
DRM_DEBUG_KMS("Unsupported voltage swing/pre-emphasis level:"
|
|
|
|
"0x%x\n", signal_levels);
|
|
|
|
return EDP_LINK_TRAIN_400_600MV_0DB_SNB_B;
|
2010-04-08 09:43:27 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-17 08:26:07 +08:00
|
|
|
/* Gen7's DP voltage swing and pre-emphasis control */
|
|
|
|
static uint32_t
|
2015-04-16 17:36:52 +08:00
|
|
|
gen7_edp_signal_levels(uint8_t train_set)
|
2011-11-17 08:26:07 +08:00
|
|
|
{
|
|
|
|
int signal_levels = train_set & (DP_TRAIN_VOLTAGE_SWING_MASK |
|
|
|
|
DP_TRAIN_PRE_EMPHASIS_MASK);
|
|
|
|
switch (signal_levels) {
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_0:
|
2011-11-17 08:26:07 +08:00
|
|
|
return EDP_LINK_TRAIN_400MV_0DB_IVB;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_1:
|
2011-11-17 08:26:07 +08:00
|
|
|
return EDP_LINK_TRAIN_400MV_3_5DB_IVB;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_2:
|
2011-11-17 08:26:07 +08:00
|
|
|
return EDP_LINK_TRAIN_400MV_6DB_IVB;
|
|
|
|
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_0:
|
2011-11-17 08:26:07 +08:00
|
|
|
return EDP_LINK_TRAIN_600MV_0DB_IVB;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_1:
|
2011-11-17 08:26:07 +08:00
|
|
|
return EDP_LINK_TRAIN_600MV_3_5DB_IVB;
|
|
|
|
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_0:
|
2011-11-17 08:26:07 +08:00
|
|
|
return EDP_LINK_TRAIN_800MV_0DB_IVB;
|
2014-08-08 18:53:41 +08:00
|
|
|
case DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_1:
|
2011-11-17 08:26:07 +08:00
|
|
|
return EDP_LINK_TRAIN_800MV_3_5DB_IVB;
|
|
|
|
|
|
|
|
default:
|
|
|
|
DRM_DEBUG_KMS("Unsupported voltage swing/pre-emphasis level:"
|
|
|
|
"0x%x\n", signal_levels);
|
|
|
|
return EDP_LINK_TRAIN_500MV_0DB_IVB;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-23 18:01:48 +08:00
|
|
|
void
|
2015-10-23 18:01:44 +08:00
|
|
|
intel_dp_set_signal_levels(struct intel_dp *intel_dp)
|
2012-12-07 02:51:50 +08:00
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2013-05-16 19:40:36 +08:00
|
|
|
enum port port = intel_dig_port->port;
|
2012-12-07 02:51:50 +08:00
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2015-10-23 18:01:47 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2015-06-25 16:11:03 +08:00
|
|
|
uint32_t signal_levels, mask = 0;
|
2012-12-07 02:51:50 +08:00
|
|
|
uint8_t train_set = intel_dp->train_set[0];
|
|
|
|
|
2017-08-30 07:22:24 +08:00
|
|
|
if (IS_GEN9_LP(dev_priv) || IS_CANNONLAKE(dev_priv)) {
|
|
|
|
signal_levels = bxt_signal_levels(intel_dp);
|
|
|
|
} else if (HAS_DDI(dev_priv)) {
|
2015-06-25 16:11:03 +08:00
|
|
|
signal_levels = ddi_signal_levels(intel_dp);
|
2017-08-30 07:22:24 +08:00
|
|
|
mask = DDI_BUF_EMP_MASK;
|
2016-10-14 17:13:44 +08:00
|
|
|
} else if (IS_CHERRYVIEW(dev_priv)) {
|
2015-04-16 17:36:52 +08:00
|
|
|
signal_levels = chv_signal_levels(intel_dp);
|
2016-10-13 18:03:08 +08:00
|
|
|
} else if (IS_VALLEYVIEW(dev_priv)) {
|
2015-04-16 17:36:52 +08:00
|
|
|
signal_levels = vlv_signal_levels(intel_dp);
|
2016-10-13 18:03:10 +08:00
|
|
|
} else if (IS_GEN7(dev_priv) && port == PORT_A) {
|
2015-04-16 17:36:52 +08:00
|
|
|
signal_levels = gen7_edp_signal_levels(train_set);
|
2012-12-07 02:51:50 +08:00
|
|
|
mask = EDP_LINK_TRAIN_VOL_EMP_MASK_IVB;
|
2016-10-13 18:03:10 +08:00
|
|
|
} else if (IS_GEN6(dev_priv) && port == PORT_A) {
|
2015-04-16 17:36:52 +08:00
|
|
|
signal_levels = gen6_edp_signal_levels(train_set);
|
2012-12-07 02:51:50 +08:00
|
|
|
mask = EDP_LINK_TRAIN_VOL_EMP_MASK_SNB;
|
|
|
|
} else {
|
2015-04-16 17:36:52 +08:00
|
|
|
signal_levels = gen4_signal_levels(train_set);
|
2012-12-07 02:51:50 +08:00
|
|
|
mask = DP_VOLTAGE_MASK | DP_PRE_EMPHASIS_MASK;
|
|
|
|
}
|
|
|
|
|
2014-11-18 18:15:27 +08:00
|
|
|
if (mask)
|
|
|
|
DRM_DEBUG_KMS("Using signal levels %08x\n", signal_levels);
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("Using vswing level %d\n",
|
|
|
|
train_set & DP_TRAIN_VOLTAGE_SWING_MASK);
|
|
|
|
DRM_DEBUG_KMS("Using pre-emphasis level %d\n",
|
|
|
|
(train_set & DP_TRAIN_PRE_EMPHASIS_MASK) >>
|
|
|
|
DP_TRAIN_PRE_EMPHASIS_SHIFT);
|
2012-12-07 02:51:50 +08:00
|
|
|
|
2015-10-23 18:01:44 +08:00
|
|
|
intel_dp->DP = (intel_dp->DP & ~mask) | signal_levels;
|
2015-10-23 18:01:47 +08:00
|
|
|
|
|
|
|
I915_WRITE(intel_dp->output_reg, intel_dp->DP);
|
|
|
|
POSTING_READ(intel_dp->output_reg);
|
2012-12-07 02:51:50 +08:00
|
|
|
}
|
|
|
|
|
2015-10-23 18:01:48 +08:00
|
|
|
void
|
2015-10-23 18:01:45 +08:00
|
|
|
intel_dp_program_link_training_pattern(struct intel_dp *intel_dp,
|
|
|
|
uint8_t dp_train_pat)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2012-10-27 05:05:50 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2015-07-06 21:39:15 +08:00
|
|
|
struct drm_i915_private *dev_priv =
|
|
|
|
to_i915(intel_dig_port->base.base.dev);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2015-10-23 18:01:44 +08:00
|
|
|
_intel_dp_set_link_train(intel_dp, &intel_dp->DP, dp_train_pat);
|
2012-07-18 03:55:16 +08:00
|
|
|
|
2015-10-23 18:01:44 +08:00
|
|
|
I915_WRITE(intel_dp->output_reg, intel_dp->DP);
|
2010-08-04 20:50:23 +08:00
|
|
|
POSTING_READ(intel_dp->output_reg);
|
2015-10-23 18:01:45 +08:00
|
|
|
}
|
|
|
|
|
2015-10-23 18:01:48 +08:00
|
|
|
void intel_dp_set_idle_link_train(struct intel_dp *intel_dp)
|
2013-05-03 17:57:41 +08:00
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2013-05-03 17:57:41 +08:00
|
|
|
enum port port = intel_dig_port->port;
|
|
|
|
uint32_t val;
|
|
|
|
|
2016-10-13 18:02:52 +08:00
|
|
|
if (!HAS_DDI(dev_priv))
|
2013-05-03 17:57:41 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
val = I915_READ(DP_TP_CTL(port));
|
|
|
|
val &= ~DP_TP_CTL_LINK_TRAIN_MASK;
|
|
|
|
val |= DP_TP_CTL_LINK_TRAIN_IDLE;
|
|
|
|
I915_WRITE(DP_TP_CTL(port), val);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On PORT_A we can have only eDP in SST mode. There the only reason
|
|
|
|
* we need to set idle transmission mode is to work around a HW issue
|
|
|
|
* where we enable the pipe while not in idle link-training mode.
|
|
|
|
* In this case there is requirement to wait for a minimum number of
|
|
|
|
* idle patterns to be sent.
|
|
|
|
*/
|
|
|
|
if (port == PORT_A)
|
|
|
|
return;
|
|
|
|
|
2016-06-30 22:33:10 +08:00
|
|
|
if (intel_wait_for_register(dev_priv,DP_TP_STATUS(port),
|
|
|
|
DP_TP_STATUS_IDLE_DONE,
|
|
|
|
DP_TP_STATUS_IDLE_DONE,
|
|
|
|
1))
|
2013-05-03 17:57:41 +08:00
|
|
|
DRM_ERROR("Timed out waiting for DP idle patterns\n");
|
|
|
|
}
|
|
|
|
|
2009-04-08 07:16:42 +08:00
|
|
|
static void
|
2010-08-04 20:50:23 +08:00
|
|
|
intel_dp_link_down(struct intel_dp *intel_dp)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2012-10-27 05:05:46 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2015-05-05 22:17:34 +08:00
|
|
|
struct intel_crtc *crtc = to_intel_crtc(intel_dig_port->base.base.crtc);
|
2013-05-16 19:40:36 +08:00
|
|
|
enum port port = intel_dig_port->port;
|
2012-10-27 05:05:46 +08:00
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2010-08-04 20:50:23 +08:00
|
|
|
uint32_t DP = intel_dp->DP;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2016-10-13 18:02:52 +08:00
|
|
|
if (WARN_ON(HAS_DDI(dev_priv)))
|
2012-10-16 02:51:41 +08:00
|
|
|
return;
|
|
|
|
|
2012-09-07 04:15:43 +08:00
|
|
|
if (WARN_ON((I915_READ(intel_dp->output_reg) & DP_PORT_EN) == 0))
|
2010-12-06 19:20:45 +08:00
|
|
|
return;
|
|
|
|
|
2009-10-09 11:39:41 +08:00
|
|
|
DRM_DEBUG_KMS("\n");
|
2009-07-24 01:00:32 +08:00
|
|
|
|
2016-10-13 18:03:10 +08:00
|
|
|
if ((IS_GEN7(dev_priv) && port == PORT_A) ||
|
2016-10-13 18:02:53 +08:00
|
|
|
(HAS_PCH_CPT(dev_priv) && port != PORT_A)) {
|
2010-04-08 09:43:27 +08:00
|
|
|
DP &= ~DP_LINK_TRAIN_MASK_CPT;
|
2015-05-05 22:17:34 +08:00
|
|
|
DP |= DP_LINK_TRAIN_PAT_IDLE_CPT;
|
2010-04-08 09:43:27 +08:00
|
|
|
} else {
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_CHERRYVIEW(dev_priv))
|
2014-06-28 07:04:25 +08:00
|
|
|
DP &= ~DP_LINK_TRAIN_MASK_CHV;
|
|
|
|
else
|
|
|
|
DP &= ~DP_LINK_TRAIN_MASK;
|
2015-05-05 22:17:34 +08:00
|
|
|
DP |= DP_LINK_TRAIN_PAT_IDLE;
|
2010-04-08 09:43:27 +08:00
|
|
|
}
|
2015-05-05 22:17:34 +08:00
|
|
|
I915_WRITE(intel_dp->output_reg, DP);
|
2010-09-12 04:37:48 +08:00
|
|
|
POSTING_READ(intel_dp->output_reg);
|
2009-07-24 01:00:31 +08:00
|
|
|
|
2015-05-05 22:17:34 +08:00
|
|
|
DP &= ~(DP_PORT_EN | DP_AUDIO_OUTPUT_ENABLE);
|
|
|
|
I915_WRITE(intel_dp->output_reg, DP);
|
|
|
|
POSTING_READ(intel_dp->output_reg);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HW workaround for IBX, we need to move the port
|
|
|
|
* to transcoder A after disabling it to allow the
|
|
|
|
* matching HDMI port to be enabled on transcoder A.
|
|
|
|
*/
|
2016-10-13 18:02:53 +08:00
|
|
|
if (HAS_PCH_IBX(dev_priv) && crtc->pipe == PIPE_B && port != PORT_A) {
|
2015-10-31 01:23:22 +08:00
|
|
|
/*
|
|
|
|
* We get CPU/PCH FIFO underruns on the other pipe when
|
|
|
|
* doing the workaround. Sweep them under the rug.
|
|
|
|
*/
|
|
|
|
intel_set_cpu_fifo_underrun_reporting(dev_priv, PIPE_A, false);
|
|
|
|
intel_set_pch_fifo_underrun_reporting(dev_priv, PIPE_A, false);
|
|
|
|
|
2015-05-05 22:17:34 +08:00
|
|
|
/* always enable with pattern 1 (as per spec) */
|
|
|
|
DP &= ~(DP_PIPEB_SELECT | DP_LINK_TRAIN_MASK);
|
|
|
|
DP |= DP_PORT_EN | DP_LINK_TRAIN_PAT_1;
|
|
|
|
I915_WRITE(intel_dp->output_reg, DP);
|
|
|
|
POSTING_READ(intel_dp->output_reg);
|
|
|
|
|
|
|
|
DP &= ~DP_PORT_EN;
|
2010-11-18 09:32:59 +08:00
|
|
|
I915_WRITE(intel_dp->output_reg, DP);
|
2014-11-24 23:54:11 +08:00
|
|
|
POSTING_READ(intel_dp->output_reg);
|
2015-10-31 01:23:22 +08:00
|
|
|
|
2016-11-01 04:37:06 +08:00
|
|
|
intel_wait_for_vblank_if_active(dev_priv, PIPE_A);
|
2015-10-31 01:23:22 +08:00
|
|
|
intel_set_cpu_fifo_underrun_reporting(dev_priv, PIPE_A, true);
|
|
|
|
intel_set_pch_fifo_underrun_reporting(dev_priv, PIPE_A, true);
|
2010-11-18 09:32:59 +08:00
|
|
|
}
|
|
|
|
|
drm/i915: Correct eDP panel power sequencing delay computations
Store the panel power sequencing delays in the dp private structure,
rather than the global device structure. Who knows, maybe we'll get
more than one eDP device in the future.
From the eDP spec, we need the following numbers:
T1 + T3 Power on to Aux Channel operation (panel_power_up_delay)
This marks how long it takes the panel to boot up and
get ready to receive aux channel communications.
T8 Video signal to backlight on (backlight_on_delay)
Once a valid video signal is being sent to the device,
it can take a while before the panel is actuall
showing useful data. This delay allows the panel
to get something reasonable up before the backlight
is turned on.
T9 Backlight off to video off (backlight_off_delay)
Turning the backlight off can take a moment, so
this delay makes sure there is still valid video
data on the screen.
T10 Video off to power off (panel_power_down_delay)
Presumably this delay allows the panel to perform
an orderly shutdown of the display.
T11 + T12 Power off to power on (panel_power_cycle_delay)
So, once you turn the panel off, you have to wait a
while before you can turn it back on. This delay is
usually the longest in the entire sequence.
Neither the VBIOS source code nor the hardware documentation has a
clear mapping between the delay values they provide and those required
by the eDP spec. The VBIOS code actually uses two different labels for
the delay values in the five words of the relevant VBT table.
**** MORE LATER ***
Look at both the current hardware register settings and the VBT
specified panel power sequencing timings. Use the maximum of the two
delays, to make sure things work reliably. If there is no VBT data,
then those values will be initialized to zero, so we'll just use the
values as programmed in the hardware. Note that the BIOS just fetches
delays from the VBT table to place in the hardware registers, so we
should get the same values from both places, except for rounding.
VBT doesn't provide any values for T1 or T2, so we'll always just use
the hardware value for that.
The panel power up delay is thus T1 + T2 + T3, which should be
sufficient in all cases.
The panel power down delay is T1 + T2 + T12, using T1+T2 as a proxy
for T11, which isn't available anywhere.
For the backlight delays, the eDP spec says T6 + T8 is the delay from the
end of link training to backlight on and T9 is the delay from
backlight off until video off. The hardware provides a 'backlight on'
delay, which I'm taking to be T6 + T8 while the VBT provides something
called 'T7', which I'm assuming is s
On the macbook air I'm testing with, this yields a power-up delay of
over 200ms and a power-down delay of over 600ms. It all works now, but
we're frobbing these power controls several times during mode setting,
making the whole process take an awfully long time.
Signed-off-by: Keith Packard <keithp@keithp.com>
2011-09-29 07:48:10 +08:00
|
|
|
msleep(intel_dp->panel_power_down_delay);
|
2015-11-10 22:16:17 +08:00
|
|
|
|
|
|
|
intel_dp->DP = DP;
|
2016-12-15 02:00:23 +08:00
|
|
|
|
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
|
|
|
|
pps_lock(intel_dp);
|
|
|
|
intel_dp->active_pipe = INVALID_PIPE;
|
|
|
|
pps_unlock(intel_dp);
|
|
|
|
}
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2016-10-25 00:33:28 +08:00
|
|
|
bool
|
2016-07-29 21:52:39 +08:00
|
|
|
intel_dp_read_dpcd(struct intel_dp *intel_dp)
|
2011-07-26 10:50:10 +08:00
|
|
|
{
|
2016-04-13 22:58:33 +08:00
|
|
|
if (drm_dp_dpcd_read(&intel_dp->aux, 0x000, intel_dp->dpcd,
|
|
|
|
sizeof(intel_dp->dpcd)) < 0)
|
2012-09-18 22:58:49 +08:00
|
|
|
return false; /* aux transfer failed */
|
2011-07-26 10:50:10 +08:00
|
|
|
|
2014-09-01 19:12:01 +08:00
|
|
|
DRM_DEBUG_KMS("DPCD: %*ph\n", (int) sizeof(intel_dp->dpcd), intel_dp->dpcd);
|
2012-12-14 00:09:02 +08:00
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
return intel_dp->dpcd[DP_DPCD_REV] != 0;
|
|
|
|
}
|
2012-09-18 22:58:49 +08:00
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
static bool
|
|
|
|
intel_edp_init_dpcd(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv =
|
|
|
|
to_i915(dp_to_dig_port(intel_dp)->base.base.dev);
|
2016-03-30 20:35:25 +08:00
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
/* this function is meant to be called only once */
|
|
|
|
WARN_ON(intel_dp->dpcd[DP_DPCD_REV] != 0);
|
2016-03-30 20:35:25 +08:00
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
if (!intel_dp_read_dpcd(intel_dp))
|
2016-03-30 20:35:25 +08:00
|
|
|
return false;
|
|
|
|
|
2017-05-18 19:10:23 +08:00
|
|
|
drm_dp_read_desc(&intel_dp->aux, &intel_dp->desc,
|
|
|
|
drm_dp_is_branch(intel_dp->dpcd));
|
2016-10-25 00:33:29 +08:00
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11)
|
|
|
|
dev_priv->no_aux_handshake = intel_dp->dpcd[DP_MAX_DOWNSPREAD] &
|
|
|
|
DP_NO_AUX_HANDSHAKE_LINK_TRAINING;
|
2015-04-02 13:32:44 +08:00
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
/* Check if the panel supports PSR */
|
|
|
|
drm_dp_dpcd_read(&intel_dp->aux, DP_PSR_SUPPORT,
|
|
|
|
intel_dp->psr_dpcd,
|
|
|
|
sizeof(intel_dp->psr_dpcd));
|
|
|
|
if (intel_dp->psr_dpcd[0] & DP_PSR_IS_SUPPORTED) {
|
|
|
|
dev_priv->psr.sink_support = true;
|
|
|
|
DRM_DEBUG_KMS("Detected EDP PSR Panel.\n");
|
|
|
|
}
|
2016-04-05 22:10:51 +08:00
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
if (INTEL_GEN(dev_priv) >= 9 &&
|
|
|
|
(intel_dp->psr_dpcd[0] & DP_PSR2_IS_SUPPORTED)) {
|
|
|
|
uint8_t frame_sync_cap;
|
|
|
|
|
|
|
|
dev_priv->psr.sink_support = true;
|
2017-05-10 17:21:48 +08:00
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux,
|
|
|
|
DP_SINK_DEVICE_AUX_FRAME_SYNC_CAP,
|
|
|
|
&frame_sync_cap) != 1)
|
|
|
|
frame_sync_cap = 0;
|
2016-07-29 21:52:39 +08:00
|
|
|
dev_priv->psr.aux_frame_sync = frame_sync_cap ? true : false;
|
|
|
|
/* PSR2 needs frame sync as well */
|
|
|
|
dev_priv->psr.psr2_support = dev_priv->psr.aux_frame_sync;
|
|
|
|
DRM_DEBUG_KMS("PSR2 %s on sink",
|
|
|
|
dev_priv->psr.psr2_support ? "supported" : "not supported");
|
2017-01-02 19:30:55 +08:00
|
|
|
|
|
|
|
if (dev_priv->psr.psr2_support) {
|
|
|
|
dev_priv->psr.y_cord_support =
|
|
|
|
intel_dp_get_y_cord_status(intel_dp);
|
|
|
|
dev_priv->psr.colorimetry_support =
|
|
|
|
intel_dp_get_colorimetry_status(intel_dp);
|
2017-01-02 19:30:58 +08:00
|
|
|
dev_priv->psr.alpm =
|
|
|
|
intel_dp_get_alpm_status(intel_dp);
|
2017-01-02 19:30:55 +08:00
|
|
|
}
|
|
|
|
|
2013-09-20 21:42:17 +08:00
|
|
|
}
|
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
/* Read the eDP Display control capabilities registers */
|
|
|
|
if ((intel_dp->dpcd[DP_EDP_CONFIGURATION_CAP] & DP_DPCD_DISPLAY_CONTROL_CAPABLE) &&
|
|
|
|
drm_dp_dpcd_read(&intel_dp->aux, DP_EDP_DPCD_REV,
|
2016-10-13 16:55:08 +08:00
|
|
|
intel_dp->edp_dpcd, sizeof(intel_dp->edp_dpcd)) ==
|
|
|
|
sizeof(intel_dp->edp_dpcd))
|
2016-07-29 21:52:39 +08:00
|
|
|
DRM_DEBUG_KMS("EDP DPCD : %*ph\n", (int) sizeof(intel_dp->edp_dpcd),
|
|
|
|
intel_dp->edp_dpcd);
|
2014-01-21 01:19:39 +08:00
|
|
|
|
2015-03-05 12:33:58 +08:00
|
|
|
/* Intermediate frequency support */
|
2016-07-29 21:52:39 +08:00
|
|
|
if (intel_dp->edp_dpcd[0] >= 0x03) { /* eDp v1.4 or higher */
|
2015-03-14 01:40:31 +08:00
|
|
|
__le16 sink_rates[DP_MAX_SUPPORTED_RATES];
|
2015-03-12 23:10:28 +08:00
|
|
|
int i;
|
|
|
|
|
2016-04-13 22:58:33 +08:00
|
|
|
drm_dp_dpcd_read(&intel_dp->aux, DP_SUPPORTED_LINK_RATES,
|
|
|
|
sink_rates, sizeof(sink_rates));
|
2015-03-12 23:10:28 +08:00
|
|
|
|
2015-03-14 01:40:31 +08:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sink_rates); i++) {
|
|
|
|
int val = le16_to_cpu(sink_rates[i]);
|
2015-03-12 23:10:28 +08:00
|
|
|
|
|
|
|
if (val == 0)
|
|
|
|
break;
|
|
|
|
|
drm/i915: Fix DP link rate math
We store DP link rates as link clock frequencies in kHz, just like all
other clock values. But, DP link rates in the DP Spec. are expressed in
Gbps/lane, which seems to have led to some confusion.
E.g., for HBR2
Max. data rate = 5.4 Gbps/lane x 4 lane x 8/10 x 1/8 = 2160000 kBps
where, 8/10 is for channel encoding and 1/8 is for bit to Byte conversion
Using link clock frequency, like we do
Max. data rate = 540000 kHz * 4 lanes = 2160000 kSymbols/s
Because, each symbol has 8 bit of data, this is 2160000 kBps
and there is no need to account for channel encoding here.
But, currently we do 540000 kHz * 4 lanes * (8/10) = 1728000 kBps
Similarly, while computing the required link bandwidth for a mode,
there is a mysterious 1/10 term.
This should simply be pixel_clock kHz * (bpp/8) to give the final result in
kBps
v2: Changed to DIV_ROUND_UP() and comment changes (Ville)
Signed-off-by: Dhinakaran Pandiyan <dhinakaran.pandiyan@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/1479160220-17794-1-git-send-email-dhinakaran.pandiyan@intel.com
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
2016-11-15 05:50:20 +08:00
|
|
|
/* Value read multiplied by 200kHz gives the per-lane
|
|
|
|
* link rate in kHz. The source rates are, however,
|
|
|
|
* stored in terms of LS_Clk kHz. The full conversion
|
|
|
|
* back to symbols is
|
|
|
|
* (val * 200kHz)*(8/10 ch. encoding)*(1/8 bit to Byte)
|
|
|
|
*/
|
2015-05-07 16:29:28 +08:00
|
|
|
intel_dp->sink_rates[i] = (val * 200) / 10;
|
2015-03-12 23:10:28 +08:00
|
|
|
}
|
2015-03-14 01:40:31 +08:00
|
|
|
intel_dp->num_sink_rates = i;
|
2015-03-05 12:33:58 +08:00
|
|
|
}
|
2015-03-12 23:10:39 +08:00
|
|
|
|
2017-03-28 22:59:05 +08:00
|
|
|
if (intel_dp->num_sink_rates)
|
|
|
|
intel_dp->use_rate_select = true;
|
|
|
|
else
|
|
|
|
intel_dp_set_sink_rates(intel_dp);
|
|
|
|
|
2017-04-06 21:44:10 +08:00
|
|
|
intel_dp_set_common_rates(intel_dp);
|
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool
|
|
|
|
intel_dp_get_dpcd(struct intel_dp *intel_dp)
|
|
|
|
{
|
2017-04-06 21:44:17 +08:00
|
|
|
u8 sink_count;
|
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
if (!intel_dp_read_dpcd(intel_dp))
|
|
|
|
return false;
|
|
|
|
|
2017-03-28 22:59:05 +08:00
|
|
|
/* Don't clobber cached eDP rates. */
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp)) {
|
2017-03-28 22:59:05 +08:00
|
|
|
intel_dp_set_sink_rates(intel_dp);
|
2017-04-06 21:44:10 +08:00
|
|
|
intel_dp_set_common_rates(intel_dp);
|
|
|
|
}
|
2017-03-28 22:59:05 +08:00
|
|
|
|
2017-04-06 21:44:17 +08:00
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux, DP_SINK_COUNT, &sink_count) <= 0)
|
2016-07-29 21:52:39 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sink count can change between short pulse hpd hence
|
|
|
|
* a member variable in intel_dp will track any changes
|
|
|
|
* between short pulse interrupts.
|
|
|
|
*/
|
2017-04-06 21:44:17 +08:00
|
|
|
intel_dp->sink_count = DP_GET_SINK_COUNT(sink_count);
|
2016-07-29 21:52:39 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* SINK_COUNT == 0 and DOWNSTREAM_PORT_PRESENT == 1 implies that
|
|
|
|
* a dongle is present but no display. Unless we require to know
|
|
|
|
* if a dongle is present or not, we don't need to update
|
|
|
|
* downstream port information. So, an early return here saves
|
|
|
|
* time from performing other operations which are not required.
|
|
|
|
*/
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp) && !intel_dp->sink_count)
|
2016-07-29 21:52:39 +08:00
|
|
|
return false;
|
2015-03-12 23:10:39 +08:00
|
|
|
|
2016-10-25 00:33:24 +08:00
|
|
|
if (!drm_dp_is_branch(intel_dp->dpcd))
|
2012-09-18 22:58:49 +08:00
|
|
|
return true; /* native DP sink */
|
|
|
|
|
|
|
|
if (intel_dp->dpcd[DP_DPCD_REV] == 0x10)
|
|
|
|
return true; /* no per-port downstream info */
|
|
|
|
|
2016-04-13 22:58:33 +08:00
|
|
|
if (drm_dp_dpcd_read(&intel_dp->aux, DP_DOWNSTREAM_PORT_0,
|
|
|
|
intel_dp->downstream_ports,
|
|
|
|
DP_MAX_DOWNSTREAM_PORTS) < 0)
|
2012-09-18 22:58:49 +08:00
|
|
|
return false; /* downstream port status fetch failed */
|
|
|
|
|
|
|
|
return true;
|
2011-07-26 10:50:10 +08:00
|
|
|
}
|
|
|
|
|
2014-05-02 12:02:48 +08:00
|
|
|
static bool
|
2016-07-29 21:51:16 +08:00
|
|
|
intel_dp_can_mst(struct intel_dp *intel_dp)
|
2014-05-02 12:02:48 +08:00
|
|
|
{
|
2017-04-06 21:44:16 +08:00
|
|
|
u8 mstm_cap;
|
2014-05-02 12:02:48 +08:00
|
|
|
|
2017-09-20 03:38:44 +08:00
|
|
|
if (!i915_modparams.enable_dp_mst)
|
2016-03-15 23:14:05 +08:00
|
|
|
return false;
|
|
|
|
|
2014-05-02 12:02:48 +08:00
|
|
|
if (!intel_dp->can_mst)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (intel_dp->dpcd[DP_DPCD_REV] < 0x12)
|
|
|
|
return false;
|
|
|
|
|
2017-04-06 21:44:16 +08:00
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux, DP_MSTM_CAP, &mstm_cap) != 1)
|
2016-07-29 21:51:16 +08:00
|
|
|
return false;
|
2014-05-02 12:02:48 +08:00
|
|
|
|
2017-04-06 21:44:16 +08:00
|
|
|
return mstm_cap & DP_MST_CAP;
|
2016-07-29 21:51:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
intel_dp_configure_mst(struct intel_dp *intel_dp)
|
|
|
|
{
|
2017-09-20 03:38:44 +08:00
|
|
|
if (!i915_modparams.enable_dp_mst)
|
2016-07-29 21:51:16 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (!intel_dp->can_mst)
|
|
|
|
return;
|
|
|
|
|
|
|
|
intel_dp->is_mst = intel_dp_can_mst(intel_dp);
|
|
|
|
|
|
|
|
if (intel_dp->is_mst)
|
|
|
|
DRM_DEBUG_KMS("Sink is MST capable\n");
|
|
|
|
else
|
|
|
|
DRM_DEBUG_KMS("Sink is not MST capable\n");
|
|
|
|
|
|
|
|
drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr,
|
|
|
|
intel_dp->is_mst);
|
2014-05-02 12:02:48 +08:00
|
|
|
}
|
|
|
|
|
2015-07-24 07:35:48 +08:00
|
|
|
static int intel_dp_sink_crc_stop(struct intel_dp *intel_dp)
|
2014-01-24 23:36:17 +08:00
|
|
|
{
|
2015-07-31 07:26:39 +08:00
|
|
|
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
2016-11-01 04:37:06 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
|
2015-07-31 07:26:39 +08:00
|
|
|
struct intel_crtc *intel_crtc = to_intel_crtc(dig_port->base.base.crtc);
|
2014-09-17 07:18:12 +08:00
|
|
|
u8 buf;
|
2015-07-24 07:35:48 +08:00
|
|
|
int ret = 0;
|
2015-11-06 02:50:20 +08:00
|
|
|
int count = 0;
|
|
|
|
int attempts = 10;
|
2014-01-24 23:36:17 +08:00
|
|
|
|
2015-07-31 07:26:39 +08:00
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_SINK, &buf) < 0) {
|
|
|
|
DRM_DEBUG_KMS("Sink CRC couldn't be stopped properly\n");
|
2015-07-24 07:35:48 +08:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
2015-05-26 05:52:29 +08:00
|
|
|
}
|
|
|
|
|
2015-07-31 07:26:39 +08:00
|
|
|
if (drm_dp_dpcd_writeb(&intel_dp->aux, DP_TEST_SINK,
|
2015-07-24 07:35:48 +08:00
|
|
|
buf & ~DP_TEST_SINK_START) < 0) {
|
2015-07-31 07:26:39 +08:00
|
|
|
DRM_DEBUG_KMS("Sink CRC couldn't be stopped properly\n");
|
2015-07-24 07:35:48 +08:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-01-24 23:36:17 +08:00
|
|
|
|
2015-11-06 02:50:20 +08:00
|
|
|
do {
|
2016-11-01 04:37:06 +08:00
|
|
|
intel_wait_for_vblank(dev_priv, intel_crtc->pipe);
|
2015-11-06 02:50:20 +08:00
|
|
|
|
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux,
|
|
|
|
DP_TEST_SINK_MISC, &buf) < 0) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
count = buf & DP_TEST_COUNT_MASK;
|
|
|
|
} while (--attempts && count);
|
|
|
|
|
|
|
|
if (attempts == 0) {
|
2016-01-30 06:44:59 +08:00
|
|
|
DRM_DEBUG_KMS("TIMEOUT: Sink CRC counter is not zeroed after calculation is stopped\n");
|
2015-11-06 02:50:20 +08:00
|
|
|
ret = -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
2015-07-24 07:35:48 +08:00
|
|
|
out:
|
2015-07-31 07:26:39 +08:00
|
|
|
hsw_enable_ips(intel_crtc);
|
2015-07-24 07:35:48 +08:00
|
|
|
return ret;
|
2015-07-31 07:26:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_dp_sink_crc_start(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
2016-11-01 04:37:06 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
|
2015-07-31 07:26:39 +08:00
|
|
|
struct intel_crtc *intel_crtc = to_intel_crtc(dig_port->base.base.crtc);
|
|
|
|
u8 buf;
|
2015-07-24 07:35:48 +08:00
|
|
|
int ret;
|
|
|
|
|
2015-07-31 07:26:39 +08:00
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_SINK_MISC, &buf) < 0)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
if (!(buf & DP_TEST_CRC_SUPPORTED))
|
|
|
|
return -ENOTTY;
|
|
|
|
|
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_SINK, &buf) < 0)
|
|
|
|
return -EIO;
|
|
|
|
|
2015-11-06 02:50:22 +08:00
|
|
|
if (buf & DP_TEST_SINK_START) {
|
|
|
|
ret = intel_dp_sink_crc_stop(intel_dp);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-07-31 07:26:39 +08:00
|
|
|
hsw_disable_ips(intel_crtc);
|
2014-10-01 22:32:37 +08:00
|
|
|
|
2014-03-14 22:51:15 +08:00
|
|
|
if (drm_dp_dpcd_writeb(&intel_dp->aux, DP_TEST_SINK,
|
2015-07-31 07:26:39 +08:00
|
|
|
buf | DP_TEST_SINK_START) < 0) {
|
|
|
|
hsw_enable_ips(intel_crtc);
|
|
|
|
return -EIO;
|
2015-05-26 05:52:29 +08:00
|
|
|
}
|
|
|
|
|
2016-11-01 04:37:06 +08:00
|
|
|
intel_wait_for_vblank(dev_priv, intel_crtc->pipe);
|
2015-07-31 07:26:39 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int intel_dp_sink_crc(struct intel_dp *intel_dp, u8 *crc)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
2016-11-01 04:37:06 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
|
2015-07-31 07:26:39 +08:00
|
|
|
struct intel_crtc *intel_crtc = to_intel_crtc(dig_port->base.base.crtc);
|
|
|
|
u8 buf;
|
2015-07-24 07:35:49 +08:00
|
|
|
int count, ret;
|
2015-07-31 07:26:39 +08:00
|
|
|
int attempts = 6;
|
|
|
|
|
|
|
|
ret = intel_dp_sink_crc_start(intel_dp);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2014-09-17 07:18:12 +08:00
|
|
|
do {
|
2016-11-01 04:37:06 +08:00
|
|
|
intel_wait_for_vblank(dev_priv, intel_crtc->pipe);
|
2015-07-24 07:35:49 +08:00
|
|
|
|
2014-10-01 22:32:37 +08:00
|
|
|
if (drm_dp_dpcd_readb(&intel_dp->aux,
|
2015-05-26 05:52:29 +08:00
|
|
|
DP_TEST_SINK_MISC, &buf) < 0) {
|
|
|
|
ret = -EIO;
|
2015-07-24 07:35:45 +08:00
|
|
|
goto stop;
|
2015-05-26 05:52:29 +08:00
|
|
|
}
|
2015-07-24 07:35:49 +08:00
|
|
|
count = buf & DP_TEST_COUNT_MASK;
|
2015-07-24 07:35:50 +08:00
|
|
|
|
2015-11-06 02:50:21 +08:00
|
|
|
} while (--attempts && count == 0);
|
2014-09-17 07:18:12 +08:00
|
|
|
|
|
|
|
if (attempts == 0) {
|
2015-11-06 02:50:21 +08:00
|
|
|
DRM_ERROR("Panel is unable to calculate any CRC after 6 vblanks\n");
|
|
|
|
ret = -ETIMEDOUT;
|
|
|
|
goto stop;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (drm_dp_dpcd_read(&intel_dp->aux, DP_TEST_CRC_R_CR, crc, 6) < 0) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto stop;
|
2014-09-17 07:18:12 +08:00
|
|
|
}
|
2014-01-24 23:36:17 +08:00
|
|
|
|
2015-07-24 07:35:45 +08:00
|
|
|
stop:
|
2015-07-31 07:26:39 +08:00
|
|
|
intel_dp_sink_crc_stop(intel_dp);
|
2015-05-26 05:52:29 +08:00
|
|
|
return ret;
|
2014-01-24 23:36:17 +08:00
|
|
|
}
|
|
|
|
|
2011-10-21 06:09:17 +08:00
|
|
|
static bool
|
|
|
|
intel_dp_get_sink_irq(struct intel_dp *intel_dp, u8 *sink_irq_vector)
|
|
|
|
{
|
2017-04-06 21:44:16 +08:00
|
|
|
return drm_dp_dpcd_readb(&intel_dp->aux, DP_DEVICE_SERVICE_IRQ_VECTOR,
|
|
|
|
sink_irq_vector) == 1;
|
2011-10-21 06:09:17 +08:00
|
|
|
}
|
|
|
|
|
2014-05-02 12:02:48 +08:00
|
|
|
static bool
|
|
|
|
intel_dp_get_sink_irq_esi(struct intel_dp *intel_dp, u8 *sink_irq_vector)
|
|
|
|
{
|
2017-09-19 06:21:39 +08:00
|
|
|
return drm_dp_dpcd_read(&intel_dp->aux, DP_SINK_COUNT_ESI,
|
|
|
|
sink_irq_vector, DP_DPRX_ESI_LEN) ==
|
|
|
|
DP_DPRX_ESI_LEN;
|
2014-05-02 12:02:48 +08:00
|
|
|
}
|
|
|
|
|
2015-04-15 23:38:38 +08:00
|
|
|
static uint8_t intel_dp_autotest_link_training(struct intel_dp *intel_dp)
|
|
|
|
{
|
2017-01-25 00:16:34 +08:00
|
|
|
int status = 0;
|
2017-06-09 04:41:03 +08:00
|
|
|
int test_link_rate;
|
2017-01-25 00:16:34 +08:00
|
|
|
uint8_t test_lane_count, test_link_bw;
|
|
|
|
/* (DP CTS 1.2)
|
|
|
|
* 4.3.1.11
|
|
|
|
*/
|
|
|
|
/* Read the TEST_LANE_COUNT and TEST_LINK_RTAE fields (DP CTS 3.1.4) */
|
|
|
|
status = drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_LANE_COUNT,
|
|
|
|
&test_lane_count);
|
|
|
|
|
|
|
|
if (status <= 0) {
|
|
|
|
DRM_DEBUG_KMS("Lane count read failed\n");
|
|
|
|
return DP_TEST_NAK;
|
|
|
|
}
|
|
|
|
test_lane_count &= DP_MAX_LANE_COUNT_MASK;
|
|
|
|
|
|
|
|
status = drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_LINK_RATE,
|
|
|
|
&test_link_bw);
|
|
|
|
if (status <= 0) {
|
|
|
|
DRM_DEBUG_KMS("Link Rate read failed\n");
|
|
|
|
return DP_TEST_NAK;
|
|
|
|
}
|
|
|
|
test_link_rate = drm_dp_bw_code_to_link_rate(test_link_bw);
|
2017-06-09 04:41:03 +08:00
|
|
|
|
|
|
|
/* Validate the requested link rate and lane count */
|
|
|
|
if (!intel_dp_link_params_valid(intel_dp, test_link_rate,
|
|
|
|
test_lane_count))
|
2017-01-25 00:16:34 +08:00
|
|
|
return DP_TEST_NAK;
|
|
|
|
|
|
|
|
intel_dp->compliance.test_lane_count = test_lane_count;
|
|
|
|
intel_dp->compliance.test_link_rate = test_link_rate;
|
|
|
|
|
|
|
|
return DP_TEST_ACK;
|
2015-04-15 23:38:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static uint8_t intel_dp_autotest_video_pattern(struct intel_dp *intel_dp)
|
|
|
|
{
|
2017-01-25 00:21:49 +08:00
|
|
|
uint8_t test_pattern;
|
2017-04-06 21:44:16 +08:00
|
|
|
uint8_t test_misc;
|
2017-01-25 00:21:49 +08:00
|
|
|
__be16 h_width, v_height;
|
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
/* Read the TEST_PATTERN (DP CTS 3.1.5) */
|
2017-04-06 21:44:16 +08:00
|
|
|
status = drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_PATTERN,
|
|
|
|
&test_pattern);
|
2017-01-25 00:21:49 +08:00
|
|
|
if (status <= 0) {
|
|
|
|
DRM_DEBUG_KMS("Test pattern read failed\n");
|
|
|
|
return DP_TEST_NAK;
|
|
|
|
}
|
|
|
|
if (test_pattern != DP_COLOR_RAMP)
|
|
|
|
return DP_TEST_NAK;
|
|
|
|
|
|
|
|
status = drm_dp_dpcd_read(&intel_dp->aux, DP_TEST_H_WIDTH_HI,
|
|
|
|
&h_width, 2);
|
|
|
|
if (status <= 0) {
|
|
|
|
DRM_DEBUG_KMS("H Width read failed\n");
|
|
|
|
return DP_TEST_NAK;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = drm_dp_dpcd_read(&intel_dp->aux, DP_TEST_V_HEIGHT_HI,
|
|
|
|
&v_height, 2);
|
|
|
|
if (status <= 0) {
|
|
|
|
DRM_DEBUG_KMS("V Height read failed\n");
|
|
|
|
return DP_TEST_NAK;
|
|
|
|
}
|
|
|
|
|
2017-04-06 21:44:16 +08:00
|
|
|
status = drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_MISC0,
|
|
|
|
&test_misc);
|
2017-01-25 00:21:49 +08:00
|
|
|
if (status <= 0) {
|
|
|
|
DRM_DEBUG_KMS("TEST MISC read failed\n");
|
|
|
|
return DP_TEST_NAK;
|
|
|
|
}
|
|
|
|
if ((test_misc & DP_TEST_COLOR_FORMAT_MASK) != DP_COLOR_FORMAT_RGB)
|
|
|
|
return DP_TEST_NAK;
|
|
|
|
if (test_misc & DP_TEST_DYNAMIC_RANGE_CEA)
|
|
|
|
return DP_TEST_NAK;
|
|
|
|
switch (test_misc & DP_TEST_BIT_DEPTH_MASK) {
|
|
|
|
case DP_TEST_BIT_DEPTH_6:
|
|
|
|
intel_dp->compliance.test_data.bpc = 6;
|
|
|
|
break;
|
|
|
|
case DP_TEST_BIT_DEPTH_8:
|
|
|
|
intel_dp->compliance.test_data.bpc = 8;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return DP_TEST_NAK;
|
|
|
|
}
|
|
|
|
|
|
|
|
intel_dp->compliance.test_data.video_pattern = test_pattern;
|
|
|
|
intel_dp->compliance.test_data.hdisplay = be16_to_cpu(h_width);
|
|
|
|
intel_dp->compliance.test_data.vdisplay = be16_to_cpu(v_height);
|
|
|
|
/* Set test active flag here so userspace doesn't interrupt things */
|
|
|
|
intel_dp->compliance.test_active = 1;
|
|
|
|
|
|
|
|
return DP_TEST_ACK;
|
2015-04-15 23:38:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static uint8_t intel_dp_autotest_edid(struct intel_dp *intel_dp)
|
2011-10-21 06:09:17 +08:00
|
|
|
{
|
2017-01-21 11:09:28 +08:00
|
|
|
uint8_t test_result = DP_TEST_ACK;
|
2015-05-04 22:48:20 +08:00
|
|
|
struct intel_connector *intel_connector = intel_dp->attached_connector;
|
|
|
|
struct drm_connector *connector = &intel_connector->base;
|
|
|
|
|
|
|
|
if (intel_connector->detect_edid == NULL ||
|
2015-05-08 22:15:41 +08:00
|
|
|
connector->edid_corrupt ||
|
2015-05-04 22:48:20 +08:00
|
|
|
intel_dp->aux.i2c_defer_count > 6) {
|
|
|
|
/* Check EDID read for NACKs, DEFERs and corruption
|
|
|
|
* (DP CTS 1.2 Core r1.1)
|
|
|
|
* 4.2.2.4 : Failed EDID read, I2C_NAK
|
|
|
|
* 4.2.2.5 : Failed EDID read, I2C_DEFER
|
|
|
|
* 4.2.2.6 : EDID corruption detected
|
|
|
|
* Use failsafe mode for all cases
|
|
|
|
*/
|
|
|
|
if (intel_dp->aux.i2c_nack_count > 0 ||
|
|
|
|
intel_dp->aux.i2c_defer_count > 0)
|
|
|
|
DRM_DEBUG_KMS("EDID read had %d NACKs, %d DEFERs\n",
|
|
|
|
intel_dp->aux.i2c_nack_count,
|
|
|
|
intel_dp->aux.i2c_defer_count);
|
2016-12-10 08:22:50 +08:00
|
|
|
intel_dp->compliance.test_data.edid = INTEL_DP_RESOLUTION_FAILSAFE;
|
2015-05-04 22:48:20 +08:00
|
|
|
} else {
|
2015-08-07 17:44:30 +08:00
|
|
|
struct edid *block = intel_connector->detect_edid;
|
|
|
|
|
|
|
|
/* We have to write the checksum
|
|
|
|
* of the last block read
|
|
|
|
*/
|
|
|
|
block += intel_connector->detect_edid->extensions;
|
|
|
|
|
2017-04-06 21:44:16 +08:00
|
|
|
if (drm_dp_dpcd_writeb(&intel_dp->aux, DP_TEST_EDID_CHECKSUM,
|
|
|
|
block->checksum) <= 0)
|
2015-05-04 22:48:20 +08:00
|
|
|
DRM_DEBUG_KMS("Failed to write EDID checksum\n");
|
|
|
|
|
|
|
|
test_result = DP_TEST_ACK | DP_TEST_EDID_CHECKSUM_WRITE;
|
2017-01-21 11:09:28 +08:00
|
|
|
intel_dp->compliance.test_data.edid = INTEL_DP_RESOLUTION_PREFERRED;
|
2015-05-04 22:48:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set test active flag here so userspace doesn't interrupt things */
|
2016-12-10 08:22:50 +08:00
|
|
|
intel_dp->compliance.test_active = 1;
|
2015-05-04 22:48:20 +08:00
|
|
|
|
2015-04-15 23:38:38 +08:00
|
|
|
return test_result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint8_t intel_dp_autotest_phy_pattern(struct intel_dp *intel_dp)
|
2011-10-21 06:09:17 +08:00
|
|
|
{
|
2015-04-15 23:38:38 +08:00
|
|
|
uint8_t test_result = DP_TEST_NAK;
|
|
|
|
return test_result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_dp_handle_test_request(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
uint8_t response = DP_TEST_NAK;
|
2017-01-21 01:04:06 +08:00
|
|
|
uint8_t request = 0;
|
|
|
|
int status;
|
2015-04-15 23:38:38 +08:00
|
|
|
|
2017-01-21 01:04:06 +08:00
|
|
|
status = drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_REQUEST, &request);
|
2015-04-15 23:38:38 +08:00
|
|
|
if (status <= 0) {
|
|
|
|
DRM_DEBUG_KMS("Could not read test request from sink\n");
|
|
|
|
goto update_status;
|
|
|
|
}
|
|
|
|
|
2017-01-21 01:04:06 +08:00
|
|
|
switch (request) {
|
2015-04-15 23:38:38 +08:00
|
|
|
case DP_TEST_LINK_TRAINING:
|
|
|
|
DRM_DEBUG_KMS("LINK_TRAINING test requested\n");
|
|
|
|
response = intel_dp_autotest_link_training(intel_dp);
|
|
|
|
break;
|
|
|
|
case DP_TEST_LINK_VIDEO_PATTERN:
|
|
|
|
DRM_DEBUG_KMS("TEST_PATTERN test requested\n");
|
|
|
|
response = intel_dp_autotest_video_pattern(intel_dp);
|
|
|
|
break;
|
|
|
|
case DP_TEST_LINK_EDID_READ:
|
|
|
|
DRM_DEBUG_KMS("EDID test requested\n");
|
|
|
|
response = intel_dp_autotest_edid(intel_dp);
|
|
|
|
break;
|
|
|
|
case DP_TEST_LINK_PHY_TEST_PATTERN:
|
|
|
|
DRM_DEBUG_KMS("PHY_PATTERN test requested\n");
|
|
|
|
response = intel_dp_autotest_phy_pattern(intel_dp);
|
|
|
|
break;
|
|
|
|
default:
|
2017-01-21 01:04:06 +08:00
|
|
|
DRM_DEBUG_KMS("Invalid test request '%02x'\n", request);
|
2015-04-15 23:38:38 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-01-21 01:04:06 +08:00
|
|
|
if (response & DP_TEST_ACK)
|
|
|
|
intel_dp->compliance.test_type = request;
|
|
|
|
|
2015-04-15 23:38:38 +08:00
|
|
|
update_status:
|
2017-01-21 01:04:06 +08:00
|
|
|
status = drm_dp_dpcd_writeb(&intel_dp->aux, DP_TEST_RESPONSE, response);
|
2015-04-15 23:38:38 +08:00
|
|
|
if (status <= 0)
|
|
|
|
DRM_DEBUG_KMS("Could not write test response to sink\n");
|
2011-10-21 06:09:17 +08:00
|
|
|
}
|
|
|
|
|
2014-05-02 12:02:48 +08:00
|
|
|
static int
|
|
|
|
intel_dp_check_mst_status(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
bool bret;
|
|
|
|
|
|
|
|
if (intel_dp->is_mst) {
|
2017-09-19 06:21:39 +08:00
|
|
|
u8 esi[DP_DPRX_ESI_LEN] = { 0 };
|
2014-05-02 12:02:48 +08:00
|
|
|
int ret = 0;
|
|
|
|
int retry;
|
|
|
|
bool handled;
|
|
|
|
bret = intel_dp_get_sink_irq_esi(intel_dp, esi);
|
|
|
|
go_again:
|
|
|
|
if (bret == true) {
|
|
|
|
|
|
|
|
/* check link status - esi[10] = 0x200c */
|
2016-08-06 00:05:42 +08:00
|
|
|
if (intel_dp->active_mst_links &&
|
2015-08-17 23:05:12 +08:00
|
|
|
!drm_dp_channel_eq_ok(&esi[10], intel_dp->lane_count)) {
|
2014-05-02 12:02:48 +08:00
|
|
|
DRM_DEBUG_KMS("channel EQ not ok, retraining\n");
|
|
|
|
intel_dp_start_link_train(intel_dp);
|
|
|
|
intel_dp_stop_link_train(intel_dp);
|
|
|
|
}
|
|
|
|
|
2015-01-15 19:45:09 +08:00
|
|
|
DRM_DEBUG_KMS("got esi %3ph\n", esi);
|
2014-05-02 12:02:48 +08:00
|
|
|
ret = drm_dp_mst_hpd_irq(&intel_dp->mst_mgr, esi, &handled);
|
|
|
|
|
|
|
|
if (handled) {
|
|
|
|
for (retry = 0; retry < 3; retry++) {
|
|
|
|
int wret;
|
|
|
|
wret = drm_dp_dpcd_write(&intel_dp->aux,
|
|
|
|
DP_SINK_COUNT_ESI+1,
|
|
|
|
&esi[1], 3);
|
|
|
|
if (wret == 3) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bret = intel_dp_get_sink_irq_esi(intel_dp, esi);
|
|
|
|
if (bret == true) {
|
2015-01-15 19:45:09 +08:00
|
|
|
DRM_DEBUG_KMS("got esi2 %3ph\n", esi);
|
2014-05-02 12:02:48 +08:00
|
|
|
goto go_again;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
DRM_DEBUG_KMS("failed to get ESI - device may have failed\n");
|
|
|
|
intel_dp->is_mst = false;
|
|
|
|
drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr, intel_dp->is_mst);
|
|
|
|
/* send a hotplug event */
|
|
|
|
drm_kms_helper_hotplug_event(intel_dig_port->base.base.dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-10-15 01:02:54 +08:00
|
|
|
static void
|
|
|
|
intel_dp_retrain_link(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
|
|
|
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
|
|
|
struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
|
|
|
|
|
|
|
|
/* Suppress underruns caused by re-training */
|
|
|
|
intel_set_cpu_fifo_underrun_reporting(dev_priv, crtc->pipe, false);
|
|
|
|
if (crtc->config->has_pch_encoder)
|
|
|
|
intel_set_pch_fifo_underrun_reporting(dev_priv,
|
|
|
|
intel_crtc_pch_transcoder(crtc), false);
|
|
|
|
|
|
|
|
intel_dp_start_link_train(intel_dp);
|
|
|
|
intel_dp_stop_link_train(intel_dp);
|
|
|
|
|
|
|
|
/* Keep underrun reporting disabled until things are stable */
|
2016-11-01 04:37:06 +08:00
|
|
|
intel_wait_for_vblank(dev_priv, crtc->pipe);
|
2016-10-15 01:02:54 +08:00
|
|
|
|
|
|
|
intel_set_cpu_fifo_underrun_reporting(dev_priv, crtc->pipe, true);
|
|
|
|
if (crtc->config->has_pch_encoder)
|
|
|
|
intel_set_pch_fifo_underrun_reporting(dev_priv,
|
|
|
|
intel_crtc_pch_transcoder(crtc), true);
|
|
|
|
}
|
|
|
|
|
2016-03-30 20:35:24 +08:00
|
|
|
static void
|
|
|
|
intel_dp_check_link_status(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_encoder *intel_encoder = &dp_to_dig_port(intel_dp)->base;
|
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
|
|
|
u8 link_status[DP_LINK_STATUS_SIZE];
|
|
|
|
|
|
|
|
WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
|
|
|
|
|
|
|
|
if (!intel_dp_get_link_status(intel_dp, link_status)) {
|
|
|
|
DRM_ERROR("Failed to get link status\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!intel_encoder->base.crtc)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!to_intel_crtc(intel_encoder->base.crtc)->active)
|
|
|
|
return;
|
|
|
|
|
2017-04-07 05:00:12 +08:00
|
|
|
/*
|
|
|
|
* Validate the cached values of intel_dp->link_rate and
|
|
|
|
* intel_dp->lane_count before attempting to retrain.
|
|
|
|
*/
|
2017-06-09 04:41:02 +08:00
|
|
|
if (!intel_dp_link_params_valid(intel_dp, intel_dp->link_rate,
|
|
|
|
intel_dp->lane_count))
|
2016-10-20 05:29:53 +08:00
|
|
|
return;
|
|
|
|
|
2017-01-25 00:16:34 +08:00
|
|
|
/* Retrain if Channel EQ or CR not ok */
|
|
|
|
if (!drm_dp_channel_eq_ok(link_status, intel_dp->lane_count)) {
|
2016-03-30 20:35:24 +08:00
|
|
|
DRM_DEBUG_KMS("%s: channel EQ not ok, retraining\n",
|
|
|
|
intel_encoder->base.name);
|
2016-10-15 01:02:54 +08:00
|
|
|
|
|
|
|
intel_dp_retrain_link(intel_dp);
|
2016-03-30 20:35:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-08 07:16:42 +08:00
|
|
|
/*
|
|
|
|
* According to DP spec
|
|
|
|
* 5.1.2:
|
|
|
|
* 1. Read DPCD
|
|
|
|
* 2. Configure link according to Receiver Capabilities
|
|
|
|
* 3. Use Link Training from 2.5.3.3 and 3.5.1.3
|
|
|
|
* 4. Check link status on receipt of hot-plug interrupt
|
2016-03-30 20:35:26 +08:00
|
|
|
*
|
|
|
|
* intel_dp_short_pulse - handles short pulse interrupts
|
|
|
|
* when full detection is not required.
|
|
|
|
* Returns %true if short pulse is handled and full detection
|
|
|
|
* is NOT required and %false otherwise.
|
2009-04-08 07:16:42 +08:00
|
|
|
*/
|
2016-03-30 20:35:26 +08:00
|
|
|
static bool
|
2016-03-30 20:35:24 +08:00
|
|
|
intel_dp_short_pulse(struct intel_dp *intel_dp)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2014-08-05 08:40:20 +08:00
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2017-01-25 00:16:34 +08:00
|
|
|
struct intel_encoder *intel_encoder = &dp_to_dig_port(intel_dp)->base;
|
2016-07-28 22:50:47 +08:00
|
|
|
u8 sink_irq_vector = 0;
|
2016-03-30 20:35:26 +08:00
|
|
|
u8 old_sink_count = intel_dp->sink_count;
|
|
|
|
bool ret;
|
2014-08-05 08:40:20 +08:00
|
|
|
|
2015-10-28 18:00:36 +08:00
|
|
|
/*
|
|
|
|
* Clearing compliance test variables to allow capturing
|
|
|
|
* of values for next automated test request.
|
|
|
|
*/
|
2016-12-10 08:22:50 +08:00
|
|
|
memset(&intel_dp->compliance, 0, sizeof(intel_dp->compliance));
|
2015-10-28 18:00:36 +08:00
|
|
|
|
2016-03-30 20:35:26 +08:00
|
|
|
/*
|
|
|
|
* Now read the DPCD to see if it's actually running
|
|
|
|
* If the current value of sink count doesn't match with
|
|
|
|
* the value that was stored earlier or dpcd read failed
|
|
|
|
* we need to do full detection
|
|
|
|
*/
|
|
|
|
ret = intel_dp_get_dpcd(intel_dp);
|
|
|
|
|
|
|
|
if ((old_sink_count != intel_dp->sink_count) || !ret) {
|
|
|
|
/* No need to proceed if we are going to do full detect */
|
|
|
|
return false;
|
2011-07-08 02:10:59 +08:00
|
|
|
}
|
|
|
|
|
2011-10-21 06:09:17 +08:00
|
|
|
/* Try to read the source of the interrupt */
|
|
|
|
if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11 &&
|
2016-07-28 22:50:47 +08:00
|
|
|
intel_dp_get_sink_irq(intel_dp, &sink_irq_vector) &&
|
|
|
|
sink_irq_vector != 0) {
|
2011-10-21 06:09:17 +08:00
|
|
|
/* Clear interrupt source */
|
2014-03-14 22:51:15 +08:00
|
|
|
drm_dp_dpcd_writeb(&intel_dp->aux,
|
|
|
|
DP_DEVICE_SERVICE_IRQ_VECTOR,
|
|
|
|
sink_irq_vector);
|
2011-10-21 06:09:17 +08:00
|
|
|
|
|
|
|
if (sink_irq_vector & DP_AUTOMATED_TEST_REQUEST)
|
2017-01-25 00:16:34 +08:00
|
|
|
intel_dp_handle_test_request(intel_dp);
|
2011-10-21 06:09:17 +08:00
|
|
|
if (sink_irq_vector & (DP_CP_IRQ | DP_SINK_SPECIFIC_IRQ))
|
|
|
|
DRM_DEBUG_DRIVER("CP or sink specific irq unhandled\n");
|
|
|
|
}
|
|
|
|
|
2016-03-30 20:35:24 +08:00
|
|
|
drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
|
|
|
|
intel_dp_check_link_status(intel_dp);
|
|
|
|
drm_modeset_unlock(&dev->mode_config.connection_mutex);
|
2017-01-25 00:16:34 +08:00
|
|
|
if (intel_dp->compliance.test_type == DP_TEST_LINK_TRAINING) {
|
|
|
|
DRM_DEBUG_KMS("Link Training Compliance Test requested\n");
|
|
|
|
/* Send a Hotplug Uevent to userspace to start modeset */
|
|
|
|
drm_kms_helper_hotplug_event(intel_encoder->base.dev);
|
|
|
|
}
|
2016-03-30 20:35:26 +08:00
|
|
|
|
|
|
|
return true;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2012-09-18 22:58:50 +08:00
|
|
|
/* XXX this is probably wrong for multiple downstream ports */
|
2011-07-13 05:38:04 +08:00
|
|
|
static enum drm_connector_status
|
2011-07-26 11:01:09 +08:00
|
|
|
intel_dp_detect_dpcd(struct intel_dp *intel_dp)
|
2011-07-13 05:38:04 +08:00
|
|
|
{
|
2017-02-22 23:10:52 +08:00
|
|
|
struct intel_lspcon *lspcon = dp_to_lspcon(intel_dp);
|
2012-09-18 22:58:50 +08:00
|
|
|
uint8_t *dpcd = intel_dp->dpcd;
|
|
|
|
uint8_t type;
|
|
|
|
|
2017-02-22 23:10:52 +08:00
|
|
|
if (lspcon->active)
|
|
|
|
lspcon_resume(lspcon);
|
|
|
|
|
2012-09-18 22:58:50 +08:00
|
|
|
if (!intel_dp_get_dpcd(intel_dp))
|
|
|
|
return connector_status_disconnected;
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp))
|
2016-04-12 14:53:54 +08:00
|
|
|
return connector_status_connected;
|
|
|
|
|
2012-09-18 22:58:50 +08:00
|
|
|
/* if there's no downstream port, we're done */
|
2016-10-25 00:33:24 +08:00
|
|
|
if (!drm_dp_is_branch(dpcd))
|
2011-07-26 11:01:09 +08:00
|
|
|
return connector_status_connected;
|
2012-09-18 22:58:50 +08:00
|
|
|
|
|
|
|
/* If we're HPD-aware, SINK_COUNT changes dynamically */
|
2013-09-27 19:48:42 +08:00
|
|
|
if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11 &&
|
|
|
|
intel_dp->downstream_ports[0] & DP_DS_PORT_HPD) {
|
2014-03-14 22:51:15 +08:00
|
|
|
|
2016-03-30 20:35:25 +08:00
|
|
|
return intel_dp->sink_count ?
|
|
|
|
connector_status_connected : connector_status_disconnected;
|
2012-09-18 22:58:50 +08:00
|
|
|
}
|
|
|
|
|
2016-07-29 21:51:16 +08:00
|
|
|
if (intel_dp_can_mst(intel_dp))
|
|
|
|
return connector_status_connected;
|
|
|
|
|
2012-09-18 22:58:50 +08:00
|
|
|
/* If no HPD, poke DDC gently */
|
2014-03-14 22:51:17 +08:00
|
|
|
if (drm_probe_ddc(&intel_dp->aux.ddc))
|
2011-07-26 11:01:09 +08:00
|
|
|
return connector_status_connected;
|
2012-09-18 22:58:50 +08:00
|
|
|
|
|
|
|
/* Well we tried, say unknown for unreliable port types */
|
2013-09-27 19:48:42 +08:00
|
|
|
if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11) {
|
|
|
|
type = intel_dp->downstream_ports[0] & DP_DS_PORT_TYPE_MASK;
|
|
|
|
if (type == DP_DS_PORT_TYPE_VGA ||
|
|
|
|
type == DP_DS_PORT_TYPE_NON_EDID)
|
|
|
|
return connector_status_unknown;
|
|
|
|
} else {
|
|
|
|
type = intel_dp->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
|
|
|
|
DP_DWN_STRM_PORT_TYPE_MASK;
|
|
|
|
if (type == DP_DWN_STRM_PORT_TYPE_ANALOG ||
|
|
|
|
type == DP_DWN_STRM_PORT_TYPE_OTHER)
|
|
|
|
return connector_status_unknown;
|
|
|
|
}
|
2012-09-18 22:58:50 +08:00
|
|
|
|
|
|
|
/* Anything else is out of spec, warn and ignore */
|
|
|
|
DRM_DEBUG_KMS("Broken DP branch device, ignoring\n");
|
2011-07-26 11:01:09 +08:00
|
|
|
return connector_status_disconnected;
|
2011-07-13 05:38:04 +08:00
|
|
|
}
|
|
|
|
|
2014-09-03 03:03:59 +08:00
|
|
|
static enum drm_connector_status
|
|
|
|
edp_detect(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-12-13 16:02:47 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-09-03 03:03:59 +08:00
|
|
|
enum drm_connector_status status;
|
|
|
|
|
2016-12-13 16:02:47 +08:00
|
|
|
status = intel_panel_detect(dev_priv);
|
2014-09-03 03:03:59 +08:00
|
|
|
if (status == connector_status_unknown)
|
|
|
|
status = connector_status_connected;
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2015-08-20 15:47:36 +08:00
|
|
|
static bool ibx_digital_port_connected(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *port)
|
2009-07-24 01:00:31 +08:00
|
|
|
{
|
2015-08-20 15:47:36 +08:00
|
|
|
u32 bit;
|
2010-10-08 07:01:12 +08:00
|
|
|
|
2015-08-20 15:47:40 +08:00
|
|
|
switch (port->port) {
|
|
|
|
case PORT_B:
|
|
|
|
bit = SDE_PORTB_HOTPLUG;
|
|
|
|
break;
|
|
|
|
case PORT_C:
|
|
|
|
bit = SDE_PORTC_HOTPLUG;
|
|
|
|
break;
|
|
|
|
case PORT_D:
|
|
|
|
bit = SDE_PORTD_HOTPLUG;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
MISSING_CASE(port->port);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return I915_READ(SDEISR) & bit;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cpt_digital_port_connected(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *port)
|
|
|
|
{
|
|
|
|
u32 bit;
|
|
|
|
|
|
|
|
switch (port->port) {
|
|
|
|
case PORT_B:
|
|
|
|
bit = SDE_PORTB_HOTPLUG_CPT;
|
|
|
|
break;
|
|
|
|
case PORT_C:
|
|
|
|
bit = SDE_PORTC_HOTPLUG_CPT;
|
|
|
|
break;
|
|
|
|
case PORT_D:
|
|
|
|
bit = SDE_PORTD_HOTPLUG_CPT;
|
|
|
|
break;
|
2017-06-16 01:12:52 +08:00
|
|
|
default:
|
|
|
|
MISSING_CASE(port->port);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return I915_READ(SDEISR) & bit;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool spt_digital_port_connected(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *port)
|
|
|
|
{
|
|
|
|
u32 bit;
|
|
|
|
|
|
|
|
switch (port->port) {
|
|
|
|
case PORT_A:
|
|
|
|
bit = SDE_PORTA_HOTPLUG_SPT;
|
|
|
|
break;
|
2015-09-18 20:54:50 +08:00
|
|
|
case PORT_E:
|
|
|
|
bit = SDE_PORTE_HOTPLUG_SPT;
|
|
|
|
break;
|
2015-08-20 15:47:40 +08:00
|
|
|
default:
|
2017-06-16 01:12:52 +08:00
|
|
|
return cpt_digital_port_connected(dev_priv, port);
|
2015-08-20 15:47:36 +08:00
|
|
|
}
|
2012-12-14 00:09:01 +08:00
|
|
|
|
2015-08-20 15:47:36 +08:00
|
|
|
return I915_READ(SDEISR) & bit;
|
2009-07-24 01:00:31 +08:00
|
|
|
}
|
|
|
|
|
2015-08-20 15:47:39 +08:00
|
|
|
static bool g4x_digital_port_connected(struct drm_i915_private *dev_priv,
|
2015-08-20 15:47:37 +08:00
|
|
|
struct intel_digital_port *port)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2015-08-20 15:47:41 +08:00
|
|
|
u32 bit;
|
2009-07-24 01:00:31 +08:00
|
|
|
|
2015-08-20 15:47:41 +08:00
|
|
|
switch (port->port) {
|
|
|
|
case PORT_B:
|
|
|
|
bit = PORTB_HOTPLUG_LIVE_STATUS_G4X;
|
|
|
|
break;
|
|
|
|
case PORT_C:
|
|
|
|
bit = PORTC_HOTPLUG_LIVE_STATUS_G4X;
|
|
|
|
break;
|
|
|
|
case PORT_D:
|
|
|
|
bit = PORTD_HOTPLUG_LIVE_STATUS_G4X;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
MISSING_CASE(port->port);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return I915_READ(PORT_HOTPLUG_STAT) & bit;
|
|
|
|
}
|
|
|
|
|
2016-02-11 01:59:05 +08:00
|
|
|
static bool gm45_digital_port_connected(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *port)
|
2015-08-20 15:47:41 +08:00
|
|
|
{
|
|
|
|
u32 bit;
|
|
|
|
|
|
|
|
switch (port->port) {
|
|
|
|
case PORT_B:
|
2016-02-11 01:59:05 +08:00
|
|
|
bit = PORTB_HOTPLUG_LIVE_STATUS_GM45;
|
2015-08-20 15:47:41 +08:00
|
|
|
break;
|
|
|
|
case PORT_C:
|
2016-02-11 01:59:05 +08:00
|
|
|
bit = PORTC_HOTPLUG_LIVE_STATUS_GM45;
|
2015-08-20 15:47:41 +08:00
|
|
|
break;
|
|
|
|
case PORT_D:
|
2016-02-11 01:59:05 +08:00
|
|
|
bit = PORTD_HOTPLUG_LIVE_STATUS_GM45;
|
2015-08-20 15:47:41 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
MISSING_CASE(port->port);
|
|
|
|
return false;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2015-08-20 15:47:37 +08:00
|
|
|
return I915_READ(PORT_HOTPLUG_STAT) & bit;
|
2014-09-01 14:58:12 +08:00
|
|
|
}
|
|
|
|
|
2017-06-16 01:12:52 +08:00
|
|
|
static bool ilk_digital_port_connected(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *port)
|
|
|
|
{
|
|
|
|
if (port->port == PORT_A)
|
|
|
|
return I915_READ(DEISR) & DE_DP_A_HOTPLUG;
|
|
|
|
else
|
|
|
|
return ibx_digital_port_connected(dev_priv, port);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool snb_digital_port_connected(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *port)
|
|
|
|
{
|
|
|
|
if (port->port == PORT_A)
|
|
|
|
return I915_READ(DEISR) & DE_DP_A_HOTPLUG;
|
|
|
|
else
|
|
|
|
return cpt_digital_port_connected(dev_priv, port);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool ivb_digital_port_connected(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *port)
|
|
|
|
{
|
|
|
|
if (port->port == PORT_A)
|
|
|
|
return I915_READ(DEISR) & DE_DP_A_HOTPLUG_IVB;
|
|
|
|
else
|
|
|
|
return cpt_digital_port_connected(dev_priv, port);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool bdw_digital_port_connected(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *port)
|
|
|
|
{
|
|
|
|
if (port->port == PORT_A)
|
|
|
|
return I915_READ(GEN8_DE_PORT_ISR) & GEN8_PORT_DP_A_HOTPLUG;
|
|
|
|
else
|
|
|
|
return cpt_digital_port_connected(dev_priv, port);
|
|
|
|
}
|
|
|
|
|
2015-08-20 15:47:42 +08:00
|
|
|
static bool bxt_digital_port_connected(struct drm_i915_private *dev_priv,
|
2015-09-11 19:28:32 +08:00
|
|
|
struct intel_digital_port *intel_dig_port)
|
2015-08-20 15:47:42 +08:00
|
|
|
{
|
2015-09-11 19:28:32 +08:00
|
|
|
struct intel_encoder *intel_encoder = &intel_dig_port->base;
|
|
|
|
enum port port;
|
2015-08-20 15:47:42 +08:00
|
|
|
u32 bit;
|
|
|
|
|
2017-08-12 02:26:49 +08:00
|
|
|
port = intel_hpd_pin_to_port(intel_encoder->hpd_pin);
|
2015-09-11 19:28:32 +08:00
|
|
|
switch (port) {
|
2015-08-20 15:47:42 +08:00
|
|
|
case PORT_A:
|
|
|
|
bit = BXT_DE_PORT_HP_DDIA;
|
|
|
|
break;
|
|
|
|
case PORT_B:
|
|
|
|
bit = BXT_DE_PORT_HP_DDIB;
|
|
|
|
break;
|
|
|
|
case PORT_C:
|
|
|
|
bit = BXT_DE_PORT_HP_DDIC;
|
|
|
|
break;
|
|
|
|
default:
|
2015-09-11 19:28:32 +08:00
|
|
|
MISSING_CASE(port);
|
2015-08-20 15:47:42 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return I915_READ(GEN8_DE_PORT_ISR) & bit;
|
|
|
|
}
|
|
|
|
|
2015-08-20 15:47:39 +08:00
|
|
|
/*
|
|
|
|
* intel_digital_port_connected - is the specified port connected?
|
|
|
|
* @dev_priv: i915 private structure
|
|
|
|
* @port: the port to test
|
|
|
|
*
|
|
|
|
* Return %true if @port is connected, %false otherwise.
|
|
|
|
*/
|
2017-01-27 17:39:19 +08:00
|
|
|
bool intel_digital_port_connected(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_digital_port *port)
|
2015-08-20 15:47:39 +08:00
|
|
|
{
|
2017-06-16 01:12:52 +08:00
|
|
|
if (HAS_GMCH_DISPLAY(dev_priv)) {
|
|
|
|
if (IS_GM45(dev_priv))
|
|
|
|
return gm45_digital_port_connected(dev_priv, port);
|
|
|
|
else
|
|
|
|
return g4x_digital_port_connected(dev_priv, port);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IS_GEN5(dev_priv))
|
|
|
|
return ilk_digital_port_connected(dev_priv, port);
|
|
|
|
else if (IS_GEN6(dev_priv))
|
|
|
|
return snb_digital_port_connected(dev_priv, port);
|
|
|
|
else if (IS_GEN7(dev_priv))
|
|
|
|
return ivb_digital_port_connected(dev_priv, port);
|
|
|
|
else if (IS_GEN8(dev_priv))
|
|
|
|
return bdw_digital_port_connected(dev_priv, port);
|
2016-12-02 16:23:49 +08:00
|
|
|
else if (IS_GEN9_LP(dev_priv))
|
2015-08-20 15:47:42 +08:00
|
|
|
return bxt_digital_port_connected(dev_priv, port);
|
2015-08-20 15:47:39 +08:00
|
|
|
else
|
2017-06-16 01:12:52 +08:00
|
|
|
return spt_digital_port_connected(dev_priv, port);
|
2015-08-20 15:47:39 +08:00
|
|
|
}
|
|
|
|
|
2011-09-29 07:38:44 +08:00
|
|
|
static struct edid *
|
2014-09-03 03:04:00 +08:00
|
|
|
intel_dp_get_edid(struct intel_dp *intel_dp)
|
2011-09-29 07:38:44 +08:00
|
|
|
{
|
2014-09-03 03:04:00 +08:00
|
|
|
struct intel_connector *intel_connector = intel_dp->attached_connector;
|
2012-06-15 03:28:33 +08:00
|
|
|
|
2012-10-19 19:51:52 +08:00
|
|
|
/* use cached edid if we have one */
|
|
|
|
if (intel_connector->edid) {
|
|
|
|
/* invalid edid */
|
|
|
|
if (IS_ERR(intel_connector->edid))
|
2012-06-15 03:28:33 +08:00
|
|
|
return NULL;
|
|
|
|
|
2013-10-01 15:38:54 +08:00
|
|
|
return drm_edid_duplicate(intel_connector->edid);
|
2014-09-03 03:04:00 +08:00
|
|
|
} else
|
|
|
|
return drm_get_edid(&intel_connector->base,
|
|
|
|
&intel_dp->aux.ddc);
|
|
|
|
}
|
2011-09-29 07:38:44 +08:00
|
|
|
|
2014-09-03 03:04:00 +08:00
|
|
|
static void
|
|
|
|
intel_dp_set_edid(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_connector *intel_connector = intel_dp->attached_connector;
|
|
|
|
struct edid *edid;
|
2011-09-29 07:38:44 +08:00
|
|
|
|
2016-03-30 20:35:22 +08:00
|
|
|
intel_dp_unset_edid(intel_dp);
|
2014-09-03 03:04:00 +08:00
|
|
|
edid = intel_dp_get_edid(intel_dp);
|
|
|
|
intel_connector->detect_edid = edid;
|
|
|
|
|
2017-05-01 21:38:00 +08:00
|
|
|
intel_dp->has_audio = drm_detect_monitor_audio(edid);
|
2011-09-29 07:38:44 +08:00
|
|
|
}
|
|
|
|
|
2014-09-03 03:04:00 +08:00
|
|
|
static void
|
|
|
|
intel_dp_unset_edid(struct intel_dp *intel_dp)
|
2011-09-29 07:38:44 +08:00
|
|
|
{
|
2014-09-03 03:04:00 +08:00
|
|
|
struct intel_connector *intel_connector = intel_dp->attached_connector;
|
2011-09-29 07:38:44 +08:00
|
|
|
|
2014-09-03 03:04:00 +08:00
|
|
|
kfree(intel_connector->detect_edid);
|
|
|
|
intel_connector->detect_edid = NULL;
|
2012-10-19 19:51:52 +08:00
|
|
|
|
2014-09-03 03:04:00 +08:00
|
|
|
intel_dp->has_audio = false;
|
|
|
|
}
|
2012-06-15 03:28:33 +08:00
|
|
|
|
2017-04-07 02:55:20 +08:00
|
|
|
static int
|
2016-03-30 20:35:22 +08:00
|
|
|
intel_dp_long_pulse(struct intel_connector *intel_connector)
|
2010-09-19 13:09:06 +08:00
|
|
|
{
|
2016-03-30 20:35:22 +08:00
|
|
|
struct drm_connector *connector = &intel_connector->base;
|
2010-09-19 13:09:06 +08:00
|
|
|
struct intel_dp *intel_dp = intel_attached_dp(connector);
|
2012-10-27 05:05:49 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct intel_encoder *intel_encoder = &intel_dig_port->base;
|
2012-10-27 05:05:44 +08:00
|
|
|
struct drm_device *dev = connector->dev;
|
2010-09-19 13:09:06 +08:00
|
|
|
enum drm_connector_status status;
|
2016-07-28 22:50:47 +08:00
|
|
|
u8 sink_irq_vector = 0;
|
2010-09-19 13:09:06 +08:00
|
|
|
|
2017-04-07 02:55:20 +08:00
|
|
|
WARN_ON(!drm_modeset_is_locked(&connector->dev->mode_config.connection_mutex));
|
|
|
|
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_get(to_i915(dev), intel_dp->aux_power_domain);
|
2010-09-19 13:09:06 +08:00
|
|
|
|
2014-09-03 03:03:59 +08:00
|
|
|
/* Can't disconnect eDP, but you can close the lid... */
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp))
|
2014-09-03 03:03:59 +08:00
|
|
|
status = edp_detect(intel_dp);
|
2015-11-18 23:19:30 +08:00
|
|
|
else if (intel_digital_port_connected(to_i915(dev),
|
|
|
|
dp_to_dig_port(intel_dp)))
|
|
|
|
status = intel_dp_detect_dpcd(intel_dp);
|
2010-09-19 13:09:06 +08:00
|
|
|
else
|
2015-11-18 23:19:30 +08:00
|
|
|
status = connector_status_disconnected;
|
|
|
|
|
2016-10-03 15:55:16 +08:00
|
|
|
if (status == connector_status_disconnected) {
|
2016-12-10 08:22:50 +08:00
|
|
|
memset(&intel_dp->compliance, 0, sizeof(intel_dp->compliance));
|
2015-10-28 18:00:36 +08:00
|
|
|
|
2016-04-12 01:11:24 +08:00
|
|
|
if (intel_dp->is_mst) {
|
|
|
|
DRM_DEBUG_KMS("MST device may have disappeared %d vs %d\n",
|
|
|
|
intel_dp->is_mst,
|
|
|
|
intel_dp->mst_mgr.mst_state);
|
|
|
|
intel_dp->is_mst = false;
|
|
|
|
drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr,
|
|
|
|
intel_dp->is_mst);
|
|
|
|
}
|
|
|
|
|
2013-11-28 04:21:54 +08:00
|
|
|
goto out;
|
2015-10-28 18:00:36 +08:00
|
|
|
}
|
2010-09-19 13:09:06 +08:00
|
|
|
|
2016-03-30 20:35:22 +08:00
|
|
|
if (intel_encoder->type != INTEL_OUTPUT_EDP)
|
2016-06-23 02:57:06 +08:00
|
|
|
intel_encoder->type = INTEL_OUTPUT_DP;
|
2016-03-30 20:35:22 +08:00
|
|
|
|
2017-02-08 08:54:11 +08:00
|
|
|
if (intel_dp->reset_link_params) {
|
2017-04-06 21:44:13 +08:00
|
|
|
/* Initial max link lane count */
|
|
|
|
intel_dp->max_link_lane_count = intel_dp_max_common_lane_count(intel_dp);
|
2016-12-06 08:27:36 +08:00
|
|
|
|
2017-04-06 21:44:13 +08:00
|
|
|
/* Initial max link rate */
|
|
|
|
intel_dp->max_link_rate = intel_dp_max_common_rate(intel_dp);
|
2017-02-08 08:54:11 +08:00
|
|
|
|
|
|
|
intel_dp->reset_link_params = false;
|
|
|
|
}
|
2016-12-06 08:27:36 +08:00
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
intel_dp_print_rates(intel_dp);
|
|
|
|
|
2017-05-18 19:10:23 +08:00
|
|
|
drm_dp_read_desc(&intel_dp->aux, &intel_dp->desc,
|
|
|
|
drm_dp_is_branch(intel_dp->dpcd));
|
2016-09-09 19:10:53 +08:00
|
|
|
|
2016-07-29 21:51:16 +08:00
|
|
|
intel_dp_configure_mst(intel_dp);
|
|
|
|
|
|
|
|
if (intel_dp->is_mst) {
|
2016-03-30 20:35:22 +08:00
|
|
|
/*
|
|
|
|
* If we are in MST mode then this connector
|
|
|
|
* won't appear connected or have anything
|
|
|
|
* with EDID on it
|
|
|
|
*/
|
2014-05-02 12:02:48 +08:00
|
|
|
status = connector_status_disconnected;
|
|
|
|
goto out;
|
2017-04-13 03:30:17 +08:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If display is now connected check links status,
|
|
|
|
* there has been known issues of link loss triggerring
|
|
|
|
* long pulse.
|
|
|
|
*
|
|
|
|
* Some sinks (eg. ASUS PB287Q) seem to perform some
|
|
|
|
* weird HPD ping pong during modesets. So we can apparently
|
|
|
|
* end up with HPD going low during a modeset, and then
|
|
|
|
* going back up soon after. And once that happens we must
|
|
|
|
* retrain the link to get a picture. That's in case no
|
|
|
|
* userspace component reacted to intermittent HPD dip.
|
|
|
|
*/
|
2016-03-30 20:35:23 +08:00
|
|
|
intel_dp_check_link_status(intel_dp);
|
2014-05-02 12:02:48 +08:00
|
|
|
}
|
|
|
|
|
2015-10-28 18:00:36 +08:00
|
|
|
/*
|
|
|
|
* Clearing NACK and defer counts to get their exact values
|
|
|
|
* while reading EDID which are required by Compliance tests
|
|
|
|
* 4.2.2.4 and 4.2.2.5
|
|
|
|
*/
|
|
|
|
intel_dp->aux.i2c_nack_count = 0;
|
|
|
|
intel_dp->aux.i2c_defer_count = 0;
|
|
|
|
|
2014-09-03 03:04:00 +08:00
|
|
|
intel_dp_set_edid(intel_dp);
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp) || intel_connector->detect_edid)
|
2016-10-03 15:55:16 +08:00
|
|
|
status = connector_status_connected;
|
2016-03-30 20:35:23 +08:00
|
|
|
intel_dp->detect_done = true;
|
2013-11-28 04:21:54 +08:00
|
|
|
|
drm/i915: Move Displayport test request and sink IRQ logic to intel_dp_detect()
Due to changes in the driver and to support Displayport compliance testing,
the test request and sink IRQ logic has been relocated from
intel_dp_check_link_status to intel_dp_detect. This is because the bulk of the
compliance tests that set the TEST_REQUEST bit in the DEVICE_IRQ field of the
DPCD issue a long pulse / hot plug event to signify the start of the test.
Currently, for a long pulse, intel_dp_check_link_status is not called for a
long HPD pulse, so if test requests come in, they cannot be detected by the
driver.
Once located in the intel_dp_detect, in the regular hot plug event path,
proper detection of Displayport compliance test requests occurs which then
invokes the test handler to support them. Additionally, this places compliance
testing in the normal operational paths, eliminating as much special case code
as possible.
The only change in intel_dp_check_link_status with this patch is that when
the IRQ is the result of a test request from the sink, the test handler is not
invoked during the short pulse path. Short pulse test requests are for a
particular variety of tests (mainly link training) that will be implemented
in the future. Once those tests are available, the test request handler will
be called from here as well.
V2:
- Rewored the commit message to be more clear about the content and intent
of this patch
- Restore IRQ detection logic to intel_dp_check_link_status(). Continue to
detect and clear sink IRQs in the short pulse case. Ignore test requests
in the short pulses for now since they are for future test implementations.
Signed-off-by: Todd Previte <tprevite@gmail.com>
Reviewed-by: Paulo Zanoni <paulo.r.zanoni@intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-04-21 06:27:34 +08:00
|
|
|
/* Try to read the source of the interrupt */
|
|
|
|
if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11 &&
|
2016-07-28 22:50:47 +08:00
|
|
|
intel_dp_get_sink_irq(intel_dp, &sink_irq_vector) &&
|
|
|
|
sink_irq_vector != 0) {
|
drm/i915: Move Displayport test request and sink IRQ logic to intel_dp_detect()
Due to changes in the driver and to support Displayport compliance testing,
the test request and sink IRQ logic has been relocated from
intel_dp_check_link_status to intel_dp_detect. This is because the bulk of the
compliance tests that set the TEST_REQUEST bit in the DEVICE_IRQ field of the
DPCD issue a long pulse / hot plug event to signify the start of the test.
Currently, for a long pulse, intel_dp_check_link_status is not called for a
long HPD pulse, so if test requests come in, they cannot be detected by the
driver.
Once located in the intel_dp_detect, in the regular hot plug event path,
proper detection of Displayport compliance test requests occurs which then
invokes the test handler to support them. Additionally, this places compliance
testing in the normal operational paths, eliminating as much special case code
as possible.
The only change in intel_dp_check_link_status with this patch is that when
the IRQ is the result of a test request from the sink, the test handler is not
invoked during the short pulse path. Short pulse test requests are for a
particular variety of tests (mainly link training) that will be implemented
in the future. Once those tests are available, the test request handler will
be called from here as well.
V2:
- Rewored the commit message to be more clear about the content and intent
of this patch
- Restore IRQ detection logic to intel_dp_check_link_status(). Continue to
detect and clear sink IRQs in the short pulse case. Ignore test requests
in the short pulses for now since they are for future test implementations.
Signed-off-by: Todd Previte <tprevite@gmail.com>
Reviewed-by: Paulo Zanoni <paulo.r.zanoni@intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-04-21 06:27:34 +08:00
|
|
|
/* Clear interrupt source */
|
|
|
|
drm_dp_dpcd_writeb(&intel_dp->aux,
|
|
|
|
DP_DEVICE_SERVICE_IRQ_VECTOR,
|
|
|
|
sink_irq_vector);
|
|
|
|
|
|
|
|
if (sink_irq_vector & DP_AUTOMATED_TEST_REQUEST)
|
|
|
|
intel_dp_handle_test_request(intel_dp);
|
|
|
|
if (sink_irq_vector & (DP_CP_IRQ | DP_SINK_SPECIFIC_IRQ))
|
|
|
|
DRM_DEBUG_DRIVER("CP or sink specific irq unhandled\n");
|
|
|
|
}
|
|
|
|
|
2013-11-28 04:21:54 +08:00
|
|
|
out:
|
2016-10-03 15:55:16 +08:00
|
|
|
if (status != connector_status_connected && !intel_dp->is_mst)
|
2016-03-30 20:35:22 +08:00
|
|
|
intel_dp_unset_edid(intel_dp);
|
2016-03-30 20:35:23 +08:00
|
|
|
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_put(to_i915(dev), intel_dp->aux_power_domain);
|
2016-10-03 15:55:16 +08:00
|
|
|
return status;
|
2016-03-30 20:35:22 +08:00
|
|
|
}
|
|
|
|
|
2017-04-07 02:55:20 +08:00
|
|
|
static int
|
|
|
|
intel_dp_detect(struct drm_connector *connector,
|
|
|
|
struct drm_modeset_acquire_ctx *ctx,
|
|
|
|
bool force)
|
2016-03-30 20:35:22 +08:00
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = intel_attached_dp(connector);
|
2017-04-07 02:55:20 +08:00
|
|
|
int status = connector->status;
|
2016-03-30 20:35:22 +08:00
|
|
|
|
|
|
|
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
|
|
|
|
connector->base.id, connector->name);
|
|
|
|
|
2016-03-30 20:35:23 +08:00
|
|
|
/* If full detect is not performed yet, do a full detect */
|
|
|
|
if (!intel_dp->detect_done)
|
2016-10-03 15:55:16 +08:00
|
|
|
status = intel_dp_long_pulse(intel_dp->attached_connector);
|
2016-03-30 20:35:23 +08:00
|
|
|
|
|
|
|
intel_dp->detect_done = false;
|
2016-03-30 20:35:22 +08:00
|
|
|
|
2016-10-03 15:55:16 +08:00
|
|
|
return status;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2014-09-03 03:04:00 +08:00
|
|
|
static void
|
|
|
|
intel_dp_force(struct drm_connector *connector)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2010-09-09 23:20:55 +08:00
|
|
|
struct intel_dp *intel_dp = intel_attached_dp(connector);
|
2014-09-03 03:04:00 +08:00
|
|
|
struct intel_encoder *intel_encoder = &dp_to_dig_port(intel_dp)->base;
|
2015-11-16 22:01:04 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_encoder->base.dev);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2014-09-03 03:04:00 +08:00
|
|
|
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
|
|
|
|
connector->base.id, connector->name);
|
|
|
|
intel_dp_unset_edid(intel_dp);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2014-09-03 03:04:00 +08:00
|
|
|
if (connector->status != connector_status_connected)
|
|
|
|
return;
|
2014-03-05 22:20:53 +08:00
|
|
|
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_get(dev_priv, intel_dp->aux_power_domain);
|
2014-09-03 03:04:00 +08:00
|
|
|
|
|
|
|
intel_dp_set_edid(intel_dp);
|
|
|
|
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_put(dev_priv, intel_dp->aux_power_domain);
|
2014-09-03 03:04:00 +08:00
|
|
|
|
|
|
|
if (intel_encoder->type != INTEL_OUTPUT_EDP)
|
2016-06-23 02:57:06 +08:00
|
|
|
intel_encoder->type = INTEL_OUTPUT_DP;
|
2014-09-03 03:04:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int intel_dp_get_modes(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct intel_connector *intel_connector = to_intel_connector(connector);
|
|
|
|
struct edid *edid;
|
|
|
|
|
|
|
|
edid = intel_connector->detect_edid;
|
|
|
|
if (edid) {
|
|
|
|
int ret = intel_connector_update_modes(connector, edid);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-07-24 01:00:32 +08:00
|
|
|
|
2012-10-19 19:51:48 +08:00
|
|
|
/* if eDP has no EDID, fall back to fixed mode */
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_attached_dp(connector)) &&
|
2014-09-03 03:04:00 +08:00
|
|
|
intel_connector->panel.fixed_mode) {
|
2012-10-19 19:51:48 +08:00
|
|
|
struct drm_display_mode *mode;
|
2014-09-03 03:04:00 +08:00
|
|
|
|
|
|
|
mode = drm_mode_duplicate(connector->dev,
|
2012-10-19 19:51:50 +08:00
|
|
|
intel_connector->panel.fixed_mode);
|
2012-10-19 19:51:48 +08:00
|
|
|
if (mode) {
|
2009-07-24 01:00:32 +08:00
|
|
|
drm_mode_probed_add(connector, mode);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2014-09-03 03:04:00 +08:00
|
|
|
|
2009-07-24 01:00:32 +08:00
|
|
|
return 0;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2016-06-24 21:00:14 +08:00
|
|
|
static int
|
|
|
|
intel_dp_connector_register(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = intel_attached_dp(connector);
|
2016-06-24 21:00:15 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = intel_connector_register(connector);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-06-24 21:00:14 +08:00
|
|
|
|
|
|
|
i915_debugfs_connector_add(connector);
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("registering %s bus for %s\n",
|
|
|
|
intel_dp->aux.name, connector->kdev->kobj.name);
|
|
|
|
|
|
|
|
intel_dp->aux.dev = connector->kdev;
|
|
|
|
return drm_dp_aux_register(&intel_dp->aux);
|
|
|
|
}
|
|
|
|
|
2016-06-17 18:40:33 +08:00
|
|
|
static void
|
|
|
|
intel_dp_connector_unregister(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
drm_dp_aux_unregister(&intel_attached_dp(connector)->aux);
|
|
|
|
intel_connector_unregister(connector);
|
|
|
|
}
|
|
|
|
|
2009-04-08 07:16:42 +08:00
|
|
|
static void
|
2013-06-13 04:27:30 +08:00
|
|
|
intel_dp_connector_destroy(struct drm_connector *connector)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2012-10-19 19:51:49 +08:00
|
|
|
struct intel_connector *intel_connector = to_intel_connector(connector);
|
2011-08-12 18:11:33 +08:00
|
|
|
|
2014-09-05 04:43:45 +08:00
|
|
|
kfree(intel_connector->detect_edid);
|
2014-09-03 03:04:00 +08:00
|
|
|
|
2012-10-19 19:51:52 +08:00
|
|
|
if (!IS_ERR_OR_NULL(intel_connector->edid))
|
|
|
|
kfree(intel_connector->edid);
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
/*
|
|
|
|
* Can't call intel_dp_is_edp() since the encoder may have been
|
|
|
|
* destroyed already.
|
|
|
|
*/
|
2013-06-13 04:27:23 +08:00
|
|
|
if (connector->connector_type == DRM_MODE_CONNECTOR_eDP)
|
2012-10-19 19:51:49 +08:00
|
|
|
intel_panel_fini(&intel_connector->panel);
|
2011-08-12 18:11:33 +08:00
|
|
|
|
2009-04-08 07:16:42 +08:00
|
|
|
drm_connector_cleanup(connector);
|
2010-03-29 16:13:57 +08:00
|
|
|
kfree(connector);
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
|
|
|
|
2012-10-27 05:05:52 +08:00
|
|
|
void intel_dp_encoder_destroy(struct drm_encoder *encoder)
|
2010-08-21 00:08:28 +08:00
|
|
|
{
|
2012-10-27 05:05:46 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = enc_to_dig_port(encoder);
|
|
|
|
struct intel_dp *intel_dp = &intel_dig_port->dp;
|
2010-08-21 00:08:28 +08:00
|
|
|
|
2014-05-02 12:02:48 +08:00
|
|
|
intel_dp_mst_encoder_cleanup(intel_dig_port);
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp)) {
|
2011-09-19 14:09:52 +08:00
|
|
|
cancel_delayed_work_sync(&intel_dp->panel_vdd_work);
|
2014-09-04 19:55:31 +08:00
|
|
|
/*
|
|
|
|
* vdd might still be enabled do to the delayed vdd off.
|
|
|
|
* Make sure vdd is actually turned off here.
|
|
|
|
*/
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_lock(intel_dp);
|
2014-01-17 21:39:48 +08:00
|
|
|
edp_panel_vdd_off_sync(intel_dp);
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
|
|
|
|
2014-07-08 04:01:46 +08:00
|
|
|
if (intel_dp->edp_notifier.notifier_call) {
|
|
|
|
unregister_reboot_notifier(&intel_dp->edp_notifier);
|
|
|
|
intel_dp->edp_notifier.notifier_call = NULL;
|
|
|
|
}
|
2011-09-19 14:09:52 +08:00
|
|
|
}
|
2016-06-20 16:29:17 +08:00
|
|
|
|
|
|
|
intel_dp_aux_fini(intel_dp);
|
|
|
|
|
2014-12-12 23:57:38 +08:00
|
|
|
drm_encoder_cleanup(encoder);
|
2012-10-27 05:05:46 +08:00
|
|
|
kfree(intel_dig_port);
|
2010-08-21 00:08:28 +08:00
|
|
|
}
|
|
|
|
|
2016-04-18 15:04:21 +08:00
|
|
|
void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
|
2014-08-18 19:42:45 +08:00
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2014-08-18 19:42:45 +08:00
|
|
|
return;
|
|
|
|
|
2014-09-04 19:55:31 +08:00
|
|
|
/*
|
|
|
|
* vdd might still be enabled do to the delayed vdd off.
|
|
|
|
* Make sure vdd is actually turned off here.
|
|
|
|
*/
|
2014-11-25 21:43:48 +08:00
|
|
|
cancel_delayed_work_sync(&intel_dp->panel_vdd_work);
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_lock(intel_dp);
|
2014-08-18 19:42:45 +08:00
|
|
|
edp_panel_vdd_off_sync(intel_dp);
|
2014-09-04 19:54:56 +08:00
|
|
|
pps_unlock(intel_dp);
|
2014-08-18 19:42:45 +08:00
|
|
|
}
|
|
|
|
|
2014-10-28 22:15:52 +08:00
|
|
|
static void intel_edp_panel_vdd_sanitize(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-10-28 22:15:52 +08:00
|
|
|
|
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
|
|
|
if (!edp_have_panel_vdd(intel_dp))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The VDD bit needs a power domain reference, so if the bit is
|
|
|
|
* already enabled when we boot or resume, grab this reference and
|
|
|
|
* schedule a vdd off, so we don't hold on to the reference
|
|
|
|
* indefinitely.
|
|
|
|
*/
|
|
|
|
DRM_DEBUG_KMS("VDD left on by BIOS, adjusting state tracking\n");
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_get(dev_priv, intel_dp->aux_power_domain);
|
2014-10-28 22:15:52 +08:00
|
|
|
|
|
|
|
edp_panel_vdd_schedule_off(intel_dp);
|
|
|
|
}
|
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
static enum pipe vlv_active_pipe(struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
|
|
|
|
|
|
|
|
if ((intel_dp->DP & DP_PORT_EN) == 0)
|
|
|
|
return INVALID_PIPE;
|
|
|
|
|
|
|
|
if (IS_CHERRYVIEW(dev_priv))
|
|
|
|
return DP_PORT_TO_PIPE_CHV(intel_dp->DP);
|
|
|
|
else
|
|
|
|
return PORT_TO_PIPE(intel_dp->DP);
|
|
|
|
}
|
|
|
|
|
2016-04-18 15:04:21 +08:00
|
|
|
void intel_dp_encoder_reset(struct drm_encoder *encoder)
|
2014-07-31 19:03:36 +08:00
|
|
|
{
|
2016-05-14 01:53:56 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(encoder->dev);
|
2016-11-22 03:15:05 +08:00
|
|
|
struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
|
|
|
|
struct intel_lspcon *lspcon = dp_to_lspcon(intel_dp);
|
2016-05-14 01:53:56 +08:00
|
|
|
|
|
|
|
if (!HAS_DDI(dev_priv))
|
|
|
|
intel_dp->DP = I915_READ(intel_dp->output_reg);
|
2014-10-28 22:15:52 +08:00
|
|
|
|
2016-11-22 03:15:05 +08:00
|
|
|
if (lspcon->active)
|
2016-10-14 22:26:52 +08:00
|
|
|
lspcon_resume(lspcon);
|
|
|
|
|
2017-02-08 08:54:11 +08:00
|
|
|
intel_dp->reset_link_params = true;
|
|
|
|
|
2014-10-28 22:15:52 +08:00
|
|
|
pps_lock(intel_dp);
|
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
|
|
|
|
intel_dp->active_pipe = vlv_active_pipe(intel_dp);
|
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp)) {
|
2016-12-15 02:00:23 +08:00
|
|
|
/* Reinit the power sequencer, in case BIOS did something with it. */
|
|
|
|
intel_dp_pps_init(encoder->dev, intel_dp);
|
|
|
|
intel_edp_panel_vdd_sanitize(intel_dp);
|
|
|
|
}
|
2014-10-28 22:15:52 +08:00
|
|
|
|
|
|
|
pps_unlock(intel_dp);
|
2014-07-31 19:03:36 +08:00
|
|
|
}
|
|
|
|
|
2009-04-08 07:16:42 +08:00
|
|
|
static const struct drm_connector_funcs intel_dp_connector_funcs = {
|
2014-09-03 03:04:00 +08:00
|
|
|
.force = intel_dp_force,
|
2009-04-08 07:16:42 +08:00
|
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
2017-05-01 21:38:01 +08:00
|
|
|
.atomic_get_property = intel_digital_connector_atomic_get_property,
|
|
|
|
.atomic_set_property = intel_digital_connector_atomic_set_property,
|
2016-06-24 21:00:14 +08:00
|
|
|
.late_register = intel_dp_connector_register,
|
2016-06-17 18:40:33 +08:00
|
|
|
.early_unregister = intel_dp_connector_unregister,
|
2013-06-13 04:27:30 +08:00
|
|
|
.destroy = intel_dp_connector_destroy,
|
2015-01-23 08:50:32 +08:00
|
|
|
.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
|
2017-05-01 21:38:01 +08:00
|
|
|
.atomic_duplicate_state = intel_digital_connector_duplicate_state,
|
2009-04-08 07:16:42 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct drm_connector_helper_funcs intel_dp_connector_helper_funcs = {
|
2017-04-07 02:55:20 +08:00
|
|
|
.detect_ctx = intel_dp_detect,
|
2009-04-08 07:16:42 +08:00
|
|
|
.get_modes = intel_dp_get_modes,
|
|
|
|
.mode_valid = intel_dp_mode_valid,
|
2017-05-01 21:38:01 +08:00
|
|
|
.atomic_check = intel_digital_connector_atomic_check,
|
2009-04-08 07:16:42 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct drm_encoder_funcs intel_dp_enc_funcs = {
|
2014-07-31 19:03:36 +08:00
|
|
|
.reset = intel_dp_encoder_reset,
|
2010-08-21 00:08:28 +08:00
|
|
|
.destroy = intel_dp_encoder_destroy,
|
2009-04-08 07:16:42 +08:00
|
|
|
};
|
|
|
|
|
2015-01-23 13:00:31 +08:00
|
|
|
enum irqreturn
|
2014-06-18 09:29:35 +08:00
|
|
|
intel_dp_hpd_pulse(struct intel_digital_port *intel_dig_port, bool long_hpd)
|
|
|
|
{
|
|
|
|
struct intel_dp *intel_dp = &intel_dig_port->dp;
|
2014-05-02 12:02:48 +08:00
|
|
|
struct drm_device *dev = intel_dig_port->base.base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2015-01-23 13:00:31 +08:00
|
|
|
enum irqreturn ret = IRQ_NONE;
|
2014-08-18 19:42:42 +08:00
|
|
|
|
2015-11-19 19:09:56 +08:00
|
|
|
if (intel_dig_port->base.type != INTEL_OUTPUT_EDP &&
|
|
|
|
intel_dig_port->base.type != INTEL_OUTPUT_HDMI)
|
2016-06-23 02:57:06 +08:00
|
|
|
intel_dig_port->base.type = INTEL_OUTPUT_DP;
|
2014-06-18 09:29:35 +08:00
|
|
|
|
2014-10-17 01:46:10 +08:00
|
|
|
if (long_hpd && intel_dig_port->base.type == INTEL_OUTPUT_EDP) {
|
|
|
|
/*
|
|
|
|
* vdd off can generate a long pulse on eDP which
|
|
|
|
* would require vdd on to handle it, and thus we
|
|
|
|
* would end up in an endless cycle of
|
|
|
|
* "vdd off -> long hpd -> vdd on -> detect -> vdd off -> ..."
|
|
|
|
*/
|
|
|
|
DRM_DEBUG_KMS("ignoring long hpd on eDP port %c\n",
|
|
|
|
port_name(intel_dig_port->port));
|
2015-02-10 20:11:46 +08:00
|
|
|
return IRQ_HANDLED;
|
2014-10-17 01:46:10 +08:00
|
|
|
}
|
|
|
|
|
2014-08-11 23:37:37 +08:00
|
|
|
DRM_DEBUG_KMS("got hpd irq on port %c - %s\n",
|
|
|
|
port_name(intel_dig_port->port),
|
2014-05-02 12:02:48 +08:00
|
|
|
long_hpd ? "long" : "short");
|
2014-06-18 09:29:35 +08:00
|
|
|
|
2016-10-03 15:55:15 +08:00
|
|
|
if (long_hpd) {
|
2017-02-08 08:54:11 +08:00
|
|
|
intel_dp->reset_link_params = true;
|
2016-10-03 15:55:15 +08:00
|
|
|
intel_dp->detect_done = false;
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_get(dev_priv, intel_dp->aux_power_domain);
|
2014-08-18 19:42:42 +08:00
|
|
|
|
2016-10-03 15:55:15 +08:00
|
|
|
if (intel_dp->is_mst) {
|
|
|
|
if (intel_dp_check_mst_status(intel_dp) == -EINVAL) {
|
|
|
|
/*
|
|
|
|
* If we were in MST mode, and device is not
|
|
|
|
* there, get out of MST mode
|
|
|
|
*/
|
|
|
|
DRM_DEBUG_KMS("MST device may have disappeared %d vs %d\n",
|
|
|
|
intel_dp->is_mst, intel_dp->mst_mgr.mst_state);
|
|
|
|
intel_dp->is_mst = false;
|
|
|
|
drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr,
|
|
|
|
intel_dp->is_mst);
|
|
|
|
intel_dp->detect_done = false;
|
|
|
|
goto put_power;
|
2014-05-02 12:02:48 +08:00
|
|
|
}
|
2016-10-03 15:55:15 +08:00
|
|
|
}
|
2014-05-02 12:02:48 +08:00
|
|
|
|
2016-10-03 15:55:15 +08:00
|
|
|
if (!intel_dp->is_mst) {
|
|
|
|
if (!intel_dp_short_pulse(intel_dp)) {
|
|
|
|
intel_dp->detect_done = false;
|
|
|
|
goto put_power;
|
2016-03-30 20:35:26 +08:00
|
|
|
}
|
2014-05-02 12:02:48 +08:00
|
|
|
}
|
2015-01-23 13:00:31 +08:00
|
|
|
|
|
|
|
ret = IRQ_HANDLED;
|
|
|
|
|
2014-08-18 19:42:42 +08:00
|
|
|
put_power:
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_display_power_put(dev_priv, intel_dp->aux_power_domain);
|
2014-08-18 19:42:42 +08:00
|
|
|
|
|
|
|
return ret;
|
2014-06-18 09:29:35 +08:00
|
|
|
}
|
|
|
|
|
2015-08-06 15:51:39 +08:00
|
|
|
/* check the VBT to see whether the eDP is on another port */
|
2017-08-18 17:30:19 +08:00
|
|
|
bool intel_dp_is_port_edp(struct drm_i915_private *dev_priv, enum port port)
|
2010-06-12 14:32:21 +08:00
|
|
|
{
|
2015-09-12 02:04:38 +08:00
|
|
|
/*
|
|
|
|
* eDP not supported on g4x. so bail out early just
|
|
|
|
* for a bit extra safety in case the VBT is bonkers.
|
|
|
|
*/
|
2016-11-16 16:55:41 +08:00
|
|
|
if (INTEL_GEN(dev_priv) < 5)
|
2015-09-12 02:04:38 +08:00
|
|
|
return false;
|
|
|
|
|
2016-12-21 18:17:24 +08:00
|
|
|
if (INTEL_GEN(dev_priv) < 9 && port == PORT_A)
|
2013-11-02 00:22:41 +08:00
|
|
|
return true;
|
|
|
|
|
2016-03-16 18:43:31 +08:00
|
|
|
return intel_bios_is_port_edp(dev_priv, port);
|
2010-06-12 14:32:21 +08:00
|
|
|
}
|
|
|
|
|
2017-04-10 18:51:10 +08:00
|
|
|
static void
|
2010-09-19 16:29:33 +08:00
|
|
|
intel_dp_add_properties(struct intel_dp *intel_dp, struct drm_connector *connector)
|
|
|
|
{
|
2017-05-01 21:37:56 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(connector->dev);
|
|
|
|
|
2011-05-13 05:17:24 +08:00
|
|
|
intel_attach_force_audio_property(connector);
|
2011-02-22 06:23:52 +08:00
|
|
|
intel_attach_broadcast_rgb_property(connector);
|
2012-10-26 17:04:00 +08:00
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (intel_dp_is_edp(intel_dp)) {
|
2017-05-01 21:37:56 +08:00
|
|
|
u32 allowed_scalers;
|
|
|
|
|
|
|
|
allowed_scalers = BIT(DRM_MODE_SCALE_ASPECT) | BIT(DRM_MODE_SCALE_FULLSCREEN);
|
|
|
|
if (!HAS_GMCH_DISPLAY(dev_priv))
|
|
|
|
allowed_scalers |= BIT(DRM_MODE_SCALE_CENTER);
|
|
|
|
|
|
|
|
drm_connector_attach_scaling_mode_property(connector, allowed_scalers);
|
|
|
|
|
2017-05-01 21:37:55 +08:00
|
|
|
connector->state->scaling_mode = DRM_MODE_SCALE_ASPECT;
|
2017-05-01 21:37:56 +08:00
|
|
|
|
2012-10-26 17:04:00 +08:00
|
|
|
}
|
2010-09-19 16:29:33 +08:00
|
|
|
}
|
|
|
|
|
2014-01-29 19:25:41 +08:00
|
|
|
static void intel_dp_init_panel_power_timestamps(struct intel_dp *intel_dp)
|
|
|
|
{
|
2016-01-23 09:39:04 +08:00
|
|
|
intel_dp->panel_power_off_time = ktime_get_boottime();
|
2014-01-29 19:25:41 +08:00
|
|
|
intel_dp->last_power_on = jiffies;
|
|
|
|
intel_dp->last_backlight_off = jiffies;
|
|
|
|
}
|
|
|
|
|
2012-10-21 02:57:45 +08:00
|
|
|
static void
|
2016-06-16 21:37:22 +08:00
|
|
|
intel_pps_readout_hw_state(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_dp *intel_dp, struct edp_power_seq *seq)
|
2012-10-21 02:57:45 +08:00
|
|
|
{
|
2015-06-18 13:30:55 +08:00
|
|
|
u32 pp_on, pp_off, pp_div = 0, pp_ctl = 0;
|
2016-06-16 21:37:21 +08:00
|
|
|
struct pps_registers regs;
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2016-06-16 21:37:21 +08:00
|
|
|
intel_pps_get_registers(dev_priv, intel_dp, ®s);
|
2012-10-21 02:57:45 +08:00
|
|
|
|
|
|
|
/* Workaround: Need to write PP_CONTROL with the unlock key as
|
|
|
|
* the very first thing. */
|
2015-06-18 13:30:55 +08:00
|
|
|
pp_ctl = ironlake_get_pp_control(intel_dp);
|
2012-10-21 02:57:45 +08:00
|
|
|
|
2016-06-16 21:37:21 +08:00
|
|
|
pp_on = I915_READ(regs.pp_on);
|
|
|
|
pp_off = I915_READ(regs.pp_off);
|
2017-06-03 04:06:44 +08:00
|
|
|
if (!IS_GEN9_LP(dev_priv) && !HAS_PCH_CNP(dev_priv)) {
|
2016-06-16 21:37:21 +08:00
|
|
|
I915_WRITE(regs.pp_ctrl, pp_ctl);
|
|
|
|
pp_div = I915_READ(regs.pp_div);
|
2015-06-18 13:30:55 +08:00
|
|
|
}
|
2012-10-21 02:57:45 +08:00
|
|
|
|
|
|
|
/* Pull timing values out of registers */
|
2016-06-16 21:37:22 +08:00
|
|
|
seq->t1_t3 = (pp_on & PANEL_POWER_UP_DELAY_MASK) >>
|
|
|
|
PANEL_POWER_UP_DELAY_SHIFT;
|
2012-10-21 02:57:45 +08:00
|
|
|
|
2016-06-16 21:37:22 +08:00
|
|
|
seq->t8 = (pp_on & PANEL_LIGHT_ON_DELAY_MASK) >>
|
|
|
|
PANEL_LIGHT_ON_DELAY_SHIFT;
|
2012-10-21 02:57:45 +08:00
|
|
|
|
2016-06-16 21:37:22 +08:00
|
|
|
seq->t9 = (pp_off & PANEL_LIGHT_OFF_DELAY_MASK) >>
|
|
|
|
PANEL_LIGHT_OFF_DELAY_SHIFT;
|
2012-10-21 02:57:45 +08:00
|
|
|
|
2016-06-16 21:37:22 +08:00
|
|
|
seq->t10 = (pp_off & PANEL_POWER_DOWN_DELAY_MASK) >>
|
|
|
|
PANEL_POWER_DOWN_DELAY_SHIFT;
|
2012-10-21 02:57:45 +08:00
|
|
|
|
2017-06-03 04:06:44 +08:00
|
|
|
if (IS_GEN9_LP(dev_priv) || HAS_PCH_CNP(dev_priv)) {
|
2017-06-27 03:21:45 +08:00
|
|
|
seq->t11_t12 = ((pp_ctl & BXT_POWER_CYCLE_DELAY_MASK) >>
|
|
|
|
BXT_POWER_CYCLE_DELAY_SHIFT) * 1000;
|
2015-06-18 13:30:55 +08:00
|
|
|
} else {
|
2016-06-16 21:37:22 +08:00
|
|
|
seq->t11_t12 = ((pp_div & PANEL_POWER_CYCLE_DELAY_MASK) >>
|
2012-10-21 02:57:45 +08:00
|
|
|
PANEL_POWER_CYCLE_DELAY_SHIFT) * 1000;
|
2015-06-18 13:30:55 +08:00
|
|
|
}
|
2016-06-16 21:37:22 +08:00
|
|
|
}
|
|
|
|
|
2016-06-17 01:01:46 +08:00
|
|
|
static void
|
|
|
|
intel_pps_dump_state(const char *state_name, const struct edp_power_seq *seq)
|
|
|
|
{
|
|
|
|
DRM_DEBUG_KMS("%s t1_t3 %d t8 %d t9 %d t10 %d t11_t12 %d\n",
|
|
|
|
state_name,
|
|
|
|
seq->t1_t3, seq->t8, seq->t9, seq->t10, seq->t11_t12);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
intel_pps_verify_state(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_dp *intel_dp)
|
|
|
|
{
|
|
|
|
struct edp_power_seq hw;
|
|
|
|
struct edp_power_seq *sw = &intel_dp->pps_delays;
|
|
|
|
|
|
|
|
intel_pps_readout_hw_state(dev_priv, intel_dp, &hw);
|
|
|
|
|
|
|
|
if (hw.t1_t3 != sw->t1_t3 || hw.t8 != sw->t8 || hw.t9 != sw->t9 ||
|
|
|
|
hw.t10 != sw->t10 || hw.t11_t12 != sw->t11_t12) {
|
|
|
|
DRM_ERROR("PPS state mismatch\n");
|
|
|
|
intel_pps_dump_state("sw", sw);
|
|
|
|
intel_pps_dump_state("hw", &hw);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-16 21:37:22 +08:00
|
|
|
static void
|
|
|
|
intel_dp_init_panel_power_sequencer(struct drm_device *dev,
|
|
|
|
struct intel_dp *intel_dp)
|
|
|
|
{
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2016-06-16 21:37:22 +08:00
|
|
|
struct edp_power_seq cur, vbt, spec,
|
|
|
|
*final = &intel_dp->pps_delays;
|
|
|
|
|
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
|
|
|
|
|
|
|
/* already initialized? */
|
|
|
|
if (final->t11_t12 != 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
intel_pps_readout_hw_state(dev_priv, intel_dp, &cur);
|
2012-10-21 02:57:45 +08:00
|
|
|
|
2016-06-17 01:01:46 +08:00
|
|
|
intel_pps_dump_state("cur", &cur);
|
2012-10-21 02:57:45 +08:00
|
|
|
|
2016-03-24 23:50:20 +08:00
|
|
|
vbt = dev_priv->vbt.edp.pps;
|
2017-07-01 00:33:48 +08:00
|
|
|
/* On Toshiba Satellite P50-C-18C system the VBT T12 delay
|
|
|
|
* of 500ms appears to be too short. Ocassionally the panel
|
|
|
|
* just fails to power back on. Increasing the delay to 800ms
|
|
|
|
* seems sufficient to avoid this problem.
|
|
|
|
*/
|
|
|
|
if (dev_priv->quirks & QUIRK_INCREASE_T12_DELAY) {
|
2017-10-04 07:37:25 +08:00
|
|
|
vbt.t11_t12 = max_t(u16, vbt.t11_t12, 1300 * 10);
|
2017-07-01 00:33:48 +08:00
|
|
|
DRM_DEBUG_KMS("Increasing T12 panel delay as per the quirk to %d\n",
|
|
|
|
vbt.t11_t12);
|
|
|
|
}
|
2017-06-27 03:21:44 +08:00
|
|
|
/* T11_T12 delay is special and actually in units of 100ms, but zero
|
|
|
|
* based in the hw (so we need to add 100 ms). But the sw vbt
|
|
|
|
* table multiplies it with 1000 to make it in units of 100usec,
|
|
|
|
* too. */
|
|
|
|
vbt.t11_t12 += 100 * 10;
|
2012-10-21 02:57:45 +08:00
|
|
|
|
|
|
|
/* Upper limits from eDP 1.3 spec. Note that we use the clunky units of
|
|
|
|
* our hw here, which are all in 100usec. */
|
|
|
|
spec.t1_t3 = 210 * 10;
|
|
|
|
spec.t8 = 50 * 10; /* no limit for t8, use t7 instead */
|
|
|
|
spec.t9 = 50 * 10; /* no limit for t9, make it symmetric with t8 */
|
|
|
|
spec.t10 = 500 * 10;
|
|
|
|
/* This one is special and actually in units of 100ms, but zero
|
|
|
|
* based in the hw (so we need to add 100 ms). But the sw vbt
|
|
|
|
* table multiplies it with 1000 to make it in units of 100usec,
|
|
|
|
* too. */
|
|
|
|
spec.t11_t12 = (510 + 100) * 10;
|
|
|
|
|
2016-06-17 01:01:46 +08:00
|
|
|
intel_pps_dump_state("vbt", &vbt);
|
2012-10-21 02:57:45 +08:00
|
|
|
|
|
|
|
/* Use the max of the register settings and vbt. If both are
|
|
|
|
* unset, fall back to the spec limits. */
|
2014-10-17 02:27:30 +08:00
|
|
|
#define assign_final(field) final->field = (max(cur.field, vbt.field) == 0 ? \
|
2012-10-21 02:57:45 +08:00
|
|
|
spec.field : \
|
|
|
|
max(cur.field, vbt.field))
|
|
|
|
assign_final(t1_t3);
|
|
|
|
assign_final(t8);
|
|
|
|
assign_final(t9);
|
|
|
|
assign_final(t10);
|
|
|
|
assign_final(t11_t12);
|
|
|
|
#undef assign_final
|
|
|
|
|
2014-10-17 02:27:30 +08:00
|
|
|
#define get_delay(field) (DIV_ROUND_UP(final->field, 10))
|
2012-10-21 02:57:45 +08:00
|
|
|
intel_dp->panel_power_up_delay = get_delay(t1_t3);
|
|
|
|
intel_dp->backlight_on_delay = get_delay(t8);
|
|
|
|
intel_dp->backlight_off_delay = get_delay(t9);
|
|
|
|
intel_dp->panel_power_down_delay = get_delay(t10);
|
|
|
|
intel_dp->panel_power_cycle_delay = get_delay(t11_t12);
|
|
|
|
#undef get_delay
|
|
|
|
|
2013-01-16 16:53:40 +08:00
|
|
|
DRM_DEBUG_KMS("panel power up delay %d, power down delay %d, power cycle delay %d\n",
|
|
|
|
intel_dp->panel_power_up_delay, intel_dp->panel_power_down_delay,
|
|
|
|
intel_dp->panel_power_cycle_delay);
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("backlight on delay %d, off delay %d\n",
|
|
|
|
intel_dp->backlight_on_delay, intel_dp->backlight_off_delay);
|
2016-06-17 01:01:46 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We override the HW backlight delays to 1 because we do manual waits
|
|
|
|
* on them. For T8, even BSpec recommends doing it. For T9, if we
|
|
|
|
* don't do this, we'll end up waiting for the backlight off delay
|
|
|
|
* twice: once when we do the manual sleep, and once when we disable
|
|
|
|
* the panel and wait for the PP_STATUS bit to become zero.
|
|
|
|
*/
|
|
|
|
final->t8 = 1;
|
|
|
|
final->t9 = 1;
|
2013-01-16 16:53:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
intel_dp_init_panel_power_sequencer_registers(struct drm_device *dev,
|
2016-12-21 00:51:17 +08:00
|
|
|
struct intel_dp *intel_dp,
|
|
|
|
bool force_disable_vdd)
|
2013-01-16 16:53:40 +08:00
|
|
|
{
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2013-03-29 00:55:41 +08:00
|
|
|
u32 pp_on, pp_off, pp_div, port_sel = 0;
|
2016-03-02 23:22:13 +08:00
|
|
|
int div = dev_priv->rawclk_freq / 1000;
|
2016-06-16 21:37:21 +08:00
|
|
|
struct pps_registers regs;
|
2014-08-19 03:15:56 +08:00
|
|
|
enum port port = dp_to_dig_port(intel_dp)->port;
|
2014-10-17 02:27:30 +08:00
|
|
|
const struct edp_power_seq *seq = &intel_dp->pps_delays;
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2014-09-04 19:53:14 +08:00
|
|
|
lockdep_assert_held(&dev_priv->pps_mutex);
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2016-06-16 21:37:21 +08:00
|
|
|
intel_pps_get_registers(dev_priv, intel_dp, ®s);
|
2013-03-29 00:55:41 +08:00
|
|
|
|
2016-12-21 00:51:17 +08:00
|
|
|
/*
|
|
|
|
* On some VLV machines the BIOS can leave the VDD
|
|
|
|
* enabled even on power seqeuencers which aren't
|
|
|
|
* hooked up to any port. This would mess up the
|
|
|
|
* power domain tracking the first time we pick
|
|
|
|
* one of these power sequencers for use since
|
|
|
|
* edp_panel_vdd_on() would notice that the VDD was
|
|
|
|
* already on and therefore wouldn't grab the power
|
|
|
|
* domain reference. Disable VDD first to avoid this.
|
|
|
|
* This also avoids spuriously turning the VDD on as
|
|
|
|
* soon as the new power seqeuencer gets initialized.
|
|
|
|
*/
|
|
|
|
if (force_disable_vdd) {
|
|
|
|
u32 pp = ironlake_get_pp_control(intel_dp);
|
|
|
|
|
|
|
|
WARN(pp & PANEL_POWER_ON, "Panel power already on\n");
|
|
|
|
|
|
|
|
if (pp & EDP_FORCE_VDD)
|
|
|
|
DRM_DEBUG_KMS("VDD already on, disabling first\n");
|
|
|
|
|
|
|
|
pp &= ~EDP_FORCE_VDD;
|
|
|
|
|
|
|
|
I915_WRITE(regs.pp_ctrl, pp);
|
|
|
|
}
|
|
|
|
|
2013-01-16 16:53:40 +08:00
|
|
|
pp_on = (seq->t1_t3 << PANEL_POWER_UP_DELAY_SHIFT) |
|
2016-06-17 01:01:46 +08:00
|
|
|
(seq->t8 << PANEL_LIGHT_ON_DELAY_SHIFT);
|
|
|
|
pp_off = (seq->t9 << PANEL_LIGHT_OFF_DELAY_SHIFT) |
|
2013-01-16 16:53:40 +08:00
|
|
|
(seq->t10 << PANEL_POWER_DOWN_DELAY_SHIFT);
|
2012-10-21 02:57:45 +08:00
|
|
|
/* Compute the divisor for the pp clock, simply match the Bspec
|
|
|
|
* formula. */
|
2017-06-03 04:06:44 +08:00
|
|
|
if (IS_GEN9_LP(dev_priv) || HAS_PCH_CNP(dev_priv)) {
|
2016-06-16 21:37:21 +08:00
|
|
|
pp_div = I915_READ(regs.pp_ctrl);
|
2015-06-18 13:30:55 +08:00
|
|
|
pp_div &= ~BXT_POWER_CYCLE_DELAY_MASK;
|
2017-06-27 03:21:45 +08:00
|
|
|
pp_div |= (DIV_ROUND_UP(seq->t11_t12, 1000)
|
2015-06-18 13:30:55 +08:00
|
|
|
<< BXT_POWER_CYCLE_DELAY_SHIFT);
|
|
|
|
} else {
|
|
|
|
pp_div = ((100 * div)/2 - 1) << PP_REFERENCE_DIVIDER_SHIFT;
|
|
|
|
pp_div |= (DIV_ROUND_UP(seq->t11_t12, 1000)
|
|
|
|
<< PANEL_POWER_CYCLE_DELAY_SHIFT);
|
|
|
|
}
|
2012-10-21 02:57:45 +08:00
|
|
|
|
|
|
|
/* Haswell doesn't have any port selection bits for the panel
|
|
|
|
* power sequencer any more. */
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
|
2014-08-19 03:15:56 +08:00
|
|
|
port_sel = PANEL_PORT_SELECT_VLV(port);
|
2016-10-13 18:02:53 +08:00
|
|
|
} else if (HAS_PCH_IBX(dev_priv) || HAS_PCH_CPT(dev_priv)) {
|
2014-08-19 03:15:56 +08:00
|
|
|
if (port == PORT_A)
|
2013-09-05 21:44:46 +08:00
|
|
|
port_sel = PANEL_PORT_SELECT_DPA;
|
2012-10-21 02:57:45 +08:00
|
|
|
else
|
2013-09-05 21:44:46 +08:00
|
|
|
port_sel = PANEL_PORT_SELECT_DPD;
|
2012-10-21 02:57:45 +08:00
|
|
|
}
|
|
|
|
|
2013-03-29 00:55:41 +08:00
|
|
|
pp_on |= port_sel;
|
|
|
|
|
2016-06-16 21:37:21 +08:00
|
|
|
I915_WRITE(regs.pp_on, pp_on);
|
|
|
|
I915_WRITE(regs.pp_off, pp_off);
|
2017-06-03 04:06:44 +08:00
|
|
|
if (IS_GEN9_LP(dev_priv) || HAS_PCH_CNP(dev_priv))
|
2016-06-16 21:37:21 +08:00
|
|
|
I915_WRITE(regs.pp_ctrl, pp_div);
|
2015-06-18 13:30:55 +08:00
|
|
|
else
|
2016-06-16 21:37:21 +08:00
|
|
|
I915_WRITE(regs.pp_div, pp_div);
|
2012-10-21 02:57:45 +08:00
|
|
|
|
|
|
|
DRM_DEBUG_KMS("panel power sequencer register settings: PP_ON %#x, PP_OFF %#x, PP_DIV %#x\n",
|
2016-06-16 21:37:21 +08:00
|
|
|
I915_READ(regs.pp_on),
|
|
|
|
I915_READ(regs.pp_off),
|
2017-06-03 04:06:44 +08:00
|
|
|
(IS_GEN9_LP(dev_priv) || HAS_PCH_CNP(dev_priv)) ?
|
2016-06-16 21:37:21 +08:00
|
|
|
(I915_READ(regs.pp_ctrl) & BXT_POWER_CYCLE_DELAY_MASK) :
|
|
|
|
I915_READ(regs.pp_div));
|
2010-09-19 16:29:33 +08:00
|
|
|
}
|
|
|
|
|
2016-08-10 19:07:32 +08:00
|
|
|
static void intel_dp_pps_init(struct drm_device *dev,
|
|
|
|
struct intel_dp *intel_dp)
|
|
|
|
{
|
2016-10-14 17:13:44 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
|
|
|
|
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
|
2016-08-10 19:07:32 +08:00
|
|
|
vlv_initial_power_sequencer_setup(intel_dp);
|
|
|
|
} else {
|
|
|
|
intel_dp_init_panel_power_sequencer(dev, intel_dp);
|
2016-12-21 00:51:17 +08:00
|
|
|
intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, false);
|
2016-08-10 19:07:32 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-13 18:03:03 +08:00
|
|
|
/**
|
|
|
|
* intel_dp_set_drrs_state - program registers for RR switch to take effect
|
2016-08-31 17:01:36 +08:00
|
|
|
* @dev_priv: i915 device
|
2016-08-25 17:07:02 +08:00
|
|
|
* @crtc_state: a pointer to the active intel_crtc_state
|
2015-02-13 18:03:03 +08:00
|
|
|
* @refresh_rate: RR to be programmed
|
|
|
|
*
|
|
|
|
* This function gets called when refresh rate (RR) has to be changed from
|
|
|
|
* one frequency to another. Switches can be between high and low RR
|
|
|
|
* supported by the panel or to any other RR based on media playback (in
|
|
|
|
* this case, RR value needs to be passed from user space).
|
|
|
|
*
|
|
|
|
* The caller of this function needs to take a lock on dev_priv->drrs.
|
|
|
|
*/
|
2016-08-09 23:04:13 +08:00
|
|
|
static void intel_dp_set_drrs_state(struct drm_i915_private *dev_priv,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *crtc_state,
|
2016-08-09 23:04:13 +08:00
|
|
|
int refresh_rate)
|
2014-04-05 14:43:28 +08:00
|
|
|
{
|
|
|
|
struct intel_encoder *encoder;
|
2015-01-10 04:55:56 +08:00
|
|
|
struct intel_digital_port *dig_port = NULL;
|
|
|
|
struct intel_dp *intel_dp = dev_priv->drrs.dp;
|
2016-08-09 23:04:13 +08:00
|
|
|
struct intel_crtc *intel_crtc = to_intel_crtc(crtc_state->base.crtc);
|
2015-01-10 04:55:56 +08:00
|
|
|
enum drrs_refresh_rate_type index = DRRS_HIGH_RR;
|
2014-04-05 14:43:28 +08:00
|
|
|
|
|
|
|
if (refresh_rate <= 0) {
|
|
|
|
DRM_DEBUG_KMS("Refresh rate should be positive non-zero.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-10 04:55:56 +08:00
|
|
|
if (intel_dp == NULL) {
|
|
|
|
DRM_DEBUG_KMS("DRRS not supported.\n");
|
2014-04-05 14:43:28 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-10 04:55:56 +08:00
|
|
|
dig_port = dp_to_dig_port(intel_dp);
|
|
|
|
encoder = &dig_port->base;
|
2015-03-20 22:18:18 +08:00
|
|
|
intel_crtc = to_intel_crtc(encoder->base.crtc);
|
2014-04-05 14:43:28 +08:00
|
|
|
|
|
|
|
if (!intel_crtc) {
|
|
|
|
DRM_DEBUG_KMS("DRRS: intel_crtc not initialized\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-10 04:55:56 +08:00
|
|
|
if (dev_priv->drrs.type < SEAMLESS_DRRS_SUPPORT) {
|
2014-04-05 14:43:28 +08:00
|
|
|
DRM_DEBUG_KMS("Only Seamless DRRS supported.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-10 04:55:56 +08:00
|
|
|
if (intel_dp->attached_connector->panel.downclock_mode->vrefresh ==
|
|
|
|
refresh_rate)
|
2014-04-05 14:43:28 +08:00
|
|
|
index = DRRS_LOW_RR;
|
|
|
|
|
2015-01-10 04:55:56 +08:00
|
|
|
if (index == dev_priv->drrs.refresh_rate_type) {
|
2014-04-05 14:43:28 +08:00
|
|
|
DRM_DEBUG_KMS(
|
|
|
|
"DRRS requested for previously set RR...ignoring\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
if (!crtc_state->base.active) {
|
2014-04-05 14:43:28 +08:00
|
|
|
DRM_DEBUG_KMS("eDP encoder disabled. CRTC not Active\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
if (INTEL_GEN(dev_priv) >= 8 && !IS_CHERRYVIEW(dev_priv)) {
|
2015-02-13 18:03:00 +08:00
|
|
|
switch (index) {
|
|
|
|
case DRRS_HIGH_RR:
|
|
|
|
intel_dp_set_m_n(intel_crtc, M1_N1);
|
|
|
|
break;
|
|
|
|
case DRRS_LOW_RR:
|
|
|
|
intel_dp_set_m_n(intel_crtc, M2_N2);
|
|
|
|
break;
|
|
|
|
case DRRS_MAX_RR:
|
|
|
|
default:
|
|
|
|
DRM_ERROR("Unsupported refreshrate type\n");
|
|
|
|
}
|
2016-08-09 23:04:13 +08:00
|
|
|
} else if (INTEL_GEN(dev_priv) > 6) {
|
|
|
|
i915_reg_t reg = PIPECONF(crtc_state->cpu_transcoder);
|
2015-09-23 00:50:01 +08:00
|
|
|
u32 val;
|
2015-02-13 18:03:00 +08:00
|
|
|
|
2015-09-23 00:50:01 +08:00
|
|
|
val = I915_READ(reg);
|
2014-04-05 14:43:28 +08:00
|
|
|
if (index > DRRS_HIGH_RR) {
|
2016-08-09 23:04:13 +08:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
|
2015-02-13 18:03:01 +08:00
|
|
|
val |= PIPECONF_EDP_RR_MODE_SWITCH_VLV;
|
|
|
|
else
|
|
|
|
val |= PIPECONF_EDP_RR_MODE_SWITCH;
|
2014-04-05 14:43:28 +08:00
|
|
|
} else {
|
2016-08-09 23:04:13 +08:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
|
2015-02-13 18:03:01 +08:00
|
|
|
val &= ~PIPECONF_EDP_RR_MODE_SWITCH_VLV;
|
|
|
|
else
|
|
|
|
val &= ~PIPECONF_EDP_RR_MODE_SWITCH;
|
2014-04-05 14:43:28 +08:00
|
|
|
}
|
|
|
|
I915_WRITE(reg, val);
|
|
|
|
}
|
|
|
|
|
2015-01-22 17:44:45 +08:00
|
|
|
dev_priv->drrs.refresh_rate_type = index;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("eDP Refresh Rate set to : %dHz\n", refresh_rate);
|
|
|
|
}
|
|
|
|
|
2015-02-13 18:03:03 +08:00
|
|
|
/**
|
|
|
|
* intel_edp_drrs_enable - init drrs struct if supported
|
|
|
|
* @intel_dp: DP struct
|
2016-08-31 17:01:36 +08:00
|
|
|
* @crtc_state: A pointer to the active crtc state.
|
2015-02-13 18:03:03 +08:00
|
|
|
*
|
|
|
|
* Initializes frontbuffer_bits and drrs.dp
|
|
|
|
*/
|
2016-08-09 23:04:13 +08:00
|
|
|
void intel_edp_drrs_enable(struct intel_dp *intel_dp,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *crtc_state)
|
2015-01-22 17:47:40 +08:00
|
|
|
{
|
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2015-01-22 17:47:40 +08:00
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
if (!crtc_state->has_drrs) {
|
2015-01-22 17:47:40 +08:00
|
|
|
DRM_DEBUG_KMS("Panel doesn't support DRRS\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-09-15 02:16:41 +08:00
|
|
|
if (dev_priv->psr.enabled) {
|
|
|
|
DRM_DEBUG_KMS("PSR enabled. Not enabling DRRS.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-22 17:47:40 +08:00
|
|
|
mutex_lock(&dev_priv->drrs.mutex);
|
|
|
|
if (WARN_ON(dev_priv->drrs.dp)) {
|
|
|
|
DRM_ERROR("DRRS already enabled\n");
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_priv->drrs.busy_frontbuffer_bits = 0;
|
|
|
|
|
|
|
|
dev_priv->drrs.dp = intel_dp;
|
|
|
|
|
|
|
|
unlock:
|
|
|
|
mutex_unlock(&dev_priv->drrs.mutex);
|
|
|
|
}
|
|
|
|
|
2015-02-13 18:03:03 +08:00
|
|
|
/**
|
|
|
|
* intel_edp_drrs_disable - Disable DRRS
|
|
|
|
* @intel_dp: DP struct
|
2016-08-31 17:01:36 +08:00
|
|
|
* @old_crtc_state: Pointer to old crtc_state.
|
2015-02-13 18:03:03 +08:00
|
|
|
*
|
|
|
|
*/
|
2016-08-09 23:04:13 +08:00
|
|
|
void intel_edp_drrs_disable(struct intel_dp *intel_dp,
|
2017-08-18 21:49:58 +08:00
|
|
|
const struct intel_crtc_state *old_crtc_state)
|
2015-01-22 17:47:40 +08:00
|
|
|
{
|
|
|
|
struct drm_device *dev = intel_dp_to_dev(intel_dp);
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2015-01-22 17:47:40 +08:00
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
if (!old_crtc_state->has_drrs)
|
2015-01-22 17:47:40 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&dev_priv->drrs.mutex);
|
|
|
|
if (!dev_priv->drrs.dp) {
|
|
|
|
mutex_unlock(&dev_priv->drrs.mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev_priv->drrs.refresh_rate_type == DRRS_LOW_RR)
|
2016-08-09 23:04:13 +08:00
|
|
|
intel_dp_set_drrs_state(dev_priv, old_crtc_state,
|
|
|
|
intel_dp->attached_connector->panel.fixed_mode->vrefresh);
|
2015-01-22 17:47:40 +08:00
|
|
|
|
|
|
|
dev_priv->drrs.dp = NULL;
|
|
|
|
mutex_unlock(&dev_priv->drrs.mutex);
|
|
|
|
|
|
|
|
cancel_delayed_work_sync(&dev_priv->drrs.work);
|
|
|
|
}
|
|
|
|
|
2015-01-22 17:44:45 +08:00
|
|
|
static void intel_edp_drrs_downclock_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv =
|
|
|
|
container_of(work, typeof(*dev_priv), drrs.work.work);
|
|
|
|
struct intel_dp *intel_dp;
|
|
|
|
|
|
|
|
mutex_lock(&dev_priv->drrs.mutex);
|
|
|
|
|
|
|
|
intel_dp = dev_priv->drrs.dp;
|
|
|
|
|
|
|
|
if (!intel_dp)
|
|
|
|
goto unlock;
|
|
|
|
|
2014-04-05 14:43:28 +08:00
|
|
|
/*
|
2015-01-22 17:44:45 +08:00
|
|
|
* The delayed work can race with an invalidate hence we need to
|
|
|
|
* recheck.
|
2014-04-05 14:43:28 +08:00
|
|
|
*/
|
|
|
|
|
2015-01-22 17:44:45 +08:00
|
|
|
if (dev_priv->drrs.busy_frontbuffer_bits)
|
|
|
|
goto unlock;
|
2014-04-05 14:43:28 +08:00
|
|
|
|
2016-08-09 23:04:13 +08:00
|
|
|
if (dev_priv->drrs.refresh_rate_type != DRRS_LOW_RR) {
|
|
|
|
struct drm_crtc *crtc = dp_to_dig_port(intel_dp)->base.base.crtc;
|
|
|
|
|
|
|
|
intel_dp_set_drrs_state(dev_priv, to_intel_crtc(crtc)->config,
|
|
|
|
intel_dp->attached_connector->panel.downclock_mode->vrefresh);
|
|
|
|
}
|
2014-04-05 14:43:28 +08:00
|
|
|
|
2015-01-22 17:44:45 +08:00
|
|
|
unlock:
|
|
|
|
mutex_unlock(&dev_priv->drrs.mutex);
|
2014-04-05 14:43:28 +08:00
|
|
|
}
|
|
|
|
|
2015-02-13 18:03:03 +08:00
|
|
|
/**
|
2015-06-15 23:20:05 +08:00
|
|
|
* intel_edp_drrs_invalidate - Disable Idleness DRRS
|
2016-08-04 23:32:38 +08:00
|
|
|
* @dev_priv: i915 device
|
2015-02-13 18:03:03 +08:00
|
|
|
* @frontbuffer_bits: frontbuffer plane tracking bits
|
|
|
|
*
|
2015-06-15 23:20:05 +08:00
|
|
|
* This function gets called everytime rendering on the given planes start.
|
|
|
|
* Hence DRRS needs to be Upclocked, i.e. (LOW_RR -> HIGH_RR).
|
2015-02-13 18:03:03 +08:00
|
|
|
*
|
|
|
|
* Dirty frontbuffers relevant to DRRS are tracked in busy_frontbuffer_bits.
|
|
|
|
*/
|
2016-08-04 23:32:38 +08:00
|
|
|
void intel_edp_drrs_invalidate(struct drm_i915_private *dev_priv,
|
|
|
|
unsigned int frontbuffer_bits)
|
2015-01-10 04:55:59 +08:00
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
enum pipe pipe;
|
|
|
|
|
2015-04-09 22:44:15 +08:00
|
|
|
if (dev_priv->drrs.type == DRRS_NOT_SUPPORTED)
|
2015-01-10 04:55:59 +08:00
|
|
|
return;
|
|
|
|
|
2015-04-09 22:44:16 +08:00
|
|
|
cancel_delayed_work(&dev_priv->drrs.work);
|
2015-03-03 14:41:46 +08:00
|
|
|
|
2015-01-10 04:55:59 +08:00
|
|
|
mutex_lock(&dev_priv->drrs.mutex);
|
2015-04-09 22:44:15 +08:00
|
|
|
if (!dev_priv->drrs.dp) {
|
|
|
|
mutex_unlock(&dev_priv->drrs.mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-10 04:55:59 +08:00
|
|
|
crtc = dp_to_dig_port(dev_priv->drrs.dp)->base.base.crtc;
|
|
|
|
pipe = to_intel_crtc(crtc)->pipe;
|
|
|
|
|
2015-06-18 16:30:25 +08:00
|
|
|
frontbuffer_bits &= INTEL_FRONTBUFFER_ALL_MASK(pipe);
|
|
|
|
dev_priv->drrs.busy_frontbuffer_bits |= frontbuffer_bits;
|
|
|
|
|
2015-06-15 23:20:05 +08:00
|
|
|
/* invalidate means busy screen hence upclock */
|
2015-06-18 16:30:25 +08:00
|
|
|
if (frontbuffer_bits && dev_priv->drrs.refresh_rate_type == DRRS_LOW_RR)
|
2016-08-09 23:04:13 +08:00
|
|
|
intel_dp_set_drrs_state(dev_priv, to_intel_crtc(crtc)->config,
|
|
|
|
dev_priv->drrs.dp->attached_connector->panel.fixed_mode->vrefresh);
|
2015-01-10 04:55:59 +08:00
|
|
|
|
|
|
|
mutex_unlock(&dev_priv->drrs.mutex);
|
|
|
|
}
|
|
|
|
|
2015-02-13 18:03:03 +08:00
|
|
|
/**
|
2015-06-15 23:20:05 +08:00
|
|
|
* intel_edp_drrs_flush - Restart Idleness DRRS
|
2016-08-04 23:32:38 +08:00
|
|
|
* @dev_priv: i915 device
|
2015-02-13 18:03:03 +08:00
|
|
|
* @frontbuffer_bits: frontbuffer plane tracking bits
|
|
|
|
*
|
2015-06-15 23:20:05 +08:00
|
|
|
* This function gets called every time rendering on the given planes has
|
|
|
|
* completed or flip on a crtc is completed. So DRRS should be upclocked
|
|
|
|
* (LOW_RR -> HIGH_RR). And also Idleness detection should be started again,
|
|
|
|
* if no other planes are dirty.
|
2015-02-13 18:03:03 +08:00
|
|
|
*
|
|
|
|
* Dirty frontbuffers relevant to DRRS are tracked in busy_frontbuffer_bits.
|
|
|
|
*/
|
2016-08-04 23:32:38 +08:00
|
|
|
void intel_edp_drrs_flush(struct drm_i915_private *dev_priv,
|
|
|
|
unsigned int frontbuffer_bits)
|
2015-01-10 04:55:59 +08:00
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
enum pipe pipe;
|
|
|
|
|
2015-04-09 22:44:15 +08:00
|
|
|
if (dev_priv->drrs.type == DRRS_NOT_SUPPORTED)
|
2015-01-10 04:55:59 +08:00
|
|
|
return;
|
|
|
|
|
2015-04-09 22:44:16 +08:00
|
|
|
cancel_delayed_work(&dev_priv->drrs.work);
|
2015-03-03 14:41:46 +08:00
|
|
|
|
2015-01-10 04:55:59 +08:00
|
|
|
mutex_lock(&dev_priv->drrs.mutex);
|
2015-04-09 22:44:15 +08:00
|
|
|
if (!dev_priv->drrs.dp) {
|
|
|
|
mutex_unlock(&dev_priv->drrs.mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-10 04:55:59 +08:00
|
|
|
crtc = dp_to_dig_port(dev_priv->drrs.dp)->base.base.crtc;
|
|
|
|
pipe = to_intel_crtc(crtc)->pipe;
|
2015-06-18 16:30:25 +08:00
|
|
|
|
|
|
|
frontbuffer_bits &= INTEL_FRONTBUFFER_ALL_MASK(pipe);
|
2015-01-10 04:55:59 +08:00
|
|
|
dev_priv->drrs.busy_frontbuffer_bits &= ~frontbuffer_bits;
|
|
|
|
|
2015-06-15 23:20:05 +08:00
|
|
|
/* flush means busy screen hence upclock */
|
2015-06-18 16:30:25 +08:00
|
|
|
if (frontbuffer_bits && dev_priv->drrs.refresh_rate_type == DRRS_LOW_RR)
|
2016-08-09 23:04:13 +08:00
|
|
|
intel_dp_set_drrs_state(dev_priv, to_intel_crtc(crtc)->config,
|
|
|
|
dev_priv->drrs.dp->attached_connector->panel.fixed_mode->vrefresh);
|
2015-06-15 23:20:05 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* flush also means no more activity hence schedule downclock, if all
|
|
|
|
* other fbs are quiescent too
|
|
|
|
*/
|
|
|
|
if (!dev_priv->drrs.busy_frontbuffer_bits)
|
2015-01-10 04:55:59 +08:00
|
|
|
schedule_delayed_work(&dev_priv->drrs.work,
|
|
|
|
msecs_to_jiffies(1000));
|
|
|
|
mutex_unlock(&dev_priv->drrs.mutex);
|
|
|
|
}
|
|
|
|
|
2015-02-13 18:03:03 +08:00
|
|
|
/**
|
|
|
|
* DOC: Display Refresh Rate Switching (DRRS)
|
|
|
|
*
|
|
|
|
* Display Refresh Rate Switching (DRRS) is a power conservation feature
|
|
|
|
* which enables swtching between low and high refresh rates,
|
|
|
|
* dynamically, based on the usage scenario. This feature is applicable
|
|
|
|
* for internal panels.
|
|
|
|
*
|
|
|
|
* Indication that the panel supports DRRS is given by the panel EDID, which
|
|
|
|
* would list multiple refresh rates for one resolution.
|
|
|
|
*
|
|
|
|
* DRRS is of 2 types - static and seamless.
|
|
|
|
* Static DRRS involves changing refresh rate (RR) by doing a full modeset
|
|
|
|
* (may appear as a blink on screen) and is used in dock-undock scenario.
|
|
|
|
* Seamless DRRS involves changing RR without any visual effect to the user
|
|
|
|
* and can be used during normal system usage. This is done by programming
|
|
|
|
* certain registers.
|
|
|
|
*
|
|
|
|
* Support for static/seamless DRRS may be indicated in the VBT based on
|
|
|
|
* inputs from the panel spec.
|
|
|
|
*
|
|
|
|
* DRRS saves power by switching to low RR based on usage scenarios.
|
|
|
|
*
|
2016-06-02 05:40:36 +08:00
|
|
|
* The implementation is based on frontbuffer tracking implementation. When
|
|
|
|
* there is a disturbance on the screen triggered by user activity or a periodic
|
|
|
|
* system activity, DRRS is disabled (RR is changed to high RR). When there is
|
|
|
|
* no movement on screen, after a timeout of 1 second, a switch to low RR is
|
|
|
|
* made.
|
|
|
|
*
|
|
|
|
* For integration with frontbuffer tracking code, intel_edp_drrs_invalidate()
|
|
|
|
* and intel_edp_drrs_flush() are called.
|
2015-02-13 18:03:03 +08:00
|
|
|
*
|
|
|
|
* DRRS can be further extended to support other internal panels and also
|
|
|
|
* the scenario of video playback wherein RR is set based on the rate
|
|
|
|
* requested by userspace.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* intel_dp_drrs_init - Init basic DRRS work and mutex.
|
|
|
|
* @intel_connector: eDP connector
|
|
|
|
* @fixed_mode: preferred mode of panel
|
|
|
|
*
|
|
|
|
* This function is called only once at driver load to initialize basic
|
|
|
|
* DRRS stuff.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Downclock mode if panel supports it, else return NULL.
|
|
|
|
* DRRS support is determined by the presence of downclock mode (apart
|
|
|
|
* from VBT setting).
|
|
|
|
*/
|
2014-04-05 14:42:31 +08:00
|
|
|
static struct drm_display_mode *
|
2015-01-10 04:55:56 +08:00
|
|
|
intel_dp_drrs_init(struct intel_connector *intel_connector,
|
|
|
|
struct drm_display_mode *fixed_mode)
|
2014-04-05 14:42:31 +08:00
|
|
|
{
|
|
|
|
struct drm_connector *connector = &intel_connector->base;
|
2015-01-10 04:55:56 +08:00
|
|
|
struct drm_device *dev = connector->dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-04-05 14:42:31 +08:00
|
|
|
struct drm_display_mode *downclock_mode = NULL;
|
|
|
|
|
2015-04-09 22:44:15 +08:00
|
|
|
INIT_DELAYED_WORK(&dev_priv->drrs.work, intel_edp_drrs_downclock_work);
|
|
|
|
mutex_init(&dev_priv->drrs.mutex);
|
|
|
|
|
2016-11-16 16:55:41 +08:00
|
|
|
if (INTEL_GEN(dev_priv) <= 6) {
|
2014-04-05 14:42:31 +08:00
|
|
|
DRM_DEBUG_KMS("DRRS supported for Gen7 and above\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev_priv->vbt.drrs_type != SEAMLESS_DRRS_SUPPORT) {
|
2014-08-05 17:39:42 +08:00
|
|
|
DRM_DEBUG_KMS("VBT doesn't support DRRS\n");
|
2014-04-05 14:42:31 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
downclock_mode = intel_find_panel_downclock
|
2016-12-13 16:02:48 +08:00
|
|
|
(dev_priv, fixed_mode, connector);
|
2014-04-05 14:42:31 +08:00
|
|
|
|
|
|
|
if (!downclock_mode) {
|
2015-02-23 20:08:33 +08:00
|
|
|
DRM_DEBUG_KMS("Downclock mode is not found. DRRS not supported\n");
|
2014-04-05 14:42:31 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-01-10 04:55:56 +08:00
|
|
|
dev_priv->drrs.type = dev_priv->vbt.drrs_type;
|
2014-04-05 14:42:31 +08:00
|
|
|
|
2015-01-10 04:55:56 +08:00
|
|
|
dev_priv->drrs.refresh_rate_type = DRRS_HIGH_RR;
|
2014-08-05 17:39:42 +08:00
|
|
|
DRM_DEBUG_KMS("seamless DRRS supported for eDP panel.\n");
|
2014-04-05 14:42:31 +08:00
|
|
|
return downclock_mode;
|
|
|
|
}
|
|
|
|
|
2013-06-13 04:27:24 +08:00
|
|
|
static bool intel_edp_init_connector(struct intel_dp *intel_dp,
|
2014-10-17 02:27:30 +08:00
|
|
|
struct intel_connector *intel_connector)
|
2013-06-13 04:27:24 +08:00
|
|
|
{
|
|
|
|
struct drm_connector *connector = &intel_connector->base;
|
|
|
|
struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
|
2014-04-23 06:55:42 +08:00
|
|
|
struct intel_encoder *intel_encoder = &intel_dig_port->base;
|
|
|
|
struct drm_device *dev = intel_encoder->base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2013-06-13 04:27:24 +08:00
|
|
|
struct drm_display_mode *fixed_mode = NULL;
|
2017-08-10 03:48:53 +08:00
|
|
|
struct drm_display_mode *alt_fixed_mode = NULL;
|
2014-04-05 14:42:31 +08:00
|
|
|
struct drm_display_mode *downclock_mode = NULL;
|
2013-06-13 04:27:24 +08:00
|
|
|
bool has_dpcd;
|
|
|
|
struct drm_display_mode *scan;
|
|
|
|
struct edid *edid;
|
2014-11-07 17:16:02 +08:00
|
|
|
enum pipe pipe = INVALID_PIPE;
|
2013-06-13 04:27:24 +08:00
|
|
|
|
2017-08-18 17:30:20 +08:00
|
|
|
if (!intel_dp_is_edp(intel_dp))
|
2013-06-13 04:27:24 +08:00
|
|
|
return true;
|
|
|
|
|
2016-06-21 16:51:47 +08:00
|
|
|
/*
|
|
|
|
* On IBX/CPT we may get here with LVDS already registered. Since the
|
|
|
|
* driver uses the only internal power sequencer available for both
|
|
|
|
* eDP and LVDS bail out early in this case to prevent interfering
|
|
|
|
* with an already powered-on LVDS power sequencer.
|
|
|
|
*/
|
|
|
|
if (intel_get_lvds_encoder(dev)) {
|
|
|
|
WARN_ON(!(HAS_PCH_IBX(dev_priv) || HAS_PCH_CPT(dev_priv)));
|
|
|
|
DRM_INFO("LVDS was detected, not registering eDP\n");
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-10-28 22:15:52 +08:00
|
|
|
pps_lock(intel_dp);
|
2016-06-21 16:51:49 +08:00
|
|
|
|
|
|
|
intel_dp_init_panel_power_timestamps(intel_dp);
|
2016-08-10 19:07:32 +08:00
|
|
|
intel_dp_pps_init(dev, intel_dp);
|
2014-10-28 22:15:52 +08:00
|
|
|
intel_edp_panel_vdd_sanitize(intel_dp);
|
2016-06-21 16:51:49 +08:00
|
|
|
|
2014-10-28 22:15:52 +08:00
|
|
|
pps_unlock(intel_dp);
|
2014-04-23 06:55:42 +08:00
|
|
|
|
2013-06-13 04:27:24 +08:00
|
|
|
/* Cache DPCD and EDID for edp. */
|
2016-07-29 21:52:39 +08:00
|
|
|
has_dpcd = intel_edp_init_dpcd(intel_dp);
|
2013-06-13 04:27:24 +08:00
|
|
|
|
2016-07-29 21:52:39 +08:00
|
|
|
if (!has_dpcd) {
|
2013-06-13 04:27:24 +08:00
|
|
|
/* if this fails, presume the device is a ghost */
|
|
|
|
DRM_INFO("failed to retrieve link info, disabling eDP\n");
|
2016-06-21 16:51:49 +08:00
|
|
|
goto out_vdd_off;
|
2013-06-13 04:27:24 +08:00
|
|
|
}
|
|
|
|
|
2014-03-22 06:22:35 +08:00
|
|
|
mutex_lock(&dev->mode_config.mutex);
|
2014-03-14 22:51:17 +08:00
|
|
|
edid = drm_get_edid(connector, &intel_dp->aux.ddc);
|
2013-06-13 04:27:24 +08:00
|
|
|
if (edid) {
|
|
|
|
if (drm_add_edid_modes(connector, edid)) {
|
|
|
|
drm_mode_connector_update_edid_property(connector,
|
|
|
|
edid);
|
|
|
|
drm_edid_to_eld(connector, edid);
|
|
|
|
} else {
|
|
|
|
kfree(edid);
|
|
|
|
edid = ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
edid = ERR_PTR(-ENOENT);
|
|
|
|
}
|
|
|
|
intel_connector->edid = edid;
|
|
|
|
|
2017-08-10 03:48:53 +08:00
|
|
|
/* prefer fixed mode from EDID if available, save an alt mode also */
|
2013-06-13 04:27:24 +08:00
|
|
|
list_for_each_entry(scan, &connector->probed_modes, head) {
|
|
|
|
if ((scan->type & DRM_MODE_TYPE_PREFERRED)) {
|
|
|
|
fixed_mode = drm_mode_duplicate(dev, scan);
|
2014-04-05 14:42:31 +08:00
|
|
|
downclock_mode = intel_dp_drrs_init(
|
|
|
|
intel_connector, fixed_mode);
|
2017-08-10 03:48:53 +08:00
|
|
|
} else if (!alt_fixed_mode) {
|
|
|
|
alt_fixed_mode = drm_mode_duplicate(dev, scan);
|
2013-06-13 04:27:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fallback to VBT if available for eDP */
|
|
|
|
if (!fixed_mode && dev_priv->vbt.lfp_lvds_vbt_mode) {
|
|
|
|
fixed_mode = drm_mode_duplicate(dev,
|
|
|
|
dev_priv->vbt.lfp_lvds_vbt_mode);
|
2016-05-31 17:08:34 +08:00
|
|
|
if (fixed_mode) {
|
2013-06-13 04:27:24 +08:00
|
|
|
fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
|
2016-05-31 17:08:34 +08:00
|
|
|
connector->display_info.width_mm = fixed_mode->width_mm;
|
|
|
|
connector->display_info.height_mm = fixed_mode->height_mm;
|
|
|
|
}
|
2013-06-13 04:27:24 +08:00
|
|
|
}
|
2014-03-22 06:22:35 +08:00
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
2013-06-13 04:27:24 +08:00
|
|
|
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
|
2014-07-08 04:01:46 +08:00
|
|
|
intel_dp->edp_notifier.notifier_call = edp_notify_handler;
|
|
|
|
register_reboot_notifier(&intel_dp->edp_notifier);
|
2014-11-07 17:16:02 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Figure out the current pipe for the initial backlight setup.
|
|
|
|
* If the current pipe isn't valid, try the PPS pipe, and if that
|
|
|
|
* fails just assume pipe A.
|
|
|
|
*/
|
2016-12-15 02:00:23 +08:00
|
|
|
pipe = vlv_active_pipe(intel_dp);
|
2014-11-07 17:16:02 +08:00
|
|
|
|
|
|
|
if (pipe != PIPE_A && pipe != PIPE_B)
|
|
|
|
pipe = intel_dp->pps_pipe;
|
|
|
|
|
|
|
|
if (pipe != PIPE_A && pipe != PIPE_B)
|
|
|
|
pipe = PIPE_A;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("using pipe %c for initial backlight setup\n",
|
|
|
|
pipe_name(pipe));
|
2014-07-08 04:01:46 +08:00
|
|
|
}
|
|
|
|
|
2017-08-10 03:48:53 +08:00
|
|
|
intel_panel_init(&intel_connector->panel, fixed_mode, alt_fixed_mode,
|
|
|
|
downclock_mode);
|
2015-09-14 19:03:48 +08:00
|
|
|
intel_connector->panel.backlight.power = intel_edp_backlight_power;
|
2014-11-07 17:16:02 +08:00
|
|
|
intel_panel_setup_backlight(connector, pipe);
|
2013-06-13 04:27:24 +08:00
|
|
|
|
|
|
|
return true;
|
2016-06-21 16:51:49 +08:00
|
|
|
|
|
|
|
out_vdd_off:
|
|
|
|
cancel_delayed_work_sync(&intel_dp->panel_vdd_work);
|
|
|
|
/*
|
|
|
|
* vdd might still be enabled do to the delayed vdd off.
|
|
|
|
* Make sure vdd is actually turned off here.
|
|
|
|
*/
|
|
|
|
pps_lock(intel_dp);
|
|
|
|
edp_panel_vdd_off_sync(intel_dp);
|
|
|
|
pps_unlock(intel_dp);
|
|
|
|
|
|
|
|
return false;
|
2013-06-13 04:27:24 +08:00
|
|
|
}
|
|
|
|
|
2017-02-22 14:34:26 +08:00
|
|
|
/* Set up the hotplug pin and aux power domain. */
|
2017-02-03 22:03:14 +08:00
|
|
|
static void
|
|
|
|
intel_dp_init_connector_port_info(struct intel_digital_port *intel_dig_port)
|
|
|
|
{
|
|
|
|
struct intel_encoder *encoder = &intel_dig_port->base;
|
2017-02-22 14:34:26 +08:00
|
|
|
struct intel_dp *intel_dp = &intel_dig_port->dp;
|
2017-02-03 22:03:14 +08:00
|
|
|
|
2017-08-12 02:26:50 +08:00
|
|
|
encoder->hpd_pin = intel_hpd_pin(intel_dig_port->port);
|
|
|
|
|
2017-02-03 22:03:14 +08:00
|
|
|
switch (intel_dig_port->port) {
|
|
|
|
case PORT_A:
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_dp->aux_power_domain = POWER_DOMAIN_AUX_A;
|
2017-02-03 22:03:14 +08:00
|
|
|
break;
|
|
|
|
case PORT_B:
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_dp->aux_power_domain = POWER_DOMAIN_AUX_B;
|
2017-02-03 22:03:14 +08:00
|
|
|
break;
|
|
|
|
case PORT_C:
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_dp->aux_power_domain = POWER_DOMAIN_AUX_C;
|
2017-02-03 22:03:14 +08:00
|
|
|
break;
|
|
|
|
case PORT_D:
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_dp->aux_power_domain = POWER_DOMAIN_AUX_D;
|
2017-02-03 22:03:14 +08:00
|
|
|
break;
|
|
|
|
case PORT_E:
|
2017-02-22 14:34:26 +08:00
|
|
|
/* FIXME: Check VBT for actual wiring of PORT E */
|
|
|
|
intel_dp->aux_power_domain = POWER_DOMAIN_AUX_D;
|
2017-02-03 22:03:14 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
MISSING_CASE(intel_dig_port->port);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-06 21:44:19 +08:00
|
|
|
static void intel_dp_modeset_retry_work_fn(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct intel_connector *intel_connector;
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
|
|
|
intel_connector = container_of(work, typeof(*intel_connector),
|
|
|
|
modeset_retry_work);
|
|
|
|
connector = &intel_connector->base;
|
|
|
|
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
|
|
|
|
connector->name);
|
|
|
|
|
|
|
|
/* Grab the locks before changing connector property*/
|
|
|
|
mutex_lock(&connector->dev->mode_config.mutex);
|
|
|
|
/* Set connector link status to BAD and send a Uevent to notify
|
|
|
|
* userspace to do a modeset.
|
|
|
|
*/
|
|
|
|
drm_mode_connector_set_link_status_property(connector,
|
|
|
|
DRM_MODE_LINK_STATUS_BAD);
|
|
|
|
mutex_unlock(&connector->dev->mode_config.mutex);
|
|
|
|
/* Send Hotplug uevent so userspace can reprobe */
|
|
|
|
drm_kms_helper_hotplug_event(connector->dev);
|
|
|
|
}
|
|
|
|
|
2013-06-13 04:27:25 +08:00
|
|
|
bool
|
2012-10-27 05:05:48 +08:00
|
|
|
intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
|
|
|
|
struct intel_connector *intel_connector)
|
2009-04-08 07:16:42 +08:00
|
|
|
{
|
2012-10-27 05:05:48 +08:00
|
|
|
struct drm_connector *connector = &intel_connector->base;
|
|
|
|
struct intel_dp *intel_dp = &intel_dig_port->dp;
|
|
|
|
struct intel_encoder *intel_encoder = &intel_dig_port->base;
|
|
|
|
struct drm_device *dev = intel_encoder->base.dev;
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2012-10-27 05:05:50 +08:00
|
|
|
enum port port = intel_dig_port->port;
|
2016-06-24 21:00:14 +08:00
|
|
|
int type;
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2017-04-06 21:44:19 +08:00
|
|
|
/* Initialize the work for modeset in case of link train failure */
|
|
|
|
INIT_WORK(&intel_connector->modeset_retry_work,
|
|
|
|
intel_dp_modeset_retry_work_fn);
|
|
|
|
|
2015-12-09 01:59:38 +08:00
|
|
|
if (WARN(intel_dig_port->max_lanes < 1,
|
|
|
|
"Not enough lanes (%d) for DP on port %c\n",
|
|
|
|
intel_dig_port->max_lanes, port_name(port)))
|
|
|
|
return false;
|
|
|
|
|
2017-03-28 22:59:04 +08:00
|
|
|
intel_dp_set_source_rates(intel_dp);
|
|
|
|
|
2017-02-08 08:54:11 +08:00
|
|
|
intel_dp->reset_link_params = true;
|
2014-09-04 19:54:20 +08:00
|
|
|
intel_dp->pps_pipe = INVALID_PIPE;
|
2016-12-15 02:00:23 +08:00
|
|
|
intel_dp->active_pipe = INVALID_PIPE;
|
2014-09-04 19:54:20 +08:00
|
|
|
|
2014-01-21 21:35:39 +08:00
|
|
|
/* intel_dp vfuncs */
|
2016-11-16 16:55:41 +08:00
|
|
|
if (INTEL_GEN(dev_priv) >= 9)
|
2014-01-21 00:00:59 +08:00
|
|
|
intel_dp->get_aux_clock_divider = skl_get_aux_clock_divider;
|
2016-10-13 18:03:00 +08:00
|
|
|
else if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv))
|
2014-01-21 21:35:39 +08:00
|
|
|
intel_dp->get_aux_clock_divider = hsw_get_aux_clock_divider;
|
2016-10-13 18:02:53 +08:00
|
|
|
else if (HAS_PCH_SPLIT(dev_priv))
|
2014-01-21 21:35:39 +08:00
|
|
|
intel_dp->get_aux_clock_divider = ilk_get_aux_clock_divider;
|
|
|
|
else
|
2016-03-02 23:22:14 +08:00
|
|
|
intel_dp->get_aux_clock_divider = g4x_get_aux_clock_divider;
|
2014-01-21 21:35:39 +08:00
|
|
|
|
2016-11-16 16:55:41 +08:00
|
|
|
if (INTEL_GEN(dev_priv) >= 9)
|
2014-01-21 00:01:00 +08:00
|
|
|
intel_dp->get_aux_send_ctl = skl_get_aux_send_ctl;
|
|
|
|
else
|
2016-03-02 23:22:14 +08:00
|
|
|
intel_dp->get_aux_send_ctl = g4x_get_aux_send_ctl;
|
2014-01-21 21:37:15 +08:00
|
|
|
|
2016-10-13 18:02:52 +08:00
|
|
|
if (HAS_DDI(dev_priv))
|
2015-10-23 18:01:49 +08:00
|
|
|
intel_dp->prepare_link_retrain = intel_ddi_prepare_link_retrain;
|
|
|
|
|
2012-09-07 04:15:42 +08:00
|
|
|
/* Preserve the current hw state. */
|
|
|
|
intel_dp->DP = I915_READ(intel_dp->output_reg);
|
2012-10-19 19:51:50 +08:00
|
|
|
intel_dp->attached_connector = intel_connector;
|
2011-02-12 18:33:12 +08:00
|
|
|
|
2017-08-18 17:30:19 +08:00
|
|
|
if (intel_dp_is_port_edp(dev_priv, port))
|
2010-07-17 02:46:28 +08:00
|
|
|
type = DRM_MODE_CONNECTOR_eDP;
|
2013-11-02 00:22:41 +08:00
|
|
|
else
|
|
|
|
type = DRM_MODE_CONNECTOR_DisplayPort;
|
2010-07-17 02:46:28 +08:00
|
|
|
|
2016-12-15 02:00:23 +08:00
|
|
|
if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
|
|
|
|
intel_dp->active_pipe = vlv_active_pipe(intel_dp);
|
|
|
|
|
2013-05-08 18:14:05 +08:00
|
|
|
/*
|
|
|
|
* For eDP we always set the encoder type to INTEL_OUTPUT_EDP, but
|
|
|
|
* for DP the encoder type can be set by the caller to
|
|
|
|
* INTEL_OUTPUT_UNKNOWN for DDI, so don't rewrite it.
|
|
|
|
*/
|
|
|
|
if (type == DRM_MODE_CONNECTOR_eDP)
|
|
|
|
intel_encoder->type = INTEL_OUTPUT_EDP;
|
|
|
|
|
2014-10-17 02:27:27 +08:00
|
|
|
/* eDP only on port B and/or C on vlv/chv */
|
2016-10-14 17:13:44 +08:00
|
|
|
if (WARN_ON((IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) &&
|
2017-08-18 17:30:20 +08:00
|
|
|
intel_dp_is_edp(intel_dp) &&
|
|
|
|
port != PORT_B && port != PORT_C))
|
2014-10-17 02:27:27 +08:00
|
|
|
return false;
|
|
|
|
|
2013-05-08 18:14:08 +08:00
|
|
|
DRM_DEBUG_KMS("Adding %s connector on port %c\n",
|
|
|
|
type == DRM_MODE_CONNECTOR_eDP ? "eDP" : "DP",
|
|
|
|
port_name(port));
|
|
|
|
|
2010-07-17 02:46:28 +08:00
|
|
|
drm_connector_init(dev, connector, &intel_dp_connector_funcs, type);
|
2009-04-08 07:16:42 +08:00
|
|
|
drm_connector_helper_add(connector, &intel_dp_connector_helper_funcs);
|
|
|
|
|
|
|
|
connector->interlace_allowed = true;
|
|
|
|
connector->doublescan_allowed = 0;
|
|
|
|
|
2017-02-22 14:34:26 +08:00
|
|
|
intel_dp_init_connector_port_info(intel_dig_port);
|
|
|
|
|
2016-09-09 19:10:52 +08:00
|
|
|
intel_dp_aux_init(intel_dp);
|
2016-06-24 21:00:14 +08:00
|
|
|
|
2012-10-27 05:05:48 +08:00
|
|
|
INIT_DELAYED_WORK(&intel_dp->panel_vdd_work,
|
2014-01-17 21:39:48 +08:00
|
|
|
edp_panel_vdd_work);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2010-09-09 23:20:55 +08:00
|
|
|
intel_connector_attach_encoder(intel_connector, intel_encoder);
|
2009-04-08 07:16:42 +08:00
|
|
|
|
2016-10-13 18:02:52 +08:00
|
|
|
if (HAS_DDI(dev_priv))
|
2012-10-27 05:05:51 +08:00
|
|
|
intel_connector->get_hw_state = intel_ddi_connector_get_hw_state;
|
|
|
|
else
|
|
|
|
intel_connector->get_hw_state = intel_connector_get_hw_state;
|
|
|
|
|
2014-05-02 12:02:48 +08:00
|
|
|
/* init MST on ports that can support it */
|
2017-08-18 17:30:20 +08:00
|
|
|
if (HAS_DP_MST(dev_priv) && !intel_dp_is_edp(intel_dp) &&
|
2015-05-18 22:10:01 +08:00
|
|
|
(port == PORT_B || port == PORT_C || port == PORT_D))
|
|
|
|
intel_dp_mst_encoder_init(intel_dig_port,
|
|
|
|
intel_connector->base.base.id);
|
2014-05-02 12:02:48 +08:00
|
|
|
|
2014-10-17 02:27:30 +08:00
|
|
|
if (!intel_edp_init_connector(intel_dp, intel_connector)) {
|
2015-11-12 02:34:11 +08:00
|
|
|
intel_dp_aux_fini(intel_dp);
|
|
|
|
intel_dp_mst_encoder_cleanup(intel_dig_port);
|
|
|
|
goto fail;
|
2013-06-13 04:27:26 +08:00
|
|
|
}
|
2009-07-24 01:00:32 +08:00
|
|
|
|
2010-09-19 16:29:33 +08:00
|
|
|
intel_dp_add_properties(intel_dp, connector);
|
|
|
|
|
2009-04-08 07:16:42 +08:00
|
|
|
/* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written
|
|
|
|
* 0xd. Failure to do so will result in spurious interrupts being
|
|
|
|
* generated on the port when a cable is not attached.
|
|
|
|
*/
|
2016-10-13 18:02:58 +08:00
|
|
|
if (IS_G4X(dev_priv) && !IS_GM45(dev_priv)) {
|
2009-04-08 07:16:42 +08:00
|
|
|
u32 temp = I915_READ(PEG_BAND_GAP_DATA);
|
|
|
|
I915_WRITE(PEG_BAND_GAP_DATA, (temp & ~0xf) | 0xd);
|
|
|
|
}
|
2013-06-13 04:27:25 +08:00
|
|
|
|
|
|
|
return true;
|
2015-11-12 02:34:11 +08:00
|
|
|
|
|
|
|
fail:
|
|
|
|
drm_connector_cleanup(connector);
|
|
|
|
|
|
|
|
return false;
|
2009-04-08 07:16:42 +08:00
|
|
|
}
|
2012-10-27 05:05:48 +08:00
|
|
|
|
2016-11-23 22:21:44 +08:00
|
|
|
bool intel_dp_init(struct drm_i915_private *dev_priv,
|
2016-06-01 15:27:50 +08:00
|
|
|
i915_reg_t output_reg,
|
|
|
|
enum port port)
|
2012-10-27 05:05:48 +08:00
|
|
|
{
|
|
|
|
struct intel_digital_port *intel_dig_port;
|
|
|
|
struct intel_encoder *intel_encoder;
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
struct intel_connector *intel_connector;
|
|
|
|
|
2013-09-19 18:18:32 +08:00
|
|
|
intel_dig_port = kzalloc(sizeof(*intel_dig_port), GFP_KERNEL);
|
2012-10-27 05:05:48 +08:00
|
|
|
if (!intel_dig_port)
|
2016-06-01 15:27:50 +08:00
|
|
|
return false;
|
2012-10-27 05:05:48 +08:00
|
|
|
|
2015-04-10 15:59:10 +08:00
|
|
|
intel_connector = intel_connector_alloc();
|
2015-10-08 21:57:59 +08:00
|
|
|
if (!intel_connector)
|
|
|
|
goto err_connector_alloc;
|
2012-10-27 05:05:48 +08:00
|
|
|
|
|
|
|
intel_encoder = &intel_dig_port->base;
|
|
|
|
encoder = &intel_encoder->base;
|
|
|
|
|
2016-11-23 22:21:44 +08:00
|
|
|
if (drm_encoder_init(&dev_priv->drm, &intel_encoder->base,
|
|
|
|
&intel_dp_enc_funcs, DRM_MODE_ENCODER_TMDS,
|
|
|
|
"DP %c", port_name(port)))
|
2015-10-08 21:58:00 +08:00
|
|
|
goto err_encoder_init;
|
2012-10-27 05:05:48 +08:00
|
|
|
|
2013-03-27 07:44:55 +08:00
|
|
|
intel_encoder->compute_config = intel_dp_compute_config;
|
2012-10-27 05:05:52 +08:00
|
|
|
intel_encoder->get_hw_state = intel_dp_get_hw_state;
|
2013-05-15 08:08:26 +08:00
|
|
|
intel_encoder->get_config = intel_dp_get_config;
|
2014-08-18 19:42:45 +08:00
|
|
|
intel_encoder->suspend = intel_dp_encoder_suspend;
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_CHERRYVIEW(dev_priv)) {
|
2014-04-09 18:29:05 +08:00
|
|
|
intel_encoder->pre_pll_enable = chv_dp_pre_pll_enable;
|
2014-04-09 18:28:20 +08:00
|
|
|
intel_encoder->pre_enable = chv_pre_enable_dp;
|
|
|
|
intel_encoder->enable = vlv_enable_dp;
|
2017-09-20 23:12:51 +08:00
|
|
|
intel_encoder->disable = vlv_disable_dp;
|
2014-04-09 18:29:00 +08:00
|
|
|
intel_encoder->post_disable = chv_post_disable_dp;
|
2015-07-09 04:45:49 +08:00
|
|
|
intel_encoder->post_pll_disable = chv_dp_post_pll_disable;
|
2016-10-13 18:03:08 +08:00
|
|
|
} else if (IS_VALLEYVIEW(dev_priv)) {
|
2013-09-06 12:38:29 +08:00
|
|
|
intel_encoder->pre_pll_enable = vlv_dp_pre_pll_enable;
|
2013-07-30 17:20:30 +08:00
|
|
|
intel_encoder->pre_enable = vlv_pre_enable_dp;
|
|
|
|
intel_encoder->enable = vlv_enable_dp;
|
2017-09-20 23:12:51 +08:00
|
|
|
intel_encoder->disable = vlv_disable_dp;
|
2014-03-31 23:21:26 +08:00
|
|
|
intel_encoder->post_disable = vlv_post_disable_dp;
|
2017-09-20 23:12:51 +08:00
|
|
|
} else if (INTEL_GEN(dev_priv) >= 5) {
|
|
|
|
intel_encoder->pre_enable = g4x_pre_enable_dp;
|
|
|
|
intel_encoder->enable = g4x_enable_dp;
|
|
|
|
intel_encoder->disable = ilk_disable_dp;
|
|
|
|
intel_encoder->post_disable = ilk_post_disable_dp;
|
2013-07-30 17:20:30 +08:00
|
|
|
} else {
|
2013-09-06 12:38:29 +08:00
|
|
|
intel_encoder->pre_enable = g4x_pre_enable_dp;
|
|
|
|
intel_encoder->enable = g4x_enable_dp;
|
2017-09-20 23:12:51 +08:00
|
|
|
intel_encoder->disable = g4x_disable_dp;
|
2013-07-30 17:20:30 +08:00
|
|
|
}
|
2012-10-27 05:05:48 +08:00
|
|
|
|
2012-10-27 05:05:50 +08:00
|
|
|
intel_dig_port->port = port;
|
2012-10-27 05:05:48 +08:00
|
|
|
intel_dig_port->dp.output_reg = output_reg;
|
2015-12-09 01:59:38 +08:00
|
|
|
intel_dig_port->max_lanes = 4;
|
2012-10-27 05:05:48 +08:00
|
|
|
|
2016-06-23 02:57:06 +08:00
|
|
|
intel_encoder->type = INTEL_OUTPUT_DP;
|
2017-02-22 14:34:27 +08:00
|
|
|
intel_encoder->power_domain = intel_port_to_power_domain(port);
|
2016-10-14 17:13:44 +08:00
|
|
|
if (IS_CHERRYVIEW(dev_priv)) {
|
2014-04-28 19:07:43 +08:00
|
|
|
if (port == PORT_D)
|
|
|
|
intel_encoder->crtc_mask = 1 << 2;
|
|
|
|
else
|
|
|
|
intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
|
|
|
|
} else {
|
|
|
|
intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);
|
|
|
|
}
|
2014-03-03 22:15:28 +08:00
|
|
|
intel_encoder->cloneable = 0;
|
2016-09-20 09:24:38 +08:00
|
|
|
intel_encoder->port = port;
|
2012-10-27 05:05:48 +08:00
|
|
|
|
2014-06-18 09:29:35 +08:00
|
|
|
intel_dig_port->hpd_pulse = intel_dp_hpd_pulse;
|
2015-05-27 20:03:42 +08:00
|
|
|
dev_priv->hotplug.irq_port[port] = intel_dig_port;
|
2014-06-18 09:29:35 +08:00
|
|
|
|
2017-08-18 21:49:55 +08:00
|
|
|
if (port != PORT_A)
|
|
|
|
intel_infoframe_init(intel_dig_port);
|
|
|
|
|
2015-10-08 21:57:59 +08:00
|
|
|
if (!intel_dp_init_connector(intel_dig_port, intel_connector))
|
|
|
|
goto err_init_connector;
|
|
|
|
|
2016-06-01 15:27:50 +08:00
|
|
|
return true;
|
2015-10-08 21:57:59 +08:00
|
|
|
|
|
|
|
err_init_connector:
|
|
|
|
drm_encoder_cleanup(encoder);
|
2015-10-08 21:58:00 +08:00
|
|
|
err_encoder_init:
|
2015-10-08 21:57:59 +08:00
|
|
|
kfree(intel_connector);
|
|
|
|
err_connector_alloc:
|
|
|
|
kfree(intel_dig_port);
|
2016-06-01 15:27:50 +08:00
|
|
|
return false;
|
2012-10-27 05:05:48 +08:00
|
|
|
}
|
2014-05-02 12:02:48 +08:00
|
|
|
|
|
|
|
void intel_dp_mst_suspend(struct drm_device *dev)
|
|
|
|
{
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-05-02 12:02:48 +08:00
|
|
|
int i;
|
|
|
|
|
|
|
|
/* disable MST */
|
|
|
|
for (i = 0; i < I915_MAX_PORTS; i++) {
|
2015-05-27 20:03:42 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dev_priv->hotplug.irq_port[i];
|
2016-06-23 02:57:00 +08:00
|
|
|
|
|
|
|
if (!intel_dig_port || !intel_dig_port->dp.can_mst)
|
2014-05-02 12:02:48 +08:00
|
|
|
continue;
|
|
|
|
|
2016-06-23 02:57:00 +08:00
|
|
|
if (intel_dig_port->dp.is_mst)
|
|
|
|
drm_dp_mst_topology_mgr_suspend(&intel_dig_port->dp.mst_mgr);
|
2014-05-02 12:02:48 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void intel_dp_mst_resume(struct drm_device *dev)
|
|
|
|
{
|
2016-07-04 18:34:36 +08:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(dev);
|
2014-05-02 12:02:48 +08:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < I915_MAX_PORTS; i++) {
|
2015-05-27 20:03:42 +08:00
|
|
|
struct intel_digital_port *intel_dig_port = dev_priv->hotplug.irq_port[i];
|
2016-06-23 02:57:00 +08:00
|
|
|
int ret;
|
2014-05-02 12:02:48 +08:00
|
|
|
|
2016-06-23 02:57:00 +08:00
|
|
|
if (!intel_dig_port || !intel_dig_port->dp.can_mst)
|
|
|
|
continue;
|
2014-05-02 12:02:48 +08:00
|
|
|
|
2016-06-23 02:57:00 +08:00
|
|
|
ret = drm_dp_mst_topology_mgr_resume(&intel_dig_port->dp.mst_mgr);
|
|
|
|
if (ret)
|
|
|
|
intel_dp_check_mst_status(&intel_dig_port->dp);
|
2014-05-02 12:02:48 +08:00
|
|
|
}
|
|
|
|
}
|