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