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