drivers/gpu/drm/drm_atomic_helper.c

   1 /*
   2  * Copyright (C) 2014 Red Hat
   3  * Copyright (C) 2014 Intel Corp.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21  * OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  * Rob Clark <robdclark@gmail.com>
  25  * Daniel Vetter <daniel.vetter@ffwll.ch>
  26  */
  27
  28 #include <drm/drmP.h>
  29 #include <drm/drm_atomic.h>
  30 #include <drm/drm_plane_helper.h>
  31 #include <drm/drm_crtc_helper.h>
  32 #include <drm/drm_atomic_helper.h>
  33 #include <linux/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         spin_lock(&crtc->commit_lock);
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                                 spin_unlock(&crtc->commit_lock);
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         spin_unlock(&crtc->commit_lock);
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
1783         for_each_oldnew_connector_in_state(state, conn, old_conn_state, new_conn_state, i) {
1784                 /* Userspace is not allowed to get ahead of the previous
1785                  * commit with nonblocking ones. */
1786                 if (nonblock && old_conn_state->commit &&
1787                     !try_wait_for_completion(&old_conn_state->commit->flip_done))
1788                         return -EBUSY;
1789
1790                 /* commit tracked through new_crtc_state->commit, no need to do it explicitly */
1791                 if (new_conn_state->crtc)
1792                         continue;
1793
1794                 commit = crtc_or_fake_commit(state, old_conn_state->crtc);
1795                 if (!commit)
1796                         return -ENOMEM;
1797
1798                 new_conn_state->commit = drm_crtc_commit_get(commit);
1799         }
1800
1801         for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
1802                 /* Userspace is not allowed to get ahead of the previous
1803                  * commit with nonblocking ones. */
1804                 if (nonblock && old_plane_state->commit &&
1805                     !try_wait_for_completion(&old_plane_state->commit->flip_done))
1806                         return -EBUSY;
1807
1808                 /*
1809                  * Unlike connectors, always track planes explicitly for
1810                  * async pageflip support.
1811                  */
1812                 commit = crtc_or_fake_commit(state, new_plane_state->crtc ?: old_plane_state->crtc);
1813                 if (!commit)
1814                         return -ENOMEM;
1815
1816                 new_plane_state->commit = drm_crtc_commit_get(commit);
1817         }
1818
1819         return 0;
1820 }
1821 EXPORT_SYMBOL(drm_atomic_helper_setup_commit);
1822
1823 /**
1824  * drm_atomic_helper_wait_for_dependencies - wait for required preceeding commits
1825  * @old_state: atomic state object with old state structures
1826  *
1827  * This function waits for all preceeding commits that touch the same CRTC as
1828  * @old_state to both be committed to the hardware (as signalled by
1829  * drm_atomic_helper_commit_hw_done) and executed by the hardware (as signalled
1830  * by calling drm_crtc_send_vblank_event() on the &drm_crtc_state.event).
1831  *
1832  * This is part of the atomic helper support for nonblocking commits, see
1833  * drm_atomic_helper_setup_commit() for an overview.
1834  */
1835 void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *old_state)
1836 {
1837         struct drm_crtc *crtc;
1838         struct drm_crtc_state *old_crtc_state;
1839         struct drm_plane *plane;
1840         struct drm_plane_state *old_plane_state;
1841         struct drm_connector *conn;
1842         struct drm_connector_state *old_conn_state;
1843         struct drm_crtc_commit *commit;
1844         int i;
1845         long ret;
1846
1847         for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1848                 commit = old_crtc_state->commit;
1849
1850                 if (!commit)
1851                         continue;
1852
1853                 ret = wait_for_completion_timeout(&commit->hw_done,
1854                                                   10*HZ);
1855                 if (ret == 0)
1856                         DRM_ERROR("[CRTC:%d:%s] hw_done timed out\n",
1857                                   crtc->base.id, crtc->name);
1858
1859                 /* Currently no support for overwriting flips, hence
1860                  * stall for previous one to execute completely. */
1861                 ret = wait_for_completion_timeout(&commit->flip_done,
1862                                                   10*HZ);
1863                 if (ret == 0)
1864                         DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n",
1865                                   crtc->base.id, crtc->name);
1866         }
1867
1868         for_each_old_connector_in_state(old_state, conn, old_conn_state, i) {
1869                 commit = old_conn_state->commit;
1870
1871                 if (!commit)
1872                         continue;
1873
1874                 ret = wait_for_completion_timeout(&commit->hw_done,
1875                                                   10*HZ);
1876                 if (ret == 0)
1877                         DRM_ERROR("[CONNECTOR:%d:%s] hw_done timed out\n",
1878                                   conn->base.id, conn->name);
1879
1880                 /* Currently no support for overwriting flips, hence
1881                  * stall for previous one to execute completely. */
1882                 ret = wait_for_completion_timeout(&commit->flip_done,
1883                                                   10*HZ);
1884                 if (ret == 0)
1885                         DRM_ERROR("[CONNECTOR:%d:%s] flip_done timed out\n",
1886                                   conn->base.id, conn->name);
1887         }
1888
1889         for_each_old_plane_in_state(old_state, plane, old_plane_state, i) {
1890                 commit = old_plane_state->commit;
1891
1892                 if (!commit)
1893                         continue;
1894
1895                 ret = wait_for_completion_timeout(&commit->hw_done,
1896                                                   10*HZ);
1897                 if (ret == 0)
1898                         DRM_ERROR("[PLANE:%d:%s] hw_done timed out\n",
1899                                   plane->base.id, plane->name);
1900
1901                 /* Currently no support for overwriting flips, hence
1902                  * stall for previous one to execute completely. */
1903                 ret = wait_for_completion_timeout(&commit->flip_done,
1904                                                   10*HZ);
1905                 if (ret == 0)
1906                         DRM_ERROR("[PLANE:%d:%s] flip_done timed out\n",
1907                                   plane->base.id, plane->name);
1908         }
1909 }
1910 EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies);
1911
1912 /**
1913  * drm_atomic_helper_commit_hw_done - setup possible nonblocking commit
1914  * @old_state: atomic state object with old state structures
1915  *
1916  * This function is used to signal completion of the hardware commit step. After
1917  * this step the driver is not allowed to read or change any permanent software
1918  * or hardware modeset state. The only exception is state protected by other
1919  * means than &drm_modeset_lock locks.
1920  *
1921  * Drivers should try to postpone any expensive or delayed cleanup work after
1922  * this function is called.
1923  *
1924  * This is part of the atomic helper support for nonblocking commits, see
1925  * drm_atomic_helper_setup_commit() for an overview.
1926  */
1927 void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *old_state)
1928 {
1929         struct drm_crtc *crtc;
1930         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1931         struct drm_crtc_commit *commit;
1932         int i;
1933
1934         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1935                 commit = new_crtc_state->commit;
1936                 if (!commit)
1937                         continue;
1938
1939                 /*
1940                  * copy new_crtc_state->commit to old_crtc_state->commit,
1941                  * it's unsafe to touch new_crtc_state after hw_done,
1942                  * but we still need to do so in cleanup_done().
1943                  */
1944                 if (old_crtc_state->commit)
1945                         drm_crtc_commit_put(old_crtc_state->commit);
1946
1947                 old_crtc_state->commit = drm_crtc_commit_get(commit);
1948
1949                 /* backend must have consumed any event by now */
1950                 WARN_ON(new_crtc_state->event);
1951                 complete_all(&commit->hw_done);
1952         }
1953
1954         if (old_state->fake_commit) {
1955                 complete_all(&old_state->fake_commit->hw_done);
1956                 complete_all(&old_state->fake_commit->flip_done);
1957         }
1958 }
1959 EXPORT_SYMBOL(drm_atomic_helper_commit_hw_done);
1960
1961 /**
1962  * drm_atomic_helper_commit_cleanup_done - signal completion of commit
1963  * @old_state: atomic state object with old state structures
1964  *
1965  * This signals completion of the atomic update @old_state, including any
1966  * cleanup work. If used, it must be called right before calling
1967  * drm_atomic_state_put().
1968  *
1969  * This is part of the atomic helper support for nonblocking commits, see
1970  * drm_atomic_helper_setup_commit() for an overview.
1971  */
1972 void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *old_state)
1973 {
1974         struct drm_crtc *crtc;
1975         struct drm_crtc_state *old_crtc_state;
1976         struct drm_crtc_commit *commit;
1977         int i;
1978
1979         for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1980                 commit = old_crtc_state->commit;
1981                 if (WARN_ON(!commit))
1982                         continue;
1983
1984                 complete_all(&commit->cleanup_done);
1985                 WARN_ON(!try_wait_for_completion(&commit->hw_done));
1986
1987                 spin_lock(&crtc->commit_lock);
1988                 list_del(&commit->commit_entry);
1989                 spin_unlock(&crtc->commit_lock);
1990         }
1991
1992         if (old_state->fake_commit)
1993                 complete_all(&old_state->fake_commit->cleanup_done);
1994 }
1995 EXPORT_SYMBOL(drm_atomic_helper_commit_cleanup_done);
1996
1997 /**
1998  * drm_atomic_helper_prepare_planes - prepare plane resources before commit
1999  * @dev: DRM device
2000  * @state: atomic state object with new state structures
2001  *
2002  * This function prepares plane state, specifically framebuffers, for the new
2003  * configuration, by calling &drm_plane_helper_funcs.prepare_fb. If any failure
2004  * is encountered this function will call &drm_plane_helper_funcs.cleanup_fb on
2005  * any already successfully prepared framebuffer.
2006  *
2007  * Returns:
2008  * 0 on success, negative error code on failure.
2009  */
2010 int drm_atomic_helper_prepare_planes(struct drm_device *dev,
2011                                      struct drm_atomic_state *state)
2012 {
2013         struct drm_plane *plane;
2014         struct drm_plane_state *new_plane_state;
2015         int ret, i, j;
2016
2017         for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2018                 const struct drm_plane_helper_funcs *funcs;
2019
2020                 funcs = plane->helper_private;
2021
2022                 if (funcs->prepare_fb) {
2023                         ret = funcs->prepare_fb(plane, new_plane_state);
2024                         if (ret)
2025                                 goto fail;
2026                 }
2027         }
2028
2029         return 0;
2030
2031 fail:
2032         for_each_new_plane_in_state(state, plane, new_plane_state, j) {
2033                 const struct drm_plane_helper_funcs *funcs;
2034
2035                 if (j >= i)
2036                         continue;
2037
2038                 funcs = plane->helper_private;
2039
2040                 if (funcs->cleanup_fb)
2041                         funcs->cleanup_fb(plane, new_plane_state);
2042         }
2043
2044         return ret;
2045 }
2046 EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
2047
2048 static bool plane_crtc_active(const struct drm_plane_state *state)
2049 {
2050         return state->crtc && state->crtc->state->active;
2051 }
2052
2053 /**
2054  * drm_atomic_helper_commit_planes - commit plane state
2055  * @dev: DRM device
2056  * @old_state: atomic state object with old state structures
2057  * @flags: flags for committing plane state
2058  *
2059  * This function commits the new plane state using the plane and atomic helper
2060  * functions for planes and crtcs. It assumes that the atomic state has already
2061  * been pushed into the relevant object state pointers, since this step can no
2062  * longer fail.
2063  *
2064  * It still requires the global state object @old_state to know which planes and
2065  * crtcs need to be updated though.
2066  *
2067  * Note that this function does all plane updates across all CRTCs in one step.
2068  * If the hardware can't support this approach look at
2069  * drm_atomic_helper_commit_planes_on_crtc() instead.
2070  *
2071  * Plane parameters can be updated by applications while the associated CRTC is
2072  * disabled. The DRM/KMS core will store the parameters in the plane state,
2073  * which will be available to the driver when the CRTC is turned on. As a result
2074  * most drivers don't need to be immediately notified of plane updates for a
2075  * disabled CRTC.
2076  *
2077  * Unless otherwise needed, drivers are advised to set the ACTIVE_ONLY flag in
2078  * @flags in order not to receive plane update notifications related to a
2079  * disabled CRTC. This avoids the need to manually ignore plane updates in
2080  * driver code when the driver and/or hardware can't or just don't need to deal
2081  * with updates on disabled CRTCs, for example when supporting runtime PM.
2082  *
2083  * Drivers may set the NO_DISABLE_AFTER_MODESET flag in @flags if the relevant
2084  * display controllers require to disable a CRTC's planes when the CRTC is
2085  * disabled. This function would skip the &drm_plane_helper_funcs.atomic_disable
2086  * call for a plane if the CRTC of the old plane state needs a modesetting
2087  * operation. Of course, the drivers need to disable the planes in their CRTC
2088  * disable callbacks since no one else would do that.
2089  *
2090  * The drm_atomic_helper_commit() default implementation doesn't set the
2091  * ACTIVE_ONLY flag to most closely match the behaviour of the legacy helpers.
2092  * This should not be copied blindly by drivers.
2093  */
2094 void drm_atomic_helper_commit_planes(struct drm_device *dev,
2095                                      struct drm_atomic_state *old_state,
2096                                      uint32_t flags)
2097 {
2098         struct drm_crtc *crtc;
2099         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2100         struct drm_plane *plane;
2101         struct drm_plane_state *old_plane_state, *new_plane_state;
2102         int i;
2103         bool active_only = flags & DRM_PLANE_COMMIT_ACTIVE_ONLY;
2104         bool no_disable = flags & DRM_PLANE_COMMIT_NO_DISABLE_AFTER_MODESET;
2105
2106         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2107                 const struct drm_crtc_helper_funcs *funcs;
2108
2109                 funcs = crtc->helper_private;
2110
2111                 if (!funcs || !funcs->atomic_begin)
2112                         continue;
2113
2114                 if (active_only && !new_crtc_state->active)
2115                         continue;
2116
2117                 funcs->atomic_begin(crtc, old_crtc_state);
2118         }
2119
2120         for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2121                 const struct drm_plane_helper_funcs *funcs;
2122                 bool disabling;
2123
2124                 funcs = plane->helper_private;
2125
2126                 if (!funcs)
2127                         continue;
2128
2129                 disabling = drm_atomic_plane_disabling(old_plane_state,
2130                                                        new_plane_state);
2131
2132                 if (active_only) {
2133                         /*
2134                          * Skip planes related to inactive CRTCs. If the plane
2135                          * is enabled use the state of the current CRTC. If the
2136                          * plane is being disabled use the state of the old
2137                          * CRTC to avoid skipping planes being disabled on an
2138                          * active CRTC.
2139                          */
2140                         if (!disabling && !plane_crtc_active(new_plane_state))
2141                                 continue;
2142                         if (disabling && !plane_crtc_active(old_plane_state))
2143                                 continue;
2144                 }
2145
2146                 /*
2147                  * Special-case disabling the plane if drivers support it.
2148                  */
2149                 if (disabling && funcs->atomic_disable) {
2150                         struct drm_crtc_state *crtc_state;
2151
2152                         crtc_state = old_plane_state->crtc->state;
2153
2154                         if (drm_atomic_crtc_needs_modeset(crtc_state) &&
2155                             no_disable)
2156                                 continue;
2157
2158                         funcs->atomic_disable(plane, old_plane_state);
2159                 } else if (new_plane_state->crtc || disabling) {
2160                         funcs->atomic_update(plane, old_plane_state);
2161                 }
2162         }
2163
2164         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2165                 const struct drm_crtc_helper_funcs *funcs;
2166
2167                 funcs = crtc->helper_private;
2168
2169                 if (!funcs || !funcs->atomic_flush)
2170                         continue;
2171
2172                 if (active_only && !new_crtc_state->active)
2173                         continue;
2174
2175                 funcs->atomic_flush(crtc, old_crtc_state);
2176         }
2177 }
2178 EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
2179
2180 /**
2181  * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a crtc
2182  * @old_crtc_state: atomic state object with the old crtc state
2183  *
2184  * This function commits the new plane state using the plane and atomic helper
2185  * functions for planes on the specific crtc. It assumes that the atomic state
2186  * has already been pushed into the relevant object state pointers, since this
2187  * step can no longer fail.
2188  *
2189  * This function is useful when plane updates should be done crtc-by-crtc
2190  * instead of one global step like drm_atomic_helper_commit_planes() does.
2191  *
2192  * This function can only be savely used when planes are not allowed to move
2193  * between different CRTCs because this function doesn't handle inter-CRTC
2194  * depencies. Callers need to ensure that either no such depencies exist,
2195  * resolve them through ordering of commit calls or through some other means.
2196  */
2197 void
2198 drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state)
2199 {
2200         const struct drm_crtc_helper_funcs *crtc_funcs;
2201         struct drm_crtc *crtc = old_crtc_state->crtc;
2202         struct drm_atomic_state *old_state = old_crtc_state->state;
2203         struct drm_plane *plane;
2204         unsigned plane_mask;
2205
2206         plane_mask = old_crtc_state->plane_mask;
2207         plane_mask |= crtc->state->plane_mask;
2208
2209         crtc_funcs = crtc->helper_private;
2210         if (crtc_funcs && crtc_funcs->atomic_begin)
2211                 crtc_funcs->atomic_begin(crtc, old_crtc_state);
2212
2213         drm_for_each_plane_mask(plane, crtc->dev, plane_mask) {
2214                 struct drm_plane_state *old_plane_state =
2215                         drm_atomic_get_old_plane_state(old_state, plane);
2216                 const struct drm_plane_helper_funcs *plane_funcs;
2217
2218                 plane_funcs = plane->helper_private;
2219
2220                 if (!old_plane_state || !plane_funcs)
2221                         continue;
2222
2223                 WARN_ON(plane->state->crtc && plane->state->crtc != crtc);
2224
2225                 if (drm_atomic_plane_disabling(old_plane_state, plane->state) &&
2226                     plane_funcs->atomic_disable)
2227                         plane_funcs->atomic_disable(plane, old_plane_state);
2228                 else if (plane->state->crtc ||
2229                          drm_atomic_plane_disabling(old_plane_state, plane->state))
2230                         plane_funcs->atomic_update(plane, old_plane_state);
2231         }
2232
2233         if (crtc_funcs && crtc_funcs->atomic_flush)
2234                 crtc_funcs->atomic_flush(crtc, old_crtc_state);
2235 }
2236 EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc);
2237
2238 /**
2239  * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes
2240  * @old_crtc_state: atomic state object with the old CRTC state
2241  * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks
2242  *
2243  * Disables all planes associated with the given CRTC. This can be
2244  * used for instance in the CRTC helper atomic_disable callback to disable
2245  * all planes.
2246  *
2247  * If the atomic-parameter is set the function calls the CRTC's
2248  * atomic_begin hook before and atomic_flush hook after disabling the
2249  * planes.
2250  *
2251  * It is a bug to call this function without having implemented the
2252  * &drm_plane_helper_funcs.atomic_disable plane hook.
2253  */
2254 void
2255 drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state *old_crtc_state,
2256                                          bool atomic)
2257 {
2258         struct drm_crtc *crtc = old_crtc_state->crtc;
2259         const struct drm_crtc_helper_funcs *crtc_funcs =
2260                 crtc->helper_private;
2261         struct drm_plane *plane;
2262
2263         if (atomic && crtc_funcs && crtc_funcs->atomic_begin)
2264                 crtc_funcs->atomic_begin(crtc, NULL);
2265
2266         drm_atomic_crtc_state_for_each_plane(plane, old_crtc_state) {
2267                 const struct drm_plane_helper_funcs *plane_funcs =
2268                         plane->helper_private;
2269
2270                 if (!plane_funcs)
2271                         continue;
2272
2273                 WARN_ON(!plane_funcs->atomic_disable);
2274                 if (plane_funcs->atomic_disable)
2275                         plane_funcs->atomic_disable(plane, NULL);
2276         }
2277
2278         if (atomic && crtc_funcs && crtc_funcs->atomic_flush)
2279                 crtc_funcs->atomic_flush(crtc, NULL);
2280 }
2281 EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc);
2282
2283 /**
2284  * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
2285  * @dev: DRM device
2286  * @old_state: atomic state object with old state structures
2287  *
2288  * This function cleans up plane state, specifically framebuffers, from the old
2289  * configuration. Hence the old configuration must be perserved in @old_state to
2290  * be able to call this function.
2291  *
2292  * This function must also be called on the new state when the atomic update
2293  * fails at any point after calling drm_atomic_helper_prepare_planes().
2294  */
2295 void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
2296                                       struct drm_atomic_state *old_state)
2297 {
2298         struct drm_plane *plane;
2299         struct drm_plane_state *old_plane_state, *new_plane_state;
2300         int i;
2301
2302         for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2303                 const struct drm_plane_helper_funcs *funcs;
2304                 struct drm_plane_state *plane_state;
2305
2306                 /*
2307                  * This might be called before swapping when commit is aborted,
2308                  * in which case we have to cleanup the new state.
2309                  */
2310                 if (old_plane_state == plane->state)
2311                         plane_state = new_plane_state;
2312                 else
2313                         plane_state = old_plane_state;
2314
2315                 funcs = plane->helper_private;
2316
2317                 if (funcs->cleanup_fb)
2318                         funcs->cleanup_fb(plane, plane_state);
2319         }
2320 }
2321 EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
2322
2323 /**
2324  * drm_atomic_helper_swap_state - store atomic state into current sw state
2325  * @state: atomic state
2326  * @stall: stall for preceeding commits
2327  *
2328  * This function stores the atomic state into the current state pointers in all
2329  * driver objects. It should be called after all failing steps have been done
2330  * and succeeded, but before the actual hardware state is committed.
2331  *
2332  * For cleanup and error recovery the current state for all changed objects will
2333  * be swapped into @state.
2334  *
2335  * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
2336  *
2337  * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
2338  *
2339  * 2. Do any other steps that might fail.
2340  *
2341  * 3. Put the staged state into the current state pointers with this function.
2342  *
2343  * 4. Actually commit the hardware state.
2344  *
2345  * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3
2346  * contains the old state. Also do any other cleanup required with that state.
2347  *
2348  * @stall must be set when nonblocking commits for this driver directly access
2349  * the &drm_plane.state, &drm_crtc.state or &drm_connector.state pointer. With
2350  * the current atomic helpers this is almost always the case, since the helpers
2351  * don't pass the right state structures to the callbacks.
2352  *
2353  * Returns:
2354  *
2355  * Returns 0 on success. Can return -ERESTARTSYS when @stall is true and the
2356  * waiting for the previous commits has been interrupted.
2357  */
2358 int drm_atomic_helper_swap_state(struct drm_atomic_state *state,
2359                                   bool stall)
2360 {
2361         int i, ret;
2362         struct drm_connector *connector;
2363         struct drm_connector_state *old_conn_state, *new_conn_state;
2364         struct drm_crtc *crtc;
2365         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2366         struct drm_plane *plane;
2367         struct drm_plane_state *old_plane_state, *new_plane_state;
2368         struct drm_crtc_commit *commit;
2369         struct drm_private_obj *obj;
2370         struct drm_private_state *old_obj_state, *new_obj_state;
2371
2372         if (stall) {
2373                 /*
2374                  * We have to stall for hw_done here before
2375                  * drm_atomic_helper_wait_for_dependencies() because flip
2376                  * depth > 1 is not yet supported by all drivers. As long as
2377                  * obj->state is directly dereferenced anywhere in the drivers
2378                  * atomic_commit_tail function, then it's unsafe to swap state
2379                  * before drm_atomic_helper_commit_hw_done() is called.
2380                  */
2381
2382                 for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) {
2383                         commit = old_crtc_state->commit;
2384
2385                         if (!commit)
2386                                 continue;
2387
2388                         ret = wait_for_completion_interruptible(&commit->hw_done);
2389                         if (ret)
2390                                 return ret;
2391                 }
2392
2393                 for_each_old_connector_in_state(state, connector, old_conn_state, i) {
2394                         commit = old_conn_state->commit;
2395
2396                         if (!commit)
2397                                 continue;
2398
2399                         ret = wait_for_completion_interruptible(&commit->hw_done);
2400                         if (ret)
2401                                 return ret;
2402                 }
2403
2404                 for_each_old_plane_in_state(state, plane, old_plane_state, i) {
2405                         commit = old_plane_state->commit;
2406
2407                         if (!commit)
2408                                 continue;
2409
2410                         ret = wait_for_completion_interruptible(&commit->hw_done);
2411                         if (ret)
2412                                 return ret;
2413                 }
2414         }
2415
2416         for_each_oldnew_connector_in_state(state, connector, old_conn_state, new_conn_state, i) {
2417                 WARN_ON(connector->state != old_conn_state);
2418
2419                 old_conn_state->state = state;
2420                 new_conn_state->state = NULL;
2421
2422                 state->connectors[i].state = old_conn_state;
2423                 connector->state = new_conn_state;
2424         }
2425
2426         for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
2427                 WARN_ON(crtc->state != old_crtc_state);
2428
2429                 old_crtc_state->state = state;
2430                 new_crtc_state->state = NULL;
2431
2432                 state->crtcs[i].state = old_crtc_state;
2433                 crtc->state = new_crtc_state;
2434
2435                 if (new_crtc_state->commit) {
2436                         spin_lock(&crtc->commit_lock);
2437                         list_add(&new_crtc_state->commit->commit_entry,
2438                                  &crtc->commit_list);
2439                         spin_unlock(&crtc->commit_lock);
2440
2441                         new_crtc_state->commit->event = NULL;
2442                 }
2443         }
2444
2445         for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
2446                 WARN_ON(plane->state != old_plane_state);
2447
2448                 old_plane_state->state = state;
2449                 new_plane_state->state = NULL;
2450
2451                 state->planes[i].state = old_plane_state;
2452                 plane->state = new_plane_state;
2453         }
2454
2455         for_each_oldnew_private_obj_in_state(state, obj, old_obj_state, new_obj_state, i) {
2456                 WARN_ON(obj->state != old_obj_state);
2457
2458                 old_obj_state->state = state;
2459                 new_obj_state->state = NULL;
2460
2461                 state->private_objs[i].state = old_obj_state;
2462                 obj->state = new_obj_state;
2463         }
2464
2465         return 0;
2466 }
2467 EXPORT_SYMBOL(drm_atomic_helper_swap_state);
2468
2469 /**
2470  * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
2471  * @plane: plane object to update
2472  * @crtc: owning CRTC of owning plane
2473  * @fb: framebuffer to flip onto plane
2474  * @crtc_x: x offset of primary plane on crtc
2475  * @crtc_y: y offset of primary plane on crtc
2476  * @crtc_w: width of primary plane rectangle on crtc
2477  * @crtc_h: height of primary plane rectangle on crtc
2478  * @src_x: x offset of @fb for panning
2479  * @src_y: y offset of @fb for panning
2480  * @src_w: width of source rectangle in @fb
2481  * @src_h: height of source rectangle in @fb
2482  * @ctx: lock acquire context
2483  *
2484  * Provides a default plane update handler using the atomic driver interface.
2485  *
2486  * RETURNS:
2487  * Zero on success, error code on failure
2488  */
2489 int drm_atomic_helper_update_plane(struct drm_plane *plane,
2490                                    struct drm_crtc *crtc,
2491                                    struct drm_framebuffer *fb,
2492                                    int crtc_x, int crtc_y,
2493                                    unsigned int crtc_w, unsigned int crtc_h,
2494                                    uint32_t src_x, uint32_t src_y,
2495                                    uint32_t src_w, uint32_t src_h,
2496                                    struct drm_modeset_acquire_ctx *ctx)
2497 {
2498         struct drm_atomic_state *state;
2499         struct drm_plane_state *plane_state;
2500         int ret = 0;
2501
2502         state = drm_atomic_state_alloc(plane->dev);
2503         if (!state)
2504                 return -ENOMEM;
2505
2506         state->acquire_ctx = ctx;
2507         plane_state = drm_atomic_get_plane_state(state, plane);
2508         if (IS_ERR(plane_state)) {
2509                 ret = PTR_ERR(plane_state);
2510                 goto fail;
2511         }
2512
2513         ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
2514         if (ret != 0)
2515                 goto fail;
2516         drm_atomic_set_fb_for_plane(plane_state, fb);
2517         plane_state->crtc_x = crtc_x;
2518         plane_state->crtc_y = crtc_y;
2519         plane_state->crtc_w = crtc_w;
2520         plane_state->crtc_h = crtc_h;
2521         plane_state->src_x = src_x;
2522         plane_state->src_y = src_y;
2523         plane_state->src_w = src_w;
2524         plane_state->src_h = src_h;
2525
2526         if (plane == crtc->cursor)
2527                 state->legacy_cursor_update = true;
2528
2529         ret = drm_atomic_commit(state);
2530 fail:
2531         drm_atomic_state_put(state);
2532         return ret;
2533 }
2534 EXPORT_SYMBOL(drm_atomic_helper_update_plane);
2535
2536 /**
2537  * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic
2538  * @plane: plane to disable
2539  * @ctx: lock acquire context
2540  *
2541  * Provides a default plane disable handler using the atomic driver interface.
2542  *
2543  * RETURNS:
2544  * Zero on success, error code on failure
2545  */
2546 int drm_atomic_helper_disable_plane(struct drm_plane *plane,
2547                                     struct drm_modeset_acquire_ctx *ctx)
2548 {
2549         struct drm_atomic_state *state;
2550         struct drm_plane_state *plane_state;
2551         int ret = 0;
2552
2553         state = drm_atomic_state_alloc(plane->dev);
2554         if (!state)
2555                 return -ENOMEM;
2556
2557         state->acquire_ctx = ctx;
2558         plane_state = drm_atomic_get_plane_state(state, plane);
2559         if (IS_ERR(plane_state)) {
2560                 ret = PTR_ERR(plane_state);
2561                 goto fail;
2562         }
2563
2564         if (plane_state->crtc && (plane == plane->crtc->cursor))
2565                 plane_state->state->legacy_cursor_update = true;
2566
2567         ret = __drm_atomic_helper_disable_plane(plane, plane_state);
2568         if (ret != 0)
2569                 goto fail;
2570
2571         ret = drm_atomic_commit(state);
2572 fail:
2573         drm_atomic_state_put(state);
2574         return ret;
2575 }
2576 EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
2577
2578 /* just used from fb-helper and atomic-helper: */
2579 int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
2580                 struct drm_plane_state *plane_state)
2581 {
2582         int ret;
2583
2584         ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
2585         if (ret != 0)
2586                 return ret;
2587
2588         drm_atomic_set_fb_for_plane(plane_state, NULL);
2589         plane_state->crtc_x = 0;
2590         plane_state->crtc_y = 0;
2591         plane_state->crtc_w = 0;
2592         plane_state->crtc_h = 0;
2593         plane_state->src_x = 0;
2594         plane_state->src_y = 0;
2595         plane_state->src_w = 0;
2596         plane_state->src_h = 0;
2597
2598         return 0;
2599 }
2600
2601 static int update_output_state(struct drm_atomic_state *state,
2602                                struct drm_mode_set *set)
2603 {
2604         struct drm_device *dev = set->crtc->dev;
2605         struct drm_crtc *crtc;
2606         struct drm_crtc_state *new_crtc_state;
2607         struct drm_connector *connector;
2608         struct drm_connector_state *new_conn_state;
2609         int ret, i;
2610
2611         ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
2612                                state->acquire_ctx);
2613         if (ret)
2614                 return ret;
2615
2616         /* First disable all connectors on the target crtc. */
2617         ret = drm_atomic_add_affected_connectors(state, set->crtc);
2618         if (ret)
2619                 return ret;
2620
2621         for_each_new_connector_in_state(state, connector, new_conn_state, i) {
2622                 if (new_conn_state->crtc == set->crtc) {
2623                         ret = drm_atomic_set_crtc_for_connector(new_conn_state,
2624                                                                 NULL);
2625                         if (ret)
2626                                 return ret;
2627
2628                         /* Make sure legacy setCrtc always re-trains */
2629                         new_conn_state->link_status = DRM_LINK_STATUS_GOOD;
2630                 }
2631         }
2632
2633         /* Then set all connectors from set->connectors on the target crtc */
2634         for (i = 0; i < set->num_connectors; i++) {
2635                 new_conn_state = drm_atomic_get_connector_state(state,
2636                                                             set->connectors[i]);
2637                 if (IS_ERR(new_conn_state))
2638                         return PTR_ERR(new_conn_state);
2639
2640                 ret = drm_atomic_set_crtc_for_connector(new_conn_state,
2641                                                         set->crtc);
2642                 if (ret)
2643                         return ret;
2644         }
2645
2646         for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
2647                 /* Don't update ->enable for the CRTC in the set_config request,
2648                  * since a mismatch would indicate a bug in the upper layers.
2649                  * The actual modeset code later on will catch any
2650                  * inconsistencies here. */
2651                 if (crtc == set->crtc)
2652                         continue;
2653
2654                 if (!new_crtc_state->connector_mask) {
2655                         ret = drm_atomic_set_mode_prop_for_crtc(new_crtc_state,
2656                                                                 NULL);
2657                         if (ret < 0)
2658                                 return ret;
2659
2660                         new_crtc_state->active = false;
2661                 }
2662         }
2663
2664         return 0;
2665 }
2666
2667 /**
2668  * drm_atomic_helper_set_config - set a new config from userspace
2669  * @set: mode set configuration
2670  * @ctx: lock acquisition context
2671  *
2672  * Provides a default crtc set_config handler using the atomic driver interface.
2673  *
2674  * NOTE: For backwards compatibility with old userspace this automatically
2675  * resets the "link-status" property to GOOD, to force any link
2676  * re-training. The SETCRTC ioctl does not define whether an update does
2677  * need a full modeset or just a plane update, hence we're allowed to do
2678  * that. See also drm_mode_connector_set_link_status_property().
2679  *
2680  * Returns:
2681  * Returns 0 on success, negative errno numbers on failure.
2682  */
2683 int drm_atomic_helper_set_config(struct drm_mode_set *set,
2684                                  struct drm_modeset_acquire_ctx *ctx)
2685 {
2686         struct drm_atomic_state *state;
2687         struct drm_crtc *crtc = set->crtc;
2688         int ret = 0;
2689
2690         state = drm_atomic_state_alloc(crtc->dev);
2691         if (!state)
2692                 return -ENOMEM;
2693
2694         state->acquire_ctx = ctx;
2695         ret = __drm_atomic_helper_set_config(set, state);
2696         if (ret != 0)
2697                 goto fail;
2698
2699         ret = handle_conflicting_encoders(state, true);
2700         if (ret)
2701                 return ret;
2702
2703         ret = drm_atomic_commit(state);
2704
2705 fail:
2706         drm_atomic_state_put(state);
2707         return ret;
2708 }
2709 EXPORT_SYMBOL(drm_atomic_helper_set_config);
2710
2711 /* just used from fb-helper and atomic-helper: */
2712 int __drm_atomic_helper_set_config(struct drm_mode_set *set,
2713                 struct drm_atomic_state *state)
2714 {
2715         struct drm_crtc_state *crtc_state;
2716         struct drm_plane_state *primary_state;
2717         struct drm_crtc *crtc = set->crtc;
2718         int hdisplay, vdisplay;
2719         int ret;
2720
2721         crtc_state = drm_atomic_get_crtc_state(state, crtc);
2722         if (IS_ERR(crtc_state))
2723                 return PTR_ERR(crtc_state);
2724
2725         primary_state = drm_atomic_get_plane_state(state, crtc->primary);
2726         if (IS_ERR(primary_state))
2727                 return PTR_ERR(primary_state);
2728
2729         if (!set->mode) {
2730                 WARN_ON(set->fb);
2731                 WARN_ON(set->num_connectors);
2732
2733                 ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL);
2734                 if (ret != 0)
2735                         return ret;
2736
2737                 crtc_state->active = false;
2738
2739                 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
2740                 if (ret != 0)
2741                         return ret;
2742
2743                 drm_atomic_set_fb_for_plane(primary_state, NULL);
2744
2745                 goto commit;
2746         }
2747
2748         WARN_ON(!set->fb);
2749         WARN_ON(!set->num_connectors);
2750
2751         ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode);
2752         if (ret != 0)
2753                 return ret;
2754
2755         crtc_state->active = true;
2756
2757         ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
2758         if (ret != 0)
2759                 return ret;
2760
2761         drm_mode_get_hv_timing(set->mode, &hdisplay, &vdisplay);
2762
2763         drm_atomic_set_fb_for_plane(primary_state, set->fb);
2764         primary_state->crtc_x = 0;
2765         primary_state->crtc_y = 0;
2766         primary_state->crtc_w = hdisplay;
2767         primary_state->crtc_h = vdisplay;
2768         primary_state->src_x = set->x << 16;
2769         primary_state->src_y = set->y << 16;
2770         if (drm_rotation_90_or_270(primary_state->rotation)) {
2771                 primary_state->src_w = vdisplay << 16;
2772                 primary_state->src_h = hdisplay << 16;
2773         } else {
2774                 primary_state->src_w = hdisplay << 16;
2775                 primary_state->src_h = vdisplay << 16;
2776         }
2777
2778 commit:
2779         ret = update_output_state(state, set);
2780         if (ret)
2781                 return ret;
2782
2783         return 0;
2784 }
2785
2786 /**
2787  * drm_atomic_helper_disable_all - disable all currently active outputs
2788  * @dev: DRM device
2789  * @ctx: lock acquisition context
2790  *
2791  * Loops through all connectors, finding those that aren't turned off and then
2792  * turns them off by setting their DPMS mode to OFF and deactivating the CRTC
2793  * that they are connected to.
2794  *
2795  * This is used for example in suspend/resume to disable all currently active
2796  * functions when suspending. If you just want to shut down everything at e.g.
2797  * driver unload, look at drm_atomic_helper_shutdown().
2798  *
2799  * Note that if callers haven't already acquired all modeset locks this might
2800  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
2801  *
2802  * Returns:
2803  * 0 on success or a negative error code on failure.
2804  *
2805  * See also:
2806  * drm_atomic_helper_suspend(), drm_atomic_helper_resume() and
2807  * drm_atomic_helper_shutdown().
2808  */
2809 int drm_atomic_helper_disable_all(struct drm_device *dev,
2810                                   struct drm_modeset_acquire_ctx *ctx)
2811 {
2812         struct drm_atomic_state *state;
2813         struct drm_connector_state *conn_state;
2814         struct drm_connector *conn;
2815         struct drm_plane_state *plane_state;
2816         struct drm_plane *plane;
2817         struct drm_crtc_state *crtc_state;
2818         struct drm_crtc *crtc;
2819         unsigned plane_mask = 0;
2820         int ret, i;
2821
2822         state = drm_atomic_state_alloc(dev);
2823         if (!state)
2824                 return -ENOMEM;
2825
2826         state->acquire_ctx = ctx;
2827
2828         drm_for_each_crtc(crtc, dev) {
2829                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
2830                 if (IS_ERR(crtc_state)) {
2831                         ret = PTR_ERR(crtc_state);
2832                         goto free;
2833                 }
2834
2835                 crtc_state->active = false;
2836
2837                 ret = drm_atomic_set_mode_prop_for_crtc(crtc_state, NULL);
2838                 if (ret < 0)
2839                         goto free;
2840
2841                 ret = drm_atomic_add_affected_planes(state, crtc);
2842                 if (ret < 0)
2843                         goto free;
2844
2845                 ret = drm_atomic_add_affected_connectors(state, crtc);
2846                 if (ret < 0)
2847                         goto free;
2848         }
2849
2850         for_each_new_connector_in_state(state, conn, conn_state, i) {
2851                 ret = drm_atomic_set_crtc_for_connector(conn_state, NULL);
2852                 if (ret < 0)
2853                         goto free;
2854         }
2855
2856         for_each_new_plane_in_state(state, plane, plane_state, i) {
2857                 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
2858                 if (ret < 0)
2859                         goto free;
2860
2861                 drm_atomic_set_fb_for_plane(plane_state, NULL);
2862                 plane_mask |= BIT(drm_plane_index(plane));
2863                 plane->old_fb = plane->fb;
2864         }
2865
2866         ret = drm_atomic_commit(state);
2867 free:
2868         if (plane_mask)
2869                 drm_atomic_clean_old_fb(dev, plane_mask, ret);
2870         drm_atomic_state_put(state);
2871         return ret;
2872 }
2873
2874 EXPORT_SYMBOL(drm_atomic_helper_disable_all);
2875
2876 /**
2877  * drm_atomic_helper_shutdown - shutdown all CRTC
2878  * @dev: DRM device
2879  *
2880  * This shuts down all CRTC, which is useful for driver unloading. Shutdown on
2881  * suspend should instead be handled with drm_atomic_helper_suspend(), since
2882  * that also takes a snapshot of the modeset state to be restored on resume.
2883  *
2884  * This is just a convenience wrapper around drm_atomic_helper_disable_all(),
2885  * and it is the atomic version of drm_crtc_force_disable_all().
2886  */
2887 void drm_atomic_helper_shutdown(struct drm_device *dev)
2888 {
2889         struct drm_modeset_acquire_ctx ctx;
2890         int ret;
2891
2892         drm_modeset_acquire_init(&ctx, 0);
2893         while (1) {
2894                 ret = drm_modeset_lock_all_ctx(dev, &ctx);
2895                 if (!ret)
2896                         ret = drm_atomic_helper_disable_all(dev, &ctx);
2897
2898                 if (ret != -EDEADLK)
2899                         break;
2900
2901                 drm_modeset_backoff(&ctx);
2902         }
2903
2904         if (ret)
2905                 DRM_ERROR("Disabling all crtc's during unload failed with %i\n", ret);
2906
2907         drm_modeset_drop_locks(&ctx);
2908         drm_modeset_acquire_fini(&ctx);
2909 }
2910 EXPORT_SYMBOL(drm_atomic_helper_shutdown);
2911
2912 /**
2913  * drm_atomic_helper_suspend - subsystem-level suspend helper
2914  * @dev: DRM device
2915  *
2916  * Duplicates the current atomic state, disables all active outputs and then
2917  * returns a pointer to the original atomic state to the caller. Drivers can
2918  * pass this pointer to the drm_atomic_helper_resume() helper upon resume to
2919  * restore the output configuration that was active at the time the system
2920  * entered suspend.
2921  *
2922  * Note that it is potentially unsafe to use this. The atomic state object
2923  * returned by this function is assumed to be persistent. Drivers must ensure
2924  * that this holds true. Before calling this function, drivers must make sure
2925  * to suspend fbdev emulation so that nothing can be using the device.
2926  *
2927  * Returns:
2928  * A pointer to a copy of the state before suspend on success or an ERR_PTR()-
2929  * encoded error code on failure. Drivers should store the returned atomic
2930  * state object and pass it to the drm_atomic_helper_resume() helper upon
2931  * resume.
2932  *
2933  * See also:
2934  * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(),
2935  * drm_atomic_helper_resume(), drm_atomic_helper_commit_duplicated_state()
2936  */
2937 struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev)
2938 {
2939         struct drm_modeset_acquire_ctx ctx;
2940         struct drm_atomic_state *state;
2941         int err;
2942
2943         drm_modeset_acquire_init(&ctx, 0);
2944
2945 retry:
2946         err = drm_modeset_lock_all_ctx(dev, &ctx);
2947         if (err < 0) {
2948                 state = ERR_PTR(err);
2949                 goto unlock;
2950         }
2951
2952         state = drm_atomic_helper_duplicate_state(dev, &ctx);
2953         if (IS_ERR(state))
2954                 goto unlock;
2955
2956         err = drm_atomic_helper_disable_all(dev, &ctx);
2957         if (err < 0) {
2958                 drm_atomic_state_put(state);
2959                 state = ERR_PTR(err);
2960                 goto unlock;
2961         }
2962
2963 unlock:
2964         if (PTR_ERR(state) == -EDEADLK) {
2965                 drm_modeset_backoff(&ctx);
2966                 goto retry;
2967         }
2968
2969         drm_modeset_drop_locks(&ctx);
2970         drm_modeset_acquire_fini(&ctx);
2971         return state;
2972 }
2973 EXPORT_SYMBOL(drm_atomic_helper_suspend);
2974
2975 /**
2976  * drm_atomic_helper_commit_duplicated_state - commit duplicated state
2977  * @state: duplicated atomic state to commit
2978  * @ctx: pointer to acquire_ctx to use for commit.
2979  *
2980  * The state returned by drm_atomic_helper_duplicate_state() and
2981  * drm_atomic_helper_suspend() is partially invalid, and needs to
2982  * be fixed up before commit.
2983  *
2984  * Returns:
2985  * 0 on success or a negative error code on failure.
2986  *
2987  * See also:
2988  * drm_atomic_helper_suspend()
2989  */
2990 int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
2991                                               struct drm_modeset_acquire_ctx *ctx)
2992 {
2993         int i;
2994         struct drm_plane *plane;
2995         struct drm_plane_state *new_plane_state;
2996         struct drm_connector *connector;
2997         struct drm_connector_state *new_conn_state;
2998         struct drm_crtc *crtc;
2999         struct drm_crtc_state *new_crtc_state;
3000         unsigned plane_mask = 0;
3001         struct drm_device *dev = state->dev;
3002         int ret;
3003
3004         state->acquire_ctx = ctx;
3005
3006         for_each_new_plane_in_state(state, plane, new_plane_state, i) {
3007                 plane_mask |= BIT(drm_plane_index(plane));
3008                 state->planes[i].old_state = plane->state;
3009         }
3010
3011         for_each_new_crtc_in_state(state, crtc, new_crtc_state, i)
3012                 state->crtcs[i].old_state = crtc->state;
3013
3014         for_each_new_connector_in_state(state, connector, new_conn_state, i)
3015                 state->connectors[i].old_state = connector->state;
3016
3017         ret = drm_atomic_commit(state);
3018         if (plane_mask)
3019                 drm_atomic_clean_old_fb(dev, plane_mask, ret);
3020
3021         return ret;
3022 }
3023 EXPORT_SYMBOL(drm_atomic_helper_commit_duplicated_state);
3024
3025 /**
3026  * drm_atomic_helper_resume - subsystem-level resume helper
3027  * @dev: DRM device
3028  * @state: atomic state to resume to
3029  *
3030  * Calls drm_mode_config_reset() to synchronize hardware and software states,
3031  * grabs all modeset locks and commits the atomic state object. This can be
3032  * used in conjunction with the drm_atomic_helper_suspend() helper to
3033  * implement suspend/resume for drivers that support atomic mode-setting.
3034  *
3035  * Returns:
3036  * 0 on success or a negative error code on failure.
3037  *
3038  * See also:
3039  * drm_atomic_helper_suspend()
3040  */
3041 int drm_atomic_helper_resume(struct drm_device *dev,
3042                              struct drm_atomic_state *state)
3043 {
3044         struct drm_modeset_acquire_ctx ctx;
3045         int err;
3046
3047         drm_mode_config_reset(dev);
3048
3049         drm_modeset_acquire_init(&ctx, 0);
3050         while (1) {
3051                 err = drm_modeset_lock_all_ctx(dev, &ctx);
3052                 if (err)
3053                         goto out;
3054
3055                 err = drm_atomic_helper_commit_duplicated_state(state, &ctx);
3056 out:
3057                 if (err != -EDEADLK)
3058                         break;
3059
3060                 drm_modeset_backoff(&ctx);
3061         }
3062
3063         drm_atomic_state_put(state);
3064         drm_modeset_drop_locks(&ctx);
3065         drm_modeset_acquire_fini(&ctx);
3066
3067         return err;
3068 }
3069 EXPORT_SYMBOL(drm_atomic_helper_resume);
3070
3071 static int page_flip_common(struct drm_atomic_state *state,
3072                             struct drm_crtc *crtc,
3073                             struct drm_framebuffer *fb,
3074                             struct drm_pending_vblank_event *event,
3075                             uint32_t flags)
3076 {
3077         struct drm_plane *plane = crtc->primary;
3078         struct drm_plane_state *plane_state;
3079         struct drm_crtc_state *crtc_state;
3080         int ret = 0;
3081
3082         crtc_state = drm_atomic_get_crtc_state(state, crtc);
3083         if (IS_ERR(crtc_state))
3084                 return PTR_ERR(crtc_state);
3085
3086         crtc_state->event = event;
3087         crtc_state->pageflip_flags = flags;
3088
3089         plane_state = drm_atomic_get_plane_state(state, plane);
3090         if (IS_ERR(plane_state))
3091                 return PTR_ERR(plane_state);
3092
3093         ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
3094         if (ret != 0)
3095                 return ret;
3096         drm_atomic_set_fb_for_plane(plane_state, fb);
3097
3098         /* Make sure we don't accidentally do a full modeset. */
3099         state->allow_modeset = false;
3100         if (!crtc_state->active) {
3101                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled, rejecting legacy flip\n",
3102                                  crtc->base.id, crtc->name);
3103                 return -EINVAL;
3104         }
3105
3106         return ret;
3107 }
3108
3109 /**
3110  * drm_atomic_helper_page_flip - execute a legacy page flip
3111  * @crtc: DRM crtc
3112  * @fb: DRM framebuffer
3113  * @event: optional DRM event to signal upon completion
3114  * @flags: flip flags for non-vblank sync'ed updates
3115  * @ctx: lock acquisition context
3116  *
3117  * Provides a default &drm_crtc_funcs.page_flip implementation
3118  * using the atomic driver interface.
3119  *
3120  * Returns:
3121  * Returns 0 on success, negative errno numbers on failure.
3122  *
3123  * See also:
3124  * drm_atomic_helper_page_flip_target()
3125  */
3126 int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
3127                                 struct drm_framebuffer *fb,
3128                                 struct drm_pending_vblank_event *event,
3129                                 uint32_t flags,
3130                                 struct drm_modeset_acquire_ctx *ctx)
3131 {
3132         struct drm_plane *plane = crtc->primary;
3133         struct drm_atomic_state *state;
3134         int ret = 0;
3135
3136         state = drm_atomic_state_alloc(plane->dev);
3137         if (!state)
3138                 return -ENOMEM;
3139
3140         state->acquire_ctx = ctx;
3141
3142         ret = page_flip_common(state, crtc, fb, event, flags);
3143         if (ret != 0)
3144                 goto fail;
3145
3146         ret = drm_atomic_nonblocking_commit(state);
3147 fail:
3148         drm_atomic_state_put(state);
3149         return ret;
3150 }
3151 EXPORT_SYMBOL(drm_atomic_helper_page_flip);
3152
3153 /**
3154  * drm_atomic_helper_page_flip_target - do page flip on target vblank period.
3155  * @crtc: DRM crtc
3156  * @fb: DRM framebuffer
3157  * @event: optional DRM event to signal upon completion
3158  * @flags: flip flags for non-vblank sync'ed updates
3159  * @target: specifying the target vblank period when the flip to take effect
3160  * @ctx: lock acquisition context
3161  *
3162  * Provides a default &drm_crtc_funcs.page_flip_target implementation.
3163  * Similar to drm_atomic_helper_page_flip() with extra parameter to specify
3164  * target vblank period to flip.
3165  *
3166  * Returns:
3167  * Returns 0 on success, negative errno numbers on failure.
3168  */
3169 int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
3170                                        struct drm_framebuffer *fb,
3171                                        struct drm_pending_vblank_event *event,
3172                                        uint32_t flags,
3173                                        uint32_t target,
3174                                        struct drm_modeset_acquire_ctx *ctx)
3175 {
3176         struct drm_plane *plane = crtc->primary;
3177         struct drm_atomic_state *state;
3178         struct drm_crtc_state *crtc_state;
3179         int ret = 0;
3180
3181         state = drm_atomic_state_alloc(plane->dev);
3182         if (!state)
3183                 return -ENOMEM;
3184
3185         state->acquire_ctx = ctx;
3186
3187         ret = page_flip_common(state, crtc, fb, event, flags);
3188         if (ret != 0)
3189                 goto fail;
3190
3191         crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
3192         if (WARN_ON(!crtc_state)) {
3193                 ret = -EINVAL;
3194                 goto fail;
3195         }
3196         crtc_state->target_vblank = target;
3197
3198         ret = drm_atomic_nonblocking_commit(state);
3199 fail:
3200         drm_atomic_state_put(state);
3201         return ret;
3202 }
3203 EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
3204
3205 /**
3206  * drm_atomic_helper_best_encoder - Helper for
3207  *      &drm_connector_helper_funcs.best_encoder callback
3208  * @connector: Connector control structure
3209  *
3210  * This is a &drm_connector_helper_funcs.best_encoder callback helper for
3211  * connectors that support exactly 1 encoder, statically determined at driver
3212  * init time.
3213  */
3214 struct drm_encoder *
3215 drm_atomic_helper_best_encoder(struct drm_connector *connector)
3216 {
3217         WARN_ON(connector->encoder_ids[1]);
3218         return drm_encoder_find(connector->dev, NULL, connector->encoder_ids[0]);
3219 }
3220 EXPORT_SYMBOL(drm_atomic_helper_best_encoder);
3221
3222 /**
3223  * DOC: atomic state reset and initialization
3224  *
3225  * Both the drm core and the atomic helpers assume that there is always the full
3226  * and correct atomic software state for all connectors, CRTCs and planes
3227  * available. Which is a bit a problem on driver load and also after system
3228  * suspend. One way to solve this is to have a hardware state read-out
3229  * infrastructure which reconstructs the full software state (e.g. the i915
3230  * driver).
3231  *
3232  * The simpler solution is to just reset the software state to everything off,
3233  * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
3234  * the atomic helpers provide default reset implementations for all hooks.
3235  *
3236  * On the upside the precise state tracking of atomic simplifies system suspend
3237  * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
3238  * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
3239  * For other drivers the building blocks are split out, see the documentation
3240  * for these functions.
3241  */
3242
3243 /**
3244  * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs
3245  * @crtc: drm CRTC
3246  *
3247  * Resets the atomic state for @crtc by freeing the state pointer (which might
3248  * be NULL, e.g. at driver load time) and allocating a new empty state object.
3249  */
3250 void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
3251 {
3252         if (crtc->state)
3253                 __drm_atomic_helper_crtc_destroy_state(crtc->state);
3254
3255         kfree(crtc->state);
3256         crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL);
3257
3258         if (crtc->state)
3259                 crtc->state->crtc = crtc;
3260 }
3261 EXPORT_SYMBOL(drm_atomic_helper_crtc_reset);
3262
3263 /**
3264  * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
3265  * @crtc: CRTC object
3266  * @state: atomic CRTC state
3267  *
3268  * Copies atomic state from a CRTC's current state and resets inferred values.
3269  * This is useful for drivers that subclass the CRTC state.
3270  */
3271 void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
3272                                               struct drm_crtc_state *state)
3273 {
3274         memcpy(state, crtc->state, sizeof(*state));
3275
3276         if (state->mode_blob)
3277                 drm_property_blob_get(state->mode_blob);
3278         if (state->degamma_lut)
3279                 drm_property_blob_get(state->degamma_lut);
3280         if (state->ctm)
3281                 drm_property_blob_get(state->ctm);
3282         if (state->gamma_lut)
3283                 drm_property_blob_get(state->gamma_lut);
3284         state->mode_changed = false;
3285         state->active_changed = false;
3286         state->planes_changed = false;
3287         state->connectors_changed = false;
3288         state->color_mgmt_changed = false;
3289         state->zpos_changed = false;
3290         state->commit = NULL;
3291         state->event = NULL;
3292         state->pageflip_flags = 0;
3293 }
3294 EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
3295
3296 /**
3297  * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
3298  * @crtc: drm CRTC
3299  *
3300  * Default CRTC state duplicate hook for drivers which don't have their own
3301  * subclassed CRTC state structure.
3302  */
3303 struct drm_crtc_state *
3304 drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
3305 {
3306         struct drm_crtc_state *state;
3307
3308         if (WARN_ON(!crtc->state))
3309                 return NULL;
3310
3311         state = kmalloc(sizeof(*state), GFP_KERNEL);
3312         if (state)
3313                 __drm_atomic_helper_crtc_duplicate_state(crtc, state);
3314
3315         return state;
3316 }
3317 EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
3318
3319 /**
3320  * __drm_atomic_helper_crtc_destroy_state - release CRTC state
3321  * @state: CRTC state object to release
3322  *
3323  * Releases all resources stored in the CRTC state without actually freeing
3324  * the memory of the CRTC state. This is useful for drivers that subclass the
3325  * CRTC state.
3326  */
3327 void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state)
3328 {
3329         if (state->commit) {
3330                 kfree(state->commit->event);
3331                 state->commit->event = NULL;
3332                 drm_crtc_commit_put(state->commit);
3333         }
3334
3335         drm_property_blob_put(state->mode_blob);
3336         drm_property_blob_put(state->degamma_lut);
3337         drm_property_blob_put(state->ctm);
3338         drm_property_blob_put(state->gamma_lut);
3339 }
3340 EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
3341
3342 /**
3343  * drm_atomic_helper_crtc_destroy_state - default state destroy hook
3344  * @crtc: drm CRTC
3345  * @state: CRTC state object to release
3346  *
3347  * Default CRTC state destroy hook for drivers which don't have their own
3348  * subclassed CRTC state structure.
3349  */
3350 void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
3351                                           struct drm_crtc_state *state)
3352 {
3353         __drm_atomic_helper_crtc_destroy_state(state);
3354         kfree(state);
3355 }
3356 EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
3357
3358 /**
3359  * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes
3360  * @plane: drm plane
3361  *
3362  * Resets the atomic state for @plane by freeing the state pointer (which might
3363  * be NULL, e.g. at driver load time) and allocating a new empty state object.
3364  */
3365 void drm_atomic_helper_plane_reset(struct drm_plane *plane)
3366 {
3367         if (plane->state)
3368                 __drm_atomic_helper_plane_destroy_state(plane->state);
3369
3370         kfree(plane->state);
3371         plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
3372
3373         if (plane->state) {
3374                 plane->state->plane = plane;
3375                 plane->state->rotation = DRM_MODE_ROTATE_0;
3376         }
3377 }
3378 EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
3379
3380 /**
3381  * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
3382  * @plane: plane object
3383  * @state: atomic plane state
3384  *
3385  * Copies atomic state from a plane's current state. This is useful for
3386  * drivers that subclass the plane state.
3387  */
3388 void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
3389                                                struct drm_plane_state *state)
3390 {
3391         memcpy(state, plane->state, sizeof(*state));
3392
3393         if (state->fb)
3394                 drm_framebuffer_get(state->fb);
3395
3396         state->fence = NULL;
3397         state->commit = NULL;
3398 }
3399 EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
3400
3401 /**
3402  * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
3403  * @plane: drm plane
3404  *
3405  * Default plane state duplicate hook for drivers which don't have their own
3406  * subclassed plane state structure.
3407  */
3408 struct drm_plane_state *
3409 drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
3410 {
3411         struct drm_plane_state *state;
3412
3413         if (WARN_ON(!plane->state))
3414                 return NULL;
3415
3416         state = kmalloc(sizeof(*state), GFP_KERNEL);
3417         if (state)
3418                 __drm_atomic_helper_plane_duplicate_state(plane, state);
3419
3420         return state;
3421 }
3422 EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
3423
3424 /**
3425  * __drm_atomic_helper_plane_destroy_state - release plane state
3426  * @state: plane state object to release
3427  *
3428  * Releases all resources stored in the plane state without actually freeing
3429  * the memory of the plane state. This is useful for drivers that subclass the
3430  * plane state.
3431  */
3432 void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state)
3433 {
3434         if (state->fb)
3435                 drm_framebuffer_put(state->fb);
3436
3437         if (state->fence)
3438                 dma_fence_put(state->fence);
3439
3440         if (state->commit)
3441                 drm_crtc_commit_put(state->commit);
3442 }
3443 EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
3444
3445 /**
3446  * drm_atomic_helper_plane_destroy_state - default state destroy hook
3447  * @plane: drm plane
3448  * @state: plane state object to release
3449  *
3450  * Default plane state destroy hook for drivers which don't have their own
3451  * subclassed plane state structure.
3452  */
3453 void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
3454                                            struct drm_plane_state *state)
3455 {
3456         __drm_atomic_helper_plane_destroy_state(state);
3457         kfree(state);
3458 }
3459 EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
3460
3461 /**
3462  * __drm_atomic_helper_connector_reset - reset state on connector
3463  * @connector: drm connector
3464  * @conn_state: connector state to assign
3465  *
3466  * Initializes the newly allocated @conn_state and assigns it to
3467  * the &drm_conector->state pointer of @connector, usually required when
3468  * initializing the drivers or when called from the &drm_connector_funcs.reset
3469  * hook.
3470  *
3471  * This is useful for drivers that subclass the connector state.
3472  */
3473 void
3474 __drm_atomic_helper_connector_reset(struct drm_connector *connector,
3475                                     struct drm_connector_state *conn_state)
3476 {
3477         if (conn_state)
3478                 conn_state->connector = connector;
3479
3480         connector->state = conn_state;
3481 }
3482 EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
3483
3484 /**
3485  * drm_atomic_helper_connector_reset - default &drm_connector_funcs.reset hook for connectors
3486  * @connector: drm connector
3487  *
3488  * Resets the atomic state for @connector by freeing the state pointer (which
3489  * might be NULL, e.g. at driver load time) and allocating a new empty state
3490  * object.
3491  */
3492 void drm_atomic_helper_connector_reset(struct drm_connector *connector)
3493 {
3494         struct drm_connector_state *conn_state =
3495                 kzalloc(sizeof(*conn_state), GFP_KERNEL);
3496
3497         if (connector->state)
3498                 __drm_atomic_helper_connector_destroy_state(connector->state);
3499
3500         kfree(connector->state);
3501         __drm_atomic_helper_connector_reset(connector, conn_state);
3502 }
3503 EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
3504
3505 /**
3506  * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
3507  * @connector: connector object
3508  * @state: atomic connector state
3509  *
3510  * Copies atomic state from a connector's current state. This is useful for
3511  * drivers that subclass the connector state.
3512  */
3513 void
3514 __drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
3515                                             struct drm_connector_state *state)
3516 {
3517         memcpy(state, connector->state, sizeof(*state));
3518         if (state->crtc)
3519                 drm_connector_get(connector);
3520         state->commit = NULL;
3521 }
3522 EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
3523
3524 /**
3525  * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
3526  * @connector: drm connector
3527  *
3528  * Default connector state duplicate hook for drivers which don't have their own
3529  * subclassed connector state structure.
3530  */
3531 struct drm_connector_state *
3532 drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
3533 {
3534         struct drm_connector_state *state;
3535
3536         if (WARN_ON(!connector->state))
3537                 return NULL;
3538
3539         state = kmalloc(sizeof(*state), GFP_KERNEL);
3540         if (state)
3541                 __drm_atomic_helper_connector_duplicate_state(connector, state);
3542
3543         return state;
3544 }
3545 EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
3546
3547 /**
3548  * drm_atomic_helper_duplicate_state - duplicate an atomic state object
3549  * @dev: DRM device
3550  * @ctx: lock acquisition context
3551  *
3552  * Makes a copy of the current atomic state by looping over all objects and
3553  * duplicating their respective states. This is used for example by suspend/
3554  * resume support code to save the state prior to suspend such that it can
3555  * be restored upon resume.
3556  *
3557  * Note that this treats atomic state as persistent between save and restore.
3558  * Drivers must make sure that this is possible and won't result in confusion
3559  * or erroneous behaviour.
3560  *
3561  * Note that if callers haven't already acquired all modeset locks this might
3562  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
3563  *
3564  * Returns:
3565  * A pointer to the copy of the atomic state object on success or an
3566  * ERR_PTR()-encoded error code on failure.
3567  *
3568  * See also:
3569  * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
3570  */
3571 struct drm_atomic_state *
3572 drm_atomic_helper_duplicate_state(struct drm_device *dev,
3573                                   struct drm_modeset_acquire_ctx *ctx)
3574 {
3575         struct drm_atomic_state *state;
3576         struct drm_connector *conn;
3577         struct drm_connector_list_iter conn_iter;
3578         struct drm_plane *plane;
3579         struct drm_crtc *crtc;
3580         int err = 0;
3581
3582         state = drm_atomic_state_alloc(dev);
3583         if (!state)
3584                 return ERR_PTR(-ENOMEM);
3585
3586         state->acquire_ctx = ctx;
3587
3588         drm_for_each_crtc(crtc, dev) {
3589                 struct drm_crtc_state *crtc_state;
3590
3591                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
3592                 if (IS_ERR(crtc_state)) {
3593                         err = PTR_ERR(crtc_state);
3594                         goto free;
3595                 }
3596         }
3597
3598         drm_for_each_plane(plane, dev) {
3599                 struct drm_plane_state *plane_state;
3600
3601                 plane_state = drm_atomic_get_plane_state(state, plane);
3602                 if (IS_ERR(plane_state)) {
3603                         err = PTR_ERR(plane_state);
3604                         goto free;
3605                 }
3606         }
3607
3608         drm_connector_list_iter_begin(dev, &conn_iter);
3609         drm_for_each_connector_iter(conn, &conn_iter) {
3610                 struct drm_connector_state *conn_state;
3611
3612                 conn_state = drm_atomic_get_connector_state(state, conn);
3613                 if (IS_ERR(conn_state)) {
3614                         err = PTR_ERR(conn_state);
3615                         drm_connector_list_iter_end(&conn_iter);
3616                         goto free;
3617                 }
3618         }
3619         drm_connector_list_iter_end(&conn_iter);
3620
3621         /* clear the acquire context so that it isn't accidentally reused */
3622         state->acquire_ctx = NULL;
3623
3624 free:
3625         if (err < 0) {
3626                 drm_atomic_state_put(state);
3627                 state = ERR_PTR(err);
3628         }
3629
3630         return state;
3631 }
3632 EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
3633
3634 /**
3635  * __drm_atomic_helper_connector_destroy_state - release connector state
3636  * @state: connector state object to release
3637  *
3638  * Releases all resources stored in the connector state without actually
3639  * freeing the memory of the connector state. This is useful for drivers that
3640  * subclass the connector state.
3641  */
3642 void
3643 __drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state)
3644 {
3645         if (state->crtc)
3646                 drm_connector_put(state->connector);
3647
3648         if (state->commit)
3649                 drm_crtc_commit_put(state->commit);
3650 }
3651 EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
3652
3653 /**
3654  * drm_atomic_helper_connector_destroy_state - default state destroy hook
3655  * @connector: drm connector
3656  * @state: connector state object to release
3657  *
3658  * Default connector state destroy hook for drivers which don't have their own
3659  * subclassed connector state structure.
3660  */
3661 void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
3662                                           struct drm_connector_state *state)
3663 {
3664         __drm_atomic_helper_connector_destroy_state(state);
3665         kfree(state);
3666 }
3667 EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
3668
3669 /**
3670  * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
3671  * @crtc: CRTC object
3672  * @red: red correction table
3673  * @green: green correction table
3674  * @blue: green correction table
3675  * @size: size of the tables
3676  * @ctx: lock acquire context
3677  *
3678  * Implements support for legacy gamma correction table for drivers
3679  * that support color management through the DEGAMMA_LUT/GAMMA_LUT
3680  * properties. See drm_crtc_enable_color_mgmt() and the containing chapter for
3681  * how the atomic color management and gamma tables work.
3682  */
3683 int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
3684                                        u16 *red, u16 *green, u16 *blue,
3685                                        uint32_t size,
3686                                        struct drm_modeset_acquire_ctx *ctx)
3687 {
3688         struct drm_device *dev = crtc->dev;
3689         struct drm_atomic_state *state;
3690         struct drm_crtc_state *crtc_state;
3691         struct drm_property_blob *blob = NULL;
3692         struct drm_color_lut *blob_data;
3693         int i, ret = 0;
3694         bool replaced;
3695
3696         state = drm_atomic_state_alloc(crtc->dev);
3697         if (!state)
3698                 return -ENOMEM;
3699
3700         blob = drm_property_create_blob(dev,
3701                                         sizeof(struct drm_color_lut) * size,
3702                                         NULL);
3703         if (IS_ERR(blob)) {
3704                 ret = PTR_ERR(blob);
3705                 blob = NULL;
3706                 goto fail;
3707         }
3708
3709         /* Prepare GAMMA_LUT with the legacy values. */
3710         blob_data = (struct drm_color_lut *) blob->data;
3711         for (i = 0; i < size; i++) {
3712                 blob_data[i].red = red[i];
3713                 blob_data[i].green = green[i];
3714                 blob_data[i].blue = blue[i];
3715         }
3716
3717         state->acquire_ctx = ctx;
3718         crtc_state = drm_atomic_get_crtc_state(state, crtc);
3719         if (IS_ERR(crtc_state)) {
3720                 ret = PTR_ERR(crtc_state);
3721                 goto fail;
3722         }
3723
3724         /* Reset DEGAMMA_LUT and CTM properties. */
3725         replaced  = drm_property_replace_blob(&crtc_state->degamma_lut, NULL);
3726         replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
3727         replaced |= drm_property_replace_blob(&crtc_state->gamma_lut, blob);
3728         crtc_state->color_mgmt_changed |= replaced;
3729
3730         ret = drm_atomic_commit(state);
3731
3732 fail:
3733         drm_atomic_state_put(state);
3734         drm_property_blob_put(blob);
3735         return ret;
3736 }
3737 EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);
3738
3739 /**
3740  * __drm_atomic_helper_private_duplicate_state - copy atomic private state
3741  * @obj: CRTC object
3742  * @state: new private object state
3743  *
3744  * Copies atomic state from a private objects's current state and resets inferred values.
3745  * This is useful for drivers that subclass the private state.
3746  */
3747 void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
3748                                                      struct drm_private_state *state)
3749 {
3750         memcpy(state, obj->state, sizeof(*state));
3751 }
3752 EXPORT_SYMBOL(__drm_atomic_helper_private_obj_duplicate_state);