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