drivers/gpu/drm/drm_atomic_helper.c

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