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