drivers/gpu/drm/drm_atomic_helper.c

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