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