sys/dev/drm/drm_atomic_helper.c

   1 /*
   2  * Copyright (C) 2014 Red Hat
   3  * Copyright (C) 2014 Intel Corp.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21  * OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  * Rob Clark <robdclark@gmail.com>
  25  * Daniel Vetter <daniel.vetter@ffwll.ch>
  26  */
  27
  28 #include <drm/drmP.h>
  29 #include <drm/drm_atomic.h>
  30 #include <drm/drm_plane_helper.h>
  31 #include <drm/drm_crtc_helper.h>
  32 #include <drm/drm_atomic_helper.h>
  33 #include <linux/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 /* XXX: implement linux/fence.h first */
 991 #if 0
 992         struct drm_plane *plane;
 993         struct drm_plane_state *plane_state;
 994         int i;
 995
 996         for_each_plane_in_state(state, plane, plane_state, i) {
 997                 if (!plane->state->fence)
 998                         continue;
 999
1000                 WARN_ON(!plane->state->fb);
1001
1002                 fence_wait(plane->state->fence, false);
1003                 fence_put(plane->state->fence);
1004                 plane->state->fence = NULL;
1005         }
1006 #endif
1007 }
1008
1009 /**
1010  * drm_atomic_helper_framebuffer_changed - check if framebuffer has changed
1011  * @dev: DRM device
1012  * @old_state: atomic state object with old state structures
1013  * @crtc: DRM crtc
1014  *
1015  * Checks whether the framebuffer used for this CRTC changes as a result of
1016  * the atomic update.  This is useful for drivers which cannot use
1017  * drm_atomic_helper_wait_for_vblanks() and need to reimplement its
1018  * functionality.
1019  *
1020  * Returns:
1021  * true if the framebuffer changed.
1022  */
1023 bool drm_atomic_helper_framebuffer_changed(struct drm_device *dev,
1024                                            struct drm_atomic_state *old_state,
1025                                            struct drm_crtc *crtc)
1026 {
1027         struct drm_plane *plane;
1028         struct drm_plane_state *old_plane_state;
1029         int i;
1030
1031         for_each_plane_in_state(old_state, plane, old_plane_state, i) {
1032                 if (plane->state->crtc != crtc &&
1033                     old_plane_state->crtc != crtc)
1034                         continue;
1035
1036                 if (plane->state->fb != old_plane_state->fb)
1037                         return true;
1038         }
1039
1040         return false;
1041 }
1042 EXPORT_SYMBOL(drm_atomic_helper_framebuffer_changed);
1043
1044 /**
1045  * drm_atomic_helper_wait_for_vblanks - wait for vblank on crtcs
1046  * @dev: DRM device
1047  * @old_state: atomic state object with old state structures
1048  *
1049  * Helper to, after atomic commit, wait for vblanks on all effected
1050  * crtcs (ie. before cleaning up old framebuffers using
1051  * drm_atomic_helper_cleanup_planes()). It will only wait on crtcs where the
1052  * framebuffers have actually changed to optimize for the legacy cursor and
1053  * plane update use-case.
1054  */
1055 void
1056 drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
1057                 struct drm_atomic_state *old_state)
1058 {
1059         struct drm_crtc *crtc;
1060         struct drm_crtc_state *old_crtc_state;
1061         int i, ret;
1062
1063         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1064                 /* No one cares about the old state, so abuse it for tracking
1065                  * and store whether we hold a vblank reference (and should do a
1066                  * vblank wait) in the ->enable boolean. */
1067                 old_crtc_state->enable = false;
1068
1069                 if (!crtc->state->enable)
1070                         continue;
1071
1072                 /* Legacy cursor ioctls are completely unsynced, and userspace
1073                  * relies on that (by doing tons of cursor updates). */
1074                 if (old_state->legacy_cursor_update)
1075                         continue;
1076
1077                 if (!drm_atomic_helper_framebuffer_changed(dev,
1078                                 old_state, crtc))
1079                         continue;
1080
1081                 ret = drm_crtc_vblank_get(crtc);
1082                 if (ret != 0)
1083                         continue;
1084
1085                 old_crtc_state->enable = true;
1086                 old_crtc_state->last_vblank_count = drm_crtc_vblank_count(crtc);
1087         }
1088
1089         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1090                 if (!old_crtc_state->enable)
1091                         continue;
1092
1093                 ret = wait_event_timeout(dev->vblank[i].queue,
1094                                 old_crtc_state->last_vblank_count !=
1095                                         drm_crtc_vblank_count(crtc),
1096                                 msecs_to_jiffies(50));
1097
1098                 drm_crtc_vblank_put(crtc);
1099         }
1100 }
1101 EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
1102
1103 /**
1104  * drm_atomic_helper_commit - commit validated state object
1105  * @dev: DRM device
1106  * @state: the driver state object
1107  * @async: asynchronous commit
1108  *
1109  * This function commits a with drm_atomic_helper_check() pre-validated state
1110  * object. This can still fail when e.g. the framebuffer reservation fails. For
1111  * now this doesn't implement asynchronous commits.
1112  *
1113  * Note that right now this function does not support async commits, and hence
1114  * driver writers must implement their own version for now. Also note that the
1115  * default ordering of how the various stages are called is to match the legacy
1116  * modeset helper library closest. One peculiarity of that is that it doesn't
1117  * mesh well with runtime PM at all.
1118  *
1119  * For drivers supporting runtime PM the recommended sequence is
1120  *
1121  *     drm_atomic_helper_commit_modeset_disables(dev, state);
1122  *
1123  *     drm_atomic_helper_commit_modeset_enables(dev, state);
1124  *
1125  *     drm_atomic_helper_commit_planes(dev, state, true);
1126  *
1127  * See the kerneldoc entries for these three functions for more details.
1128  *
1129  * RETURNS
1130  * Zero for success or -errno.
1131  */
1132 int drm_atomic_helper_commit(struct drm_device *dev,
1133                              struct drm_atomic_state *state,
1134                              bool async)
1135 {
1136         int ret;
1137
1138         if (async)
1139                 return -EBUSY;
1140
1141         ret = drm_atomic_helper_prepare_planes(dev, state);
1142         if (ret)
1143                 return ret;
1144
1145         /*
1146          * This is the point of no return - everything below never fails except
1147          * when the hw goes bonghits. Which means we can commit the new state on
1148          * the software side now.
1149          */
1150
1151         drm_atomic_helper_swap_state(dev, state);
1152
1153         /*
1154          * Everything below can be run asynchronously without the need to grab
1155          * any modeset locks at all under one condition: It must be guaranteed
1156          * that the asynchronous work has either been cancelled (if the driver
1157          * supports it, which at least requires that the framebuffers get
1158          * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
1159          * before the new state gets committed on the software side with
1160          * drm_atomic_helper_swap_state().
1161          *
1162          * This scheme allows new atomic state updates to be prepared and
1163          * checked in parallel to the asynchronous completion of the previous
1164          * update. Which is important since compositors need to figure out the
1165          * composition of the next frame right after having submitted the
1166          * current layout.
1167          */
1168
1169         wait_for_fences(dev, state);
1170
1171         drm_atomic_helper_commit_modeset_disables(dev, state);
1172
1173         drm_atomic_helper_commit_planes(dev, state, false);
1174
1175         drm_atomic_helper_commit_modeset_enables(dev, state);
1176
1177         drm_atomic_helper_wait_for_vblanks(dev, state);
1178
1179         drm_atomic_helper_cleanup_planes(dev, state);
1180
1181         drm_atomic_state_free(state);
1182
1183         return 0;
1184 }
1185 EXPORT_SYMBOL(drm_atomic_helper_commit);
1186
1187 /**
1188  * DOC: implementing async commit
1189  *
1190  * For now the atomic helpers don't support async commit directly. If there is
1191  * real need it could be added though, using the dma-buf fence infrastructure
1192  * for generic synchronization with outstanding rendering.
1193  *
1194  * For now drivers have to implement async commit themselves, with the following
1195  * sequence being the recommended one:
1196  *
1197  * 1. Run drm_atomic_helper_prepare_planes() first. This is the only function
1198  * which commit needs to call which can fail, so we want to run it first and
1199  * synchronously.
1200  *
1201  * 2. Synchronize with any outstanding asynchronous commit worker threads which
1202  * might be affected the new state update. This can be done by either cancelling
1203  * or flushing the work items, depending upon whether the driver can deal with
1204  * cancelled updates. Note that it is important to ensure that the framebuffer
1205  * cleanup is still done when cancelling.
1206  *
1207  * For sufficient parallelism it is recommended to have a work item per crtc
1208  * (for updates which don't touch global state) and a global one. Then we only
1209  * need to synchronize with the crtc work items for changed crtcs and the global
1210  * work item, which allows nice concurrent updates on disjoint sets of crtcs.
1211  *
1212  * 3. The software state is updated synchronously with
1213  * drm_atomic_helper_swap_state(). Doing this under the protection of all modeset
1214  * locks means concurrent callers never see inconsistent state. And doing this
1215  * while it's guaranteed that no relevant async worker runs means that async
1216  * workers do not need grab any locks. Actually they must not grab locks, for
1217  * otherwise the work flushing will deadlock.
1218  *
1219  * 4. Schedule a work item to do all subsequent steps, using the split-out
1220  * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
1221  * then cleaning up the framebuffers after the old framebuffer is no longer
1222  * being displayed.
1223  */
1224
1225 /**
1226  * drm_atomic_helper_prepare_planes - prepare plane resources before commit
1227  * @dev: DRM device
1228  * @state: atomic state object with new state structures
1229  *
1230  * This function prepares plane state, specifically framebuffers, for the new
1231  * configuration. If any failure is encountered this function will call
1232  * ->cleanup_fb on any already successfully prepared framebuffer.
1233  *
1234  * Returns:
1235  * 0 on success, negative error code on failure.
1236  */
1237 int drm_atomic_helper_prepare_planes(struct drm_device *dev,
1238                                      struct drm_atomic_state *state)
1239 {
1240         int nplanes = dev->mode_config.num_total_plane;
1241         int ret, i;
1242
1243         for (i = 0; i < nplanes; i++) {
1244                 const struct drm_plane_helper_funcs *funcs;
1245                 struct drm_plane *plane = state->planes[i];
1246                 struct drm_plane_state *plane_state = state->plane_states[i];
1247
1248                 if (!plane)
1249                         continue;
1250
1251                 funcs = plane->helper_private;
1252
1253                 if (funcs->prepare_fb) {
1254                         ret = funcs->prepare_fb(plane, plane_state);
1255                         if (ret)
1256                                 goto fail;
1257                 }
1258         }
1259
1260         return 0;
1261
1262 fail:
1263         for (i--; i >= 0; i--) {
1264                 const struct drm_plane_helper_funcs *funcs;
1265                 struct drm_plane *plane = state->planes[i];
1266                 struct drm_plane_state *plane_state = state->plane_states[i];
1267
1268                 if (!plane)
1269                         continue;
1270
1271                 funcs = plane->helper_private;
1272
1273                 if (funcs->cleanup_fb)
1274                         funcs->cleanup_fb(plane, plane_state);
1275
1276         }
1277
1278         return ret;
1279 }
1280 EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
1281
1282 static bool plane_crtc_active(struct drm_plane_state *state)
1283 {
1284         return state->crtc && state->crtc->state->active;
1285 }
1286
1287 /**
1288  * drm_atomic_helper_commit_planes - commit plane state
1289  * @dev: DRM device
1290  * @old_state: atomic state object with old state structures
1291  * @active_only: Only commit on active CRTC if set
1292  *
1293  * This function commits the new plane state using the plane and atomic helper
1294  * functions for planes and crtcs. It assumes that the atomic state has already
1295  * been pushed into the relevant object state pointers, since this step can no
1296  * longer fail.
1297  *
1298  * It still requires the global state object @old_state to know which planes and
1299  * crtcs need to be updated though.
1300  *
1301  * Note that this function does all plane updates across all CRTCs in one step.
1302  * If the hardware can't support this approach look at
1303  * drm_atomic_helper_commit_planes_on_crtc() instead.
1304  *
1305  * Plane parameters can be updated by applications while the associated CRTC is
1306  * disabled. The DRM/KMS core will store the parameters in the plane state,
1307  * which will be available to the driver when the CRTC is turned on. As a result
1308  * most drivers don't need to be immediately notified of plane updates for a
1309  * disabled CRTC.
1310  *
1311  * Unless otherwise needed, drivers are advised to set the @active_only
1312  * parameters to true in order not to receive plane update notifications related
1313  * to a disabled CRTC. This avoids the need to manually ignore plane updates in
1314  * driver code when the driver and/or hardware can't or just don't need to deal
1315  * with updates on disabled CRTCs, for example when supporting runtime PM.
1316  *
1317  * The drm_atomic_helper_commit() default implementation only sets @active_only
1318  * to false to most closely match the behaviour of the legacy helpers. This should
1319  * not be copied blindly by drivers.
1320  */
1321 void drm_atomic_helper_commit_planes(struct drm_device *dev,
1322                                      struct drm_atomic_state *old_state,
1323                                      bool active_only)
1324 {
1325         struct drm_crtc *crtc;
1326         struct drm_crtc_state *old_crtc_state;
1327         struct drm_plane *plane;
1328         struct drm_plane_state *old_plane_state;
1329         int i;
1330
1331         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1332                 const struct drm_crtc_helper_funcs *funcs;
1333
1334                 funcs = crtc->helper_private;
1335
1336                 if (!funcs || !funcs->atomic_begin)
1337                         continue;
1338
1339                 if (active_only && !crtc->state->active)
1340                         continue;
1341
1342                 funcs->atomic_begin(crtc, old_crtc_state);
1343         }
1344
1345         for_each_plane_in_state(old_state, plane, old_plane_state, i) {
1346                 const struct drm_plane_helper_funcs *funcs;
1347                 bool disabling;
1348
1349                 funcs = plane->helper_private;
1350
1351                 if (!funcs)
1352                         continue;
1353
1354                 disabling = drm_atomic_plane_disabling(plane, old_plane_state);
1355
1356                 if (active_only) {
1357                         /*
1358                          * Skip planes related to inactive CRTCs. If the plane
1359                          * is enabled use the state of the current CRTC. If the
1360                          * plane is being disabled use the state of the old
1361                          * CRTC to avoid skipping planes being disabled on an
1362                          * active CRTC.
1363                          */
1364                         if (!disabling && !plane_crtc_active(plane->state))
1365                                 continue;
1366                         if (disabling && !plane_crtc_active(old_plane_state))
1367                                 continue;
1368                 }
1369
1370                 /*
1371                  * Special-case disabling the plane if drivers support it.
1372                  */
1373                 if (disabling && funcs->atomic_disable)
1374                         funcs->atomic_disable(plane, old_plane_state);
1375                 else if (plane->state->crtc || disabling)
1376                         funcs->atomic_update(plane, old_plane_state);
1377         }
1378
1379         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1380                 const struct drm_crtc_helper_funcs *funcs;
1381
1382                 funcs = crtc->helper_private;
1383
1384                 if (!funcs || !funcs->atomic_flush)
1385                         continue;
1386
1387                 if (active_only && !crtc->state->active)
1388                         continue;
1389
1390                 funcs->atomic_flush(crtc, old_crtc_state);
1391         }
1392 }
1393 EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
1394
1395 /**
1396  * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a crtc
1397  * @old_crtc_state: atomic state object with the old crtc state
1398  *
1399  * This function commits the new plane state using the plane and atomic helper
1400  * functions for planes on the specific crtc. It assumes that the atomic state
1401  * has already been pushed into the relevant object state pointers, since this
1402  * step can no longer fail.
1403  *
1404  * This function is useful when plane updates should be done crtc-by-crtc
1405  * instead of one global step like drm_atomic_helper_commit_planes() does.
1406  *
1407  * This function can only be savely used when planes are not allowed to move
1408  * between different CRTCs because this function doesn't handle inter-CRTC
1409  * depencies. Callers need to ensure that either no such depencies exist,
1410  * resolve them through ordering of commit calls or through some other means.
1411  */
1412 void
1413 drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state)
1414 {
1415         const struct drm_crtc_helper_funcs *crtc_funcs;
1416         struct drm_crtc *crtc = old_crtc_state->crtc;
1417         struct drm_atomic_state *old_state = old_crtc_state->state;
1418         struct drm_plane *plane;
1419         unsigned plane_mask;
1420
1421         plane_mask = old_crtc_state->plane_mask;
1422         plane_mask |= crtc->state->plane_mask;
1423
1424         crtc_funcs = crtc->helper_private;
1425         if (crtc_funcs && crtc_funcs->atomic_begin)
1426                 crtc_funcs->atomic_begin(crtc, old_crtc_state);
1427
1428         drm_for_each_plane_mask(plane, crtc->dev, plane_mask) {
1429                 struct drm_plane_state *old_plane_state =
1430                         drm_atomic_get_existing_plane_state(old_state, plane);
1431                 const struct drm_plane_helper_funcs *plane_funcs;
1432
1433                 plane_funcs = plane->helper_private;
1434
1435                 if (!old_plane_state || !plane_funcs)
1436                         continue;
1437
1438                 WARN_ON(plane->state->crtc && plane->state->crtc != crtc);
1439
1440                 if (drm_atomic_plane_disabling(plane, old_plane_state) &&
1441                     plane_funcs->atomic_disable)
1442                         plane_funcs->atomic_disable(plane, old_plane_state);
1443                 else if (plane->state->crtc ||
1444                          drm_atomic_plane_disabling(plane, old_plane_state))
1445                         plane_funcs->atomic_update(plane, old_plane_state);
1446         }
1447
1448         if (crtc_funcs && crtc_funcs->atomic_flush)
1449                 crtc_funcs->atomic_flush(crtc, old_crtc_state);
1450 }
1451 EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc);
1452
1453 /**
1454  * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes
1455  * @crtc: CRTC
1456  * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks
1457  *
1458  * Disables all planes associated with the given CRTC. This can be
1459  * used for instance in the CRTC helper disable callback to disable
1460  * all planes before shutting down the display pipeline.
1461  *
1462  * If the atomic-parameter is set the function calls the CRTC's
1463  * atomic_begin hook before and atomic_flush hook after disabling the
1464  * planes.
1465  *
1466  * It is a bug to call this function without having implemented the
1467  * ->atomic_disable() plane hook.
1468  */
1469 void drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc *crtc,
1470                                               bool atomic)
1471 {
1472         const struct drm_crtc_helper_funcs *crtc_funcs =
1473                 crtc->helper_private;
1474         struct drm_plane *plane;
1475
1476         if (atomic && crtc_funcs && crtc_funcs->atomic_begin)
1477                 crtc_funcs->atomic_begin(crtc, NULL);
1478
1479         drm_for_each_plane(plane, crtc->dev) {
1480                 const struct drm_plane_helper_funcs *plane_funcs =
1481                         plane->helper_private;
1482
1483                 if (plane->state->crtc != crtc || !plane_funcs)
1484                         continue;
1485
1486                 WARN_ON(!plane_funcs->atomic_disable);
1487                 if (plane_funcs->atomic_disable)
1488                         plane_funcs->atomic_disable(plane, NULL);
1489         }
1490
1491         if (atomic && crtc_funcs && crtc_funcs->atomic_flush)
1492                 crtc_funcs->atomic_flush(crtc, NULL);
1493 }
1494 EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc);
1495
1496 /**
1497  * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
1498  * @dev: DRM device
1499  * @old_state: atomic state object with old state structures
1500  *
1501  * This function cleans up plane state, specifically framebuffers, from the old
1502  * configuration. Hence the old configuration must be perserved in @old_state to
1503  * be able to call this function.
1504  *
1505  * This function must also be called on the new state when the atomic update
1506  * fails at any point after calling drm_atomic_helper_prepare_planes().
1507  */
1508 void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
1509                                       struct drm_atomic_state *old_state)
1510 {
1511         struct drm_plane *plane;
1512         struct drm_plane_state *plane_state;
1513         int i;
1514
1515         for_each_plane_in_state(old_state, plane, plane_state, i) {
1516                 const struct drm_plane_helper_funcs *funcs;
1517
1518                 funcs = plane->helper_private;
1519
1520                 if (funcs->cleanup_fb)
1521                         funcs->cleanup_fb(plane, plane_state);
1522         }
1523 }
1524 EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
1525
1526 /**
1527  * drm_atomic_helper_swap_state - store atomic state into current sw state
1528  * @dev: DRM device
1529  * @state: atomic state
1530  *
1531  * This function stores the atomic state into the current state pointers in all
1532  * driver objects. It should be called after all failing steps have been done
1533  * and succeeded, but before the actual hardware state is committed.
1534  *
1535  * For cleanup and error recovery the current state for all changed objects will
1536  * be swaped into @state.
1537  *
1538  * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
1539  *
1540  * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
1541  *
1542  * 2. Do any other steps that might fail.
1543  *
1544  * 3. Put the staged state into the current state pointers with this function.
1545  *
1546  * 4. Actually commit the hardware state.
1547  *
1548  * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3
1549  * contains the old state. Also do any other cleanup required with that state.
1550  */
1551 void drm_atomic_helper_swap_state(struct drm_device *dev,
1552                                   struct drm_atomic_state *state)
1553 {
1554         int i;
1555
1556         for (i = 0; i < state->num_connector; i++) {
1557                 struct drm_connector *connector = state->connectors[i];
1558
1559                 if (!connector)
1560                         continue;
1561
1562                 connector->state->state = state;
1563                 swap(state->connector_states[i], connector->state);
1564                 connector->state->state = NULL;
1565         }
1566
1567         for (i = 0; i < dev->mode_config.num_crtc; i++) {
1568                 struct drm_crtc *crtc = state->crtcs[i];
1569
1570                 if (!crtc)
1571                         continue;
1572
1573                 crtc->state->state = state;
1574                 swap(state->crtc_states[i], crtc->state);
1575                 crtc->state->state = NULL;
1576         }
1577
1578         for (i = 0; i < dev->mode_config.num_total_plane; i++) {
1579                 struct drm_plane *plane = state->planes[i];
1580
1581                 if (!plane)
1582                         continue;
1583
1584                 plane->state->state = state;
1585                 swap(state->plane_states[i], plane->state);
1586                 plane->state->state = NULL;
1587         }
1588 }
1589 EXPORT_SYMBOL(drm_atomic_helper_swap_state);
1590
1591 /**
1592  * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
1593  * @plane: plane object to update
1594  * @crtc: owning CRTC of owning plane
1595  * @fb: framebuffer to flip onto plane
1596  * @crtc_x: x offset of primary plane on crtc
1597  * @crtc_y: y offset of primary plane on crtc
1598  * @crtc_w: width of primary plane rectangle on crtc
1599  * @crtc_h: height of primary plane rectangle on crtc
1600  * @src_x: x offset of @fb for panning
1601  * @src_y: y offset of @fb for panning
1602  * @src_w: width of source rectangle in @fb
1603  * @src_h: height of source rectangle in @fb
1604  *
1605  * Provides a default plane update handler using the atomic driver interface.
1606  *
1607  * RETURNS:
1608  * Zero on success, error code on failure
1609  */
1610 int drm_atomic_helper_update_plane(struct drm_plane *plane,
1611                                    struct drm_crtc *crtc,
1612                                    struct drm_framebuffer *fb,
1613                                    int crtc_x, int crtc_y,
1614                                    unsigned int crtc_w, unsigned int crtc_h,
1615                                    uint32_t src_x, uint32_t src_y,
1616                                    uint32_t src_w, uint32_t src_h)
1617 {
1618         struct drm_atomic_state *state;
1619         struct drm_plane_state *plane_state;
1620         int ret = 0;
1621
1622         state = drm_atomic_state_alloc(plane->dev);
1623         if (!state)
1624                 return -ENOMEM;
1625
1626         state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
1627 retry:
1628         plane_state = drm_atomic_get_plane_state(state, plane);
1629         if (IS_ERR(plane_state)) {
1630                 ret = PTR_ERR(plane_state);
1631                 goto fail;
1632         }
1633
1634         ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
1635         if (ret != 0)
1636                 goto fail;
1637         drm_atomic_set_fb_for_plane(plane_state, fb);
1638         plane_state->crtc_x = crtc_x;
1639         plane_state->crtc_y = crtc_y;
1640         plane_state->crtc_w = crtc_w;
1641         plane_state->crtc_h = crtc_h;
1642         plane_state->src_x = src_x;
1643         plane_state->src_y = src_y;
1644         plane_state->src_w = src_w;
1645         plane_state->src_h = src_h;
1646
1647         if (plane == crtc->cursor)
1648                 state->legacy_cursor_update = true;
1649
1650         ret = drm_atomic_commit(state);
1651         if (ret != 0)
1652                 goto fail;
1653
1654         /* Driver takes ownership of state on successful commit. */
1655         return 0;
1656 fail:
1657         if (ret == -EDEADLK)
1658                 goto backoff;
1659
1660         drm_atomic_state_free(state);
1661
1662         return ret;
1663 backoff:
1664         drm_atomic_state_clear(state);
1665         drm_atomic_legacy_backoff(state);
1666
1667         /*
1668          * Someone might have exchanged the framebuffer while we dropped locks
1669          * in the backoff code. We need to fix up the fb refcount tracking the
1670          * core does for us.
1671          */
1672         plane->old_fb = plane->fb;
1673
1674         goto retry;
1675 }
1676 EXPORT_SYMBOL(drm_atomic_helper_update_plane);
1677
1678 /**
1679  * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic
1680  * @plane: plane to disable
1681  *
1682  * Provides a default plane disable handler using the atomic driver interface.
1683  *
1684  * RETURNS:
1685  * Zero on success, error code on failure
1686  */
1687 int drm_atomic_helper_disable_plane(struct drm_plane *plane)
1688 {
1689         struct drm_atomic_state *state;
1690         struct drm_plane_state *plane_state;
1691         int ret = 0;
1692
1693         /*
1694          * FIXME: Without plane->crtc set we can't get at the implicit legacy
1695          * acquire context. The real fix will be to wire the acquire ctx through
1696          * everywhere we need it, but meanwhile prevent chaos by just skipping
1697          * this noop. The critical case is the cursor ioctls which a) only grab
1698          * crtc/cursor-plane locks (so we need the crtc to get at the right
1699          * acquire context) and b) can try to disable the plane multiple times.
1700          */
1701         if (!plane->crtc)
1702                 return 0;
1703
1704         state = drm_atomic_state_alloc(plane->dev);
1705         if (!state)
1706                 return -ENOMEM;
1707
1708         state->acquire_ctx = drm_modeset_legacy_acquire_ctx(plane->crtc);
1709 retry:
1710         plane_state = drm_atomic_get_plane_state(state, plane);
1711         if (IS_ERR(plane_state)) {
1712                 ret = PTR_ERR(plane_state);
1713                 goto fail;
1714         }
1715
1716         if (plane_state->crtc && (plane == plane->crtc->cursor))
1717                 plane_state->state->legacy_cursor_update = true;
1718
1719         ret = __drm_atomic_helper_disable_plane(plane, plane_state);
1720         if (ret != 0)
1721                 goto fail;
1722
1723         ret = drm_atomic_commit(state);
1724         if (ret != 0)
1725                 goto fail;
1726
1727         /* Driver takes ownership of state on successful commit. */
1728         return 0;
1729 fail:
1730         if (ret == -EDEADLK)
1731                 goto backoff;
1732
1733         drm_atomic_state_free(state);
1734
1735         return ret;
1736 backoff:
1737         drm_atomic_state_clear(state);
1738         drm_atomic_legacy_backoff(state);
1739
1740         /*
1741          * Someone might have exchanged the framebuffer while we dropped locks
1742          * in the backoff code. We need to fix up the fb refcount tracking the
1743          * core does for us.
1744          */
1745         plane->old_fb = plane->fb;
1746
1747         goto retry;
1748 }
1749 EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
1750
1751 /* just used from fb-helper and atomic-helper: */
1752 int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
1753                 struct drm_plane_state *plane_state)
1754 {
1755         int ret;
1756
1757         ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
1758         if (ret != 0)
1759                 return ret;
1760
1761         drm_atomic_set_fb_for_plane(plane_state, NULL);
1762         plane_state->crtc_x = 0;
1763         plane_state->crtc_y = 0;
1764         plane_state->crtc_w = 0;
1765         plane_state->crtc_h = 0;
1766         plane_state->src_x = 0;
1767         plane_state->src_y = 0;
1768         plane_state->src_w = 0;
1769         plane_state->src_h = 0;
1770
1771         return 0;
1772 }
1773
1774 static int update_output_state(struct drm_atomic_state *state,
1775                                struct drm_mode_set *set)
1776 {
1777         struct drm_device *dev = set->crtc->dev;
1778         struct drm_crtc *crtc;
1779         struct drm_crtc_state *crtc_state;
1780         struct drm_connector *connector;
1781         struct drm_connector_state *conn_state;
1782         int ret, i;
1783
1784         ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
1785                                state->acquire_ctx);
1786         if (ret)
1787                 return ret;
1788
1789         /* First disable all connectors on the target crtc. */
1790         ret = drm_atomic_add_affected_connectors(state, set->crtc);
1791         if (ret)
1792                 return ret;
1793
1794         for_each_connector_in_state(state, connector, conn_state, i) {
1795                 if (conn_state->crtc == set->crtc) {
1796                         ret = drm_atomic_set_crtc_for_connector(conn_state,
1797                                                                 NULL);
1798                         if (ret)
1799                                 return ret;
1800                 }
1801         }
1802
1803         /* Then set all connectors from set->connectors on the target crtc */
1804         for (i = 0; i < set->num_connectors; i++) {
1805                 conn_state = drm_atomic_get_connector_state(state,
1806                                                             set->connectors[i]);
1807                 if (IS_ERR(conn_state))
1808                         return PTR_ERR(conn_state);
1809
1810                 ret = drm_atomic_set_crtc_for_connector(conn_state,
1811                                                         set->crtc);
1812                 if (ret)
1813                         return ret;
1814         }
1815
1816         for_each_crtc_in_state(state, crtc, crtc_state, i) {
1817                 /* Don't update ->enable for the CRTC in the set_config request,
1818                  * since a mismatch would indicate a bug in the upper layers.
1819                  * The actual modeset code later on will catch any
1820                  * inconsistencies here. */
1821                 if (crtc == set->crtc)
1822                         continue;
1823
1824                 if (!crtc_state->connector_mask) {
1825                         ret = drm_atomic_set_mode_prop_for_crtc(crtc_state,
1826                                                                 NULL);
1827                         if (ret < 0)
1828                                 return ret;
1829
1830                         crtc_state->active = false;
1831                 }
1832         }
1833
1834         return 0;
1835 }
1836
1837 /**
1838  * drm_atomic_helper_set_config - set a new config from userspace
1839  * @set: mode set configuration
1840  *
1841  * Provides a default crtc set_config handler using the atomic driver interface.
1842  *
1843  * Returns:
1844  * Returns 0 on success, negative errno numbers on failure.
1845  */
1846 int drm_atomic_helper_set_config(struct drm_mode_set *set)
1847 {
1848         struct drm_atomic_state *state;
1849         struct drm_crtc *crtc = set->crtc;
1850         int ret = 0;
1851
1852         state = drm_atomic_state_alloc(crtc->dev);
1853         if (!state)
1854                 return -ENOMEM;
1855
1856         state->legacy_set_config = true;
1857         state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
1858 retry:
1859         ret = __drm_atomic_helper_set_config(set, state);
1860         if (ret != 0)
1861                 goto fail;
1862
1863         ret = drm_atomic_commit(state);
1864         if (ret != 0)
1865                 goto fail;
1866
1867         /* Driver takes ownership of state on successful commit. */
1868         return 0;
1869 fail:
1870         if (ret == -EDEADLK)
1871                 goto backoff;
1872
1873         drm_atomic_state_free(state);
1874
1875         return ret;
1876 backoff:
1877         drm_atomic_state_clear(state);
1878         drm_atomic_legacy_backoff(state);
1879
1880         /*
1881          * Someone might have exchanged the framebuffer while we dropped locks
1882          * in the backoff code. We need to fix up the fb refcount tracking the
1883          * core does for us.
1884          */
1885         crtc->primary->old_fb = crtc->primary->fb;
1886
1887         goto retry;
1888 }
1889 EXPORT_SYMBOL(drm_atomic_helper_set_config);
1890
1891 /* just used from fb-helper and atomic-helper: */
1892 int __drm_atomic_helper_set_config(struct drm_mode_set *set,
1893                 struct drm_atomic_state *state)
1894 {
1895         struct drm_crtc_state *crtc_state;
1896         struct drm_plane_state *primary_state;
1897         struct drm_crtc *crtc = set->crtc;
1898         int hdisplay, vdisplay;
1899         int ret;
1900
1901         crtc_state = drm_atomic_get_crtc_state(state, crtc);
1902         if (IS_ERR(crtc_state))
1903                 return PTR_ERR(crtc_state);
1904
1905         primary_state = drm_atomic_get_plane_state(state, crtc->primary);
1906         if (IS_ERR(primary_state))
1907                 return PTR_ERR(primary_state);
1908
1909         if (!set->mode) {
1910                 WARN_ON(set->fb);
1911                 WARN_ON(set->num_connectors);
1912
1913                 ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL);
1914                 if (ret != 0)
1915                         return ret;
1916
1917                 crtc_state->active = false;
1918
1919                 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
1920                 if (ret != 0)
1921                         return ret;
1922
1923                 drm_atomic_set_fb_for_plane(primary_state, NULL);
1924
1925                 goto commit;
1926         }
1927
1928         WARN_ON(!set->fb);
1929         WARN_ON(!set->num_connectors);
1930
1931         ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode);
1932         if (ret != 0)
1933                 return ret;
1934
1935         crtc_state->active = true;
1936
1937         ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
1938         if (ret != 0)
1939                 return ret;
1940
1941         drm_crtc_get_hv_timing(set->mode, &hdisplay, &vdisplay);
1942
1943         drm_atomic_set_fb_for_plane(primary_state, set->fb);
1944         primary_state->crtc_x = 0;
1945         primary_state->crtc_y = 0;
1946         primary_state->crtc_w = hdisplay;
1947         primary_state->crtc_h = vdisplay;
1948         primary_state->src_x = set->x << 16;
1949         primary_state->src_y = set->y << 16;
1950         if (primary_state->rotation & (BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_270))) {
1951                 primary_state->src_w = vdisplay << 16;
1952                 primary_state->src_h = hdisplay << 16;
1953         } else {
1954                 primary_state->src_w = hdisplay << 16;
1955                 primary_state->src_h = vdisplay << 16;
1956         }
1957
1958 commit:
1959         ret = update_output_state(state, set);
1960         if (ret)
1961                 return ret;
1962
1963         return 0;
1964 }
1965
1966 /**
1967  * drm_atomic_helper_disable_all - disable all currently active outputs
1968  * @dev: DRM device
1969  * @ctx: lock acquisition context
1970  *
1971  * Loops through all connectors, finding those that aren't turned off and then
1972  * turns them off by setting their DPMS mode to OFF and deactivating the CRTC
1973  * that they are connected to.
1974  *
1975  * This is used for example in suspend/resume to disable all currently active
1976  * functions when suspending.
1977  *
1978  * Note that if callers haven't already acquired all modeset locks this might
1979  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
1980  *
1981  * Returns:
1982  * 0 on success or a negative error code on failure.
1983  *
1984  * See also:
1985  * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
1986  */
1987 int drm_atomic_helper_disable_all(struct drm_device *dev,
1988                                   struct drm_modeset_acquire_ctx *ctx)
1989 {
1990         struct drm_atomic_state *state;
1991         struct drm_connector *conn;
1992         int err;
1993
1994         state = drm_atomic_state_alloc(dev);
1995         if (!state)
1996                 return -ENOMEM;
1997
1998         state->acquire_ctx = ctx;
1999
2000         drm_for_each_connector(conn, dev) {
2001                 struct drm_crtc *crtc = conn->state->crtc;
2002                 struct drm_crtc_state *crtc_state;
2003
2004                 if (!crtc || conn->dpms != DRM_MODE_DPMS_ON)
2005                         continue;
2006
2007                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
2008                 if (IS_ERR(crtc_state)) {
2009                         err = PTR_ERR(crtc_state);
2010                         goto free;
2011                 }
2012
2013                 crtc_state->active = false;
2014         }
2015
2016         err = drm_atomic_commit(state);
2017
2018 free:
2019         if (err < 0)
2020                 drm_atomic_state_free(state);
2021
2022         return err;
2023 }
2024 EXPORT_SYMBOL(drm_atomic_helper_disable_all);
2025
2026 /**
2027  * drm_atomic_helper_suspend - subsystem-level suspend helper
2028  * @dev: DRM device
2029  *
2030  * Duplicates the current atomic state, disables all active outputs and then
2031  * returns a pointer to the original atomic state to the caller. Drivers can
2032  * pass this pointer to the drm_atomic_helper_resume() helper upon resume to
2033  * restore the output configuration that was active at the time the system
2034  * entered suspend.
2035  *
2036  * Note that it is potentially unsafe to use this. The atomic state object
2037  * returned by this function is assumed to be persistent. Drivers must ensure
2038  * that this holds true. Before calling this function, drivers must make sure
2039  * to suspend fbdev emulation so that nothing can be using the device.
2040  *
2041  * Returns:
2042  * A pointer to a copy of the state before suspend on success or an ERR_PTR()-
2043  * encoded error code on failure. Drivers should store the returned atomic
2044  * state object and pass it to the drm_atomic_helper_resume() helper upon
2045  * resume.
2046  *
2047  * See also:
2048  * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(),
2049  * drm_atomic_helper_resume()
2050  */
2051 struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev)
2052 {
2053         struct drm_modeset_acquire_ctx ctx;
2054         struct drm_atomic_state *state;
2055         int err;
2056
2057         drm_modeset_acquire_init(&ctx, 0);
2058
2059 retry:
2060         err = drm_modeset_lock_all_ctx(dev, &ctx);
2061         if (err < 0) {
2062                 state = ERR_PTR(err);
2063                 goto unlock;
2064         }
2065
2066         state = drm_atomic_helper_duplicate_state(dev, &ctx);
2067         if (IS_ERR(state))
2068                 goto unlock;
2069
2070         err = drm_atomic_helper_disable_all(dev, &ctx);
2071         if (err < 0) {
2072                 drm_atomic_state_free(state);
2073                 state = ERR_PTR(err);
2074                 goto unlock;
2075         }
2076
2077 unlock:
2078         if (PTR_ERR(state) == -EDEADLK) {
2079                 drm_modeset_backoff(&ctx);
2080                 goto retry;
2081         }
2082
2083         drm_modeset_drop_locks(&ctx);
2084         drm_modeset_acquire_fini(&ctx);
2085         return state;
2086 }
2087 EXPORT_SYMBOL(drm_atomic_helper_suspend);
2088
2089 /**
2090  * drm_atomic_helper_resume - subsystem-level resume helper
2091  * @dev: DRM device
2092  * @state: atomic state to resume to
2093  *
2094  * Calls drm_mode_config_reset() to synchronize hardware and software states,
2095  * grabs all modeset locks and commits the atomic state object. This can be
2096  * used in conjunction with the drm_atomic_helper_suspend() helper to
2097  * implement suspend/resume for drivers that support atomic mode-setting.
2098  *
2099  * Returns:
2100  * 0 on success or a negative error code on failure.
2101  *
2102  * See also:
2103  * drm_atomic_helper_suspend()
2104  */
2105 int drm_atomic_helper_resume(struct drm_device *dev,
2106                              struct drm_atomic_state *state)
2107 {
2108         struct drm_mode_config *config = &dev->mode_config;
2109         int err;
2110
2111         drm_mode_config_reset(dev);
2112         drm_modeset_lock_all(dev);
2113         state->acquire_ctx = config->acquire_ctx;
2114         err = drm_atomic_commit(state);
2115         drm_modeset_unlock_all(dev);
2116
2117         return err;
2118 }
2119 EXPORT_SYMBOL(drm_atomic_helper_resume);
2120
2121 /**
2122  * drm_atomic_helper_crtc_set_property - helper for crtc properties
2123  * @crtc: DRM crtc
2124  * @property: DRM property
2125  * @val: value of property
2126  *
2127  * Provides a default crtc set_property handler using the atomic driver
2128  * interface.
2129  *
2130  * RETURNS:
2131  * Zero on success, error code on failure
2132  */
2133 int
2134 drm_atomic_helper_crtc_set_property(struct drm_crtc *crtc,
2135                                     struct drm_property *property,
2136                                     uint64_t val)
2137 {
2138         struct drm_atomic_state *state;
2139         struct drm_crtc_state *crtc_state;
2140         int ret = 0;
2141
2142         state = drm_atomic_state_alloc(crtc->dev);
2143         if (!state)
2144                 return -ENOMEM;
2145
2146         /* ->set_property is always called with all locks held. */
2147         state->acquire_ctx = crtc->dev->mode_config.acquire_ctx;
2148 retry:
2149         crtc_state = drm_atomic_get_crtc_state(state, crtc);
2150         if (IS_ERR(crtc_state)) {
2151                 ret = PTR_ERR(crtc_state);
2152                 goto fail;
2153         }
2154
2155         ret = drm_atomic_crtc_set_property(crtc, crtc_state,
2156                         property, val);
2157         if (ret)
2158                 goto fail;
2159
2160         ret = drm_atomic_commit(state);
2161         if (ret != 0)
2162                 goto fail;
2163
2164         /* Driver takes ownership of state on successful commit. */
2165         return 0;
2166 fail:
2167         if (ret == -EDEADLK)
2168                 goto backoff;
2169
2170         drm_atomic_state_free(state);
2171
2172         return ret;
2173 backoff:
2174         drm_atomic_state_clear(state);
2175         drm_atomic_legacy_backoff(state);
2176
2177         goto retry;
2178 }
2179 EXPORT_SYMBOL(drm_atomic_helper_crtc_set_property);
2180
2181 /**
2182  * drm_atomic_helper_plane_set_property - helper for plane properties
2183  * @plane: DRM plane
2184  * @property: DRM property
2185  * @val: value of property
2186  *
2187  * Provides a default plane set_property handler using the atomic driver
2188  * interface.
2189  *
2190  * RETURNS:
2191  * Zero on success, error code on failure
2192  */
2193 int
2194 drm_atomic_helper_plane_set_property(struct drm_plane *plane,
2195                                     struct drm_property *property,
2196                                     uint64_t val)
2197 {
2198         struct drm_atomic_state *state;
2199         struct drm_plane_state *plane_state;
2200         int ret = 0;
2201
2202         state = drm_atomic_state_alloc(plane->dev);
2203         if (!state)
2204                 return -ENOMEM;
2205
2206         /* ->set_property is always called with all locks held. */
2207         state->acquire_ctx = plane->dev->mode_config.acquire_ctx;
2208 retry:
2209         plane_state = drm_atomic_get_plane_state(state, plane);
2210         if (IS_ERR(plane_state)) {
2211                 ret = PTR_ERR(plane_state);
2212                 goto fail;
2213         }
2214
2215         ret = drm_atomic_plane_set_property(plane, plane_state,
2216                         property, val);
2217         if (ret)
2218                 goto fail;
2219
2220         ret = drm_atomic_commit(state);
2221         if (ret != 0)
2222                 goto fail;
2223
2224         /* Driver takes ownership of state on successful commit. */
2225         return 0;
2226 fail:
2227         if (ret == -EDEADLK)
2228                 goto backoff;
2229
2230         drm_atomic_state_free(state);
2231
2232         return ret;
2233 backoff:
2234         drm_atomic_state_clear(state);
2235         drm_atomic_legacy_backoff(state);
2236
2237         goto retry;
2238 }
2239 EXPORT_SYMBOL(drm_atomic_helper_plane_set_property);
2240
2241 /**
2242  * drm_atomic_helper_connector_set_property - helper for connector properties
2243  * @connector: DRM connector
2244  * @property: DRM property
2245  * @val: value of property
2246  *
2247  * Provides a default connector set_property handler using the atomic driver
2248  * interface.
2249  *
2250  * RETURNS:
2251  * Zero on success, error code on failure
2252  */
2253 int
2254 drm_atomic_helper_connector_set_property(struct drm_connector *connector,
2255                                     struct drm_property *property,
2256                                     uint64_t val)
2257 {
2258         struct drm_atomic_state *state;
2259         struct drm_connector_state *connector_state;
2260         int ret = 0;
2261
2262         state = drm_atomic_state_alloc(connector->dev);
2263         if (!state)
2264                 return -ENOMEM;
2265
2266         /* ->set_property is always called with all locks held. */
2267         state->acquire_ctx = connector->dev->mode_config.acquire_ctx;
2268 retry:
2269         connector_state = drm_atomic_get_connector_state(state, connector);
2270         if (IS_ERR(connector_state)) {
2271                 ret = PTR_ERR(connector_state);
2272                 goto fail;
2273         }
2274
2275         ret = drm_atomic_connector_set_property(connector, connector_state,
2276                         property, val);
2277         if (ret)
2278                 goto fail;
2279
2280         ret = drm_atomic_commit(state);
2281         if (ret != 0)
2282                 goto fail;
2283
2284         /* Driver takes ownership of state on successful commit. */
2285         return 0;
2286 fail:
2287         if (ret == -EDEADLK)
2288                 goto backoff;
2289
2290         drm_atomic_state_free(state);
2291
2292         return ret;
2293 backoff:
2294         drm_atomic_state_clear(state);
2295         drm_atomic_legacy_backoff(state);
2296
2297         goto retry;
2298 }
2299 EXPORT_SYMBOL(drm_atomic_helper_connector_set_property);
2300
2301 /**
2302  * drm_atomic_helper_page_flip - execute a legacy page flip
2303  * @crtc: DRM crtc
2304  * @fb: DRM framebuffer
2305  * @event: optional DRM event to signal upon completion
2306  * @flags: flip flags for non-vblank sync'ed updates
2307  *
2308  * Provides a default page flip implementation using the atomic driver interface.
2309  *
2310  * Note that for now so called async page flips (i.e. updates which are not
2311  * synchronized to vblank) are not supported, since the atomic interfaces have
2312  * no provisions for this yet.
2313  *
2314  * Returns:
2315  * Returns 0 on success, negative errno numbers on failure.
2316  */
2317 int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
2318                                 struct drm_framebuffer *fb,
2319                                 struct drm_pending_vblank_event *event,
2320                                 uint32_t flags)
2321 {
2322         struct drm_plane *plane = crtc->primary;
2323         struct drm_atomic_state *state;
2324         struct drm_plane_state *plane_state;
2325         struct drm_crtc_state *crtc_state;
2326         int ret = 0;
2327
2328         if (flags & DRM_MODE_PAGE_FLIP_ASYNC)
2329                 return -EINVAL;
2330
2331         state = drm_atomic_state_alloc(plane->dev);
2332         if (!state)
2333                 return -ENOMEM;
2334
2335         state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
2336 retry:
2337         crtc_state = drm_atomic_get_crtc_state(state, crtc);
2338         if (IS_ERR(crtc_state)) {
2339                 ret = PTR_ERR(crtc_state);
2340                 goto fail;
2341         }
2342         crtc_state->event = event;
2343
2344         plane_state = drm_atomic_get_plane_state(state, plane);
2345         if (IS_ERR(plane_state)) {
2346                 ret = PTR_ERR(plane_state);
2347                 goto fail;
2348         }
2349
2350         ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
2351         if (ret != 0)
2352                 goto fail;
2353         drm_atomic_set_fb_for_plane(plane_state, fb);
2354
2355         /* Make sure we don't accidentally do a full modeset. */
2356         state->allow_modeset = false;
2357         if (!crtc_state->active) {
2358                 DRM_DEBUG_ATOMIC("[CRTC:%d] disabled, rejecting legacy flip\n",
2359                                  crtc->base.id);
2360                 ret = -EINVAL;
2361                 goto fail;
2362         }
2363
2364         ret = drm_atomic_async_commit(state);
2365         if (ret != 0)
2366                 goto fail;
2367
2368         /* Driver takes ownership of state on successful async commit. */
2369         return 0;
2370 fail:
2371         if (ret == -EDEADLK)
2372                 goto backoff;
2373
2374         drm_atomic_state_free(state);
2375
2376         return ret;
2377 backoff:
2378         drm_atomic_state_clear(state);
2379         drm_atomic_legacy_backoff(state);
2380
2381         /*
2382          * Someone might have exchanged the framebuffer while we dropped locks
2383          * in the backoff code. We need to fix up the fb refcount tracking the
2384          * core does for us.
2385          */
2386         plane->old_fb = plane->fb;
2387
2388         goto retry;
2389 }
2390 EXPORT_SYMBOL(drm_atomic_helper_page_flip);
2391
2392 /**
2393  * drm_atomic_helper_connector_dpms() - connector dpms helper implementation
2394  * @connector: affected connector
2395  * @mode: DPMS mode
2396  *
2397  * This is the main helper function provided by the atomic helper framework for
2398  * implementing the legacy DPMS connector interface. It computes the new desired
2399  * ->active state for the corresponding CRTC (if the connector is enabled) and
2400  *  updates it.
2401  *
2402  * Returns:
2403  * Returns 0 on success, negative errno numbers on failure.
2404  */
2405 int drm_atomic_helper_connector_dpms(struct drm_connector *connector,
2406                                      int mode)
2407 {
2408         struct drm_mode_config *config = &connector->dev->mode_config;
2409         struct drm_atomic_state *state;
2410         struct drm_crtc_state *crtc_state;
2411         struct drm_crtc *crtc;
2412         struct drm_connector *tmp_connector;
2413         int ret;
2414         bool active = false;
2415         int old_mode = connector->dpms;
2416
2417         if (mode != DRM_MODE_DPMS_ON)
2418                 mode = DRM_MODE_DPMS_OFF;
2419
2420         connector->dpms = mode;
2421         crtc = connector->state->crtc;
2422
2423         if (!crtc)
2424                 return 0;
2425
2426         state = drm_atomic_state_alloc(connector->dev);
2427         if (!state)
2428                 return -ENOMEM;
2429
2430         state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
2431 retry:
2432         crtc_state = drm_atomic_get_crtc_state(state, crtc);
2433         if (IS_ERR(crtc_state)) {
2434                 ret = PTR_ERR(crtc_state);
2435                 goto fail;
2436         }
2437
2438         WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
2439
2440         drm_for_each_connector(tmp_connector, connector->dev) {
2441                 if (tmp_connector->state->crtc != crtc)
2442                         continue;
2443
2444                 if (tmp_connector->dpms == DRM_MODE_DPMS_ON) {
2445                         active = true;
2446                         break;
2447                 }
2448         }
2449         crtc_state->active = active;
2450
2451         ret = drm_atomic_commit(state);
2452         if (ret != 0)
2453                 goto fail;
2454
2455         /* Driver takes ownership of state on successful commit. */
2456         return 0;
2457 fail:
2458         if (ret == -EDEADLK)
2459                 goto backoff;
2460
2461         connector->dpms = old_mode;
2462         drm_atomic_state_free(state);
2463
2464         return ret;
2465 backoff:
2466         drm_atomic_state_clear(state);
2467         drm_atomic_legacy_backoff(state);
2468
2469         goto retry;
2470 }
2471 EXPORT_SYMBOL(drm_atomic_helper_connector_dpms);
2472
2473 /**
2474  * DOC: atomic state reset and initialization
2475  *
2476  * Both the drm core and the atomic helpers assume that there is always the full
2477  * and correct atomic software state for all connectors, CRTCs and planes
2478  * available. Which is a bit a problem on driver load and also after system
2479  * suspend. One way to solve this is to have a hardware state read-out
2480  * infrastructure which reconstructs the full software state (e.g. the i915
2481  * driver).
2482  *
2483  * The simpler solution is to just reset the software state to everything off,
2484  * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
2485  * the atomic helpers provide default reset implementations for all hooks.
2486  *
2487  * On the upside the precise state tracking of atomic simplifies system suspend
2488  * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
2489  * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
2490  * For other drivers the building blocks are split out, see the documentation
2491  * for these functions.
2492  */
2493
2494 /**
2495  * drm_atomic_helper_crtc_reset - default ->reset hook for CRTCs
2496  * @crtc: drm CRTC
2497  *
2498  * Resets the atomic state for @crtc by freeing the state pointer (which might
2499  * be NULL, e.g. at driver load time) and allocating a new empty state object.
2500  */
2501 void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
2502 {
2503         if (crtc->state) {
2504                 drm_property_unreference_blob(crtc->state->mode_blob);
2505                 drm_property_unreference_blob(crtc->state->degamma_lut);
2506                 drm_property_unreference_blob(crtc->state->ctm);
2507                 drm_property_unreference_blob(crtc->state->gamma_lut);
2508         }
2509         kfree(crtc->state);
2510         crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL);
2511
2512         if (crtc->state)
2513                 crtc->state->crtc = crtc;
2514 }
2515 EXPORT_SYMBOL(drm_atomic_helper_crtc_reset);
2516
2517 /**
2518  * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
2519  * @crtc: CRTC object
2520  * @state: atomic CRTC state
2521  *
2522  * Copies atomic state from a CRTC's current state and resets inferred values.
2523  * This is useful for drivers that subclass the CRTC state.
2524  */
2525 void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
2526                                               struct drm_crtc_state *state)
2527 {
2528         memcpy(state, crtc->state, sizeof(*state));
2529
2530         if (state->mode_blob)
2531                 drm_property_reference_blob(state->mode_blob);
2532         if (state->degamma_lut)
2533                 drm_property_reference_blob(state->degamma_lut);
2534         if (state->ctm)
2535                 drm_property_reference_blob(state->ctm);
2536         if (state->gamma_lut)
2537                 drm_property_reference_blob(state->gamma_lut);
2538         state->mode_changed = false;
2539         state->active_changed = false;
2540         state->planes_changed = false;
2541         state->connectors_changed = false;
2542         state->color_mgmt_changed = false;
2543         state->event = NULL;
2544 }
2545 EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
2546
2547 /**
2548  * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
2549  * @crtc: drm CRTC
2550  *
2551  * Default CRTC state duplicate hook for drivers which don't have their own
2552  * subclassed CRTC state structure.
2553  */
2554 struct drm_crtc_state *
2555 drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
2556 {
2557         struct drm_crtc_state *state;
2558
2559         if (WARN_ON(!crtc->state))
2560                 return NULL;
2561
2562         state = kmalloc(sizeof(*state), M_DRM, M_WAITOK);
2563         if (state)
2564                 __drm_atomic_helper_crtc_duplicate_state(crtc, state);
2565
2566         return state;
2567 }
2568 EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
2569
2570 /**
2571  * __drm_atomic_helper_crtc_destroy_state - release CRTC state
2572  * @crtc: CRTC object
2573  * @state: CRTC state object to release
2574  *
2575  * Releases all resources stored in the CRTC state without actually freeing
2576  * the memory of the CRTC state. This is useful for drivers that subclass the
2577  * CRTC state.
2578  */
2579 void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
2580                                             struct drm_crtc_state *state)
2581 {
2582         drm_property_unreference_blob(state->mode_blob);
2583         drm_property_unreference_blob(state->degamma_lut);
2584         drm_property_unreference_blob(state->ctm);
2585         drm_property_unreference_blob(state->gamma_lut);
2586 }
2587 EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
2588
2589 /**
2590  * drm_atomic_helper_crtc_destroy_state - default state destroy hook
2591  * @crtc: drm CRTC
2592  * @state: CRTC state object to release
2593  *
2594  * Default CRTC state destroy hook for drivers which don't have their own
2595  * subclassed CRTC state structure.
2596  */
2597 void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
2598                                           struct drm_crtc_state *state)
2599 {
2600         __drm_atomic_helper_crtc_destroy_state(crtc, state);
2601         kfree(state);
2602 }
2603 EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
2604
2605 /**
2606  * drm_atomic_helper_plane_reset - default ->reset hook for planes
2607  * @plane: drm plane
2608  *
2609  * Resets the atomic state for @plane by freeing the state pointer (which might
2610  * be NULL, e.g. at driver load time) and allocating a new empty state object.
2611  */
2612 void drm_atomic_helper_plane_reset(struct drm_plane *plane)
2613 {
2614         if (plane->state && plane->state->fb)
2615                 drm_framebuffer_unreference(plane->state->fb);
2616
2617         kfree(plane->state);
2618         plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
2619
2620         if (plane->state) {
2621                 plane->state->plane = plane;
2622                 plane->state->rotation = BIT(DRM_ROTATE_0);
2623         }
2624 }
2625 EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
2626
2627 /**
2628  * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
2629  * @plane: plane object
2630  * @state: atomic plane state
2631  *
2632  * Copies atomic state from a plane's current state. This is useful for
2633  * drivers that subclass the plane state.
2634  */
2635 void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
2636                                                struct drm_plane_state *state)
2637 {
2638         memcpy(state, plane->state, sizeof(*state));
2639
2640         if (state->fb)
2641                 drm_framebuffer_reference(state->fb);
2642 }
2643 EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
2644
2645 /**
2646  * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
2647  * @plane: drm plane
2648  *
2649  * Default plane state duplicate hook for drivers which don't have their own
2650  * subclassed plane state structure.
2651  */
2652 struct drm_plane_state *
2653 drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
2654 {
2655         struct drm_plane_state *state;
2656
2657         if (WARN_ON(!plane->state))
2658                 return NULL;
2659
2660         state = kmalloc(sizeof(*state), M_DRM, M_WAITOK);
2661         if (state)
2662                 __drm_atomic_helper_plane_duplicate_state(plane, state);
2663
2664         return state;
2665 }
2666 EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
2667
2668 /**
2669  * __drm_atomic_helper_plane_destroy_state - release plane state
2670  * @plane: plane object
2671  * @state: plane state object to release
2672  *
2673  * Releases all resources stored in the plane state without actually freeing
2674  * the memory of the plane state. This is useful for drivers that subclass the
2675  * plane state.
2676  */
2677 void __drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
2678                                              struct drm_plane_state *state)
2679 {
2680         if (state->fb)
2681                 drm_framebuffer_unreference(state->fb);
2682 }
2683 EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
2684
2685 /**
2686  * drm_atomic_helper_plane_destroy_state - default state destroy hook
2687  * @plane: drm plane
2688  * @state: plane state object to release
2689  *
2690  * Default plane state destroy hook for drivers which don't have their own
2691  * subclassed plane state structure.
2692  */
2693 void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
2694                                            struct drm_plane_state *state)
2695 {
2696         __drm_atomic_helper_plane_destroy_state(plane, state);
2697         kfree(state);
2698 }
2699 EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
2700
2701 /**
2702  * __drm_atomic_helper_connector_reset - reset state on connector
2703  * @connector: drm connector
2704  * @conn_state: connector state to assign
2705  *
2706  * Initializes the newly allocated @conn_state and assigns it to
2707  * #connector ->state, usually required when initializing the drivers
2708  * or when called from the ->reset hook.
2709  *
2710  * This is useful for drivers that subclass the connector state.
2711  */
2712 void
2713 __drm_atomic_helper_connector_reset(struct drm_connector *connector,
2714                                     struct drm_connector_state *conn_state)
2715 {
2716         if (conn_state)
2717                 conn_state->connector = connector;
2718
2719         connector->state = conn_state;
2720 }
2721 EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
2722
2723 /**
2724  * drm_atomic_helper_connector_reset - default ->reset hook for connectors
2725  * @connector: drm connector
2726  *
2727  * Resets the atomic state for @connector by freeing the state pointer (which
2728  * might be NULL, e.g. at driver load time) and allocating a new empty state
2729  * object.
2730  */
2731 void drm_atomic_helper_connector_reset(struct drm_connector *connector)
2732 {
2733         struct drm_connector_state *conn_state =
2734                 kzalloc(sizeof(*conn_state), GFP_KERNEL);
2735
2736         kfree(connector->state);
2737         __drm_atomic_helper_connector_reset(connector, conn_state);
2738 }
2739 EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
2740
2741 /**
2742  * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
2743  * @connector: connector object
2744  * @state: atomic connector state
2745  *
2746  * Copies atomic state from a connector's current state. This is useful for
2747  * drivers that subclass the connector state.
2748  */
2749 void
2750 __drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
2751                                             struct drm_connector_state *state)
2752 {
2753         memcpy(state, connector->state, sizeof(*state));
2754 }
2755 EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
2756
2757 /**
2758  * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
2759  * @connector: drm connector
2760  *
2761  * Default connector state duplicate hook for drivers which don't have their own
2762  * subclassed connector state structure.
2763  */
2764 struct drm_connector_state *
2765 drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
2766 {
2767         struct drm_connector_state *state;
2768
2769         if (WARN_ON(!connector->state))
2770                 return NULL;
2771
2772         state = kmalloc(sizeof(*state), M_DRM, M_WAITOK);
2773         if (state)
2774                 __drm_atomic_helper_connector_duplicate_state(connector, state);
2775
2776         return state;
2777 }
2778 EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
2779
2780 /**
2781  * drm_atomic_helper_duplicate_state - duplicate an atomic state object
2782  * @dev: DRM device
2783  * @ctx: lock acquisition context
2784  *
2785  * Makes a copy of the current atomic state by looping over all objects and
2786  * duplicating their respective states. This is used for example by suspend/
2787  * resume support code to save the state prior to suspend such that it can
2788  * be restored upon resume.
2789  *
2790  * Note that this treats atomic state as persistent between save and restore.
2791  * Drivers must make sure that this is possible and won't result in confusion
2792  * or erroneous behaviour.
2793  *
2794  * Note that if callers haven't already acquired all modeset locks this might
2795  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
2796  *
2797  * Returns:
2798  * A pointer to the copy of the atomic state object on success or an
2799  * ERR_PTR()-encoded error code on failure.
2800  *
2801  * See also:
2802  * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
2803  */
2804 struct drm_atomic_state *
2805 drm_atomic_helper_duplicate_state(struct drm_device *dev,
2806                                   struct drm_modeset_acquire_ctx *ctx)
2807 {
2808         struct drm_atomic_state *state;
2809         struct drm_connector *conn;
2810         struct drm_plane *plane;
2811         struct drm_crtc *crtc;
2812         int err = 0;
2813
2814         state = drm_atomic_state_alloc(dev);
2815         if (!state)
2816                 return ERR_PTR(-ENOMEM);
2817
2818         state->acquire_ctx = ctx;
2819
2820         drm_for_each_crtc(crtc, dev) {
2821                 struct drm_crtc_state *crtc_state;
2822
2823                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
2824                 if (IS_ERR(crtc_state)) {
2825                         err = PTR_ERR(crtc_state);
2826                         goto free;
2827                 }
2828         }
2829
2830         drm_for_each_plane(plane, dev) {
2831                 struct drm_plane_state *plane_state;
2832
2833                 plane_state = drm_atomic_get_plane_state(state, plane);
2834                 if (IS_ERR(plane_state)) {
2835                         err = PTR_ERR(plane_state);
2836                         goto free;
2837                 }
2838         }
2839
2840         drm_for_each_connector(conn, dev) {
2841                 struct drm_connector_state *conn_state;
2842
2843                 conn_state = drm_atomic_get_connector_state(state, conn);
2844                 if (IS_ERR(conn_state)) {
2845                         err = PTR_ERR(conn_state);
2846                         goto free;
2847                 }
2848         }
2849
2850         /* clear the acquire context so that it isn't accidentally reused */
2851         state->acquire_ctx = NULL;
2852
2853 free:
2854         if (err < 0) {
2855                 drm_atomic_state_free(state);
2856                 state = ERR_PTR(err);
2857         }
2858
2859         return state;
2860 }
2861 EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
2862
2863 /**
2864  * __drm_atomic_helper_connector_destroy_state - release connector state
2865  * @connector: connector object
2866  * @state: connector state object to release
2867  *
2868  * Releases all resources stored in the connector state without actually
2869  * freeing the memory of the connector state. This is useful for drivers that
2870  * subclass the connector state.
2871  */
2872 void
2873 __drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
2874                                             struct drm_connector_state *state)
2875 {
2876         /*
2877          * This is currently a placeholder so that drivers that subclass the
2878          * state will automatically do the right thing if code is ever added
2879          * to this function.
2880          */
2881 }
2882 EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
2883
2884 /**
2885  * drm_atomic_helper_connector_destroy_state - default state destroy hook
2886  * @connector: drm connector
2887  * @state: connector state object to release
2888  *
2889  * Default connector state destroy hook for drivers which don't have their own
2890  * subclassed connector state structure.
2891  */
2892 void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
2893                                           struct drm_connector_state *state)
2894 {
2895         __drm_atomic_helper_connector_destroy_state(connector, state);
2896         kfree(state);
2897 }
2898 EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
2899
2900 /**
2901  * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
2902  * @crtc: CRTC object
2903  * @red: red correction table
2904  * @green: green correction table
2905  * @blue: green correction table
2906  * @start:
2907  * @size: size of the tables
2908  *
2909  * Implements support for legacy gamma correction table for drivers
2910  * that support color management through the DEGAMMA_LUT/GAMMA_LUT
2911  * properties.
2912  */
2913 void drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
2914                                         u16 *red, u16 *green, u16 *blue,
2915                                         uint32_t start, uint32_t size)
2916 {
2917         struct drm_device *dev = crtc->dev;
2918         struct drm_mode_config *config = &dev->mode_config;
2919         struct drm_atomic_state *state;
2920         struct drm_crtc_state *crtc_state;
2921         struct drm_property_blob *blob = NULL;
2922         struct drm_color_lut *blob_data;
2923         int i, ret = 0;
2924
2925         state = drm_atomic_state_alloc(crtc->dev);
2926         if (!state)
2927                 return;
2928
2929         blob = drm_property_create_blob(dev,
2930                                         sizeof(struct drm_color_lut) * size,
2931                                         NULL);
2932         if (IS_ERR(blob)) {
2933                 ret = PTR_ERR(blob);
2934                 blob = NULL;
2935                 goto fail;
2936         }
2937
2938         /* Prepare GAMMA_LUT with the legacy values. */
2939         blob_data = (struct drm_color_lut *) blob->data;
2940         for (i = 0; i < size; i++) {
2941                 blob_data[i].red = red[i];
2942                 blob_data[i].green = green[i];
2943                 blob_data[i].blue = blue[i];
2944         }
2945
2946         state->acquire_ctx = crtc->dev->mode_config.acquire_ctx;
2947 retry:
2948         crtc_state = drm_atomic_get_crtc_state(state, crtc);
2949         if (IS_ERR(crtc_state)) {
2950                 ret = PTR_ERR(crtc_state);
2951                 goto fail;
2952         }
2953
2954         /* Reset DEGAMMA_LUT and CTM properties. */
2955         ret = drm_atomic_crtc_set_property(crtc, crtc_state,
2956                         config->degamma_lut_property, 0);
2957         if (ret)
2958                 goto fail;
2959
2960         ret = drm_atomic_crtc_set_property(crtc, crtc_state,
2961                         config->ctm_property, 0);
2962         if (ret)
2963                 goto fail;
2964
2965         ret = drm_atomic_crtc_set_property(crtc, crtc_state,
2966                         config->gamma_lut_property, blob->base.id);
2967         if (ret)
2968                 goto fail;
2969
2970         ret = drm_atomic_commit(state);
2971         if (ret)
2972                 goto fail;
2973
2974         /* Driver takes ownership of state on successful commit. */
2975
2976         drm_property_unreference_blob(blob);
2977
2978         return;
2979 fail:
2980         if (ret == -EDEADLK)
2981                 goto backoff;
2982
2983         drm_atomic_state_free(state);
2984         drm_property_unreference_blob(blob);
2985
2986         return;
2987 backoff:
2988         drm_atomic_state_clear(state);
2989         drm_atomic_legacy_backoff(state);
2990
2991         goto retry;
2992 }
2993 EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);