intel_frontbuffer.c 7.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
/*
 * Copyright © 2014 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:
 *	Daniel Vetter <daniel.vetter@ffwll.ch>
 */

/**
 * DOC: frontbuffer tracking
 *
 * Many features require us to track changes to the currently active
31
 * frontbuffer, especially rendering targeted at the frontbuffer.
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
 *
 * To be able to do so GEM tracks frontbuffers using a bitmask for all possible
 * frontbuffer slots through i915_gem_track_fb(). The function in this file are
 * then called when the contents of the frontbuffer are invalidated, when
 * frontbuffer rendering has stopped again to flush out all the changes and when
 * the frontbuffer is exchanged with a flip. Subsystems interested in
 * frontbuffer changes (e.g. PSR, FBC, DRRS) should directly put their callbacks
 * into the relevant places and filter for the frontbuffer slots that they are
 * interested int.
 *
 * On a high level there are two types of powersaving features. The first one
 * work like a special cache (FBC and PSR) and are interested when they should
 * stop caching and when to restart caching. This is done by placing callbacks
 * into the invalidate and the flush functions: At invalidate the caching must
 * be stopped and at flush time it can be restarted. And maybe they need to know
 * when the frontbuffer changes (e.g. when the hw doesn't initiate an invalidate
 * and flush on its own) which can be achieved with placing callbacks into the
 * flip functions.
 *
 * The other type of display power saving feature only cares about busyness
 * (e.g. DRRS). In that case all three (invalidate, flush and flip) indicate
 * busyness. There is no direct way to detect idleness. Instead an idle timer
 * work delayed work should be started from the flush and flip functions and
 * cancelled as soon as busyness is detected.
 *
 * Note that there's also an older frontbuffer activity tracking scheme which
58
 * just tracks general activity. This is done by the various mark_busy and
59 60 61 62 63 64 65
 * mark_idle functions. For display power management features using these
 * functions is deprecated and should be avoided.
 */

#include <drm/drmP.h>

#include "intel_drv.h"
66
#include "intel_frontbuffer.h"
67 68
#include "i915_drv.h"

69
void __intel_fb_obj_invalidate(struct drm_i915_gem_object *obj,
70 71
			       enum fb_op_origin origin,
			       unsigned int frontbuffer_bits)
72
{
73
	struct drm_i915_private *dev_priv = to_i915(obj->base.dev);
74

75
	if (origin == ORIGIN_CS) {
76
		spin_lock(&dev_priv->fb_tracking.lock);
77 78
		dev_priv->fb_tracking.busy_bits |= frontbuffer_bits;
		dev_priv->fb_tracking.flip_bits &= ~frontbuffer_bits;
79
		spin_unlock(&dev_priv->fb_tracking.lock);
80 81
	}

82 83
	intel_psr_invalidate(dev_priv, frontbuffer_bits);
	intel_edp_drrs_invalidate(dev_priv, frontbuffer_bits);
84
	intel_fbc_invalidate(dev_priv, frontbuffer_bits, origin);
85 86 87 88
}

/**
 * intel_frontbuffer_flush - flush frontbuffer
89
 * @dev_priv: i915 device
90
 * @frontbuffer_bits: frontbuffer plane tracking bits
91
 * @origin: which operation caused the flush
92 93 94
 *
 * This function gets called every time rendering on the given planes has
 * completed and frontbuffer caching can be started again. Flushes will get
95
 * delayed if they're blocked by some outstanding asynchronous rendering.
96 97 98
 *
 * Can be called without any locks held.
 */
99
static void intel_frontbuffer_flush(struct drm_i915_private *dev_priv,
100 101
				    unsigned frontbuffer_bits,
				    enum fb_op_origin origin)
102 103
{
	/* Delay flushing when rings are still busy.*/
104
	spin_lock(&dev_priv->fb_tracking.lock);
105
	frontbuffer_bits &= ~dev_priv->fb_tracking.busy_bits;
106
	spin_unlock(&dev_priv->fb_tracking.lock);
107

108 109 110
	if (!frontbuffer_bits)
		return;

111 112
	intel_edp_drrs_flush(dev_priv, frontbuffer_bits);
	intel_psr_flush(dev_priv, frontbuffer_bits, origin);
113
	intel_fbc_flush(dev_priv, frontbuffer_bits, origin);
114 115
}

