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