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 } 1725