1 /*
2  * Copyright (C) 2014 Red Hat
3  * Copyright (C) 2014 Intel Corp.
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21  * OTHER DEALINGS IN THE SOFTWARE.
22  *
23  * Authors:
24  * Rob Clark <robdclark@gmail.com>
25  * Daniel Vetter <daniel.vetter@ffwll.ch>
26  */
27 
28 #include <linux/dma-fence.h>
29 #include <linux/ktime.h>
30 
31 #include <drm/drm_atomic.h>
32 #include <drm/drm_atomic_helper.h>
33 #include <drm/drm_atomic_uapi.h>
34 #include <drm/drm_blend.h>
35 #include <drm/drm_bridge.h>
36 #include <drm/drm_damage_helper.h>
37 #include <drm/drm_device.h>
38 #include <drm/drm_drv.h>
39 #include <drm/drm_framebuffer.h>
40 #include <drm/drm_gem_atomic_helper.h>
41 #include <drm/drm_panic.h>
42 #include <drm/drm_print.h>
43 #include <drm/drm_self_refresh_helper.h>
44 #include <drm/drm_vblank.h>
45 #include <drm/drm_writeback.h>
46 
47 #include "drm_crtc_helper_internal.h"
48 #include "drm_crtc_internal.h"
49 
50 /**
51  * DOC: overview
52  *
53  * This helper library provides implementations of check and commit functions on
54  * top of the CRTC modeset helper callbacks and the plane helper callbacks. It
55  * also provides convenience implementations for the atomic state handling
56  * callbacks for drivers which don't need to subclass the drm core structures to
57  * add their own additional internal state.
58  *
59  * This library also provides default implementations for the check callback in
60  * drm_atomic_helper_check() and for the commit callback with
61  * drm_atomic_helper_commit(). But the individual stages and callbacks are
62  * exposed to allow drivers to mix and match and e.g. use the plane helpers only
63  * together with a driver private modeset implementation.
64  *
65  * This library also provides implementations for all the legacy driver
66  * interfaces on top of the atomic interface. See drm_atomic_helper_set_config(),
67  * drm_atomic_helper_disable_plane(), and the various functions to implement
68  * set_property callbacks. New drivers must not implement these functions
69  * themselves but must use the provided helpers.
70  *
71  * The atomic helper uses the same function table structures as all other
72  * modesetting helpers. See the documentation for &struct drm_crtc_helper_funcs,
73  * struct &drm_encoder_helper_funcs and &struct drm_connector_helper_funcs. It
74  * also shares the &struct drm_plane_helper_funcs function table with the plane
75  * helpers.
76  */
77 static void
drm_atomic_helper_plane_changed(struct drm_atomic_state * state,struct drm_plane_state * old_plane_state,struct drm_plane_state * plane_state,struct drm_plane * plane)78 drm_atomic_helper_plane_changed(struct drm_atomic_state *state,
79 				struct drm_plane_state *old_plane_state,
80 				struct drm_plane_state *plane_state,
81 				struct drm_plane *plane)
82 {
83 	struct drm_crtc_state *crtc_state;
84 
85 	if (old_plane_state->crtc) {
86 		crtc_state = drm_atomic_get_new_crtc_state(state,
87 							   old_plane_state->crtc);
88 
89 		if (WARN_ON(!crtc_state))
90 			return;
91 
92 		crtc_state->planes_changed = true;
93 	}
94 
95 	if (plane_state->crtc) {
96 		crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc);
97 
98 		if (WARN_ON(!crtc_state))
99 			return;
100 
101 		crtc_state->planes_changed = true;
102 	}
103 }
104 
handle_conflicting_encoders(struct drm_atomic_state * state,bool disable_conflicting_encoders)105 static int handle_conflicting_encoders(struct drm_atomic_state *state,
106 				       bool disable_conflicting_encoders)
107 {
108 	struct drm_connector_state *new_conn_state;
109 	struct drm_connector *connector;
110 	struct drm_connector_list_iter conn_iter;
111 	struct drm_encoder *encoder;
112 	unsigned int encoder_mask = 0;
113 	int i, ret = 0;
114 
115 	/*
116 	 * First loop, find all newly assigned encoders from the connectors
117 	 * part of the state. If the same encoder is assigned to multiple
118 	 * connectors bail out.
119 	 */
120 	for_each_new_connector_in_state(state, connector, new_conn_state, i) {
121 		const struct drm_connector_helper_funcs *funcs = connector->helper_private;
122 		struct drm_encoder *new_encoder;
123 
124 		if (!new_conn_state->crtc)
125 			continue;
126 
127 		if (funcs->atomic_best_encoder)
128 			new_encoder = funcs->atomic_best_encoder(connector,
129 								 state);
130 		else if (funcs->best_encoder)
131 			new_encoder = funcs->best_encoder(connector);
132 		else
133 			new_encoder = drm_connector_get_single_encoder(connector);
134 
135 		if (new_encoder) {
136 			if (encoder_mask & drm_encoder_mask(new_encoder)) {
137 				drm_dbg_atomic(connector->dev,
138 					       "[ENCODER:%d:%s] on [CONNECTOR:%d:%s] already assigned\n",
139 					       new_encoder->base.id, new_encoder->name,
140 					       connector->base.id, connector->name);
141 
142 				return -EINVAL;
143 			}
144 
145 			encoder_mask |= drm_encoder_mask(new_encoder);
146 		}
147 	}
148 
149 	if (!encoder_mask)
150 		return 0;
151 
152 	/*
153 	 * Second loop, iterate over all connectors not part of the state.
154 	 *
155 	 * If a conflicting encoder is found and disable_conflicting_encoders
156 	 * is not set, an error is returned. Userspace can provide a solution
157 	 * through the atomic ioctl.
158 	 *
159 	 * If the flag is set conflicting connectors are removed from the CRTC
160 	 * and the CRTC is disabled if no encoder is left. This preserves
161 	 * compatibility with the legacy set_config behavior.
162 	 */
163 	drm_connector_list_iter_begin(state->dev, &conn_iter);
164 	drm_for_each_connector_iter(connector, &conn_iter) {
165 		struct drm_crtc_state *crtc_state;
166 
167 		if (drm_atomic_get_new_connector_state(state, connector))
168 			continue;
169 
170 		encoder = connector->state->best_encoder;
171 		if (!encoder || !(encoder_mask & drm_encoder_mask(encoder)))
172 			continue;
173 
174 		if (!disable_conflicting_encoders) {
175 			drm_dbg_atomic(connector->dev,
176 				       "[ENCODER:%d:%s] in use on [CRTC:%d:%s] by [CONNECTOR:%d:%s]\n",
177 				       encoder->base.id, encoder->name,
178 				       connector->state->crtc->base.id,
179 				       connector->state->crtc->name,
180 				       connector->base.id, connector->name);
181 			ret = -EINVAL;
182 			goto out;
183 		}
184 
185 		new_conn_state = drm_atomic_get_connector_state(state, connector);
186 		if (IS_ERR(new_conn_state)) {
187 			ret = PTR_ERR(new_conn_state);
188 			goto out;
189 		}
190 
191 		drm_dbg_atomic(connector->dev,
192 			       "[ENCODER:%d:%s] in use on [CRTC:%d:%s], disabling [CONNECTOR:%d:%s]\n",
193 			       encoder->base.id, encoder->name,
194 			       new_conn_state->crtc->base.id, new_conn_state->crtc->name,
195 			       connector->base.id, connector->name);
196 
197 		crtc_state = drm_atomic_get_new_crtc_state(state, new_conn_state->crtc);
198 
199 		ret = drm_atomic_set_crtc_for_connector(new_conn_state, NULL);
200 		if (ret)
201 			goto out;
202 
203 		if (!crtc_state->connector_mask) {
204 			ret = drm_atomic_set_mode_prop_for_crtc(crtc_state,
205 								NULL);
206 			if (ret < 0)
207 				goto out;
208 
209 			crtc_state->active = false;
210 		}
211 	}
212 out:
213 	drm_connector_list_iter_end(&conn_iter);
214 
215 	return ret;
216 }
217 
218 static void
set_best_encoder(struct drm_atomic_state * state,struct drm_connector_state * conn_state,struct drm_encoder * encoder)219 set_best_encoder(struct drm_atomic_state *state,
220 		 struct drm_connector_state *conn_state,
221 		 struct drm_encoder *encoder)
222 {
223 	struct drm_crtc_state *crtc_state;
224 	struct drm_crtc *crtc;
225 
226 	if (conn_state->best_encoder) {
227 		/* Unset the encoder_mask in the old crtc state. */
228 		crtc = conn_state->connector->state->crtc;
229 
230 		/* A NULL crtc is an error here because we should have
231 		 * duplicated a NULL best_encoder when crtc was NULL.
232 		 * As an exception restoring duplicated atomic state
233 		 * during resume is allowed, so don't warn when
234 		 * best_encoder is equal to encoder we intend to set.
235 		 */
236 		WARN_ON(!crtc && encoder != conn_state->best_encoder);
237 		if (crtc) {
238 			crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
239 
240 			crtc_state->encoder_mask &=
241 				~drm_encoder_mask(conn_state->best_encoder);
242 		}
243 	}
244 
245 	if (encoder) {
246 		crtc = conn_state->crtc;
247 		WARN_ON(!crtc);
248 		if (crtc) {
249 			crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
250 
251 			crtc_state->encoder_mask |=
252 				drm_encoder_mask(encoder);
253 		}
254 	}
255 
256 	conn_state->best_encoder = encoder;
257 }
258 
259 static void
steal_encoder(struct drm_atomic_state * state,struct drm_encoder * encoder)260 steal_encoder(struct drm_atomic_state *state,
261 	      struct drm_encoder *encoder)
262 {
263 	struct drm_crtc_state *crtc_state;
264 	struct drm_connector *connector;
265 	struct drm_connector_state *old_connector_state, *new_connector_state;
266 	int i;
267 
268 	for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
269 		struct drm_crtc *encoder_crtc;
270 
271 		if (new_connector_state->best_encoder != encoder)
272 			continue;
273 
274 		encoder_crtc = old_connector_state->crtc;
275 
276 		drm_dbg_atomic(encoder->dev,
277 			       "[ENCODER:%d:%s] in use on [CRTC:%d:%s], stealing it\n",
278 			       encoder->base.id, encoder->name,
279 			       encoder_crtc->base.id, encoder_crtc->name);
280 
281 		set_best_encoder(state, new_connector_state, NULL);
282 
283 		crtc_state = drm_atomic_get_new_crtc_state(state, encoder_crtc);
284 		crtc_state->connectors_changed = true;
285 
286 		return;
287 	}
288 }
289 
290 static int
update_connector_routing(struct drm_atomic_state * state,struct drm_connector * connector,struct drm_connector_state * old_connector_state,struct drm_connector_state * new_connector_state,bool added_by_user)291 update_connector_routing(struct drm_atomic_state *state,
292 			 struct drm_connector *connector,
293 			 struct drm_connector_state *old_connector_state,
294 			 struct drm_connector_state *new_connector_state,
295 			 bool added_by_user)
296 {
297 	const struct drm_connector_helper_funcs *funcs;
298 	struct drm_encoder *new_encoder;
299 	struct drm_crtc_state *crtc_state;
300 
301 	drm_dbg_atomic(connector->dev, "Updating routing for [CONNECTOR:%d:%s]\n",
302 		       connector->base.id, connector->name);
303 
304 	if (old_connector_state->crtc != new_connector_state->crtc) {
305 		if (old_connector_state->crtc) {
306 			crtc_state = drm_atomic_get_new_crtc_state(state, old_connector_state->crtc);
307 			crtc_state->connectors_changed = true;
308 		}
309 
310 		if (new_connector_state->crtc) {
311 			crtc_state = drm_atomic_get_new_crtc_state(state, new_connector_state->crtc);
312 			crtc_state->connectors_changed = true;
313 		}
314 	}
315 
316 	if (!new_connector_state->crtc) {
317 		drm_dbg_atomic(connector->dev, "Disabling [CONNECTOR:%d:%s]\n",
318 				connector->base.id, connector->name);
319 
320 		set_best_encoder(state, new_connector_state, NULL);
321 
322 		return 0;
323 	}
324 
325 	crtc_state = drm_atomic_get_new_crtc_state(state,
326 						   new_connector_state->crtc);
327 	/*
328 	 * For compatibility with legacy users, we want to make sure that
329 	 * we allow DPMS On->Off modesets on unregistered connectors. Modesets
330 	 * which would result in anything else must be considered invalid, to
331 	 * avoid turning on new displays on dead connectors.
332 	 *
333 	 * Since the connector can be unregistered at any point during an
334 	 * atomic check or commit, this is racy. But that's OK: all we care
335 	 * about is ensuring that userspace can't do anything but shut off the
336 	 * display on a connector that was destroyed after it's been notified,
337 	 * not before.
338 	 *
339 	 * Additionally, we also want to ignore connector registration when
340 	 * we're trying to restore an atomic state during system resume since
341 	 * there's a chance the connector may have been destroyed during the
342 	 * process, but it's better to ignore that then cause
343 	 * drm_atomic_helper_resume() to fail.
344 	 *
345 	 * Last, we want to ignore connector registration when the connector
346 	 * was not pulled in the atomic state by user-space (ie, was pulled
347 	 * in by the driver, e.g. when updating a DP-MST stream).
348 	 */
349 	if (!state->duplicated && drm_connector_is_unregistered(connector) &&
350 	    added_by_user && crtc_state->active) {
351 		drm_dbg_atomic(connector->dev,
352 			       "[CONNECTOR:%d:%s] is not registered\n",
353 			       connector->base.id, connector->name);
354 		return -EINVAL;
355 	}
356 
357 	funcs = connector->helper_private;
358 
359 	if (funcs->atomic_best_encoder)
360 		new_encoder = funcs->atomic_best_encoder(connector, state);
361 	else if (funcs->best_encoder)
362 		new_encoder = funcs->best_encoder(connector);
363 	else
364 		new_encoder = drm_connector_get_single_encoder(connector);
365 
366 	if (!new_encoder) {
367 		drm_dbg_atomic(connector->dev,
368 			       "No suitable encoder found for [CONNECTOR:%d:%s]\n",
369 			       connector->base.id, connector->name);
370 		return -EINVAL;
371 	}
372 
373 	if (!drm_encoder_crtc_ok(new_encoder, new_connector_state->crtc)) {
374 		drm_dbg_atomic(connector->dev,
375 			       "[ENCODER:%d:%s] incompatible with [CRTC:%d:%s]\n",
376 			       new_encoder->base.id,
377 			       new_encoder->name,
378 			       new_connector_state->crtc->base.id,
379 			       new_connector_state->crtc->name);
380 		return -EINVAL;
381 	}
382 
383 	if (new_encoder == new_connector_state->best_encoder) {
384 		set_best_encoder(state, new_connector_state, new_encoder);
385 
386 		drm_dbg_atomic(connector->dev,
387 			       "[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on [CRTC:%d:%s]\n",
388 			       connector->base.id,
389 			       connector->name,
390 			       new_encoder->base.id,
391 			       new_encoder->name,
392 			       new_connector_state->crtc->base.id,
393 			       new_connector_state->crtc->name);
394 
395 		return 0;
396 	}
397 
398 	steal_encoder(state, new_encoder);
399 
400 	set_best_encoder(state, new_connector_state, new_encoder);
401 
402 	crtc_state->connectors_changed = true;
403 
404 	drm_dbg_atomic(connector->dev,
405 		       "[CONNECTOR:%d:%s] using [ENCODER:%d:%s] on [CRTC:%d:%s]\n",
406 		       connector->base.id,
407 		       connector->name,
408 		       new_encoder->base.id,
409 		       new_encoder->name,
410 		       new_connector_state->crtc->base.id,
411 		       new_connector_state->crtc->name);
412 
413 	return 0;
414 }
415 
416 static int
mode_fixup(struct drm_atomic_state * state)417 mode_fixup(struct drm_atomic_state *state)
418 {
419 	struct drm_crtc *crtc;
420 	struct drm_crtc_state *new_crtc_state;
421 	struct drm_connector *connector;
422 	struct drm_connector_state *new_conn_state;
423 	int i;
424 	int ret;
425 
426 	for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
427 		if (!new_crtc_state->mode_changed &&
428 		    !new_crtc_state->connectors_changed)
429 			continue;
430 
431 		drm_mode_copy(&new_crtc_state->adjusted_mode, &new_crtc_state->mode);
432 	}
433 
434 	for_each_new_connector_in_state(state, connector, new_conn_state, i) {
435 		const struct drm_encoder_helper_funcs *funcs;
436 		struct drm_encoder *encoder;
437 		struct drm_bridge *bridge;
438 
439 		WARN_ON(!!new_conn_state->best_encoder != !!new_conn_state->crtc);
440 
441 		if (!new_conn_state->crtc || !new_conn_state->best_encoder)
442 			continue;
443 
444 		new_crtc_state =
445 			drm_atomic_get_new_crtc_state(state, new_conn_state->crtc);
446 
447 		/*
448 		 * Each encoder has at most one connector (since we always steal
449 		 * it away), so we won't call ->mode_fixup twice.
450 		 */
451 		encoder = new_conn_state->best_encoder;
452 		funcs = encoder->helper_private;
453 
454 		bridge = drm_bridge_chain_get_first_bridge(encoder);
455 		ret = drm_atomic_bridge_chain_check(bridge,
456 						    new_crtc_state,
457 						    new_conn_state);
458 		if (ret) {
459 			drm_dbg_atomic(encoder->dev, "Bridge atomic check failed\n");
460 			return ret;
461 		}
462 
463 		if (funcs && funcs->atomic_check) {
464 			ret = funcs->atomic_check(encoder, new_crtc_state,
465 						  new_conn_state);
466 			if (ret) {
467 				drm_dbg_atomic(encoder->dev,
468 					       "[ENCODER:%d:%s] check failed\n",
469 					       encoder->base.id, encoder->name);
470 				return ret;
471 			}
472 		} else if (funcs && funcs->mode_fixup) {
473 			ret = funcs->mode_fixup(encoder, &new_crtc_state->mode,
474 						&new_crtc_state->adjusted_mode);
475 			if (!ret) {
476 				drm_dbg_atomic(encoder->dev,
477 					       "[ENCODER:%d:%s] fixup failed\n",
478 					       encoder->base.id, encoder->name);
479 				return -EINVAL;
480 			}
481 		}
482 	}
483 
484 	for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
485 		const struct drm_crtc_helper_funcs *funcs;
486 
487 		if (!new_crtc_state->enable)
488 			continue;
489 
490 		if (!new_crtc_state->mode_changed &&
491 		    !new_crtc_state->connectors_changed)
492 			continue;
493 
494 		funcs = crtc->helper_private;
495 		if (!funcs || !funcs->mode_fixup)
496 			continue;
497 
498 		ret = funcs->mode_fixup(crtc, &new_crtc_state->mode,
499 					&new_crtc_state->adjusted_mode);
500 		if (!ret) {
501 			drm_dbg_atomic(crtc->dev, "[CRTC:%d:%s] fixup failed\n",
502 				       crtc->base.id, crtc->name);
503 			return -EINVAL;
504 		}
505 	}
506 
507 	return 0;
508 }
509 
mode_valid_path(struct drm_connector * connector,struct drm_encoder * encoder,struct drm_crtc * crtc,const struct drm_display_mode * mode)510 static enum drm_mode_status mode_valid_path(struct drm_connector *connector,
511 					    struct drm_encoder *encoder,
512 					    struct drm_crtc *crtc,
513 					    const struct drm_display_mode *mode)
514 {
515 	struct drm_bridge *bridge;
516 	enum drm_mode_status ret;
517 
518 	ret = drm_encoder_mode_valid(encoder, mode);
519 	if (ret != MODE_OK) {
520 		drm_dbg_atomic(encoder->dev,
521 			       "[ENCODER:%d:%s] mode_valid() failed\n",
522 			       encoder->base.id, encoder->name);
523 		return ret;
524 	}
525 
526 	bridge = drm_bridge_chain_get_first_bridge(encoder);
527 	ret = drm_bridge_chain_mode_valid(bridge, &connector->display_info,
528 					  mode);
529 	if (ret != MODE_OK) {
530 		drm_dbg_atomic(encoder->dev, "[BRIDGE] mode_valid() failed\n");
531 		return ret;
532 	}
533 
534 	ret = drm_crtc_mode_valid(crtc, mode);
535 	if (ret != MODE_OK) {
536 		drm_dbg_atomic(encoder->dev, "[CRTC:%d:%s] mode_valid() failed\n",
537 			       crtc->base.id, crtc->name);
538 		return ret;
539 	}
540 
541 	return ret;
542 }
543 
544 static int
mode_valid(struct drm_atomic_state * state)545 mode_valid(struct drm_atomic_state *state)
546 {
547 	struct drm_connector_state *conn_state;
548 	struct drm_connector *connector;
549 	int i;
550 
551 	for_each_new_connector_in_state(state, connector, conn_state, i) {
552 		struct drm_encoder *encoder = conn_state->best_encoder;
553 		struct drm_crtc *crtc = conn_state->crtc;
554 		struct drm_crtc_state *crtc_state;
555 		enum drm_mode_status mode_status;
556 		const struct drm_display_mode *mode;
557 
558 		if (!crtc || !encoder)
559 			continue;
560 
561 		crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
562 		if (!crtc_state)
563 			continue;
564 		if (!crtc_state->mode_changed && !crtc_state->connectors_changed)
565 			continue;
566 
567 		mode = &crtc_state->mode;
568 
569 		mode_status = mode_valid_path(connector, encoder, crtc, mode);
570 		if (mode_status != MODE_OK)
571 			return -EINVAL;
572 	}
573 
574 	return 0;
575 }
576 
577 /**
578  * drm_atomic_helper_check_modeset - validate state object for modeset changes
579  * @dev: DRM device
580  * @state: the driver state object
581  *
582  * Check the state object to see if the requested state is physically possible.
583  * This does all the CRTC and connector related computations for an atomic
584  * update and adds any additional connectors needed for full modesets. It calls
585  * the various per-object callbacks in the follow order:
586  *
587  * 1. &drm_connector_helper_funcs.atomic_best_encoder for determining the new encoder.
588  * 2. &drm_connector_helper_funcs.atomic_check to validate the connector state.
589  * 3. If it's determined a modeset is needed then all connectors on the affected
590  *    CRTC are added and &drm_connector_helper_funcs.atomic_check is run on them.
591  * 4. &drm_encoder_helper_funcs.mode_valid, &drm_bridge_funcs.mode_valid and
592  *    &drm_crtc_helper_funcs.mode_valid are called on the affected components.
593  * 5. &drm_bridge_funcs.mode_fixup is called on all encoder bridges.
594  * 6. &drm_encoder_helper_funcs.atomic_check is called to validate any encoder state.
595  *    This function is only called when the encoder will be part of a configured CRTC,
596  *    it must not be used for implementing connector property validation.
597  *    If this function is NULL, &drm_atomic_encoder_helper_funcs.mode_fixup is called
598  *    instead.
599  * 7. &drm_crtc_helper_funcs.mode_fixup is called last, to fix up the mode with CRTC constraints.
600  *
601  * &drm_crtc_state.mode_changed is set when the input mode is changed.
602  * &drm_crtc_state.connectors_changed is set when a connector is added or
603  * removed from the CRTC.  &drm_crtc_state.active_changed is set when
604  * &drm_crtc_state.active changes, which is used for DPMS.
605  * &drm_crtc_state.no_vblank is set from the result of drm_dev_has_vblank().
606  * See also: drm_atomic_crtc_needs_modeset()
607  *
608  * IMPORTANT:
609  *
610  * Drivers which set &drm_crtc_state.mode_changed (e.g. in their
611  * &drm_plane_helper_funcs.atomic_check hooks if a plane update can't be done
612  * without a full modeset) _must_ call this function after that change. It is
613  * permitted to call this function multiple times for the same update, e.g.
614  * when the &drm_crtc_helper_funcs.atomic_check functions depend upon the
615  * adjusted dotclock for fifo space allocation and watermark computation.
616  *
617  * RETURNS:
618  * Zero for success or -errno
619  */
620 int
drm_atomic_helper_check_modeset(struct drm_device * dev,struct drm_atomic_state * state)621 drm_atomic_helper_check_modeset(struct drm_device *dev,
622 				struct drm_atomic_state *state)
623 {
624 	struct drm_crtc *crtc;
625 	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
626 	struct drm_connector *connector;
627 	struct drm_connector_state *old_connector_state, *new_connector_state;
628 	int i, ret;
629 	unsigned int connectors_mask = 0, user_connectors_mask = 0;
630 
631 	for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i)
632 		user_connectors_mask |= BIT(i);
633 
634 	for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
635 		bool has_connectors =
636 			!!new_crtc_state->connector_mask;
637 
638 		WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
639 
640 		if (!drm_mode_equal(&old_crtc_state->mode, &new_crtc_state->mode)) {
641 			drm_dbg_atomic(dev, "[CRTC:%d:%s] mode changed\n",
642 				       crtc->base.id, crtc->name);
643 			new_crtc_state->mode_changed = true;
644 		}
645 
646 		if (old_crtc_state->enable != new_crtc_state->enable) {
647 			drm_dbg_atomic(dev, "[CRTC:%d:%s] enable changed\n",
648 				       crtc->base.id, crtc->name);
649 
650 			/*
651 			 * For clarity this assignment is done here, but
652 			 * enable == 0 is only true when there are no
653 			 * connectors and a NULL mode.
654 			 *
655 			 * The other way around is true as well. enable != 0
656 			 * implies that connectors are attached and a mode is set.
657 			 */
658 			new_crtc_state->mode_changed = true;
659 			new_crtc_state->connectors_changed = true;
660 		}
661 
662 		if (old_crtc_state->active != new_crtc_state->active) {
663 			drm_dbg_atomic(dev, "[CRTC:%d:%s] active changed\n",
664 				       crtc->base.id, crtc->name);
665 			new_crtc_state->active_changed = true;
666 		}
667 
668 		if (new_crtc_state->enable != has_connectors) {
669 			drm_dbg_atomic(dev, "[CRTC:%d:%s] enabled/connectors mismatch\n",
670 				       crtc->base.id, crtc->name);
671 
672 			return -EINVAL;
673 		}
674 
675 		if (drm_dev_has_vblank(dev))
676 			new_crtc_state->no_vblank = false;
677 		else
678 			new_crtc_state->no_vblank = true;
679 	}
680 
681 	ret = handle_conflicting_encoders(state, false);
682 	if (ret)
683 		return ret;
684 
685 	for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
686 		const struct drm_connector_helper_funcs *funcs = connector->helper_private;
687 
688 		WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
689 
690 		/*
691 		 * This only sets crtc->connectors_changed for routing changes,
692 		 * drivers must set crtc->connectors_changed themselves when
693 		 * connector properties need to be updated.
694 		 */
695 		ret = update_connector_routing(state, connector,
696 					       old_connector_state,
697 					       new_connector_state,
698 					       BIT(i) & user_connectors_mask);
699 		if (ret)
700 			return ret;
701 		if (old_connector_state->crtc) {
702 			new_crtc_state = drm_atomic_get_new_crtc_state(state,
703 								       old_connector_state->crtc);
704 			if (old_connector_state->link_status !=
705 			    new_connector_state->link_status)
706 				new_crtc_state->connectors_changed = true;
707 
708 			if (old_connector_state->max_requested_bpc !=
709 			    new_connector_state->max_requested_bpc)
710 				new_crtc_state->connectors_changed = true;
711 		}
712 
713 		if (funcs->atomic_check)
714 			ret = funcs->atomic_check(connector, state);
715 		if (ret) {
716 			drm_dbg_atomic(dev,
717 				       "[CONNECTOR:%d:%s] driver check failed\n",
718 				       connector->base.id, connector->name);
719 			return ret;
720 		}
721 
722 		connectors_mask |= BIT(i);
723 	}
724 
725 	/*
726 	 * After all the routing has been prepared we need to add in any
727 	 * connector which is itself unchanged, but whose CRTC changes its
728 	 * configuration. This must be done before calling mode_fixup in case a
729 	 * crtc only changed its mode but has the same set of connectors.
730 	 */
731 	for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
732 		if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
733 			continue;
734 
735 		drm_dbg_atomic(dev,
736 			       "[CRTC:%d:%s] needs all connectors, enable: %c, active: %c\n",
737 			       crtc->base.id, crtc->name,
738 			       new_crtc_state->enable ? 'y' : 'n',
739 			       new_crtc_state->active ? 'y' : 'n');
740 
741 		ret = drm_atomic_add_affected_connectors(state, crtc);
742 		if (ret != 0)
743 			return ret;
744 
745 		ret = drm_atomic_add_affected_planes(state, crtc);
746 		if (ret != 0)
747 			return ret;
748 	}
749 
750 	/*
751 	 * Iterate over all connectors again, to make sure atomic_check()
752 	 * has been called on them when a modeset is forced.
753 	 */
754 	for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
755 		const struct drm_connector_helper_funcs *funcs = connector->helper_private;
756 
757 		if (connectors_mask & BIT(i))
758 			continue;
759 
760 		if (funcs->atomic_check)
761 			ret = funcs->atomic_check(connector, state);
762 		if (ret) {
763 			drm_dbg_atomic(dev,
764 				       "[CONNECTOR:%d:%s] driver check failed\n",
765 				       connector->base.id, connector->name);
766 			return ret;
767 		}
768 	}
769 
770 	/*
771 	 * Iterate over all connectors again, and add all affected bridges to
772 	 * the state.
773 	 */
774 	for_each_oldnew_connector_in_state(state, connector,
775 					   old_connector_state,
776 					   new_connector_state, i) {
777 		struct drm_encoder *encoder;
778 
779 		encoder = old_connector_state->best_encoder;
780 		ret = drm_atomic_add_encoder_bridges(state, encoder);
781 		if (ret)
782 			return ret;
783 
784 		encoder = new_connector_state->best_encoder;
785 		ret = drm_atomic_add_encoder_bridges(state, encoder);
786 		if (ret)
787 			return ret;
788 	}
789 
790 	ret = mode_valid(state);
791 	if (ret)
792 		return ret;
793 
794 	return mode_fixup(state);
795 }
796 EXPORT_SYMBOL(drm_atomic_helper_check_modeset);
797 
798 /**
799  * drm_atomic_helper_check_wb_connector_state() - Check writeback connector state
800  * @connector: corresponding connector
801  * @state: the driver state object
802  *
803  * Checks if the writeback connector state is valid, and returns an error if it
804  * isn't.
805  *
806  * RETURNS:
807  * Zero for success or -errno
808  */
809 int
drm_atomic_helper_check_wb_connector_state(struct drm_connector * connector,struct drm_atomic_state * state)810 drm_atomic_helper_check_wb_connector_state(struct drm_connector *connector,
811 					   struct drm_atomic_state *state)
812 {
813 	struct drm_connector_state *conn_state =
814 		drm_atomic_get_new_connector_state(state, connector);
815 	struct drm_writeback_job *wb_job = conn_state->writeback_job;
816 	struct drm_property_blob *pixel_format_blob;
817 	struct drm_framebuffer *fb;
818 	size_t i, nformats;
819 	u32 *formats;
820 
821 	if (!wb_job || !wb_job->fb)
822 		return 0;
823 
824 	pixel_format_blob = wb_job->connector->pixel_formats_blob_ptr;
825 	nformats = pixel_format_blob->length / sizeof(u32);
826 	formats = pixel_format_blob->data;
827 	fb = wb_job->fb;
828 
829 	for (i = 0; i < nformats; i++)
830 		if (fb->format->format == formats[i])
831 			return 0;
832 
833 	drm_dbg_kms(connector->dev, "Invalid pixel format %p4cc\n", &fb->format->format);
834 
835 	return -EINVAL;
836 }
837 EXPORT_SYMBOL(drm_atomic_helper_check_wb_connector_state);
838 
839 /**
840  * drm_atomic_helper_check_plane_state() - Check plane state for validity
841  * @plane_state: plane state to check
842  * @crtc_state: CRTC state to check
843  * @min_scale: minimum @src:@dest scaling factor in 16.16 fixed point
844  * @max_scale: maximum @src:@dest scaling factor in 16.16 fixed point
845  * @can_position: is it legal to position the plane such that it
846  *                doesn't cover the entire CRTC?  This will generally
847  *                only be false for primary planes.
848  * @can_update_disabled: can the plane be updated while the CRTC
849  *                       is disabled?
850  *
851  * Checks that a desired plane update is valid, and updates various
852  * bits of derived state (clipped coordinates etc.). Drivers that provide
853  * their own plane handling rather than helper-provided implementations may
854  * still wish to call this function to avoid duplication of error checking
855  * code.
856  *
857  * RETURNS:
858  * Zero if update appears valid, error code on failure
859  */
drm_atomic_helper_check_plane_state(struct drm_plane_state * plane_state,const struct drm_crtc_state * crtc_state,int min_scale,int max_scale,bool can_position,bool can_update_disabled)860 int drm_atomic_helper_check_plane_state(struct drm_plane_state *plane_state,
861 					const struct drm_crtc_state *crtc_state,
862 					int min_scale,
863 					int max_scale,
864 					bool can_position,
865 					bool can_update_disabled)
866 {
867 	struct drm_framebuffer *fb = plane_state->fb;
868 	struct drm_rect *src = &plane_state->src;
869 	struct drm_rect *dst = &plane_state->dst;
870 	unsigned int rotation = plane_state->rotation;
871 	struct drm_rect clip = {};
872 	int hscale, vscale;
873 
874 	WARN_ON(plane_state->crtc && plane_state->crtc != crtc_state->crtc);
875 
876 	*src = drm_plane_state_src(plane_state);
877 	*dst = drm_plane_state_dest(plane_state);
878 
879 	if (!fb) {
880 		plane_state->visible = false;
881 		return 0;
882 	}
883 
884 	/* crtc should only be NULL when disabling (i.e., !fb) */
885 	if (WARN_ON(!plane_state->crtc)) {
886 		plane_state->visible = false;
887 		return 0;
888 	}
889 
890 	if (!crtc_state->enable && !can_update_disabled) {
891 		drm_dbg_kms(plane_state->plane->dev,
892 			    "Cannot update plane of a disabled CRTC.\n");
893 		return -EINVAL;
894 	}
895 
896 	drm_rect_rotate(src, fb->width << 16, fb->height << 16, rotation);
897 
898 	/* Check scaling */
899 	hscale = drm_rect_calc_hscale(src, dst, min_scale, max_scale);
900 	vscale = drm_rect_calc_vscale(src, dst, min_scale, max_scale);
901 	if (hscale < 0 || vscale < 0) {
902 		drm_dbg_kms(plane_state->plane->dev,
903 			    "Invalid scaling of plane\n");
904 		drm_rect_debug_print("src: ", &plane_state->src, true);
905 		drm_rect_debug_print("dst: ", &plane_state->dst, false);
906 		return -ERANGE;
907 	}
908 
909 	if (crtc_state->enable)
910 		drm_mode_get_hv_timing(&crtc_state->mode, &clip.x2, &clip.y2);
911 
912 	plane_state->visible = drm_rect_clip_scaled(src, dst, &clip);
913 
914 	drm_rect_rotate_inv(src, fb->width << 16, fb->height << 16, rotation);
915 
916 	if (!plane_state->visible)
917 		/*
918 		 * Plane isn't visible; some drivers can handle this
919 		 * so we just return success here.  Drivers that can't
920 		 * (including those that use the primary plane helper's
921 		 * update function) will return an error from their
922 		 * update_plane handler.
923 		 */
924 		return 0;
925 
926 	if (!can_position && !drm_rect_equals(dst, &clip)) {
927 		drm_dbg_kms(plane_state->plane->dev,
928 			    "Plane must cover entire CRTC\n");
929 		drm_rect_debug_print("dst: ", dst, false);
930 		drm_rect_debug_print("clip: ", &clip, false);
931 		return -EINVAL;
932 	}
933 
934 	return 0;
935 }
936 EXPORT_SYMBOL(drm_atomic_helper_check_plane_state);
937 
938 /**
939  * drm_atomic_helper_check_crtc_primary_plane() - Check CRTC state for primary plane
940  * @crtc_state: CRTC state to check
941  *
942  * Checks that a CRTC has at least one primary plane attached to it, which is
943  * a requirement on some hardware. Note that this only involves the CRTC side
944  * of the test. To test if the primary plane is visible or if it can be updated
945  * without the CRTC being enabled, use drm_atomic_helper_check_plane_state() in
946  * the plane's atomic check.
947  *
948  * RETURNS:
949  * 0 if a primary plane is attached to the CRTC, or an error code otherwise
950  */
drm_atomic_helper_check_crtc_primary_plane(struct drm_crtc_state * crtc_state)951 int drm_atomic_helper_check_crtc_primary_plane(struct drm_crtc_state *crtc_state)
952 {
953 	struct drm_crtc *crtc = crtc_state->crtc;
954 	struct drm_device *dev = crtc->dev;
955 	struct drm_plane *plane;
956 
957 	/* needs at least one primary plane to be enabled */
958 	drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
959 		if (plane->type == DRM_PLANE_TYPE_PRIMARY)
960 			return 0;
961 	}
962 
963 	drm_dbg_atomic(dev, "[CRTC:%d:%s] primary plane missing\n", crtc->base.id, crtc->name);
964 
965 	return -EINVAL;
966 }
967 EXPORT_SYMBOL(drm_atomic_helper_check_crtc_primary_plane);
968 
969 /**
970  * drm_atomic_helper_check_planes - validate state object for planes changes
971  * @dev: DRM device
972  * @state: the driver state object
973  *
974  * Check the state object to see if the requested state is physically possible.
975  * This does all the plane update related checks using by calling into the
976  * &drm_crtc_helper_funcs.atomic_check and &drm_plane_helper_funcs.atomic_check
977  * hooks provided by the driver.
978  *
979  * It also sets &drm_crtc_state.planes_changed to indicate that a CRTC has
980  * updated planes.
981  *
982  * RETURNS:
983  * Zero for success or -errno
984  */
985 int
drm_atomic_helper_check_planes(struct drm_device * dev,struct drm_atomic_state * state)986 drm_atomic_helper_check_planes(struct drm_device *dev,
987 			       struct drm_atomic_state *state)
988 {
989 	struct drm_crtc *crtc;
990 	struct drm_crtc_state *new_crtc_state;
991 	struct drm_plane *plane;
992 	struct drm_plane_state *new_plane_state, *old_plane_state;
993 	int i, ret = 0;
994 
995 	for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
996 		const struct drm_plane_helper_funcs *funcs;
997 
998 		WARN_ON(!drm_modeset_is_locked(&plane->mutex));
999 
1000 		funcs = plane->helper_private;
1001 
1002 		drm_atomic_helper_plane_changed(state, old_plane_state, new_plane_state, plane);
1003 
1004 		drm_atomic_helper_check_plane_damage(state, new_plane_state);
1005 
1006 		if (!funcs || !funcs->atomic_check)
1007 			continue;
1008 
1009 		ret = funcs->atomic_check(plane, state);
1010 		if (ret) {
1011 			drm_dbg_atomic(plane->dev,
1012 				       "[PLANE:%d:%s] atomic driver check failed\n",
1013 				       plane->base.id, plane->name);
1014 			return ret;
1015 		}
1016 	}
1017 
1018 	for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1019 		const struct drm_crtc_helper_funcs *funcs;
1020 
1021 		funcs = crtc->helper_private;
1022 
1023 		if (!funcs || !funcs->atomic_check)
1024 			continue;
1025 
1026 		ret = funcs->atomic_check(crtc, state);
1027 		if (ret) {
1028 			drm_dbg_atomic(crtc->dev,
1029 				       "[CRTC:%d:%s] atomic driver check failed\n",
1030 				       crtc->base.id, crtc->name);
1031 			return ret;
1032 		}
1033 	}
1034 
1035 	return ret;
1036 }
1037 EXPORT_SYMBOL(drm_atomic_helper_check_planes);
1038 
1039 /**
1040  * drm_atomic_helper_check - validate state object
1041  * @dev: DRM device
1042  * @state: the driver state object
1043  *
1044  * Check the state object to see if the requested state is physically possible.
1045  * Only CRTCs and planes have check callbacks, so for any additional (global)
1046  * checking that a driver needs it can simply wrap that around this function.
1047  * Drivers without such needs can directly use this as their
1048  * &drm_mode_config_funcs.atomic_check callback.
1049  *
1050  * This just wraps the two parts of the state checking for planes and modeset
1051  * state in the default order: First it calls drm_atomic_helper_check_modeset()
1052  * and then drm_atomic_helper_check_planes(). The assumption is that the
1053  * @drm_plane_helper_funcs.atomic_check and @drm_crtc_helper_funcs.atomic_check
1054  * functions depend upon an updated adjusted_mode.clock to e.g. properly compute
1055  * watermarks.
1056  *
1057  * Note that zpos normalization will add all enable planes to the state which
1058  * might not desired for some drivers.
1059  * For example enable/disable of a cursor plane which have fixed zpos value
1060  * would trigger all other enabled planes to be forced to the state change.
1061  *
1062  * RETURNS:
1063  * Zero for success or -errno
1064  */
drm_atomic_helper_check(struct drm_device * dev,struct drm_atomic_state * state)1065 int drm_atomic_helper_check(struct drm_device *dev,
1066 			    struct drm_atomic_state *state)
1067 {
1068 	int ret;
1069 
1070 	ret = drm_atomic_helper_check_modeset(dev, state);
1071 	if (ret)
1072 		return ret;
1073 
1074 	if (dev->mode_config.normalize_zpos) {
1075 		ret = drm_atomic_normalize_zpos(dev, state);
1076 		if (ret)
1077 			return ret;
1078 	}
1079 
1080 	ret = drm_atomic_helper_check_planes(dev, state);
1081 	if (ret)
1082 		return ret;
1083 
1084 	if (state->legacy_cursor_update)
1085 		state->async_update = !drm_atomic_helper_async_check(dev, state);
1086 
1087 	drm_self_refresh_helper_alter_state(state);
1088 
1089 	return ret;
1090 }
1091 EXPORT_SYMBOL(drm_atomic_helper_check);
1092 
1093 static bool
crtc_needs_disable(struct drm_crtc_state * old_state,struct drm_crtc_state * new_state)1094 crtc_needs_disable(struct drm_crtc_state *old_state,
1095 		   struct drm_crtc_state *new_state)
1096 {
1097 	/*
1098 	 * No new_state means the CRTC is off, so the only criteria is whether
1099 	 * it's currently active or in self refresh mode.
1100 	 */
1101 	if (!new_state)
1102 		return drm_atomic_crtc_effectively_active(old_state);
1103 
1104 	/*
1105 	 * We need to disable bridge(s) and CRTC if we're transitioning out of
1106 	 * self-refresh and changing CRTCs at the same time, because the
1107 	 * bridge tracks self-refresh status via CRTC state.
1108 	 */
1109 	if (old_state->self_refresh_active &&
1110 	    old_state->crtc != new_state->crtc)
1111 		return true;
1112 
1113 	/*
1114 	 * We also need to run through the crtc_funcs->disable() function if
1115 	 * the CRTC is currently on, if it's transitioning to self refresh
1116 	 * mode, or if it's in self refresh mode and needs to be fully
1117 	 * disabled.
1118 	 */
1119 	return old_state->active ||
1120 	       (old_state->self_refresh_active && !new_state->active) ||
1121 	       new_state->self_refresh_active;
1122 }
1123 
1124 static void
disable_outputs(struct drm_device * dev,struct drm_atomic_state * old_state)1125 disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state)
1126 {
1127 	struct drm_connector *connector;
1128 	struct drm_connector_state *old_conn_state, *new_conn_state;
1129 	struct drm_crtc *crtc;
1130 	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1131 	int i;
1132 
1133 	for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
1134 		const struct drm_encoder_helper_funcs *funcs;
1135 		struct drm_encoder *encoder;
1136 		struct drm_bridge *bridge;
1137 
1138 		/*
1139 		 * Shut down everything that's in the changeset and currently
1140 		 * still on. So need to check the old, saved state.
1141 		 */
1142 		if (!old_conn_state->crtc)
1143 			continue;
1144 
1145 		old_crtc_state = drm_atomic_get_old_crtc_state(old_state, old_conn_state->crtc);
1146 
1147 		if (new_conn_state->crtc)
1148 			new_crtc_state = drm_atomic_get_new_crtc_state(
1149 						old_state,
1150 						new_conn_state->crtc);
1151 		else
1152 			new_crtc_state = NULL;
1153 
1154 		if (!crtc_needs_disable(old_crtc_state, new_crtc_state) ||
1155 		    !drm_atomic_crtc_needs_modeset(old_conn_state->crtc->state))
1156 			continue;
1157 
1158 		encoder = old_conn_state->best_encoder;
1159 
1160 		/* We shouldn't get this far if we didn't previously have
1161 		 * an encoder.. but WARN_ON() rather than explode.
1162 		 */
1163 		if (WARN_ON(!encoder))
1164 			continue;
1165 
1166 		funcs = encoder->helper_private;
1167 
1168 		drm_dbg_atomic(dev, "disabling [ENCODER:%d:%s]\n",
1169 			       encoder->base.id, encoder->name);
1170 
1171 		/*
1172 		 * Each encoder has at most one connector (since we always steal
1173 		 * it away), so we won't call disable hooks twice.
1174 		 */
1175 		bridge = drm_bridge_chain_get_first_bridge(encoder);
1176 		drm_atomic_bridge_chain_disable(bridge, old_state);
1177 
1178 		/* Right function depends upon target state. */
1179 		if (funcs) {
1180 			if (funcs->atomic_disable)
1181 				funcs->atomic_disable(encoder, old_state);
1182 			else if (new_conn_state->crtc && funcs->prepare)
1183 				funcs->prepare(encoder);
1184 			else if (funcs->disable)
1185 				funcs->disable(encoder);
1186 			else if (funcs->dpms)
1187 				funcs->dpms(encoder, DRM_MODE_DPMS_OFF);
1188 		}
1189 
1190 		drm_atomic_bridge_chain_post_disable(bridge, old_state);
1191 	}
1192 
1193 	for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1194 		const struct drm_crtc_helper_funcs *funcs;
1195 		int ret;
1196 
1197 		/* Shut down everything that needs a full modeset. */
1198 		if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
1199 			continue;
1200 
1201 		if (!crtc_needs_disable(old_crtc_state, new_crtc_state))
1202 			continue;
1203 
1204 		funcs = crtc->helper_private;
1205 
1206 		drm_dbg_atomic(dev, "disabling [CRTC:%d:%s]\n",
1207 			       crtc->base.id, crtc->name);
1208 
1209 
1210 		/* Right function depends upon target state. */
1211 		if (new_crtc_state->enable && funcs->prepare)
1212 			funcs->prepare(crtc);
1213 		else if (funcs->atomic_disable)
1214 			funcs->atomic_disable(crtc, old_state);
1215 		else if (funcs->disable)
1216 			funcs->disable(crtc);
1217 		else if (funcs->dpms)
1218 			funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
1219 
1220 		if (!drm_dev_has_vblank(dev))
1221 			continue;
1222 
1223 		ret = drm_crtc_vblank_get(crtc);
1224 		/*
1225 		 * Self-refresh is not a true "disable"; ensure vblank remains
1226 		 * enabled.
1227 		 */
1228 		if (new_crtc_state->self_refresh_active)
1229 			WARN_ONCE(ret != 0,
1230 				  "driver disabled vblank in self-refresh\n");
1231 		else
1232 			WARN_ONCE(ret != -EINVAL,
1233 				  "driver forgot to call drm_crtc_vblank_off()\n");
1234 		if (ret == 0)
1235 			drm_crtc_vblank_put(crtc);
1236 	}
1237 }
1238 
1239 /**
1240  * drm_atomic_helper_update_legacy_modeset_state - update legacy modeset state
1241  * @dev: DRM device
1242  * @old_state: atomic state object with old state structures
1243  *
1244  * This function updates all the various legacy modeset state pointers in
1245  * connectors, encoders and CRTCs.
1246  *
1247  * Drivers can use this for building their own atomic commit if they don't have
1248  * a pure helper-based modeset implementation.
1249  *
1250  * Since these updates are not synchronized with lockings, only code paths
1251  * called from &drm_mode_config_helper_funcs.atomic_commit_tail can look at the
1252  * legacy state filled out by this helper. Defacto this means this helper and
1253  * the legacy state pointers are only really useful for transitioning an
1254  * existing driver to the atomic world.
1255  */
1256 void
drm_atomic_helper_update_legacy_modeset_state(struct drm_device * dev,struct drm_atomic_state * old_state)1257 drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
1258 					      struct drm_atomic_state *old_state)
1259 {
1260 	struct drm_connector *connector;
1261 	struct drm_connector_state *old_conn_state, *new_conn_state;
1262 	struct drm_crtc *crtc;
1263 	struct drm_crtc_state *new_crtc_state;
1264 	int i;
1265 
1266 	/* clear out existing links and update dpms */
1267 	for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
1268 		if (connector->encoder) {
1269 			WARN_ON(!connector->encoder->crtc);
1270 
1271 			connector->encoder->crtc = NULL;
1272 			connector->encoder = NULL;
1273 		}
1274 
1275 		crtc = new_conn_state->crtc;
1276 		if ((!crtc && old_conn_state->crtc) ||
1277 		    (crtc && drm_atomic_crtc_needs_modeset(crtc->state))) {
1278 			int mode = DRM_MODE_DPMS_OFF;
1279 
1280 			if (crtc && crtc->state->active)
1281 				mode = DRM_MODE_DPMS_ON;
1282 
1283 			connector->dpms = mode;
1284 		}
1285 	}
1286 
1287 	/* set new links */
1288 	for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1289 		if (!new_conn_state->crtc)
1290 			continue;
1291 
1292 		if (WARN_ON(!new_conn_state->best_encoder))
1293 			continue;
1294 
1295 		connector->encoder = new_conn_state->best_encoder;
1296 		connector->encoder->crtc = new_conn_state->crtc;
1297 	}
1298 
1299 	/* set legacy state in the crtc structure */
1300 	for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
1301 		struct drm_plane *primary = crtc->primary;
1302 		struct drm_plane_state *new_plane_state;
1303 
1304 		crtc->mode = new_crtc_state->mode;
1305 		crtc->enabled = new_crtc_state->enable;
1306 
1307 		new_plane_state =
1308 			drm_atomic_get_new_plane_state(old_state, primary);
1309 
1310 		if (new_plane_state && new_plane_state->crtc == crtc) {
1311 			crtc->x = new_plane_state->src_x >> 16;
1312 			crtc->y = new_plane_state->src_y >> 16;
1313 		}
1314 	}
1315 }
1316 EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state);
1317 
1318 /**
1319  * drm_atomic_helper_calc_timestamping_constants - update vblank timestamping constants
1320  * @state: atomic state object
1321  *
1322  * Updates the timestamping constants used for precise vblank timestamps
1323  * by calling drm_calc_timestamping_constants() for all enabled crtcs in @state.
1324  */
drm_atomic_helper_calc_timestamping_constants(struct drm_atomic_state * state)1325 void drm_atomic_helper_calc_timestamping_constants(struct drm_atomic_state *state)
1326 {
1327 	struct drm_crtc_state *new_crtc_state;
1328 	struct drm_crtc *crtc;
1329 	int i;
1330 
1331 	for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1332 		if (new_crtc_state->enable)
1333 			drm_calc_timestamping_constants(crtc,
1334 							&new_crtc_state->adjusted_mode);
1335 	}
1336 }
1337 EXPORT_SYMBOL(drm_atomic_helper_calc_timestamping_constants);
1338 
1339 static void
crtc_set_mode(struct drm_device * dev,struct drm_atomic_state * old_state)1340 crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state)
1341 {
1342 	struct drm_crtc *crtc;
1343 	struct drm_crtc_state *new_crtc_state;
1344 	struct drm_connector *connector;
1345 	struct drm_connector_state *new_conn_state;
1346 	int i;
1347 
1348 	for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
1349 		const struct drm_crtc_helper_funcs *funcs;
1350 
1351 		if (!new_crtc_state->mode_changed)
1352 			continue;
1353 
1354 		funcs = crtc->helper_private;
1355 
1356 		if (new_crtc_state->enable && funcs->mode_set_nofb) {
1357 			drm_dbg_atomic(dev, "modeset on [CRTC:%d:%s]\n",
1358 				       crtc->base.id, crtc->name);
1359 
1360 			funcs->mode_set_nofb(crtc);
1361 		}
1362 	}
1363 
1364 	for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1365 		const struct drm_encoder_helper_funcs *funcs;
1366 		struct drm_encoder *encoder;
1367 		struct drm_display_mode *mode, *adjusted_mode;
1368 		struct drm_bridge *bridge;
1369 
1370 		if (!new_conn_state->best_encoder)
1371 			continue;
1372 
1373 		encoder = new_conn_state->best_encoder;
1374 		funcs = encoder->helper_private;
1375 		new_crtc_state = new_conn_state->crtc->state;
1376 		mode = &new_crtc_state->mode;
1377 		adjusted_mode = &new_crtc_state->adjusted_mode;
1378 
1379 		if (!new_crtc_state->mode_changed)
1380 			continue;
1381 
1382 		drm_dbg_atomic(dev, "modeset on [ENCODER:%d:%s]\n",
1383 			       encoder->base.id, encoder->name);
1384 
1385 		/*
1386 		 * Each encoder has at most one connector (since we always steal
1387 		 * it away), so we won't call mode_set hooks twice.
1388 		 */
1389 		if (funcs && funcs->atomic_mode_set) {
1390 			funcs->atomic_mode_set(encoder, new_crtc_state,
1391 					       new_conn_state);
1392 		} else if (funcs && funcs->mode_set) {
1393 			funcs->mode_set(encoder, mode, adjusted_mode);
1394 		}
1395 
1396 		bridge = drm_bridge_chain_get_first_bridge(encoder);
1397 		drm_bridge_chain_mode_set(bridge, mode, adjusted_mode);
1398 	}
1399 }
1400 
1401 /**
1402  * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs
1403  * @dev: DRM device
1404  * @old_state: atomic state object with old state structures
1405  *
1406  * This function shuts down all the outputs that need to be shut down and
1407  * prepares them (if required) with the new mode.
1408  *
1409  * For compatibility with legacy CRTC helpers this should be called before
1410  * drm_atomic_helper_commit_planes(), which is what the default commit function
1411  * does. But drivers with different needs can group the modeset commits together
1412  * and do the plane commits at the end. This is useful for drivers doing runtime
1413  * PM since planes updates then only happen when the CRTC is actually enabled.
1414  */
drm_atomic_helper_commit_modeset_disables(struct drm_device * dev,struct drm_atomic_state * old_state)1415 void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
1416 					       struct drm_atomic_state *old_state)
1417 {
1418 	disable_outputs(dev, old_state);
1419 
1420 	drm_atomic_helper_update_legacy_modeset_state(dev, old_state);
1421 	drm_atomic_helper_calc_timestamping_constants(old_state);
1422 
1423 	crtc_set_mode(dev, old_state);
1424 }
1425 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables);
1426 
drm_atomic_helper_commit_writebacks(struct drm_device * dev,struct drm_atomic_state * old_state)1427 static void drm_atomic_helper_commit_writebacks(struct drm_device *dev,
1428 						struct drm_atomic_state *old_state)
1429 {
1430 	struct drm_connector *connector;
1431 	struct drm_connector_state *new_conn_state;
1432 	int i;
1433 
1434 	for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1435 		const struct drm_connector_helper_funcs *funcs;
1436 
1437 		funcs = connector->helper_private;
1438 		if (!funcs->atomic_commit)
1439 			continue;
1440 
1441 		if (new_conn_state->writeback_job && new_conn_state->writeback_job->fb) {
1442 			WARN_ON(connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK);
1443 			funcs->atomic_commit(connector, old_state);
1444 		}
1445 	}
1446 }
1447 
1448 /**
1449  * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs
1450  * @dev: DRM device
1451  * @old_state: atomic state object with old state structures
1452  *
1453  * This function enables all the outputs with the new configuration which had to
1454  * be turned off for the update.
1455  *
1456  * For compatibility with legacy CRTC helpers this should be called after
1457  * drm_atomic_helper_commit_planes(), which is what the default commit function
1458  * does. But drivers with different needs can group the modeset commits together
1459  * and do the plane commits at the end. This is useful for drivers doing runtime
1460  * PM since planes updates then only happen when the CRTC is actually enabled.
1461  */
drm_atomic_helper_commit_modeset_enables(struct drm_device * dev,struct drm_atomic_state * old_state)1462 void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
1463 					      struct drm_atomic_state *old_state)
1464 {
1465 	struct drm_crtc *crtc;
1466 	struct drm_crtc_state *old_crtc_state;
1467 	struct drm_crtc_state *new_crtc_state;
1468 	struct drm_connector *connector;
1469 	struct drm_connector_state *new_conn_state;
1470 	int i;
1471 
1472 	for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1473 		const struct drm_crtc_helper_funcs *funcs;
1474 
1475 		/* Need to filter out CRTCs where only planes change. */
1476 		if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
1477 			continue;
1478 
1479 		if (!new_crtc_state->active)
1480 			continue;
1481 
1482 		funcs = crtc->helper_private;
1483 
1484 		if (new_crtc_state->enable) {
1485 			drm_dbg_atomic(dev, "enabling [CRTC:%d:%s]\n",
1486 				       crtc->base.id, crtc->name);
1487 			if (funcs->atomic_enable)
1488 				funcs->atomic_enable(crtc, old_state);
1489 			else if (funcs->commit)
1490 				funcs->commit(crtc);
1491 		}
1492 	}
1493 
1494 	for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1495 		const struct drm_encoder_helper_funcs *funcs;
1496 		struct drm_encoder *encoder;
1497 		struct drm_bridge *bridge;
1498 
1499 		if (!new_conn_state->best_encoder)
1500 			continue;
1501 
1502 		if (!new_conn_state->crtc->state->active ||
1503 		    !drm_atomic_crtc_needs_modeset(new_conn_state->crtc->state))
1504 			continue;
1505 
1506 		encoder = new_conn_state->best_encoder;
1507 		funcs = encoder->helper_private;
1508 
1509 		drm_dbg_atomic(dev, "enabling [ENCODER:%d:%s]\n",
1510 			       encoder->base.id, encoder->name);
1511 
1512 		/*
1513 		 * Each encoder has at most one connector (since we always steal
1514 		 * it away), so we won't call enable hooks twice.
1515 		 */
1516 		bridge = drm_bridge_chain_get_first_bridge(encoder);
1517 		drm_atomic_bridge_chain_pre_enable(bridge, old_state);
1518 
1519 		if (funcs) {
1520 			if (funcs->atomic_enable)
1521 				funcs->atomic_enable(encoder, old_state);
1522 			else if (funcs->enable)
1523 				funcs->enable(encoder);
1524 			else if (funcs->commit)
1525 				funcs->commit(encoder);
1526 		}
1527 
1528 		drm_atomic_bridge_chain_enable(bridge, old_state);
1529 	}
1530 
1531 	drm_atomic_helper_commit_writebacks(dev, old_state);
1532 }
1533 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
1534 
1535 /*
1536  * For atomic updates which touch just a single CRTC, calculate the time of the
1537  * next vblank, and inform all the fences of the deadline.
1538  */
set_fence_deadline(struct drm_device * dev,struct drm_atomic_state * state)1539 static void set_fence_deadline(struct drm_device *dev,
1540 			       struct drm_atomic_state *state)
1541 {
1542 	struct drm_crtc *crtc;
1543 	struct drm_crtc_state *new_crtc_state;
1544 	struct drm_plane *plane;
1545 	struct drm_plane_state *new_plane_state;
1546 	ktime_t vbltime = 0;
1547 	int i;
1548 
1549 	for_each_new_crtc_in_state (state, crtc, new_crtc_state, i) {
1550 		ktime_t v;
1551 
1552 		if (drm_atomic_crtc_needs_modeset(new_crtc_state))
1553 			continue;
1554 
1555 		if (!new_crtc_state->active)
1556 			continue;
1557 
1558 		if (drm_crtc_next_vblank_start(crtc, &v))
1559 			continue;
1560 
1561 		if (!vbltime || ktime_before(v, vbltime))
1562 			vbltime = v;
1563 	}
1564 
1565 	/* If no CRTCs updated, then nothing to do: */
1566 	if (!vbltime)
1567 		return;
1568 
1569 	for_each_new_plane_in_state (state, plane, new_plane_state, i) {
1570 		if (!new_plane_state->fence)
1571 			continue;
1572 		dma_fence_set_deadline(new_plane_state->fence, vbltime);
1573 	}
1574 }
1575 
1576 /**
1577  * drm_atomic_helper_wait_for_fences - wait for fences stashed in plane state
1578  * @dev: DRM device
1579  * @state: atomic state object with old state structures
1580  * @pre_swap: If true, do an interruptible wait, and @state is the new state.
1581  *	Otherwise @state is the old state.
1582  *
1583  * For implicit sync, driver should fish the exclusive fence out from the
1584  * incoming fb's and stash it in the drm_plane_state.  This is called after
1585  * drm_atomic_helper_swap_state() so it uses the current plane state (and
1586  * just uses the atomic state to find the changed planes)
1587  *
1588  * Note that @pre_swap is needed since the point where we block for fences moves
1589  * around depending upon whether an atomic commit is blocking or
1590  * non-blocking. For non-blocking commit all waiting needs to happen after
1591  * drm_atomic_helper_swap_state() is called, but for blocking commits we want
1592  * to wait **before** we do anything that can't be easily rolled back. That is
1593  * before we call drm_atomic_helper_swap_state().
1594  *
1595  * Returns zero if success or < 0 if dma_fence_wait() fails.
1596  */
drm_atomic_helper_wait_for_fences(struct drm_device * dev,struct drm_atomic_state * state,bool pre_swap)1597 int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
1598 				      struct drm_atomic_state *state,
1599 				      bool pre_swap)
1600 {
1601 	struct drm_plane *plane;
1602 	struct drm_plane_state *new_plane_state;
1603 	int i, ret;
1604 
1605 	set_fence_deadline(dev, state);
1606 
1607 	for_each_new_plane_in_state(state, plane, new_plane_state, i) {
1608 		if (!new_plane_state->fence)
1609 			continue;
1610 
1611 		WARN_ON(!new_plane_state->fb);
1612 
1613 		/*
1614 		 * If waiting for fences pre-swap (ie: nonblock), userspace can
1615 		 * still interrupt the operation. Instead of blocking until the
1616 		 * timer expires, make the wait interruptible.
1617 		 */
1618 		ret = dma_fence_wait(new_plane_state->fence, pre_swap);
1619 		if (ret)
1620 			return ret;
1621 
1622 		dma_fence_put(new_plane_state->fence);
1623 		new_plane_state->fence = NULL;
1624 	}
1625 
1626 	return 0;
1627 }
1628 EXPORT_SYMBOL(drm_atomic_helper_wait_for_fences);
1629 
1630 /**
1631  * drm_atomic_helper_wait_for_vblanks - wait for vblank on CRTCs
1632  * @dev: DRM device
1633  * @old_state: atomic state object with old state structures
1634  *
1635  * Helper to, after atomic commit, wait for vblanks on all affected
1636  * CRTCs (ie. before cleaning up old framebuffers using
1637  * drm_atomic_helper_cleanup_planes()). It will only wait on CRTCs where the
1638  * framebuffers have actually changed to optimize for the legacy cursor and
1639  * plane update use-case.
1640  *
1641  * Drivers using the nonblocking commit tracking support initialized by calling
1642  * drm_atomic_helper_setup_commit() should look at
1643  * drm_atomic_helper_wait_for_flip_done() as an alternative.
1644  */
1645 void
drm_atomic_helper_wait_for_vblanks(struct drm_device * dev,struct drm_atomic_state * old_state)1646 drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
1647 		struct drm_atomic_state *old_state)
1648 {
1649 	struct drm_crtc *crtc;
1650 	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1651 	int i, ret;
1652 	unsigned int crtc_mask = 0;
1653 
1654 	 /*
1655 	  * Legacy cursor ioctls are completely unsynced, and userspace
1656 	  * relies on that (by doing tons of cursor updates).
1657 	  */
1658 	if (old_state->legacy_cursor_update)
1659 		return;
1660 
1661 	for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1662 		if (!new_crtc_state->active)
1663 			continue;
1664 
1665 		ret = drm_crtc_vblank_get(crtc);
1666 		if (ret != 0)
1667 			continue;
1668 
1669 		crtc_mask |= drm_crtc_mask(crtc);
1670 		old_state->crtcs[i].last_vblank_count = drm_crtc_vblank_count(crtc);
1671 	}
1672 
1673 	for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1674 		if (!(crtc_mask & drm_crtc_mask(crtc)))
1675 			continue;
1676 
1677 		ret = wait_event_timeout(dev->vblank[i].queue,
1678 				old_state->crtcs[i].last_vblank_count !=
1679 					drm_crtc_vblank_count(crtc),
1680 				msecs_to_jiffies(100));
1681 
1682 		WARN(!ret, "[CRTC:%d:%s] vblank wait timed out\n",
1683 		     crtc->base.id, crtc->name);
1684 
1685 		drm_crtc_vblank_put(crtc);
1686 	}
1687 }
1688 EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
1689 
1690 /**
1691  * drm_atomic_helper_wait_for_flip_done - wait for all page flips to be done
1692  * @dev: DRM device
1693  * @old_state: atomic state object with old state structures
1694  *
1695  * Helper to, after atomic commit, wait for page flips on all affected
1696  * crtcs (ie. before cleaning up old framebuffers using
1697  * drm_atomic_helper_cleanup_planes()). Compared to
1698  * drm_atomic_helper_wait_for_vblanks() this waits for the completion on all
1699  * CRTCs, assuming that cursors-only updates are signalling their completion
1700  * immediately (or using a different path).
1701  *
1702  * This requires that drivers use the nonblocking commit tracking support
1703  * initialized using drm_atomic_helper_setup_commit().
1704  */
drm_atomic_helper_wait_for_flip_done(struct drm_device * dev,struct drm_atomic_state * old_state)1705 void drm_atomic_helper_wait_for_flip_done(struct drm_device *dev,
1706 					  struct drm_atomic_state *old_state)
1707 {
1708 	struct drm_crtc *crtc;
1709 	int i;
1710 
1711 	for (i = 0; i < dev->mode_config.num_crtc; i++) {
1712 		struct drm_crtc_commit *commit = old_state->crtcs[i].commit;
1713 		int ret;
1714 
1715 		crtc = old_state->crtcs[i].ptr;
1716 
1717 		if (!crtc || !commit)
1718 			continue;
1719 
1720 		ret = wait_for_completion_timeout(&commit->flip_done, 10 * HZ);
1721 		if (ret == 0)
1722 			drm_err(dev, "[CRTC:%d:%s] flip_done timed out\n",
1723 				crtc->base.id, crtc->name);
1724 	}
1725 
1726 	if (old_state->fake_commit)
1727 		complete_all(&old_state->fake_commit->flip_done);
1728 }
1729 EXPORT_SYMBOL(drm_atomic_helper_wait_for_flip_done);
1730 
1731 /**
1732  * drm_atomic_helper_commit_tail - commit atomic update to hardware
1733  * @old_state: atomic state object with old state structures
1734  *
1735  * This is the default implementation for the
1736  * &drm_mode_config_helper_funcs.atomic_commit_tail hook, for drivers
1737  * that do not support runtime_pm or do not need the CRTC to be
1738  * enabled to perform a commit. Otherwise, see
1739  * drm_atomic_helper_commit_tail_rpm().
1740  *
1741  * Note that the default ordering of how the various stages are called is to
1742  * match the legacy modeset helper library closest.
1743  */
drm_atomic_helper_commit_tail(struct drm_atomic_state * old_state)1744 void drm_atomic_helper_commit_tail(struct drm_atomic_state *old_state)
1745 {
1746 	struct drm_device *dev = old_state->dev;
1747 
1748 	drm_atomic_helper_commit_modeset_disables(dev, old_state);
1749 
1750 	drm_atomic_helper_commit_planes(dev, old_state, 0);
1751 
1752 	drm_atomic_helper_commit_modeset_enables(dev, old_state);
1753 
1754 	drm_atomic_helper_fake_vblank(old_state);
1755 
1756 	drm_atomic_helper_commit_hw_done(old_state);
1757 
1758 	drm_atomic_helper_wait_for_vblanks(dev, old_state);
1759 
1760 	drm_atomic_helper_cleanup_planes(dev, old_state);
1761 }
1762 EXPORT_SYMBOL(drm_atomic_helper_commit_tail);
1763 
1764 /**
1765  * drm_atomic_helper_commit_tail_rpm - commit atomic update to hardware
1766  * @old_state: new modeset state to be committed
1767  *
1768  * This is an alternative implementation for the
1769  * &drm_mode_config_helper_funcs.atomic_commit_tail hook, for drivers
1770  * that support runtime_pm or need the CRTC to be enabled to perform a
1771  * commit. Otherwise, one should use the default implementation
1772  * drm_atomic_helper_commit_tail().
1773  */
drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state * old_state)1774 void drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state *old_state)
1775 {
1776 	struct drm_device *dev = old_state->dev;
1777 
1778 	drm_atomic_helper_commit_modeset_disables(dev, old_state);
1779 
1780 	drm_atomic_helper_commit_modeset_enables(dev, old_state);
1781 
1782 	drm_atomic_helper_commit_planes(dev, old_state,
1783 					DRM_PLANE_COMMIT_ACTIVE_ONLY);
1784 
1785 	drm_atomic_helper_fake_vblank(old_state);
1786 
1787 	drm_atomic_helper_commit_hw_done(old_state);
1788 
1789 	drm_atomic_helper_wait_for_vblanks(dev, old_state);
1790 
1791 	drm_atomic_helper_cleanup_planes(dev, old_state);
1792 }
1793 EXPORT_SYMBOL(drm_atomic_helper_commit_tail_rpm);
1794 
commit_tail(struct drm_atomic_state * old_state)1795 static void commit_tail(struct drm_atomic_state *old_state)
1796 {
1797 	struct drm_device *dev = old_state->dev;
1798 	const struct drm_mode_config_helper_funcs *funcs;
1799 	struct drm_crtc_state *new_crtc_state;
1800 	struct drm_crtc *crtc;
1801 	ktime_t start;
1802 	s64 commit_time_ms;
1803 	unsigned int i, new_self_refresh_mask = 0;
1804 
1805 	funcs = dev->mode_config.helper_private;
1806 
1807 	/*
1808 	 * We're measuring the _entire_ commit, so the time will vary depending
1809 	 * on how many fences and objects are involved. For the purposes of self
1810 	 * refresh, this is desirable since it'll give us an idea of how
1811 	 * congested things are. This will inform our decision on how often we
1812 	 * should enter self refresh after idle.
1813 	 *
1814 	 * These times will be averaged out in the self refresh helpers to avoid
1815 	 * overreacting over one outlier frame
1816 	 */
1817 	start = ktime_get();
1818 
1819 	drm_atomic_helper_wait_for_fences(dev, old_state, false);
1820 
1821 	drm_atomic_helper_wait_for_dependencies(old_state);
1822 
1823 	/*
1824 	 * We cannot safely access new_crtc_state after
1825 	 * drm_atomic_helper_commit_hw_done() so figure out which crtc's have
1826 	 * self-refresh active beforehand:
1827 	 */
1828 	for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i)
1829 		if (new_crtc_state->self_refresh_active)
1830 			new_self_refresh_mask |= BIT(i);
1831 
1832 	if (funcs && funcs->atomic_commit_tail)
1833 		funcs->atomic_commit_tail(old_state);
1834 	else
1835 		drm_atomic_helper_commit_tail(old_state);
1836 
1837 	commit_time_ms = ktime_ms_delta(ktime_get(), start);
1838 	if (commit_time_ms > 0)
1839 		drm_self_refresh_helper_update_avg_times(old_state,
1840 						 (unsigned long)commit_time_ms,
1841 						 new_self_refresh_mask);
1842 
1843 	drm_atomic_helper_commit_cleanup_done(old_state);
1844 
1845 	drm_atomic_state_put(old_state);
1846 }
1847 
commit_work(struct work_struct * work)1848 static void commit_work(struct work_struct *work)
1849 {
1850 	struct drm_atomic_state *state = container_of(work,
1851 						      struct drm_atomic_state,
1852 						      commit_work);
1853 	commit_tail(state);
1854 }
1855 
1856 /**
1857  * drm_atomic_helper_async_check - check if state can be committed asynchronously
1858  * @dev: DRM device
1859  * @state: the driver state object
1860  *
1861  * This helper will check if it is possible to commit the state asynchronously.
1862  * Async commits are not supposed to swap the states like normal sync commits
1863  * but just do in-place changes on the current state.
1864  *
1865  * It will return 0 if the commit can happen in an asynchronous fashion or error
1866  * if not. Note that error just mean it can't be committed asynchronously, if it
1867  * fails the commit should be treated like a normal synchronous commit.
1868  */
drm_atomic_helper_async_check(struct drm_device * dev,struct drm_atomic_state * state)1869 int drm_atomic_helper_async_check(struct drm_device *dev,
1870 				   struct drm_atomic_state *state)
1871 {
1872 	struct drm_crtc *crtc;
1873 	struct drm_crtc_state *crtc_state;
1874 	struct drm_plane *plane = NULL;
1875 	struct drm_plane_state *old_plane_state = NULL;
1876 	struct drm_plane_state *new_plane_state = NULL;
1877 	const struct drm_plane_helper_funcs *funcs;
1878 	int i, ret, n_planes = 0;
1879 
1880 	for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1881 		if (drm_atomic_crtc_needs_modeset(crtc_state))
1882 			return -EINVAL;
1883 	}
1884 
1885 	for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i)
1886 		n_planes++;
1887 
1888 	/* FIXME: we support only single plane updates for now */
1889 	if (n_planes != 1) {
1890 		drm_dbg_atomic(dev,
1891 			       "only single plane async updates are supported\n");
1892 		return -EINVAL;
1893 	}
1894 
1895 	if (!new_plane_state->crtc ||
1896 	    old_plane_state->crtc != new_plane_state->crtc) {
1897 		drm_dbg_atomic(dev,
1898 			       "[PLANE:%d:%s] async update cannot change CRTC\n",
1899 			       plane->base.id, plane->name);
1900 		return -EINVAL;
1901 	}
1902 
1903 	funcs = plane->helper_private;
1904 	if (!funcs->atomic_async_update) {
1905 		drm_dbg_atomic(dev,
1906 			       "[PLANE:%d:%s] driver does not support async updates\n",
1907 			       plane->base.id, plane->name);
1908 		return -EINVAL;
1909 	}
1910 
1911 	if (new_plane_state->fence) {
1912 		drm_dbg_atomic(dev,
1913 			       "[PLANE:%d:%s] missing fence for async update\n",
1914 			       plane->base.id, plane->name);
1915 		return -EINVAL;
1916 	}
1917 
1918 	/*
1919 	 * Don't do an async update if there is an outstanding commit modifying
1920 	 * the plane.  This prevents our async update's changes from getting
1921 	 * overridden by a previous synchronous update's state.
1922 	 */
1923 	if (old_plane_state->commit &&
1924 	    !try_wait_for_completion(&old_plane_state->commit->hw_done)) {
1925 		drm_dbg_atomic(dev,
1926 			       "[PLANE:%d:%s] inflight previous commit preventing async commit\n",
1927 			       plane->base.id, plane->name);
1928 		return -EBUSY;
1929 	}
1930 
1931 	ret = funcs->atomic_async_check(plane, state);
1932 	if (ret != 0)
1933 		drm_dbg_atomic(dev,
1934 			       "[PLANE:%d:%s] driver async check failed\n",
1935 			       plane->base.id, plane->name);
1936 	return ret;
1937 }
1938 EXPORT_SYMBOL(drm_atomic_helper_async_check);
1939 
1940 /**
1941  * drm_atomic_helper_async_commit - commit state asynchronously
1942  * @dev: DRM device
1943  * @state: the driver state object
1944  *
1945  * This function commits a state asynchronously, i.e., not vblank
1946  * synchronized. It should be used on a state only when
1947  * drm_atomic_async_check() succeeds. Async commits are not supposed to swap
1948  * the states like normal sync commits, but just do in-place changes on the
1949  * current state.
1950  *
1951  * TODO: Implement full swap instead of doing in-place changes.
1952  */
drm_atomic_helper_async_commit(struct drm_device * dev,struct drm_atomic_state * state)1953 void drm_atomic_helper_async_commit(struct drm_device *dev,
1954 				    struct drm_atomic_state *state)
1955 {
1956 	struct drm_plane *plane;
1957 	struct drm_plane_state *plane_state;
1958 	const struct drm_plane_helper_funcs *funcs;
1959 	int i;
1960 
1961 	for_each_new_plane_in_state(state, plane, plane_state, i) {
1962 		struct drm_framebuffer *new_fb = plane_state->fb;
1963 		struct drm_framebuffer *old_fb = plane->state->fb;
1964 
1965 		funcs = plane->helper_private;
1966 		funcs->atomic_async_update(plane, state);
1967 
1968 		/*
1969 		 * ->atomic_async_update() is supposed to update the
1970 		 * plane->state in-place, make sure at least common
1971 		 * properties have been properly updated.
1972 		 */
1973 		WARN_ON_ONCE(plane->state->fb != new_fb);
1974 		WARN_ON_ONCE(plane->state->crtc_x != plane_state->crtc_x);
1975 		WARN_ON_ONCE(plane->state->crtc_y != plane_state->crtc_y);
1976 		WARN_ON_ONCE(plane->state->src_x != plane_state->src_x);
1977 		WARN_ON_ONCE(plane->state->src_y != plane_state->src_y);
1978 
1979 		/*
1980 		 * Make sure the FBs have been swapped so that cleanups in the
1981 		 * new_state performs a cleanup in the old FB.
1982 		 */
1983 		WARN_ON_ONCE(plane_state->fb != old_fb);
1984 	}
1985 }
1986 EXPORT_SYMBOL(drm_atomic_helper_async_commit);
1987 
1988 /**
1989  * drm_atomic_helper_commit - commit validated state object
1990  * @dev: DRM device
1991  * @state: the driver state object
1992  * @nonblock: whether nonblocking behavior is requested.
1993  *
1994  * This function commits a with drm_atomic_helper_check() pre-validated state
1995  * object. This can still fail when e.g. the framebuffer reservation fails. This
1996  * function implements nonblocking commits, using
1997  * drm_atomic_helper_setup_commit() and related functions.
1998  *
1999  * Committing the actual hardware state is done through the
2000  * &drm_mode_config_helper_funcs.atomic_commit_tail callback, or its default
2001  * implementation drm_atomic_helper_commit_tail().
2002  *
2003  * RETURNS:
2004  * Zero for success or -errno.
2005  */
drm_atomic_helper_commit(struct drm_device * dev,struct drm_atomic_state * state,bool nonblock)2006 int drm_atomic_helper_commit(struct drm_device *dev,
2007 			     struct drm_atomic_state *state,
2008 			     bool nonblock)
2009 {
2010 	int ret;
2011 
2012 	if (state->async_update) {
2013 		ret = drm_atomic_helper_prepare_planes(dev, state);
2014 		if (ret)
2015 			return ret;
2016 
2017 		drm_atomic_helper_async_commit(dev, state);
2018 		drm_atomic_helper_unprepare_planes(dev, state);
2019 
2020 		return 0;
2021 	}
2022 
2023 	ret = drm_atomic_helper_setup_commit(state, nonblock);
2024 	if (ret)
2025 		return ret;
2026 
2027 	INIT_WORK(&state->commit_work, commit_work);
2028 
2029 	ret = drm_atomic_helper_prepare_planes(dev, state);
2030 	if (ret)
2031 		return ret;
2032 
2033 	if (!nonblock) {
2034 		ret = drm_atomic_helper_wait_for_fences(dev, state, true);
2035 		if (ret)
2036 			goto err;
2037 	}
2038 
2039 	/*
2040 	 * This is the point of no return - everything below never fails except
2041 	 * when the hw goes bonghits. Which means we can commit the new state on
2042 	 * the software side now.
2043 	 */
2044 
2045 	ret = drm_atomic_helper_swap_state(state, true);
2046 	if (ret)
2047 		goto err;
2048 
2049 	/*
2050 	 * Everything below can be run asynchronously without the need to grab
2051 	 * any modeset locks at all under one condition: It must be guaranteed
2052 	 * that the asynchronous work has either been cancelled (if the driver
2053 	 * supports it, which at least requires that the framebuffers get
2054 	 * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
2055 	 * before the new state gets committed on the software side with
2056 	 * drm_atomic_helper_swap_state().
2057 	 *
2058 	 * This scheme allows new atomic state updates to be prepared and
2059 	 * checked in parallel to the asynchronous completion of the previous
2060 	 * update. Which is important since compositors need to figure out the
2061 	 * composition of the next frame right after having submitted the
2062 	 * current layout.
2063 	 *
2064 	 * NOTE: Commit work has multiple phases, first hardware commit, then
2065 	 * cleanup. We want them to overlap, hence need system_unbound_wq to
2066 	 * make sure work items don't artificially stall on each another.
2067 	 */
2068 
2069 	drm_atomic_state_get(state);
2070 	if (nonblock)
2071 		queue_work(system_unbound_wq, &state->commit_work);
2072 	else
2073 		commit_tail(state);
2074 
2075 	return 0;
2076 
2077 err:
2078 	drm_atomic_helper_unprepare_planes(dev, state);
2079 	return ret;
2080 }
2081 EXPORT_SYMBOL(drm_atomic_helper_commit);
2082 
2083 /**
2084  * DOC: implementing nonblocking commit
2085  *
2086  * Nonblocking atomic commits should use struct &drm_crtc_commit to sequence
2087  * different operations against each another. Locks, especially struct
2088  * &drm_modeset_lock, should not be held in worker threads or any other
2089  * asynchronous context used to commit the hardware state.
2090  *
2091  * drm_atomic_helper_commit() implements the recommended sequence for
2092  * nonblocking commits, using drm_atomic_helper_setup_commit() internally:
2093  *
2094  * 1. Run drm_atomic_helper_prepare_planes(). Since this can fail and we
2095  * need to propagate out of memory/VRAM errors to userspace, it must be called
2096  * synchronously.
2097  *
2098  * 2. Synchronize with any outstanding nonblocking commit worker threads which
2099  * might be affected by the new state update. This is handled by
2100  * drm_atomic_helper_setup_commit().
2101  *
2102  * Asynchronous workers need to have sufficient parallelism to be able to run
2103  * different atomic commits on different CRTCs in parallel. The simplest way to
2104  * achieve this is by running them on the &system_unbound_wq work queue. Note
2105  * that drivers are not required to split up atomic commits and run an
2106  * individual commit in parallel - userspace is supposed to do that if it cares.
2107  * But it might be beneficial to do that for modesets, since those necessarily
2108  * must be done as one global operation, and enabling or disabling a CRTC can
2109  * take a long time. But even that is not required.
2110  *
2111  * IMPORTANT: A &drm_atomic_state update for multiple CRTCs is sequenced
2112  * against all CRTCs therein. Therefore for atomic state updates which only flip
2113  * planes the driver must not get the struct &drm_crtc_state of unrelated CRTCs
2114  * in its atomic check code: This would prevent committing of atomic updates to
2115  * multiple CRTCs in parallel. In general, adding additional state structures
2116  * should be avoided as much as possible, because this reduces parallelism in
2117  * (nonblocking) commits, both due to locking and due to commit sequencing
2118  * requirements.
2119  *
2120  * 3. The software state is updated synchronously with
2121  * drm_atomic_helper_swap_state(). Doing this under the protection of all modeset
2122  * locks means concurrent callers never see inconsistent state. Note that commit
2123  * workers do not hold any locks; their access is only coordinated through
2124  * ordering. If workers would access state only through the pointers in the
2125  * free-standing state objects (currently not the case for any driver) then even
2126  * multiple pending commits could be in-flight at the same time.
2127  *
2128  * 4. Schedule a work item to do all subsequent steps, using the split-out
2129  * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
2130  * then cleaning up the framebuffers after the old framebuffer is no longer
2131  * being displayed. The scheduled work should synchronize against other workers
2132  * using the &drm_crtc_commit infrastructure as needed. See
2133  * drm_atomic_helper_setup_commit() for more details.
2134  */
2135 
stall_checks(struct drm_crtc * crtc,bool nonblock)2136 static int stall_checks(struct drm_crtc *crtc, bool nonblock)
2137 {
2138 	struct drm_crtc_commit *commit, *stall_commit = NULL;
2139 	bool completed = true;
2140 	int i;
2141 	long ret = 0;
2142 
2143 	spin_lock(&crtc->commit_lock);
2144 	i = 0;
2145 	list_for_each_entry(commit, &crtc->commit_list, commit_entry) {
2146 		if (i == 0) {
2147 			completed = try_wait_for_completion(&commit->flip_done);
2148 			/*
2149 			 * Userspace is not allowed to get ahead of the previous
2150 			 * commit with nonblocking ones.
2151 			 */
2152 			if (!completed && nonblock) {
2153 				spin_unlock(&crtc->commit_lock);
2154 				drm_dbg_atomic(crtc->dev,
2155 					       "[CRTC:%d:%s] busy with a previous commit\n",
2156 					       crtc->base.id, crtc->name);
2157 
2158 				return -EBUSY;
2159 			}
2160 		} else if (i == 1) {
2161 			stall_commit = drm_crtc_commit_get(commit);
2162 			break;
2163 		}
2164 
2165 		i++;
2166 	}
2167 	spin_unlock(&crtc->commit_lock);
2168 
2169 	if (!stall_commit)
2170 		return 0;
2171 
2172 	/* We don't want to let commits get ahead of cleanup work too much,
2173 	 * stalling on 2nd previous commit means triple-buffer won't ever stall.
2174 	 */
2175 	ret = wait_for_completion_interruptible_timeout(&stall_commit->cleanup_done,
2176 							10*HZ);
2177 	if (ret == 0)
2178 		drm_err(crtc->dev, "[CRTC:%d:%s] cleanup_done timed out\n",
2179 			crtc->base.id, crtc->name);
2180 
2181 	drm_crtc_commit_put(stall_commit);
2182 
2183 	return ret < 0 ? ret : 0;
2184 }
2185 
release_crtc_commit(struct completion * completion)2186 static void release_crtc_commit(struct completion *completion)
2187 {
2188 	struct drm_crtc_commit *commit = container_of(completion,
2189 						      typeof(*commit),
2190 						      flip_done);
2191 
2192 	drm_crtc_commit_put(commit);
2193 }
2194 
init_commit(struct drm_crtc_commit * commit,struct drm_crtc * crtc)2195 static void init_commit(struct drm_crtc_commit *commit, struct drm_crtc *crtc)
2196 {
2197 	init_completion(&commit->flip_done);
2198 	init_completion(&commit->hw_done);
2199 	init_completion(&commit->cleanup_done);
2200 	INIT_LIST_HEAD(&commit->commit_entry);
2201 	kref_init(&commit->ref);
2202 	commit->crtc = crtc;
2203 }
2204 
2205 static struct drm_crtc_commit *
crtc_or_fake_commit(struct drm_atomic_state * state,struct drm_crtc * crtc)2206 crtc_or_fake_commit(struct drm_atomic_state *state, struct drm_crtc *crtc)
2207 {
2208 	if (crtc) {
2209 		struct drm_crtc_state *new_crtc_state;
2210 
2211 		new_crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
2212 
2213 		return new_crtc_state->commit;
2214 	}
2215 
2216 	if (!state->fake_commit) {
2217 		state->fake_commit = kzalloc(sizeof(*state->fake_commit), GFP_KERNEL);
2218 		if (!state->fake_commit)
2219 			return NULL;
2220 
2221 		init_commit(state->fake_commit, NULL);
2222 	}
2223 
2224 	return state->fake_commit;
2225 }
2226 
2227 /**
2228  * drm_atomic_helper_setup_commit - setup possibly nonblocking commit
2229  * @state: new modeset state to be committed
2230  * @nonblock: whether nonblocking behavior is requested.
2231  *
2232  * This function prepares @state to be used by the atomic helper's support for
2233  * nonblocking commits. Drivers using the nonblocking commit infrastructure
2234  * should always call this function from their
2235  * &drm_mode_config_funcs.atomic_commit hook.
2236  *
2237  * Drivers that need to extend the commit setup to private objects can use the
2238  * &drm_mode_config_helper_funcs.atomic_commit_setup hook.
2239  *
2240  * To be able to use this support drivers need to use a few more helper
2241  * functions. drm_atomic_helper_wait_for_dependencies() must be called before
2242  * actually committing the hardware state, and for nonblocking commits this call
2243  * must be placed in the async worker. See also drm_atomic_helper_swap_state()
2244  * and its stall parameter, for when a driver's commit hooks look at the
2245  * &drm_crtc.state, &drm_plane.state or &drm_connector.state pointer directly.
2246  *
2247  * Completion of the hardware commit step must be signalled using
2248  * drm_atomic_helper_commit_hw_done(). After this step the driver is not allowed
2249  * to read or change any permanent software or hardware modeset state. The only
2250  * exception is state protected by other means than &drm_modeset_lock locks.
2251  * Only the free standing @state with pointers to the old state structures can
2252  * be inspected, e.g. to clean up old buffers using
2253  * drm_atomic_helper_cleanup_planes().
2254  *
2255  * At the very end, before cleaning up @state drivers must call
2256  * drm_atomic_helper_commit_cleanup_done().
2257  *
2258  * This is all implemented by in drm_atomic_helper_commit(), giving drivers a
2259  * complete and easy-to-use default implementation of the atomic_commit() hook.
2260  *
2261  * The tracking of asynchronously executed and still pending commits is done
2262  * using the core structure &drm_crtc_commit.
2263  *
2264  * By default there's no need to clean up resources allocated by this function
2265  * explicitly: drm_atomic_state_default_clear() will take care of that
2266  * automatically.
2267  *
2268  * Returns:
2269  * 0 on success. -EBUSY when userspace schedules nonblocking commits too fast,
2270  * -ENOMEM on allocation failures and -EINTR when a signal is pending.
2271  */
drm_atomic_helper_setup_commit(struct drm_atomic_state * state,bool nonblock)2272 int drm_atomic_helper_setup_commit(struct drm_atomic_state *state,
2273 				   bool nonblock)
2274 {
2275 	struct drm_crtc *crtc;
2276 	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2277 	struct drm_connector *conn;
2278 	struct drm_connector_state *old_conn_state, *new_conn_state;
2279 	struct drm_plane *plane;
2280 	struct drm_plane_state *old_plane_state, *new_plane_state;
2281 	struct drm_crtc_commit *commit;
2282 	const struct drm_mode_config_helper_funcs *funcs;
2283 	int i, ret;
2284 
2285 	funcs = state->dev->mode_config.helper_private;
2286 
2287 	for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
2288 		commit = kzalloc(sizeof(*commit), GFP_KERNEL);
2289 		if (!commit)
2290 			return -ENOMEM;
2291 
2292 		init_commit(commit, crtc);
2293 
2294 		new_crtc_state->commit = commit;
2295 
2296 		ret = stall_checks(crtc, nonblock);
2297 		if (ret)
2298 			return ret;
2299 
2300 		/*
2301 		 * Drivers only send out events when at least either current or
2302 		 * new CRTC state is active. Complete right away if everything
2303 		 * stays off.
2304 		 */
2305 		if (!old_crtc_state->active && !new_crtc_state->active) {
2306 			complete_all(&commit->flip_done);
2307 			continue;
2308 		}
2309 
2310 		/* Legacy cursor updates are fully unsynced. */
2311 		if (state->legacy_cursor_update) {
2312 			complete_all(&commit->flip_done);
2313 			continue;
2314 		}
2315 
2316 		if (!new_crtc_state->event) {
2317 			commit->event = kzalloc(sizeof(*commit->event),
2318 						GFP_KERNEL);
2319 			if (!commit->event)
2320 				return -ENOMEM;
2321 
2322 			new_crtc_state->event = commit->event;
2323 		}
2324 
2325 		new_crtc_state->event->base.completion = &commit->flip_done;
2326 		new_crtc_state->event->base.completion_release = release_crtc_commit;
2327 		drm_crtc_commit_get(commit);
2328 
2329 		commit->abort_completion = true;
2330 
2331 		state->crtcs[i].commit = commit;
2332 		drm_crtc_commit_get(commit);
2333 	}
2334 
2335 	for_each_oldnew_connector_in_state(state, conn, old_conn_state, new_conn_state, i) {
2336 		/*
2337 		 * Userspace is not allowed to get ahead of the previous
2338 		 * commit with nonblocking ones.
2339 		 */
2340 		if (nonblock && old_conn_state->commit &&
2341 		    !try_wait_for_completion(&old_conn_state->commit->flip_done)) {
2342 			drm_dbg_atomic(conn->dev,
2343 				       "[CONNECTOR:%d:%s] busy with a previous commit\n",
2344 				       conn->base.id, conn->name);
2345 
2346 			return -EBUSY;
2347 		}
2348 
2349 		/* Always track connectors explicitly for e.g. link retraining. */
2350 		commit = crtc_or_fake_commit(state, new_conn_state->crtc ?: old_conn_state->crtc);
2351 		if (!commit)
2352 			return -ENOMEM;
2353 
2354 		new_conn_state->commit = drm_crtc_commit_get(commit);
2355 	}
2356 
2357 	for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
2358 		/*
2359 		 * Userspace is not allowed to get ahead of the previous
2360 		 * commit with nonblocking ones.
2361 		 */
2362 		if (nonblock && old_plane_state->commit &&
2363 		    !try_wait_for_completion(&old_plane_state->commit->flip_done)) {
2364 			drm_dbg_atomic(plane->dev,
2365 				       "[PLANE:%d:%s] busy with a previous commit\n",
2366 				       plane->base.id, plane->name);
2367 
2368 			return -EBUSY;
2369 		}
2370 
2371 		/* Always track planes explicitly for async pageflip support. */
2372 		commit = crtc_or_fake_commit(state, new_plane_state->crtc ?: old_plane_state->crtc);
2373 		if (!commit)
2374 			return -ENOMEM;
2375 
2376 		new_plane_state->commit = drm_crtc_commit_get(commit);
2377 	}
2378 
2379 	if (funcs && funcs->atomic_commit_setup)
2380 		return funcs->atomic_commit_setup(state);
2381 
2382 	return 0;
2383 }
2384 EXPORT_SYMBOL(drm_atomic_helper_setup_commit);
2385 
2386 /**
2387  * drm_atomic_helper_wait_for_dependencies - wait for required preceding commits
2388  * @old_state: atomic state object with old state structures
2389  *
2390  * This function waits for all preceding commits that touch the same CRTC as
2391  * @old_state to both be committed to the hardware (as signalled by
2392  * drm_atomic_helper_commit_hw_done()) and executed by the hardware (as signalled
2393  * by calling drm_crtc_send_vblank_event() on the &drm_crtc_state.event).
2394  *
2395  * This is part of the atomic helper support for nonblocking commits, see
2396  * drm_atomic_helper_setup_commit() for an overview.
2397  */
drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state * old_state)2398 void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *old_state)
2399 {
2400 	struct drm_crtc *crtc;
2401 	struct drm_crtc_state *old_crtc_state;
2402 	struct drm_plane *plane;
2403 	struct drm_plane_state *old_plane_state;
2404 	struct drm_connector *conn;
2405 	struct drm_connector_state *old_conn_state;
2406 	int i;
2407 	long ret;
2408 
2409 	for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
2410 		ret = drm_crtc_commit_wait(old_crtc_state->commit);
2411 		if (ret)
2412 			drm_err(crtc->dev,
2413 				"[CRTC:%d:%s] commit wait timed out\n",
2414 				crtc->base.id, crtc->name);
2415 	}
2416 
2417 	for_each_old_connector_in_state(old_state, conn, old_conn_state, i) {
2418 		ret = drm_crtc_commit_wait(old_conn_state->commit);
2419 		if (ret)
2420 			drm_err(conn->dev,
2421 				"[CONNECTOR:%d:%s] commit wait timed out\n",
2422 				conn->base.id, conn->name);
2423 	}
2424 
2425 	for_each_old_plane_in_state(old_state, plane, old_plane_state, i) {
2426 		ret = drm_crtc_commit_wait(old_plane_state->commit);
2427 		if (ret)
2428 			drm_err(plane->dev,
2429 				"[PLANE:%d:%s] commit wait timed out\n",
2430 				plane->base.id, plane->name);
2431 	}
2432 }
2433 EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies);
2434 
2435 /**
2436  * drm_atomic_helper_fake_vblank - fake VBLANK events if needed
2437  * @old_state: atomic state object with old state structures
2438  *
2439  * This function walks all CRTCs and fakes VBLANK events on those with
2440  * &drm_crtc_state.no_vblank set to true and &drm_crtc_state.event != NULL.
2441  * The primary use of this function is writeback connectors working in oneshot
2442  * mode and faking VBLANK events. In this case they only fake the VBLANK event
2443  * when a job is queued, and any change to the pipeline that does not touch the
2444  * connector is leading to timeouts when calling
2445  * drm_atomic_helper_wait_for_vblanks() or
2446  * drm_atomic_helper_wait_for_flip_done(). In addition to writeback
2447  * connectors, this function can also fake VBLANK events for CRTCs without
2448  * VBLANK interrupt.
2449  *
2450  * This is part of the atomic helper support for nonblocking commits, see
2451  * drm_atomic_helper_setup_commit() for an overview.
2452  */
drm_atomic_helper_fake_vblank(struct drm_atomic_state * old_state)2453 void drm_atomic_helper_fake_vblank(struct drm_atomic_state *old_state)
2454 {
2455 	struct drm_crtc_state *new_crtc_state;
2456 	struct drm_crtc *crtc;
2457 	int i;
2458 
2459 	for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
2460 		unsigned long flags;
2461 
2462 		if (!new_crtc_state->no_vblank)
2463 			continue;
2464 
2465 		spin_lock_irqsave(&old_state->dev->event_lock, flags);
2466 		if (new_crtc_state->event) {
2467 			drm_crtc_send_vblank_event(crtc,
2468 						   new_crtc_state->event);
2469 			new_crtc_state->event = NULL;
2470 		}
2471 		spin_unlock_irqrestore(&old_state->dev->event_lock, flags);
2472 	}
2473 }
2474 EXPORT_SYMBOL(drm_atomic_helper_fake_vblank);
2475 
2476 /**
2477  * drm_atomic_helper_commit_hw_done - setup possible nonblocking commit
2478  * @old_state: atomic state object with old state structures
2479  *
2480  * This function is used to signal completion of the hardware commit step. After
2481  * this step the driver is not allowed to read or change any permanent software
2482  * or hardware modeset state. The only exception is state protected by other
2483  * means than &drm_modeset_lock locks.
2484  *
2485  * Drivers should try to postpone any expensive or delayed cleanup work after
2486  * this function is called.
2487  *
2488  * This is part of the atomic helper support for nonblocking commits, see
2489  * drm_atomic_helper_setup_commit() for an overview.
2490  */
drm_atomic_helper_commit_hw_done(struct drm_atomic_state * old_state)2491 void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *old_state)
2492 {
2493 	struct drm_crtc *crtc;
2494 	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2495 	struct drm_crtc_commit *commit;
2496 	int i;
2497 
2498 	for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2499 		commit = new_crtc_state->commit;
2500 		if (!commit)
2501 			continue;
2502 
2503 		/*
2504 		 * copy new_crtc_state->commit to old_crtc_state->commit,
2505 		 * it's unsafe to touch new_crtc_state after hw_done,
2506 		 * but we still need to do so in cleanup_done().
2507 		 */
2508 		if (old_crtc_state->commit)
2509 			drm_crtc_commit_put(old_crtc_state->commit);
2510 
2511 		old_crtc_state->commit = drm_crtc_commit_get(commit);
2512 
2513 		/* backend must have consumed any event by now */
2514 		WARN_ON(new_crtc_state->event);
2515 		complete_all(&commit->hw_done);
2516 	}
2517 
2518 	if (old_state->fake_commit) {
2519 		complete_all(&old_state->fake_commit->hw_done);
2520 		complete_all(&old_state->fake_commit->flip_done);
2521 	}
2522 }
2523 EXPORT_SYMBOL(drm_atomic_helper_commit_hw_done);
2524 
2525 /**
2526  * drm_atomic_helper_commit_cleanup_done - signal completion of commit
2527  * @old_state: atomic state object with old state structures
2528  *
2529  * This signals completion of the atomic update @old_state, including any
2530  * cleanup work. If used, it must be called right before calling
2531  * drm_atomic_state_put().
2532  *
2533  * This is part of the atomic helper support for nonblocking commits, see
2534  * drm_atomic_helper_setup_commit() for an overview.
2535  */
drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state * old_state)2536 void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *old_state)
2537 {
2538 	struct drm_crtc *crtc;
2539 	struct drm_crtc_state *old_crtc_state;
2540 	struct drm_crtc_commit *commit;
2541 	int i;
2542 
2543 	for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
2544 		commit = old_crtc_state->commit;
2545 		if (WARN_ON(!commit))
2546 			continue;
2547 
2548 		complete_all(&commit->cleanup_done);
2549 		WARN_ON(!try_wait_for_completion(&commit->hw_done));
2550 
2551 		spin_lock(&crtc->commit_lock);
2552 		list_del(&commit->commit_entry);
2553 		spin_unlock(&crtc->commit_lock);
2554 	}
2555 
2556 	if (old_state->fake_commit) {
2557 		complete_all(&old_state->fake_commit->cleanup_done);
2558 		WARN_ON(!try_wait_for_completion(&old_state->fake_commit->hw_done));
2559 	}
2560 }
2561 EXPORT_SYMBOL(drm_atomic_helper_commit_cleanup_done);
2562 
2563 /**
2564  * drm_atomic_helper_prepare_planes - prepare plane resources before commit
2565  * @dev: DRM device
2566  * @state: atomic state object with new state structures
2567  *
2568  * This function prepares plane state, specifically framebuffers, for the new
2569  * configuration, by calling &drm_plane_helper_funcs.prepare_fb. If any failure
2570  * is encountered this function will call &drm_plane_helper_funcs.cleanup_fb on
2571  * any already successfully prepared framebuffer.
2572  *
2573  * Returns:
2574  * 0 on success, negative error code on failure.
2575  */
drm_atomic_helper_prepare_planes(struct drm_device * dev,struct drm_atomic_state * state)2576 int drm_atomic_helper_prepare_planes(struct drm_device *dev,
2577 				     struct drm_atomic_state *state)
2578 {
2579 	struct drm_connector *connector;
2580 	struct drm_connector_state *new_conn_state;
2581 	struct drm_plane *plane;
2582 	struct drm_plane_state *new_plane_state;
2583 	int ret, i, j;
2584 
2585 	for_each_new_connector_in_state(state, connector, new_conn_state, i) {
2586 		if (!new_conn_state->writeback_job)
2587 			continue;
2588 
2589 		ret = drm_writeback_prepare_job(new_conn_state->writeback_job);
2590 		if (ret < 0)
2591 			return ret;
2592 	}
2593 
2594 	for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2595 		const struct drm_plane_helper_funcs *funcs;
2596 
2597 		funcs = plane->helper_private;
2598 
2599 		if (funcs->prepare_fb) {
2600 			ret = funcs->prepare_fb(plane, new_plane_state);
2601 			if (ret)
2602 				goto fail_prepare_fb;
2603 		} else {
2604 			WARN_ON_ONCE(funcs->cleanup_fb);
2605 
2606 			if (!drm_core_check_feature(dev, DRIVER_GEM))
2607 				continue;
2608 
2609 			ret = drm_gem_plane_helper_prepare_fb(plane, new_plane_state);
2610 			if (ret)
2611 				goto fail_prepare_fb;
2612 		}
2613 	}
2614 
2615 	for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2616 		const struct drm_plane_helper_funcs *funcs = plane->helper_private;
2617 
2618 		if (funcs->begin_fb_access) {
2619 			ret = funcs->begin_fb_access(plane, new_plane_state);
2620 			if (ret)
2621 				goto fail_begin_fb_access;
2622 		}
2623 	}
2624 
2625 	return 0;
2626 
2627 fail_begin_fb_access:
2628 	for_each_new_plane_in_state(state, plane, new_plane_state, j) {
2629 		const struct drm_plane_helper_funcs *funcs = plane->helper_private;
2630 
2631 		if (j >= i)
2632 			continue;
2633 
2634 		if (funcs->end_fb_access)
2635 			funcs->end_fb_access(plane, new_plane_state);
2636 	}
2637 	i = j; /* set i to upper limit to cleanup all planes */
2638 fail_prepare_fb:
2639 	for_each_new_plane_in_state(state, plane, new_plane_state, j) {
2640 		const struct drm_plane_helper_funcs *funcs;
2641 
2642 		if (j >= i)
2643 			continue;
2644 
2645 		funcs = plane->helper_private;
2646 
2647 		if (funcs->cleanup_fb)
2648 			funcs->cleanup_fb(plane, new_plane_state);
2649 	}
2650 
2651 	return ret;
2652 }
2653 EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
2654 
2655 /**
2656  * drm_atomic_helper_unprepare_planes - release plane resources on aborts
2657  * @dev: DRM device
2658  * @state: atomic state object with old state structures
2659  *
2660  * This function cleans up plane state, specifically framebuffers, from the
2661  * atomic state. It undoes the effects of drm_atomic_helper_prepare_planes()
2662  * when aborting an atomic commit. For cleaning up after a successful commit
2663  * use drm_atomic_helper_cleanup_planes().
2664  */
drm_atomic_helper_unprepare_planes(struct drm_device * dev,struct drm_atomic_state * state)2665 void drm_atomic_helper_unprepare_planes(struct drm_device *dev,
2666 					struct drm_atomic_state *state)
2667 {
2668 	struct drm_plane *plane;
2669 	struct drm_plane_state *new_plane_state;
2670 	int i;
2671 
2672 	for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2673 		const struct drm_plane_helper_funcs *funcs = plane->helper_private;
2674 
2675 		if (funcs->end_fb_access)
2676 			funcs->end_fb_access(plane, new_plane_state);
2677 	}
2678 
2679 	for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2680 		const struct drm_plane_helper_funcs *funcs = plane->helper_private;
2681 
2682 		if (funcs->cleanup_fb)
2683 			funcs->cleanup_fb(plane, new_plane_state);
2684 	}
2685 }
2686 EXPORT_SYMBOL(drm_atomic_helper_unprepare_planes);
2687 
plane_crtc_active(const struct drm_plane_state * state)2688 static bool plane_crtc_active(const struct drm_plane_state *state)
2689 {
2690 	return state->crtc && state->crtc->state->active;
2691 }
2692 
2693 /**
2694  * drm_atomic_helper_commit_planes - commit plane state
2695  * @dev: DRM device
2696  * @old_state: atomic state object with old state structures
2697  * @flags: flags for committing plane state
2698  *
2699  * This function commits the new plane state using the plane and atomic helper
2700  * functions for planes and CRTCs. It assumes that the atomic state has already
2701  * been pushed into the relevant object state pointers, since this step can no
2702  * longer fail.
2703  *
2704  * It still requires the global state object @old_state to know which planes and
2705  * crtcs need to be updated though.
2706  *
2707  * Note that this function does all plane updates across all CRTCs in one step.
2708  * If the hardware can't support this approach look at
2709  * drm_atomic_helper_commit_planes_on_crtc() instead.
2710  *
2711  * Plane parameters can be updated by applications while the associated CRTC is
2712  * disabled. The DRM/KMS core will store the parameters in the plane state,
2713  * which will be available to the driver when the CRTC is turned on. As a result
2714  * most drivers don't need to be immediately notified of plane updates for a
2715  * disabled CRTC.
2716  *
2717  * Unless otherwise needed, drivers are advised to set the ACTIVE_ONLY flag in
2718  * @flags in order not to receive plane update notifications related to a
2719  * disabled CRTC. This avoids the need to manually ignore plane updates in
2720  * driver code when the driver and/or hardware can't or just don't need to deal
2721  * with updates on disabled CRTCs, for example when supporting runtime PM.
2722  *
2723  * Drivers may set the NO_DISABLE_AFTER_MODESET flag in @flags if the relevant
2724  * display controllers require to disable a CRTC's planes when the CRTC is
2725  * disabled. This function would skip the &drm_plane_helper_funcs.atomic_disable
2726  * call for a plane if the CRTC of the old plane state needs a modesetting
2727  * operation. Of course, the drivers need to disable the planes in their CRTC
2728  * disable callbacks since no one else would do that.
2729  *
2730  * The drm_atomic_helper_commit() default implementation doesn't set the
2731  * ACTIVE_ONLY flag to most closely match the behaviour of the legacy helpers.
2732  * This should not be copied blindly by drivers.
2733  */
drm_atomic_helper_commit_planes(struct drm_device * dev,struct drm_atomic_state * old_state,uint32_t flags)2734 void drm_atomic_helper_commit_planes(struct drm_device *dev,
2735 				     struct drm_atomic_state *old_state,
2736 				     uint32_t flags)
2737 {
2738 	struct drm_crtc *crtc;
2739 	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2740 	struct drm_plane *plane;
2741 	struct drm_plane_state *old_plane_state, *new_plane_state;
2742 	int i;
2743 	bool active_only = flags & DRM_PLANE_COMMIT_ACTIVE_ONLY;
2744 	bool no_disable = flags & DRM_PLANE_COMMIT_NO_DISABLE_AFTER_MODESET;
2745 
2746 	for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2747 		const struct drm_crtc_helper_funcs *funcs;
2748 
2749 		funcs = crtc->helper_private;
2750 
2751 		if (!funcs || !funcs->atomic_begin)
2752 			continue;
2753 
2754 		if (active_only && !new_crtc_state->active)
2755 			continue;
2756 
2757 		funcs->atomic_begin(crtc, old_state);
2758 	}
2759 
2760 	for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2761 		const struct drm_plane_helper_funcs *funcs;
2762 		bool disabling;
2763 
2764 		funcs = plane->helper_private;
2765 
2766 		if (!funcs)
2767 			continue;
2768 
2769 		disabling = drm_atomic_plane_disabling(old_plane_state,
2770 						       new_plane_state);
2771 
2772 		if (active_only) {
2773 			/*
2774 			 * Skip planes related to inactive CRTCs. If the plane
2775 			 * is enabled use the state of the current CRTC. If the
2776 			 * plane is being disabled use the state of the old
2777 			 * CRTC to avoid skipping planes being disabled on an
2778 			 * active CRTC.
2779 			 */
2780 			if (!disabling && !plane_crtc_active(new_plane_state))
2781 				continue;
2782 			if (disabling && !plane_crtc_active(old_plane_state))
2783 				continue;
2784 		}
2785 
2786 		/*
2787 		 * Special-case disabling the plane if drivers support it.
2788 		 */
2789 		if (disabling && funcs->atomic_disable) {
2790 			struct drm_crtc_state *crtc_state;
2791 
2792 			crtc_state = old_plane_state->crtc->state;
2793 
2794 			if (drm_atomic_crtc_needs_modeset(crtc_state) &&
2795 			    no_disable)
2796 				continue;
2797 
2798 			funcs->atomic_disable(plane, old_state);
2799 		} else if (new_plane_state->crtc || disabling) {
2800 			funcs->atomic_update(plane, old_state);
2801 
2802 			if (!disabling && funcs->atomic_enable) {
2803 				if (drm_atomic_plane_enabling(old_plane_state, new_plane_state))
2804 					funcs->atomic_enable(plane, old_state);
2805 			}
2806 		}
2807 	}
2808 
2809 	for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2810 		const struct drm_crtc_helper_funcs *funcs;
2811 
2812 		funcs = crtc->helper_private;
2813 
2814 		if (!funcs || !funcs->atomic_flush)
2815 			continue;
2816 
2817 		if (active_only && !new_crtc_state->active)
2818 			continue;
2819 
2820 		funcs->atomic_flush(crtc, old_state);
2821 	}
2822 
2823 	/*
2824 	 * Signal end of framebuffer access here before hw_done. After hw_done,
2825 	 * a later commit might have already released the plane state.
2826 	 */
2827 	for_each_old_plane_in_state(old_state, plane, old_plane_state, i) {
2828 		const struct drm_plane_helper_funcs *funcs = plane->helper_private;
2829 
2830 		if (funcs->end_fb_access)
2831 			funcs->end_fb_access(plane, old_plane_state);
2832 	}
2833 }
2834 EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
2835 
2836 /**
2837  * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a CRTC
2838  * @old_crtc_state: atomic state object with the old CRTC state
2839  *
2840  * This function commits the new plane state using the plane and atomic helper
2841  * functions for planes on the specific CRTC. It assumes that the atomic state
2842  * has already been pushed into the relevant object state pointers, since this
2843  * step can no longer fail.
2844  *
2845  * This function is useful when plane updates should be done CRTC-by-CRTC
2846  * instead of one global step like drm_atomic_helper_commit_planes() does.
2847  *
2848  * This function can only be savely used when planes are not allowed to move
2849  * between different CRTCs because this function doesn't handle inter-CRTC
2850  * dependencies. Callers need to ensure that either no such dependencies exist,
2851  * resolve them through ordering of commit calls or through some other means.
2852  */
2853 void
drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state * old_crtc_state)2854 drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state)
2855 {
2856 	const struct drm_crtc_helper_funcs *crtc_funcs;
2857 	struct drm_crtc *crtc = old_crtc_state->crtc;
2858 	struct drm_atomic_state *old_state = old_crtc_state->state;
2859 	struct drm_crtc_state *new_crtc_state =
2860 		drm_atomic_get_new_crtc_state(old_state, crtc);
2861 	struct drm_plane *plane;
2862 	unsigned int plane_mask;
2863 
2864 	plane_mask = old_crtc_state->plane_mask;
2865 	plane_mask |= new_crtc_state->plane_mask;
2866 
2867 	crtc_funcs = crtc->helper_private;
2868 	if (crtc_funcs && crtc_funcs->atomic_begin)
2869 		crtc_funcs->atomic_begin(crtc, old_state);
2870 
2871 	drm_for_each_plane_mask(plane, crtc->dev, plane_mask) {
2872 		struct drm_plane_state *old_plane_state =
2873 			drm_atomic_get_old_plane_state(old_state, plane);
2874 		struct drm_plane_state *new_plane_state =
2875 			drm_atomic_get_new_plane_state(old_state, plane);
2876 		const struct drm_plane_helper_funcs *plane_funcs;
2877 		bool disabling;
2878 
2879 		plane_funcs = plane->helper_private;
2880 
2881 		if (!old_plane_state || !plane_funcs)
2882 			continue;
2883 
2884 		WARN_ON(new_plane_state->crtc &&
2885 			new_plane_state->crtc != crtc);
2886 
2887 		disabling = drm_atomic_plane_disabling(old_plane_state, new_plane_state);
2888 
2889 		if (disabling && plane_funcs->atomic_disable) {
2890 			plane_funcs->atomic_disable(plane, old_state);
2891 		} else if (new_plane_state->crtc || disabling) {
2892 			plane_funcs->atomic_update(plane, old_state);
2893 
2894 			if (!disabling && plane_funcs->atomic_enable) {
2895 				if (drm_atomic_plane_enabling(old_plane_state, new_plane_state))
2896 					plane_funcs->atomic_enable(plane, old_state);
2897 			}
2898 		}
2899 	}
2900 
2901 	if (crtc_funcs && crtc_funcs->atomic_flush)
2902 		crtc_funcs->atomic_flush(crtc, old_state);
2903 }
2904 EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc);
2905 
2906 /**
2907  * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes
2908  * @old_crtc_state: atomic state object with the old CRTC state
2909  * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks
2910  *
2911  * Disables all planes associated with the given CRTC. This can be
2912  * used for instance in the CRTC helper atomic_disable callback to disable
2913  * all planes.
2914  *
2915  * If the atomic-parameter is set the function calls the CRTC's
2916  * atomic_begin hook before and atomic_flush hook after disabling the
2917  * planes.
2918  *
2919  * It is a bug to call this function without having implemented the
2920  * &drm_plane_helper_funcs.atomic_disable plane hook.
2921  */
2922 void
drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state * old_crtc_state,bool atomic)2923 drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state *old_crtc_state,
2924 					 bool atomic)
2925 {
2926 	struct drm_crtc *crtc = old_crtc_state->crtc;
2927 	const struct drm_crtc_helper_funcs *crtc_funcs =
2928 		crtc->helper_private;
2929 	struct drm_plane *plane;
2930 
2931 	if (atomic && crtc_funcs && crtc_funcs->atomic_begin)
2932 		crtc_funcs->atomic_begin(crtc, NULL);
2933 
2934 	drm_atomic_crtc_state_for_each_plane(plane, old_crtc_state) {
2935 		const struct drm_plane_helper_funcs *plane_funcs =
2936 			plane->helper_private;
2937 
2938 		if (!plane_funcs)
2939 			continue;
2940 
2941 		WARN_ON(!plane_funcs->atomic_disable);
2942 		if (plane_funcs->atomic_disable)
2943 			plane_funcs->atomic_disable(plane, NULL);
2944 	}
2945 
2946 	if (atomic && crtc_funcs && crtc_funcs->atomic_flush)
2947 		crtc_funcs->atomic_flush(crtc, NULL);
2948 }
2949 EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc);
2950 
2951 /**
2952  * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
2953  * @dev: DRM device
2954  * @old_state: atomic state object with old state structures
2955  *
2956  * This function cleans up plane state, specifically framebuffers, from the old
2957  * configuration. Hence the old configuration must be perserved in @old_state to
2958  * be able to call this function.
2959  *
2960  * This function may not be called on the new state when the atomic update
2961  * fails at any point after calling drm_atomic_helper_prepare_planes(). Use
2962  * drm_atomic_helper_unprepare_planes() in this case.
2963  */
drm_atomic_helper_cleanup_planes(struct drm_device * dev,struct drm_atomic_state * old_state)2964 void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
2965 				      struct drm_atomic_state *old_state)
2966 {
2967 	struct drm_plane *plane;
2968 	struct drm_plane_state *old_plane_state;
2969 	int i;
2970 
2971 	for_each_old_plane_in_state(old_state, plane, old_plane_state, i) {
2972 		const struct drm_plane_helper_funcs *funcs = plane->helper_private;
2973 
2974 		if (funcs->cleanup_fb)
2975 			funcs->cleanup_fb(plane, old_plane_state);
2976 	}
2977 }
2978 EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
2979 
2980 /**
2981  * drm_atomic_helper_swap_state - store atomic state into current sw state
2982  * @state: atomic state
2983  * @stall: stall for preceding commits
2984  *
2985  * This function stores the atomic state into the current state pointers in all
2986  * driver objects. It should be called after all failing steps have been done
2987  * and succeeded, but before the actual hardware state is committed.
2988  *
2989  * For cleanup and error recovery the current state for all changed objects will
2990  * be swapped into @state.
2991  *
2992  * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
2993  *
2994  * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
2995  *
2996  * 2. Do any other steps that might fail.
2997  *
2998  * 3. Put the staged state into the current state pointers with this function.
2999  *
3000  * 4. Actually commit the hardware state.
3001  *
3002  * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3
3003  * contains the old state. Also do any other cleanup required with that state.
3004  *
3005  * @stall must be set when nonblocking commits for this driver directly access
3006  * the &drm_plane.state, &drm_crtc.state or &drm_connector.state pointer. With
3007  * the current atomic helpers this is almost always the case, since the helpers
3008  * don't pass the right state structures to the callbacks.
3009  *
3010  * Returns:
3011  * Returns 0 on success. Can return -ERESTARTSYS when @stall is true and the
3012  * waiting for the previous commits has been interrupted.
3013  */
drm_atomic_helper_swap_state(struct drm_atomic_state * state,bool stall)3014 int drm_atomic_helper_swap_state(struct drm_atomic_state *state,
3015 				  bool stall)
3016 {
3017 	int i, ret;
3018 	unsigned long flags;
3019 	struct drm_connector *connector;
3020 	struct drm_connector_state *old_conn_state, *new_conn_state;
3021 	struct drm_crtc *crtc;
3022 	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
3023 	struct drm_plane *plane;
3024 	struct drm_plane_state *old_plane_state, *new_plane_state;
3025 	struct drm_crtc_commit *commit;
3026 	struct drm_private_obj *obj;
3027 	struct drm_private_state *old_obj_state, *new_obj_state;
3028 
3029 	if (stall) {
3030 		/*
3031 		 * We have to stall for hw_done here before
3032 		 * drm_atomic_helper_wait_for_dependencies() because flip
3033 		 * depth > 1 is not yet supported by all drivers. As long as
3034 		 * obj->state is directly dereferenced anywhere in the drivers
3035 		 * atomic_commit_tail function, then it's unsafe to swap state
3036 		 * before drm_atomic_helper_commit_hw_done() is called.
3037 		 */
3038 
3039 		for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) {
3040 			commit = old_crtc_state->commit;
3041 
3042 			if (!commit)
3043 				continue;
3044 
3045 			ret = wait_for_completion_interruptible(&commit->hw_done);
3046 			if (ret)
3047 				return ret;
3048 		}
3049 
3050 		for_each_old_connector_in_state(state, connector, old_conn_state, i) {
3051 			commit = old_conn_state->commit;
3052 
3053 			if (!commit)
3054 				continue;
3055 
3056 			ret = wait_for_completion_interruptible(&commit->hw_done);
3057 			if (ret)
3058 				return ret;
3059 		}
3060 
3061 		for_each_old_plane_in_state(state, plane, old_plane_state, i) {
3062 			commit = old_plane_state->commit;
3063 
3064 			if (!commit)
3065 				continue;
3066 
3067 			ret = wait_for_completion_interruptible(&commit->hw_done);
3068 			if (ret)
3069 				return ret;
3070 		}
3071 	}
3072 
3073 	for_each_oldnew_connector_in_state(state, connector, old_conn_state, new_conn_state, i) {
3074 		WARN_ON(connector->state != old_conn_state);
3075 
3076 		old_conn_state->state = state;
3077 		new_conn_state->state = NULL;
3078 
3079 		state->connectors[i].state = old_conn_state;
3080 		connector->state = new_conn_state;
3081 	}
3082 
3083 	for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
3084 		WARN_ON(crtc->state != old_crtc_state);
3085 
3086 		old_crtc_state->state = state;
3087 		new_crtc_state->state = NULL;
3088 
3089 		state->crtcs[i].state = old_crtc_state;
3090 		crtc->state = new_crtc_state;
3091 
3092 		if (new_crtc_state->commit) {
3093 			spin_lock(&crtc->commit_lock);
3094 			list_add(&new_crtc_state->commit->commit_entry,
3095 				 &crtc->commit_list);
3096 			spin_unlock(&crtc->commit_lock);
3097 
3098 			new_crtc_state->commit->event = NULL;
3099 		}
3100 	}
3101 
3102 	drm_panic_lock(state->dev, flags);
3103 	for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
3104 		WARN_ON(plane->state != old_plane_state);
3105 
3106 		old_plane_state->state = state;
3107 		new_plane_state->state = NULL;
3108 
3109 		state->planes[i].state = old_plane_state;
3110 		plane->state = new_plane_state;
3111 	}
3112 	drm_panic_unlock(state->dev, flags);
3113 
3114 	for_each_oldnew_private_obj_in_state(state, obj, old_obj_state, new_obj_state, i) {
3115 		WARN_ON(obj->state != old_obj_state);
3116 
3117 		old_obj_state->state = state;
3118 		new_obj_state->state = NULL;
3119 
3120 		state->private_objs[i].state = old_obj_state;
3121 		obj->state = new_obj_state;
3122 	}
3123 
3124 	return 0;
3125 }
3126 EXPORT_SYMBOL(drm_atomic_helper_swap_state);
3127 
3128 /**
3129  * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
3130  * @plane: plane object to update
3131  * @crtc: owning CRTC of owning plane
3132  * @fb: framebuffer to flip onto plane
3133  * @crtc_x: x offset of primary plane on @crtc
3134  * @crtc_y: y offset of primary plane on @crtc
3135  * @crtc_w: width of primary plane rectangle on @crtc
3136  * @crtc_h: height of primary plane rectangle on @crtc
3137  * @src_x: x offset of @fb for panning
3138  * @src_y: y offset of @fb for panning
3139  * @src_w: width of source rectangle in @fb
3140  * @src_h: height of source rectangle in @fb
3141  * @ctx: lock acquire context
3142  *
3143  * Provides a default plane update handler using the atomic driver interface.
3144  *
3145  * RETURNS:
3146  * Zero on success, error code on failure
3147  */
drm_atomic_helper_update_plane(struct drm_plane * plane,struct drm_crtc * crtc,struct drm_framebuffer * fb,int crtc_x,int crtc_y,unsigned int crtc_w,unsigned int crtc_h,uint32_t src_x,uint32_t src_y,uint32_t src_w,uint32_t src_h,struct drm_modeset_acquire_ctx * ctx)3148 int drm_atomic_helper_update_plane(struct drm_plane *plane,
3149 				   struct drm_crtc *crtc,
3150 				   struct drm_framebuffer *fb,
3151 				   int crtc_x, int crtc_y,
3152 				   unsigned int crtc_w, unsigned int crtc_h,
3153 				   uint32_t src_x, uint32_t src_y,
3154 				   uint32_t src_w, uint32_t src_h,
3155 				   struct drm_modeset_acquire_ctx *ctx)
3156 {
3157 	struct drm_atomic_state *state;
3158 	struct drm_plane_state *plane_state;
3159 	int ret = 0;
3160 
3161 	state = drm_atomic_state_alloc(plane->dev);
3162 	if (!state)
3163 		return -ENOMEM;
3164 
3165 	state->acquire_ctx = ctx;
3166 	plane_state = drm_atomic_get_plane_state(state, plane);
3167 	if (IS_ERR(plane_state)) {
3168 		ret = PTR_ERR(plane_state);
3169 		goto fail;
3170 	}
3171 
3172 	ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
3173 	if (ret != 0)
3174 		goto fail;
3175 	drm_atomic_set_fb_for_plane(plane_state, fb);
3176 	plane_state->crtc_x = crtc_x;
3177 	plane_state->crtc_y = crtc_y;
3178 	plane_state->crtc_w = crtc_w;
3179 	plane_state->crtc_h = crtc_h;
3180 	plane_state->src_x = src_x;
3181 	plane_state->src_y = src_y;
3182 	plane_state->src_w = src_w;
3183 	plane_state->src_h = src_h;
3184 
3185 	if (plane == crtc->cursor)
3186 		state->legacy_cursor_update = true;
3187 
3188 	ret = drm_atomic_commit(state);
3189 fail:
3190 	drm_atomic_state_put(state);
3191 	return ret;
3192 }
3193 EXPORT_SYMBOL(drm_atomic_helper_update_plane);
3194 
3195 /**
3196  * drm_atomic_helper_disable_plane - Helper for primary plane disable using atomic
3197  * @plane: plane to disable
3198  * @ctx: lock acquire context
3199  *
3200  * Provides a default plane disable handler using the atomic driver interface.
3201  *
3202  * RETURNS:
3203  * Zero on success, error code on failure
3204  */
drm_atomic_helper_disable_plane(struct drm_plane * plane,struct drm_modeset_acquire_ctx * ctx)3205 int drm_atomic_helper_disable_plane(struct drm_plane *plane,
3206 				    struct drm_modeset_acquire_ctx *ctx)
3207 {
3208 	struct drm_atomic_state *state;
3209 	struct drm_plane_state *plane_state;
3210 	int ret = 0;
3211 
3212 	state = drm_atomic_state_alloc(plane->dev);
3213 	if (!state)
3214 		return -ENOMEM;
3215 
3216 	state->acquire_ctx = ctx;
3217 	plane_state = drm_atomic_get_plane_state(state, plane);
3218 	if (IS_ERR(plane_state)) {
3219 		ret = PTR_ERR(plane_state);
3220 		goto fail;
3221 	}
3222 
3223 	if (plane_state->crtc && plane_state->crtc->cursor == plane)
3224 		plane_state->state->legacy_cursor_update = true;
3225 
3226 	ret = __drm_atomic_helper_disable_plane(plane, plane_state);
3227 	if (ret != 0)
3228 		goto fail;
3229 
3230 	ret = drm_atomic_commit(state);
3231 fail:
3232 	drm_atomic_state_put(state);
3233 	return ret;
3234 }
3235 EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
3236 
3237 /**
3238  * drm_atomic_helper_set_config - set a new config from userspace
3239  * @set: mode set configuration
3240  * @ctx: lock acquisition context
3241  *
3242  * Provides a default CRTC set_config handler using the atomic driver interface.
3243  *
3244  * NOTE: For backwards compatibility with old userspace this automatically
3245  * resets the "link-status" property to GOOD, to force any link
3246  * re-training. The SETCRTC ioctl does not define whether an update does
3247  * need a full modeset or just a plane update, hence we're allowed to do
3248  * that. See also drm_connector_set_link_status_property().
3249  *
3250  * Returns:
3251  * Returns 0 on success, negative errno numbers on failure.
3252  */
drm_atomic_helper_set_config(struct drm_mode_set * set,struct drm_modeset_acquire_ctx * ctx)3253 int drm_atomic_helper_set_config(struct drm_mode_set *set,
3254 				 struct drm_modeset_acquire_ctx *ctx)
3255 {
3256 	struct drm_atomic_state *state;
3257 	struct drm_crtc *crtc = set->crtc;
3258 	int ret = 0;
3259 
3260 	state = drm_atomic_state_alloc(crtc->dev);
3261 	if (!state)
3262 		return -ENOMEM;
3263 
3264 	state->acquire_ctx = ctx;
3265 	ret = __drm_atomic_helper_set_config(set, state);
3266 	if (ret != 0)
3267 		goto fail;
3268 
3269 	ret = handle_conflicting_encoders(state, true);
3270 	if (ret)
3271 		goto fail;
3272 
3273 	ret = drm_atomic_commit(state);
3274 
3275 fail:
3276 	drm_atomic_state_put(state);
3277 	return ret;
3278 }
3279 EXPORT_SYMBOL(drm_atomic_helper_set_config);
3280 
3281 /**
3282  * drm_atomic_helper_disable_all - disable all currently active outputs
3283  * @dev: DRM device
3284  * @ctx: lock acquisition context
3285  *
3286  * Loops through all connectors, finding those that aren't turned off and then
3287  * turns them off by setting their DPMS mode to OFF and deactivating the CRTC
3288  * that they are connected to.
3289  *
3290  * This is used for example in suspend/resume to disable all currently active
3291  * functions when suspending. If you just want to shut down everything at e.g.
3292  * driver unload, look at drm_atomic_helper_shutdown().
3293  *
3294  * Note that if callers haven't already acquired all modeset locks this might
3295  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
3296  *
3297  * Returns:
3298  * 0 on success or a negative error code on failure.
3299  *
3300  * See also:
3301  * drm_atomic_helper_suspend(), drm_atomic_helper_resume() and
3302  * drm_atomic_helper_shutdown().
3303  */
drm_atomic_helper_disable_all(struct drm_device * dev,struct drm_modeset_acquire_ctx * ctx)3304 int drm_atomic_helper_disable_all(struct drm_device *dev,
3305 				  struct drm_modeset_acquire_ctx *ctx)
3306 {
3307 	struct drm_atomic_state *state;
3308 	struct drm_connector_state *conn_state;
3309 	struct drm_connector *conn;
3310 	struct drm_plane_state *plane_state;
3311 	struct drm_plane *plane;
3312 	struct drm_crtc_state *crtc_state;
3313 	struct drm_crtc *crtc;
3314 	int ret, i;
3315 
3316 	state = drm_atomic_state_alloc(dev);
3317 	if (!state)
3318 		return -ENOMEM;
3319 
3320 	state->acquire_ctx = ctx;
3321 
3322 	drm_for_each_crtc(crtc, dev) {
3323 		crtc_state = drm_atomic_get_crtc_state(state, crtc);
3324 		if (IS_ERR(crtc_state)) {
3325 			ret = PTR_ERR(crtc_state);
3326 			goto free;
3327 		}
3328 
3329 		crtc_state->active = false;
3330 
3331 		ret = drm_atomic_set_mode_prop_for_crtc(crtc_state, NULL);
3332 		if (ret < 0)
3333 			goto free;
3334 
3335 		ret = drm_atomic_add_affected_planes(state, crtc);
3336 		if (ret < 0)
3337 			goto free;
3338 
3339 		ret = drm_atomic_add_affected_connectors(state, crtc);
3340 		if (ret < 0)
3341 			goto free;
3342 	}
3343 
3344 	for_each_new_connector_in_state(state, conn, conn_state, i) {
3345 		ret = drm_atomic_set_crtc_for_connector(conn_state, NULL);
3346 		if (ret < 0)
3347 			goto free;
3348 	}
3349 
3350 	for_each_new_plane_in_state(state, plane, plane_state, i) {
3351 		ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
3352 		if (ret < 0)
3353 			goto free;
3354 
3355 		drm_atomic_set_fb_for_plane(plane_state, NULL);
3356 	}
3357 
3358 	ret = drm_atomic_commit(state);
3359 free:
3360 	drm_atomic_state_put(state);
3361 	return ret;
3362 }
3363 EXPORT_SYMBOL(drm_atomic_helper_disable_all);
3364 
3365 /**
3366  * drm_atomic_helper_shutdown - shutdown all CRTC
3367  * @dev: DRM device
3368  *
3369  * This shuts down all CRTC, which is useful for driver unloading. Shutdown on
3370  * suspend should instead be handled with drm_atomic_helper_suspend(), since
3371  * that also takes a snapshot of the modeset state to be restored on resume.
3372  *
3373  * This is just a convenience wrapper around drm_atomic_helper_disable_all(),
3374  * and it is the atomic version of drm_helper_force_disable_all().
3375  */
drm_atomic_helper_shutdown(struct drm_device * dev)3376 void drm_atomic_helper_shutdown(struct drm_device *dev)
3377 {
3378 	struct drm_modeset_acquire_ctx ctx;
3379 	int ret;
3380 
3381 	if (dev == NULL)
3382 		return;
3383 
3384 	DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, ret);
3385 
3386 	ret = drm_atomic_helper_disable_all(dev, &ctx);
3387 	if (ret)
3388 		drm_err(dev,
3389 			"Disabling all crtc's during unload failed with %i\n",
3390 			ret);
3391 
3392 	DRM_MODESET_LOCK_ALL_END(dev, ctx, ret);
3393 }
3394 EXPORT_SYMBOL(drm_atomic_helper_shutdown);
3395 
3396 /**
3397  * drm_atomic_helper_duplicate_state - duplicate an atomic state object
3398  * @dev: DRM device
3399  * @ctx: lock acquisition context
3400  *
3401  * Makes a copy of the current atomic state by looping over all objects and
3402  * duplicating their respective states. This is used for example by suspend/
3403  * resume support code to save the state prior to suspend such that it can
3404  * be restored upon resume.
3405  *
3406  * Note that this treats atomic state as persistent between save and restore.
3407  * Drivers must make sure that this is possible and won't result in confusion
3408  * or erroneous behaviour.
3409  *
3410  * Note that if callers haven't already acquired all modeset locks this might
3411  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
3412  *
3413  * Returns:
3414  * A pointer to the copy of the atomic state object on success or an
3415  * ERR_PTR()-encoded error code on failure.
3416  *
3417  * See also:
3418  * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
3419  */
3420 struct drm_atomic_state *
drm_atomic_helper_duplicate_state(struct drm_device * dev,struct drm_modeset_acquire_ctx * ctx)3421 drm_atomic_helper_duplicate_state(struct drm_device *dev,
3422 				  struct drm_modeset_acquire_ctx *ctx)
3423 {
3424 	struct drm_atomic_state *state;
3425 	struct drm_connector *conn;
3426 	struct drm_connector_list_iter conn_iter;
3427 	struct drm_plane *plane;
3428 	struct drm_crtc *crtc;
3429 	int err = 0;
3430 
3431 	state = drm_atomic_state_alloc(dev);
3432 	if (!state)
3433 		return ERR_PTR(-ENOMEM);
3434 
3435 	state->acquire_ctx = ctx;
3436 	state->duplicated = true;
3437 
3438 	drm_for_each_crtc(crtc, dev) {
3439 		struct drm_crtc_state *crtc_state;
3440 
3441 		crtc_state = drm_atomic_get_crtc_state(state, crtc);
3442 		if (IS_ERR(crtc_state)) {
3443 			err = PTR_ERR(crtc_state);
3444 			goto free;
3445 		}
3446 	}
3447 
3448 	drm_for_each_plane(plane, dev) {
3449 		struct drm_plane_state *plane_state;
3450 
3451 		plane_state = drm_atomic_get_plane_state(state, plane);
3452 		if (IS_ERR(plane_state)) {
3453 			err = PTR_ERR(plane_state);
3454 			goto free;
3455 		}
3456 	}
3457 
3458 	drm_connector_list_iter_begin(dev, &conn_iter);
3459 	drm_for_each_connector_iter(conn, &conn_iter) {
3460 		struct drm_connector_state *conn_state;
3461 
3462 		conn_state = drm_atomic_get_connector_state(state, conn);
3463 		if (IS_ERR(conn_state)) {
3464 			err = PTR_ERR(conn_state);
3465 			drm_connector_list_iter_end(&conn_iter);
3466 			goto free;
3467 		}
3468 	}
3469 	drm_connector_list_iter_end(&conn_iter);
3470 
3471 	/* clear the acquire context so that it isn't accidentally reused */
3472 	state->acquire_ctx = NULL;
3473 
3474 free:
3475 	if (err < 0) {
3476 		drm_atomic_state_put(state);
3477 		state = ERR_PTR(err);
3478 	}
3479 
3480 	return state;
3481 }
3482 EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
3483 
3484 /**
3485  * drm_atomic_helper_suspend - subsystem-level suspend helper
3486  * @dev: DRM device
3487  *
3488  * Duplicates the current atomic state, disables all active outputs and then
3489  * returns a pointer to the original atomic state to the caller. Drivers can
3490  * pass this pointer to the drm_atomic_helper_resume() helper upon resume to
3491  * restore the output configuration that was active at the time the system
3492  * entered suspend.
3493  *
3494  * Note that it is potentially unsafe to use this. The atomic state object
3495  * returned by this function is assumed to be persistent. Drivers must ensure
3496  * that this holds true. Before calling this function, drivers must make sure
3497  * to suspend fbdev emulation so that nothing can be using the device.
3498  *
3499  * Returns:
3500  * A pointer to a copy of the state before suspend on success or an ERR_PTR()-
3501  * encoded error code on failure. Drivers should store the returned atomic
3502  * state object and pass it to the drm_atomic_helper_resume() helper upon
3503  * resume.
3504  *
3505  * See also:
3506  * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(),
3507  * drm_atomic_helper_resume(), drm_atomic_helper_commit_duplicated_state()
3508  */
drm_atomic_helper_suspend(struct drm_device * dev)3509 struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev)
3510 {
3511 	struct drm_modeset_acquire_ctx ctx;
3512 	struct drm_atomic_state *state;
3513 	int err;
3514 
3515 	/* This can never be returned, but it makes the compiler happy */
3516 	state = ERR_PTR(-EINVAL);
3517 
3518 	DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, err);
3519 
3520 	state = drm_atomic_helper_duplicate_state(dev, &ctx);
3521 	if (IS_ERR(state))
3522 		goto unlock;
3523 
3524 	err = drm_atomic_helper_disable_all(dev, &ctx);
3525 	if (err < 0) {
3526 		drm_atomic_state_put(state);
3527 		state = ERR_PTR(err);
3528 		goto unlock;
3529 	}
3530 
3531 unlock:
3532 	DRM_MODESET_LOCK_ALL_END(dev, ctx, err);
3533 	if (err)
3534 		return ERR_PTR(err);
3535 
3536 	return state;
3537 }
3538 EXPORT_SYMBOL(drm_atomic_helper_suspend);
3539 
3540 /**
3541  * drm_atomic_helper_commit_duplicated_state - commit duplicated state
3542  * @state: duplicated atomic state to commit
3543  * @ctx: pointer to acquire_ctx to use for commit.
3544  *
3545  * The state returned by drm_atomic_helper_duplicate_state() and
3546  * drm_atomic_helper_suspend() is partially invalid, and needs to
3547  * be fixed up before commit.
3548  *
3549  * Returns:
3550  * 0 on success or a negative error code on failure.
3551  *
3552  * See also:
3553  * drm_atomic_helper_suspend()
3554  */
drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state * state,struct drm_modeset_acquire_ctx * ctx)3555 int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
3556 					      struct drm_modeset_acquire_ctx *ctx)
3557 {
3558 	int i, ret;
3559 	struct drm_plane *plane;
3560 	struct drm_plane_state *new_plane_state;
3561 	struct drm_connector *connector;
3562 	struct drm_connector_state *new_conn_state;
3563 	struct drm_crtc *crtc;
3564 	struct drm_crtc_state *new_crtc_state;
3565 
3566 	state->acquire_ctx = ctx;
3567 
3568 	for_each_new_plane_in_state(state, plane, new_plane_state, i)
3569 		state->planes[i].old_state = plane->state;
3570 
3571 	for_each_new_crtc_in_state(state, crtc, new_crtc_state, i)
3572 		state->crtcs[i].old_state = crtc->state;
3573 
3574 	for_each_new_connector_in_state(state, connector, new_conn_state, i)
3575 		state->connectors[i].old_state = connector->state;
3576 
3577 	ret = drm_atomic_commit(state);
3578 
3579 	state->acquire_ctx = NULL;
3580 
3581 	return ret;
3582 }
3583 EXPORT_SYMBOL(drm_atomic_helper_commit_duplicated_state);
3584 
3585 /**
3586  * drm_atomic_helper_resume - subsystem-level resume helper
3587  * @dev: DRM device
3588  * @state: atomic state to resume to
3589  *
3590  * Calls drm_mode_config_reset() to synchronize hardware and software states,
3591  * grabs all modeset locks and commits the atomic state object. This can be
3592  * used in conjunction with the drm_atomic_helper_suspend() helper to
3593  * implement suspend/resume for drivers that support atomic mode-setting.
3594  *
3595  * Returns:
3596  * 0 on success or a negative error code on failure.
3597  *
3598  * See also:
3599  * drm_atomic_helper_suspend()
3600  */
drm_atomic_helper_resume(struct drm_device * dev,struct drm_atomic_state * state)3601 int drm_atomic_helper_resume(struct drm_device *dev,
3602 			     struct drm_atomic_state *state)
3603 {
3604 	struct drm_modeset_acquire_ctx ctx;
3605 	int err;
3606 
3607 	drm_mode_config_reset(dev);
3608 
3609 	DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, err);
3610 
3611 	err = drm_atomic_helper_commit_duplicated_state(state, &ctx);
3612 
3613 	DRM_MODESET_LOCK_ALL_END(dev, ctx, err);
3614 	drm_atomic_state_put(state);
3615 
3616 	return err;
3617 }
3618 EXPORT_SYMBOL(drm_atomic_helper_resume);
3619 
page_flip_common(struct drm_atomic_state * state,struct drm_crtc * crtc,struct drm_framebuffer * fb,struct drm_pending_vblank_event * event,uint32_t flags)3620 static int page_flip_common(struct drm_atomic_state *state,
3621 			    struct drm_crtc *crtc,
3622 			    struct drm_framebuffer *fb,
3623 			    struct drm_pending_vblank_event *event,
3624 			    uint32_t flags)
3625 {
3626 	struct drm_plane *plane = crtc->primary;
3627 	struct drm_plane_state *plane_state;
3628 	struct drm_crtc_state *crtc_state;
3629 	int ret = 0;
3630 
3631 	crtc_state = drm_atomic_get_crtc_state(state, crtc);
3632 	if (IS_ERR(crtc_state))
3633 		return PTR_ERR(crtc_state);
3634 
3635 	crtc_state->event = event;
3636 	crtc_state->async_flip = flags & DRM_MODE_PAGE_FLIP_ASYNC;
3637 
3638 	plane_state = drm_atomic_get_plane_state(state, plane);
3639 	if (IS_ERR(plane_state))
3640 		return PTR_ERR(plane_state);
3641 
3642 	ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
3643 	if (ret != 0)
3644 		return ret;
3645 	drm_atomic_set_fb_for_plane(plane_state, fb);
3646 
3647 	/* Make sure we don't accidentally do a full modeset. */
3648 	state->allow_modeset = false;
3649 	if (!crtc_state->active) {
3650 		drm_dbg_atomic(crtc->dev,
3651 			       "[CRTC:%d:%s] disabled, rejecting legacy flip\n",
3652 			       crtc->base.id, crtc->name);
3653 		return -EINVAL;
3654 	}
3655 
3656 	return ret;
3657 }
3658 
3659 /**
3660  * drm_atomic_helper_page_flip - execute a legacy page flip
3661  * @crtc: DRM CRTC
3662  * @fb: DRM framebuffer
3663  * @event: optional DRM event to signal upon completion
3664  * @flags: flip flags for non-vblank sync'ed updates
3665  * @ctx: lock acquisition context
3666  *
3667  * Provides a default &drm_crtc_funcs.page_flip implementation
3668  * using the atomic driver interface.
3669  *
3670  * Returns:
3671  * Returns 0 on success, negative errno numbers on failure.
3672  *
3673  * See also:
3674  * drm_atomic_helper_page_flip_target()
3675  */
drm_atomic_helper_page_flip(struct drm_crtc * crtc,struct drm_framebuffer * fb,struct drm_pending_vblank_event * event,uint32_t flags,struct drm_modeset_acquire_ctx * ctx)3676 int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
3677 				struct drm_framebuffer *fb,
3678 				struct drm_pending_vblank_event *event,
3679 				uint32_t flags,
3680 				struct drm_modeset_acquire_ctx *ctx)
3681 {
3682 	struct drm_plane *plane = crtc->primary;
3683 	struct drm_atomic_state *state;
3684 	int ret = 0;
3685 
3686 	state = drm_atomic_state_alloc(plane->dev);
3687 	if (!state)
3688 		return -ENOMEM;
3689 
3690 	state->acquire_ctx = ctx;
3691 
3692 	ret = page_flip_common(state, crtc, fb, event, flags);
3693 	if (ret != 0)
3694 		goto fail;
3695 
3696 	ret = drm_atomic_nonblocking_commit(state);
3697 fail:
3698 	drm_atomic_state_put(state);
3699 	return ret;
3700 }
3701 EXPORT_SYMBOL(drm_atomic_helper_page_flip);
3702 
3703 /**
3704  * drm_atomic_helper_page_flip_target - do page flip on target vblank period.
3705  * @crtc: DRM CRTC
3706  * @fb: DRM framebuffer
3707  * @event: optional DRM event to signal upon completion
3708  * @flags: flip flags for non-vblank sync'ed updates
3709  * @target: specifying the target vblank period when the flip to take effect
3710  * @ctx: lock acquisition context
3711  *
3712  * Provides a default &drm_crtc_funcs.page_flip_target implementation.
3713  * Similar to drm_atomic_helper_page_flip() with extra parameter to specify
3714  * target vblank period to flip.
3715  *
3716  * Returns:
3717  * Returns 0 on success, negative errno numbers on failure.
3718  */
drm_atomic_helper_page_flip_target(struct drm_crtc * crtc,struct drm_framebuffer * fb,struct drm_pending_vblank_event * event,uint32_t flags,uint32_t target,struct drm_modeset_acquire_ctx * ctx)3719 int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
3720 				       struct drm_framebuffer *fb,
3721 				       struct drm_pending_vblank_event *event,
3722 				       uint32_t flags,
3723 				       uint32_t target,
3724 				       struct drm_modeset_acquire_ctx *ctx)
3725 {
3726 	struct drm_plane *plane = crtc->primary;
3727 	struct drm_atomic_state *state;
3728 	struct drm_crtc_state *crtc_state;
3729 	int ret = 0;
3730 
3731 	state = drm_atomic_state_alloc(plane->dev);
3732 	if (!state)
3733 		return -ENOMEM;
3734 
3735 	state->acquire_ctx = ctx;
3736 
3737 	ret = page_flip_common(state, crtc, fb, event, flags);
3738 	if (ret != 0)
3739 		goto fail;
3740 
3741 	crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
3742 	if (WARN_ON(!crtc_state)) {
3743 		ret = -EINVAL;
3744 		goto fail;
3745 	}
3746 	crtc_state->target_vblank = target;
3747 
3748 	ret = drm_atomic_nonblocking_commit(state);
3749 fail:
3750 	drm_atomic_state_put(state);
3751 	return ret;
3752 }
3753 EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
3754 
3755 /**
3756  * drm_atomic_helper_bridge_propagate_bus_fmt() - Propagate output format to
3757  *						  the input end of a bridge
3758  * @bridge: bridge control structure
3759  * @bridge_state: new bridge state
3760  * @crtc_state: new CRTC state
3761  * @conn_state: new connector state
3762  * @output_fmt: tested output bus format
3763  * @num_input_fmts: will contain the size of the returned array
3764  *
3765  * This helper is a pluggable implementation of the
3766  * &drm_bridge_funcs.atomic_get_input_bus_fmts operation for bridges that don't
3767  * modify the bus configuration between their input and their output. It
3768  * returns an array of input formats with a single element set to @output_fmt.
3769  *
3770  * RETURNS:
3771  * a valid format array of size @num_input_fmts, or NULL if the allocation
3772  * failed
3773  */
3774 u32 *
drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state,struct drm_crtc_state * crtc_state,struct drm_connector_state * conn_state,u32 output_fmt,unsigned int * num_input_fmts)3775 drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge,
3776 					struct drm_bridge_state *bridge_state,
3777 					struct drm_crtc_state *crtc_state,
3778 					struct drm_connector_state *conn_state,
3779 					u32 output_fmt,
3780 					unsigned int *num_input_fmts)
3781 {
3782 	u32 *input_fmts;
3783 
3784 	input_fmts = kzalloc(sizeof(*input_fmts), GFP_KERNEL);
3785 	if (!input_fmts) {
3786 		*num_input_fmts = 0;
3787 		return NULL;
3788 	}
3789 
3790 	*num_input_fmts = 1;
3791 	input_fmts[0] = output_fmt;
3792 	return input_fmts;
3793 }
3794 EXPORT_SYMBOL(drm_atomic_helper_bridge_propagate_bus_fmt);
3795