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
 864                 /* Shut down everything that needs a full modeset. */
 865                 if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
 866                         continue;
 867
 868                 if (!old_crtc_state->active)
 869                         continue;
 870
 871                 funcs = crtc->helper_private;
 872
 873                 DRM_DEBUG_ATOMIC("disabling [CRTC:%d:%s]\n",
 874                                  crtc->base.id, crtc->name);
 875
 876
 877                 /* Right function depends upon target state. */
 878                 if (new_crtc_state->enable && funcs->prepare)
 879                         funcs->prepare(crtc);
 880                 else if (funcs->atomic_disable)
 881                         funcs->atomic_disable(crtc, old_crtc_state);
 882                 else if (funcs->disable)
 883                         funcs->disable(crtc);
 884                 else
 885                         funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
 886         }
 887 }
 888
 889 /**
 890  * drm_atomic_helper_update_legacy_modeset_state - update legacy modeset state
 891  * @dev: DRM device
 892  * @old_state: atomic state object with old state structures
 893  *
 894  * This function updates all the various legacy modeset state pointers in
 895  * connectors, encoders and crtcs. It also updates the timestamping constants
 896  * used for precise vblank timestamps by calling
 897  * drm_calc_timestamping_constants().
 898  *
 899  * Drivers can use this for building their own atomic commit if they don't have
 900  * a pure helper-based modeset implementation.
 901  */
 902 void
 903 drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
 904                                               struct drm_atomic_state *old_state)
 905 {
 906         struct drm_connector *connector;
 907         struct drm_connector_state *old_conn_state, *new_conn_state;
 908         struct drm_crtc *crtc;
 909         struct drm_crtc_state *new_crtc_state;
 910         int i;
 911
 912         /* clear out existing links and update dpms */
 913         for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
 914                 if (connector->encoder) {
 915                         WARN_ON(!connector->encoder->crtc);
 916
 917                         connector->encoder->crtc = NULL;
 918                         connector->encoder = NULL;
 919                 }
 920
 921                 crtc = new_conn_state->crtc;
 922                 if ((!crtc && old_conn_state->crtc) ||
 923                     (crtc && drm_atomic_crtc_needs_modeset(crtc->state))) {
 924                         int mode = DRM_MODE_DPMS_OFF;
 925
 926                         if (crtc && crtc->state->active)
 927                                 mode = DRM_MODE_DPMS_ON;
 928
 929                         connector->dpms = mode;
 930                 }
 931         }
 932
 933         /* set new links */
 934         for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
 935                 if (!new_conn_state->crtc)
 936                         continue;
 937
 938                 if (WARN_ON(!new_conn_state->best_encoder))
 939                         continue;
 940
 941                 connector->encoder = new_conn_state->best_encoder;
 942                 connector->encoder->crtc = new_conn_state->crtc;
 943         }
 944
 945         /* set legacy state in the crtc structure */
 946         for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
 947                 struct drm_plane *primary = crtc->primary;
 948                 struct drm_plane_state *new_plane_state;
 949
 950                 crtc->mode = new_crtc_state->mode;
 951                 crtc->enabled = new_crtc_state->enable;
 952
 953                 new_plane_state =
 954                         drm_atomic_get_new_plane_state(old_state, primary);
 955
 956                 if (new_plane_state && new_plane_state->crtc == crtc) {
 957                         crtc->x = new_plane_state->src_x >> 16;
 958                         crtc->y = new_plane_state->src_y >> 16;
 959                 }
 960
 961                 if (new_crtc_state->enable)
 962                         drm_calc_timestamping_constants(crtc,
 963                                                         &new_crtc_state->adjusted_mode);
 964         }
 965 }
 966 EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state);
 967
 968 static void
 969 crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state)
 970 {
 971         struct drm_crtc *crtc;
 972         struct drm_crtc_state *new_crtc_state;
 973         struct drm_connector *connector;
 974         struct drm_connector_state *new_conn_state;
 975         int i;
 976
 977         for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
 978                 const struct drm_crtc_helper_funcs *funcs;
 979
 980                 if (!new_crtc_state->mode_changed)
 981                         continue;
 982
 983                 funcs = crtc->helper_private;
 984
 985                 if (new_crtc_state->enable && funcs->mode_set_nofb) {
 986                         DRM_DEBUG_ATOMIC("modeset on [CRTC:%d:%s]\n",
 987                                          crtc->base.id, crtc->name);
 988
 989                         funcs->mode_set_nofb(crtc);
 990                 }
 991         }
 992
 993         for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
 994                 const struct drm_encoder_helper_funcs *funcs;
 995                 struct drm_encoder *encoder;
 996                 struct drm_display_mode *mode, *adjusted_mode;
 997
 998                 if (!new_conn_state->best_encoder)
 999                         continue;
