1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2014 Red Hat
4  * Author: Rob Clark <robdclark@gmail.com>
5  */
6 
7 #include <drm/drm_atomic_uapi.h>
8 #include <drm/drm_vblank.h>
9 
10 #include "msm_atomic_trace.h"
11 #include "msm_drv.h"
12 #include "msm_gem.h"
13 #include "msm_kms.h"
14 
15 /*
16  * Helpers to control vblanks while we flush.. basically just to ensure
17  * that vblank accounting is switched on, so we get valid seqn/timestamp
18  * on pageflip events (if requested)
19  */
20 
vblank_get(struct msm_kms * kms,unsigned crtc_mask)21 static void vblank_get(struct msm_kms *kms, unsigned crtc_mask)
22 {
23 	struct drm_crtc *crtc;
24 
25 	for_each_crtc_mask(kms->dev, crtc, crtc_mask) {
26 		if (!crtc->state->active)
27 			continue;
28 		drm_crtc_vblank_get(crtc);
29 	}
30 }
31 
vblank_put(struct msm_kms * kms,unsigned crtc_mask)32 static void vblank_put(struct msm_kms *kms, unsigned crtc_mask)
33 {
34 	struct drm_crtc *crtc;
35 
36 	for_each_crtc_mask(kms->dev, crtc, crtc_mask) {
37 		if (!crtc->state->active)
38 			continue;
39 		drm_crtc_vblank_put(crtc);
40 	}
41 }
42 
lock_crtcs(struct msm_kms * kms,unsigned int crtc_mask)43 static void lock_crtcs(struct msm_kms *kms, unsigned int crtc_mask)
44 {
45 	int crtc_index;
46 	struct drm_crtc *crtc;
47 
48 	for_each_crtc_mask(kms->dev, crtc, crtc_mask) {
49 		crtc_index = drm_crtc_index(crtc);
50 		mutex_lock_nested(&kms->commit_lock[crtc_index], crtc_index);
51 	}
52 }
53 
unlock_crtcs(struct msm_kms * kms,unsigned int crtc_mask)54 static void unlock_crtcs(struct msm_kms *kms, unsigned int crtc_mask)
55 {
56 	struct drm_crtc *crtc;
57 
58 	for_each_crtc_mask_reverse(kms->dev, crtc, crtc_mask)
59 		mutex_unlock(&kms->commit_lock[drm_crtc_index(crtc)]);
60 }
61 
msm_atomic_async_commit(struct msm_kms * kms,int crtc_idx)62 static void msm_atomic_async_commit(struct msm_kms *kms, int crtc_idx)
63 {
64 	unsigned crtc_mask = BIT(crtc_idx);
65 
66 	trace_msm_atomic_async_commit_start(crtc_mask);
67 
68 	lock_crtcs(kms, crtc_mask);
69 
70 	if (!(kms->pending_crtc_mask & crtc_mask)) {
71 		unlock_crtcs(kms, crtc_mask);
72 		goto out;
73 	}
74 
75 	kms->pending_crtc_mask &= ~crtc_mask;
76 
77 	kms->funcs->enable_commit(kms);
78 
79 	vblank_get(kms, crtc_mask);
80 
81 	/*
82 	 * Flush hardware updates:
83 	 */
84 	trace_msm_atomic_flush_commit(crtc_mask);
85 	kms->funcs->flush_commit(kms, crtc_mask);
86 
87 	/*
88 	 * Wait for flush to complete:
89 	 */
90 	trace_msm_atomic_wait_flush_start(crtc_mask);
91 	kms->funcs->wait_flush(kms, crtc_mask);
92 	trace_msm_atomic_wait_flush_finish(crtc_mask);
93 
94 	vblank_put(kms, crtc_mask);
95 
96 	kms->funcs->complete_commit(kms, crtc_mask);
97 	unlock_crtcs(kms, crtc_mask);
98 	kms->funcs->disable_commit(kms);
99 
100 out:
101 	trace_msm_atomic_async_commit_finish(crtc_mask);
102 }
103 
msm_atomic_pending_work(struct kthread_work * work)104 static void msm_atomic_pending_work(struct kthread_work *work)
105 {
106 	struct msm_pending_timer *timer = container_of(work,
107 			struct msm_pending_timer, work.work);
108 
109 	msm_atomic_async_commit(timer->kms, timer->crtc_idx);
110 }
111 
msm_atomic_init_pending_timer(struct msm_pending_timer * timer,struct msm_kms * kms,int crtc_idx)112 int msm_atomic_init_pending_timer(struct msm_pending_timer *timer,
113 		struct msm_kms *kms, int crtc_idx)
114 {
115 	timer->kms = kms;
116 	timer->crtc_idx = crtc_idx;
117 
118 	timer->worker = kthread_create_worker(0, "atomic-worker-%d", crtc_idx);
119 	if (IS_ERR(timer->worker)) {
120 		int ret = PTR_ERR(timer->worker);
121 		timer->worker = NULL;
122 		return ret;
123 	}
124 	sched_set_fifo(timer->worker->task);
125 
126 	msm_hrtimer_work_init(&timer->work, timer->worker,
127 			      msm_atomic_pending_work,
128 			      CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
129 
130 	return 0;
131 }
132 
msm_atomic_destroy_pending_timer(struct msm_pending_timer * timer)133 void msm_atomic_destroy_pending_timer(struct msm_pending_timer *timer)
134 {
135 	if (timer->worker)
136 		kthread_destroy_worker(timer->worker);
137 }
138 
can_do_async(struct drm_atomic_state * state,struct drm_crtc ** async_crtc)139 static bool can_do_async(struct drm_atomic_state *state,
140 		struct drm_crtc **async_crtc)
141 {
142 	struct drm_connector_state *connector_state;
143 	struct drm_connector *connector;
144 	struct drm_crtc_state *crtc_state;
145 	struct drm_crtc *crtc;
146 	int i, num_crtcs = 0;
147 
148 	if (!(state->legacy_cursor_update || state->async_update))
149 		return false;
150 
151 	/* any connector change, means slow path: */
152 	for_each_new_connector_in_state(state, connector, connector_state, i)
153 		return false;
154 
155 	for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
156 		if (drm_atomic_crtc_needs_modeset(crtc_state))
157 			return false;
158 		if (++num_crtcs > 1)
159 			return false;
160 		*async_crtc = crtc;
161 	}
162 
163 	return true;
164 }
165 
166 /* Get bitmask of crtcs that will need to be flushed.  The bitmask
167  * can be used with for_each_crtc_mask() iterator, to iterate
168  * effected crtcs without needing to preserve the atomic state.
169  */
get_crtc_mask(struct drm_atomic_state * state)170 static unsigned get_crtc_mask(struct drm_atomic_state *state)
171 {
172 	struct drm_crtc_state *crtc_state;
173 	struct drm_crtc *crtc;
174 	unsigned i, mask = 0;
175 
176 	for_each_new_crtc_in_state(state, crtc, crtc_state, i)
177 		mask |= drm_crtc_mask(crtc);
178 
179 	return mask;
180 }
181 
msm_atomic_commit_tail(struct drm_atomic_state * state)182 void msm_atomic_commit_tail(struct drm_atomic_state *state)
183 {
184 	struct drm_device *dev = state->dev;
185 	struct msm_drm_private *priv = dev->dev_private;
186 	struct msm_kms *kms = priv->kms;
187 	struct drm_crtc *async_crtc = NULL;
188 	unsigned crtc_mask = get_crtc_mask(state);
189 	bool async = kms->funcs->vsync_time &&
190 			can_do_async(state, &async_crtc);
191 
192 	trace_msm_atomic_commit_tail_start(async, crtc_mask);
193 
194 	kms->funcs->enable_commit(kms);
195 
196 	/*
197 	 * Ensure any previous (potentially async) commit has
198 	 * completed:
199 	 */
200 	lock_crtcs(kms, crtc_mask);
201 	trace_msm_atomic_wait_flush_start(crtc_mask);
202 	kms->funcs->wait_flush(kms, crtc_mask);
203 	trace_msm_atomic_wait_flush_finish(crtc_mask);
204 
205 	/*
206 	 * Now that there is no in-progress flush, prepare the
207 	 * current update:
208 	 */
209 	kms->funcs->prepare_commit(kms, state);
210 
211 	/*
212 	 * Push atomic updates down to hardware:
213 	 */
214 	drm_atomic_helper_commit_modeset_disables(dev, state);
215 	drm_atomic_helper_commit_planes(dev, state, 0);
216 	drm_atomic_helper_commit_modeset_enables(dev, state);
217 
218 	if (async) {
219 		struct msm_pending_timer *timer =
220 			&kms->pending_timers[drm_crtc_index(async_crtc)];
221 
222 		/* async updates are limited to single-crtc updates: */
223 		WARN_ON(crtc_mask != drm_crtc_mask(async_crtc));
224 
225 		/*
226 		 * Start timer if we don't already have an update pending
227 		 * on this crtc:
228 		 */
229 		if (!(kms->pending_crtc_mask & crtc_mask)) {
230 			ktime_t vsync_time, wakeup_time;
231 
232 			kms->pending_crtc_mask |= crtc_mask;
233 
234 			vsync_time = kms->funcs->vsync_time(kms, async_crtc);
235 			wakeup_time = ktime_sub(vsync_time, ms_to_ktime(1));
236 
237 			msm_hrtimer_queue_work(&timer->work, wakeup_time,
238 					HRTIMER_MODE_ABS);
239 		}
240 
241 		kms->funcs->disable_commit(kms);
242 		unlock_crtcs(kms, crtc_mask);
243 		/*
244 		 * At this point, from drm core's perspective, we
245 		 * are done with the atomic update, so we can just
246 		 * go ahead and signal that it is done:
247 		 */
248 		drm_atomic_helper_commit_hw_done(state);
249 		drm_atomic_helper_cleanup_planes(dev, state);
250 
251 		trace_msm_atomic_commit_tail_finish(async, crtc_mask);
252 
253 		return;
254 	}
255 
256 	/*
257 	 * If there is any async flush pending on updated crtcs, fold
258 	 * them into the current flush.
259 	 */
260 	kms->pending_crtc_mask &= ~crtc_mask;
261 
262 	vblank_get(kms, crtc_mask);
263 
264 	/*
265 	 * Flush hardware updates:
266 	 */
267 	trace_msm_atomic_flush_commit(crtc_mask);
268 	kms->funcs->flush_commit(kms, crtc_mask);
269 	unlock_crtcs(kms, crtc_mask);
270 	/*
271 	 * Wait for flush to complete:
272 	 */
273 	trace_msm_atomic_wait_flush_start(crtc_mask);
274 	kms->funcs->wait_flush(kms, crtc_mask);
275 	trace_msm_atomic_wait_flush_finish(crtc_mask);
276 
277 	vblank_put(kms, crtc_mask);
278 
279 	lock_crtcs(kms, crtc_mask);
280 	kms->funcs->complete_commit(kms, crtc_mask);
281 	unlock_crtcs(kms, crtc_mask);
282 	kms->funcs->disable_commit(kms);
283 
284 	drm_atomic_helper_commit_hw_done(state);
285 	drm_atomic_helper_cleanup_planes(dev, state);
286 
287 	trace_msm_atomic_commit_tail_finish(async, crtc_mask);
288 }
289