sys/dev/drm/drm_atomic_helper.c

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