Merge airlied/drm-next into drm-intel-next-queued
[muen/linux.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_planes - validate state object for planes changes
700  * @dev: DRM device
701  * @state: the driver state object
702  *
703  * Check the state object to see if the requested state is physically possible.
704  * This does all the plane update related checks using by calling into the
705  * &drm_crtc_helper_funcs.atomic_check and &drm_plane_helper_funcs.atomic_check
706  * hooks provided by the driver.
707  *
708  * It also sets &drm_crtc_state.planes_changed to indicate that a crtc has
709  * updated planes.
710  *
711  * RETURNS:
712  * Zero for success or -errno
713  */
714 int
715 drm_atomic_helper_check_planes(struct drm_device *dev,
716                                struct drm_atomic_state *state)
717 {
718         struct drm_crtc *crtc;
719         struct drm_crtc_state *new_crtc_state;
720         struct drm_plane *plane;
721         struct drm_plane_state *new_plane_state, *old_plane_state;
722         int i, ret = 0;
723
724         for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
725                 const struct drm_plane_helper_funcs *funcs;
726
727                 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
728
729                 funcs = plane->helper_private;
730
731                 drm_atomic_helper_plane_changed(state, old_plane_state, new_plane_state, plane);
732
733                 if (!funcs || !funcs->atomic_check)
734                         continue;
735
736                 ret = funcs->atomic_check(plane, new_plane_state);
737                 if (ret) {
738                         DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic driver check failed\n",
739                                          plane->base.id, plane->name);
740                         return ret;
741                 }
742         }
743
744         for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
745                 const struct drm_crtc_helper_funcs *funcs;
746
747                 funcs = crtc->helper_private;
748
749                 if (!funcs || !funcs->atomic_check)
750                         continue;
751
752                 ret = funcs->atomic_check(crtc, new_crtc_state);
753                 if (ret) {
754                         DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic driver check failed\n",
755                                          crtc->base.id, crtc->name);
756                         return ret;
757                 }
758         }
759
760         return ret;
761 }
762 EXPORT_SYMBOL(drm_atomic_helper_check_planes);
763
764 /**
765  * drm_atomic_helper_check - validate state object
766  * @dev: DRM device
767  * @state: the driver state object
768  *
769  * Check the state object to see if the requested state is physically possible.
770  * Only crtcs and planes have check callbacks, so for any additional (global)
771  * checking that a driver needs it can simply wrap that around this function.
772  * Drivers without such needs can directly use this as their
773  * &drm_mode_config_funcs.atomic_check callback.
774  *
775  * This just wraps the two parts of the state checking for planes and modeset
776  * state in the default order: First it calls drm_atomic_helper_check_modeset()
777  * and then drm_atomic_helper_check_planes(). The assumption is that the
778  * @drm_plane_helper_funcs.atomic_check and @drm_crtc_helper_funcs.atomic_check
779  * functions depend upon an updated adjusted_mode.clock to e.g. properly compute
780  * watermarks.
781  *
782  * RETURNS:
783  * Zero for success or -errno
784  */
785 int drm_atomic_helper_check(struct drm_device *dev,
786                             struct drm_atomic_state *state)
787 {
788         int ret;
789
790         ret = drm_atomic_helper_check_modeset(dev, state);
791         if (ret)
792                 return ret;
793
794         ret = drm_atomic_helper_check_planes(dev, state);
795         if (ret)
796                 return ret;
797
798         if (state->legacy_cursor_update)
799                 state->async_update = !drm_atomic_helper_async_check(dev, state);
800
801         return ret;
802 }
803 EXPORT_SYMBOL(drm_atomic_helper_check);
804
805 static void
806 disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state)
807 {
808         struct drm_connector *connector;
809         struct drm_connector_state *old_conn_state, *new_conn_state;
810         struct drm_crtc *crtc;
811         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
812         int i;
813
814         for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
815                 const struct drm_encoder_helper_funcs *funcs;
816                 struct drm_encoder *encoder;
817
818                 /* Shut down everything that's in the changeset and currently
819                  * still on. So need to check the old, saved state. */
820                 if (!old_conn_state->crtc)
821                         continue;
822
823                 old_crtc_state = drm_atomic_get_old_crtc_state(old_state, old_conn_state->crtc);
824
825                 if (!old_crtc_state->active ||
826                     !drm_atomic_crtc_needs_modeset(old_conn_state->crtc->state))
827                         continue;
828
829                 encoder = old_conn_state->best_encoder;
830
831                 /* We shouldn't get this far if we didn't previously have
832                  * an encoder.. but WARN_ON() rather than explode.
833                  */
834                 if (WARN_ON(!encoder))
835                         continue;
836
837                 funcs = encoder->helper_private;
838
839                 DRM_DEBUG_ATOMIC("disabling [ENCODER:%d:%s]\n",
840                                  encoder->base.id, encoder->name);
841
842                 /*
843                  * Each encoder has at most one connector (since we always steal
844                  * it away), so we won't call disable hooks twice.
845                  */
846                 drm_bridge_disable(encoder->bridge);
847
848                 /* Right function depends upon target state. */
849                 if (funcs) {
850                         if (new_conn_state->crtc && funcs->prepare)
851                                 funcs->prepare(encoder);
852                         else if (funcs->disable)
853                                 funcs->disable(encoder);
854                         else if (funcs->dpms)
855                                 funcs->dpms(encoder, DRM_MODE_DPMS_OFF);
856                 }
857
858                 drm_bridge_post_disable(encoder->bridge);
859         }
860
861         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
862                 const struct drm_crtc_helper_funcs *funcs;
863
864                 /* Shut down everything that needs a full modeset. */
865                 if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
866                         continue;
867
868                 if (!old_crtc_state->active)
869                         continue;
870
871                 funcs = crtc->helper_private;
872
873                 DRM_DEBUG_ATOMIC("disabling [CRTC:%d:%s]\n",
874                                  crtc->base.id, crtc->name);
875
876
877                 /* Right function depends upon target state. */
878                 if (new_crtc_state->enable && funcs->prepare)
879                         funcs->prepare(crtc);
880                 else if (funcs->atomic_disable)
881                         funcs->atomic_disable(crtc, old_crtc_state);
882                 else if (funcs->disable)
883                         funcs->disable(crtc);
884                 else
885                         funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
886         }
887 }
888
889 /**
890  * drm_atomic_helper_update_legacy_modeset_state - update legacy modeset state
891  * @dev: DRM device
892  * @old_state: atomic state object with old state structures
893  *
894  * This function updates all the various legacy modeset state pointers in
895  * connectors, encoders and crtcs. It also updates the timestamping constants
896  * used for precise vblank timestamps by calling
897  * drm_calc_timestamping_constants().
898  *
899  * Drivers can use this for building their own atomic commit if they don't have
900  * a pure helper-based modeset implementation.
901  */
902 void
903 drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
904                                               struct drm_atomic_state *old_state)
905 {
906         struct drm_connector *connector;
907         struct drm_connector_state *old_conn_state, *new_conn_state;
908         struct drm_crtc *crtc;
909         struct drm_crtc_state *new_crtc_state;
910         int i;
911
912         /* clear out existing links and update dpms */
913         for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
914                 if (connector->encoder) {
915                         WARN_ON(!connector->encoder->crtc);
916
917                         connector->encoder->crtc = NULL;
918                         connector->encoder = NULL;
919                 }
920
921                 crtc = new_conn_state->crtc;
922                 if ((!crtc && old_conn_state->crtc) ||
923                     (crtc && drm_atomic_crtc_needs_modeset(crtc->state))) {
924                         int mode = DRM_MODE_DPMS_OFF;
925
926                         if (crtc && crtc->state->active)
927                                 mode = DRM_MODE_DPMS_ON;
928
929                         connector->dpms = mode;
930                 }
931         }
932
933         /* set new links */
934         for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
935                 if (!new_conn_state->crtc)
936                         continue;
937
938                 if (WARN_ON(!new_conn_state->best_encoder))
939                         continue;
940
941                 connector->encoder = new_conn_state->best_encoder;
942                 connector->encoder->crtc = new_conn_state->crtc;
943         }
944
945         /* set legacy state in the crtc structure */
946         for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
947                 struct drm_plane *primary = crtc->primary;
948                 struct drm_plane_state *new_plane_state;
949
950                 crtc->mode = new_crtc_state->mode;
951                 crtc->enabled = new_crtc_state->enable;
952
953                 new_plane_state =
954                         drm_atomic_get_new_plane_state(old_state, primary);
955
956                 if (new_plane_state && new_plane_state->crtc == crtc) {
957                         crtc->x = new_plane_state->src_x >> 16;
958                         crtc->y = new_plane_state->src_y >> 16;
959                 }
960
961                 if (new_crtc_state->enable)
962                         drm_calc_timestamping_constants(crtc,
963                                                         &new_crtc_state->adjusted_mode);
964         }
965 }
966 EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state);
967
968 static void
969 crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state)
970 {
971         struct drm_crtc *crtc;
972         struct drm_crtc_state *new_crtc_state;
973         struct drm_connector *connector;
974         struct drm_connector_state *new_conn_state;
975         int i;
976
977         for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
978                 const struct drm_crtc_helper_funcs *funcs;
979
980                 if (!new_crtc_state->mode_changed)
981                         continue;
982
983                 funcs = crtc->helper_private;
984
985                 if (new_crtc_state->enable && funcs->mode_set_nofb) {
986                         DRM_DEBUG_ATOMIC("modeset on [CRTC:%d:%s]\n",
987                                          crtc->base.id, crtc->name);
988
989                         funcs->mode_set_nofb(crtc);
990                 }
991         }
992
993         for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
994                 const struct drm_encoder_helper_funcs *funcs;
995                 struct drm_encoder *encoder;
996                 struct drm_display_mode *mode, *adjusted_mode;
997
998                 if (!new_conn_state->best_encoder)
999                         continue;
1000
1001                 encoder = new_conn_state->best_encoder;
1002                 funcs = encoder->helper_private;
1003                 new_crtc_state = new_conn_state->crtc->state;
1004                 mode = &new_crtc_state->mode;
1005                 adjusted_mode = &new_crtc_state->adjusted_mode;
1006
1007                 if (!new_crtc_state->mode_changed)
1008                         continue;
1009
1010                 DRM_DEBUG_ATOMIC("modeset on [ENCODER:%d:%s]\n",
1011                                  encoder->base.id, encoder->name);
1012
1013                 /*
1014                  * Each encoder has at most one connector (since we always steal
1015                  * it away), so we won't call mode_set hooks twice.
1016                  */
1017                 if (funcs && funcs->atomic_mode_set) {
1018                         funcs->atomic_mode_set(encoder, new_crtc_state,
1019                                                new_conn_state);
1020                 } else if (funcs && funcs->mode_set) {
1021                         funcs->mode_set(encoder, mode, adjusted_mode);
1022                 }
1023
1024                 drm_bridge_mode_set(encoder->bridge, mode, adjusted_mode);
1025         }
1026 }
1027
1028 /**
1029  * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs
1030  * @dev: DRM device
1031  * @old_state: atomic state object with old state structures
1032  *
1033  * This function shuts down all the outputs that need to be shut down and
1034  * prepares them (if required) with the new mode.
1035  *
1036  * For compatibility with legacy crtc helpers this should be called before
1037  * drm_atomic_helper_commit_planes(), which is what the default commit function
1038  * does. But drivers with different needs can group the modeset commits together
1039  * and do the plane commits at the end. This is useful for drivers doing runtime
1040  * PM since planes updates then only happen when the CRTC is actually enabled.
1041  */
1042 void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
1043                                                struct drm_atomic_state *old_state)
1044 {
1045         disable_outputs(dev, old_state);
1046
1047         drm_atomic_helper_update_legacy_modeset_state(dev, old_state);
1048
1049         crtc_set_mode(dev, old_state);
1050 }
1051 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables);
1052
1053 /**
1054  * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs
1055  * @dev: DRM device
1056  * @old_state: atomic state object with old state structures
1057  *
1058  * This function enables all the outputs with the new configuration which had to
1059  * be turned off for the update.
1060  *
1061  * For compatibility with legacy crtc helpers this should be called after
1062  * drm_atomic_helper_commit_planes(), which is what the default commit function
1063  * does. But drivers with different needs can group the modeset commits together
1064  * and do the plane commits at the end. This is useful for drivers doing runtime
1065  * PM since planes updates then only happen when the CRTC is actually enabled.
1066  */
1067 void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
1068                                               struct drm_atomic_state *old_state)
1069 {
1070         struct drm_crtc *crtc;
1071         struct drm_crtc_state *old_crtc_state;
1072         struct drm_crtc_state *new_crtc_state;
1073         struct drm_connector *connector;
1074         struct drm_connector_state *new_conn_state;
1075         int i;
1076
1077         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1078                 const struct drm_crtc_helper_funcs *funcs;
1079
1080                 /* Need to filter out CRTCs where only planes change. */
1081                 if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
1082                         continue;
1083
1084                 if (!new_crtc_state->active)
1085                         continue;
1086
1087                 funcs = crtc->helper_private;
1088
1089                 if (new_crtc_state->enable) {
1090                         DRM_DEBUG_ATOMIC("enabling [CRTC:%d:%s]\n",
1091                                          crtc->base.id, crtc->name);
1092
1093                         if (funcs->atomic_enable)
1094                                 funcs->atomic_enable(crtc, old_crtc_state);
1095                         else
1096                                 funcs->commit(crtc);
1097                 }
1098         }
1099
1100         for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1101                 const struct drm_encoder_helper_funcs *funcs;
1102                 struct drm_encoder *encoder;
1103
1104                 if (!new_conn_state->best_encoder)
1105                         continue;
1106
1107                 if (!new_conn_state->crtc->state->active ||
1108                     !drm_atomic_crtc_needs_modeset(new_conn_state->crtc->state))
1109                         continue;
1110
1111                 encoder = new_conn_state->best_encoder;
1112                 funcs = encoder->helper_private;
1113
1114                 DRM_DEBUG_ATOMIC("enabling [ENCODER:%d:%s]\n",
1115                                  encoder->base.id, encoder->name);
1116
1117                 /*
1118                  * Each encoder has at most one connector (since we always steal
1119                  * it away), so we won't call enable hooks twice.
1120                  */
1121                 drm_bridge_pre_enable(encoder->bridge);
1122
1123                 if (funcs) {
1124                         if (funcs->enable)
1125                                 funcs->enable(encoder);
1126                         else if (funcs->commit)
1127                                 funcs->commit(encoder);
1128                 }
1129
1130                 drm_bridge_enable(encoder->bridge);
1131         }
1132 }
1133 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
1134
1135 /**
1136  * drm_atomic_helper_wait_for_fences - wait for fences stashed in plane state
1137  * @dev: DRM device
1138  * @state: atomic state object with old state structures
1139  * @pre_swap: If true, do an interruptible wait, and @state is the new state.
1140  *      Otherwise @state is the old state.
1141  *
1142  * For implicit sync, driver should fish the exclusive fence out from the
1143  * incoming fb's and stash it in the drm_plane_state.  This is called after
1144  * drm_atomic_helper_swap_state() so it uses the current plane state (and
1145  * just uses the atomic state to find the changed planes)
1146  *
1147  * Note that @pre_swap is needed since the point where we block for fences moves
1148  * around depending upon whether an atomic commit is blocking or
1149  * non-blocking. For non-blocking commit all waiting needs to happen after
1150  * drm_atomic_helper_swap_state() is called, but for blocking commits we want
1151  * to wait **before** we do anything that can't be easily rolled back. That is
1152  * before we call drm_atomic_helper_swap_state().
1153  *
1154  * Returns zero if success or < 0 if dma_fence_wait() fails.
1155  */
1156 int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
1157                                       struct drm_atomic_state *state,
1158                                       bool pre_swap)
1159 {
1160         struct drm_plane *plane;
1161         struct drm_plane_state *new_plane_state;
1162         int i, ret;
1163
1164         for_each_new_plane_in_state(state, plane, new_plane_state, i) {
1165                 if (!new_plane_state->fence)
1166                         continue;
1167
1168                 WARN_ON(!new_plane_state->fb);
1169
1170                 /*
1171                  * If waiting for fences pre-swap (ie: nonblock), userspace can
1172                  * still interrupt the operation. Instead of blocking until the
1173                  * timer expires, make the wait interruptible.
1174                  */
1175                 ret = dma_fence_wait(new_plane_state->fence, pre_swap);
1176                 if (ret)
1177                         return ret;
1178
1179                 dma_fence_put(new_plane_state->fence);
1180                 new_plane_state->fence = NULL;
1181         }
1182
1183         return 0;
1184 }
1185 EXPORT_SYMBOL(drm_atomic_helper_wait_for_fences);
1186
1187 /**
1188  * drm_atomic_helper_wait_for_vblanks - wait for vblank on crtcs
1189  * @dev: DRM device
1190  * @old_state: atomic state object with old state structures
1191  *
1192  * Helper to, after atomic commit, wait for vblanks on all effected
1193  * crtcs (ie. before cleaning up old framebuffers using
1194  * drm_atomic_helper_cleanup_planes()). It will only wait on CRTCs where the
1195  * framebuffers have actually changed to optimize for the legacy cursor and
1196  * plane update use-case.
1197  *
1198  * Drivers using the nonblocking commit tracking support initialized by calling
1199  * drm_atomic_helper_setup_commit() should look at
1200  * drm_atomic_helper_wait_for_flip_done() as an alternative.
1201  */
1202 void
1203 drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
1204                 struct drm_atomic_state *old_state)
1205 {
1206         struct drm_crtc *crtc;
1207         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1208         int i, ret;
1209         unsigned crtc_mask = 0;
1210
1211          /*
1212           * Legacy cursor ioctls are completely unsynced, and userspace
1213           * relies on that (by doing tons of cursor updates).
1214           */
1215         if (old_state->legacy_cursor_update)
1216                 return;
1217
1218         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1219                 if (!new_crtc_state->active || !new_crtc_state->planes_changed)
1220                         continue;
1221
1222                 ret = drm_crtc_vblank_get(crtc);
1223                 if (ret != 0)
1224                         continue;
1225
1226                 crtc_mask |= drm_crtc_mask(crtc);
1227                 old_state->crtcs[i].last_vblank_count = drm_crtc_vblank_count(crtc);
1228         }
1229
1230         for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1231                 if (!(crtc_mask & drm_crtc_mask(crtc)))
1232                         continue;
1233
1234                 ret = wait_event_timeout(dev->vblank[i].queue,
1235                                 old_state->crtcs[i].last_vblank_count !=
1236                                         drm_crtc_vblank_count(crtc),
1237                                 msecs_to_jiffies(50));
1238
1239                 WARN(!ret, "[CRTC:%d:%s] vblank wait timed out\n",
1240                      crtc->base.id, crtc->name);
1241
1242                 drm_crtc_vblank_put(crtc);
1243         }
1244 }
1245 EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
1246
1247 /**
1248  * drm_atomic_helper_wait_for_flip_done - wait for all page flips to be done
1249  * @dev: DRM device
1250  * @old_state: atomic state object with old state structures
1251  *
1252  * Helper to, after atomic commit, wait for page flips on all effected
1253  * crtcs (ie. before cleaning up old framebuffers using
1254  * drm_atomic_helper_cleanup_planes()). Compared to
1255  * drm_atomic_helper_wait_for_vblanks() this waits for the completion of on all
1256  * CRTCs, assuming that cursors-only updates are signalling their completion
1257  * immediately (or using a different path).
1258  *
1259  * This requires that drivers use the nonblocking commit tracking support
1260  * initialized using drm_atomic_helper_setup_commit().
1261  */
1262 void drm_atomic_helper_wait_for_flip_done(struct drm_device *dev,
1263                                           struct drm_atomic_state *old_state)
1264 {
1265         struct drm_crtc_state *unused;
1266         struct drm_crtc *crtc;
1267         int i;
1268
1269         for_each_new_crtc_in_state(old_state, crtc, unused, i) {
1270                 struct drm_crtc_commit *commit = old_state->crtcs[i].commit;
1271                 int ret;
1272
1273                 if (!commit)
1274                         continue;
1275
1276                 ret = wait_for_completion_timeout(&commit->flip_done, 10 * HZ);
1277                 if (ret == 0)
1278                         DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n",
1279                                   crtc->base.id, crtc->name);
1280         }
1281 }
1282 EXPORT_SYMBOL(drm_atomic_helper_wait_for_flip_done);
1283
1284 /**
1285  * drm_atomic_helper_commit_tail - commit atomic update to hardware
1286  * @old_state: atomic state object with old state structures
1287  *
1288  * This is the default implementation for the
1289  * &drm_mode_config_helper_funcs.atomic_commit_tail hook, for drivers
1290  * that do not support runtime_pm or do not need the CRTC to be
1291  * enabled to perform a commit. Otherwise, see
1292  * drm_atomic_helper_commit_tail_rpm().
1293  *
1294  * Note that the default ordering of how the various stages are called is to
1295  * match the legacy modeset helper library closest.
1296  */
1297 void drm_atomic_helper_commit_tail(struct drm_atomic_state *old_state)
1298 {
1299         struct drm_device *dev = old_state->dev;
1300
1301         drm_atomic_helper_commit_modeset_disables(dev, old_state);
1302
1303         drm_atomic_helper_commit_planes(dev, old_state, 0);
1304
1305         drm_atomic_helper_commit_modeset_enables(dev, old_state);
1306
1307         drm_atomic_helper_commit_hw_done(old_state);
1308
1309         drm_atomic_helper_wait_for_vblanks(dev, old_state);
1310
1311         drm_atomic_helper_cleanup_planes(dev, old_state);
1312 }
1313 EXPORT_SYMBOL(drm_atomic_helper_commit_tail);
1314
1315 /**
1316  * drm_atomic_helper_commit_tail_rpm - commit atomic update to hardware
1317  * @old_state: new modeset state to be committed
1318  *
1319  * This is an alternative implementation for the
1320  * &drm_mode_config_helper_funcs.atomic_commit_tail hook, for drivers
1321  * that support runtime_pm or need the CRTC to be enabled to perform a
1322  * commit. Otherwise, one should use the default implementation
1323  * drm_atomic_helper_commit_tail().
1324  */
1325 void drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state *old_state)
1326 {
1327         struct drm_device *dev = old_state->dev;
1328
1329         drm_atomic_helper_commit_modeset_disables(dev, old_state);
1330
1331         drm_atomic_helper_commit_modeset_enables(dev, old_state);
1332
1333         drm_atomic_helper_commit_planes(dev, old_state,
1334                                         DRM_PLANE_COMMIT_ACTIVE_ONLY);
1335
1336         drm_atomic_helper_commit_hw_done(old_state);
1337
1338         drm_atomic_helper_wait_for_vblanks(dev, old_state);
1339
1340         drm_atomic_helper_cleanup_planes(dev, old_state);
1341 }
1342 EXPORT_SYMBOL(drm_atomic_helper_commit_tail_rpm);
1343
1344 static void commit_tail(struct drm_atomic_state *old_state)
1345 {
1346         struct drm_device *dev = old_state->dev;
1347         const struct drm_mode_config_helper_funcs *funcs;
1348
1349         funcs = dev->mode_config.helper_private;
1350
1351         drm_atomic_helper_wait_for_fences(dev, old_state, false);
1352
1353         drm_atomic_helper_wait_for_dependencies(old_state);
1354
1355         if (funcs && funcs->atomic_commit_tail)
1356                 funcs->atomic_commit_tail(old_state);
1357         else
1358                 drm_atomic_helper_commit_tail(old_state);
1359
1360         drm_atomic_helper_commit_cleanup_done(old_state);
1361
1362         drm_atomic_state_put(old_state);
1363 }
1364
1365 static void commit_work(struct work_struct *work)
1366 {
1367         struct drm_atomic_state *state = container_of(work,
1368                                                       struct drm_atomic_state,
1369                                                       commit_work);
1370         commit_tail(state);
1371 }
1372
1373 /**
1374  * drm_atomic_helper_async_check - check if state can be commited asynchronously
1375  * @dev: DRM device
1376  * @state: the driver state object
1377  *
1378  * This helper will check if it is possible to commit the state asynchronously.
1379  * Async commits are not supposed to swap the states like normal sync commits
1380  * but just do in-place changes on the current state.
1381  *
1382  * It will return 0 if the commit can happen in an asynchronous fashion or error
1383  * if not. Note that error just mean it can't be commited asynchronously, if it
1384  * fails the commit should be treated like a normal synchronous commit.
1385  */
1386 int drm_atomic_helper_async_check(struct drm_device *dev,
1387                                    struct drm_atomic_state *state)
1388 {
1389         struct drm_crtc *crtc;
1390         struct drm_crtc_state *crtc_state;
1391         struct drm_crtc_commit *commit;
1392         struct drm_plane *__plane, *plane = NULL;
1393         struct drm_plane_state *__plane_state, *plane_state = NULL;
1394         const struct drm_plane_helper_funcs *funcs;
1395         int i, j, n_planes = 0;
1396
1397         for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1398                 if (drm_atomic_crtc_needs_modeset(crtc_state))
1399                         return -EINVAL;
1400         }
1401
1402         for_each_new_plane_in_state(state, __plane, __plane_state, i) {
1403                 n_planes++;
1404                 plane = __plane;
1405                 plane_state = __plane_state;
1406         }
1407
1408         /* FIXME: we support only single plane updates for now */
1409         if (!plane || n_planes != 1)
1410                 return -EINVAL;
1411
1412         if (!plane_state->crtc)
1413                 return -EINVAL;
1414
1415         funcs = plane->helper_private;
1416         if (!funcs->atomic_async_update)
1417                 return -EINVAL;
1418
1419         if (plane_state->fence)
1420                 return -EINVAL;
1421
1422         /*
1423          * Don't do an async update if there is an outstanding commit modifying
1424          * the plane.  This prevents our async update's changes from getting
1425          * overridden by a previous synchronous update's state.
1426          */
1427         for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1428                 if (plane->crtc != crtc)
1429                         continue;
1430
1431                 spin_lock(&crtc->commit_lock);
1432                 commit = list_first_entry_or_null(&crtc->commit_list,
1433                                                   struct drm_crtc_commit,
1434                                                   commit_entry);
1435                 if (!commit) {
1436                         spin_unlock(&crtc->commit_lock);
1437                         continue;
1438                 }
1439                 spin_unlock(&crtc->commit_lock);
1440
1441                 if (!crtc->state->state)
1442                         continue;
1443
1444                 for_each_plane_in_state(crtc->state->state, __plane,
1445                                         __plane_state, j) {
1446                         if (__plane == plane)
1447                                 return -EINVAL;
1448                 }
1449         }
1450
1451         return funcs->atomic_async_check(plane, plane_state);
1452 }
1453 EXPORT_SYMBOL(drm_atomic_helper_async_check);
1454
1455 /**
1456  * drm_atomic_helper_async_commit - commit state asynchronously
1457  * @dev: DRM device
1458  * @state: the driver state object
1459  *
1460  * This function commits a state asynchronously, i.e., not vblank
1461  * synchronized. It should be used on a state only when
1462  * drm_atomic_async_check() succeeds. Async commits are not supposed to swap
1463  * the states like normal sync commits, but just do in-place changes on the
1464  * current state.
1465  */
1466 void drm_atomic_helper_async_commit(struct drm_device *dev,
1467                                     struct drm_atomic_state *state)
1468 {
1469         struct drm_plane *plane;
1470         struct drm_plane_state *plane_state;
1471         const struct drm_plane_helper_funcs *funcs;
1472         int i;
1473
1474         for_each_new_plane_in_state(state, plane, plane_state, i) {
1475                 funcs = plane->helper_private;
1476                 funcs->atomic_async_update(plane, plane_state);
1477         }
1478 }
1479 EXPORT_SYMBOL(drm_atomic_helper_async_commit);
1480
1481 /**
1482  * drm_atomic_helper_commit - commit validated state object
1483  * @dev: DRM device
1484  * @state: the driver state object
1485  * @nonblock: whether nonblocking behavior is requested.
1486  *
1487  * This function commits a with drm_atomic_helper_check() pre-validated state
1488  * object. This can still fail when e.g. the framebuffer reservation fails. This
1489  * function implements nonblocking commits, using
1490  * drm_atomic_helper_setup_commit() and related functions.
1491  *
1492  * Committing the actual hardware state is done through the
1493  * &drm_mode_config_helper_funcs.atomic_commit_tail callback, or it's default
1494  * implementation drm_atomic_helper_commit_tail().
1495  *
1496  * RETURNS:
1497  * Zero for success or -errno.
1498  */
1499 int drm_atomic_helper_commit(struct drm_device *dev,
1500                              struct drm_atomic_state *state,
1501                              bool nonblock)
1502 {
1503         int ret;
1504
1505         if (state->async_update) {
1506                 ret = drm_atomic_helper_prepare_planes(dev, state);
1507                 if (ret)
1508                         return ret;
1509
1510                 drm_atomic_helper_async_commit(dev, state);
1511                 drm_atomic_helper_cleanup_planes(dev, state);
1512
1513                 return 0;
1514         }
1515
1516         ret = drm_atomic_helper_setup_commit(state, nonblock);
1517         if (ret)
1518                 return ret;
1519
1520         INIT_WORK(&state->commit_work, commit_work);
1521
1522         ret = drm_atomic_helper_prepare_planes(dev, state);
1523         if (ret)
1524                 return ret;
1525
1526         if (!nonblock) {
1527                 ret = drm_atomic_helper_wait_for_fences(dev, state, true);
1528                 if (ret)
1529                         goto err;
1530         }
1531
1532         /*
1533          * This is the point of no return - everything below never fails except
1534          * when the hw goes bonghits. Which means we can commit the new state on
1535          * the software side now.
1536          */
1537
1538         ret = drm_atomic_helper_swap_state(state, true);
1539         if (ret)
1540                 goto err;
1541
1542         /*
1543          * Everything below can be run asynchronously without the need to grab
1544          * any modeset locks at all under one condition: It must be guaranteed
1545          * that the asynchronous work has either been cancelled (if the driver
1546          * supports it, which at least requires that the framebuffers get
1547          * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
1548          * before the new state gets committed on the software side with
1549          * drm_atomic_helper_swap_state().
1550          *
1551          * This scheme allows new atomic state updates to be prepared and
1552          * checked in parallel to the asynchronous completion of the previous
1553          * update. Which is important since compositors need to figure out the
1554          * composition of the next frame right after having submitted the
1555          * current layout.
1556          *
1557          * NOTE: Commit work has multiple phases, first hardware commit, then
1558          * cleanup. We want them to overlap, hence need system_unbound_wq to
1559          * make sure work items don't artifically stall on each another.
1560          */
1561
1562         drm_atomic_state_get(state);
1563         if (nonblock)
1564                 queue_work(system_unbound_wq, &state->commit_work);
1565         else
1566                 commit_tail(state);
1567
1568         return 0;
1569
1570 err:
1571         drm_atomic_helper_cleanup_planes(dev, state);
1572         return ret;
1573 }
1574 EXPORT_SYMBOL(drm_atomic_helper_commit);
1575
1576 /**
1577  * DOC: implementing nonblocking commit
1578  *
1579  * Nonblocking atomic commits have to be implemented in the following sequence:
1580  *
1581  * 1. Run drm_atomic_helper_prepare_planes() first. This is the only function
1582  * which commit needs to call which can fail, so we want to run it first and
1583  * synchronously.
1584  *
1585  * 2. Synchronize with any outstanding nonblocking commit worker threads which
1586  * might be affected the new state update. This can be done by either cancelling
1587  * or flushing the work items, depending upon whether the driver can deal with
1588  * cancelled updates. Note that it is important to ensure that the framebuffer
1589  * cleanup is still done when cancelling.
1590  *
1591  * Asynchronous workers need to have sufficient parallelism to be able to run
1592  * different atomic commits on different CRTCs in parallel. The simplest way to
1593  * achive this is by running them on the &system_unbound_wq work queue. Note
1594  * that drivers are not required to split up atomic commits and run an
1595  * individual commit in parallel - userspace is supposed to do that if it cares.
1596  * But it might be beneficial to do that for modesets, since those necessarily
1597  * must be done as one global operation, and enabling or disabling a CRTC can
1598  * take a long time. But even that is not required.
1599  *
1600  * 3. The software state is updated synchronously with
1601  * drm_atomic_helper_swap_state(). Doing this under the protection of all modeset
1602  * locks means concurrent callers never see inconsistent state. And doing this
1603  * while it's guaranteed that no relevant nonblocking worker runs means that
1604  * nonblocking workers do not need grab any locks. Actually they must not grab
1605  * locks, for otherwise the work flushing will deadlock.
1606  *
1607  * 4. Schedule a work item to do all subsequent steps, using the split-out
1608  * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
1609  * then cleaning up the framebuffers after the old framebuffer is no longer
1610  * being displayed.
1611  *
1612  * The above scheme is implemented in the atomic helper libraries in
1613  * drm_atomic_helper_commit() using a bunch of helper functions. See
1614  * drm_atomic_helper_setup_commit() for a starting point.
1615  */
1616
1617 static int stall_checks(struct drm_crtc *crtc, bool nonblock)
1618 {
1619         struct drm_crtc_commit *commit, *stall_commit = NULL;
1620         bool completed = true;
1621         int i;
1622         long ret = 0;
1623
1624         spin_lock(&crtc->commit_lock);
1625         i = 0;
1626         list_for_each_entry(commit, &crtc->commit_list, commit_entry) {
1627                 if (i == 0) {
1628                         completed = try_wait_for_completion(&commit->flip_done);
1629                         /* Userspace is not allowed to get ahead of the previous
1630                          * commit with nonblocking ones. */
1631                         if (!completed && nonblock) {
1632                                 spin_unlock(&crtc->commit_lock);
1633                                 return -EBUSY;
1634                         }
1635                 } else if (i == 1) {
1636                         stall_commit = commit;
1637                         drm_crtc_commit_get(stall_commit);
1638                         break;
1639                 }
1640
1641                 i++;
1642         }
1643         spin_unlock(&crtc->commit_lock);
1644
1645         if (!stall_commit)
1646                 return 0;
1647
1648         /* We don't want to let commits get ahead of cleanup work too much,
1649          * stalling on 2nd previous commit means triple-buffer won't ever stall.
1650          */
1651         ret = wait_for_completion_interruptible_timeout(&stall_commit->cleanup_done,
1652                                                         10*HZ);
1653         if (ret == 0)
1654                 DRM_ERROR("[CRTC:%d:%s] cleanup_done timed out\n",
1655                           crtc->base.id, crtc->name);
1656
1657         drm_crtc_commit_put(stall_commit);
1658
1659         return ret < 0 ? ret : 0;
1660 }
1661
1662 static void release_crtc_commit(struct completion *completion)
1663 {
1664         struct drm_crtc_commit *commit = container_of(completion,
1665                                                       typeof(*commit),
1666                                                       flip_done);
1667
1668         drm_crtc_commit_put(commit);
1669 }
1670
1671 /**
1672  * drm_atomic_helper_setup_commit - setup possibly nonblocking commit
1673  * @state: new modeset state to be committed
1674  * @nonblock: whether nonblocking behavior is requested.
1675  *
1676  * This function prepares @state to be used by the atomic helper's support for
1677  * nonblocking commits. Drivers using the nonblocking commit infrastructure
1678  * should always call this function from their
1679  * &drm_mode_config_funcs.atomic_commit hook.
1680  *
1681  * To be able to use this support drivers need to use a few more helper
1682  * functions. drm_atomic_helper_wait_for_dependencies() must be called before
1683  * actually committing the hardware state, and for nonblocking commits this call
1684  * must be placed in the async worker. See also drm_atomic_helper_swap_state()
1685  * and it's stall parameter, for when a driver's commit hooks look at the
1686  * &drm_crtc.state, &drm_plane.state or &drm_connector.state pointer directly.
1687  *
1688  * Completion of the hardware commit step must be signalled using
1689  * drm_atomic_helper_commit_hw_done(). After this step the driver is not allowed
1690  * to read or change any permanent software or hardware modeset state. The only
1691  * exception is state protected by other means than &drm_modeset_lock locks.
1692  * Only the free standing @state with pointers to the old state structures can
1693  * be inspected, e.g. to clean up old buffers using
1694  * drm_atomic_helper_cleanup_planes().
1695  *
1696  * At the very end, before cleaning up @state drivers must call
1697  * drm_atomic_helper_commit_cleanup_done().
1698  *
1699  * This is all implemented by in drm_atomic_helper_commit(), giving drivers a
1700  * complete and esay-to-use default implementation of the atomic_commit() hook.
1701  *
1702  * The tracking of asynchronously executed and still pending commits is done
1703  * using the core structure &drm_crtc_commit.
1704  *
1705  * By default there's no need to clean up resources allocated by this function
1706  * explicitly: drm_atomic_state_default_clear() will take care of that
1707  * automatically.
1708  *
1709  * Returns:
1710  *
1711  * 0 on success. -EBUSY when userspace schedules nonblocking commits too fast,
1712  * -ENOMEM on allocation failures and -EINTR when a signal is pending.
1713  */
1714 int drm_atomic_helper_setup_commit(struct drm_atomic_state *state,
1715                                    bool nonblock)
1716 {
1717         struct drm_crtc *crtc;
1718         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1719         struct drm_crtc_commit *commit;
1720         int i, ret;
1721
1722         for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
1723                 commit = kzalloc(sizeof(*commit), GFP_KERNEL);
1724                 if (!commit)
1725                         return -ENOMEM;
1726
1727                 init_completion(&commit->flip_done);
1728                 init_completion(&commit->hw_done);
1729                 init_completion(&commit->cleanup_done);
1730                 INIT_LIST_HEAD(&commit->commit_entry);
1731                 kref_init(&commit->ref);
1732                 commit->crtc = crtc;
1733
1734                 state->crtcs[i].commit = commit;
1735
1736                 ret = stall_checks(crtc, nonblock);
1737                 if (ret)
1738                         return ret;
1739
1740                 /* Drivers only send out events when at least either current or
1741                  * new CRTC state is active. Complete right away if everything
1742                  * stays off. */
1743                 if (!old_crtc_state->active && !new_crtc_state->active) {
1744                         complete_all(&commit->flip_done);
1745                         continue;
1746                 }
1747
1748                 /* Legacy cursor updates are fully unsynced. */
1749                 if (state->legacy_cursor_update) {
1750                         complete_all(&commit->flip_done);
1751                         continue;
1752                 }
1753
1754                 if (!new_crtc_state->event) {
1755                         commit->event = kzalloc(sizeof(*commit->event),
1756                                                 GFP_KERNEL);
1757                         if (!commit->event)
1758                                 return -ENOMEM;
1759
1760                         new_crtc_state->event = commit->event;
1761                 }
1762
1763                 new_crtc_state->event->base.completion = &commit->flip_done;
1764                 new_crtc_state->event->base.completion_release = release_crtc_commit;
1765                 drm_crtc_commit_get(commit);
1766         }
1767
1768         return 0;
1769 }
1770 EXPORT_SYMBOL(drm_atomic_helper_setup_commit);
1771
1772
1773 static struct drm_crtc_commit *preceeding_commit(struct drm_crtc *crtc)
1774 {
1775         struct drm_crtc_commit *commit;
1776         int i = 0;
1777
1778         list_for_each_entry(commit, &crtc->commit_list, commit_entry) {
1779                 /* skip the first entry, that's the current commit */
1780                 if (i == 1)
1781                         return commit;
1782                 i++;
1783         }
1784
1785         return NULL;
1786 }
1787
1788 /**
1789  * drm_atomic_helper_wait_for_dependencies - wait for required preceeding commits
1790  * @old_state: atomic state object with old state structures
1791  *
1792  * This function waits for all preceeding commits that touch the same CRTC as
1793  * @old_state to both be committed to the hardware (as signalled by
1794  * drm_atomic_helper_commit_hw_done) and executed by the hardware (as signalled
1795  * by calling drm_crtc_vblank_send_event() on the &drm_crtc_state.event).
1796  *
1797  * This is part of the atomic helper support for nonblocking commits, see
1798  * drm_atomic_helper_setup_commit() for an overview.
1799  */
1800 void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *old_state)
1801 {
1802         struct drm_crtc *crtc;
1803         struct drm_crtc_state *new_crtc_state;
1804         struct drm_crtc_commit *commit;
1805         int i;
1806         long ret;
1807
1808         for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
1809                 spin_lock(&crtc->commit_lock);
1810                 commit = preceeding_commit(crtc);
1811                 if (commit)
1812                         drm_crtc_commit_get(commit);
1813                 spin_unlock(&crtc->commit_lock);
1814
1815                 if (!commit)
1816                         continue;
1817
1818                 ret = wait_for_completion_timeout(&commit->hw_done,
1819                                                   10*HZ);
1820                 if (ret == 0)
1821                         DRM_ERROR("[CRTC:%d:%s] hw_done timed out\n",
1822                                   crtc->base.id, crtc->name);
1823
1824                 /* Currently no support for overwriting flips, hence
1825                  * stall for previous one to execute completely. */
1826                 ret = wait_for_completion_timeout(&commit->flip_done,
1827                                                   10*HZ);
1828                 if (ret == 0)
1829                         DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n",
1830                                   crtc->base.id, crtc->name);
1831
1832                 drm_crtc_commit_put(commit);
1833         }
1834 }
1835 EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies);
1836
1837 /**
1838  * drm_atomic_helper_commit_hw_done - setup possible nonblocking commit
1839  * @old_state: atomic state object with old state structures
1840  *
1841  * This function is used to signal completion of the hardware commit step. After
1842  * this step the driver is not allowed to read or change any permanent software
1843  * or hardware modeset state. The only exception is state protected by other
1844  * means than &drm_modeset_lock locks.
1845  *
1846  * Drivers should try to postpone any expensive or delayed cleanup work after
1847  * this function is called.
1848  *
1849  * This is part of the atomic helper support for nonblocking commits, see
1850  * drm_atomic_helper_setup_commit() for an overview.
1851  */
1852 void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *old_state)
1853 {
1854         struct drm_crtc *crtc;
1855         struct drm_crtc_state *new_crtc_state;
1856         struct drm_crtc_commit *commit;
1857         int i;
1858
1859         for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
1860                 commit = old_state->crtcs[i].commit;
1861                 if (!commit)
1862                         continue;
1863
1864                 /* backend must have consumed any event by now */
1865                 WARN_ON(new_crtc_state->event);
1866                 complete_all(&commit->hw_done);
1867         }
1868 }
1869 EXPORT_SYMBOL(drm_atomic_helper_commit_hw_done);
1870
1871 /**
1872  * drm_atomic_helper_commit_cleanup_done - signal completion of commit
1873  * @old_state: atomic state object with old state structures
1874  *
1875  * This signals completion of the atomic update @old_state, including any
1876  * cleanup work. If used, it must be called right before calling
1877  * drm_atomic_state_put().
1878  *
1879  * This is part of the atomic helper support for nonblocking commits, see
1880  * drm_atomic_helper_setup_commit() for an overview.
1881  */
1882 void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *old_state)
1883 {
1884         struct drm_crtc *crtc;
1885         struct drm_crtc_state *new_crtc_state;
1886         struct drm_crtc_commit *commit;
1887         int i;
1888         long ret;
1889
1890         for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
1891                 commit = old_state->crtcs[i].commit;
1892                 if (WARN_ON(!commit))
1893                         continue;
1894
1895                 complete_all(&commit->cleanup_done);
1896                 WARN_ON(!try_wait_for_completion(&commit->hw_done));
1897
1898                 /* commit_list borrows our reference, need to remove before we
1899                  * clean up our drm_atomic_state. But only after it actually
1900                  * completed, otherwise subsequent commits won't stall properly. */
1901                 if (try_wait_for_completion(&commit->flip_done))
1902                         goto del_commit;
1903
1904                 /* We must wait for the vblank event to signal our completion
1905                  * before releasing our reference, since the vblank work does
1906                  * not hold a reference of its own. */
1907                 ret = wait_for_completion_timeout(&commit->flip_done,
1908                                                   10*HZ);
1909                 if (ret == 0)
1910                         DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n",
1911                                   crtc->base.id, crtc->name);
1912
1913 del_commit:
1914                 spin_lock(&crtc->commit_lock);
1915                 list_del(&commit->commit_entry);
1916                 spin_unlock(&crtc->commit_lock);
1917         }
1918 }
1919 EXPORT_SYMBOL(drm_atomic_helper_commit_cleanup_done);
1920
1921 /**
1922  * drm_atomic_helper_prepare_planes - prepare plane resources before commit
1923  * @dev: DRM device
1924  * @state: atomic state object with new state structures
1925  *
1926  * This function prepares plane state, specifically framebuffers, for the new
1927  * configuration, by calling &drm_plane_helper_funcs.prepare_fb. If any failure
1928  * is encountered this function will call &drm_plane_helper_funcs.cleanup_fb on
1929  * any already successfully prepared framebuffer.
1930  *
1931  * Returns:
1932  * 0 on success, negative error code on failure.
1933  */
1934 int drm_atomic_helper_prepare_planes(struct drm_device *dev,
1935                                      struct drm_atomic_state *state)
1936 {
1937         struct drm_plane *plane;
1938         struct drm_plane_state *new_plane_state;
1939         int ret, i, j;
1940
1941         for_each_new_plane_in_state(state, plane, new_plane_state, i) {
1942                 const struct drm_plane_helper_funcs *funcs;
1943
1944                 funcs = plane->helper_private;
1945
1946                 if (funcs->prepare_fb) {
1947                         ret = funcs->prepare_fb(plane, new_plane_state);
1948                         if (ret)
1949                                 goto fail;
1950                 }
1951         }
1952
1953         return 0;
1954
1955 fail:
1956         for_each_new_plane_in_state(state, plane, new_plane_state, j) {
1957                 const struct drm_plane_helper_funcs *funcs;
1958
1959                 if (j >= i)
1960                         continue;
1961
1962                 funcs = plane->helper_private;
1963
1964                 if (funcs->cleanup_fb)
1965                         funcs->cleanup_fb(plane, new_plane_state);
1966         }
1967
1968         return ret;
1969 }
1970 EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
1971
1972 static bool plane_crtc_active(const struct drm_plane_state *state)
1973 {
1974         return state->crtc && state->crtc->state->active;
1975 }
1976
1977 /**
1978  * drm_atomic_helper_commit_planes - commit plane state
1979  * @dev: DRM device
1980  * @old_state: atomic state object with old state structures
1981  * @flags: flags for committing plane state
1982  *
1983  * This function commits the new plane state using the plane and atomic helper
1984  * functions for planes and crtcs. It assumes that the atomic state has already
1985  * been pushed into the relevant object state pointers, since this step can no
1986  * longer fail.
1987  *
1988  * It still requires the global state object @old_state to know which planes and
1989  * crtcs need to be updated though.
1990  *
1991  * Note that this function does all plane updates across all CRTCs in one step.
1992  * If the hardware can't support this approach look at
1993  * drm_atomic_helper_commit_planes_on_crtc() instead.
1994  *
1995  * Plane parameters can be updated by applications while the associated CRTC is
1996  * disabled. The DRM/KMS core will store the parameters in the plane state,
1997  * which will be available to the driver when the CRTC is turned on. As a result
1998  * most drivers don't need to be immediately notified of plane updates for a
1999  * disabled CRTC.
2000  *
2001  * Unless otherwise needed, drivers are advised to set the ACTIVE_ONLY flag in
2002  * @flags in order not to receive plane update notifications related to a
2003  * disabled CRTC. This avoids the need to manually ignore plane updates in
2004  * driver code when the driver and/or hardware can't or just don't need to deal
2005  * with updates on disabled CRTCs, for example when supporting runtime PM.
2006  *
2007  * Drivers may set the NO_DISABLE_AFTER_MODESET flag in @flags if the relevant
2008  * display controllers require to disable a CRTC's planes when the CRTC is
2009  * disabled. This function would skip the &drm_plane_helper_funcs.atomic_disable
2010  * call for a plane if the CRTC of the old plane state needs a modesetting
2011  * operation. Of course, the drivers need to disable the planes in their CRTC
2012  * disable callbacks since no one else would do that.
2013  *
2014  * The drm_atomic_helper_commit() default implementation doesn't set the
2015  * ACTIVE_ONLY flag to most closely match the behaviour of the legacy helpers.
2016  * This should not be copied blindly by drivers.
2017  */
2018 void drm_atomic_helper_commit_planes(struct drm_device *dev,
2019                                      struct drm_atomic_state *old_state,
2020                                      uint32_t flags)
2021 {
2022         struct drm_crtc *crtc;
2023         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2024         struct drm_plane *plane;
2025         struct drm_plane_state *old_plane_state, *new_plane_state;
2026         int i;
2027         bool active_only = flags & DRM_PLANE_COMMIT_ACTIVE_ONLY;
2028         bool no_disable = flags & DRM_PLANE_COMMIT_NO_DISABLE_AFTER_MODESET;
2029
2030         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2031                 const struct drm_crtc_helper_funcs *funcs;
2032
2033                 funcs = crtc->helper_private;
2034
2035                 if (!funcs || !funcs->atomic_begin)
2036                         continue;
2037
2038                 if (active_only && !new_crtc_state->active)
2039                         continue;
2040
2041                 funcs->atomic_begin(crtc, old_crtc_state);
2042         }
2043
2044         for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2045                 const struct drm_plane_helper_funcs *funcs;
2046                 bool disabling;
2047
2048                 funcs = plane->helper_private;
2049
2050                 if (!funcs)
2051                         continue;
2052
2053                 disabling = drm_atomic_plane_disabling(old_plane_state,
2054                                                        new_plane_state);
2055
2056                 if (active_only) {
2057                         /*
2058                          * Skip planes related to inactive CRTCs. If the plane
2059                          * is enabled use the state of the current CRTC. If the
2060                          * plane is being disabled use the state of the old
2061                          * CRTC to avoid skipping planes being disabled on an
2062                          * active CRTC.
2063                          */
2064                         if (!disabling && !plane_crtc_active(new_plane_state))
2065                                 continue;
2066                         if (disabling && !plane_crtc_active(old_plane_state))
2067                                 continue;
2068                 }
2069
2070                 /*
2071                  * Special-case disabling the plane if drivers support it.
2072                  */
2073                 if (disabling && funcs->atomic_disable) {
2074                         struct drm_crtc_state *crtc_state;
2075
2076                         crtc_state = old_plane_state->crtc->state;
2077
2078                         if (drm_atomic_crtc_needs_modeset(crtc_state) &&
2079                             no_disable)
2080                                 continue;
2081
2082                         funcs->atomic_disable(plane, old_plane_state);
2083                 } else if (new_plane_state->crtc || disabling) {
2084                         funcs->atomic_update(plane, old_plane_state);
2085                 }
2086         }
2087
2088         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2089                 const struct drm_crtc_helper_funcs *funcs;
2090
2091                 funcs = crtc->helper_private;
2092
2093                 if (!funcs || !funcs->atomic_flush)
2094                         continue;
2095
2096                 if (active_only && !new_crtc_state->active)
2097                         continue;
2098
2099                 funcs->atomic_flush(crtc, old_crtc_state);
2100         }
2101 }
2102 EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
2103
2104 /**
2105  * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a crtc
2106  * @old_crtc_state: atomic state object with the old crtc state
2107  *
2108  * This function commits the new plane state using the plane and atomic helper
2109  * functions for planes on the specific crtc. It assumes that the atomic state
2110  * has already been pushed into the relevant object state pointers, since this
2111  * step can no longer fail.
2112  *
2113  * This function is useful when plane updates should be done crtc-by-crtc
2114  * instead of one global step like drm_atomic_helper_commit_planes() does.
2115  *
2116  * This function can only be savely used when planes are not allowed to move
2117  * between different CRTCs because this function doesn't handle inter-CRTC
2118  * depencies. Callers need to ensure that either no such depencies exist,
2119  * resolve them through ordering of commit calls or through some other means.
2120  */
2121 void
2122 drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state)
2123 {
2124         const struct drm_crtc_helper_funcs *crtc_funcs;
2125         struct drm_crtc *crtc = old_crtc_state->crtc;
2126         struct drm_atomic_state *old_state = old_crtc_state->state;
2127         struct drm_plane *plane;
2128         unsigned plane_mask;
2129
2130         plane_mask = old_crtc_state->plane_mask;
2131         plane_mask |= crtc->state->plane_mask;
2132
2133         crtc_funcs = crtc->helper_private;
2134         if (crtc_funcs && crtc_funcs->atomic_begin)
2135                 crtc_funcs->atomic_begin(crtc, old_crtc_state);
2136
2137         drm_for_each_plane_mask(plane, crtc->dev, plane_mask) {
2138                 struct drm_plane_state *old_plane_state =
2139                         drm_atomic_get_old_plane_state(old_state, plane);
2140                 const struct drm_plane_helper_funcs *plane_funcs;
2141
2142                 plane_funcs = plane->helper_private;
2143
2144                 if (!old_plane_state || !plane_funcs)
2145                         continue;
2146
2147                 WARN_ON(plane->state->crtc && plane->state->crtc != crtc);
2148
2149                 if (drm_atomic_plane_disabling(old_plane_state, plane->state) &&
2150                     plane_funcs->atomic_disable)
2151                         plane_funcs->atomic_disable(plane, old_plane_state);
2152                 else if (plane->state->crtc ||
2153                          drm_atomic_plane_disabling(old_plane_state, plane->state))
2154                         plane_funcs->atomic_update(plane, old_plane_state);
2155         }
2156
2157         if (crtc_funcs && crtc_funcs->atomic_flush)
2158                 crtc_funcs->atomic_flush(crtc, old_crtc_state);
2159 }
2160 EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc);
2161
2162 /**
2163  * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes
2164  * @old_crtc_state: atomic state object with the old CRTC state
2165  * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks
2166  *
2167  * Disables all planes associated with the given CRTC. This can be
2168  * used for instance in the CRTC helper atomic_disable callback to disable
2169  * all planes.
2170  *
2171  * If the atomic-parameter is set the function calls the CRTC's
2172  * atomic_begin hook before and atomic_flush hook after disabling the
2173  * planes.
2174  *
2175  * It is a bug to call this function without having implemented the
2176  * &drm_plane_helper_funcs.atomic_disable plane hook.
2177  */
2178 void
2179 drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state *old_crtc_state,
2180                                          bool atomic)
2181 {
2182         struct drm_crtc *crtc = old_crtc_state->crtc;
2183         const struct drm_crtc_helper_funcs *crtc_funcs =
2184                 crtc->helper_private;
2185         struct drm_plane *plane;
2186
2187         if (atomic && crtc_funcs && crtc_funcs->atomic_begin)
2188                 crtc_funcs->atomic_begin(crtc, NULL);
2189
2190         drm_atomic_crtc_state_for_each_plane(plane, old_crtc_state) {
2191                 const struct drm_plane_helper_funcs *plane_funcs =
2192                         plane->helper_private;
2193
2194                 if (!plane_funcs)
2195                         continue;
2196
2197                 WARN_ON(!plane_funcs->atomic_disable);
2198                 if (plane_funcs->atomic_disable)
2199                         plane_funcs->atomic_disable(plane, NULL);
2200         }
2201
2202         if (atomic && crtc_funcs && crtc_funcs->atomic_flush)
2203                 crtc_funcs->atomic_flush(crtc, NULL);
2204 }
2205 EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc);
2206
2207 /**
2208  * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
2209  * @dev: DRM device
2210  * @old_state: atomic state object with old state structures
2211  *
2212  * This function cleans up plane state, specifically framebuffers, from the old
2213  * configuration. Hence the old configuration must be perserved in @old_state to
2214  * be able to call this function.
2215  *
2216  * This function must also be called on the new state when the atomic update
2217  * fails at any point after calling drm_atomic_helper_prepare_planes().
2218  */
2219 void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
2220                                       struct drm_atomic_state *old_state)
2221 {
2222         struct drm_plane *plane;
2223         struct drm_plane_state *old_plane_state, *new_plane_state;
2224         int i;
2225
2226         for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2227                 const struct drm_plane_helper_funcs *funcs;
2228                 struct drm_plane_state *plane_state;
2229
2230                 /*
2231                  * This might be called before swapping when commit is aborted,
2232                  * in which case we have to cleanup the new state.
2233                  */
2234                 if (old_plane_state == plane->state)
2235                         plane_state = new_plane_state;
2236                 else
2237                         plane_state = old_plane_state;
2238
2239                 funcs = plane->helper_private;
2240
2241                 if (funcs->cleanup_fb)
2242                         funcs->cleanup_fb(plane, plane_state);
2243         }
2244 }
2245 EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
2246
2247 /**
2248  * drm_atomic_helper_swap_state - store atomic state into current sw state
2249  * @state: atomic state
2250  * @stall: stall for preceeding commits
2251  *
2252  * This function stores the atomic state into the current state pointers in all
2253  * driver objects. It should be called after all failing steps have been done
2254  * and succeeded, but before the actual hardware state is committed.
2255  *
2256  * For cleanup and error recovery the current state for all changed objects will
2257  * be swapped into @state.
2258  *
2259  * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
2260  *
2261  * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
2262  *
2263  * 2. Do any other steps that might fail.
2264  *
2265  * 3. Put the staged state into the current state pointers with this function.
2266  *
2267  * 4. Actually commit the hardware state.
2268  *
2269  * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3
2270  * contains the old state. Also do any other cleanup required with that state.
2271  *
2272  * @stall must be set when nonblocking commits for this driver directly access
2273  * the &drm_plane.state, &drm_crtc.state or &drm_connector.state pointer. With
2274  * the current atomic helpers this is almost always the case, since the helpers
2275  * don't pass the right state structures to the callbacks.
2276  *
2277  * Returns:
2278  *
2279  * Returns 0 on success. Can return -ERESTARTSYS when @stall is true and the
2280  * waiting for the previous commits has been interrupted.
2281  */
2282 int drm_atomic_helper_swap_state(struct drm_atomic_state *state,
2283                                   bool stall)
2284 {
2285         int i, ret;
2286         struct drm_connector *connector;
2287         struct drm_connector_state *old_conn_state, *new_conn_state;
2288         struct drm_crtc *crtc;
2289         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2290         struct drm_plane *plane;
2291         struct drm_plane_state *old_plane_state, *new_plane_state;
2292         struct drm_crtc_commit *commit;
2293         struct drm_private_obj *obj;
2294         struct drm_private_state *old_obj_state, *new_obj_state;
2295
2296         if (stall) {
2297                 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
2298                         spin_lock(&crtc->commit_lock);
2299                         commit = list_first_entry_or_null(&crtc->commit_list,
2300                                         struct drm_crtc_commit, commit_entry);
2301                         if (commit)
2302                                 drm_crtc_commit_get(commit);
2303                         spin_unlock(&crtc->commit_lock);
2304
2305                         if (!commit)
2306                                 continue;
2307
2308                         ret = wait_for_completion_interruptible(&commit->hw_done);
2309                         drm_crtc_commit_put(commit);
2310
2311                         if (ret)
2312                                 return ret;
2313                 }
2314         }
2315
2316         for_each_oldnew_connector_in_state(state, connector, old_conn_state, new_conn_state, i) {
2317                 WARN_ON(connector->state != old_conn_state);
2318
2319                 old_conn_state->state = state;
2320                 new_conn_state->state = NULL;
2321
2322                 state->connectors[i].state = old_conn_state;
2323                 connector->state = new_conn_state;
2324         }
2325
2326         for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
2327                 WARN_ON(crtc->state != old_crtc_state);
2328
2329                 old_crtc_state->state = state;
2330                 new_crtc_state->state = NULL;
2331
2332                 state->crtcs[i].state = old_crtc_state;
2333                 crtc->state = new_crtc_state;
2334
2335                 if (state->crtcs[i].commit) {
2336                         spin_lock(&crtc->commit_lock);
2337                         list_add(&state->crtcs[i].commit->commit_entry,
2338                                  &crtc->commit_list);
2339                         spin_unlock(&crtc->commit_lock);
2340
2341                         state->crtcs[i].commit->event = NULL;
2342                 }
2343         }
2344
2345         for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
2346                 WARN_ON(plane->state != old_plane_state);
2347
2348                 old_plane_state->state = state;
2349                 new_plane_state->state = NULL;
2350
2351                 state->planes[i].state = old_plane_state;
2352                 plane->state = new_plane_state;
2353         }
2354
2355         for_each_oldnew_private_obj_in_state(state, obj, old_obj_state, new_obj_state, i) {
2356                 WARN_ON(obj->state != old_obj_state);
2357
2358                 old_obj_state->state = state;
2359                 new_obj_state->state = NULL;
2360
2361                 state->private_objs[i].state = old_obj_state;
2362                 obj->state = new_obj_state;
2363         }
2364
2365         return 0;
2366 }
2367 EXPORT_SYMBOL(drm_atomic_helper_swap_state);
2368
2369 /**
2370  * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
2371  * @plane: plane object to update
2372  * @crtc: owning CRTC of owning plane
2373  * @fb: framebuffer to flip onto plane
2374  * @crtc_x: x offset of primary plane on crtc
2375  * @crtc_y: y offset of primary plane on crtc
2376  * @crtc_w: width of primary plane rectangle on crtc
2377  * @crtc_h: height of primary plane rectangle on crtc
2378  * @src_x: x offset of @fb for panning
2379  * @src_y: y offset of @fb for panning
2380  * @src_w: width of source rectangle in @fb
2381  * @src_h: height of source rectangle in @fb
2382  * @ctx: lock acquire context
2383  *
2384  * Provides a default plane update handler using the atomic driver interface.
2385  *
2386  * RETURNS:
2387  * Zero on success, error code on failure
2388  */
2389 int drm_atomic_helper_update_plane(struct drm_plane *plane,
2390                                    struct drm_crtc *crtc,
2391                                    struct drm_framebuffer *fb,
2392                                    int crtc_x, int crtc_y,
2393                                    unsigned int crtc_w, unsigned int crtc_h,
2394                                    uint32_t src_x, uint32_t src_y,
2395                                    uint32_t src_w, uint32_t src_h,
2396                                    struct drm_modeset_acquire_ctx *ctx)
2397 {
2398         struct drm_atomic_state *state;
2399         struct drm_plane_state *plane_state;
2400         int ret = 0;
2401
2402         state = drm_atomic_state_alloc(plane->dev);
2403         if (!state)
2404                 return -ENOMEM;
2405
2406         state->acquire_ctx = ctx;
2407         plane_state = drm_atomic_get_plane_state(state, plane);
2408         if (IS_ERR(plane_state)) {
2409                 ret = PTR_ERR(plane_state);
2410                 goto fail;
2411         }
2412
2413         ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
2414         if (ret != 0)
2415                 goto fail;
2416         drm_atomic_set_fb_for_plane(plane_state, fb);
2417         plane_state->crtc_x = crtc_x;
2418         plane_state->crtc_y = crtc_y;
2419         plane_state->crtc_w = crtc_w;
2420         plane_state->crtc_h = crtc_h;
2421         plane_state->src_x = src_x;
2422         plane_state->src_y = src_y;
2423         plane_state->src_w = src_w;
2424         plane_state->src_h = src_h;
2425
2426         if (plane == crtc->cursor)
2427                 state->legacy_cursor_update = true;
2428
2429         ret = drm_atomic_commit(state);
2430 fail:
2431         drm_atomic_state_put(state);
2432         return ret;
2433 }
2434 EXPORT_SYMBOL(drm_atomic_helper_update_plane);
2435
2436 /**
2437  * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic
2438  * @plane: plane to disable
2439  * @ctx: lock acquire context
2440  *
2441  * Provides a default plane disable handler using the atomic driver interface.
2442  *
2443  * RETURNS:
2444  * Zero on success, error code on failure
2445  */
2446 int drm_atomic_helper_disable_plane(struct drm_plane *plane,
2447                                     struct drm_modeset_acquire_ctx *ctx)
2448 {
2449         struct drm_atomic_state *state;
2450         struct drm_plane_state *plane_state;
2451         int ret = 0;
2452
2453         state = drm_atomic_state_alloc(plane->dev);
2454         if (!state)
2455                 return -ENOMEM;
2456
2457         state->acquire_ctx = ctx;
2458         plane_state = drm_atomic_get_plane_state(state, plane);
2459         if (IS_ERR(plane_state)) {
2460                 ret = PTR_ERR(plane_state);
2461                 goto fail;
2462         }
2463
2464         if (plane_state->crtc && (plane == plane->crtc->cursor))
2465                 plane_state->state->legacy_cursor_update = true;
2466
2467         ret = __drm_atomic_helper_disable_plane(plane, plane_state);
2468         if (ret != 0)
2469                 goto fail;
2470
2471         ret = drm_atomic_commit(state);
2472 fail:
2473         drm_atomic_state_put(state);
2474         return ret;
2475 }
2476 EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
2477
2478 /* just used from fb-helper and atomic-helper: */
2479 int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
2480                 struct drm_plane_state *plane_state)
2481 {
2482         int ret;
2483
2484         ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
2485         if (ret != 0)
2486                 return ret;
2487
2488         drm_atomic_set_fb_for_plane(plane_state, NULL);
2489         plane_state->crtc_x = 0;
2490         plane_state->crtc_y = 0;
2491         plane_state->crtc_w = 0;
2492         plane_state->crtc_h = 0;
2493         plane_state->src_x = 0;
2494         plane_state->src_y = 0;
2495         plane_state->src_w = 0;
2496         plane_state->src_h = 0;
2497
2498         return 0;
2499 }
2500
2501 static int update_output_state(struct drm_atomic_state *state,
2502                                struct drm_mode_set *set)
2503 {
2504         struct drm_device *dev = set->crtc->dev;
2505         struct drm_crtc *crtc;
2506         struct drm_crtc_state *new_crtc_state;
2507         struct drm_connector *connector;
2508         struct drm_connector_state *new_conn_state;
2509         int ret, i;
2510
2511         ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
2512                                state->acquire_ctx);
2513         if (ret)
2514                 return ret;
2515
2516         /* First disable all connectors on the target crtc. */
2517         ret = drm_atomic_add_affected_connectors(state, set->crtc);
2518         if (ret)
2519                 return ret;
2520
2521         for_each_new_connector_in_state(state, connector, new_conn_state, i) {
2522                 if (new_conn_state->crtc == set->crtc) {
2523                         ret = drm_atomic_set_crtc_for_connector(new_conn_state,
2524                                                                 NULL);
2525                         if (ret)
2526                                 return ret;
2527
2528                         /* Make sure legacy setCrtc always re-trains */
2529                         new_conn_state->link_status = DRM_LINK_STATUS_GOOD;
2530                 }
2531         }
2532
2533         /* Then set all connectors from set->connectors on the target crtc */
2534         for (i = 0; i < set->num_connectors; i++) {
2535                 new_conn_state = drm_atomic_get_connector_state(state,
2536                                                             set->connectors[i]);
2537                 if (IS_ERR(new_conn_state))
2538                         return PTR_ERR(new_conn_state);
2539
2540                 ret = drm_atomic_set_crtc_for_connector(new_conn_state,
2541                                                         set->crtc);
2542                 if (ret)
2543                         return ret;
2544         }
2545
2546         for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
2547                 /* Don't update ->enable for the CRTC in the set_config request,
2548                  * since a mismatch would indicate a bug in the upper layers.
2549                  * The actual modeset code later on will catch any
2550                  * inconsistencies here. */
2551                 if (crtc == set->crtc)
2552                         continue;
2553
2554                 if (!new_crtc_state->connector_mask) {
2555                         ret = drm_atomic_set_mode_prop_for_crtc(new_crtc_state,
2556                                                                 NULL);
2557                         if (ret < 0)
2558                                 return ret;
2559
2560                         new_crtc_state->active = false;
2561                 }
2562         }
2563
2564         return 0;
2565 }
2566
2567 /**
2568  * drm_atomic_helper_set_config - set a new config from userspace
2569  * @set: mode set configuration
2570  * @ctx: lock acquisition context
2571  *
2572  * Provides a default crtc set_config handler using the atomic driver interface.
2573  *
2574  * NOTE: For backwards compatibility with old userspace this automatically
2575  * resets the "link-status" property to GOOD, to force any link
2576  * re-training. The SETCRTC ioctl does not define whether an update does
2577  * need a full modeset or just a plane update, hence we're allowed to do
2578  * that. See also drm_mode_connector_set_link_status_property().
2579  *
2580  * Returns:
2581  * Returns 0 on success, negative errno numbers on failure.
2582  */
2583 int drm_atomic_helper_set_config(struct drm_mode_set *set,
2584                                  struct drm_modeset_acquire_ctx *ctx)
2585 {
2586         struct drm_atomic_state *state;
2587         struct drm_crtc *crtc = set->crtc;
2588         int ret = 0;
2589
2590         state = drm_atomic_state_alloc(crtc->dev);
2591         if (!state)
2592                 return -ENOMEM;
2593
2594         state->acquire_ctx = ctx;
2595         ret = __drm_atomic_helper_set_config(set, state);
2596         if (ret != 0)
2597                 goto fail;
2598
2599         ret = handle_conflicting_encoders(state, true);
2600         if (ret)
2601                 return ret;
2602
2603         ret = drm_atomic_commit(state);
2604
2605 fail:
2606         drm_atomic_state_put(state);
2607         return ret;
2608 }
2609 EXPORT_SYMBOL(drm_atomic_helper_set_config);
2610
2611 /* just used from fb-helper and atomic-helper: */
2612 int __drm_atomic_helper_set_config(struct drm_mode_set *set,
2613                 struct drm_atomic_state *state)
2614 {
2615         struct drm_crtc_state *crtc_state;
2616         struct drm_plane_state *primary_state;
2617         struct drm_crtc *crtc = set->crtc;
2618         int hdisplay, vdisplay;
2619         int ret;
2620
2621         crtc_state = drm_atomic_get_crtc_state(state, crtc);
2622         if (IS_ERR(crtc_state))
2623                 return PTR_ERR(crtc_state);
2624
2625         primary_state = drm_atomic_get_plane_state(state, crtc->primary);
2626         if (IS_ERR(primary_state))
2627                 return PTR_ERR(primary_state);
2628
2629         if (!set->mode) {
2630                 WARN_ON(set->fb);
2631                 WARN_ON(set->num_connectors);
2632
2633                 ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL);
2634                 if (ret != 0)
2635                         return ret;
2636
2637                 crtc_state->active = false;
2638
2639                 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
2640                 if (ret != 0)
2641                         return ret;
2642
2643                 drm_atomic_set_fb_for_plane(primary_state, NULL);
2644
2645                 goto commit;
2646         }
2647
2648         WARN_ON(!set->fb);
2649         WARN_ON(!set->num_connectors);
2650
2651         ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode);
2652         if (ret != 0)
2653                 return ret;
2654
2655         crtc_state->active = true;
2656
2657         ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
2658         if (ret != 0)
2659                 return ret;
2660
2661         drm_mode_get_hv_timing(set->mode, &hdisplay, &vdisplay);
2662
2663         drm_atomic_set_fb_for_plane(primary_state, set->fb);
2664         primary_state->crtc_x = 0;
2665         primary_state->crtc_y = 0;
2666         primary_state->crtc_w = hdisplay;
2667         primary_state->crtc_h = vdisplay;
2668         primary_state->src_x = set->x << 16;
2669         primary_state->src_y = set->y << 16;
2670         if (drm_rotation_90_or_270(primary_state->rotation)) {
2671                 primary_state->src_w = vdisplay << 16;
2672                 primary_state->src_h = hdisplay << 16;
2673         } else {
2674                 primary_state->src_w = hdisplay << 16;
2675                 primary_state->src_h = vdisplay << 16;
2676         }
2677
2678 commit:
2679         ret = update_output_state(state, set);
2680         if (ret)
2681                 return ret;
2682
2683         return 0;
2684 }
2685
2686 /**
2687  * drm_atomic_helper_disable_all - disable all currently active outputs
2688  * @dev: DRM device
2689  * @ctx: lock acquisition context
2690  *
2691  * Loops through all connectors, finding those that aren't turned off and then
2692  * turns them off by setting their DPMS mode to OFF and deactivating the CRTC
2693  * that they are connected to.
2694  *
2695  * This is used for example in suspend/resume to disable all currently active
2696  * functions when suspending. If you just want to shut down everything at e.g.
2697  * driver unload, look at drm_atomic_helper_shutdown().
2698  *
2699  * Note that if callers haven't already acquired all modeset locks this might
2700  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
2701  *
2702  * Returns:
2703  * 0 on success or a negative error code on failure.
2704  *
2705  * See also:
2706  * drm_atomic_helper_suspend(), drm_atomic_helper_resume() and
2707  * drm_atomic_helper_shutdown().
2708  */
2709 int drm_atomic_helper_disable_all(struct drm_device *dev,
2710                                   struct drm_modeset_acquire_ctx *ctx)
2711 {
2712         struct drm_atomic_state *state;
2713         struct drm_connector_state *conn_state;
2714         struct drm_connector *conn;
2715         struct drm_plane_state *plane_state;
2716         struct drm_plane *plane;
2717         struct drm_crtc_state *crtc_state;
2718         struct drm_crtc *crtc;
2719         unsigned plane_mask = 0;
2720         int ret, i;
2721
2722         state = drm_atomic_state_alloc(dev);
2723         if (!state)
2724                 return -ENOMEM;
2725
2726         state->acquire_ctx = ctx;
2727
2728         drm_for_each_crtc(crtc, dev) {
2729                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
2730                 if (IS_ERR(crtc_state)) {
2731                         ret = PTR_ERR(crtc_state);
2732                         goto free;
2733                 }
2734
2735                 crtc_state->active = false;
2736
2737                 ret = drm_atomic_set_mode_prop_for_crtc(crtc_state, NULL);
2738                 if (ret < 0)
2739                         goto free;
2740
2741                 ret = drm_atomic_add_affected_planes(state, crtc);
2742                 if (ret < 0)
2743                         goto free;
2744
2745                 ret = drm_atomic_add_affected_connectors(state, crtc);
2746                 if (ret < 0)
2747                         goto free;
2748         }
2749
2750         for_each_new_connector_in_state(state, conn, conn_state, i) {
2751                 ret = drm_atomic_set_crtc_for_connector(conn_state, NULL);
2752                 if (ret < 0)
2753                         goto free;
2754         }
2755
2756         for_each_new_plane_in_state(state, plane, plane_state, i) {
2757                 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
2758                 if (ret < 0)
2759                         goto free;
2760
2761                 drm_atomic_set_fb_for_plane(plane_state, NULL);
2762                 plane_mask |= BIT(drm_plane_index(plane));
2763                 plane->old_fb = plane->fb;
2764         }
2765
2766         ret = drm_atomic_commit(state);
2767 free:
2768         if (plane_mask)
2769                 drm_atomic_clean_old_fb(dev, plane_mask, ret);
2770         drm_atomic_state_put(state);
2771         return ret;
2772 }
2773
2774 EXPORT_SYMBOL(drm_atomic_helper_disable_all);
2775
2776 /**
2777  * drm_atomic_helper_shutdown - shutdown all CRTC
2778  * @dev: DRM device
2779  *
2780  * This shuts down all CRTC, which is useful for driver unloading. Shutdown on
2781  * suspend should instead be handled with drm_atomic_helper_suspend(), since
2782  * that also takes a snapshot of the modeset state to be restored on resume.
2783  *
2784  * This is just a convenience wrapper around drm_atomic_helper_disable_all(),
2785  * and it is the atomic version of drm_crtc_force_disable_all().
2786  */
2787 void drm_atomic_helper_shutdown(struct drm_device *dev)
2788 {
2789         struct drm_modeset_acquire_ctx ctx;
2790         int ret;
2791
2792         drm_modeset_acquire_init(&ctx, 0);
2793         while (1) {
2794                 ret = drm_modeset_lock_all_ctx(dev, &ctx);
2795                 if (!ret)
2796                         ret = drm_atomic_helper_disable_all(dev, &ctx);
2797
2798                 if (ret != -EDEADLK)
2799                         break;
2800
2801                 drm_modeset_backoff(&ctx);
2802         }
2803
2804         if (ret)
2805                 DRM_ERROR("Disabling all crtc's during unload failed with %i\n", ret);
2806
2807         drm_modeset_drop_locks(&ctx);
2808         drm_modeset_acquire_fini(&ctx);
2809 }
2810 EXPORT_SYMBOL(drm_atomic_helper_shutdown);
2811
2812 /**
2813  * drm_atomic_helper_suspend - subsystem-level suspend helper
2814  * @dev: DRM device
2815  *
2816  * Duplicates the current atomic state, disables all active outputs and then
2817  * returns a pointer to the original atomic state to the caller. Drivers can
2818  * pass this pointer to the drm_atomic_helper_resume() helper upon resume to
2819  * restore the output configuration that was active at the time the system
2820  * entered suspend.
2821  *
2822  * Note that it is potentially unsafe to use this. The atomic state object
2823  * returned by this function is assumed to be persistent. Drivers must ensure
2824  * that this holds true. Before calling this function, drivers must make sure
2825  * to suspend fbdev emulation so that nothing can be using the device.
2826  *
2827  * Returns:
2828  * A pointer to a copy of the state before suspend on success or an ERR_PTR()-
2829  * encoded error code on failure. Drivers should store the returned atomic
2830  * state object and pass it to the drm_atomic_helper_resume() helper upon
2831  * resume.
2832  *
2833  * See also:
2834  * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(),
2835  * drm_atomic_helper_resume(), drm_atomic_helper_commit_duplicated_state()
2836  */
2837 struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev)
2838 {
2839         struct drm_modeset_acquire_ctx ctx;
2840         struct drm_atomic_state *state;
2841         int err;
2842
2843         drm_modeset_acquire_init(&ctx, 0);
2844
2845 retry:
2846         err = drm_modeset_lock_all_ctx(dev, &ctx);
2847         if (err < 0) {
2848                 state = ERR_PTR(err);
2849                 goto unlock;
2850         }
2851
2852         state = drm_atomic_helper_duplicate_state(dev, &ctx);
2853         if (IS_ERR(state))
2854                 goto unlock;
2855
2856         err = drm_atomic_helper_disable_all(dev, &ctx);
2857         if (err < 0) {
2858                 drm_atomic_state_put(state);
2859                 state = ERR_PTR(err);
2860                 goto unlock;
2861         }
2862
2863 unlock:
2864         if (PTR_ERR(state) == -EDEADLK) {
2865                 drm_modeset_backoff(&ctx);
2866                 goto retry;
2867         }
2868
2869         drm_modeset_drop_locks(&ctx);
2870         drm_modeset_acquire_fini(&ctx);
2871         return state;
2872 }
2873 EXPORT_SYMBOL(drm_atomic_helper_suspend);
2874
2875 /**
2876  * drm_atomic_helper_commit_duplicated_state - commit duplicated state
2877  * @state: duplicated atomic state to commit
2878  * @ctx: pointer to acquire_ctx to use for commit.
2879  *
2880  * The state returned by drm_atomic_helper_duplicate_state() and
2881  * drm_atomic_helper_suspend() is partially invalid, and needs to
2882  * be fixed up before commit.
2883  *
2884  * Returns:
2885  * 0 on success or a negative error code on failure.
2886  *
2887  * See also:
2888  * drm_atomic_helper_suspend()
2889  */
2890 int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
2891                                               struct drm_modeset_acquire_ctx *ctx)
2892 {
2893         int i;
2894         struct drm_plane *plane;
2895         struct drm_plane_state *new_plane_state;
2896         struct drm_connector *connector;
2897         struct drm_connector_state *new_conn_state;
2898         struct drm_crtc *crtc;
2899         struct drm_crtc_state *new_crtc_state;
2900         unsigned plane_mask = 0;
2901         struct drm_device *dev = state->dev;
2902         int ret;
2903
2904         state->acquire_ctx = ctx;
2905
2906         for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2907                 plane_mask |= BIT(drm_plane_index(plane));
2908                 state->planes[i].old_state = plane->state;
2909         }
2910
2911         for_each_new_crtc_in_state(state, crtc, new_crtc_state, i)
2912                 state->crtcs[i].old_state = crtc->state;
2913
2914         for_each_new_connector_in_state(state, connector, new_conn_state, i)
2915                 state->connectors[i].old_state = connector->state;
2916
2917         ret = drm_atomic_commit(state);
2918         if (plane_mask)
2919                 drm_atomic_clean_old_fb(dev, plane_mask, ret);
2920
2921         return ret;
2922 }
2923 EXPORT_SYMBOL(drm_atomic_helper_commit_duplicated_state);
2924
2925 /**
2926  * drm_atomic_helper_resume - subsystem-level resume helper
2927  * @dev: DRM device
2928  * @state: atomic state to resume to
2929  *
2930  * Calls drm_mode_config_reset() to synchronize hardware and software states,
2931  * grabs all modeset locks and commits the atomic state object. This can be
2932  * used in conjunction with the drm_atomic_helper_suspend() helper to
2933  * implement suspend/resume for drivers that support atomic mode-setting.
2934  *
2935  * Returns:
2936  * 0 on success or a negative error code on failure.
2937  *
2938  * See also:
2939  * drm_atomic_helper_suspend()
2940  */
2941 int drm_atomic_helper_resume(struct drm_device *dev,
2942                              struct drm_atomic_state *state)
2943 {
2944         struct drm_modeset_acquire_ctx ctx;
2945         int err;
2946
2947         drm_mode_config_reset(dev);
2948
2949         drm_modeset_acquire_init(&ctx, 0);
2950         while (1) {
2951                 err = drm_modeset_lock_all_ctx(dev, &ctx);
2952                 if (err)
2953                         goto out;
2954
2955                 err = drm_atomic_helper_commit_duplicated_state(state, &ctx);
2956 out:
2957                 if (err != -EDEADLK)
2958                         break;
2959
2960                 drm_modeset_backoff(&ctx);
2961         }
2962
2963         drm_modeset_drop_locks(&ctx);
2964         drm_modeset_acquire_fini(&ctx);
2965
2966         return err;
2967 }
2968 EXPORT_SYMBOL(drm_atomic_helper_resume);
2969
2970 static int page_flip_common(struct drm_atomic_state *state,
2971                             struct drm_crtc *crtc,
2972                             struct drm_framebuffer *fb,
2973                             struct drm_pending_vblank_event *event,
2974                             uint32_t flags)
2975 {
2976         struct drm_plane *plane = crtc->primary;
2977         struct drm_plane_state *plane_state;
2978         struct drm_crtc_state *crtc_state;
2979         int ret = 0;
2980
2981         crtc_state = drm_atomic_get_crtc_state(state, crtc);
2982         if (IS_ERR(crtc_state))
2983                 return PTR_ERR(crtc_state);
2984
2985         crtc_state->event = event;
2986         crtc_state->pageflip_flags = flags;
2987
2988         plane_state = drm_atomic_get_plane_state(state, plane);
2989         if (IS_ERR(plane_state))
2990                 return PTR_ERR(plane_state);
2991
2992         ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
2993         if (ret != 0)
2994                 return ret;
2995         drm_atomic_set_fb_for_plane(plane_state, fb);
2996
2997         /* Make sure we don't accidentally do a full modeset. */
2998         state->allow_modeset = false;
2999         if (!crtc_state->active) {
3000                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled, rejecting legacy flip\n",
3001                                  crtc->base.id, crtc->name);
3002                 return -EINVAL;
3003         }
3004
3005         return ret;
3006 }
3007
3008 /**
3009  * drm_atomic_helper_page_flip - execute a legacy page flip
3010  * @crtc: DRM crtc
3011  * @fb: DRM framebuffer
3012  * @event: optional DRM event to signal upon completion
3013  * @flags: flip flags for non-vblank sync'ed updates
3014  * @ctx: lock acquisition context
3015  *
3016  * Provides a default &drm_crtc_funcs.page_flip implementation
3017  * using the atomic driver interface.
3018  *
3019  * Returns:
3020  * Returns 0 on success, negative errno numbers on failure.
3021  *
3022  * See also:
3023  * drm_atomic_helper_page_flip_target()
3024  */
3025 int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
3026                                 struct drm_framebuffer *fb,
3027                                 struct drm_pending_vblank_event *event,
3028                                 uint32_t flags,
3029                                 struct drm_modeset_acquire_ctx *ctx)
3030 {
3031         struct drm_plane *plane = crtc->primary;
3032         struct drm_atomic_state *state;
3033         int ret = 0;
3034
3035         state = drm_atomic_state_alloc(plane->dev);
3036         if (!state)
3037                 return -ENOMEM;
3038
3039         state->acquire_ctx = ctx;
3040
3041         ret = page_flip_common(state, crtc, fb, event, flags);
3042         if (ret != 0)
3043                 goto fail;
3044
3045         ret = drm_atomic_nonblocking_commit(state);
3046 fail:
3047         drm_atomic_state_put(state);
3048         return ret;
3049 }
3050 EXPORT_SYMBOL(drm_atomic_helper_page_flip);
3051
3052 /**
3053  * drm_atomic_helper_page_flip_target - do page flip on target vblank period.
3054  * @crtc: DRM crtc
3055  * @fb: DRM framebuffer
3056  * @event: optional DRM event to signal upon completion
3057  * @flags: flip flags for non-vblank sync'ed updates
3058  * @target: specifying the target vblank period when the flip to take effect
3059  * @ctx: lock acquisition context
3060  *
3061  * Provides a default &drm_crtc_funcs.page_flip_target implementation.
3062  * Similar to drm_atomic_helper_page_flip() with extra parameter to specify
3063  * target vblank period to flip.
3064  *
3065  * Returns:
3066  * Returns 0 on success, negative errno numbers on failure.
3067  */
3068 int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
3069                                        struct drm_framebuffer *fb,
3070                                        struct drm_pending_vblank_event *event,
3071                                        uint32_t flags,
3072                                        uint32_t target,
3073                                        struct drm_modeset_acquire_ctx *ctx)
3074 {
3075         struct drm_plane *plane = crtc->primary;
3076         struct drm_atomic_state *state;
3077         struct drm_crtc_state *crtc_state;
3078         int ret = 0;
3079
3080         state = drm_atomic_state_alloc(plane->dev);
3081         if (!state)
3082                 return -ENOMEM;
3083
3084         state->acquire_ctx = ctx;
3085
3086         ret = page_flip_common(state, crtc, fb, event, flags);
3087         if (ret != 0)
3088                 goto fail;
3089
3090         crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
3091         if (WARN_ON(!crtc_state)) {
3092                 ret = -EINVAL;
3093                 goto fail;
3094         }
3095         crtc_state->target_vblank = target;
3096
3097         ret = drm_atomic_nonblocking_commit(state);
3098 fail:
3099         drm_atomic_state_put(state);
3100         return ret;
3101 }
3102 EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
3103
3104 /**
3105  * drm_atomic_helper_best_encoder - Helper for
3106  *      &drm_connector_helper_funcs.best_encoder callback
3107  * @connector: Connector control structure
3108  *
3109  * This is a &drm_connector_helper_funcs.best_encoder callback helper for
3110  * connectors that support exactly 1 encoder, statically determined at driver
3111  * init time.
3112  */
3113 struct drm_encoder *
3114 drm_atomic_helper_best_encoder(struct drm_connector *connector)
3115 {
3116         WARN_ON(connector->encoder_ids[1]);
3117         return drm_encoder_find(connector->dev, connector->encoder_ids[0]);
3118 }
3119 EXPORT_SYMBOL(drm_atomic_helper_best_encoder);
3120
3121 /**
3122  * DOC: atomic state reset and initialization
3123  *
3124  * Both the drm core and the atomic helpers assume that there is always the full
3125  * and correct atomic software state for all connectors, CRTCs and planes
3126  * available. Which is a bit a problem on driver load and also after system
3127  * suspend. One way to solve this is to have a hardware state read-out
3128  * infrastructure which reconstructs the full software state (e.g. the i915
3129  * driver).
3130  *
3131  * The simpler solution is to just reset the software state to everything off,
3132  * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
3133  * the atomic helpers provide default reset implementations for all hooks.
3134  *
3135  * On the upside the precise state tracking of atomic simplifies system suspend
3136  * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
3137  * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
3138  * For other drivers the building blocks are split out, see the documentation
3139  * for these functions.
3140  */
3141
3142 /**
3143  * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs
3144  * @crtc: drm CRTC
3145  *
3146  * Resets the atomic state for @crtc by freeing the state pointer (which might
3147  * be NULL, e.g. at driver load time) and allocating a new empty state object.
3148  */
3149 void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
3150 {
3151         if (crtc->state)
3152                 __drm_atomic_helper_crtc_destroy_state(crtc->state);
3153
3154         kfree(crtc->state);
3155         crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL);
3156
3157         if (crtc->state)
3158                 crtc->state->crtc = crtc;
3159 }
3160 EXPORT_SYMBOL(drm_atomic_helper_crtc_reset);
3161
3162 /**
3163  * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
3164  * @crtc: CRTC object
3165  * @state: atomic CRTC state
3166  *
3167  * Copies atomic state from a CRTC's current state and resets inferred values.
3168  * This is useful for drivers that subclass the CRTC state.
3169  */
3170 void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
3171                                               struct drm_crtc_state *state)
3172 {
3173         memcpy(state, crtc->state, sizeof(*state));
3174
3175         if (state->mode_blob)
3176                 drm_property_blob_get(state->mode_blob);
3177         if (state->degamma_lut)
3178                 drm_property_blob_get(state->degamma_lut);
3179         if (state->ctm)
3180                 drm_property_blob_get(state->ctm);
3181         if (state->gamma_lut)
3182                 drm_property_blob_get(state->gamma_lut);
3183         state->mode_changed = false;
3184         state->active_changed = false;
3185         state->planes_changed = false;
3186         state->connectors_changed = false;
3187         state->color_mgmt_changed = false;
3188         state->zpos_changed = false;
3189         state->event = NULL;
3190         state->pageflip_flags = 0;
3191 }
3192 EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
3193
3194 /**
3195  * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
3196  * @crtc: drm CRTC
3197  *
3198  * Default CRTC state duplicate hook for drivers which don't have their own
3199  * subclassed CRTC state structure.
3200  */
3201 struct drm_crtc_state *
3202 drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
3203 {
3204         struct drm_crtc_state *state;
3205
3206         if (WARN_ON(!crtc->state))
3207                 return NULL;
3208
3209         state = kmalloc(sizeof(*state), GFP_KERNEL);
3210         if (state)
3211                 __drm_atomic_helper_crtc_duplicate_state(crtc, state);
3212
3213         return state;
3214 }
3215 EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
3216
3217 /**
3218  * __drm_atomic_helper_crtc_destroy_state - release CRTC state
3219  * @state: CRTC state object to release
3220  *
3221  * Releases all resources stored in the CRTC state without actually freeing
3222  * the memory of the CRTC state. This is useful for drivers that subclass the
3223  * CRTC state.
3224  */
3225 void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state)
3226 {
3227         drm_property_blob_put(state->mode_blob);
3228         drm_property_blob_put(state->degamma_lut);
3229         drm_property_blob_put(state->ctm);
3230         drm_property_blob_put(state->gamma_lut);
3231 }
3232 EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
3233
3234 /**
3235  * drm_atomic_helper_crtc_destroy_state - default state destroy hook
3236  * @crtc: drm CRTC
3237  * @state: CRTC state object to release
3238  *
3239  * Default CRTC state destroy hook for drivers which don't have their own
3240  * subclassed CRTC state structure.
3241  */
3242 void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
3243                                           struct drm_crtc_state *state)
3244 {
3245         __drm_atomic_helper_crtc_destroy_state(state);
3246         kfree(state);
3247 }
3248 EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
3249
3250 /**
3251  * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes
3252  * @plane: drm plane
3253  *
3254  * Resets the atomic state for @plane by freeing the state pointer (which might
3255  * be NULL, e.g. at driver load time) and allocating a new empty state object.
3256  */
3257 void drm_atomic_helper_plane_reset(struct drm_plane *plane)
3258 {
3259         if (plane->state)
3260                 __drm_atomic_helper_plane_destroy_state(plane->state);
3261
3262         kfree(plane->state);
3263         plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
3264