1000
1001                 encoder = new_conn_state->best_encoder;
1002                 funcs = encoder->helper_private;
1003                 new_crtc_state = new_conn_state->crtc->state;
1004                 mode = &new_crtc_state->mode;
1005                 adjusted_mode = &new_crtc_state->adjusted_mode;
1006
1007                 if (!new_crtc_state->mode_changed)
1008                         continue;
1009
1010                 DRM_DEBUG_ATOMIC("modeset on [ENCODER:%d:%s]\n",
1011                                  encoder->base.id, encoder->name);
1012
1013                 /*
1014                  * Each encoder has at most one connector (since we always steal
1015                  * it away), so we won't call mode_set hooks twice.
1016                  */
1017                 if (funcs && funcs->atomic_mode_set) {
1018                         funcs->atomic_mode_set(encoder, new_crtc_state,
1019                                                new_conn_state);
1020                 } else if (funcs && funcs->mode_set) {
1021                         funcs->mode_set(encoder, mode, adjusted_mode);
1022                 }
1023
1024                 drm_bridge_mode_set(encoder->bridge, mode, adjusted_mode);
1025         }
1026 }
1027
1028 /**
1029  * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs
1030  * @dev: DRM device
1031  * @old_state: atomic state object with old state structures
1032  *
1033  * This function shuts down all the outputs that need to be shut down and
1034  * prepares them (if required) with the new mode.
1035  *
1036  * For compatibility with legacy crtc helpers this should be called before
1037  * drm_atomic_helper_commit_planes(), which is what the default commit function
1038  * does. But drivers with different needs can group the modeset commits together
1039  * and do the plane commits at the end. This is useful for drivers doing runtime
1040  * PM since planes updates then only happen when the CRTC is actually enabled.
1041  */
1042 void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
1043                                                struct drm_atomic_state *old_state)
1044 {
1045         disable_outputs(dev, old_state);
1046
1047         drm_atomic_helper_update_legacy_modeset_state(dev, old_state);
1048
1049         crtc_set_mode(dev, old_state);
1050 }
1051 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables);
1052
1053 /**
1054  * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs
1055  * @dev: DRM device
1056  * @old_state: atomic state object with old state structures
1057  *
1058  * This function enables all the outputs with the new configuration which had to
1059  * be turned off for the update.
1060  *
1061  * For compatibility with legacy crtc helpers this should be called after
1062  * drm_atomic_helper_commit_planes(), which is what the default commit function
1063  * does. But drivers with different needs can group the modeset commits together
1064  * and do the plane commits at the end. This is useful for drivers doing runtime
1065  * PM since planes updates then only happen when the CRTC is actually enabled.
1066  */
1067 void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
1068                                               struct drm_atomic_state *old_state)
1069 {
1070         struct drm_crtc *crtc;
1071         struct drm_crtc_state *old_crtc_state;
1072         struct drm_crtc_state *new_crtc_state;
1073         struct drm_connector *connector;
1074         struct drm_connector_state *new_conn_state;
1075         int i;
1076
1077         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1078                 const struct drm_crtc_helper_funcs *funcs;
1079
1080                 /* Need to filter out CRTCs where only planes change. */
1081                 if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
1082                         continue;
1083
1084                 if (!new_crtc_state->active)
1085                         continue;
1086
1087                 funcs = crtc->helper_private;
1088
1089                 if (new_crtc_state->enable) {
1090                         DRM_DEBUG_ATOMIC("enabling [CRTC:%d:%s]\n",
1091                                          crtc->base.id, crtc->name);
1092
1093                         if (funcs->atomic_enable)
1094                                 funcs->atomic_enable(crtc, old_crtc_state);
1095                         else
1096                                 funcs->commit(crtc);
1097                 }
1098         }
1099
1100         for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1101                 const struct drm_encoder_helper_funcs *funcs;
1102                 struct drm_encoder *encoder;
1103
1104                 if (!new_conn_state->best_encoder)
1105                         continue;
1106
1107                 if (!new_conn_state->crtc->state->active ||
1108                     !drm_atomic_crtc_needs_modeset(new_conn_state->crtc->state))
1109                         continue;
1110
1111                 encoder = new_conn_state->best_encoder;
1112                 funcs = encoder->helper_private;
1113
1114                 DRM_DEBUG_ATOMIC("enabling [ENCODER:%d:%s]\n",
1115                                  encoder->base.id, encoder->name);
1116
1117                 /*
1118                  * Each encoder has at most one connector (since we always steal
1119                  * it away), so we won't call enable hooks twice.
1120                  */
1121                 drm_bridge_pre_enable(encoder->bridge);
1122
1123                 if (funcs) {
1124                         if (funcs->enable)
1125                                 funcs->enable(encoder);
1126                         else if (funcs->commit)
1127                                 funcs->commit(encoder);
1128                 }
1129
1130                 drm_bridge_enable(encoder->bridge);
1131         }
1132 }
1133 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
1134
1135 /**
1136  * drm_atomic_helper_wait_for_fences - wait for fences stashed in plane state
1137  * @dev: DRM device
1138  * @state: atomic state object with old state structures
1139  * @pre_swap: If true, do an interruptible wait, and @state is the new state.
1140  *      Otherwise @state is the old state.
1141  *
1142  * For implicit sync, driver should fish the exclusive fence out from the
1143  * incoming fb's and stash it in the drm_plane_state.  This is called after
1144  * drm_atomic_helper_swap_state() so it uses the current plane state (and
1145  * just uses the atomic state to find the changed planes)
1146  *
1147  * Note that @pre_swap is needed since the point where we block for fences moves
1148  * around depending upon whether an atomic commit is blocking or
1149  * non-blocking. For non-blocking commit all waiting needs to happen after
1150  * drm_atomic_helper_swap_state() is called, but for blocking commits we want
1151  * to wait **before** we do anything that can't be easily rolled back. That is
1152  * before we call drm_atomic_helper_swap_state().
1153  *
1154  * Returns zero if success or < 0 if dma_fence_wait() fails.
1155  */
1156 int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
1157                                       struct drm_atomic_state *state,
1158                                       bool pre_swap)
1159 {
1160         struct drm_plane *plane;
1161         struct drm_plane_state *new_plane_state;
1162         int i, ret;
1163
1164         for_each_new_plane_in_state(state, plane, new_plane_state, i) {
1165                 if (!new_plane_state->fence)
1166                         continue;
1167
1168                 WARN_ON(!new_plane_state->fb);
1169
1170                 /*
1171                  * If waiting for fences pre-swap (ie: nonblock), userspace can
1172                  * still interrupt the operation. Instead of blocking until the
1173                  * timer expires, make the wait interruptible.
1174                  */
1175                 ret = dma_fence_wait(new_plane_state->fence, pre_swap);
1176                 if (ret)
1177                         return ret;
1178
1179                 dma_fence_put(new_plane_state->fence);
1180                 new_plane_state->fence = NULL;
1181         }
1182
1183         return 0;
1184 }
1185 EXPORT_SYMBOL(drm_atomic_helper_wait_for_fences);
1186
1187 /**
1188  * drm_atomic_helper_wait_for_vblanks - wait for vblank on crtcs
1189  * @dev: DRM device
1190  * @old_state: atomic state object with old state structures
1191  *
1192  * Helper to, after atomic commit, wait for vblanks on all effected
1193  * crtcs (ie. before cleaning up old framebuffers using
1194  * drm_atomic_helper_cleanup_planes()). It will only wait on CRTCs where the
1195  * framebuffers have actually changed to optimize for the legacy cursor and
1196  * plane update use-case.
1197  *
1198  * Drivers using the nonblocking commit tracking support initialized by calling
1199  * drm_atomic_helper_setup_commit() should look at
1200  * drm_atomic_helper_wait_for_flip_done() as an alternative.
1201  */
1202 void
1203 drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
1204                 struct drm_atomic_state *old_state)
1205 {
1206         struct drm_crtc *crtc;
1207         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1208         int i, ret;
1209         unsigned crtc_mask = 0;
1210
1211          /*
1212           * Legacy cursor ioctls are completely unsynced, and userspace
1213           * relies on that (by doing tons of cursor updates).
1214           */
1215         if (old_state->legacy_cursor_update)
1216                 return;
1217
1218         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1219                 if (!new_crtc_state->active || !new_crtc_state->planes_changed)
1220                         continue;
1221
1222                 ret = drm_crtc_vblank_get(crtc);
1223                 if (ret != 0)
1224                         continue;
1225
1226                 crtc_mask |= drm_crtc_mask(crtc);
1227                 old_state->crtcs[i].last_vblank_count = drm_crtc_vblank_count(crtc);
1228         }
1229
1230         for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1231                 if (!(crtc_mask & drm_crtc_mask(crtc)))
1232                         continue;
1233
1234                 ret = wait_event_timeout(dev->vblank[i].queue,
1235                                 old_state->crtcs[i].last_vblank_count !=
1236                                         drm_crtc_vblank_count(crtc),
1237                                 msecs_to_jiffies(50));
1238
1239                 WARN(!ret, "[CRTC:%d:%s] vblank wait timed out\n",
1240                      crtc->base.id, crtc->name);
1241
1242                 drm_crtc_vblank_put(crtc);
1243         }
1244 }
1245 EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
1246
1247 /**
1248  * drm_atomic_helper_wait_for_flip_done - wait for all page flips to be done
1249  * @dev: DRM device
1250  * @old_state: atomic state object with old state structures
1251  *
1252  * Helper to, after atomic commit, wait for page flips on all effected
1253  * crtcs (ie. before cleaning up old framebuffers using
1254  * drm_atomic_helper_cleanup_planes()). Compared to
1255  * drm_atomic_helper_wait_for_vblanks() this waits for the completion of on all
1256  * CRTCs, assuming that cursors-only updates are signalling their completion
1257  * immediately (or using a different path).
1258  *
1259  * This requires that drivers use the nonblocking commit tracking support
1260  * initialized using drm_atomic_helper_setup_commit().
1261  */
1262 void drm_atomic_helper_wait_for_flip_done(struct drm_device *dev,
1263                                           struct drm_atomic_state *old_state)
1264 {
1265         struct drm_crtc_state *new_crtc_state;
1266         struct drm_crtc *crtc;
1267         int i;
1268
1269         for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
1270                 struct drm_crtc_commit *commit = new_crtc_state->commit;
1271                 int ret;
1272
1273                 if (!commit)
1274                         continue;
1275
1276                 ret = wait_for_completion_timeout(&commit->flip_done, 10 * HZ);
1277                 if (ret == 0)
1278                         DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n",
1279                                   crtc->base.id, crtc->name);
1280         }
1281 }
1282 EXPORT_SYMBOL(drm_atomic_helper_wait_for_flip_done);
1283
1284 /**
1285  * drm_atomic_helper_commit_tail - commit atomic update to hardware
1286  * @old_state: atomic state object with old state structures
1287  *
1288  * This is the default implementation for the
1289  * &drm_mode_config_helper_funcs.atomic_commit_tail hook, for drivers
1290  * that do not support runtime_pm or do not need the CRTC to be
1291  * enabled to perform a commit. Otherwise, see
1292  * drm_atomic_helper_commit_tail_rpm().
1293  *
1294  * Note that the default ordering of how the various stages are called is to
1295  * match the legacy modeset helper library closest.
1296  */
1297 void drm_atomic_helper_commit_tail(struct drm_atomic_state *old_state)
1298 {
1299         struct drm_device *dev = old_state->dev;
1300
1301         drm_atomic_helper_commit_modeset_disables(dev, old_state);
1302
1303         drm_atomic_helper_commit_planes(dev, old_state, 0);
1304
1305         drm_atomic_helper_commit_modeset_enables(dev, old_state);
1306
1307         drm_atomic_helper_commit_hw_done(old_state);
1308
1309         drm_atomic_helper_wait_for_vblanks(dev, old_state);
1310
1311         drm_atomic_helper_cleanup_planes(dev, old_state);
1312 }
1313 EXPORT_SYMBOL(drm_atomic_helper_commit_tail);
1314
1315 /**
1316  * drm_atomic_helper_commit_tail_rpm - commit atomic update to hardware
1317  * @old_state: new modeset state to be committed
1318  *
1319  * This is an alternative implementation for the
1320  * &drm_mode_config_helper_funcs.atomic_commit_tail hook, for drivers
1321  * that support runtime_pm or need the CRTC to be enabled to perform a
1322  * commit. Otherwise, one should use the default implementation
1323  * drm_atomic_helper_commit_tail().
1324  */
1325 void drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state *old_state)
1326 {
1327         struct drm_device *dev = old_state->dev;
1328
1329         drm_atomic_helper_commit_modeset_disables(dev, old_state);
1330
1331         drm_atomic_helper_commit_modeset_enables(dev, old_state);
1332
1333         drm_atomic_helper_commit_planes(dev, old_state,
1334                                         DRM_PLANE_COMMIT_ACTIVE_ONLY);
1335
1336         drm_atomic_helper_commit_hw_done(old_state);
1337
1338         drm_atomic_helper_wait_for_vblanks(dev, old_state);
1339
1340         drm_atomic_helper_cleanup_planes(dev, old_state);
1341 }
1342 EXPORT_SYMBOL(drm_atomic_helper_commit_tail_rpm);
1343
1344 static void commit_tail(struct drm_atomic_state *old_state)
1345 {
1346         struct drm_device *dev = old_state->dev;
1347         const struct drm_mode_config_helper_funcs *funcs;
1348
1349         funcs = dev->mode_config.helper_private;
1350
1351         drm_atomic_helper_wait_for_fences(dev, old_state, false);
1352
1353         drm_atomic_helper_wait_for_dependencies(old_state);
1354
1355         if (funcs && funcs->atomic_commit_tail)
1356                 funcs->atomic_commit_tail(old_state);
1357         else
1358                 drm_atomic_helper_commit_tail(old_state);
1359
1360         drm_atomic_helper_commit_cleanup_done(old_state);
1361
1362         drm_atomic_state_put(old_state);
1363 }
1364
1365 static void commit_work(struct work_struct *work)
1366 {
1367         struct drm_atomic_state *state = container_of(work,
1368                                                       struct drm_atomic_state,
1369                                                       commit_work);
1370         commit_tail(state);
1371 }
1372
1373 /**
1374  * drm_atomic_helper_async_check - check if state can be commited asynchronously
1375  * @dev: DRM device
1376  * @state: the driver state object
1377  *
1378  * This helper will check if it is possible to commit the state asynchronously.
1379  * Async commits are not supposed to swap the states like normal sync commits
1380  * but just do in-place changes on the current state.
1381  *
1382  * It will return 0 if the commit can happen in an asynchronous fashion or error
1383  * if not. Note that error just mean it can't be commited asynchronously, if it
1384  * fails the commit should be treated like a normal synchronous commit.
1385  */
1386 int drm_atomic_helper_async_check(struct drm_device *dev,
1387                                    struct drm_atomic_state *state)
1388 {
1389         struct drm_crtc *crtc;
1390         struct drm_crtc_state *crtc_state;
1391         struct drm_plane *plane;
1392         struct drm_plane_state *old_plane_state, *new_plane_state;
1393         const struct drm_plane_helper_funcs *funcs;
1394         int i, n_planes = 0;
1395
1396         for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1397                 if (drm_atomic_crtc_needs_modeset(crtc_state))
1398                         return -EINVAL;
1399         }
1400
1401         for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i)
1402                 n_planes++;
1403
1404         /* FIXME: we support only single plane updates for now */
1405         if (n_planes != 1)
1406                 return -EINVAL;
1407
1408         if (!new_plane_state->crtc)
1409                 return -EINVAL;
1410
1411         funcs = plane->helper_private;
1412         if (!funcs->atomic_async_update)
1413                 return -EINVAL;
1414
1415         if (new_plane_state->fence)
1416                 return -EINVAL;
1417
1418         /*
1419          * Don't do an async update if there is an outstanding commit modifying
1420          * the plane.  This prevents our async update's changes from getting
1421          * overridden by a previous synchronous update's state.
1422          */
1423         if (old_plane_state->commit &&
1424             !try_wait_for_completion(&old_plane_state->commit->hw_done))
1425                 return -EBUSY;
1426
1427         return funcs->atomic_async_check(plane, new_plane_state);
1428 }
1429 EXPORT_SYMBOL(drm_atomic_helper_async_check);
1430
1431 /**
1432  * drm_atomic_helper_async_commit - commit state asynchronously
1433  * @dev: DRM device
1434  * @state: the driver state object
1435  *
1436  * This function commits a state asynchronously, i.e., not vblank
1437  * synchronized. It should be used on a state only when
1438  * drm_atomic_async_check() succeeds. Async commits are not supposed to swap
1439  * the states like normal sync commits, but just do in-place changes on the
1440  * current state.
1441  */
1442 void drm_atomic_helper_async_commit(struct drm_device *dev,
1443                                     struct drm_atomic_state *state)
1444 {
1445         struct drm_plane *plane;
1446         struct drm_plane_state *plane_state;
1447         const struct drm_plane_helper_funcs *funcs;
1448         int i;
1449
1450         for_each_new_plane_in_state(state, plane, plane_state, i) {
1451                 funcs = plane->helper_private;
1452                 funcs->atomic_async_update(plane, plane_state);
1453         }
1454 }
1455 EXPORT_SYMBOL(drm_atomic_helper_async_commit);
1456
1457 /**
1458  * drm_atomic_helper_commit - commit validated state object
1459  * @dev: DRM device
1460  * @state: the driver state object
1461  * @nonblock: whether nonblocking behavior is requested.
1462  *
1463  * This function commits a with drm_atomic_helper_check() pre-validated state
1464  * object. This can still fail when e.g. the framebuffer reservation fails. This
1465  * function implements nonblocking commits, using
1466  * drm_atomic_helper_setup_commit() and related functions.
1467  *
1468  * Committing the actual hardware state is done through the
1469  * &drm_mode_config_helper_funcs.atomic_commit_tail callback, or it's default
1470  * implementation drm_atomic_helper_commit_tail().
1471  *
1472  * RETURNS:
1473  * Zero for success or -errno.
1474  */
1475 int drm_atomic_helper_commit(struct drm_device *dev,
1476                              struct drm_atomic_state *state,
1477                              bool nonblock)
1478 {
1479         int ret;
1480
1481         if (state->async_update) {
1482                 ret = drm_atomic_helper_prepare_planes(dev, state);
1483                 if (ret)
1484                         return ret;
1485
1486                 drm_atomic_helper_async_commit(dev, state);
1487                 drm_atomic_helper_cleanup_planes(dev, state);
1488
1489                 return 0;
1490         }
1491
1492         ret = drm_atomic_helper_setup_commit(state, nonblock);
1493         if (ret)
1494                 return ret;
1495
1496         INIT_WORK(&state->commit_work, commit_work);
1497
1498         ret = drm_atomic_helper_prepare_planes(dev, state);
1499         if (ret)
1500                 return ret;
1501
1502         if (!nonblock) {
1503                 ret = drm_atomic_helper_wait_for_fences(dev, state, true);
1504                 if (ret)
1505                         goto err;
1506         }
1507
1508         /*
1509          * This is the point of no return - everything below never fails except
1510          * when the hw goes bonghits. Which means we can commit the new state on
1511          * the software side now.
1512          */
1513
1514         ret = drm_atomic_helper_swap_state(state, true);
1515         if (ret)
1516                 goto err;
1517
1518         /*
1519          * Everything below can be run asynchronously without the need to grab
1520          * any modeset locks at all under one condition: It must be guaranteed
1521          * that the asynchronous work has either been cancelled (if the driver
1522          * supports it, which at least requires that the framebuffers get
1523          * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
1524          * before the new state gets committed on the software side with
1525          * drm_atomic_helper_swap_state().
1526          *
1527          * This scheme allows new atomic state updates to be prepared and
1528          * checked in parallel to the asynchronous completion of the previous
1529          * update. Which is important since compositors need to figure out the
1530          * composition of the next frame right after having submitted the
1531          * current layout.
1532          *
1533          * NOTE: Commit work has multiple phases, first hardware commit, then
1534          * cleanup. We want them to overlap, hence need system_unbound_wq to
1535          * make sure work items don't artifically stall on each another.
1536          */
1537
1538         drm_atomic_state_get(state);
1539         if (nonblock)
1540                 queue_work(system_unbound_wq, &state->commit_work);
1541         else
1542                 commit_tail(state);
1543
1544         return 0;
1545
1546 err:
1547         drm_atomic_helper_cleanup_planes(dev, state);
1548         return ret;
1549 }
1550 EXPORT_SYMBOL(drm_atomic_helper_commit);
1551
1552 /**
1553  * DOC: implementing nonblocking commit
1554  *
1555  * Nonblocking atomic commits have to be implemented in the following sequence:
1556  *
1557  * 1. Run drm_atomic_helper_prepare_planes() first. This is the only function
1558  * which commit needs to call which can fail, so we want to run it first and
1559  * synchronously.
1560  *
1561  * 2. Synchronize with any outstanding nonblocking commit worker threads which
1562  * might be affected the new state update. This can be done by either cancelling
1563  * or flushing the work items, depending upon whether the driver can deal with
1564  * cancelled updates. Note that it is important to ensure that the framebuffer
1565  * cleanup is still done when cancelling.
1566  *
1567  * Asynchronous workers need to have sufficient parallelism to be able to run
1568  * different atomic commits on different CRTCs in parallel. The simplest way to
1569  * achive this is by running them on the &system_unbound_wq work queue. Note
1570  * that drivers are not required to split up atomic commits and run an
1571  * individual commit in parallel - userspace is supposed to do that if it cares.
1572  * But it might be beneficial to do that for modesets, since those necessarily
1573  * must be done as one global operation, and enabling or disabling a CRTC can
1574  * take a long time. But even that is not required.
1575  *
1576  * 3. The software state is updated synchronously with
1577  * drm_atomic_helper_swap_state(). Doing this under the protection of all modeset
1578  * locks means concurrent callers never see inconsistent state. And doing this
1579  * while it's guaranteed that no relevant nonblocking worker runs means that
1580  * nonblocking workers do not need grab any locks. Actually they must not grab
1581  * locks, for otherwise the work flushing will deadlock.
1582  *
1583  * 4. Schedule a work item to do all subsequent steps, using the split-out
1584  * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
1585  * then cleaning up the framebuffers after the old framebuffer is no longer
1586  * being displayed.
1587  *
1588  * The above scheme is implemented in the atomic helper libraries in
1589  * drm_atomic_helper_commit() using a bunch of helper functions. See
1590  * drm_atomic_helper_setup_commit() for a starting point.
1591  */
1592
1593 static int stall_checks(struct drm_crtc *crtc, bool nonblock)
1594 {
1595         struct drm_crtc_commit *commit, *stall_commit = NULL;
1596         bool completed = true;
1597         int i;
1598         long ret = 0;
1599
1600         spin_lock(&crtc->commit_lock);
1601         i = 0;
1602         list_for_each_entry(commit, &crtc->commit_list, commit_entry) {
1603                 if (i == 0) {
1604                         completed = try_wait_for_completion(&commit->flip_done);
1605                         /* Userspace is not allowed to get ahead of the previous
1606                          * commit with nonblocking ones. */
1607                         if (!completed && nonblock) {
1608                                 spin_unlock(&crtc->commit_lock);
1609                                 return -EBUSY;
1610                         }
1611                 } else if (i == 1) {
1612                         stall_commit = drm_crtc_commit_get(commit);
1613                         break;
1614                 }
1615
1616                 i++;
1617         }
1618         spin_unlock(&crtc->commit_lock);
1619
1620         if (!stall_commit)
1621                 return 0;
1622
1623         /* We don't want to let commits get ahead of cleanup work too much,
1624          * stalling on 2nd previous commit means triple-buffer won't ever stall.
1625          */
1626         ret = wait_for_completion_interruptible_timeout(&stall_commit->cleanup_done,
1627                                                         10*HZ);
1628         if (ret == 0)
1629                 DRM_ERROR("[CRTC:%d:%s] cleanup_done timed out\n",
1630                           crtc->base.id, crtc->name);
1631
1632         drm_crtc_commit_put(stall_commit);
1633
1634         return ret < 0 ? ret : 0;
1635 }
1636
1637 static void release_crtc_commit(struct completion *completion)
1638 {
1639         struct drm_crtc_commit *commit = container_of(completion,
1640                                                       typeof(*commit),
1641                                                       flip_done);
1642
1643         drm_crtc_commit_put(commit);
1644 }
1645
1646 static void init_commit(struct drm_crtc_commit *commit, struct drm_crtc *crtc)
1647 {
1648         init_completion(&commit->flip_done);
1649         init_completion(&commit->hw_done);
1650         init_completion(&commit->cleanup_done);
1651         INIT_LIST_HEAD(&commit->commit_entry);
1652         kref_init(&commit->ref);
1653         commit->crtc = crtc;
1654 }
1655
1656 static struct drm_crtc_commit *
1657 crtc_or_fake_commit(struct drm_atomic_state *state, struct drm_crtc *crtc)
1658 {
1659         if (crtc) {
1660                 struct drm_crtc_state *new_crtc_state;
1661
1662                 new_crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
1663
1664                 return new_crtc_state->commit;
1665         }
1666
1667         if (!state->fake_commit) {
1668                 state->fake_commit = kzalloc(sizeof(*state->fake_commit), GFP_KERNEL);
1669                 if (!state->fake_commit)
1670                         return NULL;
1671
1672                 init_commit(state->fake_commit, NULL);
1673         }
1674
1675         return state->fake_commit;
1676 }
1677
1678 /**
1679  * drm_atomic_helper_setup_commit - setup possibly nonblocking commit
1680  * @state: new modeset state to be committed
1681  * @nonblock: whether nonblocking behavior is requested.
1682  *
1683  * This function prepares @state to be used by the atomic helper's support for
1684  * nonblocking commits. Drivers using the nonblocking commit infrastructure
1685  * should always call this function from their
1686  * &drm_mode_config_funcs.atomic_commit hook.
1687  *
1688  * To be able to use this support drivers need to use a few more helper
1689  * functions. drm_atomic_helper_wait_for_dependencies() must be called before
1690  * actually committing the hardware state, and for nonblocking commits this call
1691  * must be placed in the async worker. See also drm_atomic_helper_swap_state()
1692  * and it's stall parameter, for when a driver's commit hooks look at the
1693  * &drm_crtc.state, &drm_plane.state or &drm_connector.state pointer directly.
1694  *
1695  * Completion of the hardware commit step must be signalled using
1696  * drm_atomic_helper_commit_hw_done(). After this step the driver is not allowed
1697  * to read or change any permanent software or hardware modeset state. The only
1698  * exception is state protected by other means than &drm_modeset_lock locks.
1699  * Only the free standing @state with pointers to the old state structures can
1700  * be inspected, e.g. to clean up old buffers using
1701  * drm_atomic_helper_cleanup_planes().
1702  *
1703  * At the very end, before cleaning up @state drivers must call
1704  * drm_atomic_helper_commit_cleanup_done().
1705  *
1706  * This is all implemented by in drm_atomic_helper_commit(), giving drivers a
1707  * complete and esay-to-use default implementation of the atomic_commit() hook.
1708  *
1709  * The tracking of asynchronously executed and still pending commits is done
1710  * using the core structure &drm_crtc_commit.
1711  *
1712  * By default there's no need to clean up resources allocated by this function
1713  * explicitly: drm_atomic_state_default_clear() will take care of that
1714  * automatically.
1715  *
1716  * Returns:
1717  *
1718  * 0 on success. -EBUSY when userspace schedules nonblocking commits too fast,
1719  * -ENOMEM on allocation failures and -EINTR when a signal is pending.
1720  */
1721 int drm_atomic_helper_setup_commit(struct drm_atomic_state *state,
1722                                    bool nonblock)
1723 {
1724         struct drm_crtc *crtc;
1725         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1726         struct drm_connector *conn;
1727         struct drm_connector_state *old_conn_state, *new_conn_state;
1728         struct drm_plane *plane;
1729         struct drm_plane_state *old_plane_state, *new_plane_state;
1730         struct drm_crtc_commit *commit;
1731         int i, ret;
1732
1733         for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
1734                 commit = kzalloc(sizeof(*commit), GFP_KERNEL);
1735                 if (!commit)
1736                         return -ENOMEM;
1737
1738                 init_commit(commit, crtc);
1739
1740                 new_crtc_state->commit = commit;
1741
1742                 ret = stall_checks(crtc, nonblock);
1743                 if (ret)
1744                         return ret;
1745
1746                 /* Drivers only send out events when at least either current or
1747                  * new CRTC state is active. Complete right away if everything
1748                  * stays off. */
1749                 if (!old_crtc_state->active && !new_crtc_state->active) {
1750                         complete_all(&commit->flip_done);
1751                         continue;
1752                 }
1753
1754                 /* Legacy cursor updates are fully unsynced. */
1755                 if (state->legacy_cursor_update) {
1756                         complete_all(&commit->flip_done);
1757                         continue;
1758                 }
1759
1760                 if (!new_crtc_state->event) {
1761                         commit->event = kzalloc(sizeof(*commit->event),
1762                                                 GFP_KERNEL);
1763                         if (!commit->event)
1764                                 return -ENOMEM;
1765
1766                         new_crtc_state->event = commit->event;
1767                 }
1768
1769                 new_crtc_state->event->base.completion = &commit->flip_done;
1770                 new_crtc_state->event->base.completion_release = release_crtc_commit;
1771                 drm_crtc_commit_get(commit);
1772         }
1773
1774         for_each_oldnew_connector_in_state(state, conn, old_conn_state, new_conn_state, i) {
1775                 /* commit tracked through new_crtc_state->commit, no need to do it explicitly */
1776                 if (new_conn_state->crtc)
1777                         continue;
1778
1779                 /* Userspace is not allowed to get ahead of the previous
1780                  * commit with nonblocking ones. */
1781                 if (nonblock && old_conn_state->commit &&
1782                     !try_wait_for_completion(&old_conn_state->commit->flip_done))
1783                         return -EBUSY;
1784
1785                 commit = crtc_or_fake_commit(state, old_conn_state->crtc);
1786                 if (!commit)
1787                         return -ENOMEM;
1788
1789                 new_conn_state->commit = drm_crtc_commit_get(commit);
1790         }
1791
1792         for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
1793                 /*
1794                  * Unlike connectors, always track planes explicitly for
1795                  * async pageflip support.
1796                  */
1797
1798                 /* Userspace is not allowed to get ahead of the previous
1799                  * commit with nonblocking ones. */
1800                 if (nonblock && old_plane_state->commit &&
1801                     !try_wait_for_completion(&old_plane_state->commit->flip_done))
1802                         return -EBUSY;
1803
1804                 commit = crtc_or_fake_commit(state, old_plane_state->crtc);
1805                 if (!commit)
1806                         return -ENOMEM;
1807
1808                 new_plane_state->commit = drm_crtc_commit_get(commit);
1809         }
1810
1811         return 0;
1812 }
1813 EXPORT_SYMBOL(drm_atomic_helper_setup_commit);
1814
1815 /**
1816  * drm_atomic_helper_wait_for_dependencies - wait for required preceeding commits
1817  * @old_state: atomic state object with old state structures
1818  *
1819  * This function waits for all preceeding commits that touch the same CRTC as
1820  * @old_state to both be committed to the hardware (as signalled by
1821  * drm_atomic_helper_commit_hw_done) and executed by the hardware (as signalled
1822  * by calling drm_crtc_vblank_send_event() on the &drm_crtc_state.event).
1823  *
1824  * This is part of the atomic helper support for nonblocking commits, see
1825  * drm_atomic_helper_setup_commit() for an overview.
1826  */
1827 void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *old_state)
1828 {
1829         struct drm_crtc *crtc;
1830         struct drm_crtc_state *old_crtc_state;
1831         struct drm_plane *plane;
1832         struct drm_plane_state *old_plane_state;
1833         struct drm_connector *conn;
1834         struct drm_connector_state *old_conn_state;
1835         struct drm_crtc_commit *commit;
1836         int i;
1837         long ret;
1838
1839         for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1840                 commit = old_crtc_state->commit;
1841
1842                 if (!commit)
1843                         continue;
1844
1845                 ret = wait_for_completion_timeout(&commit->hw_done,
1846                                                   10*HZ);
1847                 if (ret == 0)
1848                         DRM_ERROR("[CRTC:%d:%s] hw_done timed out\n",
1849                                   crtc->base.id, crtc->name);
1850
1851                 /* Currently no support for overwriting flips, hence
1852                  * stall for previous one to execute completely. */
1853                 ret = wait_for_completion_timeout(&commit->flip_done,
1854                                                   10*HZ);
1855                 if (ret == 0)
1856                         DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n",
1857                                   crtc->base.id, crtc->name);
1858         }
1859
1860         for_each_old_connector_in_state(old_state, conn, old_conn_state, i) {
1861                 commit = old_conn_state->commit;
1862
1863                 if (!commit)
1864                         continue;
1865
1866                 ret = wait_for_completion_timeout(&commit->hw_done,
1867                                                   10*HZ);
1868                 if (ret == 0)
1869                         DRM_ERROR("[CONNECTOR:%d:%s] hw_done timed out\n",
1870                                   conn->base.id, conn->name);
1871
1872                 /* Currently no support for overwriting flips, hence
1873                  * stall for previous one to execute completely. */
1874                 ret = wait_for_completion_timeout(&commit->flip_done,
1875                                                   10*HZ);
1876                 if (ret == 0)
1877                         DRM_ERROR("[CONNECTOR:%d:%s] flip_done timed out\n",
1878                                   conn->base.id, conn->name);
1879         }
1880
1881         for_each_old_plane_in_state(old_state, plane, old_plane_state, i) {
1882                 commit = old_plane_state->commit;
1883
1884                 if (!commit)
1885                         continue;
1886
1887                 ret = wait_for_completion_timeout(&commit->hw_done,
1888                                                   10*HZ);
1889                 if (ret == 0)
1890                         DRM_ERROR("[PLANE:%d:%s] hw_done timed out\n",
1891                                   plane->base.id, plane->name);
1892
1893                 /* Currently no support for overwriting flips, hence
1894                  * stall for previous one to execute completely. */
1895                 ret = wait_for_completion_timeout(&commit->flip_done,
1896                                                   10*HZ);
1897                 if (ret == 0)
1898                         DRM_ERROR("[PLANE:%d:%s] flip_done timed out\n",
1899                                   plane->base.id, plane->name);
1900         }
1901 }
1902 EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies);
1903
1904 /**
1905  * drm_atomic_helper_commit_hw_done - setup possible nonblocking commit
1906  * @old_state: atomic state object with old state structures
1907  *
1908  * This function is used to signal completion of the hardware commit step. After
1909  * this step the driver is not allowed to read or change any permanent software
1910  * or hardware modeset state. The only exception is state protected by other
1911  * means than &drm_modeset_lock locks.
1912  *
1913  * Drivers should try to postpone any expensive or delayed cleanup work after
1914  * this function is called.
1915  *
1916  * This is part of the atomic helper support for nonblocking commits, see
1917  * drm_atomic_helper_setup_commit() for an overview.
1918  */
1919 void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *old_state)
1920 {
1921         struct drm_crtc *crtc;
1922         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1923         struct drm_crtc_commit *commit;
1924         int i;
1925
1926         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1927                 commit = new_crtc_state->commit;
1928                 if (!commit)
1929                         continue;
1930
1931                 /*
1932                  * copy new_crtc_state->commit to old_crtc_state->commit,
1933                  * it's unsafe to touch new_crtc_state after hw_done,
1934                  * but we still need to do so in cleanup_done().
1935                  */
1936                 if (old_crtc_state->commit)
1937                         drm_crtc_commit_put(old_crtc_state->commit);
1938
1939                 old_crtc_state->commit = drm_crtc_commit_get(commit);
1940
1941                 /* backend must have consumed any event by now */
1942                 WARN_ON(new_crtc_state->event);
1943                 complete_all(&commit->hw_done);
1944         }
1945
1946         if (old_state->fake_commit) {
1947                 complete_all(&old_state->fake_commit->hw_done);
1948                 complete_all(&old_state->fake_commit->flip_done);
1949         }
1950 }
1951 EXPORT_SYMBOL(drm_atomic_helper_commit_hw_done);
1952
1953 /**
1954  * drm_atomic_helper_commit_cleanup_done - signal completion of commit
1955  * @old_state: atomic state object with old state structures
1956  *
1957  * This signals completion of the atomic update @old_state, including any
1958  * cleanup work. If used, it must be called right before calling
1959  * drm_atomic_state_put().
1960  *
1961  * This is part of the atomic helper support for nonblocking commits, see
1962  * drm_atomic_helper_setup_commit() for an overview.
1963  */
1964 void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *old_state)
1965 {
1966         struct drm_crtc *crtc;
1967         struct drm_crtc_state *old_crtc_state;
1968         struct drm_crtc_commit *commit;
1969         int i;
1970
1971         for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1972                 commit = old_crtc_state->commit;
1973                 if (WARN_ON(!commit))
1974                         continue;
1975
1976                 complete_all(&commit->cleanup_done);
1977                 WARN_ON(!try_wait_for_completion(&commit->hw_done));
1978
1979                 spin_lock(&crtc->commit_lock);
1980                 list_del(&commit->commit_entry);
1981                 spin_unlock(&crtc->commit_lock);
1982         }
1983
1984         if (old_state->fake_commit)
1985                 complete_all(&old_state->fake_commit->cleanup_done);
1986 }
1987 EXPORT_SYMBOL(drm_atomic_helper_commit_cleanup_done);
1988
1989 /**
1990  * drm_atomic_helper_prepare_planes - prepare plane resources before commit
1991  * @dev: DRM device
1992  * @state: atomic state object with new state structures
1993  *
1994  * This function prepares plane state, specifically framebuffers, for the new
1995  * configuration, by calling &drm_plane_helper_funcs.prepare_fb. If any failure
1996  * is encountered this function will call &drm_plane_helper_funcs.cleanup_fb on
1997  * any already successfully prepared framebuffer.
1998  *
1999  * Returns:
2000  * 0 on success, negative error code on failure.
2001  */
2002 int drm_atomic_helper_prepare_planes(struct drm_device *dev,
2003                                      struct drm_atomic_state *state)
2004 {
2005         struct drm_plane *plane;
2006         struct drm_plane_state *new_plane_state;
2007         int ret, i, j;
2008
2009         for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2010                 const struct drm_plane_helper_funcs *funcs;
2011
2012                 funcs = plane->helper_private;
2013
2014                 if (funcs->prepare_fb) {
2015                         ret = funcs->prepare_fb(plane, new_plane_state);
2016                         if (ret)
2017                                 goto fail;
2018                 }
2019         }
2020
2021         return 0;
2022
2023 fail:
2024         for_each_new_plane_in_state(state, plane, new_plane_state, j) {
2025                 const struct drm_plane_helper_funcs *funcs;
2026
2027                 if (j >= i)
2028                         continue;
2029
2030                 funcs = plane->helper_private;
2031
2032                 if (funcs->cleanup_fb)
2033                         funcs->cleanup_fb(plane, new_plane_state);
2034         }
2035
2036         return ret;
2037 }
2038 EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
2039
2040 static bool plane_crtc_active(const struct drm_plane_state *state)
2041 {
2042         return state->crtc && state->crtc->state->active;
2043 }
2044
2045 /**
2046  * drm_atomic_helper_commit_planes - commit plane state
2047  * @dev: DRM device
2048  * @old_state: atomic state object with old state structures
2049  * @flags: flags for committing plane state
2050  *
2051  * This function commits the new plane state using the plane and atomic helper
2052  * functions for planes and crtcs. It assumes that the atomic state has already
2053  * been pushed into the relevant object state pointers, since this step can no
2054  * longer fail.
2055  *
2056  * It still requires the global state object @old_state to know which planes and
2057  * crtcs need to be updated though.
2058  *
2059  * Note that this function does all plane updates across all CRTCs in one step.
2060  * If the hardware can't support this approach look at
2061  * drm_atomic_helper_commit_planes_on_crtc() instead.
2062  *
2063  * Plane parameters can be updated by applications while the associated CRTC is
2064  * disabled. The DRM/KMS core will store the parameters in the plane state,
2065  * which will be available to the driver when the CRTC is turned on. As a result
2066  * most drivers don't need to be immediately notified of plane updates for a
2067  * disabled CRTC.
2068  *
2069  * Unless otherwise needed, drivers are advised to set the ACTIVE_ONLY flag in
2070  * @flags in order not to receive plane update notifications related to a
2071  * disabled CRTC. This avoids the need to manually ignore plane updates in
2072  * driver code when the driver and/or hardware can't or just don't need to deal
2073  * with updates on disabled CRTCs, for example when supporting runtime PM.
2074  *
2075  * Drivers may set the NO_DISABLE_AFTER_MODESET flag in @flags if the relevant
2076  * display controllers require to disable a CRTC's planes when the CRTC is
2077  * disabled. This function would skip the &drm_plane_helper_funcs.atomic_disable
2078  * call for a plane if the CRTC of the old plane state needs a modesetting
2079  * operation. Of course, the drivers need to disable the planes in their CRTC
2080  * disable callbacks since no one else would do that.
2081  *
2082  * The drm_atomic_helper_commit() default implementation doesn't set the
2083  * ACTIVE_ONLY flag to most closely match the behaviour of the legacy helpers.
2084  * This should not be copied blindly by drivers.
2085  */
2086 void drm_atomic_helper_commit_planes(struct drm_device *dev,
2087                                      struct drm_atomic_state *old_state,
2088                                      uint32_t flags)
2089 {
2090         struct drm_crtc *crtc;
2091         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2092         struct drm_plane *plane;
2093         struct drm_plane_state *old_plane_state, *new_plane_state;
2094         int i;
2095         bool active_only = flags & DRM_PLANE_COMMIT_ACTIVE_ONLY;
2096         bool no_disable = flags & DRM_PLANE_COMMIT_NO_DISABLE_AFTER_MODESET;
2097
2098         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2099                 const struct drm_crtc_helper_funcs *funcs;
2100
2101                 funcs = crtc->helper_private;
2102
2103                 if (!funcs || !funcs->atomic_begin)
2104                         continue;
2105
2106                 if (active_only && !new_crtc_state->active)
2107                         continue;
2108
2109                 funcs->atomic_begin(crtc, old_crtc_state);
2110         }
2111
2112         for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2113                 const struct drm_plane_helper_funcs *funcs;
2114                 bool disabling;
2115
2116                 funcs = plane->helper_private;
2117
2118                 if (!funcs)
2119                         continue;
2120
2121                 disabling = drm_atomic_plane_disabling(old_plane_state,
2122                                                        new_plane_state);
2123
2124                 if (active_only) {
2125                         /*
2126                          * Skip planes related to inactive CRTCs. If the plane
2127                          * is enabled use the state of the current CRTC. If the
2128                          * plane is being disabled use the state of the old
2129                          * CRTC to avoid skipping planes being disabled on an
2130                          * active CRTC.
2131                          */
2132                         if (!disabling && !plane_crtc_active(new_plane_state))
2133                                 continue;
2134                         if (disabling && !plane_crtc_active(old_plane_state))
2135                                 continue;
2136                 }
2137
2138                 /*
2139                  * Special-case disabling the plane if drivers support it.
2140                  */
2141                 if (disabling && funcs->atomic_disable) {
2142                         struct drm_crtc_state *crtc_state;
2143
2144                         crtc_state = old_plane_state->crtc->state;
2145
2146                         if (drm_atomic_crtc_needs_modeset(crtc_state) &&
2147                             no_disable)
2148                                 continue;
2149
2150                         funcs->atomic_disable(plane, old_plane_state);
2151                 } else if (new_plane_state->crtc || disabling) {
2152                         funcs->atomic_update(plane, old_plane_state);
2153                 }
2154         }
2155
2156         for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2157                 const struct drm_crtc_helper_funcs *funcs;
2158
2159                 funcs = crtc->helper_private;
2160
2161                 if (!funcs || !funcs->atomic_flush)
2162                         continue;
2163
2164                 if (active_only && !new_crtc_state->active)
2165                         continue;
2166
2167                 funcs->atomic_flush(crtc, old_crtc_state);
2168         }
2169 }
2170 EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
2171
2172 /**
2173  * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a crtc
2174  * @old_crtc_state: atomic state object with the old crtc state
2175  *
2176  * This function commits the new plane state using the plane and atomic helper
2177  * functions for planes on the specific crtc. It assumes that the atomic state
2178  * has already been pushed into the relevant object state pointers, since this
2179  * step can no longer fail.
2180  *
2181  * This function is useful when plane updates should be done crtc-by-crtc
2182  * instead of one global step like drm_atomic_helper_commit_planes() does.
2183  *
2184  * This function can only be savely used when planes are not allowed to move
2185  * between different CRTCs because this function doesn't handle inter-CRTC
2186  * depencies. Callers need to ensure that either no such depencies exist,
2187  * resolve them through ordering of commit calls or through some other means.
2188  */
2189 void
2190 drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state)
2191 {
2192         const struct drm_crtc_helper_funcs *crtc_funcs;
2193         struct drm_crtc *crtc = old_crtc_state->crtc;
2194         struct drm_atomic_state *old_state = old_crtc_state->state;
2195         struct drm_plane *plane;
2196         unsigned plane_mask;
2197
2198         plane_mask = old_crtc_state->plane_mask;
2199         plane_mask |= crtc->state->plane_mask;
2200
2201         crtc_funcs = crtc->helper_private;
2202         if (crtc_funcs && crtc_funcs->atomic_begin)
2203                 crtc_funcs->atomic_begin(crtc, old_crtc_state);
2204
2205         drm_for_each_plane_mask(plane, crtc->dev, plane_mask) {
2206                 struct drm_plane_state *old_plane_state =
2207                         drm_atomic_get_old_plane_state(old_state, plane);
2208                 const struct drm_plane_helper_funcs *plane_funcs;
2209
2210                 plane_funcs = plane->helper_private;
2211
2212                 if (!old_plane_state || !plane_funcs)
2213                         continue;
2214
2215                 WARN_ON(plane->state->crtc && plane->state->crtc != crtc);
2216
2217                 if (drm_atomic_plane_disabling(old_plane_state, plane->state) &&
2218                     plane_funcs->atomic_disable)
2219                         plane_funcs->atomic_disable(plane, old_plane_state);
2220                 else if (plane->state->crtc ||
2221                          drm_atomic_plane_disabling(old_plane_state, plane->state))
2222                         plane_funcs->atomic_update(plane, old_plane_state);
2223         }
2224
2225         if (crtc_funcs && crtc_funcs->atomic_flush)
2226                 crtc_funcs->atomic_flush(crtc, old_crtc_state);
2227 }
2228 EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc);
2229
2230 /**
2231  * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes
2232  * @old_crtc_state: atomic state object with the old CRTC state
2233  * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks
2234  *
2235  * Disables all planes associated with the given CRTC. This can be
2236  * used for instance in the CRTC helper atomic_disable callback to disable
2237  * all planes.
2238  *
2239  * If the atomic-parameter is set the function calls the CRTC's
2240  * atomic_begin hook before and atomic_flush hook after disabling the
2241  * planes.
2242  *
2243  * It is a bug to call this function without having implemented the
2244  * &drm_plane_helper_funcs.atomic_disable plane hook.
2245  */
2246 void
2247 drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state *old_crtc_state,
2248                                          bool atomic)
2249 {
2250         struct drm_crtc *crtc = old_crtc_state->crtc;
2251         const struct drm_crtc_helper_funcs *crtc_funcs =
2252                 crtc->helper_private;
2253         struct drm_plane *plane;
2254
2255         if (atomic && crtc_funcs && crtc_funcs->atomic_begin)
2256                 crtc_funcs->atomic_begin(crtc, NULL);
2257
2258         drm_atomic_crtc_state_for_each_plane(plane, old_crtc_state) {
2259                 const struct drm_plane_helper_funcs *plane_funcs =
2260                         plane->helper_private;
2261
2262                 if (!plane_funcs)
2263                         continue;
2264
2265                 WARN_ON(!plane_funcs->atomic_disable);
2266                 if (plane_funcs->atomic_disable)
2267                         plane_funcs->atomic_disable(plane, NULL);
2268         }
2269
2270         if (atomic && crtc_funcs && crtc_funcs->atomic_flush)
2271                 crtc_funcs->atomic_flush(crtc, NULL);
2272 }
2273 EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc);
2274
2275 /**
2276  * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
2277  * @dev: DRM device
2278  * @old_state: atomic state object with old state structures
2279  *
2280  * This function cleans up plane state, specifically framebuffers, from the old
2281  * configuration. Hence the old configuration must be perserved in @old_state to
2282  * be able to call this function.
2283  *
2284  * This function must also be called on the new state when the atomic update
2285  * fails at any point after calling drm_atomic_helper_prepare_planes().
2286  */
2287 void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
2288                                       struct drm_atomic_state *old_state)
2289 {
2290         struct drm_plane *plane;
2291         struct drm_plane_state *old_plane_state, *new_plane_state;
2292         int i;
2293
2294         for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2295                 const struct drm_plane_helper_funcs *funcs;
2296                 struct drm_plane_state *plane_state;
2297
2298                 /*
2299                  * This might be called before swapping when commit is aborted,
2300                  * in which case we have to cleanup the new state.
2301                  */
2302                 if (old_plane_state == plane->state)
2303                         plane_state = new_plane_state;
2304                 else
2305                         plane_state = old_plane_state;
2306
2307                 funcs = plane->helper_private;
2308
2309                 if (funcs->cleanup_fb)
2310                         funcs->cleanup_fb(plane, plane_state);
2311         }
2312 }
2313 EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
2314
2315 /**
2316  * drm_atomic_helper_swap_state - store atomic state into current sw state
2317  * @state: atomic state
2318  * @stall: stall for preceeding commits
2319  *
2320  * This function stores the atomic state into the current state pointers in all
2321  * driver objects. It should be called after all failing steps have been done
2322  * and succeeded, but before the actual hardware state is committed.
2323  *
2324  * For cleanup and error recovery the current state for all changed objects will
2325  * be swapped into @state.
2326  *
2327  * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
2328  *
2329  * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
2330  *
2331  * 2. Do any other steps that might fail.
2332  *
2333  * 3. Put the staged state into the current state pointers with this function.
2334  *
2335  * 4. Actually commit the hardware state.
2336  *
2337  * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3
2338  * contains the old state. Also do any other cleanup required with that state.
2339  *
2340  * @stall must be set when nonblocking commits for this driver directly access
2341  * the &drm_plane.state, &drm_crtc.state or &drm_connector.state pointer. With
2342  * the current atomic helpers this is almost always the case, since the helpers
2343  * don't pass the right state structures to the callbacks.
2344  *
2345  * Returns:
2346  *
2347  * Returns 0 on success. Can return -ERESTARTSYS when @stall is true and the
2348  * waiting for the previous commits has been interrupted.
2349  */
2350 int drm_atomic_helper_swap_state(struct drm_atomic_state *state,
2351                                   bool stall)
2352 {
2353         int i, ret;
2354         struct drm_connector *connector;
2355         struct drm_connector_state *old_conn_state, *new_conn_state;
2356         struct drm_crtc *crtc;
2357         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2358         struct drm_plane *plane;
2359         struct drm_plane_state *old_plane_state, *new_plane_state;
2360         struct drm_crtc_commit *commit;
2361         struct drm_private_obj *obj;
2362         struct drm_private_state *old_obj_state, *new_obj_state;
2363
2364         if (stall) {
2365                 /*
2366                  * We have to stall for hw_done here before
2367                  * drm_atomic_helper_wait_for_dependencies() because flip
2368                  * depth > 1 is not yet supported by all drivers. As long as
2369                  * obj->state is directly dereferenced anywhere in the drivers
2370                  * atomic_commit_tail function, then it's unsafe to swap state
2371                  * before drm_atomic_helper_commit_hw_done() is called.
2372                  */
2373
2374                 for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) {
2375                         commit = old_crtc_state->commit;
2376
2377                         if (!commit)
2378                                 continue;
2379
2380                         ret = wait_for_completion_interruptible(&commit->hw_done);
2381                         if (ret)
2382                                 return ret;
2383                 }
2384
2385                 for_each_old_connector_in_state(state, connector, old_conn_state, i) {
2386                         commit = old_conn_state->commit;
2387
2388                         if (!commit)
2389                                 continue;
2390
2391                         ret = wait_for_completion_interruptible(&commit->hw_done);
2392                         if (ret)
2393                                 return ret;
2394                 }
2395
2396                 for_each_old_plane_in_state(state, plane, old_plane_state, i) {
2397                         commit = old_plane_state->commit;
2398
2399                         if (!commit)
2400                                 continue;
2401
2402                         ret = wait_for_completion_interruptible(&commit->hw_done);
2403                         if (ret)
2404                                 return ret;
2405                 }
2406         }
2407
2408         for_each_oldnew_connector_in_state(state, connector, old_conn_state, new_conn_state, i) {
2409                 WARN_ON(connector->state != old_conn_state);
2410
2411                 old_conn_state->state = state;
2412                 new_conn_state->state = NULL;
2413
2414                 state->connectors[i].state = old_conn_state;
2415                 connector->state = new_conn_state;
2416         }
2417
2418         for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
2419                 WARN_ON(crtc->state != old_crtc_state);
2420
2421                 old_crtc_state->state = state;
2422                 new_crtc_state->state = NULL;
2423
2424                 state->crtcs[i].state = old_crtc_state;
2425                 crtc->state = new_crtc_state;
2426
2427                 if (new_crtc_state->commit) {
2428                         spin_lock(&crtc->commit_lock);
2429                         list_add(&new_crtc_state->commit->commit_entry,
2430                                  &crtc->commit_list);
2431                         spin_unlock(&crtc->commit_lock);
2432
2433                         new_crtc_state->commit->event = NULL;
2434                 }
2435         }
2436
2437         for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
2438                 WARN_ON(plane->state != old_plane_state);
2439
2440                 old_plane_state->state = state;
2441                 new_plane_state->state = NULL;
2442
2443                 state->planes[i].state = old_plane_state;
2444                 plane->state = new_plane_state;
2445         }
2446
2447         for_each_oldnew_private_obj_in_state(state, obj, old_obj_state, new_obj_state, i) {
2448                 WARN_ON(obj->state != old_obj_state);
2449
2450                 old_obj_state->state = state;
2451                 new_obj_state->state = NULL;
2452
2453                 state->private_objs[i].state = old_obj_state;
2454                 obj->state = new_obj_state;
2455         }
2456
2457         return 0;
2458 }
2459 EXPORT_SYMBOL(drm_atomic_helper_swap_state);
2460
2461 /**
2462  * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
2463  * @plane: plane object to update
2464  * @crtc: owning CRTC of owning plane
2465  * @fb: framebuffer to flip onto plane
2466  * @crtc_x: x offset of primary plane on crtc
2467  * @crtc_y: y offset of primary plane on crtc
2468  * @crtc_w: width of primary plane rectangle on crtc
2469  * @crtc_h: height of primary plane rectangle on crtc
2470  * @src_x: x offset of @fb for panning
2471  * @src_y: y offset of @fb for panning
2472  * @src_w: width of source rectangle in @fb
2473  * @src_h: height of source rectangle in @fb
2474  * @ctx: lock acquire context
2475  *
2476  * Provides a default plane update handler using the atomic driver interface.
2477  *
2478  * RETURNS:
2479  * Zero on success, error code on failure
2480  */
2481 int drm_atomic_helper_update_plane(struct drm_plane *plane,
2482                                    struct drm_crtc *crtc,
2483                                    struct drm_framebuffer *fb,
2484                                    int crtc_x, int crtc_y,
2485                                    unsigned int crtc_w, unsigned int crtc_h,
2486                                    uint32_t src_x, uint32_t src_y,
2487                                    uint32_t src_w, uint32_t src_h,
2488                                    struct drm_modeset_acquire_ctx *ctx)
2489 {
2490         struct drm_atomic_state *state;
2491         struct drm_plane_state *plane_state;
2492         int ret = 0;
2493
2494         state = drm_atomic_state_alloc(plane->dev);
2495         if (!state)
2496                 return -ENOMEM;
2497
2498         state->acquire_ctx = ctx;
2499         plane_state = drm_atomic_get_plane_state(state, plane);
2500         if (IS_ERR(plane_state)) {
2501                 ret = PTR_ERR(plane_state);
2502                 goto fail;
2503         }
2504
2505         ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
2506         if (ret != 0)
2507                 goto fail;
2508         drm_atomic_set_fb_for_plane(plane_state, fb);
2509         plane_state->crtc_x = crtc_x;
2510         plane_state->crtc_y = crtc_y;
2511         plane_state->crtc_w = crtc_w;
2512         plane_state->crtc_h = crtc_h;
2513         plane_state->src_x = src_x;
2514         plane_state->src_y = src_y;
2515         plane_state->src_w = src_w;
2516         plane_state->src_h = src_h;
2517
2518         if (plane == crtc->cursor)
2519                 state->legacy_cursor_update = true;
2520
2521         ret = drm_atomic_commit(state);
2522 fail:
2523         drm_atomic_state_put(state);
2524         return ret;
2525 }
2526 EXPORT_SYMBOL(drm_atomic_helper_update_plane);
2527
2528 /**
2529  * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic
2530  * @plane: plane to disable
2531  * @ctx: lock acquire context
2532  *
2533  * Provides a default plane disable handler using the atomic driver interface.
2534  *
2535  * RETURNS:
2536  * Zero on success, error code on failure
2537  */
2538 int drm_atomic_helper_disable_plane(struct drm_plane *plane,
2539                                     struct drm_modeset_acquire_ctx *ctx)
2540 {
2541         struct drm_atomic_state *state;
2542         struct drm_plane_state *plane_state;
2543         int ret = 0;
2544
2545         state = drm_atomic_state_alloc(plane->dev);
2546         if (!state)
2547                 return -ENOMEM;
2548
2549         state->acquire_ctx = ctx;
2550         plane_state = drm_atomic_get_plane_state(state, plane);
2551         if (IS_ERR(plane_state)) {
2552                 ret = PTR_ERR(plane_state);
2553                 goto fail;
2554         }
2555
2556         if (plane_state->crtc && (plane == plane->crtc->cursor))
2557                 plane_state->state->legacy_cursor_update = true;
2558
2559         ret = __drm_atomic_helper_disable_plane(plane, plane_state);
2560         if (ret != 0)
2561                 goto fail;
2562
2563         ret = drm_atomic_commit(state);
2564 fail:
2565         drm_atomic_state_put(state);
2566         return ret;
2567 }
2568 EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
2569
2570 /* just used from fb-helper and atomic-helper: */
2571 int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
2572                 struct drm_plane_state *plane_state)
2573 {
2574         int ret;
2575
2576         ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
2577         if (ret != 0)
2578                 return ret;
2579
2580         drm_atomic_set_fb_for_plane(plane_state, NULL);
2581         plane_state->crtc_x = 0;
2582         plane_state->crtc_y = 0;
2583         plane_state->crtc_w = 0;
2584         plane_state->crtc_h = 0;
2585         plane_state->src_x = 0;
2586         plane_state->src_y = 0;
2587         plane_state->src_w = 0;
2588         plane_state->src_h = 0;
2589
2590         return 0;
2591 }
2592
2593 static int update_output_state(struct drm_atomic_state *state,
2594                                struct drm_mode_set *set)
2595 {
2596         struct drm_device *dev = set->crtc->dev;
2597         struct drm_crtc *crtc;
2598         struct drm_crtc_state *new_crtc_state;
2599         struct drm_connector *connector;
2600         struct drm_connector_state *new_conn_state;
2601         int ret, i;
2602
2603         ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
2604                                state->acquire_ctx);
2605         if (ret)
2606                 return ret;
2607
2608         /* First disable all connectors on the target crtc. */
2609         ret = drm_atomic_add_affected_connectors(state, set->crtc);
2610         if (ret)
2611                 return ret;
2612
2613         for_each_new_connector_in_state(state, connector, new_conn_state, i) {
2614                 if (new_conn_state->crtc == set->crtc) {
2615                         ret = drm_atomic_set_crtc_for_connector(new_conn_state,
2616                                                                 NULL);
2617                         if (ret)
2618                                 return ret;
2619
2620                         /* Make sure legacy setCrtc always re-trains */
2621                         new_conn_state->link_status = DRM_LINK_STATUS_GOOD;
2622                 }
2623         }
2624
2625         /* Then set all connectors from set->connectors on the target crtc */
2626         for (i = 0; i < set->num_connectors; i++) {
2627                 new_conn_state = drm_atomic_get_connector_state(state,
2628                                                             set->connectors[i]);
2629                 if (IS_ERR(new_conn_state))
2630                         return PTR_ERR(new_conn_state);
2631
2632                 ret = drm_atomic_set_crtc_for_connector(new_conn_state,
2633                                                         set->crtc);
2634                 if (ret)
2635                         return ret;
2636         }
2637
2638         for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
2639                 /* Don't update ->enable for the CRTC in the set_config request,
2640                  * since a mismatch would indicate a bug in the upper layers.
2641                  * The actual modeset code later on will catch any
2642                  * inconsistencies here. */
2643                 if (crtc == set->crtc)
2644                         continue;
2645
2646                 if (!new_crtc_state->connector_mask) {
2647                         ret = drm_atomic_set_mode_prop_for_crtc(new_crtc_state,
2648                                                                 NULL);
2649                         if (ret < 0)
2650                                 return ret;
2651
2652                         new_crtc_state->active = false;
2653                 }
2654         }
2655
2656         return 0;
2657 }
2658
2659 /**
2660  * drm_atomic_helper_set_config - set a new config from userspace
2661  * @set: mode set configuration
2662  * @ctx: lock acquisition context
2663  *
2664  * Provides a default crtc set_config handler using the atomic driver interface.
2665  *
2666  * NOTE: For backwards compatibility with old userspace this automatically
2667  * resets the "link-status" property to GOOD, to force any link
2668  * re-training. The SETCRTC ioctl does not define whether an update does
2669  * need a full modeset or just a plane update, hence we're allowed to do
2670  * that. See also drm_mode_connector_set_link_status_property().
2671  *
2672  * Returns:
2673  * Returns 0 on success, negative errno numbers on failure.
2674  */
2675 int drm_atomic_helper_set_config(struct drm_mode_set *set,
2676                                  struct drm_modeset_acquire_ctx *ctx)
2677 {
2678         struct drm_atomic_state *state;
2679         struct drm_crtc *crtc = set->crtc;
2680         int ret = 0;
2681
2682         state = drm_atomic_state_alloc(crtc->dev);
2683         if (!state)
2684                 return -ENOMEM;
2685
2686         state->acquire_ctx = ctx;
2687         ret = __drm_atomic_helper_set_config(set, state);
2688         if (ret != 0)
2689                 goto fail;
2690
2691         ret = handle_conflicting_encoders(state, true);
2692         if (ret)
2693                 return ret;
2694
2695         ret = drm_atomic_commit(state);
2696
2697 fail:
2698         drm_atomic_state_put(state);
2699         return ret;
2700 }
2701 EXPORT_SYMBOL(drm_atomic_helper_set_config);
2702
2703 /* just used from fb-helper and atomic-helper: */
2704 int __drm_atomic_helper_set_config(struct drm_mode_set *set,
2705                 struct drm_atomic_state *state)
2706 {
2707         struct drm_crtc_state *crtc_state;
2708         struct drm_plane_state *primary_state;
2709         struct drm_crtc *crtc = set->crtc;
2710         int hdisplay, vdisplay;
2711         int ret;
2712
2713         crtc_state = drm_atomic_get_crtc_state(state, crtc);
2714         if (IS_ERR(crtc_state))
2715                 return PTR_ERR(crtc_state);
2716
2717         primary_state = drm_atomic_get_plane_state(state, crtc->primary);
2718         if (IS_ERR(primary_state))
2719                 return PTR_ERR(primary_state);
2720
2721         if (!set->mode) {
2722                 WARN_ON(set->fb);
2723                 WARN_ON(set->num_connectors);
2724
2725                 ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL);
2726                 if (ret != 0)
2727                         return ret;
2728
2729                 crtc_state->active = false;
2730
2731                 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
2732                 if (ret != 0)
2733                         return ret;
2734
2735                 drm_atomic_set_fb_for_plane(primary_state, NULL);
2736
2737                 goto commit;
2738         }
2739
2740         WARN_ON(!set->fb);
2741         WARN_ON(!set->num_connectors);
2742
2743         ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode);
2744         if (ret != 0)
2745                 return ret;
2746
2747         crtc_state->active = true;
2748
2749         ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
2750         if (ret != 0)
2751                 return ret;
2752
2753         drm_mode_get_hv_timing(set->mode, &hdisplay, &vdisplay);
2754
2755         drm_atomic_set_fb_for_plane(primary_state, set->fb);
2756         primary_state->crtc_x = 0;
2757         primary_state->crtc_y = 0;
2758         primary_state->crtc_w = hdisplay;
2759         primary_state->crtc_h = vdisplay;
2760         primary_state->src_x = set->x << 16;
2761         primary_state->src_y = set->y << 16;
2762         if (drm_rotation_90_or_270(primary_state->rotation)) {
2763                 primary_state->src_w = vdisplay << 16;
2764                 primary_state->src_h = hdisplay << 16;
2765         } else {
2766                 primary_state->src_w = hdisplay << 16;
2767                 primary_state->src_h = vdisplay << 16;
2768         }
2769
2770 commit:
2771         ret = update_output_state(state, set);
2772         if (ret)
2773                 return ret;
2774
2775         return 0;
2776 }
2777
2778 /**
2779  * drm_atomic_helper_disable_all - disable all currently active outputs
2780  * @dev: DRM device
2781  * @ctx: lock acquisition context
2782  *
2783  * Loops through all connectors, finding those that aren't turned off and then
2784  * turns them off by setting their DPMS mode to OFF and deactivating the CRTC
2785  * that they are connected to.
2786  *
2787  * This is used for example in suspend/resume to disable all currently active
2788  * functions when suspending. If you just want to shut down everything at e.g.
2789  * driver unload, look at drm_atomic_helper_shutdown().
2790  *
2791  * Note that if callers haven't already acquired all modeset locks this might
2792  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
2793  *
2794  * Returns:
2795  * 0 on success or a negative error code on failure.
2796  *
2797  * See also:
2798  * drm_atomic_helper_suspend(), drm_atomic_helper_resume() and
2799  * drm_atomic_helper_shutdown().
2800  */
2801 int drm_atomic_helper_disable_all(struct drm_device *dev,
2802                                   struct drm_modeset_acquire_ctx *ctx)
2803 {
2804         struct drm_atomic_state *state;
2805         struct drm_connector_state *conn_state;
2806         struct drm_connector *conn;
2807         struct drm_plane_state *plane_state;
2808         struct drm_plane *plane;
2809         struct drm_crtc_state *crtc_state;
2810         struct drm_crtc *crtc;
2811         unsigned plane_mask = 0;
2812         int ret, i;
2813
2814         state = drm_atomic_state_alloc(dev);
2815         if (!state)
2816                 return -ENOMEM;
2817
2818         state->acquire_ctx = ctx;
2819
2820         drm_for_each_crtc(crtc, dev) {
2821                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
2822                 if (IS_ERR(crtc_state)) {
2823                         ret = PTR_ERR(crtc_state);
2824                         goto free;
2825                 }
2826
2827                 crtc_state->active = false;
2828
2829                 ret = drm_atomic_set_mode_prop_for_crtc(crtc_state, NULL);
2830                 if (ret < 0)
2831                         goto free;
2832
2833                 ret = drm_atomic_add_affected_planes(state, crtc);
2834                 if (ret < 0)
2835                         goto free;
2836
2837                 ret = drm_atomic_add_affected_connectors(state, crtc);
2838                 if (ret < 0)
2839                         goto free;
2840         }
2841
2842         for_each_new_connector_in_state(state, conn, conn_state, i) {
2843                 ret = drm_atomic_set_crtc_for_connector(conn_state, NULL);
2844                 if (ret < 0)
2845                         goto free;
2846         }
2847
2848         for_each_new_plane_in_state(state, plane, plane_state, i) {
2849                 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
2850                 if (ret < 0)
2851                         goto free;
2852
2853                 drm_atomic_set_fb_for_plane(plane_state, NULL);
2854                 plane_mask |= BIT(drm_plane_index(plane));
2855                 plane->old_fb = plane->fb;
2856         }
2857
2858         ret = drm_atomic_commit(state);
2859 free:
2860         if (plane_mask)
2861                 drm_atomic_clean_old_fb(dev, plane_mask, ret);
2862         drm_atomic_state_put(state);
2863         return ret;
2864 }
2865
2866 EXPORT_SYMBOL(drm_atomic_helper_disable_all);
2867
2868 /**
2869  * drm_atomic_helper_shutdown - shutdown all CRTC
2870  * @dev: DRM device
2871  *
2872  * This shuts down all CRTC, which is useful for driver unloading. Shutdown on
2873  * suspend should instead be handled with drm_atomic_helper_suspend(), since
2874  * that also takes a snapshot of the modeset state to be restored on resume.
2875  *
2876  * This is just a convenience wrapper around drm_atomic_helper_disable_all(),
2877  * and it is the atomic version of drm_crtc_force_disable_all().
2878  */
2879 void drm_atomic_helper_shutdown(struct drm_device *dev)
2880 {
2881         struct drm_modeset_acquire_ctx ctx;
2882         int ret;
2883
2884         drm_modeset_acquire_init(&ctx, 0);
2885         while (1) {
2886                 ret = drm_modeset_lock_all_ctx(dev, &ctx);
2887                 if (!ret)
2888                         ret = drm_atomic_helper_disable_all(dev, &ctx);
2889
2890                 if (ret != -EDEADLK)
2891                         break;
2892
2893                 drm_modeset_backoff(&ctx);
2894         }
2895
2896         if (ret)
2897                 DRM_ERROR("Disabling all crtc's during unload failed with %i\n", ret);
2898
2899         drm_modeset_drop_locks(&ctx);
2900         drm_modeset_acquire_fini(&ctx);
2901 }
2902 EXPORT_SYMBOL(drm_atomic_helper_shutdown);
2903
2904 /**
2905  * drm_atomic_helper_suspend - subsystem-level suspend helper
2906  * @dev: DRM device
2907  *
2908  * Duplicates the current atomic state, disables all active outputs and then
2909  * returns a pointer to the original atomic state to the caller. Drivers can
2910  * pass this pointer to the drm_atomic_helper_resume() helper upon resume to
2911  * restore the output configuration that was active at the time the system
2912  * entered suspend.
2913  *
2914  * Note that it is potentially unsafe to use this. The atomic state object
2915  * returned by this function is assumed to be persistent. Drivers must ensure
2916  * that this holds true. Before calling this function, drivers must make sure
2917  * to suspend fbdev emulation so that nothing can be using the device.
2918  *
2919  * Returns:
2920  * A pointer to a copy of the state before suspend on success or an ERR_PTR()-
2921  * encoded error code on failure. Drivers should store the returned atomic
2922  * state object and pass it to the drm_atomic_helper_resume() helper upon
2923  * resume.
2924  *
2925  * See also:
2926  * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(),
2927  * drm_atomic_helper_resume(), drm_atomic_helper_commit_duplicated_state()
2928  */
2929 struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev)
2930 {
2931         struct drm_modeset_acquire_ctx ctx;
2932         struct drm_atomic_state *state;
2933         int err;
2934
2935         drm_modeset_acquire_init(&ctx, 0);
2936
2937 retry:
2938         err = drm_modeset_lock_all_ctx(dev, &ctx);
2939         if (err < 0) {
2940                 state = ERR_PTR(err);
2941                 goto unlock;
2942         }
2943
2944         state = drm_atomic_helper_duplicate_state(dev, &ctx);
2945         if (IS_ERR(state))
2946                 goto unlock;
2947
2948         err = drm_atomic_helper_disable_all(dev, &ctx);
2949         if (err < 0) {
2950                 drm_atomic_state_put(state);
2951                 state = ERR_PTR(err);
2952                 goto unlock;
2953         }
2954
2955 unlock:
2956         if (PTR_ERR(state) == -EDEADLK) {
2957                 drm_modeset_backoff(&ctx);
2958                 goto retry;
2959         }
2960
2961         drm_modeset_drop_locks(&ctx);
2962         drm_modeset_acquire_fini(&ctx);
2963         return state;
2964 }
2965 EXPORT_SYMBOL(drm_atomic_helper_suspend);
2966
2967 /**
2968  * drm_atomic_helper_commit_duplicated_state - commit duplicated state
2969  * @state: duplicated atomic state to commit
2970  * @ctx: pointer to acquire_ctx to use for commit.
2971  *
2972  * The state returned by drm_atomic_helper_duplicate_state() and
2973  * drm_atomic_helper_suspend() is partially invalid, and needs to
2974  * be fixed up before commit.
2975  *
2976  * Returns:
2977  * 0 on success or a negative error code on failure.
2978  *
2979  * See also:
2980  * drm_atomic_helper_suspend()
2981  */
2982 int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
2983                                               struct drm_modeset_acquire_ctx *ctx)
2984 {
2985         int i;
2986         struct drm_plane *plane;
2987         struct drm_plane_state *new_plane_state;
2988         struct drm_connector *connector;
2989         struct drm_connector_state *new_conn_state;
2990         struct drm_crtc *crtc;
2991         struct drm_crtc_state *new_crtc_state;
2992         unsigned plane_mask = 0;
2993         struct drm_device *dev = state->dev;
2994         int ret;
2995
2996         state->acquire_ctx = ctx;
2997
2998         for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2999                 plane_mask |= BIT(drm_plane_index(plane));
3000                 state->planes[i].old_state = plane->state;
3001         }
3002
3003         for_each_new_crtc_in_state(state, crtc, new_crtc_state, i)
3004                 state->crtcs[i].old_state = crtc->state;
3005
3006         for_each_new_connector_in_state(state, connector, new_conn_state, i)
3007                 state->connectors[i].old_state = connector->state;
3008
3009         ret = drm_atomic_commit(state);
3010         if (plane_mask)
3011                 drm_atomic_clean_old_fb(dev, plane_mask, ret);
3012
3013         return ret;
3014 }
3015 EXPORT_SYMBOL(drm_atomic_helper_commit_duplicated_state);
3016
3017 /**
3018  * drm_atomic_helper_resume - subsystem-level resume helper
3019  * @dev: DRM device
3020  * @state: atomic state to resume to
3021  *
3022  * Calls drm_mode_config_reset() to synchronize hardware and software states,
3023  * grabs all modeset locks and commits the atomic state object. This can be
3024  * used in conjunction with the drm_atomic_helper_suspend() helper to
3025  * implement suspend/resume for drivers that support atomic mode-setting.
3026  *
3027  * Returns:
3028  * 0 on success or a negative error code on failure.
3029  *
3030  * See also:
3031  * drm_atomic_helper_suspend()
3032  */
3033 int drm_atomic_helper_resume(struct drm_device *dev,
3034                              struct drm_atomic_state *state)
3035 {
3036         struct drm_modeset_acquire_ctx ctx;
3037         int err;
3038
3039         drm_mode_config_reset(dev);
3040
3041         drm_modeset_acquire_init(&ctx, 0);
3042         while (1) {
3043                 err = drm_modeset_lock_all_ctx(dev, &ctx);
3044                 if (err)
3045                         goto out;
3046
3047                 err = drm_atomic_helper_commit_duplicated_state(state, &ctx);
3048 out:
3049                 if (err != -EDEADLK)
3050                         break;
3051
3052                 drm_modeset_backoff(&ctx);
3053         }
3054
3055         drm_modeset_drop_locks(&ctx);
3056         drm_modeset_acquire_fini(&ctx);
3057
3058         return err;
3059 }
3060 EXPORT_SYMBOL(drm_atomic_helper_resume);
3061
3062 static int page_flip_common(struct drm_atomic_state *state,
3063                             struct drm_crtc *crtc,
3064                             struct drm_framebuffer *fb,
3065                             struct drm_pending_vblank_event *event,
3066                             uint32_t flags)
3067 {
3068         struct drm_plane *plane = crtc->primary;
3069         struct drm_plane_state *plane_state;
3070         struct drm_crtc_state *crtc_state;
3071         int ret = 0;
3072
3073         crtc_state = drm_atomic_get_crtc_state(state, crtc);
3074         if (IS_ERR(crtc_state))
3075                 return PTR_ERR(crtc_state);
3076
3077         crtc_state->event = event;
3078         crtc_state->pageflip_flags = flags;
3079
3080         plane_state = drm_atomic_get_plane_state(state, plane);
3081         if (IS_ERR(plane_state))
3082                 return PTR_ERR(plane_state);
3083
3084         ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
3085         if (ret != 0)
3086                 return ret;
3087         drm_atomic_set_fb_for_plane(plane_state, fb);
3088
3089         /* Make sure we don't accidentally do a full modeset. */
3090         state->allow_modeset = false;
3091         if (!crtc_state->active) {
3092                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled, rejecting legacy flip\n",
3093                                  crtc->base.id, crtc->name);
3094                 return -EINVAL;
3095         }
3096
3097         return ret;
3098 }
3099
3100 /**
3101  * drm_atomic_helper_page_flip - execute a legacy page flip
3102  * @crtc: DRM crtc
3103  * @fb: DRM framebuffer
3104  * @event: optional DRM event to signal upon completion
3105  * @flags: flip flags for non-vblank sync'ed updates
3106  * @ctx: lock acquisition context
3107  *
3108  * Provides a default &drm_crtc_funcs.page_flip implementation
3109  * using the atomic driver interface.
3110  *
3111  * Returns:
3112  * Returns 0 on success, negative errno numbers on failure.
3113  *
3114  * See also:
3115  * drm_atomic_helper_page_flip_target()
3116  */
3117 int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
3118                                 struct drm_framebuffer *fb,
3119                                 struct drm_pending_vblank_event *event,
3120                                 uint32_t flags,
3121                                 struct drm_modeset_acquire_ctx *ctx)
3122 {
3123         struct drm_plane *plane = crtc->primary;
3124         struct drm_atomic_state *state;
3125         int ret = 0;
3126
3127         state = drm_atomic_state_alloc(plane->dev);
3128         if (!state)
3129                 return -ENOMEM;
3130
3131         state->acquire_ctx = ctx;
3132
3133         ret = page_flip_common(state, crtc, fb, event, flags);
3134         if (ret != 0)
3135                 goto fail;
3136
3137         ret = drm_atomic_nonblocking_commit(state);
3138 fail:
3139         drm_atomic_state_put(state);
3140         return ret;
3141 }
3142 EXPORT_SYMBOL(drm_atomic_helper_page_flip);
3143
3144 /**
3145  * drm_atomic_helper_page_flip_target - do page flip on target vblank period.
3146  * @crtc: DRM crtc
3147  * @fb: DRM framebuffer
3148  * @event: optional DRM event to signal upon completion
3149  * @flags: flip flags for non-vblank sync'ed updates
3150  * @target: specifying the target vblank period when the flip to take effect
3151  * @ctx: lock acquisition context
3152  *
3153  * Provides a default &drm_crtc_funcs.page_flip_target implementation.
3154  * Similar to drm_atomic_helper_page_flip() with extra parameter to specify
3155  * target vblank period to flip.
3156  *
3157  * Returns:
3158  * Returns 0 on success, negative errno numbers on failure.
3159  */
3160 int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
3161                                        struct drm_framebuffer *fb,
3162                                        struct drm_pending_vblank_event *event,
3163                                        uint32_t flags,
3164                                        uint32_t target,
3165                                        struct drm_modeset_acquire_ctx *ctx)
3166 {
3167         struct drm_plane *plane = crtc->primary;
3168         struct drm_atomic_state *state;
3169         struct drm_crtc_state *crtc_state;
3170         int ret = 0;
3171
3172         state = drm_atomic_state_alloc(plane->dev);
3173         if (!state)
3174                 return -ENOMEM;
3175
3176         state->acquire_ctx = ctx;
3177
3178         ret = page_flip_common(state, crtc, fb, event, flags);
3179         if (ret != 0)
3180                 goto fail;
3181
3182         crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
3183         if (WARN_ON(!crtc_state)) {
3184                 ret = -EINVAL;
3185                 goto fail;
3186         }
3187         crtc_state->target_vblank = target;
3188
3189         ret = drm_atomic_nonblocking_commit(state);
3190 fail:
3191         drm_atomic_state_put(state);
3192         return ret;
3193 }
3194 EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
3195
3196 /**
3197  * drm_atomic_helper_best_encoder - Helper for
3198  *      &drm_connector_helper_funcs.best_encoder callback
3199  * @connector: Connector control structure
3200  *
3201  * This is a &drm_connector_helper_funcs.best_encoder callback helper for
3202  * connectors that support exactly 1 encoder, statically determined at driver
3203  * init time.
3204  */
3205 struct drm_encoder *
3206 drm_atomic_helper_best_encoder(struct drm_connector *connector)
3207 {
3208         WARN_ON(connector->encoder_ids[1]);
3209         return drm_encoder_find(connector->dev, connector->encoder_ids[0]);
3210 }
3211 EXPORT_SYMBOL(drm_atomic_helper_best_encoder);
3212
3213 /**
3214  * DOC: atomic state reset and initialization
3215  *
3216  * Both the drm core and the atomic helpers assume that there is always the full
3217  * and correct atomic software state for all connectors, CRTCs and planes
3218  * available. Which is a bit a problem on driver load and also after system
3219  * suspend. One way to solve this is to have a hardware state read-out
3220  * infrastructure which reconstructs the full software state (e.g. the i915
3221  * driver).
3222  *
3223  * The simpler solution is to just reset the software state to everything off,
3224  * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
3225  * the atomic helpers provide default reset implementations for all hooks.
3226  *
3227  * On the upside the precise state tracking of atomic simplifies system suspend
3228  * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
3229  * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
3230  * For other drivers the building blocks are split out, see the documentation
3231  * for these functions.
3232  */
3233
3234 /**
3235  * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs
3236  * @crtc: drm CRTC
3237  *
3238  * Resets the atomic state for @crtc by freeing the state pointer (which might
3239  * be NULL, e.g. at driver load time) and allocating a new empty state object.
3240  */
3241 void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
3242 {
3243         if (crtc->state)
3244                 __drm_atomic_helper_crtc_destroy_state(crtc->state);
3245
3246         kfree(crtc->state);
3247         crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL);
3248
3249         if (crtc->state)
3250                 crtc->state->crtc = crtc;
3251 }
3252 EXPORT_SYMBOL(drm_atomic_helper_crtc_reset);
3253
3254 /**
3255  * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
3256  * @crtc: CRTC object
3257  * @state: atomic CRTC state
3258  *
3259  * Copies atomic state from a CRTC's current state and resets inferred values.
3260  * This is useful for drivers that subclass the CRTC state.
3261  */
3262 void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
3263                                               struct drm_crtc_state *state)
3264 {
3265         memcpy(state, crtc->state, sizeof(*state));
3266
3267         if (state->mode_blob)
3268                 drm_property_blob_get(state->mode_blob);
3269         if (state->degamma_lut)
3270                 drm_property_blob_get(state->degamma_lut);
3271         if (state->ctm)
3272                 drm_property_blob_get(state->ctm);
3273         if (state->gamma_lut)
3274                 drm_property_blob_get(state->gamma_lut);
3275         state->mode_changed = false;
3276         state->active_changed = false;
3277         state->planes_changed = false;
3278         state->connectors_changed = false;
3279         state->color_mgmt_changed = false;
3280         state->zpos_changed = false;
3281         state->commit = NULL;
3282         state->event = NULL;
3283         state->pageflip_flags = 0;
3284 }
3285 EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
3286
3287 /**
3288  * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
3289  * @crtc: drm CRTC
3290  *
3291  * Default CRTC state duplicate hook for drivers which don't have their own
3292  * subclassed CRTC state structure.
3293  */
3294 struct drm_crtc_state *
3295 drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
3296 {
3297         struct drm_crtc_state *state;
3298
3299         if (WARN_ON(!crtc->state))
3300                 return NULL;
3301
3302         state = kmalloc(sizeof(*state), GFP_KERNEL);
3303         if (state)
3304                 __drm_atomic_helper_crtc_duplicate_state(crtc, state);
3305
3306         return state;
3307 }
3308 EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
3309
3310 /**
3311  * __drm_atomic_helper_crtc_destroy_state - release CRTC state
3312  * @state: CRTC state object to release
3313  *
3314  * Releases all resources stored in the CRTC state without actually freeing
3315  * the memory of the CRTC state. This is useful for drivers that subclass the
3316  * CRTC state.
3317  */
3318 void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state)
3319 {
3320         if (state->commit) {
3321                 kfree(state->commit->event);
3322                 state->commit->event = NULL;
3323                 drm_crtc_commit_put(state->commit);
3324         }
3325
3326         drm_property_blob_put(state->mode_blob);
3327         drm_property_blob_put(state->degamma_lut);
3328         drm_property_blob_put(state->ctm);
3329         drm_property_blob_put(state->gamma_lut);
3330 }
3331 EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
3332
3333 /**
3334  * drm_atomic_helper_crtc_destroy_state - default state destroy hook
3335  * @crtc: drm CRTC
3336  * @state: CRTC state object to release
3337  *
3338  * Default CRTC state destroy hook for drivers which don't have their own
3339  * subclassed CRTC state structure.
3340  */
3341 void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
3342                                           struct drm_crtc_state *state)
3343 {
3344         __drm_atomic_helper_crtc_destroy_state(state);
3345         kfree(state);
3346 }
3347 EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
3348
3349 /**
3350  * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes
3351  * @plane: drm plane
3352  *
3353  * Resets the atomic state for @plane by freeing the state pointer (which might
3354  * be NULL, e.g. at driver load time) and allocating a new empty state object.
3355  */
3356 void drm_atomic_helper_plane_reset(struct drm_plane *plane)
3357 {
3358         if (plane->state)
3359                 __drm_atomic_helper_plane_destroy_state(plane->state);
3360
3361         kfree(plane->state);
3362         plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
3363
3364         if (plane->state) {
3365                 plane->state->plane = plane;
3366                 plane->state->rotation = DRM_MODE_ROTATE_0;
3367         }
3368 }
3369 EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
3370
3371 /**
3372  * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
3373  * @plane: plane object
3374  * @state: atomic plane state
3375  *
3376  * Copies atomic state from a plane's current state. This is useful for
3377  * drivers that subclass the plane state.
3378  */
3379 void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
3380                                                struct drm_plane_state *state)
3381 {
3382         memcpy(state, plane->state, sizeof(*state));
3383
3384         if (state->fb)
3385                 drm_framebuffer_get(state->fb);
3386
3387         state->fence = NULL;
3388         state->commit = NULL;
3389 }
3390 EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
3391
3392 /**
3393  * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
3394  * @plane: drm plane
3395  *
3396  * Default plane state duplicate hook for drivers which don't have their own
3397  * subclassed plane state structure.
3398  */
3399 struct drm_plane_state *
3400 drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
3401 {
3402         struct drm_plane_state *state;
3403
3404         if (WARN_ON(!plane->state))
3405                 return NULL;
3406
3407         state = kmalloc(sizeof(*state), GFP_KERNEL);
3408         if (state)
3409                 __drm_atomic_helper_plane_duplicate_state(plane, state);
3410
3411         return state;
3412 }
3413 EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
3414
3415 /**
3416  * __drm_atomic_helper_plane_destroy_state - release plane state
3417  * @state: plane state object to release
3418  *
3419  * Releases all resources stored in the plane state without actually freeing
3420  * the memory of the plane state. This is useful for drivers that subclass the
3421  * plane state.
3422  */
3423 void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state)
3424 {
3425         if (state->fb)
3426                 drm_framebuffer_put(state->fb);
3427
3428         if (state->fence)
3429                 dma_fence_put(state->fence);
3430
3431         if (state->commit)
3432                 drm_crtc_commit_put(state->commit);
3433 }
3434 EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
3435
3436 /**
3437  * drm_atomic_helper_plane_destroy_state - default state destroy hook
3438  * @plane: drm plane
3439  * @state: plane state object to release
3440  *
3441  * Default plane state destroy hook for drivers which don't have their own
3442  * subclassed plane state structure.
3443  */
3444 void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
3445                                            struct drm_plane_state *state)
3446 {
3447         __drm_atomic_helper_plane_destroy_state(state);
3448         kfree(state);
3449 }
3450 EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
3451
3452 /**
3453  * __drm_atomic_helper_connector_reset - reset state on connector
3454  * @connector: drm connector
3455  * @conn_state: connector state to assign
3456  *
3457  * Initializes the newly allocated @conn_state and assigns it to
3458  * the &drm_conector->state pointer of @connector, usually required when
3459  * initializing the drivers or when called from the &drm_connector_funcs.reset
3460  * hook.
3461  *
3462  * This is useful for drivers that subclass the connector state.
3463  */
3464 void
3465 __drm_atomic_helper_connector_reset(struct drm_connector *connector,
3466                                     struct drm_connector_state *conn_state)
3467 {
3468         if (conn_state)
3469                 conn_state->connector = connector;
3470
3471         connector->state = conn_state;
3472 }
3473 EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
3474
3475 /**
3476  * drm_atomic_helper_connector_reset - default &drm_connector_funcs.reset hook for connectors
3477  * @connector: drm connector
3478  *
3479  * Resets the atomic state for @connector by freeing the state pointer (which
3480  * might be NULL, e.g. at driver load time) and allocating a new empty state
3481  * object.
3482  */
3483 void drm_atomic_helper_connector_reset(struct drm_connector *connector)
3484 {
3485         struct drm_connector_state *conn_state =
3486                 kzalloc(sizeof(*conn_state), GFP_KERNEL);
3487
3488         if (connector->state)
3489                 __drm_atomic_helper_connector_destroy_state(connector->state);
3490
3491         kfree(connector->state);
3492         __drm_atomic_helper_connector_reset(connector, conn_state);
3493 }
3494 EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
3495
3496 /**
3497  * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
3498  * @connector: connector object
3499  * @state: atomic connector state
3500  *
3501  * Copies atomic state from a connector's current state. This is useful for
3502  * drivers that subclass the connector state.
3503  */
3504 void
3505 __drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
3506                                             struct drm_connector_state *state)
3507 {
3508         memcpy(state, connector->state, sizeof(*state));
3509         if (state->crtc)
3510                 drm_connector_get(connector);
3511         state->commit = NULL;
3512 }
3513 EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
3514
3515 /**
3516  * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
3517  * @connector: drm connector
3518  *
3519  * Default connector state duplicate hook for drivers which don't have their own
3520  * subclassed connector state structure.
3521  */
3522 struct drm_connector_state *
3523 drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
3524 {
3525         struct drm_connector_state *state;
3526
3527         if (WARN_ON(!connector->state))
3528                 return NULL;
3529
3530         state = kmalloc(sizeof(*state), GFP_KERNEL);
3531         if (state)
3532                 __drm_atomic_helper_connector_duplicate_state(connector, state);
3533
3534         return state;
3535 }
3536 EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
3537
3538 /**
3539  * drm_atomic_helper_duplicate_state - duplicate an atomic state object
3540  * @dev: DRM device
3541  * @ctx: lock acquisition context
3542  *
3543  * Makes a copy of the current atomic state by looping over all objects and
3544  * duplicating their respective states. This is used for example by suspend/
3545  * resume support code to save the state prior to suspend such that it can
3546  * be restored upon resume.
3547  *
3548  * Note that this treats atomic state as persistent between save and restore.
3549  * Drivers must make sure that this is possible and won't result in confusion
3550  * or erroneous behaviour.
3551  *
3552  * Note that if callers haven't already acquired all modeset locks this might
3553  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
3554  *
3555  * Returns:
3556  * A pointer to the copy of the atomic state object on success or an
3557  * ERR_PTR()-encoded error code on failure.
3558  *
3559  * See also:
3560  * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
3561  */
3562 struct drm_atomic_state *
3563 drm_atomic_helper_duplicate_state(struct drm_device *dev,
3564                                   struct drm_modeset_acquire_ctx *ctx)
3565 {
3566         struct drm_atomic_state *state;
3567         struct drm_connector *conn;
3568         struct drm_connector_list_iter conn_iter;
3569         struct drm_plane *plane;
3570         struct drm_crtc *crtc;
3571         int err = 0;
3572
3573         state = drm_atomic_state_alloc(dev);
3574         if (!state)
3575                 return ERR_PTR(-ENOMEM);
3576
3577         state->acquire_ctx = ctx;
3578
3579         drm_for_each_crtc(crtc, dev) {
3580                 struct drm_crtc_state *crtc_state;
3581
3582                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
3583                 if (IS_ERR(crtc_state)) {
3584                         err = PTR_ERR(crtc_state);
3585                         goto free;
3586                 }
3587         }
3588
3589         drm_for_each_plane(plane, dev) {
3590                 struct drm_plane_state *plane_state;
3591
3592                 plane_state = drm_atomic_get_plane_state(state, plane);
3593                 if (IS_ERR(plane_state)) {
3594                         err = PTR_ERR(plane_state);
3595                         goto free;
3596                 }
3597         }
3598
3599         drm_connector_list_iter_begin(dev, &conn_iter);
3600         drm_for_each_connector_iter(conn, &conn_iter) {
3601                 struct drm_connector_state *conn_state;
3602
3603                 conn_state = drm_atomic_get_connector_state(state, conn);
3604                 if (IS_ERR(conn_state)) {
3605                         err = PTR_ERR(conn_state);
3606                         drm_connector_list_iter_end(&conn_iter);
3607                         goto free;
3608                 }
3609         }
3610         drm_connector_list_iter_end(&conn_iter);
3611
3612         /* clear the acquire context so that it isn't accidentally reused */
3613         state->acquire_ctx = NULL;
3614
3615 free:
3616         if (err < 0) {
3617                 drm_atomic_state_put(state);
3618                 state = ERR_PTR(err);
3619         }
3620
3621         return state;
3622 }
3623 EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
3624
3625 /**
3626  * __drm_atomic_helper_connector_destroy_state - release connector state
3627  * @state: connector state object to release
3628  *
3629  * Releases all resources stored in the connector state without actually
3630  * freeing the memory of the connector state. This is useful for drivers that
3631  * subclass the connector state.
3632  */
3633 void
3634 __drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state)
3635 {
3636         if (state->crtc)
3637                 drm_connector_put(state->connector);
3638
3639         if (state->commit)
3640                 drm_crtc_commit_put(state->commit);
3641 }
3642 EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
3643
3644 /**
3645  * drm_atomic_helper_connector_destroy_state - default state destroy hook
3646  * @connector: drm connector
3647  * @state: connector state object to release
3648  *
3649  * Default connector state destroy hook for drivers which don't have their own
3650  * subclassed connector state structure.
3651  */
3652 void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
3653                                           struct drm_connector_state *state)
3654 {
3655         __drm_atomic_helper_connector_destroy_state(state);
3656         kfree(state);
3657 }
3658 EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
3659
3660 /**
3661  * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
3662  * @crtc: CRTC object
3663  * @red: red correction table
3664  * @green: green correction table
3665  * @blue: green correction table
3666  * @size: size of the tables
3667  * @ctx: lock acquire context
3668  *
3669  * Implements support for legacy gamma correction table for drivers
3670  * that support color management through the DEGAMMA_LUT/GAMMA_LUT
3671  * properties. See drm_crtc_enable_color_mgmt() and the containing chapter for
3672  * how the atomic color management and gamma tables work.
3673  */
3674 int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
3675                                        u16 *red, u16 *green, u16 *blue,
3676                                        uint32_t size,
3677                                        struct drm_modeset_acquire_ctx *ctx)
3678 {
3679         struct drm_device *dev = crtc->dev;
3680         struct drm_atomic_state *state;
3681         struct drm_crtc_state *crtc_state;
3682         struct drm_property_blob *blob = NULL;
3683         struct drm_color_lut *blob_data;
3684         int i, ret = 0;
3685         bool replaced;
3686
3687         state = drm_atomic_state_alloc(crtc->dev);
3688         if (!state)
3689                 return -ENOMEM;
3690
3691         blob = drm_property_create_blob(dev,
3692                                         sizeof(struct drm_color_lut) * size,
3693                                         NULL);
3694         if (IS_ERR(blob)) {
3695                 ret = PTR_ERR(blob);
3696                 blob = NULL;
3697                 goto fail;
3698         }
3699
3700         /* Prepare GAMMA_LUT with the legacy values. */
3701         blob_data = (struct drm_color_lut *) blob->data;
3702         for (i = 0; i < size; i++) {
3703                 blob_data[i].red = red[i];
3704                 blob_data[i].green = green[i];
3705                 blob_data[i].blue = blue[i];
3706         }
3707
3708         state->acquire_ctx = ctx;
3709         crtc_state = drm_atomic_get_crtc_state(state, crtc);
3710         if (IS_ERR(crtc_state)) {
3711                 ret = PTR_ERR(crtc_state);
3712                 goto fail;
3713         }
3714
3715         /* Reset DEGAMMA_LUT and CTM properties. */
3716         replaced  = drm_property_replace_blob(&crtc_state->degamma_lut, NULL);
3717         replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
3718         replaced |= drm_property_replace_blob(&crtc_state->gamma_lut, blob);
3719         crtc_state->color_mgmt_changed |= replaced;
3720
3721         ret = drm_atomic_commit(state);
3722
3723 fail:
3724         drm_atomic_state_put(state);
3725         drm_property_blob_put(blob);
3726         return ret;
3727 }
3728 EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);
3729
3730 /**
3731  * __drm_atomic_helper_private_duplicate_state - copy atomic private state
3732  * @obj: CRTC object
3733  * @state: new private object state
3734  *
3735  * Copies atomic state from a private objects's current state and resets inferred values.
3736  * This is useful for drivers that subclass the private state.
3737  */
3738 void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
3739                                                      struct drm_private_state *state)
3740 {
3741         memcpy(state, obj->state, sizeof(*state));
3742 }
3743 EXPORT_SYMBOL(__drm_atomic_helper_private_obj_duplicate_state);