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