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