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_print.h> 33 #include <linux/sync_file.h> 34 35 #include "drm_crtc_internal.h" 36 #include "drm_internal.h" 37 38 void __drm_crtc_commit_free(struct kref *kref) 39 { 40 struct drm_crtc_commit *commit = 41 container_of(kref, struct drm_crtc_commit, ref); 42 43 kfree(commit); 44 } 45 EXPORT_SYMBOL(__drm_crtc_commit_free); 46 47 /** 48 * drm_atomic_state_default_release - 49 * release memory initialized by drm_atomic_state_init 50 * @state: atomic state 51 * 52 * Free all the memory allocated by drm_atomic_state_init. 53 * This should only be used by drivers which are still subclassing 54 * &drm_atomic_state and haven't switched to &drm_private_state yet. 55 */ 56 void drm_atomic_state_default_release(struct drm_atomic_state *state) 57 { 58 kfree(state->connectors); 59 kfree(state->crtcs); 60 kfree(state->planes); 61 kfree(state->private_objs); 62 } 63 EXPORT_SYMBOL(drm_atomic_state_default_release); 64 65 /** 66 * drm_atomic_state_init - init new atomic state 67 * @dev: DRM device 68 * @state: atomic state 69 * 70 * Default implementation for filling in a new atomic state. 71 * This should only be used by drivers which are still subclassing 72 * &drm_atomic_state and haven't switched to &drm_private_state yet. 73 */ 74 int 75 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state) 76 { 77 kref_init(&state->ref); 78 79 /* TODO legacy paths should maybe do a better job about 80 * setting this appropriately? 81 */ 82 state->allow_modeset = true; 83 84 state->crtcs = kcalloc(dev->mode_config.num_crtc, 85 sizeof(*state->crtcs), GFP_KERNEL); 86 if (!state->crtcs) 87 goto fail; 88 state->planes = kcalloc(dev->mode_config.num_total_plane, 89 sizeof(*state->planes), GFP_KERNEL); 90 if (!state->planes) 91 goto fail; 92 93 state->dev = dev; 94 95 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state); 96 97 return 0; 98 fail: 99 drm_atomic_state_default_release(state); 100 return -ENOMEM; 101 } 102 EXPORT_SYMBOL(drm_atomic_state_init); 103 104 /** 105 * drm_atomic_state_alloc - allocate atomic state 106 * @dev: DRM device 107 * 108 * This allocates an empty atomic state to track updates. 109 */ 110 struct drm_atomic_state * 111 drm_atomic_state_alloc(struct drm_device *dev) 112 { 113 struct drm_mode_config *config = &dev->mode_config; 114 115 if (!config->funcs->atomic_state_alloc) { 116 struct drm_atomic_state *state; 117 118 state = kzalloc(sizeof(*state), GFP_KERNEL); 119 if (!state) 120 return NULL; 121 if (drm_atomic_state_init(dev, state) < 0) { 122 kfree(state); 123 return NULL; 124 } 125 return state; 126 } 127 128 return config->funcs->atomic_state_alloc(dev); 129 } 130 EXPORT_SYMBOL(drm_atomic_state_alloc); 131 132 /** 133 * drm_atomic_state_default_clear - clear base atomic state 134 * @state: atomic state 135 * 136 * Default implementation for clearing atomic state. 137 * This should only be used by drivers which are still subclassing 138 * &drm_atomic_state and haven't switched to &drm_private_state yet. 139 */ 140 void drm_atomic_state_default_clear(struct drm_atomic_state *state) 141 { 142 struct drm_device *dev = state->dev; 143 struct drm_mode_config *config = &dev->mode_config; 144 int i; 145 146 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state); 147 148 for (i = 0; i < state->num_connector; i++) { 149 struct drm_connector *connector = state->connectors[i].ptr; 150 151 if (!connector) 152 continue; 153 154 connector->funcs->atomic_destroy_state(connector, 155 state->connectors[i].state); 156 state->connectors[i].ptr = NULL; 157 state->connectors[i].state = NULL; 158 drm_connector_put(connector); 159 } 160 161 for (i = 0; i < config->num_crtc; i++) { 162 struct drm_crtc *crtc = state->crtcs[i].ptr; 163 164 if (!crtc) 165 continue; 166 167 crtc->funcs->atomic_destroy_state(crtc, 168 state->crtcs[i].state); 169 170 state->crtcs[i].ptr = NULL; 171 state->crtcs[i].state = NULL; 172 } 173 174 for (i = 0; i < config->num_total_plane; i++) { 175 struct drm_plane *plane = state->planes[i].ptr; 176 177 if (!plane) 178 continue; 179 180 plane->funcs->atomic_destroy_state(plane, 181 state->planes[i].state); 182 state->planes[i].ptr = NULL; 183 state->planes[i].state = NULL; 184 } 185 186 for (i = 0; i < state->num_private_objs; i++) { 187 struct drm_private_obj *obj = state->private_objs[i].ptr; 188 189 obj->funcs->atomic_destroy_state(obj, 190 state->private_objs[i].state); 191 state->private_objs[i].ptr = NULL; 192 state->private_objs[i].state = NULL; 193 } 194 state->num_private_objs = 0; 195 196 if (state->fake_commit) { 197 drm_crtc_commit_put(state->fake_commit); 198 state->fake_commit = NULL; 199 } 200 } 201 EXPORT_SYMBOL(drm_atomic_state_default_clear); 202 203 /** 204 * drm_atomic_state_clear - clear state object 205 * @state: atomic state 206 * 207 * When the w/w mutex algorithm detects a deadlock we need to back off and drop 208 * all locks. So someone else could sneak in and change the current modeset 209 * configuration. Which means that all the state assembled in @state is no 210 * longer an atomic update to the current state, but to some arbitrary earlier 211 * state. Which could break assumptions the driver's 212 * &drm_mode_config_funcs.atomic_check likely relies on. 213 * 214 * Hence we must clear all cached state and completely start over, using this 215 * function. 216 */ 217 void drm_atomic_state_clear(struct drm_atomic_state *state) 218 { 219 struct drm_device *dev = state->dev; 220 struct drm_mode_config *config = &dev->mode_config; 221 222 if (config->funcs->atomic_state_clear) 223 config->funcs->atomic_state_clear(state); 224 else 225 drm_atomic_state_default_clear(state); 226 } 227 EXPORT_SYMBOL(drm_atomic_state_clear); 228 229 /** 230 * __drm_atomic_state_free - free all memory for an atomic state 231 * @ref: This atomic state to deallocate 232 * 233 * This frees all memory associated with an atomic state, including all the 234 * per-object state for planes, crtcs and connectors. 235 */ 236 void __drm_atomic_state_free(struct kref *ref) 237 { 238 struct drm_atomic_state *state = container_of(ref, typeof(*state), ref); 239 struct drm_mode_config *config = &state->dev->mode_config; 240 241 drm_atomic_state_clear(state); 242 243 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state); 244 245 if (config->funcs->atomic_state_free) { 246 config->funcs->atomic_state_free(state); 247 } else { 248 drm_atomic_state_default_release(state); 249 kfree(state); 250 } 251 } 252 EXPORT_SYMBOL(__drm_atomic_state_free); 253 254 /** 255 * drm_atomic_get_crtc_state - get crtc state 256 * @state: global atomic state object 257 * @crtc: crtc to get state object for 258 * 259 * This function returns the crtc state for the given crtc, allocating it if 260 * needed. It will also grab the relevant crtc lock to make sure that the state 261 * is consistent. 262 * 263 * Returns: 264 * 265 * Either the allocated state or the error code encoded into the pointer. When 266 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the 267 * entire atomic sequence must be restarted. All other errors are fatal. 268 */ 269 struct drm_crtc_state * 270 drm_atomic_get_crtc_state(struct drm_atomic_state *state, 271 struct drm_crtc *crtc) 272 { 273 int ret, index = drm_crtc_index(crtc); 274 struct drm_crtc_state *crtc_state; 275 276 WARN_ON(!state->acquire_ctx); 277 278 crtc_state = drm_atomic_get_existing_crtc_state(state, crtc); 279 if (crtc_state) 280 return crtc_state; 281 282 ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx); 283 if (ret) 284 return ERR_PTR(ret); 285 286 crtc_state = crtc->funcs->atomic_duplicate_state(crtc); 287 if (!crtc_state) 288 return ERR_PTR(-ENOMEM); 289 290 state->crtcs[index].state = crtc_state; 291 state->crtcs[index].old_state = crtc->state; 292 state->crtcs[index].new_state = crtc_state; 293 state->crtcs[index].ptr = crtc; 294 crtc_state->state = state; 295 296 DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n", 297 crtc->base.id, crtc->name, crtc_state, state); 298 299 return crtc_state; 300 } 301 EXPORT_SYMBOL(drm_atomic_get_crtc_state); 302 303 static void set_out_fence_for_crtc(struct drm_atomic_state *state, 304 struct drm_crtc *crtc, s32 __user *fence_ptr) 305 { 306 state->crtcs[drm_crtc_index(crtc)].out_fence_ptr = fence_ptr; 307 } 308 309 static s32 __user *get_out_fence_for_crtc(struct drm_atomic_state *state, 310 struct drm_crtc *crtc) 311 { 312 s32 __user *fence_ptr; 313 314 fence_ptr = state->crtcs[drm_crtc_index(crtc)].out_fence_ptr; 315 state->crtcs[drm_crtc_index(crtc)].out_fence_ptr = NULL; 316 317 return fence_ptr; 318 } 319 320 /** 321 * drm_atomic_set_mode_for_crtc - set mode for CRTC 322 * @state: the CRTC whose incoming state to update 323 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable 324 * 325 * Set a mode (originating from the kernel) on the desired CRTC state and update 326 * the enable property. 327 * 328 * RETURNS: 329 * Zero on success, error code on failure. Cannot return -EDEADLK. 330 */ 331 int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state, 332 const struct drm_display_mode *mode) 333 { 334 struct drm_mode_modeinfo umode; 335 336 /* Early return for no change. */ 337 if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0) 338 return 0; 339 340 drm_property_blob_put(state->mode_blob); 341 state->mode_blob = NULL; 342 343 if (mode) { 344 drm_mode_convert_to_umode(&umode, mode); 345 state->mode_blob = 346 drm_property_create_blob(state->crtc->dev, 347 sizeof(umode), 348 &umode); 349 if (IS_ERR(state->mode_blob)) 350 return PTR_ERR(state->mode_blob); 351 352 drm_mode_copy(&state->mode, mode); 353 state->enable = true; 354 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n", 355 mode->name, state); 356 } else { 357 memset(&state->mode, 0, sizeof(state->mode)); 358 state->enable = false; 359 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n", 360 state); 361 } 362 363 return 0; 364 } 365 EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc); 366 367 /** 368 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC 369 * @state: the CRTC whose incoming state to update 370 * @blob: pointer to blob property to use for mode 371 * 372 * Set a mode (originating from a blob property) on the desired CRTC state. 373 * This function will take a reference on the blob property for the CRTC state, 374 * and release the reference held on the state's existing mode property, if any 375 * was set. 376 * 377 * RETURNS: 378 * Zero on success, error code on failure. Cannot return -EDEADLK. 379 */ 380 int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state, 381 struct drm_property_blob *blob) 382 { 383 if (blob == state->mode_blob) 384 return 0; 385 386 drm_property_blob_put(state->mode_blob); 387 state->mode_blob = NULL; 388 389 memset(&state->mode, 0, sizeof(state->mode)); 390 391 if (blob) { 392 if (blob->length != sizeof(struct drm_mode_modeinfo) || 393 drm_mode_convert_umode(state->crtc->dev, &state->mode, 394 blob->data)) 395 return -EINVAL; 396 397 state->mode_blob = drm_property_blob_get(blob); 398 state->enable = true; 399 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n", 400 state->mode.name, state); 401 } else { 402 state->enable = false; 403 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n", 404 state); 405 } 406 407 return 0; 408 } 409 EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc); 410 411 /** 412 * drm_atomic_replace_property_blob_from_id - lookup the new blob and replace the old one with it 413 * @dev: DRM device 414 * @blob: a pointer to the member blob to be replaced 415 * @blob_id: ID of the new blob 416 * @expected_size: total expected size of the blob data (in bytes) 417 * @expected_elem_size: expected element size of the blob data (in bytes) 418 * @replaced: did the blob get replaced? 419 * 420 * Replace @blob with another blob with the ID @blob_id. If @blob_id is zero 421 * @blob becomes NULL. 422 * 423 * If @expected_size is positive the new blob length is expected to be equal 424 * to @expected_size bytes. If @expected_elem_size is positive the new blob 425 * length is expected to be a multiple of @expected_elem_size bytes. Otherwise 426 * an error is returned. 427 * 428 * @replaced will indicate to the caller whether the blob was replaced or not. 429 * If the old and new blobs were in fact the same blob @replaced will be false 430 * otherwise it will be true. 431 * 432 * RETURNS: 433 * Zero on success, error code on failure. 434 */ 435 static int 436 drm_atomic_replace_property_blob_from_id(struct drm_device *dev, 437 struct drm_property_blob **blob, 438 uint64_t blob_id, 439 ssize_t expected_size, 440 ssize_t expected_elem_size, 441 bool *replaced) 442 { 443 struct drm_property_blob *new_blob = NULL; 444 445 if (blob_id != 0) { 446 new_blob = drm_property_lookup_blob(dev, blob_id); 447 if (new_blob == NULL) 448 return -EINVAL; 449 450 if (expected_size > 0 && 451 new_blob->length != expected_size) { 452 drm_property_blob_put(new_blob); 453 return -EINVAL; 454 } 455 if (expected_elem_size > 0 && 456 new_blob->length % expected_elem_size != 0) { 457 drm_property_blob_put(new_blob); 458 return -EINVAL; 459 } 460 } 461 462 *replaced |= drm_property_replace_blob(blob, new_blob); 463 drm_property_blob_put(new_blob); 464 465 return 0; 466 } 467 468 /** 469 * drm_atomic_crtc_set_property - set property on CRTC 470 * @crtc: the drm CRTC to set a property on 471 * @state: the state object to update with the new property value 472 * @property: the property to set 473 * @val: the new property value 474 * 475 * This function handles generic/core properties and calls out to driver's 476 * &drm_crtc_funcs.atomic_set_property for driver properties. To ensure 477 * consistent behavior you must call this function rather than the driver hook 478 * directly. 479 * 480 * RETURNS: 481 * Zero on success, error code on failure 482 */ 483 int drm_atomic_crtc_set_property(struct drm_crtc *crtc, 484 struct drm_crtc_state *state, struct drm_property *property, 485 uint64_t val) 486 { 487 struct drm_device *dev = crtc->dev; 488 struct drm_mode_config *config = &dev->mode_config; 489 bool replaced = false; 490 int ret; 491 492 if (property == config->prop_active) 493 state->active = val; 494 else if (property == config->prop_mode_id) { 495 struct drm_property_blob *mode = 496 drm_property_lookup_blob(dev, val); 497 ret = drm_atomic_set_mode_prop_for_crtc(state, mode); 498 drm_property_blob_put(mode); 499 return ret; 500 } else if (property == config->degamma_lut_property) { 501 ret = drm_atomic_replace_property_blob_from_id(dev, 502 &state->degamma_lut, 503 val, 504 -1, sizeof(struct drm_color_lut), 505 &replaced); 506 state->color_mgmt_changed |= replaced; 507 return ret; 508 } else if (property == config->ctm_property) { 509 ret = drm_atomic_replace_property_blob_from_id(dev, 510 &state->ctm, 511 val, 512 sizeof(struct drm_color_ctm), -1, 513 &replaced); 514 state->color_mgmt_changed |= replaced; 515 return ret; 516 } else if (property == config->gamma_lut_property) { 517 ret = drm_atomic_replace_property_blob_from_id(dev, 518 &state->gamma_lut, 519 val, 520 -1, sizeof(struct drm_color_lut), 521 &replaced); 522 state->color_mgmt_changed |= replaced; 523 return ret; 524 } else if (property == config->prop_out_fence_ptr) { 525 s32 __user *fence_ptr = u64_to_user_ptr(val); 526 527 if (!fence_ptr) 528 return 0; 529 530 if (put_user(-1, fence_ptr)) 531 return -EFAULT; 532 533 set_out_fence_for_crtc(state->state, crtc, fence_ptr); 534 } else if (crtc->funcs->atomic_set_property) 535 return crtc->funcs->atomic_set_property(crtc, state, property, val); 536 else 537 return -EINVAL; 538 539 return 0; 540 } 541 EXPORT_SYMBOL(drm_atomic_crtc_set_property); 542 543 /** 544 * drm_atomic_crtc_get_property - get property value from CRTC state 545 * @crtc: the drm CRTC to set a property on 546 * @state: the state object to get the property value from 547 * @property: the property to set 548 * @val: return location for the property value 549 * 550 * This function handles generic/core properties and calls out to driver's 551 * &drm_crtc_funcs.atomic_get_property for driver properties. To ensure 552 * consistent behavior you must call this function rather than the driver hook 553 * directly. 554 * 555 * RETURNS: 556 * Zero on success, error code on failure 557 */ 558 static int 559 drm_atomic_crtc_get_property(struct drm_crtc *crtc, 560 const struct drm_crtc_state *state, 561 struct drm_property *property, uint64_t *val) 562 { 563 struct drm_device *dev = crtc->dev; 564 struct drm_mode_config *config = &dev->mode_config; 565 566 if (property == config->prop_active) 567 *val = state->active; 568 else if (property == config->prop_mode_id) 569 *val = (state->mode_blob) ? state->mode_blob->base.id : 0; 570 else if (property == config->degamma_lut_property) 571 *val = (state->degamma_lut) ? state->degamma_lut->base.id : 0; 572 else if (property == config->ctm_property) 573 *val = (state->ctm) ? state->ctm->base.id : 0; 574 else if (property == config->gamma_lut_property) 575 *val = (state->gamma_lut) ? state->gamma_lut->base.id : 0; 576 else if (property == config->prop_out_fence_ptr) 577 *val = 0; 578 else if (crtc->funcs->atomic_get_property) 579 return crtc->funcs->atomic_get_property(crtc, state, property, val); 580 else 581 return -EINVAL; 582 583 return 0; 584 } 585 586 /** 587 * drm_atomic_crtc_check - check crtc state 588 * @crtc: crtc to check 589 * @state: crtc state to check 590 * 591 * Provides core sanity checks for crtc state. 592 * 593 * RETURNS: 594 * Zero on success, error code on failure 595 */ 596 static int drm_atomic_crtc_check(struct drm_crtc *crtc, 597 struct drm_crtc_state *state) 598 { 599 /* NOTE: we explicitly don't enforce constraints such as primary 600 * layer covering entire screen, since that is something we want 601 * to allow (on hw that supports it). For hw that does not, it 602 * should be checked in driver's crtc->atomic_check() vfunc. 603 * 604 * TODO: Add generic modeset state checks once we support those. 605 */ 606 607 if (state->active && !state->enable) { 608 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n", 609 crtc->base.id, crtc->name); 610 return -EINVAL; 611 } 612 613 /* The state->enable vs. state->mode_blob checks can be WARN_ON, 614 * as this is a kernel-internal detail that userspace should never 615 * be able to trigger. */ 616 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) && 617 WARN_ON(state->enable && !state->mode_blob)) { 618 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n", 619 crtc->base.id, crtc->name); 620 return -EINVAL; 621 } 622 623 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) && 624 WARN_ON(!state->enable && state->mode_blob)) { 625 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n", 626 crtc->base.id, crtc->name); 627 return -EINVAL; 628 } 629 630 /* 631 * Reject event generation for when a CRTC is off and stays off. 632 * It wouldn't be hard to implement this, but userspace has a track 633 * record of happily burning through 100% cpu (or worse, crash) when the 634 * display pipe is suspended. To avoid all that fun just reject updates 635 * that ask for events since likely that indicates a bug in the 636 * compositor's drawing loop. This is consistent with the vblank IOCTL 637 * and legacy page_flip IOCTL which also reject service on a disabled 638 * pipe. 639 */ 640 if (state->event && !state->active && !crtc->state->active) { 641 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requesting event but off\n", 642 crtc->base.id, crtc->name); 643 return -EINVAL; 644 } 645 646 return 0; 647 } 648 649 static void drm_atomic_crtc_print_state(struct drm_printer *p, 650 const struct drm_crtc_state *state) 651 { 652 struct drm_crtc *crtc = state->crtc; 653 654 drm_printf(p, "crtc[%u]: %s\n", crtc->base.id, crtc->name); 655 drm_printf(p, "\tenable=%d\n", state->enable); 656 drm_printf(p, "\tactive=%d\n", state->active); 657 drm_printf(p, "\tplanes_changed=%d\n", state->planes_changed); 658 drm_printf(p, "\tmode_changed=%d\n", state->mode_changed); 659 drm_printf(p, "\tactive_changed=%d\n", state->active_changed); 660 drm_printf(p, "\tconnectors_changed=%d\n", state->connectors_changed); 661 drm_printf(p, "\tcolor_mgmt_changed=%d\n", state->color_mgmt_changed); 662 drm_printf(p, "\tplane_mask=%x\n", state->plane_mask); 663 drm_printf(p, "\tconnector_mask=%x\n", state->connector_mask); 664 drm_printf(p, "\tencoder_mask=%x\n", state->encoder_mask); 665 drm_printf(p, "\tmode: " DRM_MODE_FMT "\n", DRM_MODE_ARG(&state->mode)); 666 667 if (crtc->funcs->atomic_print_state) 668 crtc->funcs->atomic_print_state(p, state); 669 } 670 671 /** 672 * drm_atomic_get_plane_state - get plane state 673 * @state: global atomic state object 674 * @plane: plane to get state object for 675 * 676 * This function returns the plane state for the given plane, allocating it if 677 * needed. It will also grab the relevant plane lock to make sure that the state 678 * is consistent. 679 * 680 * Returns: 681 * 682 * Either the allocated state or the error code encoded into the pointer. When 683 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the 684 * entire atomic sequence must be restarted. All other errors are fatal. 685 */ 686 struct drm_plane_state * 687 drm_atomic_get_plane_state(struct drm_atomic_state *state, 688 struct drm_plane *plane) 689 { 690 int ret, index = drm_plane_index(plane); 691 struct drm_plane_state *plane_state; 692 693 WARN_ON(!state->acquire_ctx); 694 695 plane_state = drm_atomic_get_existing_plane_state(state, plane); 696 if (plane_state) 697 return plane_state; 698 699 ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx); 700 if (ret) 701 return ERR_PTR(ret); 702 703 plane_state = plane->funcs->atomic_duplicate_state(plane); 704 if (!plane_state) 705 return ERR_PTR(-ENOMEM); 706 707 state->planes[index].state = plane_state; 708 state->planes[index].ptr = plane; 709 state->planes[index].old_state = plane->state; 710 state->planes[index].new_state = plane_state; 711 plane_state->state = state; 712 713 DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n", 714 plane->base.id, plane->name, plane_state, state); 715 716 if (plane_state->crtc) { 717 struct drm_crtc_state *crtc_state; 718 719 crtc_state = drm_atomic_get_crtc_state(state, 720 plane_state->crtc); 721 if (IS_ERR(crtc_state)) 722 return ERR_CAST(crtc_state); 723 } 724 725 return plane_state; 726 } 727 EXPORT_SYMBOL(drm_atomic_get_plane_state); 728 729 /** 730 * drm_atomic_plane_set_property - set property on plane 731 * @plane: the drm plane to set a property on 732 * @state: the state object to update with the new property value 733 * @property: the property to set 734 * @val: the new property value 735 * 736 * This function handles generic/core properties and calls out to driver's 737 * &drm_plane_funcs.atomic_set_property for driver properties. To ensure 738 * consistent behavior you must call this function rather than the driver hook 739 * directly. 740 * 741 * RETURNS: 742 * Zero on success, error code on failure 743 */ 744 static int drm_atomic_plane_set_property(struct drm_plane *plane, 745 struct drm_plane_state *state, struct drm_property *property, 746 uint64_t val) 747 { 748 struct drm_device *dev = plane->dev; 749 struct drm_mode_config *config = &dev->mode_config; 750 751 if (property == config->prop_fb_id) { 752 struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, NULL, val); 753 drm_atomic_set_fb_for_plane(state, fb); 754 if (fb) 755 drm_framebuffer_put(fb); 756 } else if (property == config->prop_in_fence_fd) { 757 if (state->fence) 758 return -EINVAL; 759 760 if (U642I64(val) == -1) 761 return 0; 762 763 state->fence = sync_file_get_fence(val); 764 if (!state->fence) 765 return -EINVAL; 766 767 } else if (property == config->prop_crtc_id) { 768 struct drm_crtc *crtc = drm_crtc_find(dev, NULL, val); 769 return drm_atomic_set_crtc_for_plane(state, crtc); 770 } else if (property == config->prop_crtc_x) { 771 state->crtc_x = U642I64(val); 772 } else if (property == config->prop_crtc_y) { 773 state->crtc_y = U642I64(val); 774 } else if (property == config->prop_crtc_w) { 775 state->crtc_w = val; 776 } else if (property == config->prop_crtc_h) { 777 state->crtc_h = val; 778 } else if (property == config->prop_src_x) { 779 state->src_x = val; 780 } else if (property == config->prop_src_y) { 781 state->src_y = val; 782 } else if (property == config->prop_src_w) { 783 state->src_w = val; 784 } else if (property == config->prop_src_h) { 785 state->src_h = val; 786 } else if (property == plane->rotation_property) { 787 if (!is_power_of_2(val & DRM_MODE_ROTATE_MASK)) 788 return -EINVAL; 789 state->rotation = val; 790 } else if (property == plane->zpos_property) { 791 state->zpos = val; 792 } else if (property == plane->color_encoding_property) { 793 state->color_encoding = val; 794 } else if (property == plane->color_range_property) { 795 state->color_range = val; 796 } else if (plane->funcs->atomic_set_property) { 797 return plane->funcs->atomic_set_property(plane, state, 798 property, val); 799 } else { 800 return -EINVAL; 801 } 802 803 return 0; 804 } 805 806 /** 807 * drm_atomic_plane_get_property - get property value from plane state 808 * @plane: the drm plane to set a property on 809 * @state: the state object to get the property value from 810 * @property: the property to set 811 * @val: return location for the property value 812 * 813 * This function handles generic/core properties and calls out to driver's 814 * &drm_plane_funcs.atomic_get_property for driver properties. To ensure 815 * consistent behavior you must call this function rather than the driver hook 816 * directly. 817 * 818 * RETURNS: 819 * Zero on success, error code on failure 820 */ 821 static int 822 drm_atomic_plane_get_property(struct drm_plane *plane, 823 const struct drm_plane_state *state, 824 struct drm_property *property, uint64_t *val) 825 { 826 struct drm_device *dev = plane->dev; 827 struct drm_mode_config *config = &dev->mode_config; 828 829 if (property == config->prop_fb_id) { 830 *val = (state->fb) ? state->fb->base.id : 0; 831 } else if (property == config->prop_in_fence_fd) { 832 *val = -1; 833 } else if (property == config->prop_crtc_id) { 834 *val = (state->crtc) ? state->crtc->base.id : 0; 835 } else if (property == config->prop_crtc_x) { 836 *val = I642U64(state->crtc_x); 837 } else if (property == config->prop_crtc_y) { 838 *val = I642U64(state->crtc_y); 839 } else if (property == config->prop_crtc_w) { 840 *val = state->crtc_w; 841 } else if (property == config->prop_crtc_h) { 842 *val = state->crtc_h; 843 } else if (property == config->prop_src_x) { 844 *val = state->src_x; 845 } else if (property == config->prop_src_y) { 846 *val = state->src_y; 847 } else if (property == config->prop_src_w) { 848 *val = state->src_w; 849 } else if (property == config->prop_src_h) { 850 *val = state->src_h; 851 } else if (property == plane->rotation_property) { 852 *val = state->rotation; 853 } else if (property == plane->zpos_property) { 854 *val = state->zpos; 855 } else if (property == plane->color_encoding_property) { 856 *val = state->color_encoding; 857 } else if (property == plane->color_range_property) { 858 *val = state->color_range; 859 } else if (plane->funcs->atomic_get_property) { 860 return plane->funcs->atomic_get_property(plane, state, property, val); 861 } else { 862 return -EINVAL; 863 } 864 865 return 0; 866 } 867 868 static bool 869 plane_switching_crtc(struct drm_atomic_state *state, 870 struct drm_plane *plane, 871 struct drm_plane_state *plane_state) 872 { 873 if (!plane->state->crtc || !plane_state->crtc) 874 return false; 875 876 if (plane->state->crtc == plane_state->crtc) 877 return false; 878 879 /* This could be refined, but currently there's no helper or driver code 880 * to implement direct switching of active planes nor userspace to take 881 * advantage of more direct plane switching without the intermediate 882 * full OFF state. 883 */ 884 return true; 885 } 886 887 /** 888 * drm_atomic_plane_check - check plane state 889 * @plane: plane to check 890 * @state: plane state to check 891 * 892 * Provides core sanity checks for plane state. 893 * 894 * RETURNS: 895 * Zero on success, error code on failure 896 */ 897 static int drm_atomic_plane_check(struct drm_plane *plane, 898 struct drm_plane_state *state) 899 { 900 unsigned int fb_width, fb_height; 901 int ret; 902 903 /* either *both* CRTC and FB must be set, or neither */ 904 if (state->crtc && !state->fb) { 905 DRM_DEBUG_ATOMIC("CRTC set but no FB\n"); 906 return -EINVAL; 907 } else if (state->fb && !state->crtc) { 908 DRM_DEBUG_ATOMIC("FB set but no CRTC\n"); 909 return -EINVAL; 910 } 911 912 /* if disabled, we don't care about the rest of the state: */ 913 if (!state->crtc) 914 return 0; 915 916 /* Check whether this plane is usable on this CRTC */ 917 if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) { 918 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n"); 919 return -EINVAL; 920 } 921 922 /* Check whether this plane supports the fb pixel format. */ 923 ret = drm_plane_check_pixel_format(plane, state->fb->format->format, 924 state->fb->modifier); 925 if (ret) { 926 struct drm_format_name_buf format_name; 927 DRM_DEBUG_ATOMIC("Invalid pixel format %s, modifier 0x%llx\n", 928 drm_get_format_name(state->fb->format->format, 929 &format_name), 930 state->fb->modifier); 931 return ret; 932 } 933 934 /* Give drivers some help against integer overflows */ 935 if (state->crtc_w > INT_MAX || 936 state->crtc_x > INT_MAX - (int32_t) state->crtc_w || 937 state->crtc_h > INT_MAX || 938 state->crtc_y > INT_MAX - (int32_t) state->crtc_h) { 939 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n", 940 state->crtc_w, state->crtc_h, 941 state->crtc_x, state->crtc_y); 942 return -ERANGE; 943 } 944 945 fb_width = state->fb->width << 16; 946 fb_height = state->fb->height << 16; 947 948 /* Make sure source coordinates are inside the fb. */ 949 if (state->src_w > fb_width || 950 state->src_x > fb_width - state->src_w || 951 state->src_h > fb_height || 952 state->src_y > fb_height - state->src_h) { 953 DRM_DEBUG_ATOMIC("Invalid source coordinates " 954 "%u.%06ux%u.%06u+%u.%06u+%u.%06u (fb %ux%u)\n", 955 state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10, 956 state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10, 957 state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10, 958 state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10, 959 state->fb->width, state->fb->height); 960 return -ENOSPC; 961 } 962 963 if (plane_switching_crtc(state->state, plane, state)) { 964 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n", 965 plane->base.id, plane->name); 966 return -EINVAL; 967 } 968 969 return 0; 970 } 971 972 static void drm_atomic_plane_print_state(struct drm_printer *p, 973 const struct drm_plane_state *state) 974 { 975 struct drm_plane *plane = state->plane; 976 struct drm_rect src = drm_plane_state_src(state); 977 struct drm_rect dest = drm_plane_state_dest(state); 978 979 drm_printf(p, "plane[%u]: %s\n", plane->base.id, plane->name); 980 drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)"); 981 drm_printf(p, "\tfb=%u\n", state->fb ? state->fb->base.id : 0); 982 if (state->fb) 983 drm_framebuffer_print_info(p, 2, state->fb); 984 drm_printf(p, "\tcrtc-pos=" DRM_RECT_FMT "\n", DRM_RECT_ARG(&dest)); 985 drm_printf(p, "\tsrc-pos=" DRM_RECT_FP_FMT "\n", DRM_RECT_FP_ARG(&src)); 986 drm_printf(p, "\trotation=%x\n", state->rotation); 987 drm_printf(p, "\tcolor-encoding=%s\n", 988 drm_get_color_encoding_name(state->color_encoding)); 989 drm_printf(p, "\tcolor-range=%s\n", 990 drm_get_color_range_name(state->color_range)); 991 992 if (plane->funcs->atomic_print_state) 993 plane->funcs->atomic_print_state(p, state); 994 } 995 996 /** 997 * DOC: handling driver private state 998 * 999 * Very often the DRM objects exposed to userspace in the atomic modeset api 1000 * (&drm_connector, &drm_crtc and &drm_plane) do not map neatly to the 1001 * underlying hardware. Especially for any kind of shared resources (e.g. shared 1002 * clocks, scaler units, bandwidth and fifo limits shared among a group of 1003 * planes or CRTCs, and so on) it makes sense to model these as independent 1004 * objects. Drivers then need to do similar state tracking and commit ordering for 1005 * such private (since not exposed to userpace) objects as the atomic core and 1006 * helpers already provide for connectors, planes and CRTCs. 1007 * 1008 * To make this easier on drivers the atomic core provides some support to track 1009 * driver private state objects using struct &drm_private_obj, with the 1010 * associated state struct &drm_private_state. 1011 * 1012 * Similar to userspace-exposed objects, private state structures can be 1013 * acquired by calling drm_atomic_get_private_obj_state(). Since this function 1014 * does not take care of locking, drivers should wrap it for each type of 1015 * private state object they have with the required call to drm_modeset_lock() 1016 * for the corresponding &drm_modeset_lock. 1017 * 1018 * All private state structures contained in a &drm_atomic_state update can be 1019 * iterated using for_each_oldnew_private_obj_in_state(), 1020 * for_each_new_private_obj_in_state() and for_each_old_private_obj_in_state(). 1021 * Drivers are recommended to wrap these for each type of driver private state 1022 * object they have, filtering on &drm_private_obj.funcs using for_each_if(), at 1023 * least if they want to iterate over all objects of a given type. 1024 * 1025 * An earlier way to handle driver private state was by subclassing struct 1026 * &drm_atomic_state. But since that encourages non-standard ways to implement 1027 * the check/commit split atomic requires (by using e.g. "check and rollback or 1028 * commit instead" of "duplicate state, check, then either commit or release 1029 * duplicated state) it is deprecated in favour of using &drm_private_state. 1030 */ 1031 1032 /** 1033 * drm_atomic_private_obj_init - initialize private object 1034 * @obj: private object 1035 * @state: initial private object state 1036 * @funcs: pointer to the struct of function pointers that identify the object 1037 * type 1038 * 1039 * Initialize the private object, which can be embedded into any 1040 * driver private object that needs its own atomic state. 1041 */ 1042 void 1043 drm_atomic_private_obj_init(struct drm_private_obj *obj, 1044 struct drm_private_state *state, 1045 const struct drm_private_state_funcs *funcs) 1046 { 1047 memset(obj, 0, sizeof(*obj)); 1048 1049 obj->state = state; 1050 obj->funcs = funcs; 1051 } 1052 EXPORT_SYMBOL(drm_atomic_private_obj_init); 1053 1054 /** 1055 * drm_atomic_private_obj_fini - finalize private object 1056 * @obj: private object 1057 * 1058 * Finalize the private object. 1059 */ 1060 void 1061 drm_atomic_private_obj_fini(struct drm_private_obj *obj) 1062 { 1063 obj->funcs->atomic_destroy_state(obj, obj->state); 1064 } 1065 EXPORT_SYMBOL(drm_atomic_private_obj_fini); 1066 1067 /** 1068 * drm_atomic_get_private_obj_state - get private object state 1069 * @state: global atomic state 1070 * @obj: private object to get the state for 1071 * 1072 * This function returns the private object state for the given private object, 1073 * allocating the state if needed. It does not grab any locks as the caller is 1074 * expected to care of any required locking. 1075 * 1076 * RETURNS: 1077 * 1078 * Either the allocated state or the error code encoded into a pointer. 1079 */ 1080 struct drm_private_state * 1081 drm_atomic_get_private_obj_state(struct drm_atomic_state *state, 1082 struct drm_private_obj *obj) 1083 { 1084 int index, num_objs, i; 1085 size_t size; 1086 struct __drm_private_objs_state *arr; 1087 struct drm_private_state *obj_state; 1088 1089 for (i = 0; i < state->num_private_objs; i++) 1090 if (obj == state->private_objs[i].ptr) 1091 return state->private_objs[i].state; 1092 1093 num_objs = state->num_private_objs + 1; 1094 size = sizeof(*state->private_objs) * num_objs; 1095 arr = krealloc(state->private_objs, size, GFP_KERNEL); 1096 if (!arr) 1097 return ERR_PTR(-ENOMEM); 1098 1099 state->private_objs = arr; 1100 index = state->num_private_objs; 1101 memset(&state->private_objs[index], 0, sizeof(*state->private_objs)); 1102 1103 obj_state = obj->funcs->atomic_duplicate_state(obj); 1104 if (!obj_state) 1105 return ERR_PTR(-ENOMEM); 1106 1107 state->private_objs[index].state = obj_state; 1108 state->private_objs[index].old_state = obj->state; 1109 state->private_objs[index].new_state = obj_state; 1110 state->private_objs[index].ptr = obj; 1111 1112 state->num_private_objs = num_objs; 1113 1114 DRM_DEBUG_ATOMIC("Added new private object %p state %p to %p\n", 1115 obj, obj_state, state); 1116 1117 return obj_state; 1118 } 1119 EXPORT_SYMBOL(drm_atomic_get_private_obj_state); 1120 1121 /** 1122 * drm_atomic_get_connector_state - get connector state 1123 * @state: global atomic state object 1124 * @connector: connector to get state object for 1125 * 1126 * This function returns the connector state for the given connector, 1127 * allocating it if needed. It will also grab the relevant connector lock to 1128 * make sure that the state is consistent. 1129 * 1130 * Returns: 1131 * 1132 * Either the allocated state or the error code encoded into the pointer. When 1133 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the 1134 * entire atomic sequence must be restarted. All other errors are fatal. 1135 */ 1136 struct drm_connector_state * 1137 drm_atomic_get_connector_state(struct drm_atomic_state *state, 1138 struct drm_connector *connector) 1139 { 1140 int ret, index; 1141 struct drm_mode_config *config = &connector->dev->mode_config; 1142 struct drm_connector_state *connector_state; 1143 1144 WARN_ON(!state->acquire_ctx); 1145 1146 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx); 1147 if (ret) 1148 return ERR_PTR(ret); 1149 1150 index = drm_connector_index(connector); 1151 1152 if (index >= state->num_connector) { 1153 struct __drm_connnectors_state *c; 1154 int alloc = max(index + 1, config->num_connector); 1155 1156 c = krealloc(state->connectors, alloc * sizeof(*state->connectors), GFP_KERNEL); 1157 if (!c) 1158 return ERR_PTR(-ENOMEM); 1159 1160 state->connectors = c; 1161 memset(&state->connectors[state->num_connector], 0, 1162 sizeof(*state->connectors) * (alloc - state->num_connector)); 1163 1164 state->num_connector = alloc; 1165 } 1166 1167 if (state->connectors[index].state) 1168 return state->connectors[index].state; 1169 1170 connector_state = connector->funcs->atomic_duplicate_state(connector); 1171 if (!connector_state) 1172 return ERR_PTR(-ENOMEM); 1173 1174 drm_connector_get(connector); 1175 state->connectors[index].state = connector_state; 1176 state->connectors[index].old_state = connector->state; 1177 state->connectors[index].new_state = connector_state; 1178 state->connectors[index].ptr = connector; 1179 connector_state->state = state; 1180 1181 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d:%s] %p state to %p\n", 1182 connector->base.id, connector->name, 1183 connector_state, state); 1184 1185 if (connector_state->crtc) { 1186 struct drm_crtc_state *crtc_state; 1187 1188 crtc_state = drm_atomic_get_crtc_state(state, 1189 connector_state->crtc); 1190 if (IS_ERR(crtc_state)) 1191 return ERR_CAST(crtc_state); 1192 } 1193 1194 return connector_state; 1195 } 1196 EXPORT_SYMBOL(drm_atomic_get_connector_state); 1197 1198 /** 1199 * drm_atomic_connector_set_property - set property on connector. 1200 * @connector: the drm connector to set a property on 1201 * @state: the state object to update with the new property value 1202 * @property: the property to set 1203 * @val: the new property value 1204 * 1205 * This function handles generic/core properties and calls out to driver's 1206 * &drm_connector_funcs.atomic_set_property for driver properties. To ensure 1207 * consistent behavior you must call this function rather than the driver hook 1208 * directly. 1209 * 1210 * RETURNS: 1211 * Zero on success, error code on failure 1212 */ 1213 static int drm_atomic_connector_set_property(struct drm_connector *connector, 1214 struct drm_connector_state *state, struct drm_property *property, 1215 uint64_t val) 1216 { 1217 struct drm_device *dev = connector->dev; 1218 struct drm_mode_config *config = &dev->mode_config; 1219 1220 if (property == config->prop_crtc_id) { 1221 struct drm_crtc *crtc = drm_crtc_find(dev, NULL, val); 1222 return drm_atomic_set_crtc_for_connector(state, crtc); 1223 } else if (property == config->dpms_property) { 1224 /* setting DPMS property requires special handling, which 1225 * is done in legacy setprop path for us. Disallow (for 1226 * now?) atomic writes to DPMS property: 1227 */ 1228 return -EINVAL; 1229 } else if (property == config->tv_select_subconnector_property) { 1230 state->tv.subconnector = val; 1231 } else if (property == config->tv_left_margin_property) { 1232 state->tv.margins.left = val; 1233 } else if (property == config->tv_right_margin_property) { 1234 state->tv.margins.right = val; 1235 } else if (property == config->tv_top_margin_property) { 1236 state->tv.margins.top = val; 1237 } else if (property == config->tv_bottom_margin_property) { 1238 state->tv.margins.bottom = val; 1239 } else if (property == config->tv_mode_property) { 1240 state->tv.mode = val; 1241 } else if (property == config->tv_brightness_property) { 1242 state->tv.brightness = val; 1243 } else if (property == config->tv_contrast_property) { 1244 state->tv.contrast = val; 1245 } else if (property == config->tv_flicker_reduction_property) { 1246 state->tv.flicker_reduction = val; 1247 } else if (property == config->tv_overscan_property) { 1248 state->tv.overscan = val; 1249 } else if (property == config->tv_saturation_property) { 1250 state->tv.saturation = val; 1251 } else if (property == config->tv_hue_property) { 1252 state->tv.hue = val; 1253 } else if (property == config->link_status_property) { 1254 /* Never downgrade from GOOD to BAD on userspace's request here, 1255 * only hw issues can do that. 1256 * 1257 * For an atomic property the userspace doesn't need to be able 1258 * to understand all the properties, but needs to be able to 1259 * restore the state it wants on VT switch. So if the userspace 1260 * tries to change the link_status from GOOD to BAD, driver 1261 * silently rejects it and returns a 0. This prevents userspace 1262 * from accidently breaking the display when it restores the 1263 * state. 1264 */ 1265 if (state->link_status != DRM_LINK_STATUS_GOOD) 1266 state->link_status = val; 1267 } else if (property == config->aspect_ratio_property) { 1268 state->picture_aspect_ratio = val; 1269 } else if (property == connector->scaling_mode_property) { 1270 state->scaling_mode = val; 1271 } else if (property == connector->content_protection_property) { 1272 if (val == DRM_MODE_CONTENT_PROTECTION_ENABLED) { 1273 DRM_DEBUG_KMS("only drivers can set CP Enabled\n"); 1274 return -EINVAL; 1275 } 1276 state->content_protection = val; 1277 } else if (connector->funcs->atomic_set_property) { 1278 return connector->funcs->atomic_set_property(connector, 1279 state, property, val); 1280 } else { 1281 return -EINVAL; 1282 } 1283 1284 return 0; 1285 } 1286 1287 static void drm_atomic_connector_print_state(struct drm_printer *p, 1288 const struct drm_connector_state *state) 1289 { 1290 struct drm_connector *connector = state->connector; 1291 1292 drm_printf(p, "connector[%u]: %s\n", connector->base.id, connector->name); 1293 drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)"); 1294 1295 if (connector->funcs->atomic_print_state) 1296 connector->funcs->atomic_print_state(p, state); 1297 } 1298 1299 /** 1300 * drm_atomic_connector_get_property - get property value from connector state 1301 * @connector: the drm connector to set a property on 1302 * @state: the state object to get the property value from 1303 * @property: the property to set 1304 * @val: return location for the property value 1305 * 1306 * This function handles generic/core properties and calls out to driver's 1307 * &drm_connector_funcs.atomic_get_property for driver properties. To ensure 1308 * consistent behavior you must call this function rather than the driver hook 1309 * directly. 1310 * 1311 * RETURNS: 1312 * Zero on success, error code on failure 1313 */ 1314 static int 1315 drm_atomic_connector_get_property(struct drm_connector *connector, 1316 const struct drm_connector_state *state, 1317 struct drm_property *property, uint64_t *val) 1318 { 1319 struct drm_device *dev = connector->dev; 1320 struct drm_mode_config *config = &dev->mode_config; 1321 1322 if (property == config->prop_crtc_id) { 1323 *val = (state->crtc) ? state->crtc->base.id : 0; 1324 } else if (property == config->dpms_property) { 1325 *val = connector->dpms; 1326 } else if (property == config->tv_select_subconnector_property) { 1327 *val = state->tv.subconnector; 1328 } else if (property == config->tv_left_margin_property) { 1329 *val = state->tv.margins.left; 1330 } else if (property == config->tv_right_margin_property) { 1331 *val = state->tv.margins.right; 1332 } else if (property == config->tv_top_margin_property) { 1333 *val = state->tv.margins.top; 1334 } else if (property == config->tv_bottom_margin_property) { 1335 *val = state->tv.margins.bottom; 1336 } else if (property == config->tv_mode_property) { 1337 *val = state->tv.mode; 1338 } else if (property == config->tv_brightness_property) { 1339 *val = state->tv.brightness; 1340 } else if (property == config->tv_contrast_property) { 1341 *val = state->tv.contrast; 1342 } else if (property == config->tv_flicker_reduction_property) { 1343 *val = state->tv.flicker_reduction; 1344 } else if (property == config->tv_overscan_property) { 1345 *val = state->tv.overscan; 1346 } else if (property == config->tv_saturation_property) { 1347 *val = state->tv.saturation; 1348 } else if (property == config->tv_hue_property) { 1349 *val = state->tv.hue; 1350 } else if (property == config->link_status_property) { 1351 *val = state->link_status; 1352 } else if (property == config->aspect_ratio_property) { 1353 *val = state->picture_aspect_ratio; 1354 } else if (property == connector->scaling_mode_property) { 1355 *val = state->scaling_mode; 1356 } else if (property == connector->content_protection_property) { 1357 *val = state->content_protection; 1358 } else if (connector->funcs->atomic_get_property) { 1359 return connector->funcs->atomic_get_property(connector, 1360 state, property, val); 1361 } else { 1362 return -EINVAL; 1363 } 1364 1365 return 0; 1366 } 1367 1368 int drm_atomic_get_property(struct drm_mode_object *obj, 1369 struct drm_property *property, uint64_t *val) 1370 { 1371 struct drm_device *dev = property->dev; 1372 int ret; 1373 1374 switch (obj->type) { 1375 case DRM_MODE_OBJECT_CONNECTOR: { 1376 struct drm_connector *connector = obj_to_connector(obj); 1377 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex)); 1378 ret = drm_atomic_connector_get_property(connector, 1379 connector->state, property, val); 1380 break; 1381 } 1382 case DRM_MODE_OBJECT_CRTC: { 1383 struct drm_crtc *crtc = obj_to_crtc(obj); 1384 WARN_ON(!drm_modeset_is_locked(&crtc->mutex)); 1385 ret = drm_atomic_crtc_get_property(crtc, 1386 crtc->state, property, val); 1387 break; 1388 } 1389 case DRM_MODE_OBJECT_PLANE: { 1390 struct drm_plane *plane = obj_to_plane(obj); 1391 WARN_ON(!drm_modeset_is_locked(&plane->mutex)); 1392 ret = drm_atomic_plane_get_property(plane, 1393 plane->state, property, val); 1394 break; 1395 } 1396 default: 1397 ret = -EINVAL; 1398 break; 1399 } 1400 1401 return ret; 1402 } 1403 1404 /** 1405 * drm_atomic_set_crtc_for_plane - set crtc for plane 1406 * @plane_state: the plane whose incoming state to update 1407 * @crtc: crtc to use for the plane 1408 * 1409 * Changing the assigned crtc for a plane requires us to grab the lock and state 1410 * for the new crtc, as needed. This function takes care of all these details 1411 * besides updating the pointer in the state object itself. 1412 * 1413 * Returns: 1414 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK 1415 * then the w/w mutex code has detected a deadlock and the entire atomic 1416 * sequence must be restarted. All other errors are fatal. 1417 */ 1418 int 1419 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state, 1420 struct drm_crtc *crtc) 1421 { 1422 struct drm_plane *plane = plane_state->plane; 1423 struct drm_crtc_state *crtc_state; 1424 1425 if (plane_state->crtc) { 1426 crtc_state = drm_atomic_get_crtc_state(plane_state->state, 1427 plane_state->crtc); 1428 if (WARN_ON(IS_ERR(crtc_state))) 1429 return PTR_ERR(crtc_state); 1430 1431 crtc_state->plane_mask &= ~(1 << drm_plane_index(plane)); 1432 } 1433 1434 plane_state->crtc = crtc; 1435 1436 if (crtc) { 1437 crtc_state = drm_atomic_get_crtc_state(plane_state->state, 1438 crtc); 1439 if (IS_ERR(crtc_state)) 1440 return PTR_ERR(crtc_state); 1441 crtc_state->plane_mask |= (1 << drm_plane_index(plane)); 1442 } 1443 1444 if (crtc) 1445 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n", 1446 plane_state, crtc->base.id, crtc->name); 1447 else 1448 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n", 1449 plane_state); 1450 1451 return 0; 1452 } 1453 EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane); 1454 1455 /** 1456 * drm_atomic_set_fb_for_plane - set framebuffer for plane 1457 * @plane_state: atomic state object for the plane 1458 * @fb: fb to use for the plane 1459 * 1460 * Changing the assigned framebuffer for a plane requires us to grab a reference 1461 * to the new fb and drop the reference to the old fb, if there is one. This 1462 * function takes care of all these details besides updating the pointer in the 1463 * state object itself. 1464 */ 1465 void 1466 drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state, 1467 struct drm_framebuffer *fb) 1468 { 1469 if (fb) 1470 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n", 1471 fb->base.id, plane_state); 1472 else 1473 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n", 1474 plane_state); 1475 1476 drm_framebuffer_assign(&plane_state->fb, fb); 1477 } 1478 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane); 1479 1480 /** 1481 * drm_atomic_set_fence_for_plane - set fence for plane 1482 * @plane_state: atomic state object for the plane 1483 * @fence: dma_fence to use for the plane 1484 * 1485 * Helper to setup the plane_state fence in case it is not set yet. 1486 * By using this drivers doesn't need to worry if the user choose 1487 * implicit or explicit fencing. 1488 * 1489 * This function will not set the fence to the state if it was set 1490 * via explicit fencing interfaces on the atomic ioctl. In that case it will 1491 * drop the reference to the fence as we are not storing it anywhere. 1492 * Otherwise, if &drm_plane_state.fence is not set this function we just set it 1493 * with the received implicit fence. In both cases this function consumes a 1494 * reference for @fence. 1495 */ 1496 void 1497 drm_atomic_set_fence_for_plane(struct drm_plane_state *plane_state, 1498 struct dma_fence *fence) 1499 { 1500 if (plane_state->fence) { 1501 dma_fence_put(fence); 1502 return; 1503 } 1504 1505 plane_state->fence = fence; 1506 } 1507 EXPORT_SYMBOL(drm_atomic_set_fence_for_plane); 1508 1509 /** 1510 * drm_atomic_set_crtc_for_connector - set crtc for connector 1511 * @conn_state: atomic state object for the connector 1512 * @crtc: crtc to use for the connector 1513 * 1514 * Changing the assigned crtc for a connector requires us to grab the lock and 1515 * state for the new crtc, as needed. This function takes care of all these 1516 * details besides updating the pointer in the state object itself. 1517 * 1518 * Returns: 1519 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK 1520 * then the w/w mutex code has detected a deadlock and the entire atomic 1521 * sequence must be restarted. All other errors are fatal. 1522 */ 1523 int 1524 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, 1525 struct drm_crtc *crtc) 1526 { 1527 struct drm_crtc_state *crtc_state; 1528 1529 if (conn_state->crtc == crtc) 1530 return 0; 1531 1532 if (conn_state->crtc) { 1533 crtc_state = drm_atomic_get_new_crtc_state(conn_state->state, 1534 conn_state->crtc); 1535 1536 crtc_state->connector_mask &= 1537 ~(1 << drm_connector_index(conn_state->connector)); 1538 1539 drm_connector_put(conn_state->connector); 1540 conn_state->crtc = NULL; 1541 } 1542 1543 if (crtc) { 1544 crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc); 1545 if (IS_ERR(crtc_state)) 1546 return PTR_ERR(crtc_state); 1547 1548 crtc_state->connector_mask |= 1549 1 << drm_connector_index(conn_state->connector); 1550 1551 drm_connector_get(conn_state->connector); 1552 conn_state->crtc = crtc; 1553 1554 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n", 1555 conn_state, crtc->base.id, crtc->name); 1556 } else { 1557 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n", 1558 conn_state); 1559 } 1560 1561 return 0; 1562 } 1563 EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector); 1564 1565 /** 1566 * drm_atomic_add_affected_connectors - add connectors for crtc 1567 * @state: atomic state 1568 * @crtc: DRM crtc 1569 * 1570 * This function walks the current configuration and adds all connectors 1571 * currently using @crtc to the atomic configuration @state. Note that this 1572 * function must acquire the connection mutex. This can potentially cause 1573 * unneeded seralization if the update is just for the planes on one crtc. Hence 1574 * drivers and helpers should only call this when really needed (e.g. when a 1575 * full modeset needs to happen due to some change). 1576 * 1577 * Returns: 1578 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK 1579 * then the w/w mutex code has detected a deadlock and the entire atomic 1580 * sequence must be restarted. All other errors are fatal. 1581 */ 1582 int 1583 drm_atomic_add_affected_connectors(struct drm_atomic_state *state, 1584 struct drm_crtc *crtc) 1585 { 1586 struct drm_mode_config *config = &state->dev->mode_config; 1587 struct drm_connector *connector; 1588 struct drm_connector_state *conn_state; 1589 struct drm_connector_list_iter conn_iter; 1590 struct drm_crtc_state *crtc_state; 1591 int ret; 1592 1593 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1594 if (IS_ERR(crtc_state)) 1595 return PTR_ERR(crtc_state); 1596 1597 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx); 1598 if (ret) 1599 return ret; 1600 1601 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n", 1602 crtc->base.id, crtc->name, state); 1603 1604 /* 1605 * Changed connectors are already in @state, so only need to look 1606 * at the connector_mask in crtc_state. 1607 */ 1608 drm_connector_list_iter_begin(state->dev, &conn_iter); 1609 drm_for_each_connector_iter(connector, &conn_iter) { 1610 if (!(crtc_state->connector_mask & (1 << drm_connector_index(connector)))) 1611 continue; 1612 1613 conn_state = drm_atomic_get_connector_state(state, connector); 1614 if (IS_ERR(conn_state)) { 1615 drm_connector_list_iter_end(&conn_iter); 1616 return PTR_ERR(conn_state); 1617 } 1618 } 1619 drm_connector_list_iter_end(&conn_iter); 1620 1621 return 0; 1622 } 1623 EXPORT_SYMBOL(drm_atomic_add_affected_connectors); 1624 1625 /** 1626 * drm_atomic_add_affected_planes - add planes for crtc 1627 * @state: atomic state 1628 * @crtc: DRM crtc 1629 * 1630 * This function walks the current configuration and adds all planes 1631 * currently used by @crtc to the atomic configuration @state. This is useful 1632 * when an atomic commit also needs to check all currently enabled plane on 1633 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC 1634 * to avoid special code to force-enable all planes. 1635 * 1636 * Since acquiring a plane state will always also acquire the w/w mutex of the 1637 * current CRTC for that plane (if there is any) adding all the plane states for 1638 * a CRTC will not reduce parallism of atomic updates. 1639 * 1640 * Returns: 1641 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK 1642 * then the w/w mutex code has detected a deadlock and the entire atomic 1643 * sequence must be restarted. All other errors are fatal. 1644 */ 1645 int 1646 drm_atomic_add_affected_planes(struct drm_atomic_state *state, 1647 struct drm_crtc *crtc) 1648 { 1649 struct drm_plane *plane; 1650 1651 WARN_ON(!drm_atomic_get_new_crtc_state(state, crtc)); 1652 1653 drm_for_each_plane_mask(plane, state->dev, crtc->state->plane_mask) { 1654 struct drm_plane_state *plane_state = 1655 drm_atomic_get_plane_state(state, plane); 1656 1657 if (IS_ERR(plane_state)) 1658 return PTR_ERR(plane_state); 1659 } 1660 return 0; 1661 } 1662 EXPORT_SYMBOL(drm_atomic_add_affected_planes); 1663 1664 /** 1665 * drm_atomic_check_only - check whether a given config would work 1666 * @state: atomic configuration to check 1667 * 1668 * Note that this function can return -EDEADLK if the driver needed to acquire 1669 * more locks but encountered a deadlock. The caller must then do the usual w/w 1670 * backoff dance and restart. All other errors are fatal. 1671 * 1672 * Returns: 1673 * 0 on success, negative error code on failure. 1674 */ 1675 int drm_atomic_check_only(struct drm_atomic_state *state) 1676 { 1677 struct drm_device *dev = state->dev; 1678 struct drm_mode_config *config = &dev->mode_config; 1679 struct drm_plane *plane; 1680 struct drm_plane_state *plane_state; 1681 struct drm_crtc *crtc; 1682 struct drm_crtc_state *crtc_state; 1683 int i, ret = 0; 1684 1685 DRM_DEBUG_ATOMIC("checking %p\n", state); 1686 1687 for_each_new_plane_in_state(state, plane, plane_state, i) { 1688 ret = drm_atomic_plane_check(plane, plane_state); 1689 if (ret) { 1690 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n", 1691 plane->base.id, plane->name); 1692 return ret; 1693 } 1694 } 1695 1696 for_each_new_crtc_in_state(state, crtc, crtc_state, i) { 1697 ret = drm_atomic_crtc_check(crtc, crtc_state); 1698 if (ret) { 1699 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n", 1700 crtc->base.id, crtc->name); 1701 return ret; 1702 } 1703 } 1704 1705 if (config->funcs->atomic_check) 1706 ret = config->funcs->atomic_check(state->dev, state); 1707 1708 if (ret) 1709 return ret; 1710 1711 if (!state->allow_modeset) { 1712 for_each_new_crtc_in_state(state, crtc, crtc_state, i) { 1713 if (drm_atomic_crtc_needs_modeset(crtc_state)) { 1714 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n", 1715 crtc->base.id, crtc->name); 1716 return -EINVAL; 1717 } 1718 } 1719 } 1720 1721 return 0; 1722 } 1723 EXPORT_SYMBOL(drm_atomic_check_only); 1724 1725 /** 1726 * drm_atomic_commit - commit configuration atomically 1727 * @state: atomic configuration to check 1728 * 1729 * Note that this function can return -EDEADLK if the driver needed to acquire 1730 * more locks but encountered a deadlock. The caller must then do the usual w/w 1731 * backoff dance and restart. All other errors are fatal. 1732 * 1733 * This function will take its own reference on @state. 1734 * Callers should always release their reference with drm_atomic_state_put(). 1735 * 1736 * Returns: 1737 * 0 on success, negative error code on failure. 1738 */ 1739 int drm_atomic_commit(struct drm_atomic_state *state) 1740 { 1741 struct drm_mode_config *config = &state->dev->mode_config; 1742 int ret; 1743 1744 ret = drm_atomic_check_only(state); 1745 if (ret) 1746 return ret; 1747 1748 DRM_DEBUG_ATOMIC("committing %p\n", state); 1749 1750 return config->funcs->atomic_commit(state->dev, state, false); 1751 } 1752 EXPORT_SYMBOL(drm_atomic_commit); 1753 1754 /** 1755 * drm_atomic_nonblocking_commit - atomic nonblocking commit 1756 * @state: atomic configuration to check 1757 * 1758 * Note that this function can return -EDEADLK if the driver needed to acquire 1759 * more locks but encountered a deadlock. The caller must then do the usual w/w 1760 * backoff dance and restart. All other errors are fatal. 1761 * 1762 * This function will take its own reference on @state. 1763 * Callers should always release their reference with drm_atomic_state_put(). 1764 * 1765 * Returns: 1766 * 0 on success, negative error code on failure. 1767 */ 1768 int drm_atomic_nonblocking_commit(struct drm_atomic_state *state) 1769 { 1770 struct drm_mode_config *config = &state->dev->mode_config; 1771 int ret; 1772 1773 ret = drm_atomic_check_only(state); 1774 if (ret) 1775 return ret; 1776 1777 DRM_DEBUG_ATOMIC("committing %p nonblocking\n", state); 1778 1779 return config->funcs->atomic_commit(state->dev, state, true); 1780 } 1781 EXPORT_SYMBOL(drm_atomic_nonblocking_commit); 1782 1783 static void drm_atomic_print_state(const struct drm_atomic_state *state) 1784 { 1785 struct drm_printer p = drm_info_printer(state->dev->dev); 1786 struct drm_plane *plane; 1787 struct drm_plane_state *plane_state; 1788 struct drm_crtc *crtc; 1789 struct drm_crtc_state *crtc_state; 1790 struct drm_connector *connector; 1791 struct drm_connector_state *connector_state; 1792 int i; 1793 1794 DRM_DEBUG_ATOMIC("checking %p\n", state); 1795 1796 for_each_new_plane_in_state(state, plane, plane_state, i) 1797 drm_atomic_plane_print_state(&p, plane_state); 1798 1799 for_each_new_crtc_in_state(state, crtc, crtc_state, i) 1800 drm_atomic_crtc_print_state(&p, crtc_state); 1801 1802 for_each_new_connector_in_state(state, connector, connector_state, i) 1803 drm_atomic_connector_print_state(&p, connector_state); 1804 } 1805 1806 static void __drm_state_dump(struct drm_device *dev, struct drm_printer *p, 1807 bool take_locks) 1808 { 1809 struct drm_mode_config *config = &dev->mode_config; 1810 struct drm_plane *plane; 1811 struct drm_crtc *crtc; 1812 struct drm_connector *connector; 1813 struct drm_connector_list_iter conn_iter; 1814 1815 if (!drm_core_check_feature(dev, DRIVER_ATOMIC)) 1816 return; 1817 1818 list_for_each_entry(plane, &config->plane_list, head) { 1819 if (take_locks) 1820 drm_modeset_lock(&plane->mutex, NULL); 1821 drm_atomic_plane_print_state(p, plane->state); 1822 if (take_locks) 1823 drm_modeset_unlock(&plane->mutex); 1824 } 1825 1826 list_for_each_entry(crtc, &config->crtc_list, head) { 1827 if (take_locks) 1828 drm_modeset_lock(&crtc->mutex, NULL); 1829 drm_atomic_crtc_print_state(p, crtc->state); 1830 if (take_locks) 1831 drm_modeset_unlock(&crtc->mutex); 1832 } 1833 1834 drm_connector_list_iter_begin(dev, &conn_iter); 1835 if (take_locks) 1836 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 1837 drm_for_each_connector_iter(connector, &conn_iter) 1838 drm_atomic_connector_print_state(p, connector->state); 1839 if (take_locks) 1840 drm_modeset_unlock(&dev->mode_config.connection_mutex); 1841 drm_connector_list_iter_end(&conn_iter); 1842 } 1843 1844 /** 1845 * drm_state_dump - dump entire device atomic state 1846 * @dev: the drm device 1847 * @p: where to print the state to 1848 * 1849 * Just for debugging. Drivers might want an option to dump state 1850 * to dmesg in case of error irq's. (Hint, you probably want to 1851 * ratelimit this!) 1852 * 1853 * The caller must drm_modeset_lock_all(), or if this is called 1854 * from error irq handler, it should not be enabled by default. 1855 * (Ie. if you are debugging errors you might not care that this 1856 * is racey. But calling this without all modeset locks held is 1857 * not inherently safe.) 1858 */ 1859 void drm_state_dump(struct drm_device *dev, struct drm_printer *p) 1860 { 1861 __drm_state_dump(dev, p, false); 1862 } 1863 EXPORT_SYMBOL(drm_state_dump); 1864 1865 #ifdef CONFIG_DEBUG_FS 1866 static int drm_state_info(struct seq_file *m, void *data) 1867 { 1868 struct drm_info_node *node = (struct drm_info_node *) m->private; 1869 struct drm_device *dev = node->minor->dev; 1870 struct drm_printer p = drm_seq_file_printer(m); 1871 1872 __drm_state_dump(dev, &p, true); 1873 1874 return 0; 1875 } 1876 1877 /* any use in debugfs files to dump individual planes/crtc/etc? */ 1878 static const struct drm_info_list drm_atomic_debugfs_list[] = { 1879 {"state", drm_state_info, 0}, 1880 }; 1881 1882 int drm_atomic_debugfs_init(struct drm_minor *minor) 1883 { 1884 return drm_debugfs_create_files(drm_atomic_debugfs_list, 1885 ARRAY_SIZE(drm_atomic_debugfs_list), 1886 minor->debugfs_root, minor); 1887 } 1888 #endif 1889 1890 /* 1891 * The big monster ioctl 1892 */ 1893 1894 static struct drm_pending_vblank_event *create_vblank_event( 1895 struct drm_crtc *crtc, uint64_t user_data) 1896 { 1897 struct drm_pending_vblank_event *e = NULL; 1898 1899 e = kzalloc(sizeof *e, GFP_KERNEL); 1900 if (!e) 1901 return NULL; 1902 1903 e->event.base.type = DRM_EVENT_FLIP_COMPLETE; 1904 e->event.base.length = sizeof(e->event); 1905 e->event.vbl.crtc_id = crtc->base.id; 1906 e->event.vbl.user_data = user_data; 1907 1908 return e; 1909 } 1910 1911 int drm_atomic_connector_commit_dpms(struct drm_atomic_state *state, 1912 struct drm_connector *connector, 1913 int mode) 1914 { 1915 struct drm_connector *tmp_connector; 1916 struct drm_connector_state *new_conn_state; 1917 struct drm_crtc *crtc; 1918 struct drm_crtc_state *crtc_state; 1919 int i, ret, old_mode = connector->dpms; 1920 bool active = false; 1921 1922 ret = drm_modeset_lock(&state->dev->mode_config.connection_mutex, 1923 state->acquire_ctx); 1924 if (ret) 1925 return ret; 1926 1927 if (mode != DRM_MODE_DPMS_ON) 1928 mode = DRM_MODE_DPMS_OFF; 1929 connector->dpms = mode; 1930 1931 crtc = connector->state->crtc; 1932 if (!crtc) 1933 goto out; 1934 ret = drm_atomic_add_affected_connectors(state, crtc); 1935 if (ret) 1936 goto out; 1937 1938 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1939 if (IS_ERR(crtc_state)) { 1940 ret = PTR_ERR(crtc_state); 1941 goto out; 1942 } 1943 1944 for_each_new_connector_in_state(state, tmp_connector, new_conn_state, i) { 1945 if (new_conn_state->crtc != crtc) 1946 continue; 1947 if (tmp_connector->dpms == DRM_MODE_DPMS_ON) { 1948 active = true; 1949 break; 1950 } 1951 } 1952 1953 crtc_state->active = active; 1954 ret = drm_atomic_commit(state); 1955 out: 1956 if (ret != 0) 1957 connector->dpms = old_mode; 1958 return ret; 1959 } 1960 1961 int drm_atomic_set_property(struct drm_atomic_state *state, 1962 struct drm_mode_object *obj, 1963 struct drm_property *prop, 1964 uint64_t prop_value) 1965 { 1966 struct drm_mode_object *ref; 1967 int ret; 1968 1969 if (!drm_property_change_valid_get(prop, prop_value, &ref)) 1970 return -EINVAL; 1971 1972 switch (obj->type) { 1973 case DRM_MODE_OBJECT_CONNECTOR: { 1974 struct drm_connector *connector = obj_to_connector(obj); 1975 struct drm_connector_state *connector_state; 1976 1977 connector_state = drm_atomic_get_connector_state(state, connector); 1978 if (IS_ERR(connector_state)) { 1979 ret = PTR_ERR(connector_state); 1980 break; 1981 } 1982 1983 ret = drm_atomic_connector_set_property(connector, 1984 connector_state, prop, prop_value); 1985 break; 1986 } 1987 case DRM_MODE_OBJECT_CRTC: { 1988 struct drm_crtc *crtc = obj_to_crtc(obj); 1989 struct drm_crtc_state *crtc_state; 1990 1991 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1992 if (IS_ERR(crtc_state)) { 1993 ret = PTR_ERR(crtc_state); 1994 break; 1995 } 1996 1997 ret = drm_atomic_crtc_set_property(crtc, 1998 crtc_state, prop, prop_value); 1999 break; 2000 } 2001 case DRM_MODE_OBJECT_PLANE: { 2002 struct drm_plane *plane = obj_to_plane(obj); 2003 struct drm_plane_state *plane_state; 2004 2005 plane_state = drm_atomic_get_plane_state(state, plane); 2006 if (IS_ERR(plane_state)) { 2007 ret = PTR_ERR(plane_state); 2008 break; 2009 } 2010 2011 ret = drm_atomic_plane_set_property(plane, 2012 plane_state, prop, prop_value); 2013 break; 2014 } 2015 default: 2016 ret = -EINVAL; 2017 break; 2018 } 2019 2020 drm_property_change_valid_put(prop, ref); 2021 return ret; 2022 } 2023 2024 /** 2025 * drm_atomic_clean_old_fb -- Unset old_fb pointers and set plane->fb pointers. 2026 * 2027 * @dev: drm device to check. 2028 * @plane_mask: plane mask for planes that were updated. 2029 * @ret: return value, can be -EDEADLK for a retry. 2030 * 2031 * Before doing an update &drm_plane.old_fb is set to &drm_plane.fb, but before 2032 * dropping the locks old_fb needs to be set to NULL and plane->fb updated. This 2033 * is a common operation for each atomic update, so this call is split off as a 2034 * helper. 2035 */ 2036 void drm_atomic_clean_old_fb(struct drm_device *dev, 2037 unsigned plane_mask, 2038 int ret) 2039 { 2040 struct drm_plane *plane; 2041 2042 /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping 2043 * locks (ie. while it is still safe to deref plane->state). We 2044 * need to do this here because the driver entry points cannot 2045 * distinguish between legacy and atomic ioctls. 2046 */ 2047 drm_for_each_plane_mask(plane, dev, plane_mask) { 2048 if (ret == 0) { 2049 struct drm_framebuffer *new_fb = plane->state->fb; 2050 if (new_fb) 2051 drm_framebuffer_get(new_fb); 2052 plane->fb = new_fb; 2053 plane->crtc = plane->state->crtc; 2054 2055 if (plane->old_fb) 2056 drm_framebuffer_put(plane->old_fb); 2057 } 2058 plane->old_fb = NULL; 2059 } 2060 } 2061 EXPORT_SYMBOL(drm_atomic_clean_old_fb); 2062 2063 /** 2064 * DOC: explicit fencing properties 2065 * 2066 * Explicit fencing allows userspace to control the buffer synchronization 2067 * between devices. A Fence or a group of fences are transfered to/from 2068 * userspace using Sync File fds and there are two DRM properties for that. 2069 * IN_FENCE_FD on each DRM Plane to send fences to the kernel and 2070 * OUT_FENCE_PTR on each DRM CRTC to receive fences from the kernel. 2071 * 2072 * As a contrast, with implicit fencing the kernel keeps track of any 2073 * ongoing rendering, and automatically ensures that the atomic update waits 2074 * for any pending rendering to complete. For shared buffers represented with 2075 * a &struct dma_buf this is tracked in &struct reservation_object. 2076 * Implicit syncing is how Linux traditionally worked (e.g. DRI2/3 on X.org), 2077 * whereas explicit fencing is what Android wants. 2078 * 2079 * "IN_FENCE_FD”: 2080 * Use this property to pass a fence that DRM should wait on before 2081 * proceeding with the Atomic Commit request and show the framebuffer for 2082 * the plane on the screen. The fence can be either a normal fence or a 2083 * merged one, the sync_file framework will handle both cases and use a 2084 * fence_array if a merged fence is received. Passing -1 here means no 2085 * fences to wait on. 2086 * 2087 * If the Atomic Commit request has the DRM_MODE_ATOMIC_TEST_ONLY flag 2088 * it will only check if the Sync File is a valid one. 2089 * 2090 * On the driver side the fence is stored on the @fence parameter of 2091 * &struct drm_plane_state. Drivers which also support implicit fencing 2092 * should set the implicit fence using drm_atomic_set_fence_for_plane(), 2093 * to make sure there's consistent behaviour between drivers in precedence 2094 * of implicit vs. explicit fencing. 2095 * 2096 * "OUT_FENCE_PTR”: 2097 * Use this property to pass a file descriptor pointer to DRM. Once the 2098 * Atomic Commit request call returns OUT_FENCE_PTR will be filled with 2099 * the file descriptor number of a Sync File. This Sync File contains the 2100 * CRTC fence that will be signaled when all framebuffers present on the 2101 * Atomic Commit * request for that given CRTC are scanned out on the 2102 * screen. 2103 * 2104 * The Atomic Commit request fails if a invalid pointer is passed. If the 2105 * Atomic Commit request fails for any other reason the out fence fd 2106 * returned will be -1. On a Atomic Commit with the 2107 * DRM_MODE_ATOMIC_TEST_ONLY flag the out fence will also be set to -1. 2108 * 2109 * Note that out-fences don't have a special interface to drivers and are 2110 * internally represented by a &struct drm_pending_vblank_event in struct 2111 * &drm_crtc_state, which is also used by the nonblocking atomic commit 2112 * helpers and for the DRM event handling for existing userspace. 2113 */ 2114 2115 struct drm_out_fence_state { 2116 s32 __user *out_fence_ptr; 2117 struct sync_file *sync_file; 2118 int fd; 2119 }; 2120 2121 static int setup_out_fence(struct drm_out_fence_state *fence_state, 2122 struct dma_fence *fence) 2123 { 2124 fence_state->fd = get_unused_fd_flags(O_CLOEXEC); 2125 if (fence_state->fd < 0) 2126 return fence_state->fd; 2127 2128 if (put_user(fence_state->fd, fence_state->out_fence_ptr)) 2129 return -EFAULT; 2130 2131 fence_state->sync_file = sync_file_create(fence); 2132 if (!fence_state->sync_file) 2133 return -ENOMEM; 2134 2135 return 0; 2136 } 2137 2138 static int prepare_crtc_signaling(struct drm_device *dev, 2139 struct drm_atomic_state *state, 2140 struct drm_mode_atomic *arg, 2141 struct drm_file *file_priv, 2142 struct drm_out_fence_state **fence_state, 2143 unsigned int *num_fences) 2144 { 2145 struct drm_crtc *crtc; 2146 struct drm_crtc_state *crtc_state; 2147 int i, c = 0, ret; 2148 2149 if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) 2150 return 0; 2151 2152 for_each_new_crtc_in_state(state, crtc, crtc_state, i) { 2153 s32 __user *fence_ptr; 2154 2155 fence_ptr = get_out_fence_for_crtc(crtc_state->state, crtc); 2156 2157 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT || fence_ptr) { 2158 struct drm_pending_vblank_event *e; 2159 2160 e = create_vblank_event(crtc, arg->user_data); 2161 if (!e) 2162 return -ENOMEM; 2163 2164 crtc_state->event = e; 2165 } 2166 2167 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) { 2168 struct drm_pending_vblank_event *e = crtc_state->event; 2169 2170 if (!file_priv) 2171 continue; 2172 2173 ret = drm_event_reserve_init(dev, file_priv, &e->base, 2174 &e->event.base); 2175 if (ret) { 2176 kfree(e); 2177 crtc_state->event = NULL; 2178 return ret; 2179 } 2180 } 2181 2182 if (fence_ptr) { 2183 struct dma_fence *fence; 2184 struct drm_out_fence_state *f; 2185 2186 f = krealloc(*fence_state, sizeof(**fence_state) * 2187 (*num_fences + 1), GFP_KERNEL); 2188 if (!f) 2189 return -ENOMEM; 2190 2191 memset(&f[*num_fences], 0, sizeof(*f)); 2192 2193 f[*num_fences].out_fence_ptr = fence_ptr; 2194 *fence_state = f; 2195 2196 fence = drm_crtc_create_fence(crtc); 2197 if (!fence) 2198 return -ENOMEM; 2199 2200 ret = setup_out_fence(&f[(*num_fences)++], fence); 2201 if (ret) { 2202 dma_fence_put(fence); 2203 return ret; 2204 } 2205 2206 crtc_state->event->base.fence = fence; 2207 } 2208 2209 c++; 2210 } 2211 2212 /* 2213 * Having this flag means user mode pends on event which will never 2214 * reach due to lack of at least one CRTC for signaling 2215 */ 2216 if (c == 0 && (arg->flags & DRM_MODE_PAGE_FLIP_EVENT)) 2217 return -EINVAL; 2218 2219 return 0; 2220 } 2221 2222 static void complete_crtc_signaling(struct drm_device *dev, 2223 struct drm_atomic_state *state, 2224 struct drm_out_fence_state *fence_state, 2225 unsigned int num_fences, 2226 bool install_fds) 2227 { 2228 struct drm_crtc *crtc; 2229 struct drm_crtc_state *crtc_state; 2230 int i; 2231 2232 if (install_fds) { 2233 for (i = 0; i < num_fences; i++) 2234 fd_install(fence_state[i].fd, 2235 fence_state[i].sync_file->file); 2236 2237 kfree(fence_state); 2238 return; 2239 } 2240 2241 for_each_new_crtc_in_state(state, crtc, crtc_state, i) { 2242 struct drm_pending_vblank_event *event = crtc_state->event; 2243 /* 2244 * Free the allocated event. drm_atomic_helper_setup_commit 2245 * can allocate an event too, so only free it if it's ours 2246 * to prevent a double free in drm_atomic_state_clear. 2247 */ 2248 if (event && (event->base.fence || event->base.file_priv)) { 2249 drm_event_cancel_free(dev, &event->base); 2250 crtc_state->event = NULL; 2251 } 2252 } 2253 2254 if (!fence_state) 2255 return; 2256 2257 for (i = 0; i < num_fences; i++) { 2258 if (fence_state[i].sync_file) 2259 fput(fence_state[i].sync_file->file); 2260 if (fence_state[i].fd >= 0) 2261 put_unused_fd(fence_state[i].fd); 2262 2263 /* If this fails log error to the user */ 2264 if (fence_state[i].out_fence_ptr && 2265 put_user(-1, fence_state[i].out_fence_ptr)) 2266 DRM_DEBUG_ATOMIC("Couldn't clear out_fence_ptr\n"); 2267 } 2268 2269 kfree(fence_state); 2270 } 2271 2272 int drm_mode_atomic_ioctl(struct drm_device *dev, 2273 void *data, struct drm_file *file_priv) 2274 { 2275 struct drm_mode_atomic *arg = data; 2276 uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr); 2277 uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr); 2278 uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr); 2279 uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr); 2280 unsigned int copied_objs, copied_props; 2281 struct drm_atomic_state *state; 2282 struct drm_modeset_acquire_ctx ctx; 2283 struct drm_plane *plane; 2284 struct drm_out_fence_state *fence_state; 2285 unsigned plane_mask; 2286 int ret = 0; 2287 unsigned int i, j, num_fences; 2288 2289 /* disallow for drivers not supporting atomic: */ 2290 if (!drm_core_check_feature(dev, DRIVER_ATOMIC)) 2291 return -EINVAL; 2292 2293 /* disallow for userspace that has not enabled atomic cap (even 2294 * though this may be a bit overkill, since legacy userspace 2295 * wouldn't know how to call this ioctl) 2296 */ 2297 if (!file_priv->atomic) 2298 return -EINVAL; 2299 2300 if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS) 2301 return -EINVAL; 2302 2303 if (arg->reserved) 2304 return -EINVAL; 2305 2306 if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) && 2307 !dev->mode_config.async_page_flip) 2308 return -EINVAL; 2309 2310 /* can't test and expect an event at the same time. */ 2311 if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) && 2312 (arg->flags & DRM_MODE_PAGE_FLIP_EVENT)) 2313 return -EINVAL; 2314 2315 drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE); 2316 2317 state = drm_atomic_state_alloc(dev); 2318 if (!state) 2319 return -ENOMEM; 2320 2321 state->acquire_ctx = &ctx; 2322 state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET); 2323 2324 retry: 2325 plane_mask = 0; 2326 copied_objs = 0; 2327 copied_props = 0; 2328 fence_state = NULL; 2329 num_fences = 0; 2330 2331 for (i = 0; i < arg->count_objs; i++) { 2332 uint32_t obj_id, count_props; 2333 struct drm_mode_object *obj; 2334 2335 if (get_user(obj_id, objs_ptr + copied_objs)) { 2336 ret = -EFAULT; 2337 goto out; 2338 } 2339 2340 obj = drm_mode_object_find(dev, file_priv, obj_id, DRM_MODE_OBJECT_ANY); 2341 if (!obj) { 2342 ret = -ENOENT; 2343 goto out; 2344 } 2345 2346 if (!obj->properties) { 2347 drm_mode_object_put(obj); 2348 ret = -ENOENT; 2349 goto out; 2350 } 2351 2352 if (get_user(count_props, count_props_ptr + copied_objs)) { 2353 drm_mode_object_put(obj); 2354 ret = -EFAULT; 2355 goto out; 2356 } 2357 2358 copied_objs++; 2359 2360 for (j = 0; j < count_props; j++) { 2361 uint32_t prop_id; 2362 uint64_t prop_value; 2363 struct drm_property *prop; 2364 2365 if (get_user(prop_id, props_ptr + copied_props)) { 2366 drm_mode_object_put(obj); 2367 ret = -EFAULT; 2368 goto out; 2369 } 2370 2371 prop = drm_mode_obj_find_prop_id(obj, prop_id); 2372 if (!prop) { 2373 drm_mode_object_put(obj); 2374 ret = -ENOENT; 2375 goto out; 2376 } 2377 2378 if (copy_from_user(&prop_value, 2379 prop_values_ptr + copied_props, 2380 sizeof(prop_value))) { 2381 drm_mode_object_put(obj); 2382 ret = -EFAULT; 2383 goto out; 2384 } 2385 2386 ret = drm_atomic_set_property(state, obj, prop, 2387 prop_value); 2388 if (ret) { 2389 drm_mode_object_put(obj); 2390 goto out; 2391 } 2392 2393 copied_props++; 2394 } 2395 2396 if (obj->type == DRM_MODE_OBJECT_PLANE && count_props && 2397 !(arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)) { 2398 plane = obj_to_plane(obj); 2399 plane_mask |= (1 << drm_plane_index(plane)); 2400 plane->old_fb = plane->fb; 2401 } 2402 drm_mode_object_put(obj); 2403 } 2404 2405 ret = prepare_crtc_signaling(dev, state, arg, file_priv, &fence_state, 2406 &num_fences); 2407 if (ret) 2408 goto out; 2409 2410 if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) { 2411 ret = drm_atomic_check_only(state); 2412 } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) { 2413 ret = drm_atomic_nonblocking_commit(state); 2414 } else { 2415 if (unlikely(drm_debug & DRM_UT_STATE)) 2416 drm_atomic_print_state(state); 2417 2418 ret = drm_atomic_commit(state); 2419 } 2420 2421 out: 2422 drm_atomic_clean_old_fb(dev, plane_mask, ret); 2423 2424 complete_crtc_signaling(dev, state, fence_state, num_fences, !ret); 2425 2426 if (ret == -EDEADLK) { 2427 drm_atomic_state_clear(state); 2428 ret = drm_modeset_backoff(&ctx); 2429 if (!ret) 2430 goto retry; 2431 } 2432 2433 drm_atomic_state_put(state); 2434 2435 drm_modeset_drop_locks(&ctx); 2436 drm_modeset_acquire_fini(&ctx); 2437 2438 return ret; 2439 } 2440