116
void __intel_fb_obj_flush(struct drm_i915_gem_object *obj,
117 118
			  enum fb_op_origin origin,
			  unsigned int frontbuffer_bits)
119
{
120
	struct drm_i915_private *dev_priv = to_i915(obj->base.dev);
121

122
	if (origin == ORIGIN_CS) {
123
		spin_lock(&dev_priv->fb_tracking.lock);
124 125 126
		/* Filter out new bits since rendering started. */
		frontbuffer_bits &= dev_priv->fb_tracking.busy_bits;
		dev_priv->fb_tracking.busy_bits &= ~frontbuffer_bits;
127
		spin_unlock(&dev_priv->fb_tracking.lock);
128 129
	}

130
	if (frontbuffer_bits)
131
		intel_frontbuffer_flush(dev_priv, frontbuffer_bits, origin);
132 133 134
}

/**
135
 * intel_frontbuffer_flip_prepare - prepare asynchronous frontbuffer flip
136
 * @dev_priv: i915 device
137 138 139 140 141 142 143 144 145
 * @frontbuffer_bits: frontbuffer plane tracking bits
 *
 * This function gets called after scheduling a flip on @obj. The actual
 * frontbuffer flushing will be delayed until completion is signalled with
 * intel_frontbuffer_flip_complete. If an invalidate happens in between this
 * flush will be cancelled.
 *
 * Can be called without any locks held.
 */
146
void intel_frontbuffer_flip_prepare(struct drm_i915_private *dev_priv,
147 148
				    unsigned frontbuffer_bits)
{
149
	spin_lock(&dev_priv->fb_tracking.lock);
150 151 152
	dev_priv->fb_tracking.flip_bits |= frontbuffer_bits;
	/* Remove stale busy bits due to the old buffer. */
	dev_priv->fb_tracking.busy_bits &= ~frontbuffer_bits;
153
	spin_unlock(&dev_priv->fb_tracking.lock);
154

155
	intel_psr_single_frame_update(dev_priv, frontbuffer_bits);
156 157 158
}

/**
159
 * intel_frontbuffer_flip_complete - complete asynchronous frontbuffer flip
160
 * @dev_priv: i915 device
161 162 163
 * @frontbuffer_bits: frontbuffer plane tracking bits
 *
 * This function gets called after the flip has been latched and will complete
164
 * on the next vblank. It will execute the flush if it hasn't been cancelled yet.
165 166 167
 *
 * Can be called without any locks held.
 */
168
void intel_frontbuffer_flip_complete(struct drm_i915_private *dev_priv,
169 170
				     unsigned frontbuffer_bits)
{
171
	spin_lock(&dev_priv->fb_tracking.lock);
172 173 174
	/* Mask any cancelled flips. */
	frontbuffer_bits &= dev_priv->fb_tracking.flip_bits;
	dev_priv->fb_tracking.flip_bits &= ~frontbuffer_bits;
175
	spin_unlock(&dev_priv->fb_tracking.lock);
176

177
	if (frontbuffer_bits)
178 179
		intel_frontbuffer_flush(dev_priv,
					frontbuffer_bits, ORIGIN_FLIP);
180
}
181 182 183

/**
 * intel_frontbuffer_flip - synchronous frontbuffer flip
184
 * @dev_priv: i915 device
185 186 187 188 189 190 191 192
 * @frontbuffer_bits: frontbuffer plane tracking bits
 *
 * This function gets called after scheduling a flip on @obj. This is for
 * synchronous plane updates which will happen on the next vblank and which will
 * not get delayed by pending gpu rendering.
 *
 * Can be called without any locks held.
 */
193
void intel_frontbuffer_flip(struct drm_i915_private *dev_priv,
194 195
			    unsigned frontbuffer_bits)
{
196
	spin_lock(&dev_priv->fb_tracking.lock);
197 198
	/* Remove stale busy bits due to the old buffer. */
	dev_priv->fb_tracking.busy_bits &= ~frontbuffer_bits;
199
	spin_unlock(&dev_priv->fb_tracking.lock);
200

201
	intel_frontbuffer_flush(dev_priv, frontbuffer_bits, ORIGIN_FLIP);
202
}