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