Merge remote-tracking branch 'origin/f23' into f23-user-thl-vanilla-fedorakernel-4.6.3-200.vanilla.knurd.1.fc23

1 files changed, 141 insertions, 0 deletions

diff --git a/0004-drm-i915-gen9-Allow-calculation-of-data-rate-for-in-.patch b/0004-drm-i915-gen9-Allow-calculation-of-data-rate-for-in-.patch
new file mode 100644
index 000000000..3a2b0aa1c
--- /dev/null
+++ b/0004-drm-i915-gen9-Allow-calculation-of-data-rate-for-in-.patch
@@ -0,0 +1,141 @@
+From a75a3c793e2cd3e7648597f2c77d87453f520f31 Mon Sep 17 00:00:00 2001
+From: Fedora Kernel Team <kernel-team@fedoraproject.org>
+Date: Mon, 20 Jun 2016 11:13:23 +0200
+Subject: [PATCH 04/17] drm/i915/gen9: Allow calculation of data rate for
+ in-flight state (v2)
+
+Upstream: since drm-intel-next-2016-05-22
+commit 9c74d82621c553f0da1f41bd5d90f5eab5659fdb
+
+Author:     Matt Roper <matthew.d.roper@intel.com>
+AuthorDate: Thu May 12 07:05:58 2016 -0700
+Commit:     Matt Roper <matthew.d.roper@intel.com>
+CommitDate: Fri May 13 07:32:49 2016 -0700
+
+    drm/i915/gen9: Allow calculation of data rate for in-flight state (v2)
+
+    Our skl_get_total_relative_data_rate() function gets passed a crtc state
+    object to calculate the data rate for, but it currently always looks
+    up the committed plane states that correspond to that CRTC.  Let's
+    check whether the CRTC state is an in-flight state (meaning
+    cstate->state is non-NULL) and if so, use the corresponding in-flight
+    plane states.
+
+    We'll soon be using this function exclusively for in-flight states; at
+    that time we'll be able to simplify the function a bit, but for now we
+    allow it to be used in either mode.
+
+    v2:
+     - Rebase on top of changes to cache plane data rates.
+
+    Signed-off-by: Matt Roper <matthew.d.roper@intel.com>
+    Reviewed-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
+    Link: http://patchwork.freedesktop.org/patch/msgid/1463061971-19638-5-git-send-email-matthew.d.roper@intel.com
+---
+ drivers/gpu/drm/i915/intel_pm.c | 74 +++++++++++++++++++++++++++++++++--------
+ 1 file changed, 60 insertions(+), 14 deletions(-)
+
+diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c
+index 854f0a4..b863bfc 100644
+--- a/drivers/gpu/drm/i915/intel_pm.c
++++ b/drivers/gpu/drm/i915/intel_pm.c
+@@ -2914,25 +2914,69 @@ skl_plane_relative_data_rate(const struct intel_crtc_state *cstate,
+  *   3 * 4096 * 8192  * 4 < 2^32
+  */
+ static unsigned int
+-skl_get_total_relative_data_rate(struct intel_crtc_state *cstate)
++skl_get_total_relative_data_rate(struct intel_crtc_state *intel_cstate)
+ {
+-	struct intel_crtc *intel_crtc = to_intel_crtc(cstate->base.crtc);
+-	struct drm_device *dev = intel_crtc->base.dev;
++	struct drm_crtc_state *cstate = &intel_cstate->base;
++	struct drm_atomic_state *state = cstate->state;
++	struct drm_crtc *crtc = cstate->crtc;
++	struct drm_device *dev = crtc->dev;
++	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+ 	const struct intel_plane *intel_plane;
+ 	unsigned int rate, total_data_rate = 0;
++	int id;
+ 
+ 	/* Calculate and cache data rate for each plane */
+-	for_each_intel_plane_on_crtc(dev, intel_crtc, intel_plane) {
+-		const struct drm_plane_state *pstate = intel_plane->base.state;
+-		int id = skl_wm_plane_id(intel_plane);
++	/*
++	 * FIXME: At the moment this function can be called on either an
++	 * in-flight or a committed state object.  If it's in-flight then we
++	 * only want to re-calculate the plane data rate for planes that are
++	 * part of the transaction (i.e., we don't want to grab any additional
++	 * plane states if we don't have to).  If we're operating on committed
++	 * state, we'll just go ahead and recalculate the plane data rate for
++	 * all planes.
++	 *
++	 * Once we finish moving our DDB allocation to the atomic check phase,
++	 * we'll only be calling this function on in-flight state objects, so
++	 * the 'else' branch here will go away.
++	 */
++	if (state) {
++		struct drm_plane *plane;
++		struct drm_plane_state *pstate;
++		int i;
++
++		for_each_plane_in_state(state, plane, pstate, i) {
++			intel_plane = to_intel_plane(plane);
++			id = skl_wm_plane_id(intel_plane);
++
++			if (intel_plane->pipe != intel_crtc->pipe)
++				continue;
++
++			/* packed/uv */
++			rate = skl_plane_relative_data_rate(intel_cstate,
++							    pstate, 0);
++			intel_cstate->wm.skl.plane_data_rate[id] = rate;
++
++			/* y-plane */
++			rate = skl_plane_relative_data_rate(intel_cstate,
++							    pstate, 1);
++			intel_cstate->wm.skl.plane_y_data_rate[id] = rate;
++		}
++	} else {
++		for_each_intel_plane_on_crtc(dev, intel_crtc, intel_plane) {
++			const struct drm_plane_state *pstate =
++				intel_plane->base.state;
++			int id = skl_wm_plane_id(intel_plane);
+ 
+-		/* packed/uv */
+-		rate = skl_plane_relative_data_rate(cstate, pstate, 0);
+-		cstate->wm.skl.plane_data_rate[id] = rate;
++			/* packed/uv */
++			rate = skl_plane_relative_data_rate(intel_cstate,
++							    pstate, 0);
++			intel_cstate->wm.skl.plane_data_rate[id] = rate;
+ 
+-		/* y-plane */
+-		rate = skl_plane_relative_data_rate(cstate, pstate, 1);
+-		cstate->wm.skl.plane_y_data_rate[id] = rate;
++			/* y-plane */
++			rate = skl_plane_relative_data_rate(intel_cstate,
++							    pstate, 1);
++			intel_cstate->wm.skl.plane_y_data_rate[id] = rate;
++		}
+ 	}
+ 
+ 	/* Calculate CRTC's total data rate from cached values */
+@@ -2940,10 +2984,12 @@ skl_get_total_relative_data_rate(struct intel_crtc_state *cstate)
+ 		int id = skl_wm_plane_id(intel_plane);
+ 
+ 		/* packed/uv */
+-		total_data_rate += cstate->wm.skl.plane_data_rate[id];
+-		total_data_rate += cstate->wm.skl.plane_y_data_rate[id];
++		total_data_rate += intel_cstate->wm.skl.plane_data_rate[id];
++		total_data_rate += intel_cstate->wm.skl.plane_y_data_rate[id];
+ 	}
+ 
++	WARN_ON(cstate->plane_mask && total_data_rate == 0);
++
+ 	return total_data_rate;
+ }
+ 
+-- 
+2.7.4
+