root/drivers/gpu/drm/drm_atomic_helper.c

DEFINITIONS

1. drm_atomic_helper_plane_changed
2. pick_single_encoder_for_connector
3. handle_conflicting_encoders
4. set_best_encoder
5. steal_encoder
6. update_connector_routing
7. mode_fixup
8. mode_valid_path
9. mode_valid
10. drm_atomic_helper_check_modeset
11. drm_atomic_helper_check_plane_state
12. drm_atomic_helper_check_planes
13. drm_atomic_helper_check
14. crtc_needs_disable
15. disable_outputs
16. drm_atomic_helper_update_legacy_modeset_state
17. crtc_set_mode
18. drm_atomic_helper_commit_modeset_disables
19. drm_atomic_helper_commit_writebacks
20. drm_atomic_helper_commit_modeset_enables
21. drm_atomic_helper_wait_for_fences
22. drm_atomic_helper_wait_for_vblanks
23. drm_atomic_helper_wait_for_flip_done
24. drm_atomic_helper_commit_tail
25. drm_atomic_helper_commit_tail_rpm
26. commit_tail
27. commit_work
28. drm_atomic_helper_async_check
29. drm_atomic_helper_async_commit
30. drm_atomic_helper_commit
31. stall_checks
32. release_crtc_commit
33. init_commit
34. crtc_or_fake_commit
35. drm_atomic_helper_setup_commit
36. drm_atomic_helper_wait_for_dependencies
37. drm_atomic_helper_fake_vblank
38. drm_atomic_helper_commit_hw_done
39. drm_atomic_helper_commit_cleanup_done
40. drm_atomic_helper_prepare_planes
41. plane_crtc_active
42. drm_atomic_helper_commit_planes
43. drm_atomic_helper_commit_planes_on_crtc
44. drm_atomic_helper_disable_planes_on_crtc
45. drm_atomic_helper_cleanup_planes
46. drm_atomic_helper_swap_state
47. drm_atomic_helper_update_plane
48. drm_atomic_helper_disable_plane
49. drm_atomic_helper_set_config
50. drm_atomic_helper_disable_all
51. drm_atomic_helper_shutdown
52. drm_atomic_helper_duplicate_state
53. drm_atomic_helper_suspend
54. drm_atomic_helper_commit_duplicated_state
55. drm_atomic_helper_resume
56. page_flip_common
57. drm_atomic_helper_page_flip
58. drm_atomic_helper_page_flip_target
59. drm_atomic_helper_legacy_gamma_set

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