drivers/gpu/drm/drm_atomic.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
  29 #include <drm/drmP.h>
  30 #include <drm/drm_atomic.h>
  31 #include <drm/drm_mode.h>
  32 #include <drm/drm_plane_helper.h>
  33
  34 /**
  35  * drm_atomic_state_default_release -
  36  * release memory initialized by drm_atomic_state_init
  37  * @state: atomic state
  38  *
  39  * Free all the memory allocated by drm_atomic_state_init.
  40  * This is useful for drivers that subclass the atomic state.
  41  */
  42 void drm_atomic_state_default_release(struct drm_atomic_state *state)
  43 {
  44         kfree(state->connectors);
  45         kfree(state->connector_states);
  46         kfree(state->crtcs);
  47         kfree(state->crtc_states);
  48         kfree(state->planes);
  49         kfree(state->plane_states);
  50 }
  51 EXPORT_SYMBOL(drm_atomic_state_default_release);
  52
  53 /**
  54  * drm_atomic_state_init - init new atomic state
  55  * @dev: DRM device
  56  * @state: atomic state
  57  *
  58  * Default implementation for filling in a new atomic state.
  59  * This is useful for drivers that subclass the atomic state.
  60  */
  61 int
  62 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
  63 {
  64         /* TODO legacy paths should maybe do a better job about
  65          * setting this appropriately?
  66          */
  67         state->allow_modeset = true;
  68
  69         state->crtcs = kcalloc(dev->mode_config.num_crtc,
  70                                sizeof(*state->crtcs), GFP_KERNEL);
  71         if (!state->crtcs)
  72                 goto fail;
  73         state->crtc_states = kcalloc(dev->mode_config.num_crtc,
  74                                      sizeof(*state->crtc_states), GFP_KERNEL);
  75         if (!state->crtc_states)
  76                 goto fail;
  77         state->planes = kcalloc(dev->mode_config.num_total_plane,
  78                                 sizeof(*state->planes), GFP_KERNEL);
  79         if (!state->planes)
  80                 goto fail;
  81         state->plane_states = kcalloc(dev->mode_config.num_total_plane,
  82                                       sizeof(*state->plane_states), GFP_KERNEL);
  83         if (!state->plane_states)
  84                 goto fail;
  85
  86         state->dev = dev;
  87
  88         DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);
  89
  90         return 0;
  91 fail:
  92         drm_atomic_state_default_release(state);
  93         return -ENOMEM;
  94 }
  95 EXPORT_SYMBOL(drm_atomic_state_init);
  96
  97 /**
  98  * drm_atomic_state_alloc - allocate atomic state
  99  * @dev: DRM device
 100  *
 101  * This allocates an empty atomic state to track updates.
 102  */
 103 struct drm_atomic_state *
 104 drm_atomic_state_alloc(struct drm_device *dev)
 105 {
 106         struct drm_mode_config *config = &dev->mode_config;
 107         struct drm_atomic_state *state;
 108
 109         if (!config->funcs->atomic_state_alloc) {
 110                 state = kzalloc(sizeof(*state), GFP_KERNEL);
 111                 if (!state)
 112                         return NULL;
 113                 if (drm_atomic_state_init(dev, state) < 0) {
 114                         kfree(state);
 115                         return NULL;
 116                 }
 117                 return state;
 118         }
 119
 120         return config->funcs->atomic_state_alloc(dev);
 121 }
 122 EXPORT_SYMBOL(drm_atomic_state_alloc);
 123
 124 /**
 125  * drm_atomic_state_default_clear - clear base atomic state
 126  * @state: atomic state
 127  *
 128  * Default implementation for clearing atomic state.
 129  * This is useful for drivers that subclass the atomic state.
 130  */
 131 void drm_atomic_state_default_clear(struct drm_atomic_state *state)
 132 {
 133         struct drm_device *dev = state->dev;
 134         struct drm_mode_config *config = &dev->mode_config;
 135         int i;
 136
 137         DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
 138
 139         for (i = 0; i < state->num_connector; i++) {
 140                 struct drm_connector *connector = state->connectors[i];
 141
 142                 if (!connector)
 143                         continue;
 144
 145                 /*
 146                  * FIXME: Async commits can race with connector unplugging and
 147                  * there's currently nothing that prevents cleanup up state for
 148                  * deleted connectors. As long as the callback doesn't look at
 149                  * the connector we'll be fine though, so make sure that's the
 150                  * case by setting all connector pointers to NULL.
 151                  */
 152                 state->connector_states[i]->connector = NULL;
 153                 connector->funcs->atomic_destroy_state(NULL,
 154                                                        state->connector_states[i]);
 155                 state->connectors[i] = NULL;
 156                 state->connector_states[i] = NULL;
 157         }
 158
 159         for (i = 0; i < config->num_crtc; i++) {
 160                 struct drm_crtc *crtc = state->crtcs[i];
 161
 162                 if (!crtc)
 163                         continue;
 164
 165                 crtc->funcs->atomic_destroy_state(crtc,
 166                                                   state->crtc_states[i]);
 167                 state->crtcs[i] = NULL;
 168                 state->crtc_states[i] = NULL;
 169         }
 170
 171         for (i = 0; i < config->num_total_plane; i++) {
 172                 struct drm_plane *plane = state->planes[i];
 173
 174                 if (!plane)
 175                         continue;
 176
 177                 plane->funcs->atomic_destroy_state(plane,
 178                                                    state->plane_states[i]);
 179                 state->planes[i] = NULL;
 180                 state->plane_states[i] = NULL;
 181         }
 182 }
 183 EXPORT_SYMBOL(drm_atomic_state_default_clear);
 184
 185 /**
 186  * drm_atomic_state_clear - clear state object
 187  * @state: atomic state
 188  *
 189  * When the w/w mutex algorithm detects a deadlock we need to back off and drop
 190  * all locks. So someone else could sneak in and change the current modeset
 191  * configuration. Which means that all the state assembled in @state is no
 192  * longer an atomic update to the current state, but to some arbitrary earlier
 193  * state. Which could break assumptions the driver's ->atomic_check likely
 194  * relies on.
 195  *
 196  * Hence we must clear all cached state and completely start over, using this
 197  * function.
 198  */
 199 void drm_atomic_state_clear(struct drm_atomic_state *state)
 200 {
 201         struct drm_device *dev = state->dev;
 202         struct drm_mode_config *config = &dev->mode_config;
 203
 204         if (config->funcs->atomic_state_clear)
 205                 config->funcs->atomic_state_clear(state);
 206         else
 207                 drm_atomic_state_default_clear(state);
 208 }
 209 EXPORT_SYMBOL(drm_atomic_state_clear);
 210
 211 /**
 212  * drm_atomic_state_free - free all memory for an atomic state
 213  * @state: atomic state to deallocate
 214  *
 215  * This frees all memory associated with an atomic state, including all the
 216  * per-object state for planes, crtcs and connectors.
 217  */
 218 void drm_atomic_state_free(struct drm_atomic_state *state)
 219 {
 220         struct drm_device *dev;
 221         struct drm_mode_config *config;
 222
 223         if (!state)
 224                 return;
 225
 226         dev = state->dev;
 227         config = &dev->mode_config;
 228
 229         drm_atomic_state_clear(state);
 230
 231         DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
 232
 233         if (config->funcs->atomic_state_free) {
 234                 config->funcs->atomic_state_free(state);
 235         } else {
 236                 drm_atomic_state_default_release(state);
 237                 kfree(state);
 238         }
 239 }
 240 EXPORT_SYMBOL(drm_atomic_state_free);
 241
 242 /**
 243  * drm_atomic_get_crtc_state - get crtc state
 244  * @state: global atomic state object
 245  * @crtc: crtc to get state object for
 246  *
 247  * This function returns the crtc state for the given crtc, allocating it if
 248  * needed. It will also grab the relevant crtc lock to make sure that the state
 249  * is consistent.
 250  *
 251  * Returns:
 252  *
 253  * Either the allocated state or the error code encoded into the pointer. When
 254  * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
 255  * entire atomic sequence must be restarted. All other errors are fatal.
 256  */
 257 struct drm_crtc_state *
 258 drm_atomic_get_crtc_state(struct drm_atomic_state *state,
 259                           struct drm_crtc *crtc)
 260 {
 261         int ret, index = drm_crtc_index(crtc);
 262         struct drm_crtc_state *crtc_state;
 263
 264         crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
 265         if (crtc_state)
 266                 return crtc_state;
 267
 268         ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
 269         if (ret)
 270                 return ERR_PTR(ret);
 271
 272         crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
 273         if (!crtc_state)
 274                 return ERR_PTR(-ENOMEM);
 275
 276         state->crtc_states[index] = crtc_state;
 277         state->crtcs[index] = crtc;
 278         crtc_state->state = state;
 279
 280         DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
 281                          crtc->base.id, crtc->name, crtc_state, state);
 282
 283         return crtc_state;
 284 }
 285 EXPORT_SYMBOL(drm_atomic_get_crtc_state);
 286
 287 /**
 288  * drm_atomic_set_mode_for_crtc - set mode for CRTC
 289  * @state: the CRTC whose incoming state to update
 290  * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
 291  *
 292  * Set a mode (originating from the kernel) on the desired CRTC state. Does
 293  * not change any other state properties, including enable, active, or
 294  * mode_changed.
 295  *
 296  * RETURNS:
 297  * Zero on success, error code on failure. Cannot return -EDEADLK.
 298  */
 299 int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
 300                                  struct drm_display_mode *mode)
 301 {
 302         struct drm_mode_modeinfo umode;
 303
 304         /* Early return for no change. */
 305         if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)
 306                 return 0;
 307
 308         drm_property_unreference_blob(state->mode_blob);
 309         state->mode_blob = NULL;
 310
 311         if (mode) {
 312                 drm_mode_convert_to_umode(&umode, mode);
 313                 state->mode_blob =
 314                         drm_property_create_blob(state->crtc->dev,
 315                                                  sizeof(umode),
 316                                                  &umode);
 317                 if (IS_ERR(state->mode_blob))
 318                         return PTR_ERR(state->mode_blob);
 319
 320                 drm_mode_copy(&state->mode, mode);
 321                 state->enable = true;
 322                 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
 323                                  mode->name, state);
 324         } else {
 325                 memset(&state->mode, 0, sizeof(state->mode));
 326                 state->enable = false;
 327                 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
 328                                  state);
 329         }
 330
 331         return 0;
 332 }
 333 EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc);
 334
 335 /**
 336  * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
 337  * @state: the CRTC whose incoming state to update
 338  * @blob: pointer to blob property to use for mode
 339  *
 340  * Set a mode (originating from a blob property) on the desired CRTC state.
 341  * This function will take a reference on the blob property for the CRTC state,
 342  * and release the reference held on the state's existing mode property, if any
 343  * was set.
 344  *
 345  * RETURNS:
 346  * Zero on success, error code on failure. Cannot return -EDEADLK.
 347  */
 348 int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
 349                                       struct drm_property_blob *blob)
 350 {
 351         if (blob == state->mode_blob)
 352                 return 0;
 353
 354         drm_property_unreference_blob(state->mode_blob);
 355         state->mode_blob = NULL;
 356
 357         if (blob) {
 358                 if (blob->length != sizeof(struct drm_mode_modeinfo) ||
 359                     drm_mode_convert_umode(&state->mode,
 360                                            (const struct drm_mode_modeinfo *)
 361                                             blob->data))
 362                         return -EINVAL;
 363
 364                 state->mode_blob = drm_property_reference_blob(blob);
 365                 state->enable = true;
 366                 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
 367                                  state->mode.name, state);
 368         } else {
 369                 memset(&state->mode, 0, sizeof(state->mode));
 370                 state->enable = false;
 371                 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
 372                                  state);
 373         }
 374
 375         return 0;
 376 }
 377 EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc);
 378
 379 /**
 380  * drm_atomic_replace_property_blob - replace a blob property
 381  * @blob: a pointer to the member blob to be replaced
 382  * @new_blob: the new blob to replace with
 383  * @expected_size: the expected size of the new blob
 384  * @replaced: whether the blob has been replaced
 385  *
 386  * RETURNS:
 387  * Zero on success, error code on failure
 388  */
 389 static void
 390 drm_atomic_replace_property_blob(struct drm_property_blob **blob,
 391                                  struct drm_property_blob *new_blob,
 392                                  bool *replaced)
 393 {
 394         struct drm_property_blob *old_blob = *blob;
 395
 396         if (old_blob == new_blob)
 397                 return;
 398
 399         if (old_blob)
 400                 drm_property_unreference_blob(old_blob);
 401         if (new_blob)
 402                 drm_property_reference_blob(new_blob);
 403         *blob = new_blob;
 404         *replaced = true;
 405
 406         return;
 407 }
 408
 409 static int
 410 drm_atomic_replace_property_blob_from_id(struct drm_crtc *crtc,
 411                                          struct drm_property_blob **blob,
 412                                          uint64_t blob_id,
 413                                          ssize_t expected_size,
 414                                          bool *replaced)
 415 {
 416         struct drm_device *dev = crtc->dev;
 417         struct drm_property_blob *new_blob = NULL;
 418
 419         if (blob_id != 0) {
 420                 new_blob = drm_property_lookup_blob(dev, blob_id);
 421                 if (new_blob == NULL)
 422                         return -EINVAL;
 423                 if (expected_size > 0 && expected_size != new_blob->length)
 424                         return -EINVAL;
 425         }
 426
 427         drm_atomic_replace_property_blob(blob, new_blob, replaced);
 428
 429         return 0;
 430 }
 431
 432 /**
 433  * drm_atomic_crtc_set_property - set property on CRTC
 434  * @crtc: the drm CRTC to set a property on
 435  * @state: the state object to update with the new property value
 436  * @property: the property to set
 437  * @val: the new property value
 438  *
 439  * Use this instead of calling crtc->atomic_set_property directly.
 440  * This function handles generic/core properties and calls out to
 441  * driver's ->atomic_set_property() for driver properties.  To ensure
 442  * consistent behavior you must call this function rather than the
 443  * driver hook directly.
 444  *
 445  * RETURNS:
 446  * Zero on success, error code on failure
 447  */
 448 int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
 449                 struct drm_crtc_state *state, struct drm_property *property,
 450                 uint64_t val)
 451 {
 452         struct drm_device *dev = crtc->dev;
 453         struct drm_mode_config *config = &dev->mode_config;
 454         bool replaced = false;
 455         int ret;
 456
 457         if (property == config->prop_active)
 458                 state->active = val;
 459         else if (property == config->prop_mode_id) {
 460                 struct drm_property_blob *mode =
 461                         drm_property_lookup_blob(dev, val);
 462                 ret = drm_atomic_set_mode_prop_for_crtc(state, mode);
 463                 drm_property_unreference_blob(mode);
 464                 return ret;
 465         } else if (property == config->degamma_lut_property) {
 466                 ret = drm_atomic_replace_property_blob_from_id(crtc,
 467                                         &state->degamma_lut,
 468                                         val,
 469                                         -1,
 470                                         &replaced);
 471                 state->color_mgmt_changed = replaced;
 472                 return ret;
 473         } else if (property == config->ctm_property) {
 474                 ret = drm_atomic_replace_property_blob_from_id(crtc,
 475                                         &state->ctm,
 476                                         val,
 477                                         sizeof(struct drm_color_ctm),
 478                                         &replaced);
 479                 state->color_mgmt_changed = replaced;
 480                 return ret;
 481         } else if (property == config->gamma_lut_property) {
 482                 ret = drm_atomic_replace_property_blob_from_id(crtc,
 483                                         &state->gamma_lut,
 484                                         val,
 485                                         -1,
 486                                         &replaced);
 487                 state->color_mgmt_changed = replaced;
 488                 return ret;
 489         } else if (crtc->funcs->atomic_set_property)
 490                 return crtc->funcs->atomic_set_property(crtc, state, property, val);
 491         else
 492                 return -EINVAL;
 493
 494         return 0;
 495 }
 496 EXPORT_SYMBOL(drm_atomic_crtc_set_property);
 497
 498 /**
 499  * drm_atomic_crtc_get_property - get property value from CRTC state
 500  * @crtc: the drm CRTC to set a property on
 501  * @state: the state object to get the property value from
 502  * @property: the property to set
 503  * @val: return location for the property value
 504  *
 505  * This function handles generic/core properties and calls out to
 506  * driver's ->atomic_get_property() for driver properties.  To ensure
 507  * consistent behavior you must call this function rather than the
 508  * driver hook directly.
 509  *
 510  * RETURNS:
 511  * Zero on success, error code on failure
 512  */
 513 static int
 514 drm_atomic_crtc_get_property(struct drm_crtc *crtc,
 515                 const struct drm_crtc_state *state,
 516                 struct drm_property *property, uint64_t *val)
 517 {
 518         struct drm_device *dev = crtc->dev;
 519         struct drm_mode_config *config = &dev->mode_config;
 520
 521         if (property == config->prop_active)
 522                 *val = state->active;
 523         else if (property == config->prop_mode_id)
 524                 *val = (state->mode_blob) ? state->mode_blob->base.id : 0;
 525         else if (property == config->degamma_lut_property)
 526                 *val = (state->degamma_lut) ? state->degamma_lut->base.id : 0;
 527         else if (property == config->ctm_property)
 528                 *val = (state->ctm) ? state->ctm->base.id : 0;
 529         else if (property == config->gamma_lut_property)
 530                 *val = (state->gamma_lut) ? state->gamma_lut->base.id : 0;
 531         else if (crtc->funcs->atomic_get_property)
 532                 return crtc->funcs->atomic_get_property(crtc, state, property, val);
 533         else
 534                 return -EINVAL;
 535
 536         return 0;
 537 }
 538
 539 /**
 540  * drm_atomic_crtc_check - check crtc state
 541  * @crtc: crtc to check
 542  * @state: crtc state to check
 543  *
 544  * Provides core sanity checks for crtc state.
 545  *
 546  * RETURNS:
 547  * Zero on success, error code on failure
 548  */
 549 static int drm_atomic_crtc_check(struct drm_crtc *crtc,
 550                 struct drm_crtc_state *state)
 551 {
 552         /* NOTE: we explicitly don't enforce constraints such as primary
 553          * layer covering entire screen, since that is something we want
 554          * to allow (on hw that supports it).  For hw that does not, it
 555          * should be checked in driver's crtc->atomic_check() vfunc.
 556          *
 557          * TODO: Add generic modeset state checks once we support those.
 558          */
 559
 560         if (state->active && !state->enable) {
 561                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
 562                                  crtc->base.id, crtc->name);
 563                 return -EINVAL;
 564         }
 565
 566         /* The state->enable vs. state->mode_blob checks can be WARN_ON,
 567          * as this is a kernel-internal detail that userspace should never
 568          * be able to trigger. */
 569         if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
 570             WARN_ON(state->enable && !state->mode_blob)) {
 571                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
 572                                  crtc->base.id, crtc->name);
 573                 return -EINVAL;
 574         }
 575
 576         if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
 577             WARN_ON(!state->enable && state->mode_blob)) {
 578                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
 579                                  crtc->base.id, crtc->name);
 580                 return -EINVAL;
 581         }
 582
 583         /*
 584          * Reject event generation for when a CRTC is off and stays off.
 585          * It wouldn't be hard to implement this, but userspace has a track
 586          * record of happily burning through 100% cpu (or worse, crash) when the
 587          * display pipe is suspended. To avoid all that fun just reject updates
 588          * that ask for events since likely that indicates a bug in the
 589          * compositor's drawing loop. This is consistent with the vblank IOCTL
 590          * and legacy page_flip IOCTL which also reject service on a disabled
 591          * pipe.
 592          */
 593         if (state->event && !state->active && !crtc->state->active) {
 594                 DRM_DEBUG_ATOMIC("[CRTC:%d] requesting event but off\n",
 595                                  crtc->base.id);
 596                 return -EINVAL;
 597         }
 598
 599         return 0;
 600 }
 601
 602 /**
 603  * drm_atomic_get_plane_state - get plane state
 604  * @state: global atomic state object
 605  * @plane: plane to get state object for
 606  *
 607  * This function returns the plane state for the given plane, allocating it if
 608  * needed. It will also grab the relevant plane lock to make sure that the state
 609  * is consistent.
 610  *
 611  * Returns:
 612  *
 613  * Either the allocated state or the error code encoded into the pointer. When
 614  * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
 615  * entire atomic sequence must be restarted. All other errors are fatal.
 616  */
 617 struct drm_plane_state *
 618 drm_atomic_get_plane_state(struct drm_atomic_state *state,
 619                           struct drm_plane *plane)
 620 {
 621         int ret, index = drm_plane_index(plane);
 622         struct drm_plane_state *plane_state;
 623
 624         plane_state = drm_atomic_get_existing_plane_state(state, plane);
 625         if (plane_state)
 626                 return plane_state;
 627
 628         ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
 629         if (ret)
 630                 return ERR_PTR(ret);
 631
 632         plane_state = plane->funcs->atomic_duplicate_state(plane);
 633         if (!plane_state)
 634                 return ERR_PTR(-ENOMEM);
 635
 636         state->plane_states[index] = plane_state;
 637         state->planes[index] = plane;
 638         plane_state->state = state;
 639
 640         DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
 641                          plane->base.id, plane->name, plane_state, state);
 642
 643         if (plane_state->crtc) {
 644                 struct drm_crtc_state *crtc_state;
 645
 646                 crtc_state = drm_atomic_get_crtc_state(state,
 647                                                        plane_state->crtc);
 648                 if (IS_ERR(crtc_state))
 649                         return ERR_CAST(crtc_state);
 650         }
 651
 652         return plane_state;
 653 }
 654 EXPORT_SYMBOL(drm_atomic_get_plane_state);
 655
 656 /**
 657  * drm_atomic_plane_set_property - set property on plane
 658  * @plane: the drm plane to set a property on
 659  * @state: the state object to update with the new property value
 660  * @property: the property to set
 661  * @val: the new property value
 662  *
 663  * Use this instead of calling plane->atomic_set_property directly.
 664  * This function handles generic/core properties and calls out to
 665  * driver's ->atomic_set_property() for driver properties.  To ensure
 666  * consistent behavior you must call this function rather than the
 667  * driver hook directly.
 668  *
 669  * RETURNS:
 670  * Zero on success, error code on failure
 671  */
 672 int drm_atomic_plane_set_property(struct drm_plane *plane,
 673                 struct drm_plane_state *state, struct drm_property *property,
 674                 uint64_t val)
 675 {
 676         struct drm_device *dev = plane->dev;
 677         struct drm_mode_config *config = &dev->mode_config;
 678
 679         if (property == config->prop_fb_id) {
 680                 struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
 681                 drm_atomic_set_fb_for_plane(state, fb);
 682                 if (fb)
 683                         drm_framebuffer_unreference(fb);
 684         } else if (property == config->prop_crtc_id) {
 685                 struct drm_crtc *crtc = drm_crtc_find(dev, val);
 686                 return drm_atomic_set_crtc_for_plane(state, crtc);
 687         } else if (property == config->prop_crtc_x) {
 688                 state->crtc_x = U642I64(val);
 689         } else if (property == config->prop_crtc_y) {
 690                 state->crtc_y = U642I64(val);
 691         } else if (property == config->prop_crtc_w) {
 692                 state->crtc_w = val;
 693         } else if (property == config->prop_crtc_h) {
 694                 state->crtc_h = val;
 695         } else if (property == config->prop_src_x) {
 696                 state->src_x = val;
 697         } else if (property == config->prop_src_y) {
 698                 state->src_y = val;
 699         } else if (property == config->prop_src_w) {
 700                 state->src_w = val;
 701         } else if (property == config->prop_src_h) {
 702                 state->src_h = val;
 703         } else if (property == config->rotation_property) {
 704                 state->rotation = val;
 705         } else if (plane->funcs->atomic_set_property) {
 706                 return plane->funcs->atomic_set_property(plane, state,
 707                                 property, val);
 708         } else {
 709                 return -EINVAL;
 710         }
 711
 712         return 0;
 713 }
 714 EXPORT_SYMBOL(drm_atomic_plane_set_property);
 715
 716 /**
 717  * drm_atomic_plane_get_property - get property value from plane state
 718  * @plane: the drm plane to set a property on
 719  * @state: the state object to get the property value from
 720  * @property: the property to set
 721  * @val: return location for the property value
 722  *
 723  * This function handles generic/core properties and calls out to
 724  * driver's ->atomic_get_property() for driver properties.  To ensure
 725  * consistent behavior you must call this function rather than the
 726  * driver hook directly.
 727  *
 728  * RETURNS:
 729  * Zero on success, error code on failure
 730  */
 731 static int
 732 drm_atomic_plane_get_property(struct drm_plane *plane,
 733                 const struct drm_plane_state *state,
 734                 struct drm_property *property, uint64_t *val)
 735 {
 736         struct drm_device *dev = plane->dev;
 737         struct drm_mode_config *config = &dev->mode_config;
 738
 739         if (property == config->prop_fb_id) {
 740                 *val = (state->fb) ? state->fb->base.id : 0;
 741         } else if (property == config->prop_crtc_id) {
 742                 *val = (state->crtc) ? state->crtc->base.id : 0;
 743         } else if (property == config->prop_crtc_x) {
 744                 *val = I642U64(state->crtc_x);
 745         } else if (property == config->prop_crtc_y) {
 746                 *val = I642U64(state->crtc_y);
 747         } else if (property == config->prop_crtc_w) {
 748                 *val = state->crtc_w;
 749         } else if (property == config->prop_crtc_h) {
 750                 *val = state->crtc_h;
 751         } else if (property == config->prop_src_x) {
 752                 *val = state->src_x;
 753         } else if (property == config->prop_src_y) {
 754                 *val = state->src_y;
 755         } else if (property == config->prop_src_w) {
 756                 *val = state->src_w;
 757         } else if (property == config->prop_src_h) {
 758                 *val = state->src_h;
 759         } else if (property == config->rotation_property) {
 760                 *val = state->rotation;
 761         } else if (plane->funcs->atomic_get_property) {
 762                 return plane->funcs->atomic_get_property(plane, state, property, val);
 763         } else {
 764                 return -EINVAL;
 765         }
 766
 767         return 0;
 768 }
 769
 770 static bool
 771 plane_switching_crtc(struct drm_atomic_state *state,
 772                      struct drm_plane *plane,
 773                      struct drm_plane_state *plane_state)
 774 {
 775         if (!plane->state->crtc || !plane_state->crtc)
 776                 return false;
 777
 778         if (plane->state->crtc == plane_state->crtc)
 779                 return false;
 780
 781         /* This could be refined, but currently there's no helper or driver code
 782          * to implement direct switching of active planes nor userspace to take
 783          * advantage of more direct plane switching without the intermediate
 784          * full OFF state.
 785          */
 786         return true;
 787 }
 788
 789 /**
 790  * drm_atomic_plane_check - check plane state
 791  * @plane: plane to check
 792  * @state: plane state to check
 793  *
 794  * Provides core sanity checks for plane state.
 795  *
 796  * RETURNS:
 797  * Zero on success, error code on failure
 798  */
 799 static int drm_atomic_plane_check(struct drm_plane *plane,
 800                 struct drm_plane_state *state)
 801 {
 802         unsigned int fb_width, fb_height;
 803         int ret;
 804
 805         /* either *both* CRTC and FB must be set, or neither */
 806         if (WARN_ON(state->crtc && !state->fb)) {
 807                 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
 808                 return -EINVAL;
 809         } else if (WARN_ON(state->fb && !state->crtc)) {
 810                 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
 811                 return -EINVAL;
 812         }
 813
 814         /* if disabled, we don't care about the rest of the state: */
 815         if (!state->crtc)
 816                 return 0;
 817
 818         /* Check whether this plane is usable on this CRTC */
 819         if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
 820                 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
 821                 return -EINVAL;
 822         }
 823
 824         /* Check whether this plane supports the fb pixel format. */
 825         ret = drm_plane_check_pixel_format(plane, state->fb->pixel_format);
 826         if (ret) {
 827                 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
 828                                  drm_get_format_name(state->fb->pixel_format));
 829                 return ret;
 830         }
 831
 832         /* Give drivers some help against integer overflows */
 833         if (state->crtc_w > INT_MAX ||
 834             state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
 835             state->crtc_h > INT_MAX ||
 836             state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
 837                 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
 838                                  state->crtc_w, state->crtc_h,
 839                                  state->crtc_x, state->crtc_y);
 840                 return -ERANGE;
 841         }
 842
 843         fb_width = state->fb->width << 16;
 844         fb_height = state->fb->height << 16;
 845
 846         /* Make sure source coordinates are inside the fb. */
 847         if (state->src_w > fb_width ||
 848             state->src_x > fb_width - state->src_w ||
 849             state->src_h > fb_height ||
 850             state->src_y > fb_height - state->src_h) {
 851                 DRM_DEBUG_ATOMIC("Invalid source coordinates "
 852                                  "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
 853                                  state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
 854                                  state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
 855                                  state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
 856                                  state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
 857                 return -ENOSPC;
 858         }
 859
 860         if (plane_switching_crtc(state->state, plane, state)) {
 861                 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
 862                                  plane->base.id, plane->name);
 863                 return -EINVAL;
 864         }
 865
 866         return 0;
 867 }
 868
 869 /**
 870  * drm_atomic_get_connector_state - get connector state
 871  * @state: global atomic state object
 872  * @connector: connector to get state object for
 873  *
 874  * This function returns the connector state for the given connector,
 875  * allocating it if needed. It will also grab the relevant connector lock to
 876  * make sure that the state is consistent.
 877  *
 878  * Returns:
 879  *
 880  * Either the allocated state or the error code encoded into the pointer. When
 881  * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
 882  * entire atomic sequence must be restarted. All other errors are fatal.
 883  */
 884 struct drm_connector_state *
 885 drm_atomic_get_connector_state(struct drm_atomic_state *state,
 886                           struct drm_connector *connector)
 887 {
 888         int ret, index;
 889         struct drm_mode_config *config = &connector->dev->mode_config;
 890         struct drm_connector_state *connector_state;
 891
 892         ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
 893         if (ret)
 894                 return ERR_PTR(ret);
 895
 896         index = drm_connector_index(connector);
 897
 898         if (index >= state->num_connector) {
 899                 struct drm_connector **c;
 900                 struct drm_connector_state **cs;
 901                 int alloc = max(index + 1, config->num_connector);
 902
 903                 c = krealloc(state->connectors, alloc * sizeof(*state->connectors), GFP_KERNEL);
 904                 if (!c)
 905                         return ERR_PTR(-ENOMEM);
 906
 907                 state->connectors = c;
 908                 memset(&state->connectors[state->num_connector], 0,
 909                        sizeof(*state->connectors) * (alloc - state->num_connector));
 910
 911                 cs = krealloc(state->connector_states, alloc * sizeof(*state->connector_states), GFP_KERNEL);
 912                 if (!cs)
 913                         return ERR_PTR(-ENOMEM);
 914
 915                 state->connector_states = cs;
 916                 memset(&state->connector_states[state->num_connector], 0,
 917                        sizeof(*state->connector_states) * (alloc - state->num_connector));
 918                 state->num_connector = alloc;
 919         }
 920
 921         if (state->connector_states[index])
 922                 return state->connector_states[index];
 923
 924         connector_state = connector->funcs->atomic_duplicate_state(connector);
 925         if (!connector_state)
 926                 return ERR_PTR(-ENOMEM);
 927
 928         state->connector_states[index] = connector_state;
 929         state->connectors[index] = connector;
 930         connector_state->state = state;
 931
 932         DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
 933                          connector->base.id, connector_state, state);
 934
 935         if (connector_state->crtc) {
 936                 struct drm_crtc_state *crtc_state;
 937
 938                 crtc_state = drm_atomic_get_crtc_state(state,
 939                                                        connector_state->crtc);
 940                 if (IS_ERR(crtc_state))
 941                         return ERR_CAST(crtc_state);
 942         }
 943
 944         return connector_state;
 945 }
 946 EXPORT_SYMBOL(drm_atomic_get_connector_state);
 947
 948 /**
 949  * drm_atomic_connector_set_property - set property on connector.
 950  * @connector: the drm connector to set a property on
 951  * @state: the state object to update with the new property value
 952  * @property: the property to set
 953  * @val: the new property value
 954  *
 955  * Use this instead of calling connector->atomic_set_property directly.
 956  * This function handles generic/core properties and calls out to
 957  * driver's ->atomic_set_property() for driver properties.  To ensure
 958  * consistent behavior you must call this function rather than the
 959  * driver hook directly.
 960  *
 961  * RETURNS:
 962  * Zero on success, error code on failure
 963  */
 964 int drm_atomic_connector_set_property(struct drm_connector *connector,
 965                 struct drm_connector_state *state, struct drm_property *property,
 966                 uint64_t val)
 967 {
 968         struct drm_device *dev = connector->dev;
 969         struct drm_mode_config *config = &dev->mode_config;
 970
 971         if (property == config->prop_crtc_id) {
 972                 struct drm_crtc *crtc = drm_crtc_find(dev, val);
 973                 return drm_atomic_set_crtc_for_connector(state, crtc);
 974         } else if (property == config->dpms_property) {
 975                 /* setting DPMS property requires special handling, which
 976                  * is done in legacy setprop path for us.  Disallow (for
 977                  * now?) atomic writes to DPMS property:
 978                  */
 979                 return -EINVAL;
 980         } else if (connector->funcs->atomic_set_property) {
 981                 return connector->funcs->atomic_set_property(connector,
 982                                 state, property, val);
 983         } else {
 984                 return -EINVAL;
 985         }
 986 }
 987 EXPORT_SYMBOL(drm_atomic_connector_set_property);
 988
 989 /**
 990  * drm_atomic_connector_get_property - get property value from connector state
 991  * @connector: the drm connector to set a property on
 992  * @state: the state object to get the property value from
 993  * @property: the property to set
 994  * @val: return location for the property value
 995  *
 996  * This function handles generic/core properties and calls out to
 997  * driver's ->atomic_get_property() for driver properties.  To ensure
 998  * consistent behavior you must call this function rather than the
 999  * driver hook directly.
1000  *
1001  * RETURNS:
1002  * Zero on success, error code on failure
1003  */
1004 static int
1005 drm_atomic_connector_get_property(struct drm_connector *connector,
1006                 const struct drm_connector_state *state,
1007                 struct drm_property *property, uint64_t *val)
1008 {
1009         struct drm_device *dev = connector->dev;
1010         struct drm_mode_config *config = &dev->mode_config;
1011
1012         if (property == config->prop_crtc_id) {
1013                 *val = (state->crtc) ? state->crtc->base.id : 0;
1014         } else if (property == config->dpms_property) {
1015                 *val = connector->dpms;
1016         } else if (connector->funcs->atomic_get_property) {
1017                 return connector->funcs->atomic_get_property(connector,
1018                                 state, property, val);
1019         } else {
1020                 return -EINVAL;
1021         }
1022
1023         return 0;
1024 }
1025
1026 int drm_atomic_get_property(struct drm_mode_object *obj,
1027                 struct drm_property *property, uint64_t *val)
1028 {
1029         struct drm_device *dev = property->dev;
1030         int ret;
1031
1032         switch (obj->type) {
1033         case DRM_MODE_OBJECT_CONNECTOR: {
1034                 struct drm_connector *connector = obj_to_connector(obj);
1035                 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
1036                 ret = drm_atomic_connector_get_property(connector,
1037                                 connector->state, property, val);
1038                 break;
1039         }
1040         case DRM_MODE_OBJECT_CRTC: {
1041                 struct drm_crtc *crtc = obj_to_crtc(obj);
1042                 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
1043                 ret = drm_atomic_crtc_get_property(crtc,
1044                                 crtc->state, property, val);
1045                 break;
1046         }
1047         case DRM_MODE_OBJECT_PLANE: {
1048                 struct drm_plane *plane = obj_to_plane(obj);
1049                 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
1050                 ret = drm_atomic_plane_get_property(plane,
1051                                 plane->state, property, val);
1052                 break;
1053         }
1054         default:
1055                 ret = -EINVAL;
1056                 break;
1057         }
1058
1059         return ret;
1060 }
1061
1062 /**
1063  * drm_atomic_set_crtc_for_plane - set crtc for plane
1064  * @plane_state: the plane whose incoming state to update
1065  * @crtc: crtc to use for the plane
1066  *
1067  * Changing the assigned crtc for a plane requires us to grab the lock and state
1068  * for the new crtc, as needed. This function takes care of all these details
1069  * besides updating the pointer in the state object itself.
1070  *
1071  * Returns:
1072  * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1073  * then the w/w mutex code has detected a deadlock and the entire atomic
1074  * sequence must be restarted. All other errors are fatal.
1075  */
1076 int
1077 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
1078                               struct drm_crtc *crtc)
1079 {
1080         struct drm_plane *plane = plane_state->plane;
1081         struct drm_crtc_state *crtc_state;
1082
1083         if (plane_state->crtc) {
1084                 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1085                                                        plane_state->crtc);
1086                 if (WARN_ON(IS_ERR(crtc_state)))
1087                         return PTR_ERR(crtc_state);
1088
1089                 crtc_state->plane_mask &= ~(1 << drm_plane_index(plane));
1090         }
1091
1092         plane_state->crtc = crtc;
1093
1094         if (crtc) {
1095                 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1096                                                        crtc);
1097                 if (IS_ERR(crtc_state))
1098                         return PTR_ERR(crtc_state);
1099                 crtc_state->plane_mask |= (1 << drm_plane_index(plane));
1100         }
1101
1102         if (crtc)
1103                 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n",
1104                                  plane_state, crtc->base.id, crtc->name);
1105         else
1106                 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
1107                                  plane_state);
1108
1109         return 0;
1110 }
1111 EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
1112
1113 /**
1114  * drm_atomic_set_fb_for_plane - set framebuffer for plane
1115  * @plane_state: atomic state object for the plane
1116  * @fb: fb to use for the plane
1117  *
1118  * Changing the assigned framebuffer for a plane requires us to grab a reference
1119  * to the new fb and drop the reference to the old fb, if there is one. This
1120  * function takes care of all these details besides updating the pointer in the
1121  * state object itself.
1122  */
1123 void
1124 drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
1125                             struct drm_framebuffer *fb)
1126 {
1127         if (plane_state->fb)
1128                 drm_framebuffer_unreference(plane_state->fb);
1129         if (fb)
1130                 drm_framebuffer_reference(fb);
1131         plane_state->fb = fb;
1132
1133         if (fb)
1134                 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1135                                  fb->base.id, plane_state);
1136         else
1137                 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1138                                  plane_state);
1139 }
1140 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
1141
1142 /**
1143  * drm_atomic_set_crtc_for_connector - set crtc for connector
1144  * @conn_state: atomic state object for the connector
1145  * @crtc: crtc to use for the connector
1146  *
1147  * Changing the assigned crtc for a connector requires us to grab the lock and
1148  * state for the new crtc, as needed. This function takes care of all these
1149  * details besides updating the pointer in the state object itself.
1150  *
1151  * Returns:
1152  * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1153  * then the w/w mutex code has detected a deadlock and the entire atomic
1154  * sequence must be restarted. All other errors are fatal.
1155  */
1156 int
1157 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
1158                                   struct drm_crtc *crtc)
1159 {
1160         struct drm_crtc_state *crtc_state;
1161
1162         if (conn_state->crtc && conn_state->crtc != crtc) {
1163                 crtc_state = drm_atomic_get_existing_crtc_state(conn_state->state,
1164                                                                 conn_state->crtc);
1165
1166                 crtc_state->connector_mask &=
1167                         ~(1 << drm_connector_index(conn_state->connector));
1168         }
1169
1170         if (crtc) {
1171                 crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
1172                 if (IS_ERR(crtc_state))
1173                         return PTR_ERR(crtc_state);
1174
1175                 crtc_state->connector_mask |=
1176                         1 << drm_connector_index(conn_state->connector);
1177         }
1178
1179         conn_state->crtc = crtc;
1180
1181         if (crtc)
1182                 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n",
1183                                  conn_state, crtc->base.id, crtc->name);
1184         else
1185                 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1186                                  conn_state);
1187
1188         return 0;
1189 }
1190 EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
1191
1192 /**
1193  * drm_atomic_add_affected_connectors - add connectors for crtc
1194  * @state: atomic state
1195  * @crtc: DRM crtc
1196  *
1197  * This function walks the current configuration and adds all connectors
1198  * currently using @crtc to the atomic configuration @state. Note that this
1199  * function must acquire the connection mutex. This can potentially cause
1200  * unneeded seralization if the update is just for the planes on one crtc. Hence
1201  * drivers and helpers should only call this when really needed (e.g. when a
1202  * full modeset needs to happen due to some change).
1203  *
1204  * Returns:
1205  * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1206  * then the w/w mutex code has detected a deadlock and the entire atomic
1207  * sequence must be restarted. All other errors are fatal.
1208  */
1209 int
1210 drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
1211                                    struct drm_crtc *crtc)
1212 {
1213         struct drm_mode_config *config = &state->dev->mode_config;
1214         struct drm_connector *connector;
1215         struct drm_connector_state *conn_state;
1216         int ret;
1217
1218         ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1219         if (ret)
1220                 return ret;
1221
1222         DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1223                          crtc->base.id, crtc->name, state);
1224
1225         /*
1226          * Changed connectors are already in @state, so only need to look at the
1227          * current configuration.
1228          */
1229         drm_for_each_connector(connector, state->dev) {
1230                 if (connector->state->crtc != crtc)
1231                         continue;
1232
1233                 conn_state = drm_atomic_get_connector_state(state, connector);
1234                 if (IS_ERR(conn_state))
1235                         return PTR_ERR(conn_state);
1236         }
1237
1238         return 0;
1239 }
1240 EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
1241
1242 /**
1243  * drm_atomic_add_affected_planes - add planes for crtc
1244  * @state: atomic state
1245  * @crtc: DRM crtc
1246  *
1247  * This function walks the current configuration and adds all planes
1248  * currently used by @crtc to the atomic configuration @state. This is useful
1249  * when an atomic commit also needs to check all currently enabled plane on
1250  * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1251  * to avoid special code to force-enable all planes.
1252  *
1253  * Since acquiring a plane state will always also acquire the w/w mutex of the
1254  * current CRTC for that plane (if there is any) adding all the plane states for
1255  * a CRTC will not reduce parallism of atomic updates.
1256  *
1257  * Returns:
1258  * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1259  * then the w/w mutex code has detected a deadlock and the entire atomic
1260  * sequence must be restarted. All other errors are fatal.
1261  */
1262 int
1263 drm_atomic_add_affected_planes(struct drm_atomic_state *state,
1264                                struct drm_crtc *crtc)
1265 {
1266         struct drm_plane *plane;
1267
1268         WARN_ON(!drm_atomic_get_existing_crtc_state(state, crtc));
1269
1270         drm_for_each_plane_mask(plane, state->dev, crtc->state->plane_mask) {
1271                 struct drm_plane_state *plane_state =
1272                         drm_atomic_get_plane_state(state, plane);
1273
1274                 if (IS_ERR(plane_state))
1275                         return PTR_ERR(plane_state);
1276         }
1277         return 0;
1278 }
1279 EXPORT_SYMBOL(drm_atomic_add_affected_planes);
1280
1281 /**
1282  * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1283  * @state: atomic state
1284  *
1285  * This function should be used by legacy entry points which don't understand
1286  * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
1287  * the slowpath completed.
1288  */
1289 void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
1290 {
1291         int ret;
1292
1293 retry:
1294         drm_modeset_backoff(state->acquire_ctx);
1295
1296         ret = drm_modeset_lock_all_ctx(state->dev, state->acquire_ctx);
1297         if (ret)
1298                 goto retry;
1299 }
1300 EXPORT_SYMBOL(drm_atomic_legacy_backoff);
1301
1302 /**
1303  * drm_atomic_check_only - check whether a given config would work
1304  * @state: atomic configuration to check
1305  *
1306  * Note that this function can return -EDEADLK if the driver needed to acquire
1307  * more locks but encountered a deadlock. The caller must then do the usual w/w
1308  * backoff dance and restart. All other errors are fatal.
1309  *
1310  * Returns:
1311  * 0 on success, negative error code on failure.
1312  */
1313 int drm_atomic_check_only(struct drm_atomic_state *state)
1314 {
1315         struct drm_device *dev = state->dev;
1316         struct drm_mode_config *config = &dev->mode_config;
1317         struct drm_plane *plane;
1318         struct drm_plane_state *plane_state;
1319         struct drm_crtc *crtc;
1320         struct drm_crtc_state *crtc_state;
1321         int i, ret = 0;
1322
1323         DRM_DEBUG_ATOMIC("checking %p\n", state);
1324
1325         for_each_plane_in_state(state, plane, plane_state, i) {
1326                 ret = drm_atomic_plane_check(plane, plane_state);
1327                 if (ret) {
1328                         DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1329                                          plane->base.id, plane->name);
1330                         return ret;
1331                 }
1332         }
1333
1334         for_each_crtc_in_state(state, crtc, crtc_state, i) {
1335                 ret = drm_atomic_crtc_check(crtc, crtc_state);
1336                 if (ret) {
1337                         DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1338                                          crtc->base.id, crtc->name);
1339                         return ret;
1340                 }
1341         }
1342
1343         if (config->funcs->atomic_check)
1344                 ret = config->funcs->atomic_check(state->dev, state);
1345
1346         if (!state->allow_modeset) {
1347                 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1348                         if (drm_atomic_crtc_needs_modeset(crtc_state)) {
1349                                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1350                                                  crtc->base.id, crtc->name);
1351                                 return -EINVAL;
1352                         }
1353                 }
1354         }
1355
1356         return ret;
1357 }
1358 EXPORT_SYMBOL(drm_atomic_check_only);
1359
1360 /**
1361  * drm_atomic_commit - commit configuration atomically
1362  * @state: atomic configuration to check
1363  *
1364  * Note that this function can return -EDEADLK if the driver needed to acquire
1365  * more locks but encountered a deadlock. The caller must then do the usual w/w
1366  * backoff dance and restart. All other errors are fatal.
1367  *
1368  * Also note that on successful execution ownership of @state is transferred
1369  * from the caller of this function to the function itself. The caller must not
1370  * free or in any other way access @state. If the function fails then the caller
1371  * must clean up @state itself.
1372  *
1373  * Returns:
1374  * 0 on success, negative error code on failure.
1375  */
1376 int drm_atomic_commit(struct drm_atomic_state *state)
1377 {
1378         struct drm_mode_config *config = &state->dev->mode_config;
1379         int ret;
1380
1381         ret = drm_atomic_check_only(state);
1382         if (ret)
1383                 return ret;
1384
1385         DRM_DEBUG_ATOMIC("commiting %p\n", state);
1386
1387         return config->funcs->atomic_commit(state->dev, state, false);
1388 }
1389 EXPORT_SYMBOL(drm_atomic_commit);
1390
1391 /**
1392  * drm_atomic_async_commit - atomic&async configuration commit
1393  * @state: atomic configuration to check
1394  *
1395  * Note that this function can return -EDEADLK if the driver needed to acquire
1396  * more locks but encountered a deadlock. The caller must then do the usual w/w
1397  * backoff dance and restart. All other errors are fatal.
1398  *
1399  * Also note that on successful execution ownership of @state is transferred
1400  * from the caller of this function to the function itself. The caller must not
1401  * free or in any other way access @state. If the function fails then the caller
1402  * must clean up @state itself.
1403  *
1404  * Returns:
1405  * 0 on success, negative error code on failure.
1406  */
1407 int drm_atomic_async_commit(struct drm_atomic_state *state)
1408 {
1409         struct drm_mode_config *config = &state->dev->mode_config;
1410         int ret;
1411
1412         ret = drm_atomic_check_only(state);
1413         if (ret)
1414                 return ret;
1415
1416         DRM_DEBUG_ATOMIC("commiting %p asynchronously\n", state);
1417
1418         return config->funcs->atomic_commit(state->dev, state, true);
1419 }
1420 EXPORT_SYMBOL(drm_atomic_async_commit);
1421
1422 /*
1423  * The big monstor ioctl
1424  */
1425
1426 static struct drm_pending_vblank_event *create_vblank_event(
1427                 struct drm_device *dev, struct drm_file *file_priv, uint64_t user_data)
1428 {
1429         struct drm_pending_vblank_event *e = NULL;
1430         int ret;
1431
1432         e = kzalloc(sizeof *e, GFP_KERNEL);
1433         if (!e)
1434                 return NULL;
1435
1436         e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
1437         e->event.base.length = sizeof(e->event);
1438         e->event.user_data = user_data;
1439
1440         ret = drm_event_reserve_init(dev, file_priv, &e->base, &e->event.base);
1441         if (ret) {
1442                 kfree(e);
1443                 return NULL;
1444         }
1445
1446         return e;
1447 }
1448
1449 static int atomic_set_prop(struct drm_atomic_state *state,
1450                 struct drm_mode_object *obj, struct drm_property *prop,
1451                 uint64_t prop_value)
1452 {
1453         struct drm_mode_object *ref;
1454         int ret;
1455
1456         if (!drm_property_change_valid_get(prop, prop_value, &ref))
1457                 return -EINVAL;
1458
1459         switch (obj->type) {
1460         case DRM_MODE_OBJECT_CONNECTOR: {
1461                 struct drm_connector *connector = obj_to_connector(obj);
1462                 struct drm_connector_state *connector_state;
1463
1464                 connector_state = drm_atomic_get_connector_state(state, connector);
1465                 if (IS_ERR(connector_state)) {
1466                         ret = PTR_ERR(connector_state);
1467                         break;
1468                 }
1469
1470                 ret = drm_atomic_connector_set_property(connector,
1471                                 connector_state, prop, prop_value);
1472                 break;
1473         }
1474         case DRM_MODE_OBJECT_CRTC: {
1475                 struct drm_crtc *crtc = obj_to_crtc(obj);
1476                 struct drm_crtc_state *crtc_state;
1477
1478                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1479                 if (IS_ERR(crtc_state)) {
1480                         ret = PTR_ERR(crtc_state);
1481                         break;
1482                 }
1483
1484                 ret = drm_atomic_crtc_set_property(crtc,
1485                                 crtc_state, prop, prop_value);
1486                 break;
1487         }
1488         case DRM_MODE_OBJECT_PLANE: {
1489                 struct drm_plane *plane = obj_to_plane(obj);
1490                 struct drm_plane_state *plane_state;
1491
1492                 plane_state = drm_atomic_get_plane_state(state, plane);
1493                 if (IS_ERR(plane_state)) {
1494                         ret = PTR_ERR(plane_state);
1495                         break;
1496                 }
1497
1498                 ret = drm_atomic_plane_set_property(plane,
1499                                 plane_state, prop, prop_value);
1500                 break;
1501         }
1502         default:
1503                 ret = -EINVAL;
1504                 break;
1505         }
1506
1507         drm_property_change_valid_put(prop, ref);
1508         return ret;
1509 }
1510
1511 /**
1512  * drm_atomic_clean_old_fb -- Unset old_fb pointers and set plane->fb pointers.
1513  *
1514  * @dev: drm device to check.
1515  * @plane_mask: plane mask for planes that were updated.
1516  * @ret: return value, can be -EDEADLK for a retry.
1517  *
1518  * Before doing an update plane->old_fb is set to plane->fb,
1519  * but before dropping the locks old_fb needs to be set to NULL
1520  * and plane->fb updated. This is a common operation for each
1521  * atomic update, so this call is split off as a helper.
1522  */
1523 void drm_atomic_clean_old_fb(struct drm_device *dev,
1524                              unsigned plane_mask,
1525                              int ret)
1526 {
1527         struct drm_plane *plane;
1528
1529         /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1530          * locks (ie. while it is still safe to deref plane->state).  We
1531          * need to do this here because the driver entry points cannot
1532          * distinguish between legacy and atomic ioctls.
1533          */
1534         drm_for_each_plane_mask(plane, dev, plane_mask) {
1535                 if (ret == 0) {
1536                         struct drm_framebuffer *new_fb = plane->state->fb;
1537                         if (new_fb)
1538                                 drm_framebuffer_reference(new_fb);
1539                         plane->fb = new_fb;
1540                         plane->crtc = plane->state->crtc;
1541
1542                         if (plane->old_fb)
1543                                 drm_framebuffer_unreference(plane->old_fb);
1544                 }
1545                 plane->old_fb = NULL;
1546         }
1547 }
1548 EXPORT_SYMBOL(drm_atomic_clean_old_fb);
1549
1550 int drm_mode_atomic_ioctl(struct drm_device *dev,
1551                           void *data, struct drm_file *file_priv)
1552 {
1553         struct drm_mode_atomic *arg = data;
1554         uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
1555         uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
1556         uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
1557         uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
1558         unsigned int copied_objs, copied_props;
1559         struct drm_atomic_state *state;
1560         struct drm_modeset_acquire_ctx ctx;
1561         struct drm_plane *plane;
1562         struct drm_crtc *crtc;
1563         struct drm_crtc_state *crtc_state;
1564         unsigned plane_mask;
1565         int ret = 0;
1566         unsigned int i, j;
1567
1568         /* disallow for drivers not supporting atomic: */
1569         if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1570                 return -EINVAL;
1571
1572         /* disallow for userspace that has not enabled atomic cap (even
1573          * though this may be a bit overkill, since legacy userspace
1574          * wouldn't know how to call this ioctl)
1575          */
1576         if (!file_priv->atomic)
1577                 return -EINVAL;
1578
1579         if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS)
1580                 return -EINVAL;
1581
1582         if (arg->reserved)
1583                 return -EINVAL;
1584
1585         if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) &&
1586                         !dev->mode_config.async_page_flip)
1587                 return -EINVAL;
1588
1589         /* can't test and expect an event at the same time. */
1590         if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
1591                         (arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
1592                 return -EINVAL;
1593
1594         drm_modeset_acquire_init(&ctx, 0);
1595
1596         state = drm_atomic_state_alloc(dev);
1597         if (!state)
1598                 return -ENOMEM;
1599
1600         state->acquire_ctx = &ctx;
1601         state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
1602
1603 retry:
1604         plane_mask = 0;
1605         copied_objs = 0;
1606         copied_props = 0;
1607
1608         for (i = 0; i < arg->count_objs; i++) {
1609                 uint32_t obj_id, count_props;
1610                 struct drm_mode_object *obj;
1611
1612                 if (get_user(obj_id, objs_ptr + copied_objs)) {
1613                         ret = -EFAULT;
1614                         goto out;
1615                 }
1616
1617                 obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
1618                 if (!obj || !obj->properties) {
1619                         ret = -ENOENT;
1620                         goto out;
1621                 }
1622
1623                 if (get_user(count_props, count_props_ptr + copied_objs)) {
1624                         ret = -EFAULT;
1625                         goto out;
1626                 }
1627
1628                 copied_objs++;
1629
1630                 for (j = 0; j < count_props; j++) {
1631                         uint32_t prop_id;
1632                         uint64_t prop_value;
1633                         struct drm_property *prop;
1634
1635                         if (get_user(prop_id, props_ptr + copied_props)) {
1636                                 ret = -EFAULT;
1637                                 goto out;
1638                         }
1639
1640                         prop = drm_property_find(dev, prop_id);
1641                         if (!prop) {
1642                                 ret = -ENOENT;
1643                                 goto out;
1644                         }
1645
1646                         if (copy_from_user(&prop_value,
1647                                            prop_values_ptr + copied_props,
1648                                            sizeof(prop_value))) {
1649                                 ret = -EFAULT;
1650                                 goto out;
1651                         }
1652
1653                         ret = atomic_set_prop(state, obj, prop, prop_value);
1654                         if (ret)
1655                                 goto out;
1656
1657                         copied_props++;
1658                 }
1659
1660                 if (obj->type == DRM_MODE_OBJECT_PLANE && count_props &&
1661                     !(arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)) {
1662                         plane = obj_to_plane(obj);
1663                         plane_mask |= (1 << drm_plane_index(plane));
1664                         plane->old_fb = plane->fb;
1665                 }
1666         }
1667
1668         if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1669                 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1670                         struct drm_pending_vblank_event *e;
1671
1672                         e = create_vblank_event(dev, file_priv, arg->user_data);
1673                         if (!e) {
1674                                 ret = -ENOMEM;
1675                                 goto out;
1676                         }
1677
1678                         crtc_state->event = e;
1679                 }
1680         }
1681
1682         if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
1683                 /*
1684                  * Unlike commit, check_only does not clean up state.
1685                  * Below we call drm_atomic_state_free for it.
1686                  */
1687                 ret = drm_atomic_check_only(state);
1688         } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
1689                 ret = drm_atomic_async_commit(state);
1690         } else {
1691                 ret = drm_atomic_commit(state);
1692         }
1693
1694 out:
1695         drm_atomic_clean_old_fb(dev, plane_mask, ret);
1696
1697         if (ret && arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1698                 /*
1699                  * TEST_ONLY and PAGE_FLIP_EVENT are mutually exclusive,
1700                  * if they weren't, this code should be called on success
1701                  * for TEST_ONLY too.
1702                  */
1703
1704                 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1705                         if (!crtc_state->event)
1706                                 continue;
1707
1708                         drm_event_cancel_free(dev, &crtc_state->event->base);
1709                 }
1710         }
1711
1712         if (ret == -EDEADLK) {
1713                 drm_atomic_state_clear(state);
1714                 drm_modeset_backoff(&ctx);
1715                 goto retry;
1716         }
1717
1718         if (ret || arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)
1719                 drm_atomic_state_free(state);
1720
1721         drm_modeset_drop_locks(&ctx);
1722         drm_modeset_acquire_fini(&ctx);
1723
1724         return ret;
1725 }