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