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 49 void __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 } 56 EXPORT_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 */ 69 int 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 } 95 EXPORT_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 */ 106 void 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 } 113 EXPORT_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 */ 124 int 125 drm_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; 154 fail: 155 drm_atomic_state_default_release(state); 156 return -ENOMEM; 157 } 158 EXPORT_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 */ 166 struct drm_atomic_state * 167 drm_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 } 186 EXPORT_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 */ 196 void 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 } 270 EXPORT_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 */ 286 void 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 } 296 EXPORT_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 */ 305 void __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 } 324 EXPORT_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 */ 345 struct drm_crtc_state * 346 drm_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 } 377 EXPORT_SYMBOL(drm_atomic_get_crtc_state); 378 379 static 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 440 static 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 463 static 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 */ 526 struct drm_plane_state * 527 drm_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 } 572 EXPORT_SYMBOL(drm_atomic_get_plane_state); 573 574 static bool 575 plane_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 */ 602 static 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 716 static 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 737 if (plane->funcs->atomic_print_state) 738 plane->funcs->atomic_print_state(p, state); 739 } 740 741 /** 742 * DOC: handling driver private state 743 * 744 * Very often the DRM objects exposed to userspace in the atomic modeset api 745 * (&drm_connector, &drm_crtc and &drm_plane) do not map neatly to the 746 * underlying hardware. Especially for any kind of shared resources (e.g. shared 747 * clocks, scaler units, bandwidth and fifo limits shared among a group of 748 * planes or CRTCs, and so on) it makes sense to model these as independent 749 * objects. Drivers then need to do similar state tracking and commit ordering for 750 * such private (since not exposed to userspace) objects as the atomic core and 751 * helpers already provide for connectors, planes and CRTCs. 752 * 753 * To make this easier on drivers the atomic core provides some support to track 754 * driver private state objects using struct &drm_private_obj, with the 755 * associated state struct &drm_private_state. 756 * 757 * Similar to userspace-exposed objects, private state structures can be 758 * acquired by calling drm_atomic_get_private_obj_state(). This also takes care 759 * of locking, hence drivers should not have a need to call drm_modeset_lock() 760 * directly. Sequence of the actual hardware state commit is not handled, 761 * drivers might need to keep track of struct drm_crtc_commit within subclassed 762 * structure of &drm_private_state as necessary, e.g. similar to 763 * &drm_plane_state.commit. See also &drm_atomic_state.fake_commit. 764 * 765 * All private state structures contained in a &drm_atomic_state update can be 766 * iterated using for_each_oldnew_private_obj_in_state(), 767 * for_each_new_private_obj_in_state() and for_each_old_private_obj_in_state(). 768 * Drivers are recommended to wrap these for each type of driver private state 769 * object they have, filtering on &drm_private_obj.funcs using for_each_if(), at 770 * least if they want to iterate over all objects of a given type. 771 * 772 * An earlier way to handle driver private state was by subclassing struct 773 * &drm_atomic_state. But since that encourages non-standard ways to implement 774 * the check/commit split atomic requires (by using e.g. "check and rollback or 775 * commit instead" of "duplicate state, check, then either commit or release 776 * duplicated state) it is deprecated in favour of using &drm_private_state. 777 */ 778 779 /** 780 * drm_atomic_private_obj_init - initialize private object 781 * @dev: DRM device this object will be attached to 782 * @obj: private object 783 * @state: initial private object state 784 * @funcs: pointer to the struct of function pointers that identify the object 785 * type 786 * 787 * Initialize the private object, which can be embedded into any 788 * driver private object that needs its own atomic state. 789 */ 790 void 791 drm_atomic_private_obj_init(struct drm_device *dev, 792 struct drm_private_obj *obj, 793 struct drm_private_state *state, 794 const struct drm_private_state_funcs *funcs) 795 { 796 memset(obj, 0, sizeof(*obj)); 797 798 drm_modeset_lock_init(&obj->lock); 799 800 obj->state = state; 801 obj->funcs = funcs; 802 list_add_tail(&obj->head, &dev->mode_config.privobj_list); 803 804 state->obj = obj; 805 } 806 EXPORT_SYMBOL(drm_atomic_private_obj_init); 807 808 /** 809 * drm_atomic_private_obj_fini - finalize private object 810 * @obj: private object 811 * 812 * Finalize the private object. 813 */ 814 void 815 drm_atomic_private_obj_fini(struct drm_private_obj *obj) 816 { 817 list_del(&obj->head); 818 obj->funcs->atomic_destroy_state(obj, obj->state); 819 drm_modeset_lock_fini(&obj->lock); 820 } 821 EXPORT_SYMBOL(drm_atomic_private_obj_fini); 822 823 /** 824 * drm_atomic_get_private_obj_state - get private object state 825 * @state: global atomic state 826 * @obj: private object to get the state for 827 * 828 * This function returns the private object state for the given private object, 829 * allocating the state if needed. It will also grab the relevant private 830 * object lock to make sure that the state is consistent. 831 * 832 * RETURNS: 833 * 834 * Either the allocated state or the error code encoded into a pointer. 835 */ 836 struct drm_private_state * 837 drm_atomic_get_private_obj_state(struct drm_atomic_state *state, 838 struct drm_private_obj *obj) 839 { 840 int index, num_objs, i, ret; 841 size_t size; 842 struct __drm_private_objs_state *arr; 843 struct drm_private_state *obj_state; 844 845 for (i = 0; i < state->num_private_objs; i++) 846 if (obj == state->private_objs[i].ptr) 847 return state->private_objs[i].state; 848 849 ret = drm_modeset_lock(&obj->lock, state->acquire_ctx); 850 if (ret) 851 return ERR_PTR(ret); 852 853 num_objs = state->num_private_objs + 1; 854 size = sizeof(*state->private_objs) * num_objs; 855 arr = krealloc(state->private_objs, size, GFP_KERNEL); 856 if (!arr) 857 return ERR_PTR(-ENOMEM); 858 859 state->private_objs = arr; 860 index = state->num_private_objs; 861 memset(&state->private_objs[index], 0, sizeof(*state->private_objs)); 862 863 obj_state = obj->funcs->atomic_duplicate_state(obj); 864 if (!obj_state) 865 return ERR_PTR(-ENOMEM); 866 867 state->private_objs[index].state = obj_state; 868 state->private_objs[index].old_state = obj->state; 869 state->private_objs[index].new_state = obj_state; 870 state->private_objs[index].ptr = obj; 871 obj_state->state = state; 872 873 state->num_private_objs = num_objs; 874 875 drm_dbg_atomic(state->dev, 876 "Added new private object %p state %p to %p\n", 877 obj, obj_state, state); 878 879 return obj_state; 880 } 881 EXPORT_SYMBOL(drm_atomic_get_private_obj_state); 882 883 /** 884 * drm_atomic_get_old_private_obj_state 885 * @state: global atomic state object 886 * @obj: private_obj to grab 887 * 888 * This function returns the old private object state for the given private_obj, 889 * or NULL if the private_obj is not part of the global atomic state. 890 */ 891 struct drm_private_state * 892 drm_atomic_get_old_private_obj_state(const struct drm_atomic_state *state, 893 struct drm_private_obj *obj) 894 { 895 int i; 896 897 for (i = 0; i < state->num_private_objs; i++) 898 if (obj == state->private_objs[i].ptr) 899 return state->private_objs[i].old_state; 900 901 return NULL; 902 } 903 EXPORT_SYMBOL(drm_atomic_get_old_private_obj_state); 904 905 /** 906 * drm_atomic_get_new_private_obj_state 907 * @state: global atomic state object 908 * @obj: private_obj to grab 909 * 910 * This function returns the new private object state for the given private_obj, 911 * or NULL if the private_obj is not part of the global atomic state. 912 */ 913 struct drm_private_state * 914 drm_atomic_get_new_private_obj_state(const struct drm_atomic_state *state, 915 struct drm_private_obj *obj) 916 { 917 int i; 918 919 for (i = 0; i < state->num_private_objs; i++) 920 if (obj == state->private_objs[i].ptr) 921 return state->private_objs[i].new_state; 922 923 return NULL; 924 } 925 EXPORT_SYMBOL(drm_atomic_get_new_private_obj_state); 926 927 /** 928 * drm_atomic_get_old_connector_for_encoder - Get old connector for an encoder 929 * @state: Atomic state 930 * @encoder: The encoder to fetch the connector state for 931 * 932 * This function finds and returns the connector that was connected to @encoder 933 * as specified by the @state. 934 * 935 * If there is no connector in @state which previously had @encoder connected to 936 * it, this function will return NULL. While this may seem like an invalid use 937 * case, it is sometimes useful to differentiate commits which had no prior 938 * connectors attached to @encoder vs ones that did (and to inspect their 939 * state). This is especially true in enable hooks because the pipeline has 940 * changed. 941 * 942 * Returns: The old connector connected to @encoder, or NULL if the encoder is 943 * not connected. 944 */ 945 struct drm_connector * 946 drm_atomic_get_old_connector_for_encoder(const struct drm_atomic_state *state, 947 struct drm_encoder *encoder) 948 { 949 struct drm_connector_state *conn_state; 950 struct drm_connector *connector; 951 unsigned int i; 952 953 for_each_old_connector_in_state(state, connector, conn_state, i) { 954 if (conn_state->best_encoder == encoder) 955 return connector; 956 } 957 958 return NULL; 959 } 960 EXPORT_SYMBOL(drm_atomic_get_old_connector_for_encoder); 961 962 /** 963 * drm_atomic_get_new_connector_for_encoder - Get new connector for an encoder 964 * @state: Atomic state 965 * @encoder: The encoder to fetch the connector state for 966 * 967 * This function finds and returns the connector that will be connected to 968 * @encoder as specified by the @state. 969 * 970 * If there is no connector in @state which will have @encoder connected to it, 971 * this function will return NULL. While this may seem like an invalid use case, 972 * it is sometimes useful to differentiate commits which have no connectors 973 * attached to @encoder vs ones that do (and to inspect their state). This is 974 * especially true in disable hooks because the pipeline will change. 975 * 976 * Returns: The new connector connected to @encoder, or NULL if the encoder is 977 * not connected. 978 */ 979 struct drm_connector * 980 drm_atomic_get_new_connector_for_encoder(const struct drm_atomic_state *state, 981 struct drm_encoder *encoder) 982 { 983 struct drm_connector_state *conn_state; 984 struct drm_connector *connector; 985 unsigned int i; 986 987 for_each_new_connector_in_state(state, connector, conn_state, i) { 988 if (conn_state->best_encoder == encoder) 989 return connector; 990 } 991 992 return NULL; 993 } 994 EXPORT_SYMBOL(drm_atomic_get_new_connector_for_encoder); 995 996 /** 997 * drm_atomic_get_old_crtc_for_encoder - Get old crtc for an encoder 998 * @state: Atomic state 999 * @encoder: The encoder to fetch the crtc state for 1000 * 1001 * This function finds and returns the crtc that was connected to @encoder 1002 * as specified by the @state. 1003 * 1004 * Returns: The old crtc connected to @encoder, or NULL if the encoder is 1005 * not connected. 1006 */ 1007 struct drm_crtc * 1008 drm_atomic_get_old_crtc_for_encoder(struct drm_atomic_state *state, 1009 struct drm_encoder *encoder) 1010 { 1011 struct drm_connector *connector; 1012 struct drm_connector_state *conn_state; 1013 1014 connector = drm_atomic_get_old_connector_for_encoder(state, encoder); 1015 if (!connector) 1016 return NULL; 1017 1018 conn_state = drm_atomic_get_old_connector_state(state, connector); 1019 if (!conn_state) 1020 return NULL; 1021 1022 return conn_state->crtc; 1023 } 1024 EXPORT_SYMBOL(drm_atomic_get_old_crtc_for_encoder); 1025 1026 /** 1027 * drm_atomic_get_new_crtc_for_encoder - Get new crtc for an encoder 1028 * @state: Atomic state 1029 * @encoder: The encoder to fetch the crtc state for 1030 * 1031 * This function finds and returns the crtc that will be connected to @encoder 1032 * as specified by the @state. 1033 * 1034 * Returns: The new crtc connected to @encoder, or NULL if the encoder is 1035 * not connected. 1036 */ 1037 struct drm_crtc * 1038 drm_atomic_get_new_crtc_for_encoder(struct drm_atomic_state *state, 1039 struct drm_encoder *encoder) 1040 { 1041 struct drm_connector *connector; 1042 struct drm_connector_state *conn_state; 1043 1044 connector = drm_atomic_get_new_connector_for_encoder(state, encoder); 1045 if (!connector) 1046 return NULL; 1047 1048 conn_state = drm_atomic_get_new_connector_state(state, connector); 1049 if (!conn_state) 1050 return NULL; 1051 1052 return conn_state->crtc; 1053 } 1054 EXPORT_SYMBOL(drm_atomic_get_new_crtc_for_encoder); 1055 1056 /** 1057 * drm_atomic_get_connector_state - get connector state 1058 * @state: global atomic state object 1059 * @connector: connector to get state object for 1060 * 1061 * This function returns the connector state for the given connector, 1062 * allocating it if needed. It will also grab the relevant connector lock to 1063 * make sure that the state is consistent. 1064 * 1065 * Returns: 1066 * 1067 * Either the allocated state or the error code encoded into the pointer. When 1068 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the 1069 * entire atomic sequence must be restarted. All other errors are fatal. 1070 */ 1071 struct drm_connector_state * 1072 drm_atomic_get_connector_state(struct drm_atomic_state *state, 1073 struct drm_connector *connector) 1074 { 1075 int ret, index; 1076 struct drm_mode_config *config = &connector->dev->mode_config; 1077 struct drm_connector_state *connector_state; 1078 1079 WARN_ON(!state->acquire_ctx); 1080 1081 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx); 1082 if (ret) 1083 return ERR_PTR(ret); 1084 1085 index = drm_connector_index(connector); 1086 1087 if (index >= state->num_connector) { 1088 struct __drm_connnectors_state *c; 1089 int alloc = max(index + 1, config->num_connector); 1090 1091 c = krealloc_array(state->connectors, alloc, 1092 sizeof(*state->connectors), GFP_KERNEL); 1093 if (!c) 1094 return ERR_PTR(-ENOMEM); 1095 1096 state->connectors = c; 1097 memset(&state->connectors[state->num_connector], 0, 1098 sizeof(*state->connectors) * (alloc - state->num_connector)); 1099 1100 state->num_connector = alloc; 1101 } 1102 1103 if (state->connectors[index].state) 1104 return state->connectors[index].state; 1105 1106 connector_state = connector->funcs->atomic_duplicate_state(connector); 1107 if (!connector_state) 1108 return ERR_PTR(-ENOMEM); 1109 1110 drm_connector_get(connector); 1111 state->connectors[index].state = connector_state; 1112 state->connectors[index].old_state = connector->state; 1113 state->connectors[index].new_state = connector_state; 1114 state->connectors[index].ptr = connector; 1115 connector_state->state = state; 1116 1117 drm_dbg_atomic(connector->dev, "Added [CONNECTOR:%d:%s] %p state to %p\n", 1118 connector->base.id, connector->name, 1119 connector_state, state); 1120 1121 if (connector_state->crtc) { 1122 struct drm_crtc_state *crtc_state; 1123 1124 crtc_state = drm_atomic_get_crtc_state(state, 1125 connector_state->crtc); 1126 if (IS_ERR(crtc_state)) 1127 return ERR_CAST(crtc_state); 1128 } 1129 1130 return connector_state; 1131 } 1132 EXPORT_SYMBOL(drm_atomic_get_connector_state); 1133 1134 static void drm_atomic_connector_print_state(struct drm_printer *p, 1135 const struct drm_connector_state *state) 1136 { 1137 struct drm_connector *connector = state->connector; 1138 1139 drm_printf(p, "connector[%u]: %s\n", connector->base.id, connector->name); 1140 drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)"); 1141 drm_printf(p, "\tself_refresh_aware=%d\n", state->self_refresh_aware); 1142 drm_printf(p, "\tmax_requested_bpc=%d\n", state->max_requested_bpc); 1143 drm_printf(p, "\tcolorspace=%s\n", drm_get_colorspace_name(state->colorspace)); 1144 1145 if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK) 1146 if (state->writeback_job && state->writeback_job->fb) 1147 drm_printf(p, "\tfb=%d\n", state->writeback_job->fb->base.id); 1148 1149 if (connector->funcs->atomic_print_state) 1150 connector->funcs->atomic_print_state(p, state); 1151 } 1152 1153 /** 1154 * drm_atomic_get_bridge_state - get bridge state 1155 * @state: global atomic state object 1156 * @bridge: bridge to get state object for 1157 * 1158 * This function returns the bridge state for the given bridge, allocating it 1159 * if needed. It will also grab the relevant bridge lock to make sure that the 1160 * state is consistent. 1161 * 1162 * Returns: 1163 * 1164 * Either the allocated state or the error code encoded into the pointer. When 1165 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the 1166 * entire atomic sequence must be restarted. 1167 */ 1168 struct drm_bridge_state * 1169 drm_atomic_get_bridge_state(struct drm_atomic_state *state, 1170 struct drm_bridge *bridge) 1171 { 1172 struct drm_private_state *obj_state; 1173 1174 obj_state = drm_atomic_get_private_obj_state(state, &bridge->base); 1175 if (IS_ERR(obj_state)) 1176 return ERR_CAST(obj_state); 1177 1178 return drm_priv_to_bridge_state(obj_state); 1179 } 1180 EXPORT_SYMBOL(drm_atomic_get_bridge_state); 1181 1182 /** 1183 * drm_atomic_get_old_bridge_state - get old bridge state, if it exists 1184 * @state: global atomic state object 1185 * @bridge: bridge to grab 1186 * 1187 * This function returns the old bridge state for the given bridge, or NULL if 1188 * the bridge is not part of the global atomic state. 1189 */ 1190 struct drm_bridge_state * 1191 drm_atomic_get_old_bridge_state(const struct drm_atomic_state *state, 1192 struct drm_bridge *bridge) 1193 { 1194 struct drm_private_state *obj_state; 1195 1196 obj_state = drm_atomic_get_old_private_obj_state(state, &bridge->base); 1197 if (!obj_state) 1198 return NULL; 1199 1200 return drm_priv_to_bridge_state(obj_state); 1201 } 1202 EXPORT_SYMBOL(drm_atomic_get_old_bridge_state); 1203 1204 /** 1205 * drm_atomic_get_new_bridge_state - get new bridge state, if it exists 1206 * @state: global atomic state object 1207 * @bridge: bridge to grab 1208 * 1209 * This function returns the new bridge state for the given bridge, or NULL if 1210 * the bridge is not part of the global atomic state. 1211 */ 1212 struct drm_bridge_state * 1213 drm_atomic_get_new_bridge_state(const struct drm_atomic_state *state, 1214 struct drm_bridge *bridge) 1215 { 1216 struct drm_private_state *obj_state; 1217 1218 obj_state = drm_atomic_get_new_private_obj_state(state, &bridge->base); 1219 if (!obj_state) 1220 return NULL; 1221 1222 return drm_priv_to_bridge_state(obj_state); 1223 } 1224 EXPORT_SYMBOL(drm_atomic_get_new_bridge_state); 1225 1226 /** 1227 * drm_atomic_add_encoder_bridges - add bridges attached to an encoder 1228 * @state: atomic state 1229 * @encoder: DRM encoder 1230 * 1231 * This function adds all bridges attached to @encoder. This is needed to add 1232 * bridge states to @state and make them available when 1233 * &drm_bridge_funcs.atomic_check(), &drm_bridge_funcs.atomic_pre_enable(), 1234 * &drm_bridge_funcs.atomic_enable(), 1235 * &drm_bridge_funcs.atomic_disable_post_disable() are called. 1236 * 1237 * Returns: 1238 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK 1239 * then the w/w mutex code has detected a deadlock and the entire atomic 1240 * sequence must be restarted. All other errors are fatal. 1241 */ 1242 int 1243 drm_atomic_add_encoder_bridges(struct drm_atomic_state *state, 1244 struct drm_encoder *encoder) 1245 { 1246 struct drm_bridge_state *bridge_state; 1247 struct drm_bridge *bridge; 1248 1249 if (!encoder) 1250 return 0; 1251 1252 drm_dbg_atomic(encoder->dev, 1253 "Adding all bridges for [encoder:%d:%s] to %p\n", 1254 encoder->base.id, encoder->name, state); 1255 1256 drm_for_each_bridge_in_chain(encoder, bridge) { 1257 /* Skip bridges that don't implement the atomic state hooks. */ 1258 if (!bridge->funcs->atomic_duplicate_state) 1259 continue; 1260 1261 bridge_state = drm_atomic_get_bridge_state(state, bridge); 1262 if (IS_ERR(bridge_state)) 1263 return PTR_ERR(bridge_state); 1264 } 1265 1266 return 0; 1267 } 1268 EXPORT_SYMBOL(drm_atomic_add_encoder_bridges); 1269 1270 /** 1271 * drm_atomic_add_affected_connectors - add connectors for CRTC 1272 * @state: atomic state 1273 * @crtc: DRM CRTC 1274 * 1275 * This function walks the current configuration and adds all connectors 1276 * currently using @crtc to the atomic configuration @state. Note that this 1277 * function must acquire the connection mutex. This can potentially cause 1278 * unneeded serialization if the update is just for the planes on one CRTC. Hence 1279 * drivers and helpers should only call this when really needed (e.g. when a 1280 * full modeset needs to happen due to some change). 1281 * 1282 * Returns: 1283 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK 1284 * then the w/w mutex code has detected a deadlock and the entire atomic 1285 * sequence must be restarted. All other errors are fatal. 1286 */ 1287 int 1288 drm_atomic_add_affected_connectors(struct drm_atomic_state *state, 1289 struct drm_crtc *crtc) 1290 { 1291 struct drm_mode_config *config = &state->dev->mode_config; 1292 struct drm_connector *connector; 1293 struct drm_connector_state *conn_state; 1294 struct drm_connector_list_iter conn_iter; 1295 struct drm_crtc_state *crtc_state; 1296 int ret; 1297 1298 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1299 if (IS_ERR(crtc_state)) 1300 return PTR_ERR(crtc_state); 1301 1302 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx); 1303 if (ret) 1304 return ret; 1305 1306 drm_dbg_atomic(crtc->dev, 1307 "Adding all current connectors for [CRTC:%d:%s] to %p\n", 1308 crtc->base.id, crtc->name, state); 1309 1310 /* 1311 * Changed connectors are already in @state, so only need to look 1312 * at the connector_mask in crtc_state. 1313 */ 1314 drm_connector_list_iter_begin(state->dev, &conn_iter); 1315 drm_for_each_connector_iter(connector, &conn_iter) { 1316 if (!(crtc_state->connector_mask & drm_connector_mask(connector))) 1317 continue; 1318 1319 conn_state = drm_atomic_get_connector_state(state, connector); 1320 if (IS_ERR(conn_state)) { 1321 drm_connector_list_iter_end(&conn_iter); 1322 return PTR_ERR(conn_state); 1323 } 1324 } 1325 drm_connector_list_iter_end(&conn_iter); 1326 1327 return 0; 1328 } 1329 EXPORT_SYMBOL(drm_atomic_add_affected_connectors); 1330 1331 /** 1332 * drm_atomic_add_affected_planes - add planes for CRTC 1333 * @state: atomic state 1334 * @crtc: DRM CRTC 1335 * 1336 * This function walks the current configuration and adds all planes 1337 * currently used by @crtc to the atomic configuration @state. This is useful 1338 * when an atomic commit also needs to check all currently enabled plane on 1339 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC 1340 * to avoid special code to force-enable all planes. 1341 * 1342 * Since acquiring a plane state will always also acquire the w/w mutex of the 1343 * current CRTC for that plane (if there is any) adding all the plane states for 1344 * a CRTC will not reduce parallelism of atomic updates. 1345 * 1346 * Returns: 1347 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK 1348 * then the w/w mutex code has detected a deadlock and the entire atomic 1349 * sequence must be restarted. All other errors are fatal. 1350 */ 1351 int 1352 drm_atomic_add_affected_planes(struct drm_atomic_state *state, 1353 struct drm_crtc *crtc) 1354 { 1355 const struct drm_crtc_state *old_crtc_state = 1356 drm_atomic_get_old_crtc_state(state, crtc); 1357 struct drm_plane *plane; 1358 1359 WARN_ON(!drm_atomic_get_new_crtc_state(state, crtc)); 1360 1361 drm_dbg_atomic(crtc->dev, 1362 "Adding all current planes for [CRTC:%d:%s] to %p\n", 1363 crtc->base.id, crtc->name, state); 1364 1365 drm_for_each_plane_mask(plane, state->dev, old_crtc_state->plane_mask) { 1366 struct drm_plane_state *plane_state = 1367 drm_atomic_get_plane_state(state, plane); 1368 1369 if (IS_ERR(plane_state)) 1370 return PTR_ERR(plane_state); 1371 } 1372 return 0; 1373 } 1374 EXPORT_SYMBOL(drm_atomic_add_affected_planes); 1375 1376 /** 1377 * drm_atomic_check_only - check whether a given config would work 1378 * @state: atomic configuration to check 1379 * 1380 * Note that this function can return -EDEADLK if the driver needed to acquire 1381 * more locks but encountered a deadlock. The caller must then do the usual w/w 1382 * backoff dance and restart. All other errors are fatal. 1383 * 1384 * Returns: 1385 * 0 on success, negative error code on failure. 1386 */ 1387 int drm_atomic_check_only(struct drm_atomic_state *state) 1388 { 1389 struct drm_device *dev = state->dev; 1390 struct drm_mode_config *config = &dev->mode_config; 1391 struct drm_plane *plane; 1392 struct drm_plane_state *old_plane_state; 1393 struct drm_plane_state *new_plane_state; 1394 struct drm_crtc *crtc; 1395 struct drm_crtc_state *old_crtc_state; 1396 struct drm_crtc_state *new_crtc_state; 1397 struct drm_connector *conn; 1398 struct drm_connector_state *conn_state; 1399 unsigned int requested_crtc = 0; 1400 unsigned int affected_crtc = 0; 1401 int i, ret = 0; 1402 1403 drm_dbg_atomic(dev, "checking %p\n", state); 1404 1405 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { 1406 if (new_crtc_state->enable) 1407 requested_crtc |= drm_crtc_mask(crtc); 1408 } 1409 1410 for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) { 1411 ret = drm_atomic_plane_check(old_plane_state, new_plane_state); 1412 if (ret) { 1413 drm_dbg_atomic(dev, "[PLANE:%d:%s] atomic core check failed\n", 1414 plane->base.id, plane->name); 1415 return ret; 1416 } 1417 } 1418 1419 for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) { 1420 ret = drm_atomic_crtc_check(old_crtc_state, new_crtc_state); 1421 if (ret) { 1422 drm_dbg_atomic(dev, "[CRTC:%d:%s] atomic core check failed\n", 1423 crtc->base.id, crtc->name); 1424 return ret; 1425 } 1426 } 1427 1428 for_each_new_connector_in_state(state, conn, conn_state, i) { 1429 ret = drm_atomic_connector_check(conn, conn_state); 1430 if (ret) { 1431 drm_dbg_atomic(dev, "[CONNECTOR:%d:%s] atomic core check failed\n", 1432 conn->base.id, conn->name); 1433 return ret; 1434 } 1435 } 1436 1437 if (config->funcs->atomic_check) { 1438 ret = config->funcs->atomic_check(state->dev, state); 1439 1440 if (ret) { 1441 drm_dbg_atomic(dev, "atomic driver check for %p failed: %d\n", 1442 state, ret); 1443 return ret; 1444 } 1445 } 1446 1447 if (!state->allow_modeset) { 1448 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { 1449 if (drm_atomic_crtc_needs_modeset(new_crtc_state)) { 1450 drm_dbg_atomic(dev, "[CRTC:%d:%s] requires full modeset\n", 1451 crtc->base.id, crtc->name); 1452 return -EINVAL; 1453 } 1454 } 1455 } 1456 1457 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { 1458 if (new_crtc_state->enable) 1459 affected_crtc |= drm_crtc_mask(crtc); 1460 } 1461 1462 /* 1463 * For commits that allow modesets drivers can add other CRTCs to the 1464 * atomic commit, e.g. when they need to reallocate global resources. 1465 * This can cause spurious EBUSY, which robs compositors of a very 1466 * effective sanity check for their drawing loop. Therefor only allow 1467 * drivers to add unrelated CRTC states for modeset commits. 1468 * 1469 * FIXME: Should add affected_crtc mask to the ATOMIC IOCTL as an output 1470 * so compositors know what's going on. 1471 */ 1472 if (affected_crtc != requested_crtc) { 1473 drm_dbg_atomic(dev, 1474 "driver added CRTC to commit: requested 0x%x, affected 0x%0x\n", 1475 requested_crtc, affected_crtc); 1476 WARN(!state->allow_modeset, "adding CRTC not allowed without modesets: requested 0x%x, affected 0x%0x\n", 1477 requested_crtc, affected_crtc); 1478 } 1479 1480 return 0; 1481 } 1482 EXPORT_SYMBOL(drm_atomic_check_only); 1483 1484 /** 1485 * drm_atomic_commit - commit configuration atomically 1486 * @state: atomic configuration to check 1487 * 1488 * Note that this function can return -EDEADLK if the driver needed to acquire 1489 * more locks but encountered a deadlock. The caller must then do the usual w/w 1490 * backoff dance and restart. All other errors are fatal. 1491 * 1492 * This function will take its own reference on @state. 1493 * Callers should always release their reference with drm_atomic_state_put(). 1494 * 1495 * Returns: 1496 * 0 on success, negative error code on failure. 1497 */ 1498 int drm_atomic_commit(struct drm_atomic_state *state) 1499 { 1500 struct drm_mode_config *config = &state->dev->mode_config; 1501 struct drm_printer p = drm_info_printer(state->dev->dev); 1502 int ret; 1503 1504 if (drm_debug_enabled(DRM_UT_STATE)) 1505 drm_atomic_print_new_state(state, &p); 1506 1507 ret = drm_atomic_check_only(state); 1508 if (ret) 1509 return ret; 1510 1511 drm_dbg_atomic(state->dev, "committing %p\n", state); 1512 1513 return config->funcs->atomic_commit(state->dev, state, false); 1514 } 1515 EXPORT_SYMBOL(drm_atomic_commit); 1516 1517 /** 1518 * drm_atomic_nonblocking_commit - atomic nonblocking commit 1519 * @state: atomic configuration to check 1520 * 1521 * Note that this function can return -EDEADLK if the driver needed to acquire 1522 * more locks but encountered a deadlock. The caller must then do the usual w/w 1523 * backoff dance and restart. All other errors are fatal. 1524 * 1525 * This function will take its own reference on @state. 1526 * Callers should always release their reference with drm_atomic_state_put(). 1527 * 1528 * Returns: 1529 * 0 on success, negative error code on failure. 1530 */ 1531 int drm_atomic_nonblocking_commit(struct drm_atomic_state *state) 1532 { 1533 struct drm_mode_config *config = &state->dev->mode_config; 1534 int ret; 1535 1536 ret = drm_atomic_check_only(state); 1537 if (ret) 1538 return ret; 1539 1540 drm_dbg_atomic(state->dev, "committing %p nonblocking\n", state); 1541 1542 return config->funcs->atomic_commit(state->dev, state, true); 1543 } 1544 EXPORT_SYMBOL(drm_atomic_nonblocking_commit); 1545 1546 /* just used from drm-client and atomic-helper: */ 1547 int __drm_atomic_helper_disable_plane(struct drm_plane *plane, 1548 struct drm_plane_state *plane_state) 1549 { 1550 int ret; 1551 1552 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL); 1553 if (ret != 0) 1554 return ret; 1555 1556 drm_atomic_set_fb_for_plane(plane_state, NULL); 1557 plane_state->crtc_x = 0; 1558 plane_state->crtc_y = 0; 1559 plane_state->crtc_w = 0; 1560 plane_state->crtc_h = 0; 1561 plane_state->src_x = 0; 1562 plane_state->src_y = 0; 1563 plane_state->src_w = 0; 1564 plane_state->src_h = 0; 1565 1566 return 0; 1567 } 1568 EXPORT_SYMBOL(__drm_atomic_helper_disable_plane); 1569 1570 static int update_output_state(struct drm_atomic_state *state, 1571 struct drm_mode_set *set) 1572 { 1573 struct drm_device *dev = set->crtc->dev; 1574 struct drm_crtc *crtc; 1575 struct drm_crtc_state *new_crtc_state; 1576 struct drm_connector *connector; 1577 struct drm_connector_state *new_conn_state; 1578 int ret, i; 1579 1580 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, 1581 state->acquire_ctx); 1582 if (ret) 1583 return ret; 1584 1585 /* First disable all connectors on the target crtc. */ 1586 ret = drm_atomic_add_affected_connectors(state, set->crtc); 1587 if (ret) 1588 return ret; 1589 1590 for_each_new_connector_in_state(state, connector, new_conn_state, i) { 1591 if (new_conn_state->crtc == set->crtc) { 1592 ret = drm_atomic_set_crtc_for_connector(new_conn_state, 1593 NULL); 1594 if (ret) 1595 return ret; 1596 1597 /* Make sure legacy setCrtc always re-trains */ 1598 new_conn_state->link_status = DRM_LINK_STATUS_GOOD; 1599 } 1600 } 1601 1602 /* Then set all connectors from set->connectors on the target crtc */ 1603 for (i = 0; i < set->num_connectors; i++) { 1604 new_conn_state = drm_atomic_get_connector_state(state, 1605 set->connectors[i]); 1606 if (IS_ERR(new_conn_state)) 1607 return PTR_ERR(new_conn_state); 1608 1609 ret = drm_atomic_set_crtc_for_connector(new_conn_state, 1610 set->crtc); 1611 if (ret) 1612 return ret; 1613 } 1614 1615 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { 1616 /* 1617 * Don't update ->enable for the CRTC in the set_config request, 1618 * since a mismatch would indicate a bug in the upper layers. 1619 * The actual modeset code later on will catch any 1620 * inconsistencies here. 1621 */ 1622 if (crtc == set->crtc) 1623 continue; 1624 1625 if (!new_crtc_state->connector_mask) { 1626 ret = drm_atomic_set_mode_prop_for_crtc(new_crtc_state, 1627 NULL); 1628 if (ret < 0) 1629 return ret; 1630 1631 new_crtc_state->active = false; 1632 } 1633 } 1634 1635 return 0; 1636 } 1637 1638 /* just used from drm-client and atomic-helper: */ 1639 int __drm_atomic_helper_set_config(struct drm_mode_set *set, 1640 struct drm_atomic_state *state) 1641 { 1642 struct drm_crtc_state *crtc_state; 1643 struct drm_plane_state *primary_state; 1644 struct drm_crtc *crtc = set->crtc; 1645 int hdisplay, vdisplay; 1646 int ret; 1647 1648 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1649 if (IS_ERR(crtc_state)) 1650 return PTR_ERR(crtc_state); 1651 1652 primary_state = drm_atomic_get_plane_state(state, crtc->primary); 1653 if (IS_ERR(primary_state)) 1654 return PTR_ERR(primary_state); 1655 1656 if (!set->mode) { 1657 WARN_ON(set->fb); 1658 WARN_ON(set->num_connectors); 1659 1660 ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL); 1661 if (ret != 0) 1662 return ret; 1663 1664 crtc_state->active = false; 1665 1666 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL); 1667 if (ret != 0) 1668 return ret; 1669 1670 drm_atomic_set_fb_for_plane(primary_state, NULL); 1671 1672 goto commit; 1673 } 1674 1675 WARN_ON(!set->fb); 1676 WARN_ON(!set->num_connectors); 1677 1678 ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode); 1679 if (ret != 0) 1680 return ret; 1681 1682 crtc_state->active = true; 1683 1684 ret = drm_atomic_set_crtc_for_plane(primary_state, crtc); 1685 if (ret != 0) 1686 return ret; 1687 1688 drm_mode_get_hv_timing(set->mode, &hdisplay, &vdisplay); 1689 1690 drm_atomic_set_fb_for_plane(primary_state, set->fb); 1691 primary_state->crtc_x = 0; 1692 primary_state->crtc_y = 0; 1693 primary_state->crtc_w = hdisplay; 1694 primary_state->crtc_h = vdisplay; 1695 primary_state->src_x = set->x << 16; 1696 primary_state->src_y = set->y << 16; 1697 if (drm_rotation_90_or_270(primary_state->rotation)) { 1698 primary_state->src_w = vdisplay << 16; 1699 primary_state->src_h = hdisplay << 16; 1700 } else { 1701 primary_state->src_w = hdisplay << 16; 1702 primary_state->src_h = vdisplay << 16; 1703 } 1704 1705 commit: 1706 ret = update_output_state(state, set); 1707 if (ret) 1708 return ret; 1709 1710 return 0; 1711 } 1712 EXPORT_SYMBOL(__drm_atomic_helper_set_config); 1713 1714 static void drm_atomic_private_obj_print_state(struct drm_printer *p, 1715 const struct drm_private_state *state) 1716 { 1717 struct drm_private_obj *obj = state->obj; 1718 1719 if (obj->funcs->atomic_print_state) 1720 obj->funcs->atomic_print_state(p, state); 1721 } 1722 1723 /** 1724 * drm_atomic_print_new_state - prints drm atomic state 1725 * @state: atomic configuration to check 1726 * @p: drm printer 1727 * 1728 * This functions prints the drm atomic state snapshot using the drm printer 1729 * which is passed to it. This snapshot can be used for debugging purposes. 1730 * 1731 * Note that this function looks into the new state objects and hence its not 1732 * safe to be used after the call to drm_atomic_helper_commit_hw_done(). 1733 */ 1734 void drm_atomic_print_new_state(const struct drm_atomic_state *state, 1735 struct drm_printer *p) 1736 { 1737 struct drm_plane *plane; 1738 struct drm_plane_state *plane_state; 1739 struct drm_crtc *crtc; 1740 struct drm_crtc_state *crtc_state; 1741 struct drm_connector *connector; 1742 struct drm_connector_state *connector_state; 1743 struct drm_private_obj *obj; 1744 struct drm_private_state *obj_state; 1745 int i; 1746 1747 if (!p) { 1748 drm_err(state->dev, "invalid drm printer\n"); 1749 return; 1750 } 1751 1752 drm_dbg_atomic(state->dev, "checking %p\n", state); 1753 1754 for_each_new_plane_in_state(state, plane, plane_state, i) 1755 drm_atomic_plane_print_state(p, plane_state); 1756 1757 for_each_new_crtc_in_state(state, crtc, crtc_state, i) 1758 drm_atomic_crtc_print_state(p, crtc_state); 1759 1760 for_each_new_connector_in_state(state, connector, connector_state, i) 1761 drm_atomic_connector_print_state(p, connector_state); 1762 1763 for_each_new_private_obj_in_state(state, obj, obj_state, i) 1764 drm_atomic_private_obj_print_state(p, obj_state); 1765 } 1766 EXPORT_SYMBOL(drm_atomic_print_new_state); 1767 1768 static void __drm_state_dump(struct drm_device *dev, struct drm_printer *p, 1769 bool take_locks) 1770 { 1771 struct drm_mode_config *config = &dev->mode_config; 1772 struct drm_plane *plane; 1773 struct drm_crtc *crtc; 1774 struct drm_connector *connector; 1775 struct drm_connector_list_iter conn_iter; 1776 1777 if (!drm_drv_uses_atomic_modeset(dev)) 1778 return; 1779 1780 list_for_each_entry(plane, &config->plane_list, head) { 1781 if (take_locks) 1782 drm_modeset_lock(&plane->mutex, NULL); 1783 drm_atomic_plane_print_state(p, plane->state); 1784 if (take_locks) 1785 drm_modeset_unlock(&plane->mutex); 1786 } 1787 1788 list_for_each_entry(crtc, &config->crtc_list, head) { 1789 if (take_locks) 1790 drm_modeset_lock(&crtc->mutex, NULL); 1791 drm_atomic_crtc_print_state(p, crtc->state); 1792 if (take_locks) 1793 drm_modeset_unlock(&crtc->mutex); 1794 } 1795 1796 drm_connector_list_iter_begin(dev, &conn_iter); 1797 if (take_locks) 1798 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 1799 drm_for_each_connector_iter(connector, &conn_iter) 1800 drm_atomic_connector_print_state(p, connector->state); 1801 if (take_locks) 1802 drm_modeset_unlock(&dev->mode_config.connection_mutex); 1803 drm_connector_list_iter_end(&conn_iter); 1804 } 1805 1806 /** 1807 * drm_state_dump - dump entire device atomic state 1808 * @dev: the drm device 1809 * @p: where to print the state to 1810 * 1811 * Just for debugging. Drivers might want an option to dump state 1812 * to dmesg in case of error irq's. (Hint, you probably want to 1813 * ratelimit this!) 1814 * 1815 * The caller must wrap this drm_modeset_lock_all_ctx() and 1816 * drm_modeset_drop_locks(). If this is called from error irq handler, it should 1817 * not be enabled by default - if you are debugging errors you might 1818 * not care that this is racey, but calling this without all modeset locks held 1819 * is inherently unsafe. 1820 */ 1821 void drm_state_dump(struct drm_device *dev, struct drm_printer *p) 1822 { 1823 __drm_state_dump(dev, p, false); 1824 } 1825 EXPORT_SYMBOL(drm_state_dump); 1826 1827 #ifdef CONFIG_DEBUG_FS 1828 static int drm_state_info(struct seq_file *m, void *data) 1829 { 1830 struct drm_debugfs_entry *entry = m->private; 1831 struct drm_device *dev = entry->dev; 1832 struct drm_printer p = drm_seq_file_printer(m); 1833 1834 __drm_state_dump(dev, &p, true); 1835 1836 return 0; 1837 } 1838 1839 /* any use in debugfs files to dump individual planes/crtc/etc? */ 1840 static const struct drm_debugfs_info drm_atomic_debugfs_list[] = { 1841 {"state", drm_state_info, 0}, 1842 }; 1843 1844 void drm_atomic_debugfs_init(struct drm_device *dev) 1845 { 1846 drm_debugfs_add_files(dev, drm_atomic_debugfs_list, 1847 ARRAY_SIZE(drm_atomic_debugfs_list)); 1848 } 1849 #endif 1850