1/* 2 * Copyright (C) 2014 Red Hat 3 * Copyright (C) 2014 Intel Corp. 4 * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 * OTHER DEALINGS IN THE SOFTWARE. 23 * 24 * Authors: 25 * Rob Clark <robdclark@gmail.com> 26 * Daniel Vetter <daniel.vetter@ffwll.ch> 27 */ 28 29 30#include <linux/sync_file.h> 31 32#include <drm/drm_atomic.h> 33#include <drm/drm_atomic_uapi.h> 34#include <drm/drm_blend.h> 35#include <drm/drm_bridge.h> 36#include <drm/drm_debugfs.h> 37#include <drm/drm_device.h> 38#include <drm/drm_drv.h> 39#include <drm/drm_file.h> 40#include <drm/drm_fourcc.h> 41#include <drm/drm_framebuffer.h> 42#include <drm/drm_mode.h> 43#include <drm/drm_print.h> 44#include <drm/drm_writeback.h> 45 46#include "drm_crtc_internal.h" 47#include "drm_internal.h" 48 49void __drm_crtc_commit_free(struct kref *kref) 50{ 51 struct drm_crtc_commit *commit = 52 container_of(kref, struct drm_crtc_commit, ref); 53 54 kfree(commit); 55} 56EXPORT_SYMBOL(__drm_crtc_commit_free); 57 58/** 59 * drm_crtc_commit_wait - Waits for a commit to complete 60 * @commit: &drm_crtc_commit to wait for 61 * 62 * Waits for a given &drm_crtc_commit to be programmed into the 63 * hardware and flipped to. 64 * 65 * Returns: 66 * 67 * 0 on success, a negative error code otherwise. 68 */ 69int drm_crtc_commit_wait(struct drm_crtc_commit *commit) 70{ 71 unsigned long timeout = 10 * HZ; 72 int ret; 73 74 if (!commit) 75 return 0; 76 77 ret = wait_for_completion_timeout(&commit->hw_done, timeout); 78 if (!ret) { 79 drm_err(commit->crtc->dev, "hw_done timed out\n"); 80 return -ETIMEDOUT; 81 } 82 83 /* 84 * Currently no support for overwriting flips, hence 85 * stall for previous one to execute completely. 86 */ 87 ret = wait_for_completion_timeout(&commit->flip_done, timeout); 88 if (!ret) { 89 drm_err(commit->crtc->dev, "flip_done timed out\n"); 90 return -ETIMEDOUT; 91 } 92 93 return 0; 94} 95EXPORT_SYMBOL(drm_crtc_commit_wait); 96 97/** 98 * drm_atomic_state_default_release - 99 * release memory initialized by drm_atomic_state_init 100 * @state: atomic state 101 * 102 * Free all the memory allocated by drm_atomic_state_init. 103 * This should only be used by drivers which are still subclassing 104 * &drm_atomic_state and haven't switched to &drm_private_state yet. 105 */ 106void drm_atomic_state_default_release(struct drm_atomic_state *state) 107{ 108 kfree(state->connectors); 109 kfree(state->crtcs); 110 kfree(state->planes); 111 kfree(state->private_objs); 112} 113EXPORT_SYMBOL(drm_atomic_state_default_release); 114 115/** 116 * drm_atomic_state_init - init new atomic state 117 * @dev: DRM device 118 * @state: atomic state 119 * 120 * Default implementation for filling in a new atomic state. 121 * This should only be used by drivers which are still subclassing 122 * &drm_atomic_state and haven't switched to &drm_private_state yet. 123 */ 124int 125drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state) 126{ 127 kref_init(&state->ref); 128 129 /* TODO legacy paths should maybe do a better job about 130 * setting this appropriately? 131 */ 132 state->allow_modeset = true; 133 134 state->crtcs = kcalloc(dev->mode_config.num_crtc, 135 sizeof(*state->crtcs), GFP_KERNEL); 136 if (!state->crtcs) 137 goto fail; 138 state->planes = kcalloc(dev->mode_config.num_total_plane, 139 sizeof(*state->planes), GFP_KERNEL); 140 if (!state->planes) 141 goto fail; 142 143 /* 144 * Because drm_atomic_state can be committed asynchronously we need our 145 * own reference and cannot rely on the on implied by drm_file in the 146 * ioctl call. 147 */ 148 drm_dev_get(dev); 149 state->dev = dev; 150 151 drm_dbg_atomic(dev, "Allocated atomic state %p\n", state); 152 153 return 0; 154fail: 155 drm_atomic_state_default_release(state); 156 return -ENOMEM; 157} 158EXPORT_SYMBOL(drm_atomic_state_init); 159 160/** 161 * drm_atomic_state_alloc - allocate atomic state 162 * @dev: DRM device 163 * 164 * This allocates an empty atomic state to track updates. 165 */ 166struct drm_atomic_state * 167drm_atomic_state_alloc(struct drm_device *dev) 168{ 169 struct drm_mode_config *config = &dev->mode_config; 170 171 if (!config->funcs->atomic_state_alloc) { 172 struct drm_atomic_state *state; 173 174 state = kzalloc(sizeof(*state), GFP_KERNEL); 175 if (!state) 176 return NULL; 177 if (drm_atomic_state_init(dev, state) < 0) { 178 kfree(state); 179 return NULL; 180 } 181 return state; 182 } 183 184 return config->funcs->atomic_state_alloc(dev); 185} 186EXPORT_SYMBOL(drm_atomic_state_alloc); 187 188/** 189 * drm_atomic_state_default_clear - clear base atomic state 190 * @state: atomic state 191 * 192 * Default implementation for clearing atomic state. 193 * This should only be used by drivers which are still subclassing 194 * &drm_atomic_state and haven't switched to &drm_private_state yet. 195 */ 196void drm_atomic_state_default_clear(struct drm_atomic_state *state) 197{ 198 struct drm_device *dev = state->dev; 199 struct drm_mode_config *config = &dev->mode_config; 200 int i; 201 202 drm_dbg_atomic(dev, "Clearing atomic state %p\n", state); 203 204 for (i = 0; i < state->num_connector; i++) { 205 struct drm_connector *connector = state->connectors[i].ptr; 206 207 if (!connector) 208 continue; 209 210 connector->funcs->atomic_destroy_state(connector, 211 state->connectors[i].state); 212 state->connectors[i].ptr = NULL; 213 state->connectors[i].state = NULL; 214 state->connectors[i].old_state = NULL; 215 state->connectors[i].new_state = NULL; 216 drm_connector_put(connector); 217 } 218 219 for (i = 0; i < config->num_crtc; i++) { 220 struct drm_crtc *crtc = state->crtcs[i].ptr; 221 222 if (!crtc) 223 continue; 224 225 crtc->funcs->atomic_destroy_state(crtc, 226 state->crtcs[i].state); 227 228 state->crtcs[i].ptr = NULL; 229 state->crtcs[i].state = NULL; 230 state->crtcs[i].old_state = NULL; 231 state->crtcs[i].new_state = NULL; 232 233 if (state->crtcs[i].commit) { 234 drm_crtc_commit_put(state->crtcs[i].commit); 235 state->crtcs[i].commit = NULL; 236 } 237 } 238 239 for (i = 0; i < config->num_total_plane; i++) { 240 struct drm_plane *plane = state->planes[i].ptr; 241 242 if (!plane) 243 continue; 244 245 plane->funcs->atomic_destroy_state(plane, 246 state->planes[i].state); 247 state->planes[i].ptr = NULL; 248 state->planes[i].state = NULL; 249 state->planes[i].old_state = NULL; 250 state->planes[i].new_state = NULL; 251 } 252 253 for (i = 0; i < state->num_private_objs; i++) { 254 struct drm_private_obj *obj = state->private_objs[i].ptr; 255 256 obj->funcs->atomic_destroy_state(obj, 257 state->private_objs[i].state); 258 state->private_objs[i].ptr = NULL; 259 state->private_objs[i].state = NULL; 260 state->private_objs[i].old_state = NULL; 261 state->private_objs[i].new_state = NULL; 262 } 263 state->num_private_objs = 0; 264 265 if (state->fake_commit) { 266 drm_crtc_commit_put(state->fake_commit); 267 state->fake_commit = NULL; 268 } 269} 270EXPORT_SYMBOL(drm_atomic_state_default_clear); 271 272/** 273 * drm_atomic_state_clear - clear state object 274 * @state: atomic state 275 * 276 * When the w/w mutex algorithm detects a deadlock we need to back off and drop 277 * all locks. So someone else could sneak in and change the current modeset 278 * configuration. Which means that all the state assembled in @state is no 279 * longer an atomic update to the current state, but to some arbitrary earlier 280 * state. Which could break assumptions the driver's 281 * &drm_mode_config_funcs.atomic_check likely relies on. 282 * 283 * Hence we must clear all cached state and completely start over, using this 284 * function. 285 */ 286void drm_atomic_state_clear(struct drm_atomic_state *state) 287{ 288 struct drm_device *dev = state->dev; 289 struct drm_mode_config *config = &dev->mode_config; 290 291 if (config->funcs->atomic_state_clear) 292 config->funcs->atomic_state_clear(state); 293 else 294 drm_atomic_state_default_clear(state); 295} 296EXPORT_SYMBOL(drm_atomic_state_clear); 297 298/** 299 * __drm_atomic_state_free - free all memory for an atomic state 300 * @ref: This atomic state to deallocate 301 * 302 * This frees all memory associated with an atomic state, including all the 303 * per-object state for planes, CRTCs and connectors. 304 */ 305void __drm_atomic_state_free(struct kref *ref) 306{ 307 struct drm_atomic_state *state = container_of(ref, typeof(*state), ref); 308 struct drm_device *dev = state->dev; 309 struct drm_mode_config *config = &dev->mode_config; 310 311 drm_atomic_state_clear(state); 312 313 drm_dbg_atomic(state->dev, "Freeing atomic state %p\n", state); 314 315 if (config->funcs->atomic_state_free) { 316 config->funcs->atomic_state_free(state); 317 } else { 318 drm_atomic_state_default_release(state); 319 kfree(state); 320 } 321 322 drm_dev_put(dev); 323} 324EXPORT_SYMBOL(__drm_atomic_state_free); 325 326/** 327 * drm_atomic_get_crtc_state - get CRTC state 328 * @state: global atomic state object 329 * @crtc: CRTC to get state object for 330 * 331 * This function returns the CRTC state for the given CRTC, allocating it if 332 * needed. It will also grab the relevant CRTC lock to make sure that the state 333 * is consistent. 334 * 335 * WARNING: Drivers may only add new CRTC states to a @state if 336 * drm_atomic_state.allow_modeset is set, or if it's a driver-internal commit 337 * not created by userspace through an IOCTL call. 338 * 339 * Returns: 340 * 341 * Either the allocated state or the error code encoded into the pointer. When 342 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the 343 * entire atomic sequence must be restarted. All other errors are fatal. 344 */ 345struct drm_crtc_state * 346drm_atomic_get_crtc_state(struct drm_atomic_state *state, 347 struct drm_crtc *crtc) 348{ 349 int ret, index = drm_crtc_index(crtc); 350 struct drm_crtc_state *crtc_state; 351 352 WARN_ON(!state->acquire_ctx); 353 354 crtc_state = drm_atomic_get_existing_crtc_state(state, crtc); 355 if (crtc_state) 356 return crtc_state; 357 358 ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx); 359 if (ret) 360 return ERR_PTR(ret); 361 362 crtc_state = crtc->funcs->atomic_duplicate_state(crtc); 363 if (!crtc_state) 364 return ERR_PTR(-ENOMEM); 365 366 state->crtcs[index].state = crtc_state; 367 state->crtcs[index].old_state = crtc->state; 368 state->crtcs[index].new_state = crtc_state; 369 state->crtcs[index].ptr = crtc; 370 crtc_state->state = state; 371 372 drm_dbg_atomic(state->dev, "Added [CRTC:%d:%s] %p state to %p\n", 373 crtc->base.id, crtc->name, crtc_state, state); 374 375 return crtc_state; 376} 377EXPORT_SYMBOL(drm_atomic_get_crtc_state); 378 379static int drm_atomic_crtc_check(const struct drm_crtc_state *old_crtc_state, 380 const struct drm_crtc_state *new_crtc_state) 381{ 382 struct drm_crtc *crtc = new_crtc_state->crtc; 383 384 /* NOTE: we explicitly don't enforce constraints such as primary 385 * layer covering entire screen, since that is something we want 386 * to allow (on hw that supports it). For hw that does not, it 387 * should be checked in driver's crtc->atomic_check() vfunc. 388 * 389 * TODO: Add generic modeset state checks once we support those. 390 */ 391 392 if (new_crtc_state->active && !new_crtc_state->enable) { 393 drm_dbg_atomic(crtc->dev, 394 "[CRTC:%d:%s] active without enabled\n", 395 crtc->base.id, crtc->name); 396 return -EINVAL; 397 } 398 399 /* The state->enable vs. state->mode_blob checks can be WARN_ON, 400 * as this is a kernel-internal detail that userspace should never 401 * be able to trigger. 402 */ 403 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) && 404 WARN_ON(new_crtc_state->enable && !new_crtc_state->mode_blob)) { 405 drm_dbg_atomic(crtc->dev, 406 "[CRTC:%d:%s] enabled without mode blob\n", 407 crtc->base.id, crtc->name); 408 return -EINVAL; 409 } 410 411 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) && 412 WARN_ON(!new_crtc_state->enable && new_crtc_state->mode_blob)) { 413 drm_dbg_atomic(crtc->dev, 414 "[CRTC:%d:%s] disabled with mode blob\n", 415 crtc->base.id, crtc->name); 416 return -EINVAL; 417 } 418 419 /* 420 * Reject event generation for when a CRTC is off and stays off. 421 * It wouldn't be hard to implement this, but userspace has a track 422 * record of happily burning through 100% cpu (or worse, crash) when the 423 * display pipe is suspended. To avoid all that fun just reject updates 424 * that ask for events since likely that indicates a bug in the 425 * compositor's drawing loop. This is consistent with the vblank IOCTL 426 * and legacy page_flip IOCTL which also reject service on a disabled 427 * pipe. 428 */ 429 if (new_crtc_state->event && 430 !new_crtc_state->active && !old_crtc_state->active) { 431 drm_dbg_atomic(crtc->dev, 432 "[CRTC:%d:%s] requesting event but off\n", 433 crtc->base.id, crtc->name); 434 return -EINVAL; 435 } 436 437 return 0; 438} 439 440static void drm_atomic_crtc_print_state(struct drm_printer *p, 441 const struct drm_crtc_state *state) 442{ 443 struct drm_crtc *crtc = state->crtc; 444 445 drm_printf(p, "crtc[%u]: %s\n", crtc->base.id, crtc->name); 446 drm_printf(p, "\tenable=%d\n", state->enable); 447 drm_printf(p, "\tactive=%d\n", state->active); 448 drm_printf(p, "\tself_refresh_active=%d\n", state->self_refresh_active); 449 drm_printf(p, "\tplanes_changed=%d\n", state->planes_changed); 450 drm_printf(p, "\tmode_changed=%d\n", state->mode_changed); 451 drm_printf(p, "\tactive_changed=%d\n", state->active_changed); 452 drm_printf(p, "\tconnectors_changed=%d\n", state->connectors_changed); 453 drm_printf(p, "\tcolor_mgmt_changed=%d\n", state->color_mgmt_changed); 454 drm_printf(p, "\tplane_mask=%x\n", state->plane_mask); 455 drm_printf(p, "\tconnector_mask=%x\n", state->connector_mask); 456 drm_printf(p, "\tencoder_mask=%x\n", state->encoder_mask); 457 drm_printf(p, "\tmode: " DRM_MODE_FMT "\n", DRM_MODE_ARG(&state->mode)); 458 459 if (crtc->funcs->atomic_print_state) 460 crtc->funcs->atomic_print_state(p, state); 461} 462 463static int drm_atomic_connector_check(struct drm_connector *connector, 464 struct drm_connector_state *state) 465{ 466 struct drm_crtc_state *crtc_state; 467 struct drm_writeback_job *writeback_job = state->writeback_job; 468 const struct drm_display_info *info = &connector->display_info; 469 470 state->max_bpc = info->bpc ? info->bpc : 8; 471 if (connector->max_bpc_property) 472 state->max_bpc = min(state->max_bpc, state->max_requested_bpc); 473 474 if ((connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK) || !writeback_job) 475 return 0; 476 477 if (writeback_job->fb && !state->crtc) { 478 drm_dbg_atomic(connector->dev, 479 "[CONNECTOR:%d:%s] framebuffer without CRTC\n", 480 connector->base.id, connector->name); 481 return -EINVAL; 482 } 483 484 if (state->crtc) 485 crtc_state = drm_atomic_get_existing_crtc_state(state->state, 486 state->crtc); 487 488 if (writeback_job->fb && !crtc_state->active) { 489 drm_dbg_atomic(connector->dev, 490 "[CONNECTOR:%d:%s] has framebuffer, but [CRTC:%d] is off\n", 491 connector->base.id, connector->name, 492 state->crtc->base.id); 493 return -EINVAL; 494 } 495 496 if (!writeback_job->fb) { 497 if (writeback_job->out_fence) { 498 drm_dbg_atomic(connector->dev, 499 "[CONNECTOR:%d:%s] requesting out-fence without framebuffer\n", 500 connector->base.id, connector->name); 501 return -EINVAL; 502 } 503 504 drm_writeback_cleanup_job(writeback_job); 505 state->writeback_job = NULL; 506 } 507 508 return 0; 509} 510 511/** 512 * drm_atomic_get_plane_state - get plane state 513 * @state: global atomic state object 514 * @plane: plane to get state object for 515 * 516 * This function returns the plane state for the given plane, allocating it if 517 * needed. It will also grab the relevant plane lock to make sure that the state 518 * is consistent. 519 * 520 * Returns: 521 * 522 * Either the allocated state or the error code encoded into the pointer. When 523 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the 524 * entire atomic sequence must be restarted. All other errors are fatal. 525 */ 526struct drm_plane_state * 527drm_atomic_get_plane_state(struct drm_atomic_state *state, 528 struct drm_plane *plane) 529{ 530 int ret, index = drm_plane_index(plane); 531 struct drm_plane_state *plane_state; 532 533 WARN_ON(!state->acquire_ctx); 534 535 /* the legacy pointers should never be set */ 536 WARN_ON(plane->fb); 537 WARN_ON(plane->old_fb); 538 WARN_ON(plane->crtc); 539 540 plane_state = drm_atomic_get_existing_plane_state(state, plane); 541 if (plane_state) 542 return plane_state; 543 544 ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx); 545 if (ret) 546 return ERR_PTR(ret); 547 548 plane_state = plane->funcs->atomic_duplicate_state(plane); 549 if (!plane_state) 550 return ERR_PTR(-ENOMEM); 551 552 state->planes[index].state = plane_state; 553 state->planes[index].ptr = plane; 554 state->planes[index].old_state = plane->state; 555 state->planes[index].new_state = plane_state; 556 plane_state->state = state; 557 558 drm_dbg_atomic(plane->dev, "Added [PLANE:%d:%s] %p state to %p\n", 559 plane->base.id, plane->name, plane_state, state); 560 561 if (plane_state->crtc) { 562 struct drm_crtc_state *crtc_state; 563 564 crtc_state = drm_atomic_get_crtc_state(state, 565 plane_state->crtc); 566 if (IS_ERR(crtc_state)) 567 return ERR_CAST(crtc_state); 568 } 569 570 return plane_state; 571} 572EXPORT_SYMBOL(drm_atomic_get_plane_state); 573 574static bool 575plane_switching_crtc(const struct drm_plane_state *old_plane_state, 576 const struct drm_plane_state *new_plane_state) 577{ 578 if (!old_plane_state->crtc || !new_plane_state->crtc) 579 return false; 580 581 if (old_plane_state->crtc == new_plane_state->crtc) 582 return false; 583 584 /* This could be refined, but currently there's no helper or driver code 585 * to implement direct switching of active planes nor userspace to take 586 * advantage of more direct plane switching without the intermediate 587 * full OFF state. 588 */ 589 return true; 590} 591 592/** 593 * drm_atomic_plane_check - check plane state 594 * @old_plane_state: old plane state to check 595 * @new_plane_state: new plane state to check 596 * 597 * Provides core sanity checks for plane state. 598 * 599 * RETURNS: 600 * Zero on success, error code on failure 601 */ 602static int drm_atomic_plane_check(const struct drm_plane_state *old_plane_state, 603 const struct drm_plane_state *new_plane_state) 604{ 605 struct drm_plane *plane = new_plane_state->plane; 606 struct drm_crtc *crtc = new_plane_state->crtc; 607 const struct drm_framebuffer *fb = new_plane_state->fb; 608 unsigned int fb_width, fb_height; 609 struct drm_mode_rect *clips; 610 uint32_t num_clips; 611 int ret; 612 613 /* either *both* CRTC and FB must be set, or neither */ 614 if (crtc && !fb) { 615 drm_dbg_atomic(plane->dev, "[PLANE:%d:%s] CRTC set but no FB\n", 616 plane->base.id, plane->name); 617 return -EINVAL; 618 } else if (fb && !crtc) { 619 drm_dbg_atomic(plane->dev, "[PLANE:%d:%s] FB set but no CRTC\n", 620 plane->base.id, plane->name); 621 return -EINVAL; 622 } 623 624 /* if disabled, we don't care about the rest of the state: */ 625 if (!crtc) 626 return 0; 627 628 /* Check whether this plane is usable on this CRTC */ 629 if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) { 630 drm_dbg_atomic(plane->dev, 631 "Invalid [CRTC:%d:%s] for [PLANE:%d:%s]\n", 632 crtc->base.id, crtc->name, 633 plane->base.id, plane->name); 634 return -EINVAL; 635 } 636 637 /* Check whether this plane supports the fb pixel format. */ 638 ret = drm_plane_check_pixel_format(plane, fb->format->format, 639 fb->modifier); 640 if (ret) { 641 drm_dbg_atomic(plane->dev, 642 "[PLANE:%d:%s] invalid pixel format %p4cc, modifier 0x%llx\n", 643 plane->base.id, plane->name, 644 &fb->format->format, fb->modifier); 645 return ret; 646 } 647 648 /* Give drivers some help against integer overflows */ 649 if (new_plane_state->crtc_w > INT_MAX || 650 new_plane_state->crtc_x > INT_MAX - (int32_t) new_plane_state->crtc_w || 651 new_plane_state->crtc_h > INT_MAX || 652 new_plane_state->crtc_y > INT_MAX - (int32_t) new_plane_state->crtc_h) { 653 drm_dbg_atomic(plane->dev, 654 "[PLANE:%d:%s] invalid CRTC coordinates %ux%u+%d+%d\n", 655 plane->base.id, plane->name, 656 new_plane_state->crtc_w, new_plane_state->crtc_h, 657 new_plane_state->crtc_x, new_plane_state->crtc_y); 658 return -ERANGE; 659 } 660 661 fb_width = fb->width << 16; 662 fb_height = fb->height << 16; 663 664 /* Make sure source coordinates are inside the fb. */ 665 if (new_plane_state->src_w > fb_width || 666 new_plane_state->src_x > fb_width - new_plane_state->src_w || 667 new_plane_state->src_h > fb_height || 668 new_plane_state->src_y > fb_height - new_plane_state->src_h) { 669 drm_dbg_atomic(plane->dev, 670 "[PLANE:%d:%s] invalid source coordinates " 671 "%u.%06ux%u.%06u+%u.%06u+%u.%06u (fb %ux%u)\n", 672 plane->base.id, plane->name, 673 new_plane_state->src_w >> 16, 674 ((new_plane_state->src_w & 0xffff) * 15625) >> 10, 675 new_plane_state->src_h >> 16, 676 ((new_plane_state->src_h & 0xffff) * 15625) >> 10, 677 new_plane_state->src_x >> 16, 678 ((new_plane_state->src_x & 0xffff) * 15625) >> 10, 679 new_plane_state->src_y >> 16, 680 ((new_plane_state->src_y & 0xffff) * 15625) >> 10, 681 fb->width, fb->height); 682 return -ENOSPC; 683 } 684 685 clips = __drm_plane_get_damage_clips(new_plane_state); 686 num_clips = drm_plane_get_damage_clips_count(new_plane_state); 687 688 /* Make sure damage clips are valid and inside the fb. */ 689 while (num_clips > 0) { 690 if (clips->x1 >= clips->x2 || 691 clips->y1 >= clips->y2 || 692 clips->x1 < 0 || 693 clips->y1 < 0 || 694 clips->x2 > fb_width || 695 clips->y2 > fb_height) { 696 drm_dbg_atomic(plane->dev, 697 "[PLANE:%d:%s] invalid damage clip %d %d %d %d\n", 698 plane->base.id, plane->name, clips->x1, 699 clips->y1, clips->x2, clips->y2); 700 return -EINVAL; 701 } 702 clips++; 703 num_clips--; 704 } 705 706 if (plane_switching_crtc(old_plane_state, new_plane_state)) { 707 drm_dbg_atomic(plane->dev, 708 "[PLANE:%d:%s] switching CRTC directly\n", 709 plane->base.id, plane->name); 710 return -EINVAL; 711 } 712 713 return 0; 714} 715 716static void drm_atomic_plane_print_state(struct drm_printer *p, 717 const struct drm_plane_state *state) 718{ 719 struct drm_plane *plane = state->plane; 720 struct drm_rect src = drm_plane_state_src(state); 721 struct drm_rect dest = drm_plane_state_dest(state); 722 723 drm_printf(p, "plane[%u]: %s\n", plane->base.id, plane->name); 724 drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)"); 725 drm_printf(p, "\tfb=%u\n", state->fb ? state->fb->base.id : 0); 726 if (state->fb) 727 drm_framebuffer_print_info(p, 2, state->fb); 728 drm_printf(p, "\tcrtc-pos=" DRM_RECT_FMT "\n", DRM_RECT_ARG(&dest)); 729 drm_printf(p, "\tsrc-pos=" DRM_RECT_FP_FMT "\n", DRM_RECT_FP_ARG(&src)); 730 drm_printf(p, "\trotation=%x\n", state->rotation); 731 drm_printf(p, "\tnormalized-zpos=%x\n", state->normalized_zpos); 732 drm_printf(p, "\tcolor-encoding=%s\n", 733 drm_get_color_encoding_name(state->color_encoding)); 734 drm_printf(p, "\tcolor-range=%s\n", 735 drm_get_color_range_name(state->color_range)); 736 drm_printf(p, "\tcolor_mgmt_changed=%d\n", state->color_mgmt_changed); 737 738 if (plane->funcs->atomic_print_state) 739 plane->funcs->atomic_print_state(p, state); 740} 741 742/** 743 * DOC: handling driver private state 744 * 745 * Very often the DRM objects exposed to userspace in the atomic modeset api 746 * (&drm_connector, &drm_crtc and &drm_plane) do not map neatly to the 747 * underlying hardware. Especially for any kind of shared resources (e.g. shared 748 * clocks, scaler units, bandwidth and fifo limits shared among a group of 749 * planes or CRTCs, and so on) it makes sense to model these as independent 750 * objects. Drivers then need to do similar state tracking and commit ordering for 751 * such private (since not exposed to userspace) objects as the atomic core and 752 * helpers already provide for connectors, planes and CRTCs. 753 * 754 * To make this easier on drivers the atomic core provides some support to track 755 * driver private state objects using struct &drm_private_obj, with the 756 * associated state struct &drm_private_state. 757 * 758 * Similar to userspace-exposed objects, private state structures can be 759 * acquired by calling drm_atomic_get_private_obj_state(). This also takes care 760 * of locking, hence drivers should not have a need to call drm_modeset_lock() 761 * directly. Sequence of the actual hardware state commit is not handled, 762 * drivers might need to keep track of struct drm_crtc_commit within subclassed 763 * structure of &drm_private_state as necessary, e.g. similar to 764 * &drm_plane_state.commit. See also &drm_atomic_state.fake_commit. 765 * 766 * All private state structures contained in a &drm_atomic_state update can be 767 * iterated using for_each_oldnew_private_obj_in_state(), 768 * for_each_new_private_obj_in_state() and for_each_old_private_obj_in_state(). 769 * Drivers are recommended to wrap these for each type of driver private state 770 * object they have, filtering on &drm_private_obj.funcs using for_each_if(), at 771 * least if they want to iterate over all objects of a given type. 772 * 773 * An earlier way to handle driver private state was by subclassing struct 774 * &drm_atomic_state. But since that encourages non-standard ways to implement 775 * the check/commit split atomic requires (by using e.g. "check and rollback or 776 * commit instead" of "duplicate state, check, then either commit or release 777 * duplicated state) it is deprecated in favour of using &drm_private_state. 778 */ 779 780/** 781 * drm_atomic_private_obj_init - initialize private object 782 * @dev: DRM device this object will be attached to 783 * @obj: private object 784 * @state: initial private object state 785 * @funcs: pointer to the struct of function pointers that identify the object 786 * type 787 * 788 * Initialize the private object, which can be embedded into any 789 * driver private object that needs its own atomic state. 790 */ 791void 792drm_atomic_private_obj_init(struct drm_device *dev, 793 struct drm_private_obj *obj, 794 struct drm_private_state *state, 795 const struct drm_private_state_funcs *funcs) 796{ 797 memset(obj, 0, sizeof(*obj)); 798 799 drm_modeset_lock_init(&obj->lock); 800 801 obj->state = state; 802 obj->funcs = funcs; 803 list_add_tail(&obj->head, &dev->mode_config.privobj_list); 804 805 state->obj = obj; 806} 807EXPORT_SYMBOL(drm_atomic_private_obj_init); 808 809/** 810 * drm_atomic_private_obj_fini - finalize private object 811 * @obj: private object 812 * 813 * Finalize the private object. 814 */ 815void 816drm_atomic_private_obj_fini(struct drm_private_obj *obj) 817{ 818 list_del(&obj->head); 819 obj->funcs->atomic_destroy_state(obj, obj->state); 820 drm_modeset_lock_fini(&obj->lock); 821} 822EXPORT_SYMBOL(drm_atomic_private_obj_fini); 823 824/** 825 * drm_atomic_get_private_obj_state - get private object state 826 * @state: global atomic state 827 * @obj: private object to get the state for 828 * 829 * This function returns the private object state for the given private object, 830 * allocating the state if needed. It will also grab the relevant private 831 * object lock to make sure that the state is consistent. 832 * 833 * RETURNS: 834 * 835 * Either the allocated state or the error code encoded into a pointer. 836 */ 837struct drm_private_state * 838drm_atomic_get_private_obj_state(struct drm_atomic_state *state, 839 struct drm_private_obj *obj) 840{ 841 int index, num_objs, i, ret; 842 size_t size; 843 struct __drm_private_objs_state *arr; 844 struct drm_private_state *obj_state; 845 846 for (i = 0; i < state->num_private_objs; i++) 847 if (obj == state->private_objs[i].ptr) 848 return state->private_objs[i].state; 849 850 ret = drm_modeset_lock(&obj->lock, state->acquire_ctx); 851 if (ret) 852 return ERR_PTR(ret); 853 854 num_objs = state->num_private_objs + 1; 855 size = sizeof(*state->private_objs) * num_objs; 856 arr = krealloc(state->private_objs, size, GFP_KERNEL); 857 if (!arr) 858 return ERR_PTR(-ENOMEM); 859 860 state->private_objs = arr; 861 index = state->num_private_objs; 862 memset(&state->private_objs[index], 0, sizeof(*state->private_objs)); 863 864 obj_state = obj->funcs->atomic_duplicate_state(obj); 865 if (!obj_state) 866 return ERR_PTR(-ENOMEM); 867 868 state->private_objs[index].state = obj_state; 869 state->private_objs[index].old_state = obj->state; 870 state->private_objs[index].new_state = obj_state; 871 state->private_objs[index].ptr = obj; 872 obj_state->state = state; 873 874 state->num_private_objs = num_objs; 875 876 drm_dbg_atomic(state->dev, 877 "Added new private object %p state %p to %p\n", 878 obj, obj_state, state); 879 880 return obj_state; 881} 882EXPORT_SYMBOL(drm_atomic_get_private_obj_state); 883 884/** 885 * drm_atomic_get_old_private_obj_state 886 * @state: global atomic state object 887 * @obj: private_obj to grab 888 * 889 * This function returns the old private object state for the given private_obj, 890 * or NULL if the private_obj is not part of the global atomic state. 891 */ 892struct drm_private_state * 893drm_atomic_get_old_private_obj_state(const struct drm_atomic_state *state, 894 struct drm_private_obj *obj) 895{ 896 int i; 897 898 for (i = 0; i < state->num_private_objs; i++) 899 if (obj == state->private_objs[i].ptr) 900 return state->private_objs[i].old_state; 901 902 return NULL; 903} 904EXPORT_SYMBOL(drm_atomic_get_old_private_obj_state); 905 906/** 907 * drm_atomic_get_new_private_obj_state 908 * @state: global atomic state object 909 * @obj: private_obj to grab 910 * 911 * This function returns the new private object state for the given private_obj, 912 * or NULL if the private_obj is not part of the global atomic state. 913 */ 914struct drm_private_state * 915drm_atomic_get_new_private_obj_state(const struct drm_atomic_state *state, 916 struct drm_private_obj *obj) 917{ 918 int i; 919 920 for (i = 0; i < state->num_private_objs; i++) 921 if (obj == state->private_objs[i].ptr) 922 return state->private_objs[i].new_state; 923 924 return NULL; 925} 926EXPORT_SYMBOL(drm_atomic_get_new_private_obj_state); 927 928/** 929 * drm_atomic_get_old_connector_for_encoder - Get old connector for an encoder 930 * @state: Atomic state 931 * @encoder: The encoder to fetch the connector state for 932 * 933 * This function finds and returns the connector that was connected to @encoder 934 * as specified by the @state. 935 * 936 * If there is no connector in @state which previously had @encoder connected to 937 * it, this function will return NULL. While this may seem like an invalid use 938 * case, it is sometimes useful to differentiate commits which had no prior 939 * connectors attached to @encoder vs ones that did (and to inspect their 940 * state). This is especially true in enable hooks because the pipeline has 941 * changed. 942 * 943 * Returns: The old connector connected to @encoder, or NULL if the encoder is 944 * not connected. 945 */ 946struct drm_connector * 947drm_atomic_get_old_connector_for_encoder(const struct drm_atomic_state *state, 948 struct drm_encoder *encoder) 949{ 950 struct drm_connector_state *conn_state; 951 struct drm_connector *connector; 952 unsigned int i; 953 954 for_each_old_connector_in_state(state, connector, conn_state, i) { 955 if (conn_state->best_encoder == encoder) 956 return connector; 957 } 958 959 return NULL; 960} 961EXPORT_SYMBOL(drm_atomic_get_old_connector_for_encoder); 962 963/** 964 * drm_atomic_get_new_connector_for_encoder - Get new connector for an encoder 965 * @state: Atomic state 966 * @encoder: The encoder to fetch the connector state for 967 * 968 * This function finds and returns the connector that will be connected to 969 * @encoder as specified by the @state. 970 * 971 * If there is no connector in @state which will have @encoder connected to it, 972 * this function will return NULL. While this may seem like an invalid use case, 973 * it is sometimes useful to differentiate commits which have no connectors 974 * attached to @encoder vs ones that do (and to inspect their state). This is 975 * especially true in disable hooks because the pipeline will change. 976 * 977 * Returns: The new connector connected to @encoder, or NULL if the encoder is 978 * not connected. 979 */ 980struct drm_connector * 981drm_atomic_get_new_connector_for_encoder(const struct drm_atomic_state *state, 982 struct drm_encoder *encoder) 983{ 984 struct drm_connector_state *conn_state; 985 struct drm_connector *connector; 986 unsigned int i; 987 988 for_each_new_connector_in_state(state, connector, conn_state, i) { 989 if (conn_state->best_encoder == encoder) 990 return connector; 991 } 992 993 return NULL; 994} 995EXPORT_SYMBOL(drm_atomic_get_new_connector_for_encoder); 996 997/** 998 * drm_atomic_get_old_crtc_for_encoder - Get old crtc for an encoder 999 * @state: Atomic state 1000 * @encoder: The encoder to fetch the crtc state for 1001 * 1002 * This function finds and returns the crtc that was connected to @encoder 1003 * as specified by the @state. 1004 * 1005 * Returns: The old crtc connected to @encoder, or NULL if the encoder is 1006 * not connected. 1007 */ 1008struct drm_crtc * 1009drm_atomic_get_old_crtc_for_encoder(struct drm_atomic_state *state, 1010 struct drm_encoder *encoder) 1011{ 1012 struct drm_connector *connector; 1013 struct drm_connector_state *conn_state; 1014 1015 connector = drm_atomic_get_old_connector_for_encoder(state, encoder); 1016 if (!connector) 1017 return NULL; 1018 1019 conn_state = drm_atomic_get_old_connector_state(state, connector); 1020 if (!conn_state) 1021 return NULL; 1022 1023 return conn_state->crtc; 1024} 1025EXPORT_SYMBOL(drm_atomic_get_old_crtc_for_encoder); 1026 1027/** 1028 * drm_atomic_get_new_crtc_for_encoder - Get new crtc for an encoder 1029 * @state: Atomic state 1030 * @encoder: The encoder to fetch the crtc state for 1031 * 1032 * This function finds and returns the crtc that will be connected to @encoder 1033 * as specified by the @state. 1034 * 1035 * Returns: The new crtc connected to @encoder, or NULL if the encoder is 1036 * not connected. 1037 */ 1038struct drm_crtc * 1039drm_atomic_get_new_crtc_for_encoder(struct drm_atomic_state *state, 1040 struct drm_encoder *encoder) 1041{ 1042 struct drm_connector *connector; 1043 struct drm_connector_state *conn_state; 1044 1045 connector = drm_atomic_get_new_connector_for_encoder(state, encoder); 1046 if (!connector) 1047 return NULL; 1048 1049 conn_state = drm_atomic_get_new_connector_state(state, connector); 1050 if (!conn_state) 1051 return NULL; 1052 1053 return conn_state->crtc; 1054} 1055EXPORT_SYMBOL(drm_atomic_get_new_crtc_for_encoder); 1056 1057/** 1058 * drm_atomic_get_connector_state - get connector state 1059 * @state: global atomic state object 1060 * @connector: connector to get state object for 1061 * 1062 * This function returns the connector state for the given connector, 1063 * allocating it if needed. It will also grab the relevant connector lock to 1064 * make sure that the state is consistent. 1065 * 1066 * Returns: 1067 * 1068 * Either the allocated state or the error code encoded into the pointer. When 1069 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the 1070 * entire atomic sequence must be restarted. All other errors are fatal. 1071 */ 1072struct drm_connector_state * 1073drm_atomic_get_connector_state(struct drm_atomic_state *state, 1074 struct drm_connector *connector) 1075{ 1076 int ret, index; 1077 struct drm_mode_config *config = &connector->dev->mode_config; 1078 struct drm_connector_state *connector_state; 1079 1080 WARN_ON(!state->acquire_ctx); 1081 1082 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx); 1083 if (ret) 1084 return ERR_PTR(ret); 1085 1086 index = drm_connector_index(connector); 1087 1088 if (index >= state->num_connector) { 1089 struct __drm_connnectors_state *c; 1090 int alloc = max(index + 1, config->num_connector); 1091 1092 c = krealloc_array(state->connectors, alloc, 1093 sizeof(*state->connectors), GFP_KERNEL); 1094 if (!c) 1095 return ERR_PTR(-ENOMEM); 1096 1097 state->connectors = c; 1098 memset(&state->connectors[state->num_connector], 0, 1099 sizeof(*state->connectors) * (alloc - state->num_connector)); 1100 1101 state->num_connector = alloc; 1102 } 1103 1104 if (state->connectors[index].state) 1105 return state->connectors[index].state; 1106 1107 connector_state = connector->funcs->atomic_duplicate_state(connector); 1108 if (!connector_state) 1109 return ERR_PTR(-ENOMEM); 1110 1111 drm_connector_get(connector); 1112 state->connectors[index].state = connector_state; 1113 state->connectors[index].old_state = connector->state; 1114 state->connectors[index].new_state = connector_state; 1115 state->connectors[index].ptr = connector; 1116 connector_state->state = state; 1117 1118 drm_dbg_atomic(connector->dev, "Added [CONNECTOR:%d:%s] %p state to %p\n", 1119 connector->base.id, connector->name, 1120 connector_state, state); 1121 1122 if (connector_state->crtc) { 1123 struct drm_crtc_state *crtc_state; 1124 1125 crtc_state = drm_atomic_get_crtc_state(state, 1126 connector_state->crtc); 1127 if (IS_ERR(crtc_state)) 1128 return ERR_CAST(crtc_state); 1129 } 1130 1131 return connector_state; 1132} 1133EXPORT_SYMBOL(drm_atomic_get_connector_state); 1134 1135static void drm_atomic_connector_print_state(struct drm_printer *p, 1136 const struct drm_connector_state *state) 1137{ 1138 struct drm_connector *connector = state->connector; 1139 1140 drm_printf(p, "connector[%u]: %s\n", connector->base.id, connector->name); 1141 drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)"); 1142 drm_printf(p, "\tself_refresh_aware=%d\n", state->self_refresh_aware); 1143 drm_printf(p, "\tmax_requested_bpc=%d\n", state->max_requested_bpc); 1144 drm_printf(p, "\tcolorspace=%s\n", drm_get_colorspace_name(state->colorspace)); 1145 1146 if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK) 1147 if (state->writeback_job && state->writeback_job->fb) 1148 drm_printf(p, "\tfb=%d\n", state->writeback_job->fb->base.id); 1149 1150 if (connector->funcs->atomic_print_state) 1151 connector->funcs->atomic_print_state(p, state); 1152} 1153 1154/** 1155 * drm_atomic_get_bridge_state - get bridge state 1156 * @state: global atomic state object 1157 * @bridge: bridge to get state object for 1158 * 1159 * This function returns the bridge state for the given bridge, allocating it 1160 * if needed. It will also grab the relevant bridge lock to make sure that the 1161 * state is consistent. 1162 * 1163 * Returns: 1164 * 1165 * Either the allocated state or the error code encoded into the pointer. When 1166 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the 1167 * entire atomic sequence must be restarted. 1168 */ 1169struct drm_bridge_state * 1170drm_atomic_get_bridge_state(struct drm_atomic_state *state, 1171 struct drm_bridge *bridge) 1172{ 1173 struct drm_private_state *obj_state; 1174 1175 obj_state = drm_atomic_get_private_obj_state(state, &bridge->base); 1176 if (IS_ERR(obj_state)) 1177 return ERR_CAST(obj_state); 1178 1179 return drm_priv_to_bridge_state(obj_state); 1180} 1181EXPORT_SYMBOL(drm_atomic_get_bridge_state); 1182 1183/** 1184 * drm_atomic_get_old_bridge_state - get old bridge state, if it exists 1185 * @state: global atomic state object 1186 * @bridge: bridge to grab 1187 * 1188 * This function returns the old bridge state for the given bridge, or NULL if 1189 * the bridge is not part of the global atomic state. 1190 */ 1191struct drm_bridge_state * 1192drm_atomic_get_old_bridge_state(const struct drm_atomic_state *state, 1193 struct drm_bridge *bridge) 1194{ 1195 struct drm_private_state *obj_state; 1196 1197 obj_state = drm_atomic_get_old_private_obj_state(state, &bridge->base); 1198 if (!obj_state) 1199 return NULL; 1200 1201 return drm_priv_to_bridge_state(obj_state); 1202} 1203EXPORT_SYMBOL(drm_atomic_get_old_bridge_state); 1204 1205/** 1206 * drm_atomic_get_new_bridge_state - get new bridge state, if it exists 1207 * @state: global atomic state object 1208 * @bridge: bridge to grab 1209 * 1210 * This function returns the new bridge state for the given bridge, or NULL if 1211 * the bridge is not part of the global atomic state. 1212 */ 1213struct drm_bridge_state * 1214drm_atomic_get_new_bridge_state(const struct drm_atomic_state *state, 1215 struct drm_bridge *bridge) 1216{ 1217 struct drm_private_state *obj_state; 1218 1219 obj_state = drm_atomic_get_new_private_obj_state(state, &bridge->base); 1220 if (!obj_state) 1221 return NULL; 1222 1223 return drm_priv_to_bridge_state(obj_state); 1224} 1225EXPORT_SYMBOL(drm_atomic_get_new_bridge_state); 1226 1227/** 1228 * drm_atomic_add_encoder_bridges - add bridges attached to an encoder 1229 * @state: atomic state 1230 * @encoder: DRM encoder 1231 * 1232 * This function adds all bridges attached to @encoder. This is needed to add 1233 * bridge states to @state and make them available when 1234 * &drm_bridge_funcs.atomic_check(), &drm_bridge_funcs.atomic_pre_enable(), 1235 * &drm_bridge_funcs.atomic_enable(), 1236 * &drm_bridge_funcs.atomic_disable_post_disable() are called. 1237 * 1238 * Returns: 1239 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK 1240 * then the w/w mutex code has detected a deadlock and the entire atomic 1241 * sequence must be restarted. All other errors are fatal. 1242 */ 1243int 1244drm_atomic_add_encoder_bridges(struct drm_atomic_state *state, 1245 struct drm_encoder *encoder) 1246{ 1247 struct drm_bridge_state *bridge_state; 1248 struct drm_bridge *bridge; 1249 1250 if (!encoder) 1251 return 0; 1252 1253 drm_dbg_atomic(encoder->dev, 1254 "Adding all bridges for [encoder:%d:%s] to %p\n", 1255 encoder->base.id, encoder->name, state); 1256 1257 drm_for_each_bridge_in_chain(encoder, bridge) { 1258 /* Skip bridges that don't implement the atomic state hooks. */ 1259 if (!bridge->funcs->atomic_duplicate_state) 1260 continue; 1261 1262 bridge_state = drm_atomic_get_bridge_state(state, bridge); 1263 if (IS_ERR(bridge_state)) 1264 return PTR_ERR(bridge_state); 1265 } 1266 1267 return 0; 1268} 1269EXPORT_SYMBOL(drm_atomic_add_encoder_bridges); 1270 1271/** 1272 * drm_atomic_add_affected_connectors - add connectors for CRTC 1273 * @state: atomic state 1274 * @crtc: DRM CRTC 1275 * 1276 * This function walks the current configuration and adds all connectors 1277 * currently using @crtc to the atomic configuration @state. Note that this 1278 * function must acquire the connection mutex. This can potentially cause 1279 * unneeded serialization if the update is just for the planes on one CRTC. Hence 1280 * drivers and helpers should only call this when really needed (e.g. when a 1281 * full modeset needs to happen due to some change). 1282 * 1283 * Returns: 1284 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK 1285 * then the w/w mutex code has detected a deadlock and the entire atomic 1286 * sequence must be restarted. All other errors are fatal. 1287 */ 1288int 1289drm_atomic_add_affected_connectors(struct drm_atomic_state *state, 1290 struct drm_crtc *crtc) 1291{ 1292 struct drm_mode_config *config = &state->dev->mode_config; 1293 struct drm_connector *connector; 1294 struct drm_connector_state *conn_state; 1295 struct drm_connector_list_iter conn_iter; 1296 struct drm_crtc_state *crtc_state; 1297 int ret; 1298 1299 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1300 if (IS_ERR(crtc_state)) 1301 return PTR_ERR(crtc_state); 1302 1303 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx); 1304 if (ret) 1305 return ret; 1306 1307 drm_dbg_atomic(crtc->dev, 1308 "Adding all current connectors for [CRTC:%d:%s] to %p\n", 1309 crtc->base.id, crtc->name, state); 1310 1311 /* 1312 * Changed connectors are already in @state, so only need to look 1313 * at the connector_mask in crtc_state. 1314 */ 1315 drm_connector_list_iter_begin(state->dev, &conn_iter); 1316 drm_for_each_connector_iter(connector, &conn_iter) { 1317 if (!(crtc_state->connector_mask & drm_connector_mask(connector))) 1318 continue; 1319 1320 conn_state = drm_atomic_get_connector_state(state, connector); 1321 if (IS_ERR(conn_state)) { 1322 drm_connector_list_iter_end(&conn_iter); 1323 return PTR_ERR(conn_state); 1324 } 1325 } 1326 drm_connector_list_iter_end(&conn_iter); 1327 1328 return 0; 1329} 1330EXPORT_SYMBOL(drm_atomic_add_affected_connectors); 1331 1332/** 1333 * drm_atomic_add_affected_planes - add planes for CRTC 1334 * @state: atomic state 1335 * @crtc: DRM CRTC 1336 * 1337 * This function walks the current configuration and adds all planes 1338 * currently used by @crtc to the atomic configuration @state. This is useful 1339 * when an atomic commit also needs to check all currently enabled plane on 1340 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC 1341 * to avoid special code to force-enable all planes. 1342 * 1343 * Since acquiring a plane state will always also acquire the w/w mutex of the 1344 * current CRTC for that plane (if there is any) adding all the plane states for 1345 * a CRTC will not reduce parallelism of atomic updates. 1346 * 1347 * Returns: 1348 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK 1349 * then the w/w mutex code has detected a deadlock and the entire atomic 1350 * sequence must be restarted. All other errors are fatal. 1351 */ 1352int 1353drm_atomic_add_affected_planes(struct drm_atomic_state *state, 1354 struct drm_crtc *crtc) 1355{ 1356 const struct drm_crtc_state *old_crtc_state = 1357 drm_atomic_get_old_crtc_state(state, crtc); 1358 struct drm_plane *plane; 1359 1360 WARN_ON(!drm_atomic_get_new_crtc_state(state, crtc)); 1361 1362 drm_dbg_atomic(crtc->dev, 1363 "Adding all current planes for [CRTC:%d:%s] to %p\n", 1364 crtc->base.id, crtc->name, state); 1365 1366 drm_for_each_plane_mask(plane, state->dev, old_crtc_state->plane_mask) { 1367 struct drm_plane_state *plane_state = 1368 drm_atomic_get_plane_state(state, plane); 1369 1370 if (IS_ERR(plane_state)) 1371 return PTR_ERR(plane_state); 1372 } 1373 return 0; 1374} 1375EXPORT_SYMBOL(drm_atomic_add_affected_planes); 1376 1377/** 1378 * drm_atomic_check_only - check whether a given config would work 1379 * @state: atomic configuration to check 1380 * 1381 * Note that this function can return -EDEADLK if the driver needed to acquire 1382 * more locks but encountered a deadlock. The caller must then do the usual w/w 1383 * backoff dance and restart. All other errors are fatal. 1384 * 1385 * Returns: 1386 * 0 on success, negative error code on failure. 1387 */ 1388int drm_atomic_check_only(struct drm_atomic_state *state) 1389{ 1390 struct drm_device *dev = state->dev; 1391 struct drm_mode_config *config = &dev->mode_config; 1392 struct drm_plane *plane; 1393 struct drm_plane_state *old_plane_state; 1394 struct drm_plane_state *new_plane_state; 1395 struct drm_crtc *crtc; 1396 struct drm_crtc_state *old_crtc_state; 1397 struct drm_crtc_state *new_crtc_state; 1398 struct drm_connector *conn; 1399 struct drm_connector_state *conn_state; 1400 unsigned int requested_crtc = 0; 1401 unsigned int affected_crtc = 0; 1402 int i, ret = 0; 1403 1404 drm_dbg_atomic(dev, "checking %p\n", state); 1405 1406 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { 1407 if (new_crtc_state->enable) 1408 requested_crtc |= drm_crtc_mask(crtc); 1409 } 1410 1411 for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) { 1412 ret = drm_atomic_plane_check(old_plane_state, new_plane_state); 1413 if (ret) { 1414 drm_dbg_atomic(dev, "[PLANE:%d:%s] atomic core check failed\n", 1415 plane->base.id, plane->name); 1416 return ret; 1417 } 1418 } 1419 1420 for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) { 1421 ret = drm_atomic_crtc_check(old_crtc_state, new_crtc_state); 1422 if (ret) { 1423 drm_dbg_atomic(dev, "[CRTC:%d:%s] atomic core check failed\n", 1424 crtc->base.id, crtc->name); 1425 return ret; 1426 } 1427 } 1428 1429 for_each_new_connector_in_state(state, conn, conn_state, i) { 1430 ret = drm_atomic_connector_check(conn, conn_state); 1431 if (ret) { 1432 drm_dbg_atomic(dev, "[CONNECTOR:%d:%s] atomic core check failed\n", 1433 conn->base.id, conn->name); 1434 return ret; 1435 } 1436 } 1437 1438 if (config->funcs->atomic_check) { 1439 ret = config->funcs->atomic_check(state->dev, state); 1440 1441 if (ret) { 1442 drm_dbg_atomic(dev, "atomic driver check for %p failed: %d\n", 1443 state, ret); 1444 return ret; 1445 } 1446 } 1447 1448 if (!state->allow_modeset) { 1449 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { 1450 if (drm_atomic_crtc_needs_modeset(new_crtc_state)) { 1451 drm_dbg_atomic(dev, "[CRTC:%d:%s] requires full modeset\n", 1452 crtc->base.id, crtc->name); 1453 return -EINVAL; 1454 } 1455 } 1456 } 1457 1458 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { 1459 if (new_crtc_state->enable) 1460 affected_crtc |= drm_crtc_mask(crtc); 1461 } 1462 1463 /* 1464 * For commits that allow modesets drivers can add other CRTCs to the 1465 * atomic commit, e.g. when they need to reallocate global resources. 1466 * This can cause spurious EBUSY, which robs compositors of a very 1467 * effective sanity check for their drawing loop. Therefor only allow 1468 * drivers to add unrelated CRTC states for modeset commits. 1469 * 1470 * FIXME: Should add affected_crtc mask to the ATOMIC IOCTL as an output 1471 * so compositors know what's going on. 1472 */ 1473 if (affected_crtc != requested_crtc) { 1474 drm_dbg_atomic(dev, 1475 "driver added CRTC to commit: requested 0x%x, affected 0x%0x\n", 1476 requested_crtc, affected_crtc); 1477 WARN(!state->allow_modeset, "adding CRTC not allowed without modesets: requested 0x%x, affected 0x%0x\n", 1478 requested_crtc, affected_crtc); 1479 } 1480 1481 return 0; 1482} 1483EXPORT_SYMBOL(drm_atomic_check_only); 1484 1485/** 1486 * drm_atomic_commit - commit configuration atomically 1487 * @state: atomic configuration to check 1488 * 1489 * Note that this function can return -EDEADLK if the driver needed to acquire 1490 * more locks but encountered a deadlock. The caller must then do the usual w/w 1491 * backoff dance and restart. All other errors are fatal. 1492 * 1493 * This function will take its own reference on @state. 1494 * Callers should always release their reference with drm_atomic_state_put(). 1495 * 1496 * Returns: 1497 * 0 on success, negative error code on failure. 1498 */ 1499int drm_atomic_commit(struct drm_atomic_state *state) 1500{ 1501 struct drm_mode_config *config = &state->dev->mode_config; 1502 struct drm_printer p = drm_info_printer(state->dev->dev); 1503 int ret; 1504 1505 if (drm_debug_enabled(DRM_UT_STATE)) 1506 drm_atomic_print_new_state(state, &p); 1507 1508 ret = drm_atomic_check_only(state); 1509 if (ret) 1510 return ret; 1511 1512 drm_dbg_atomic(state->dev, "committing %p\n", state); 1513 1514 return config->funcs->atomic_commit(state->dev, state, false); 1515} 1516EXPORT_SYMBOL(drm_atomic_commit); 1517 1518/** 1519 * drm_atomic_nonblocking_commit - atomic nonblocking commit 1520 * @state: atomic configuration to check 1521 * 1522 * Note that this function can return -EDEADLK if the driver needed to acquire 1523 * more locks but encountered a deadlock. The caller must then do the usual w/w 1524 * backoff dance and restart. All other errors are fatal. 1525 * 1526 * This function will take its own reference on @state. 1527 * Callers should always release their reference with drm_atomic_state_put(). 1528 * 1529 * Returns: 1530 * 0 on success, negative error code on failure. 1531 */ 1532int drm_atomic_nonblocking_commit(struct drm_atomic_state *state) 1533{ 1534 struct drm_mode_config *config = &state->dev->mode_config; 1535 int ret; 1536 1537 ret = drm_atomic_check_only(state); 1538 if (ret) 1539 return ret; 1540 1541 drm_dbg_atomic(state->dev, "committing %p nonblocking\n", state); 1542 1543 return config->funcs->atomic_commit(state->dev, state, true); 1544} 1545EXPORT_SYMBOL(drm_atomic_nonblocking_commit); 1546 1547/* just used from drm-client and atomic-helper: */ 1548int __drm_atomic_helper_disable_plane(struct drm_plane *plane, 1549 struct drm_plane_state *plane_state) 1550{ 1551 int ret; 1552 1553 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL); 1554 if (ret != 0) 1555 return ret; 1556 1557 drm_atomic_set_fb_for_plane(plane_state, NULL); 1558 plane_state->crtc_x = 0; 1559 plane_state->crtc_y = 0; 1560 plane_state->crtc_w = 0; 1561 plane_state->crtc_h = 0; 1562 plane_state->src_x = 0; 1563 plane_state->src_y = 0; 1564 plane_state->src_w = 0; 1565 plane_state->src_h = 0; 1566 1567 return 0; 1568} 1569EXPORT_SYMBOL(__drm_atomic_helper_disable_plane); 1570 1571static int update_output_state(struct drm_atomic_state *state, 1572 struct drm_mode_set *set) 1573{ 1574 struct drm_device *dev = set->crtc->dev; 1575 struct drm_crtc *crtc; 1576 struct drm_crtc_state *new_crtc_state; 1577 struct drm_connector *connector; 1578 struct drm_connector_state *new_conn_state; 1579 int ret, i; 1580 1581 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, 1582 state->acquire_ctx); 1583 if (ret) 1584 return ret; 1585 1586 /* First disable all connectors on the target crtc. */ 1587 ret = drm_atomic_add_affected_connectors(state, set->crtc); 1588 if (ret) 1589 return ret; 1590 1591 for_each_new_connector_in_state(state, connector, new_conn_state, i) { 1592 if (new_conn_state->crtc == set->crtc) { 1593 ret = drm_atomic_set_crtc_for_connector(new_conn_state, 1594 NULL); 1595 if (ret) 1596 return ret; 1597 1598 /* Make sure legacy setCrtc always re-trains */ 1599 new_conn_state->link_status = DRM_LINK_STATUS_GOOD; 1600 } 1601 } 1602 1603 /* Then set all connectors from set->connectors on the target crtc */ 1604 for (i = 0; i < set->num_connectors; i++) { 1605 new_conn_state = drm_atomic_get_connector_state(state, 1606 set->connectors[i]); 1607 if (IS_ERR(new_conn_state)) 1608 return PTR_ERR(new_conn_state); 1609 1610 ret = drm_atomic_set_crtc_for_connector(new_conn_state, 1611 set->crtc); 1612 if (ret) 1613 return ret; 1614 } 1615 1616 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { 1617 /* 1618 * Don't update ->enable for the CRTC in the set_config request, 1619 * since a mismatch would indicate a bug in the upper layers. 1620 * The actual modeset code later on will catch any 1621 * inconsistencies here. 1622 */ 1623 if (crtc == set->crtc) 1624 continue; 1625 1626 if (!new_crtc_state->connector_mask) { 1627 ret = drm_atomic_set_mode_prop_for_crtc(new_crtc_state, 1628 NULL); 1629 if (ret < 0) 1630 return ret; 1631 1632 new_crtc_state->active = false; 1633 } 1634 } 1635 1636 return 0; 1637} 1638 1639/* just used from drm-client and atomic-helper: */ 1640int __drm_atomic_helper_set_config(struct drm_mode_set *set, 1641 struct drm_atomic_state *state) 1642{ 1643 struct drm_crtc_state *crtc_state; 1644 struct drm_plane_state *primary_state; 1645 struct drm_crtc *crtc = set->crtc; 1646 int hdisplay, vdisplay; 1647 int ret; 1648 1649 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1650 if (IS_ERR(crtc_state)) 1651 return PTR_ERR(crtc_state); 1652 1653 primary_state = drm_atomic_get_plane_state(state, crtc->primary); 1654 if (IS_ERR(primary_state)) 1655 return PTR_ERR(primary_state); 1656 1657 if (!set->mode) { 1658 WARN_ON(set->fb); 1659 WARN_ON(set->num_connectors); 1660 1661 ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL); 1662 if (ret != 0) 1663 return ret; 1664 1665 crtc_state->active = false; 1666 1667 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL); 1668 if (ret != 0) 1669 return ret; 1670 1671 drm_atomic_set_fb_for_plane(primary_state, NULL); 1672 1673 goto commit; 1674 } 1675 1676 WARN_ON(!set->fb); 1677 WARN_ON(!set->num_connectors); 1678 1679 ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode); 1680 if (ret != 0) 1681 return ret; 1682 1683 crtc_state->active = true; 1684 1685 ret = drm_atomic_set_crtc_for_plane(primary_state, crtc); 1686 if (ret != 0) 1687 return ret; 1688 1689 drm_mode_get_hv_timing(set->mode, &hdisplay, &vdisplay); 1690 1691 drm_atomic_set_fb_for_plane(primary_state, set->fb); 1692 primary_state->crtc_x = 0; 1693 primary_state->crtc_y = 0; 1694 primary_state->crtc_w = hdisplay; 1695 primary_state->crtc_h = vdisplay; 1696 primary_state->src_x = set->x << 16; 1697 primary_state->src_y = set->y << 16; 1698 if (drm_rotation_90_or_270(primary_state->rotation)) { 1699 primary_state->src_w = vdisplay << 16; 1700 primary_state->src_h = hdisplay << 16; 1701 } else { 1702 primary_state->src_w = hdisplay << 16; 1703 primary_state->src_h = vdisplay << 16; 1704 } 1705 1706commit: 1707 ret = update_output_state(state, set); 1708 if (ret) 1709 return ret; 1710 1711 return 0; 1712} 1713EXPORT_SYMBOL(__drm_atomic_helper_set_config); 1714 1715static void drm_atomic_private_obj_print_state(struct drm_printer *p, 1716 const struct drm_private_state *state) 1717{ 1718 struct drm_private_obj *obj = state->obj; 1719 1720 if (obj->funcs->atomic_print_state) 1721 obj->funcs->atomic_print_state(p, state); 1722} 1723 1724/** 1725 * drm_atomic_print_new_state - prints drm atomic state 1726 * @state: atomic configuration to check 1727 * @p: drm printer 1728 * 1729 * This functions prints the drm atomic state snapshot using the drm printer 1730 * which is passed to it. This snapshot can be used for debugging purposes. 1731 * 1732 * Note that this function looks into the new state objects and hence its not 1733 * safe to be used after the call to drm_atomic_helper_commit_hw_done(). 1734 */ 1735void drm_atomic_print_new_state(const struct drm_atomic_state *state, 1736 struct drm_printer *p) 1737{ 1738 struct drm_plane *plane; 1739 struct drm_plane_state *plane_state; 1740 struct drm_crtc *crtc; 1741 struct drm_crtc_state *crtc_state; 1742 struct drm_connector *connector; 1743 struct drm_connector_state *connector_state; 1744 struct drm_private_obj *obj; 1745 struct drm_private_state *obj_state; 1746 int i; 1747 1748 if (!p) { 1749 drm_err(state->dev, "invalid drm printer\n"); 1750 return; 1751 } 1752 1753 drm_dbg_atomic(state->dev, "checking %p\n", state); 1754 1755 for_each_new_plane_in_state(state, plane, plane_state, i) 1756 drm_atomic_plane_print_state(p, plane_state); 1757 1758 for_each_new_crtc_in_state(state, crtc, crtc_state, i) 1759 drm_atomic_crtc_print_state(p, crtc_state); 1760 1761 for_each_new_connector_in_state(state, connector, connector_state, i) 1762 drm_atomic_connector_print_state(p, connector_state); 1763 1764 for_each_new_private_obj_in_state(state, obj, obj_state, i) 1765 drm_atomic_private_obj_print_state(p, obj_state); 1766} 1767EXPORT_SYMBOL(drm_atomic_print_new_state); 1768 1769static void __drm_state_dump(struct drm_device *dev, struct drm_printer *p, 1770 bool take_locks) 1771{ 1772 struct drm_mode_config *config = &dev->mode_config; 1773 struct drm_plane *plane; 1774 struct drm_crtc *crtc; 1775 struct drm_connector *connector; 1776 struct drm_connector_list_iter conn_iter; 1777 struct drm_private_obj *obj; 1778 1779 if (!drm_drv_uses_atomic_modeset(dev)) 1780 return; 1781 1782 list_for_each_entry(plane, &config->plane_list, head) { 1783 if (take_locks) 1784 drm_modeset_lock(&plane->mutex, NULL); 1785 drm_atomic_plane_print_state(p, plane->state); 1786 if (take_locks) 1787 drm_modeset_unlock(&plane->mutex); 1788 } 1789 1790 list_for_each_entry(crtc, &config->crtc_list, head) { 1791 if (take_locks) 1792 drm_modeset_lock(&crtc->mutex, NULL); 1793 drm_atomic_crtc_print_state(p, crtc->state); 1794 if (take_locks) 1795 drm_modeset_unlock(&crtc->mutex); 1796 } 1797 1798 drm_connector_list_iter_begin(dev, &conn_iter); 1799 if (take_locks) 1800 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 1801 drm_for_each_connector_iter(connector, &conn_iter) 1802 drm_atomic_connector_print_state(p, connector->state); 1803 if (take_locks) 1804 drm_modeset_unlock(&dev->mode_config.connection_mutex); 1805 drm_connector_list_iter_end(&conn_iter); 1806 1807 list_for_each_entry(obj, &config->privobj_list, head) { 1808 if (take_locks) 1809 drm_modeset_lock(&obj->lock, NULL); 1810 drm_atomic_private_obj_print_state(p, obj->state); 1811 if (take_locks) 1812 drm_modeset_unlock(&obj->lock); 1813 } 1814} 1815 1816/** 1817 * drm_state_dump - dump entire device atomic state 1818 * @dev: the drm device 1819 * @p: where to print the state to 1820 * 1821 * Just for debugging. Drivers might want an option to dump state 1822 * to dmesg in case of error irq's. (Hint, you probably want to 1823 * ratelimit this!) 1824 * 1825 * The caller must wrap this drm_modeset_lock_all_ctx() and 1826 * drm_modeset_drop_locks(). If this is called from error irq handler, it should 1827 * not be enabled by default - if you are debugging errors you might 1828 * not care that this is racey, but calling this without all modeset locks held 1829 * is inherently unsafe. 1830 */ 1831void drm_state_dump(struct drm_device *dev, struct drm_printer *p) 1832{ 1833 __drm_state_dump(dev, p, false); 1834} 1835EXPORT_SYMBOL(drm_state_dump); 1836 1837#ifdef CONFIG_DEBUG_FS 1838static int drm_state_info(struct seq_file *m, void *data) 1839{ 1840 struct drm_debugfs_entry *entry = m->private; 1841 struct drm_device *dev = entry->dev; 1842 struct drm_printer p = drm_seq_file_printer(m); 1843 1844 __drm_state_dump(dev, &p, true); 1845 1846 return 0; 1847} 1848 1849/* any use in debugfs files to dump individual planes/crtc/etc? */ 1850static const struct drm_debugfs_info drm_atomic_debugfs_list[] = { 1851 {"state", drm_state_info, 0}, 1852}; 1853 1854void drm_atomic_debugfs_init(struct drm_device *dev) 1855{ 1856 drm_debugfs_add_files(dev, drm_atomic_debugfs_list, 1857 ARRAY_SIZE(drm_atomic_debugfs_list)); 1858} 1859#endif 1860