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