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