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 #include <drm/drmP.h> 29 #include <drm/drm_atomic.h> 30 #include <drm/drm_plane_helper.h> 31 #include <drm/drm_crtc_helper.h> 32 #include <drm/drm_atomic_helper.h> 33 #include <linux/fence.h> 34 35 /** 36 * DOC: overview 37 * 38 * This helper library provides implementations of check and commit functions on 39 * top of the CRTC modeset helper callbacks and the plane helper callbacks. It 40 * also provides convenience implementations for the atomic state handling 41 * callbacks for drivers which don't need to subclass the drm core structures to 42 * add their own additional internal state. 43 * 44 * This library also provides default implementations for the check callback in 45 * drm_atomic_helper_check() and for the commit callback with 46 * drm_atomic_helper_commit(). But the individual stages and callbacks are 47 * exposed to allow drivers to mix and match and e.g. use the plane helpers only 48 * together with a driver private modeset implementation. 49 * 50 * This library also provides implementations for all the legacy driver 51 * interfaces on top of the atomic interface. See drm_atomic_helper_set_config(), 52 * drm_atomic_helper_disable_plane(), drm_atomic_helper_disable_plane() and the 53 * various functions to implement set_property callbacks. New drivers must not 54 * implement these functions themselves but must use the provided helpers. 55 * 56 * The atomic helper uses the same function table structures as all other 57 * modesetting helpers. See the documentation for struct &drm_crtc_helper_funcs, 58 * struct &drm_encoder_helper_funcs and struct &drm_connector_helper_funcs. It 59 * also shares the struct &drm_plane_helper_funcs function table with the plane 60 * helpers. 61 */ 62 static void 63 drm_atomic_helper_plane_changed(struct drm_atomic_state *state, 64 struct drm_plane_state *plane_state, 65 struct drm_plane *plane) 66 { 67 struct drm_crtc_state *crtc_state; 68 69 if (plane->state->crtc) { 70 crtc_state = state->crtc_states[drm_crtc_index(plane->state->crtc)]; 71 72 if (WARN_ON(!crtc_state)) 73 return; 74 75 crtc_state->planes_changed = true; 76 } 77 78 if (plane_state->crtc) { 79 crtc_state = 80 state->crtc_states[drm_crtc_index(plane_state->crtc)]; 81 82 if (WARN_ON(!crtc_state)) 83 return; 84 85 crtc_state->planes_changed = true; 86 } 87 } 88 89 static bool 90 check_pending_encoder_assignment(struct drm_atomic_state *state, 91 struct drm_encoder *new_encoder) 92 { 93 struct drm_connector *connector; 94 struct drm_connector_state *conn_state; 95 int i; 96 97 for_each_connector_in_state(state, connector, conn_state, i) { 98 if (conn_state->best_encoder != new_encoder) 99 continue; 100 101 /* encoder already assigned and we're trying to re-steal it! */ 102 if (connector->state->best_encoder != conn_state->best_encoder) 103 return false; 104 } 105 106 return true; 107 } 108 109 static struct drm_crtc * 110 get_current_crtc_for_encoder(struct drm_device *dev, 111 struct drm_encoder *encoder) 112 { 113 struct drm_mode_config *config = &dev->mode_config; 114 struct drm_connector *connector; 115 116 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); 117 118 drm_for_each_connector(connector, dev) { 119 if (connector->state->best_encoder != encoder) 120 continue; 121 122 return connector->state->crtc; 123 } 124 125 return NULL; 126 } 127 128 static int 129 steal_encoder(struct drm_atomic_state *state, 130 struct drm_encoder *encoder, 131 struct drm_crtc *encoder_crtc) 132 { 133 struct drm_mode_config *config = &state->dev->mode_config; 134 struct drm_crtc_state *crtc_state; 135 struct drm_connector *connector; 136 struct drm_connector_state *connector_state; 137 int ret; 138 139 /* 140 * We can only steal an encoder coming from a connector, which means we 141 * must already hold the connection_mutex. 142 */ 143 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); 144 145 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s], stealing it\n", 146 encoder->base.id, encoder->name, 147 encoder_crtc->base.id, encoder_crtc->name); 148 149 crtc_state = drm_atomic_get_crtc_state(state, encoder_crtc); 150 if (IS_ERR(crtc_state)) 151 return PTR_ERR(crtc_state); 152 153 crtc_state->connectors_changed = true; 154 155 list_for_each_entry(connector, &config->connector_list, head) { 156 if (connector->state->best_encoder != encoder) 157 continue; 158 159 DRM_DEBUG_ATOMIC("Stealing encoder from [CONNECTOR:%d:%s]\n", 160 connector->base.id, 161 connector->name); 162 163 connector_state = drm_atomic_get_connector_state(state, 164 connector); 165 if (IS_ERR(connector_state)) 166 return PTR_ERR(connector_state); 167 168 ret = drm_atomic_set_crtc_for_connector(connector_state, NULL); 169 if (ret) 170 return ret; 171 connector_state->best_encoder = NULL; 172 } 173 174 return 0; 175 } 176 177 static int 178 update_connector_routing(struct drm_atomic_state *state, int conn_idx) 179 { 180 const struct drm_connector_helper_funcs *funcs; 181 struct drm_encoder *new_encoder; 182 struct drm_crtc *encoder_crtc; 183 struct drm_connector *connector; 184 struct drm_connector_state *connector_state; 185 struct drm_crtc_state *crtc_state; 186 int idx, ret; 187 188 connector = state->connectors[conn_idx]; 189 connector_state = state->connector_states[conn_idx]; 190 191 if (!connector) 192 return 0; 193 194 DRM_DEBUG_ATOMIC("Updating routing for [CONNECTOR:%d:%s]\n", 195 connector->base.id, 196 connector->name); 197 198 if (connector->state->crtc != connector_state->crtc) { 199 if (connector->state->crtc) { 200 idx = drm_crtc_index(connector->state->crtc); 201 202 crtc_state = state->crtc_states[idx]; 203 crtc_state->connectors_changed = true; 204 } 205 206 if (connector_state->crtc) { 207 idx = drm_crtc_index(connector_state->crtc); 208 209 crtc_state = state->crtc_states[idx]; 210 crtc_state->connectors_changed = true; 211 } 212 } 213 214 if (!connector_state->crtc) { 215 DRM_DEBUG_ATOMIC("Disabling [CONNECTOR:%d:%s]\n", 216 connector->base.id, 217 connector->name); 218 219 connector_state->best_encoder = NULL; 220 221 return 0; 222 } 223 224 funcs = connector->helper_private; 225 226 if (funcs->atomic_best_encoder) 227 new_encoder = funcs->atomic_best_encoder(connector, 228 connector_state); 229 else 230 new_encoder = funcs->best_encoder(connector); 231 232 if (!new_encoder) { 233 DRM_DEBUG_ATOMIC("No suitable encoder found for [CONNECTOR:%d:%s]\n", 234 connector->base.id, 235 connector->name); 236 return -EINVAL; 237 } 238 239 if (!drm_encoder_crtc_ok(new_encoder, connector_state->crtc)) { 240 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] incompatible with [CRTC:%d]\n", 241 new_encoder->base.id, 242 new_encoder->name, 243 connector_state->crtc->base.id); 244 return -EINVAL; 245 } 246 247 if (new_encoder == connector_state->best_encoder) { 248 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on [CRTC:%d:%s]\n", 249 connector->base.id, 250 connector->name, 251 new_encoder->base.id, 252 new_encoder->name, 253 connector_state->crtc->base.id, 254 connector_state->crtc->name); 255 256 return 0; 257 } 258 259 if (!check_pending_encoder_assignment(state, new_encoder)) { 260 DRM_DEBUG_ATOMIC("Encoder for [CONNECTOR:%d:%s] already assigned\n", 261 connector->base.id, 262 connector->name); 263 return -EINVAL; 264 } 265 266 encoder_crtc = get_current_crtc_for_encoder(state->dev, 267 new_encoder); 268 269 if (encoder_crtc) { 270 ret = steal_encoder(state, new_encoder, encoder_crtc); 271 if (ret) { 272 DRM_DEBUG_ATOMIC("Encoder stealing failed for [CONNECTOR:%d:%s]\n", 273 connector->base.id, 274 connector->name); 275 return ret; 276 } 277 } 278 279 if (WARN_ON(!connector_state->crtc)) 280 return -EINVAL; 281 282 connector_state->best_encoder = new_encoder; 283 idx = drm_crtc_index(connector_state->crtc); 284 285 crtc_state = state->crtc_states[idx]; 286 crtc_state->connectors_changed = true; 287 288 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] using [ENCODER:%d:%s] on [CRTC:%d:%s]\n", 289 connector->base.id, 290 connector->name, 291 new_encoder->base.id, 292 new_encoder->name, 293 connector_state->crtc->base.id, 294 connector_state->crtc->name); 295 296 return 0; 297 } 298 299 static int 300 mode_fixup(struct drm_atomic_state *state) 301 { 302 struct drm_crtc *crtc; 303 struct drm_crtc_state *crtc_state; 304 struct drm_connector *connector; 305 struct drm_connector_state *conn_state; 306 int i; 307 bool ret; 308 309 for_each_crtc_in_state(state, crtc, crtc_state, i) { 310 if (!crtc_state->mode_changed && 311 !crtc_state->connectors_changed) 312 continue; 313 314 drm_mode_copy(&crtc_state->adjusted_mode, &crtc_state->mode); 315 } 316 317 for_each_connector_in_state(state, connector, conn_state, i) { 318 const struct drm_encoder_helper_funcs *funcs; 319 struct drm_encoder *encoder; 320 321 WARN_ON(!!conn_state->best_encoder != !!conn_state->crtc); 322 323 if (!conn_state->crtc || !conn_state->best_encoder) 324 continue; 325 326 crtc_state = 327 state->crtc_states[drm_crtc_index(conn_state->crtc)]; 328 329 /* 330 * Each encoder has at most one connector (since we always steal 331 * it away), so we won't call ->mode_fixup twice. 332 */ 333 encoder = conn_state->best_encoder; 334 funcs = encoder->helper_private; 335 if (!funcs) 336 continue; 337 338 ret = drm_bridge_mode_fixup(encoder->bridge, &crtc_state->mode, 339 &crtc_state->adjusted_mode); 340 if (!ret) { 341 DRM_DEBUG_ATOMIC("Bridge fixup failed\n"); 342 return -EINVAL; 343 } 344 345 if (funcs->atomic_check) { 346 ret = funcs->atomic_check(encoder, crtc_state, 347 conn_state); 348 if (ret) { 349 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] check failed\n", 350 encoder->base.id, encoder->name); 351 return ret; 352 } 353 } else if (funcs->mode_fixup) { 354 ret = funcs->mode_fixup(encoder, &crtc_state->mode, 355 &crtc_state->adjusted_mode); 356 if (!ret) { 357 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] fixup failed\n", 358 encoder->base.id, encoder->name); 359 return -EINVAL; 360 } 361 } 362 } 363 364 for_each_crtc_in_state(state, crtc, crtc_state, i) { 365 const struct drm_crtc_helper_funcs *funcs; 366 367 if (!crtc_state->mode_changed && 368 !crtc_state->connectors_changed) 369 continue; 370 371 funcs = crtc->helper_private; 372 if (!funcs->mode_fixup) 373 continue; 374 375 ret = funcs->mode_fixup(crtc, &crtc_state->mode, 376 &crtc_state->adjusted_mode); 377 if (!ret) { 378 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] fixup failed\n", 379 crtc->base.id, crtc->name); 380 return -EINVAL; 381 } 382 } 383 384 return 0; 385 } 386 387 /** 388 * drm_atomic_helper_check_modeset - validate state object for modeset changes 389 * @dev: DRM device 390 * @state: the driver state object 391 * 392 * Check the state object to see if the requested state is physically possible. 393 * This does all the crtc and connector related computations for an atomic 394 * update and adds any additional connectors needed for full modesets and calls 395 * down into ->mode_fixup functions of the driver backend. 396 * 397 * crtc_state->mode_changed is set when the input mode is changed. 398 * crtc_state->connectors_changed is set when a connector is added or 399 * removed from the crtc. 400 * crtc_state->active_changed is set when crtc_state->active changes, 401 * which is used for dpms. 402 * 403 * IMPORTANT: 404 * 405 * Drivers which update ->mode_changed (e.g. in their ->atomic_check hooks if a 406 * plane update can't be done without a full modeset) _must_ call this function 407 * afterwards after that change. It is permitted to call this function multiple 408 * times for the same update, e.g. when the ->atomic_check functions depend upon 409 * the adjusted dotclock for fifo space allocation and watermark computation. 410 * 411 * RETURNS 412 * Zero for success or -errno 413 */ 414 int 415 drm_atomic_helper_check_modeset(struct drm_device *dev, 416 struct drm_atomic_state *state) 417 { 418 struct drm_crtc *crtc; 419 struct drm_crtc_state *crtc_state; 420 struct drm_connector *connector; 421 struct drm_connector_state *connector_state; 422 int i, ret; 423 424 for_each_crtc_in_state(state, crtc, crtc_state, i) { 425 if (!drm_mode_equal(&crtc->state->mode, &crtc_state->mode)) { 426 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] mode changed\n", 427 crtc->base.id, crtc->name); 428 crtc_state->mode_changed = true; 429 } 430 431 if (crtc->state->enable != crtc_state->enable) { 432 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enable changed\n", 433 crtc->base.id, crtc->name); 434 435 /* 436 * For clarity this assignment is done here, but 437 * enable == 0 is only true when there are no 438 * connectors and a NULL mode. 439 * 440 * The other way around is true as well. enable != 0 441 * iff connectors are attached and a mode is set. 442 */ 443 crtc_state->mode_changed = true; 444 crtc_state->connectors_changed = true; 445 } 446 } 447 448 for_each_connector_in_state(state, connector, connector_state, i) { 449 /* 450 * This only sets crtc->mode_changed for routing changes, 451 * drivers must set crtc->mode_changed themselves when connector 452 * properties need to be updated. 453 */ 454 ret = update_connector_routing(state, i); 455 if (ret) 456 return ret; 457 } 458 459 /* 460 * After all the routing has been prepared we need to add in any 461 * connector which is itself unchanged, but who's crtc changes it's 462 * configuration. This must be done before calling mode_fixup in case a 463 * crtc only changed its mode but has the same set of connectors. 464 */ 465 for_each_crtc_in_state(state, crtc, crtc_state, i) { 466 bool has_connectors = 467 !!crtc_state->connector_mask; 468 469 /* 470 * We must set ->active_changed after walking connectors for 471 * otherwise an update that only changes active would result in 472 * a full modeset because update_connector_routing force that. 473 */ 474 if (crtc->state->active != crtc_state->active) { 475 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active changed\n", 476 crtc->base.id, crtc->name); 477 crtc_state->active_changed = true; 478 } 479 480 if (!drm_atomic_crtc_needs_modeset(crtc_state)) 481 continue; 482 483 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] needs all connectors, enable: %c, active: %c\n", 484 crtc->base.id, crtc->name, 485 crtc_state->enable ? 'y' : 'n', 486 crtc_state->active ? 'y' : 'n'); 487 488 ret = drm_atomic_add_affected_connectors(state, crtc); 489 if (ret != 0) 490 return ret; 491 492 ret = drm_atomic_add_affected_planes(state, crtc); 493 if (ret != 0) 494 return ret; 495 496 if (crtc_state->enable != has_connectors) { 497 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled/connectors mismatch\n", 498 crtc->base.id, crtc->name); 499 500 return -EINVAL; 501 } 502 } 503 504 return mode_fixup(state); 505 } 506 EXPORT_SYMBOL(drm_atomic_helper_check_modeset); 507 508 /** 509 * drm_atomic_helper_check_planes - validate state object for planes changes 510 * @dev: DRM device 511 * @state: the driver state object 512 * 513 * Check the state object to see if the requested state is physically possible. 514 * This does all the plane update related checks using by calling into the 515 * ->atomic_check hooks provided by the driver. 516 * 517 * It also sets crtc_state->planes_changed to indicate that a crtc has 518 * updated planes. 519 * 520 * RETURNS 521 * Zero for success or -errno 522 */ 523 int 524 drm_atomic_helper_check_planes(struct drm_device *dev, 525 struct drm_atomic_state *state) 526 { 527 struct drm_crtc *crtc; 528 struct drm_crtc_state *crtc_state; 529 struct drm_plane *plane; 530 struct drm_plane_state *plane_state; 531 int i, ret = 0; 532 533 for_each_plane_in_state(state, plane, plane_state, i) { 534 const struct drm_plane_helper_funcs *funcs; 535 536 funcs = plane->helper_private; 537 538 drm_atomic_helper_plane_changed(state, plane_state, plane); 539 540 if (!funcs || !funcs->atomic_check) 541 continue; 542 543 ret = funcs->atomic_check(plane, plane_state); 544 if (ret) { 545 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic driver check failed\n", 546 plane->base.id, plane->name); 547 return ret; 548 } 549 } 550 551 for_each_crtc_in_state(state, crtc, crtc_state, i) { 552 const struct drm_crtc_helper_funcs *funcs; 553 554 funcs = crtc->helper_private; 555 556 if (!funcs || !funcs->atomic_check) 557 continue; 558 559 ret = funcs->atomic_check(crtc, state->crtc_states[i]); 560 if (ret) { 561 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic driver check failed\n", 562 crtc->base.id, crtc->name); 563 return ret; 564 } 565 } 566 567 return ret; 568 } 569 EXPORT_SYMBOL(drm_atomic_helper_check_planes); 570 571 /** 572 * drm_atomic_helper_check - validate state object 573 * @dev: DRM device 574 * @state: the driver state object 575 * 576 * Check the state object to see if the requested state is physically possible. 577 * Only crtcs and planes have check callbacks, so for any additional (global) 578 * checking that a driver needs it can simply wrap that around this function. 579 * Drivers without such needs can directly use this as their ->atomic_check() 580 * callback. 581 * 582 * This just wraps the two parts of the state checking for planes and modeset 583 * state in the default order: First it calls drm_atomic_helper_check_modeset() 584 * and then drm_atomic_helper_check_planes(). The assumption is that the 585 * ->atomic_check functions depend upon an updated adjusted_mode.clock to 586 * e.g. properly compute watermarks. 587 * 588 * RETURNS 589 * Zero for success or -errno 590 */ 591 int drm_atomic_helper_check(struct drm_device *dev, 592 struct drm_atomic_state *state) 593 { 594 int ret; 595 596 ret = drm_atomic_helper_check_modeset(dev, state); 597 if (ret) 598 return ret; 599 600 ret = drm_atomic_helper_check_planes(dev, state); 601 if (ret) 602 return ret; 603 604 return ret; 605 } 606 EXPORT_SYMBOL(drm_atomic_helper_check); 607 608 static void 609 disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state) 610 { 611 struct drm_connector *connector; 612 struct drm_connector_state *old_conn_state; 613 struct drm_crtc *crtc; 614 struct drm_crtc_state *old_crtc_state; 615 int i; 616 617 for_each_connector_in_state(old_state, connector, old_conn_state, i) { 618 const struct drm_encoder_helper_funcs *funcs; 619 struct drm_encoder *encoder; 620 struct drm_crtc_state *old_crtc_state; 621 622 /* Shut down everything that's in the changeset and currently 623 * still on. So need to check the old, saved state. */ 624 if (!old_conn_state->crtc) 625 continue; 626 627 old_crtc_state = old_state->crtc_states[drm_crtc_index(old_conn_state->crtc)]; 628 629 if (!old_crtc_state->active || 630 !drm_atomic_crtc_needs_modeset(old_conn_state->crtc->state)) 631 continue; 632 633 encoder = old_conn_state->best_encoder; 634 635 /* We shouldn't get this far if we didn't previously have 636 * an encoder.. but WARN_ON() rather than explode. 637 */ 638 if (WARN_ON(!encoder)) 639 continue; 640 641 funcs = encoder->helper_private; 642 643 DRM_DEBUG_ATOMIC("disabling [ENCODER:%d:%s]\n", 644 encoder->base.id, encoder->name); 645 646 /* 647 * Each encoder has at most one connector (since we always steal 648 * it away), so we won't call disable hooks twice. 649 */ 650 drm_bridge_disable(encoder->bridge); 651 652 /* Right function depends upon target state. */ 653 if (connector->state->crtc && funcs->prepare) 654 funcs->prepare(encoder); 655 else if (funcs->disable) 656 funcs->disable(encoder); 657 else 658 funcs->dpms(encoder, DRM_MODE_DPMS_OFF); 659 660 drm_bridge_post_disable(encoder->bridge); 661 } 662 663 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 664 const struct drm_crtc_helper_funcs *funcs; 665 666 /* Shut down everything that needs a full modeset. */ 667 if (!drm_atomic_crtc_needs_modeset(crtc->state)) 668 continue; 669 670 if (!old_crtc_state->active) 671 continue; 672 673 funcs = crtc->helper_private; 674 675 DRM_DEBUG_ATOMIC("disabling [CRTC:%d:%s]\n", 676 crtc->base.id, crtc->name); 677 678 679 /* Right function depends upon target state. */ 680 if (crtc->state->enable && funcs->prepare) 681 funcs->prepare(crtc); 682 else if (funcs->disable) 683 funcs->disable(crtc); 684 else 685 funcs->dpms(crtc, DRM_MODE_DPMS_OFF); 686 } 687 } 688 689 /** 690 * drm_atomic_helper_update_legacy_modeset_state - update legacy modeset state 691 * @dev: DRM device 692 * @old_state: atomic state object with old state structures 693 * 694 * This function updates all the various legacy modeset state pointers in 695 * connectors, encoders and crtcs. It also updates the timestamping constants 696 * used for precise vblank timestamps by calling 697 * drm_calc_timestamping_constants(). 698 * 699 * Drivers can use this for building their own atomic commit if they don't have 700 * a pure helper-based modeset implementation. 701 */ 702 void 703 drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev, 704 struct drm_atomic_state *old_state) 705 { 706 struct drm_connector *connector; 707 struct drm_connector_state *old_conn_state; 708 struct drm_crtc *crtc; 709 struct drm_crtc_state *old_crtc_state; 710 int i; 711 712 /* clear out existing links and update dpms */ 713 for_each_connector_in_state(old_state, connector, old_conn_state, i) { 714 if (connector->encoder) { 715 WARN_ON(!connector->encoder->crtc); 716 717 connector->encoder->crtc = NULL; 718 connector->encoder = NULL; 719 } 720 721 crtc = connector->state->crtc; 722 if ((!crtc && old_conn_state->crtc) || 723 (crtc && drm_atomic_crtc_needs_modeset(crtc->state))) { 724 struct drm_property *dpms_prop = 725 dev->mode_config.dpms_property; 726 int mode = DRM_MODE_DPMS_OFF; 727 728 if (crtc && crtc->state->active) 729 mode = DRM_MODE_DPMS_ON; 730 731 connector->dpms = mode; 732 drm_object_property_set_value(&connector->base, 733 dpms_prop, mode); 734 } 735 } 736 737 /* set new links */ 738 for_each_connector_in_state(old_state, connector, old_conn_state, i) { 739 if (!connector->state->crtc) 740 continue; 741 742 if (WARN_ON(!connector->state->best_encoder)) 743 continue; 744 745 connector->encoder = connector->state->best_encoder; 746 connector->encoder->crtc = connector->state->crtc; 747 } 748 749 /* set legacy state in the crtc structure */ 750 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 751 struct drm_plane *primary = crtc->primary; 752 753 crtc->mode = crtc->state->mode; 754 crtc->enabled = crtc->state->enable; 755 756 if (drm_atomic_get_existing_plane_state(old_state, primary) && 757 primary->state->crtc == crtc) { 758 crtc->x = primary->state->src_x >> 16; 759 crtc->y = primary->state->src_y >> 16; 760 } 761 762 if (crtc->state->enable) 763 drm_calc_timestamping_constants(crtc, 764 &crtc->state->adjusted_mode); 765 } 766 } 767 EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state); 768 769 static void 770 crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state) 771 { 772 struct drm_crtc *crtc; 773 struct drm_crtc_state *old_crtc_state; 774 struct drm_connector *connector; 775 struct drm_connector_state *old_conn_state; 776 int i; 777 778 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 779 const struct drm_crtc_helper_funcs *funcs; 780 781 if (!crtc->state->mode_changed) 782 continue; 783 784 funcs = crtc->helper_private; 785 786 if (crtc->state->enable && funcs->mode_set_nofb) { 787 DRM_DEBUG_ATOMIC("modeset on [CRTC:%d:%s]\n", 788 crtc->base.id, crtc->name); 789 790 funcs->mode_set_nofb(crtc); 791 } 792 } 793 794 for_each_connector_in_state(old_state, connector, old_conn_state, i) { 795 const struct drm_encoder_helper_funcs *funcs; 796 struct drm_crtc_state *new_crtc_state; 797 struct drm_encoder *encoder; 798 struct drm_display_mode *mode, *adjusted_mode; 799 800 if (!connector->state->best_encoder) 801 continue; 802 803 encoder = connector->state->best_encoder; 804 funcs = encoder->helper_private; 805 new_crtc_state = connector->state->crtc->state; 806 mode = &new_crtc_state->mode; 807 adjusted_mode = &new_crtc_state->adjusted_mode; 808 809 if (!new_crtc_state->mode_changed) 810 continue; 811 812 DRM_DEBUG_ATOMIC("modeset on [ENCODER:%d:%s]\n", 813 encoder->base.id, encoder->name); 814 815 /* 816 * Each encoder has at most one connector (since we always steal 817 * it away), so we won't call mode_set hooks twice. 818 */ 819 if (funcs->mode_set) 820 funcs->mode_set(encoder, mode, adjusted_mode); 821 822 drm_bridge_mode_set(encoder->bridge, mode, adjusted_mode); 823 } 824 } 825 826 /** 827 * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs 828 * @dev: DRM device 829 * @old_state: atomic state object with old state structures 830 * 831 * This function shuts down all the outputs that need to be shut down and 832 * prepares them (if required) with the new mode. 833 * 834 * For compatibility with legacy crtc helpers this should be called before 835 * drm_atomic_helper_commit_planes(), which is what the default commit function 836 * does. But drivers with different needs can group the modeset commits together 837 * and do the plane commits at the end. This is useful for drivers doing runtime 838 * PM since planes updates then only happen when the CRTC is actually enabled. 839 */ 840 void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev, 841 struct drm_atomic_state *old_state) 842 { 843 disable_outputs(dev, old_state); 844 845 drm_atomic_helper_update_legacy_modeset_state(dev, old_state); 846 847 crtc_set_mode(dev, old_state); 848 } 849 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables); 850 851 /** 852 * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs 853 * @dev: DRM device 854 * @old_state: atomic state object with old state structures 855 * 856 * This function enables all the outputs with the new configuration which had to 857 * be turned off for the update. 858 * 859 * For compatibility with legacy crtc helpers this should be called after 860 * drm_atomic_helper_commit_planes(), which is what the default commit function 861 * does. But drivers with different needs can group the modeset commits together 862 * and do the plane commits at the end. This is useful for drivers doing runtime 863 * PM since planes updates then only happen when the CRTC is actually enabled. 864 */ 865 void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev, 866 struct drm_atomic_state *old_state) 867 { 868 struct drm_crtc *crtc; 869 struct drm_crtc_state *old_crtc_state; 870 struct drm_connector *connector; 871 struct drm_connector_state *old_conn_state; 872 int i; 873 874 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 875 const struct drm_crtc_helper_funcs *funcs; 876 877 /* Need to filter out CRTCs where only planes change. */ 878 if (!drm_atomic_crtc_needs_modeset(crtc->state)) 879 continue; 880 881 if (!crtc->state->active) 882 continue; 883 884 funcs = crtc->helper_private; 885 886 if (crtc->state->enable) { 887 DRM_DEBUG_ATOMIC("enabling [CRTC:%d:%s]\n", 888 crtc->base.id, crtc->name); 889 890 if (funcs->enable) 891 funcs->enable(crtc); 892 else 893 funcs->commit(crtc); 894 } 895 } 896 897 for_each_connector_in_state(old_state, connector, old_conn_state, i) { 898 const struct drm_encoder_helper_funcs *funcs; 899 struct drm_encoder *encoder; 900 901 if (!connector->state->best_encoder) 902 continue; 903 904 if (!connector->state->crtc->state->active || 905 !drm_atomic_crtc_needs_modeset(connector->state->crtc->state)) 906 continue; 907 908 encoder = connector->state->best_encoder; 909 funcs = encoder->helper_private; 910 911 DRM_DEBUG_ATOMIC("enabling [ENCODER:%d:%s]\n", 912 encoder->base.id, encoder->name); 913 914 /* 915 * Each encoder has at most one connector (since we always steal 916 * it away), so we won't call enable hooks twice. 917 */ 918 drm_bridge_pre_enable(encoder->bridge); 919 920 if (funcs->enable) 921 funcs->enable(encoder); 922 else 923 funcs->commit(encoder); 924 925 drm_bridge_enable(encoder->bridge); 926 } 927 } 928 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables); 929 930 static void wait_for_fences(struct drm_device *dev, 931 struct drm_atomic_state *state) 932 { 933 /* XXX: implement linux/fence.h first */ 934 #if 0 935 struct drm_plane *plane; 936 struct drm_plane_state *plane_state; 937 int i; 938 939 for_each_plane_in_state(state, plane, plane_state, i) { 940 if (!plane->state->fence) 941 continue; 942 943 WARN_ON(!plane->state->fb); 944 945 fence_wait(plane->state->fence, false); 946 fence_put(plane->state->fence); 947 plane->state->fence = NULL; 948 } 949 #endif 950 } 951 952 /** 953 * drm_atomic_helper_framebuffer_changed - check if framebuffer has changed 954 * @dev: DRM device 955 * @old_state: atomic state object with old state structures 956 * @crtc: DRM crtc 957 * 958 * Checks whether the framebuffer used for this CRTC changes as a result of 959 * the atomic update. This is useful for drivers which cannot use 960 * drm_atomic_helper_wait_for_vblanks() and need to reimplement its 961 * functionality. 962 * 963 * Returns: 964 * true if the framebuffer changed. 965 */ 966 bool drm_atomic_helper_framebuffer_changed(struct drm_device *dev, 967 struct drm_atomic_state *old_state, 968 struct drm_crtc *crtc) 969 { 970 struct drm_plane *plane; 971 struct drm_plane_state *old_plane_state; 972 int i; 973 974 for_each_plane_in_state(old_state, plane, old_plane_state, i) { 975 if (plane->state->crtc != crtc && 976 old_plane_state->crtc != crtc) 977 continue; 978 979 if (plane->state->fb != old_plane_state->fb) 980 return true; 981 } 982 983 return false; 984 } 985 EXPORT_SYMBOL(drm_atomic_helper_framebuffer_changed); 986 987 /** 988 * drm_atomic_helper_wait_for_vblanks - wait for vblank on crtcs 989 * @dev: DRM device 990 * @old_state: atomic state object with old state structures 991 * 992 * Helper to, after atomic commit, wait for vblanks on all effected 993 * crtcs (ie. before cleaning up old framebuffers using 994 * drm_atomic_helper_cleanup_planes()). It will only wait on crtcs where the 995 * framebuffers have actually changed to optimize for the legacy cursor and 996 * plane update use-case. 997 */ 998 void 999 drm_atomic_helper_wait_for_vblanks(struct drm_device *dev, 1000 struct drm_atomic_state *old_state) 1001 { 1002 struct drm_crtc *crtc; 1003 struct drm_crtc_state *old_crtc_state; 1004 int i, ret; 1005 1006 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 1007 /* No one cares about the old state, so abuse it for tracking 1008 * and store whether we hold a vblank reference (and should do a 1009 * vblank wait) in the ->enable boolean. */ 1010 old_crtc_state->enable = false; 1011 1012 if (!crtc->state->enable) 1013 continue; 1014 1015 /* Legacy cursor ioctls are completely unsynced, and userspace 1016 * relies on that (by doing tons of cursor updates). */ 1017 if (old_state->legacy_cursor_update) 1018 continue; 1019 1020 if (!drm_atomic_helper_framebuffer_changed(dev, 1021 old_state, crtc)) 1022 continue; 1023 1024 ret = drm_crtc_vblank_get(crtc); 1025 if (ret != 0) 1026 continue; 1027 1028 old_crtc_state->enable = true; 1029 old_crtc_state->last_vblank_count = drm_crtc_vblank_count(crtc); 1030 } 1031 1032 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 1033 if (!old_crtc_state->enable) 1034 continue; 1035 1036 ret = wait_event_timeout(dev->vblank[i].queue, 1037 old_crtc_state->last_vblank_count != 1038 drm_crtc_vblank_count(crtc), 1039 msecs_to_jiffies(50)); 1040 1041 drm_crtc_vblank_put(crtc); 1042 } 1043 } 1044 EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks); 1045 1046 /** 1047 * drm_atomic_helper_commit - commit validated state object 1048 * @dev: DRM device 1049 * @state: the driver state object 1050 * @async: asynchronous commit 1051 * 1052 * This function commits a with drm_atomic_helper_check() pre-validated state 1053 * object. This can still fail when e.g. the framebuffer reservation fails. For 1054 * now this doesn't implement asynchronous commits. 1055 * 1056 * Note that right now this function does not support async commits, and hence 1057 * driver writers must implement their own version for now. Also note that the 1058 * default ordering of how the various stages are called is to match the legacy 1059 * modeset helper library closest. One peculiarity of that is that it doesn't 1060 * mesh well with runtime PM at all. 1061 * 1062 * For drivers supporting runtime PM the recommended sequence is 1063 * 1064 * drm_atomic_helper_commit_modeset_disables(dev, state); 1065 * 1066 * drm_atomic_helper_commit_modeset_enables(dev, state); 1067 * 1068 * drm_atomic_helper_commit_planes(dev, state, true); 1069 * 1070 * See the kerneldoc entries for these three functions for more details. 1071 * 1072 * RETURNS 1073 * Zero for success or -errno. 1074 */ 1075 int drm_atomic_helper_commit(struct drm_device *dev, 1076 struct drm_atomic_state *state, 1077 bool async) 1078 { 1079 int ret; 1080 1081 if (async) 1082 return -EBUSY; 1083 1084 ret = drm_atomic_helper_prepare_planes(dev, state); 1085 if (ret) 1086 return ret; 1087 1088 /* 1089 * This is the point of no return - everything below never fails except 1090 * when the hw goes bonghits. Which means we can commit the new state on 1091 * the software side now. 1092 */ 1093 1094 drm_atomic_helper_swap_state(dev, state); 1095 1096 /* 1097 * Everything below can be run asynchronously without the need to grab 1098 * any modeset locks at all under one condition: It must be guaranteed 1099 * that the asynchronous work has either been cancelled (if the driver 1100 * supports it, which at least requires that the framebuffers get 1101 * cleaned up with drm_atomic_helper_cleanup_planes()) or completed 1102 * before the new state gets committed on the software side with 1103 * drm_atomic_helper_swap_state(). 1104 * 1105 * This scheme allows new atomic state updates to be prepared and 1106 * checked in parallel to the asynchronous completion of the previous 1107 * update. Which is important since compositors need to figure out the 1108 * composition of the next frame right after having submitted the 1109 * current layout. 1110 */ 1111 1112 wait_for_fences(dev, state); 1113 1114 drm_atomic_helper_commit_modeset_disables(dev, state); 1115 1116 drm_atomic_helper_commit_planes(dev, state, false); 1117 1118 drm_atomic_helper_commit_modeset_enables(dev, state); 1119 1120 drm_atomic_helper_wait_for_vblanks(dev, state); 1121 1122 drm_atomic_helper_cleanup_planes(dev, state); 1123 1124 drm_atomic_state_free(state); 1125 1126 return 0; 1127 } 1128 EXPORT_SYMBOL(drm_atomic_helper_commit); 1129 1130 /** 1131 * DOC: implementing async commit 1132 * 1133 * For now the atomic helpers don't support async commit directly. If there is 1134 * real need it could be added though, using the dma-buf fence infrastructure 1135 * for generic synchronization with outstanding rendering. 1136 * 1137 * For now drivers have to implement async commit themselves, with the following 1138 * sequence being the recommended one: 1139 * 1140 * 1. Run drm_atomic_helper_prepare_planes() first. This is the only function 1141 * which commit needs to call which can fail, so we want to run it first and 1142 * synchronously. 1143 * 1144 * 2. Synchronize with any outstanding asynchronous commit worker threads which 1145 * might be affected the new state update. This can be done by either cancelling 1146 * or flushing the work items, depending upon whether the driver can deal with 1147 * cancelled updates. Note that it is important to ensure that the framebuffer 1148 * cleanup is still done when cancelling. 1149 * 1150 * For sufficient parallelism it is recommended to have a work item per crtc 1151 * (for updates which don't touch global state) and a global one. Then we only 1152 * need to synchronize with the crtc work items for changed crtcs and the global 1153 * work item, which allows nice concurrent updates on disjoint sets of crtcs. 1154 * 1155 * 3. The software state is updated synchronously with 1156 * drm_atomic_helper_swap_state(). Doing this under the protection of all modeset 1157 * locks means concurrent callers never see inconsistent state. And doing this 1158 * while it's guaranteed that no relevant async worker runs means that async 1159 * workers do not need grab any locks. Actually they must not grab locks, for 1160 * otherwise the work flushing will deadlock. 1161 * 1162 * 4. Schedule a work item to do all subsequent steps, using the split-out 1163 * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and 1164 * then cleaning up the framebuffers after the old framebuffer is no longer 1165 * being displayed. 1166 */ 1167 1168 /** 1169 * drm_atomic_helper_prepare_planes - prepare plane resources before commit 1170 * @dev: DRM device 1171 * @state: atomic state object with new state structures 1172 * 1173 * This function prepares plane state, specifically framebuffers, for the new 1174 * configuration. If any failure is encountered this function will call 1175 * ->cleanup_fb on any already successfully prepared framebuffer. 1176 * 1177 * Returns: 1178 * 0 on success, negative error code on failure. 1179 */ 1180 int drm_atomic_helper_prepare_planes(struct drm_device *dev, 1181 struct drm_atomic_state *state) 1182 { 1183 int nplanes = dev->mode_config.num_total_plane; 1184 int ret, i; 1185 1186 for (i = 0; i < nplanes; i++) { 1187 const struct drm_plane_helper_funcs *funcs; 1188 struct drm_plane *plane = state->planes[i]; 1189 struct drm_plane_state *plane_state = state->plane_states[i]; 1190 1191 if (!plane) 1192 continue; 1193 1194 funcs = plane->helper_private; 1195 1196 if (funcs->prepare_fb) { 1197 ret = funcs->prepare_fb(plane, plane_state); 1198 if (ret) 1199 goto fail; 1200 } 1201 } 1202 1203 return 0; 1204 1205 fail: 1206 for (i--; i >= 0; i--) { 1207 const struct drm_plane_helper_funcs *funcs; 1208 struct drm_plane *plane = state->planes[i]; 1209 struct drm_plane_state *plane_state = state->plane_states[i]; 1210 1211 if (!plane) 1212 continue; 1213 1214 funcs = plane->helper_private; 1215 1216 if (funcs->cleanup_fb) 1217 funcs->cleanup_fb(plane, plane_state); 1218 1219 } 1220 1221 return ret; 1222 } 1223 EXPORT_SYMBOL(drm_atomic_helper_prepare_planes); 1224 1225 static bool plane_crtc_active(struct drm_plane_state *state) 1226 { 1227 return state->crtc && state->crtc->state->active; 1228 } 1229 1230 /** 1231 * drm_atomic_helper_commit_planes - commit plane state 1232 * @dev: DRM device 1233 * @old_state: atomic state object with old state structures 1234 * @active_only: Only commit on active CRTC if set 1235 * 1236 * This function commits the new plane state using the plane and atomic helper 1237 * functions for planes and crtcs. It assumes that the atomic state has already 1238 * been pushed into the relevant object state pointers, since this step can no 1239 * longer fail. 1240 * 1241 * It still requires the global state object @old_state to know which planes and 1242 * crtcs need to be updated though. 1243 * 1244 * Note that this function does all plane updates across all CRTCs in one step. 1245 * If the hardware can't support this approach look at 1246 * drm_atomic_helper_commit_planes_on_crtc() instead. 1247 * 1248 * Plane parameters can be updated by applications while the associated CRTC is 1249 * disabled. The DRM/KMS core will store the parameters in the plane state, 1250 * which will be available to the driver when the CRTC is turned on. As a result 1251 * most drivers don't need to be immediately notified of plane updates for a 1252 * disabled CRTC. 1253 * 1254 * Unless otherwise needed, drivers are advised to set the @active_only 1255 * parameters to true in order not to receive plane update notifications related 1256 * to a disabled CRTC. This avoids the need to manually ignore plane updates in 1257 * driver code when the driver and/or hardware can't or just don't need to deal 1258 * with updates on disabled CRTCs, for example when supporting runtime PM. 1259 * 1260 * The drm_atomic_helper_commit() default implementation only sets @active_only 1261 * to false to most closely match the behaviour of the legacy helpers. This should 1262 * not be copied blindly by drivers. 1263 */ 1264 void drm_atomic_helper_commit_planes(struct drm_device *dev, 1265 struct drm_atomic_state *old_state, 1266 bool active_only) 1267 { 1268 struct drm_crtc *crtc; 1269 struct drm_crtc_state *old_crtc_state; 1270 struct drm_plane *plane; 1271 struct drm_plane_state *old_plane_state; 1272 int i; 1273 1274 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 1275 const struct drm_crtc_helper_funcs *funcs; 1276 1277 funcs = crtc->helper_private; 1278 1279 if (!funcs || !funcs->atomic_begin) 1280 continue; 1281 1282 if (active_only && !crtc->state->active) 1283 continue; 1284 1285 funcs->atomic_begin(crtc, old_crtc_state); 1286 } 1287 1288 for_each_plane_in_state(old_state, plane, old_plane_state, i) { 1289 const struct drm_plane_helper_funcs *funcs; 1290 bool disabling; 1291 1292 funcs = plane->helper_private; 1293 1294 if (!funcs) 1295 continue; 1296 1297 disabling = drm_atomic_plane_disabling(plane, old_plane_state); 1298 1299 if (active_only) { 1300 /* 1301 * Skip planes related to inactive CRTCs. If the plane 1302 * is enabled use the state of the current CRTC. If the 1303 * plane is being disabled use the state of the old 1304 * CRTC to avoid skipping planes being disabled on an 1305 * active CRTC. 1306 */ 1307 if (!disabling && !plane_crtc_active(plane->state)) 1308 continue; 1309 if (disabling && !plane_crtc_active(old_plane_state)) 1310 continue; 1311 } 1312 1313 /* 1314 * Special-case disabling the plane if drivers support it. 1315 */ 1316 if (disabling && funcs->atomic_disable) 1317 funcs->atomic_disable(plane, old_plane_state); 1318 else if (plane->state->crtc || disabling) 1319 funcs->atomic_update(plane, old_plane_state); 1320 } 1321 1322 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 1323 const struct drm_crtc_helper_funcs *funcs; 1324 1325 funcs = crtc->helper_private; 1326 1327 if (!funcs || !funcs->atomic_flush) 1328 continue; 1329 1330 if (active_only && !crtc->state->active) 1331 continue; 1332 1333 funcs->atomic_flush(crtc, old_crtc_state); 1334 } 1335 } 1336 EXPORT_SYMBOL(drm_atomic_helper_commit_planes); 1337 1338 /** 1339 * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a crtc 1340 * @old_crtc_state: atomic state object with the old crtc state 1341 * 1342 * This function commits the new plane state using the plane and atomic helper 1343 * functions for planes on the specific crtc. It assumes that the atomic state 1344 * has already been pushed into the relevant object state pointers, since this 1345 * step can no longer fail. 1346 * 1347 * This function is useful when plane updates should be done crtc-by-crtc 1348 * instead of one global step like drm_atomic_helper_commit_planes() does. 1349 * 1350 * This function can only be savely used when planes are not allowed to move 1351 * between different CRTCs because this function doesn't handle inter-CRTC 1352 * depencies. Callers need to ensure that either no such depencies exist, 1353 * resolve them through ordering of commit calls or through some other means. 1354 */ 1355 void 1356 drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state) 1357 { 1358 const struct drm_crtc_helper_funcs *crtc_funcs; 1359 struct drm_crtc *crtc = old_crtc_state->crtc; 1360 struct drm_atomic_state *old_state = old_crtc_state->state; 1361 struct drm_plane *plane; 1362 unsigned plane_mask; 1363 1364 plane_mask = old_crtc_state->plane_mask; 1365 plane_mask |= crtc->state->plane_mask; 1366 1367 crtc_funcs = crtc->helper_private; 1368 if (crtc_funcs && crtc_funcs->atomic_begin) 1369 crtc_funcs->atomic_begin(crtc, old_crtc_state); 1370 1371 drm_for_each_plane_mask(plane, crtc->dev, plane_mask) { 1372 struct drm_plane_state *old_plane_state = 1373 drm_atomic_get_existing_plane_state(old_state, plane); 1374 const struct drm_plane_helper_funcs *plane_funcs; 1375 1376 plane_funcs = plane->helper_private; 1377 1378 if (!old_plane_state || !plane_funcs) 1379 continue; 1380 1381 WARN_ON(plane->state->crtc && plane->state->crtc != crtc); 1382 1383 if (drm_atomic_plane_disabling(plane, old_plane_state) && 1384 plane_funcs->atomic_disable) 1385 plane_funcs->atomic_disable(plane, old_plane_state); 1386 else if (plane->state->crtc || 1387 drm_atomic_plane_disabling(plane, old_plane_state)) 1388 plane_funcs->atomic_update(plane, old_plane_state); 1389 } 1390 1391 if (crtc_funcs && crtc_funcs->atomic_flush) 1392 crtc_funcs->atomic_flush(crtc, old_crtc_state); 1393 } 1394 EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc); 1395 1396 /** 1397 * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes 1398 * @crtc: CRTC 1399 * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks 1400 * 1401 * Disables all planes associated with the given CRTC. This can be 1402 * used for instance in the CRTC helper disable callback to disable 1403 * all planes before shutting down the display pipeline. 1404 * 1405 * If the atomic-parameter is set the function calls the CRTC's 1406 * atomic_begin hook before and atomic_flush hook after disabling the 1407 * planes. 1408 * 1409 * It is a bug to call this function without having implemented the 1410 * ->atomic_disable() plane hook. 1411 */ 1412 void drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc *crtc, 1413 bool atomic) 1414 { 1415 const struct drm_crtc_helper_funcs *crtc_funcs = 1416 crtc->helper_private; 1417 struct drm_plane *plane; 1418 1419 if (atomic && crtc_funcs && crtc_funcs->atomic_begin) 1420 crtc_funcs->atomic_begin(crtc, NULL); 1421 1422 drm_for_each_plane(plane, crtc->dev) { 1423 const struct drm_plane_helper_funcs *plane_funcs = 1424 plane->helper_private; 1425 1426 if (plane->state->crtc != crtc || !plane_funcs) 1427 continue; 1428 1429 WARN_ON(!plane_funcs->atomic_disable); 1430 if (plane_funcs->atomic_disable) 1431 plane_funcs->atomic_disable(plane, NULL); 1432 } 1433 1434 if (atomic && crtc_funcs && crtc_funcs->atomic_flush) 1435 crtc_funcs->atomic_flush(crtc, NULL); 1436 } 1437 EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc); 1438 1439 /** 1440 * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit 1441 * @dev: DRM device 1442 * @old_state: atomic state object with old state structures 1443 * 1444 * This function cleans up plane state, specifically framebuffers, from the old 1445 * configuration. Hence the old configuration must be perserved in @old_state to 1446 * be able to call this function. 1447 * 1448 * This function must also be called on the new state when the atomic update 1449 * fails at any point after calling drm_atomic_helper_prepare_planes(). 1450 */ 1451 void drm_atomic_helper_cleanup_planes(struct drm_device *dev, 1452 struct drm_atomic_state *old_state) 1453 { 1454 struct drm_plane *plane; 1455 struct drm_plane_state *plane_state; 1456 int i; 1457 1458 for_each_plane_in_state(old_state, plane, plane_state, i) { 1459 const struct drm_plane_helper_funcs *funcs; 1460 1461 funcs = plane->helper_private; 1462 1463 if (funcs->cleanup_fb) 1464 funcs->cleanup_fb(plane, plane_state); 1465 } 1466 } 1467 EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes); 1468 1469 /** 1470 * drm_atomic_helper_swap_state - store atomic state into current sw state 1471 * @dev: DRM device 1472 * @state: atomic state 1473 * 1474 * This function stores the atomic state into the current state pointers in all 1475 * driver objects. It should be called after all failing steps have been done 1476 * and succeeded, but before the actual hardware state is committed. 1477 * 1478 * For cleanup and error recovery the current state for all changed objects will 1479 * be swaped into @state. 1480 * 1481 * With that sequence it fits perfectly into the plane prepare/cleanup sequence: 1482 * 1483 * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state. 1484 * 1485 * 2. Do any other steps that might fail. 1486 * 1487 * 3. Put the staged state into the current state pointers with this function. 1488 * 1489 * 4. Actually commit the hardware state. 1490 * 1491 * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3 1492 * contains the old state. Also do any other cleanup required with that state. 1493 */ 1494 void drm_atomic_helper_swap_state(struct drm_device *dev, 1495 struct drm_atomic_state *state) 1496 { 1497 int i; 1498 1499 for (i = 0; i < dev->mode_config.num_connector; i++) { 1500 struct drm_connector *connector = state->connectors[i]; 1501 1502 if (!connector) 1503 continue; 1504 1505 connector->state->state = state; 1506 swap(state->connector_states[i], connector->state); 1507 connector->state->state = NULL; 1508 } 1509 1510 for (i = 0; i < dev->mode_config.num_crtc; i++) { 1511 struct drm_crtc *crtc = state->crtcs[i]; 1512 1513 if (!crtc) 1514 continue; 1515 1516 crtc->state->state = state; 1517 swap(state->crtc_states[i], crtc->state); 1518 crtc->state->state = NULL; 1519 } 1520 1521 for (i = 0; i < dev->mode_config.num_total_plane; i++) { 1522 struct drm_plane *plane = state->planes[i]; 1523 1524 if (!plane) 1525 continue; 1526 1527 plane->state->state = state; 1528 swap(state->plane_states[i], plane->state); 1529 plane->state->state = NULL; 1530 } 1531 } 1532 EXPORT_SYMBOL(drm_atomic_helper_swap_state); 1533 1534 /** 1535 * drm_atomic_helper_update_plane - Helper for primary plane update using atomic 1536 * @plane: plane object to update 1537 * @crtc: owning CRTC of owning plane 1538 * @fb: framebuffer to flip onto plane 1539 * @crtc_x: x offset of primary plane on crtc 1540 * @crtc_y: y offset of primary plane on crtc 1541 * @crtc_w: width of primary plane rectangle on crtc 1542 * @crtc_h: height of primary plane rectangle on crtc 1543 * @src_x: x offset of @fb for panning 1544 * @src_y: y offset of @fb for panning 1545 * @src_w: width of source rectangle in @fb 1546 * @src_h: height of source rectangle in @fb 1547 * 1548 * Provides a default plane update handler using the atomic driver interface. 1549 * 1550 * RETURNS: 1551 * Zero on success, error code on failure 1552 */ 1553 int drm_atomic_helper_update_plane(struct drm_plane *plane, 1554 struct drm_crtc *crtc, 1555 struct drm_framebuffer *fb, 1556 int crtc_x, int crtc_y, 1557 unsigned int crtc_w, unsigned int crtc_h, 1558 uint32_t src_x, uint32_t src_y, 1559 uint32_t src_w, uint32_t src_h) 1560 { 1561 struct drm_atomic_state *state; 1562 struct drm_plane_state *plane_state; 1563 int ret = 0; 1564 1565 state = drm_atomic_state_alloc(plane->dev); 1566 if (!state) 1567 return -ENOMEM; 1568 1569 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 1570 retry: 1571 plane_state = drm_atomic_get_plane_state(state, plane); 1572 if (IS_ERR(plane_state)) { 1573 ret = PTR_ERR(plane_state); 1574 goto fail; 1575 } 1576 1577 ret = drm_atomic_set_crtc_for_plane(plane_state, crtc); 1578 if (ret != 0) 1579 goto fail; 1580 drm_atomic_set_fb_for_plane(plane_state, fb); 1581 plane_state->crtc_x = crtc_x; 1582 plane_state->crtc_y = crtc_y; 1583 plane_state->crtc_w = crtc_w; 1584 plane_state->crtc_h = crtc_h; 1585 plane_state->src_x = src_x; 1586 plane_state->src_y = src_y; 1587 plane_state->src_w = src_w; 1588 plane_state->src_h = src_h; 1589 1590 if (plane == crtc->cursor) 1591 state->legacy_cursor_update = true; 1592 1593 ret = drm_atomic_commit(state); 1594 if (ret != 0) 1595 goto fail; 1596 1597 /* Driver takes ownership of state on successful commit. */ 1598 return 0; 1599 fail: 1600 if (ret == -EDEADLK) 1601 goto backoff; 1602 1603 drm_atomic_state_free(state); 1604 1605 return ret; 1606 backoff: 1607 drm_atomic_state_clear(state); 1608 drm_atomic_legacy_backoff(state); 1609 1610 /* 1611 * Someone might have exchanged the framebuffer while we dropped locks 1612 * in the backoff code. We need to fix up the fb refcount tracking the 1613 * core does for us. 1614 */ 1615 plane->old_fb = plane->fb; 1616 1617 goto retry; 1618 } 1619 EXPORT_SYMBOL(drm_atomic_helper_update_plane); 1620 1621 /** 1622 * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic 1623 * @plane: plane to disable 1624 * 1625 * Provides a default plane disable handler using the atomic driver interface. 1626 * 1627 * RETURNS: 1628 * Zero on success, error code on failure 1629 */ 1630 int drm_atomic_helper_disable_plane(struct drm_plane *plane) 1631 { 1632 struct drm_atomic_state *state; 1633 struct drm_plane_state *plane_state; 1634 int ret = 0; 1635 1636 /* 1637 * FIXME: Without plane->crtc set we can't get at the implicit legacy 1638 * acquire context. The real fix will be to wire the acquire ctx through 1639 * everywhere we need it, but meanwhile prevent chaos by just skipping 1640 * this noop. The critical case is the cursor ioctls which a) only grab 1641 * crtc/cursor-plane locks (so we need the crtc to get at the right 1642 * acquire context) and b) can try to disable the plane multiple times. 1643 */ 1644 if (!plane->crtc) 1645 return 0; 1646 1647 state = drm_atomic_state_alloc(plane->dev); 1648 if (!state) 1649 return -ENOMEM; 1650 1651 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(plane->crtc); 1652 retry: 1653 plane_state = drm_atomic_get_plane_state(state, plane); 1654 if (IS_ERR(plane_state)) { 1655 ret = PTR_ERR(plane_state); 1656 goto fail; 1657 } 1658 1659 if (plane_state->crtc && (plane == plane->crtc->cursor)) 1660 plane_state->state->legacy_cursor_update = true; 1661 1662 ret = __drm_atomic_helper_disable_plane(plane, plane_state); 1663 if (ret != 0) 1664 goto fail; 1665 1666 ret = drm_atomic_commit(state); 1667 if (ret != 0) 1668 goto fail; 1669 1670 /* Driver takes ownership of state on successful commit. */ 1671 return 0; 1672 fail: 1673 if (ret == -EDEADLK) 1674 goto backoff; 1675 1676 drm_atomic_state_free(state); 1677 1678 return ret; 1679 backoff: 1680 drm_atomic_state_clear(state); 1681 drm_atomic_legacy_backoff(state); 1682 1683 /* 1684 * Someone might have exchanged the framebuffer while we dropped locks 1685 * in the backoff code. We need to fix up the fb refcount tracking the 1686 * core does for us. 1687 */ 1688 plane->old_fb = plane->fb; 1689 1690 goto retry; 1691 } 1692 EXPORT_SYMBOL(drm_atomic_helper_disable_plane); 1693 1694 /* just used from fb-helper and atomic-helper: */ 1695 int __drm_atomic_helper_disable_plane(struct drm_plane *plane, 1696 struct drm_plane_state *plane_state) 1697 { 1698 int ret; 1699 1700 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL); 1701 if (ret != 0) 1702 return ret; 1703 1704 drm_atomic_set_fb_for_plane(plane_state, NULL); 1705 plane_state->crtc_x = 0; 1706 plane_state->crtc_y = 0; 1707 plane_state->crtc_w = 0; 1708 plane_state->crtc_h = 0; 1709 plane_state->src_x = 0; 1710 plane_state->src_y = 0; 1711 plane_state->src_w = 0; 1712 plane_state->src_h = 0; 1713 1714 return 0; 1715 } 1716 1717 static int update_output_state(struct drm_atomic_state *state, 1718 struct drm_mode_set *set) 1719 { 1720 struct drm_device *dev = set->crtc->dev; 1721 struct drm_crtc *crtc; 1722 struct drm_crtc_state *crtc_state; 1723 struct drm_connector *connector; 1724 struct drm_connector_state *conn_state; 1725 int ret, i, j; 1726 1727 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, 1728 state->acquire_ctx); 1729 if (ret) 1730 return ret; 1731 1732 /* First grab all affected connector/crtc states. */ 1733 for (i = 0; i < set->num_connectors; i++) { 1734 conn_state = drm_atomic_get_connector_state(state, 1735 set->connectors[i]); 1736 if (IS_ERR(conn_state)) 1737 return PTR_ERR(conn_state); 1738 } 1739 1740 for_each_crtc_in_state(state, crtc, crtc_state, i) { 1741 ret = drm_atomic_add_affected_connectors(state, crtc); 1742 if (ret) 1743 return ret; 1744 } 1745 1746 /* Then recompute connector->crtc links and crtc enabling state. */ 1747 for_each_connector_in_state(state, connector, conn_state, i) { 1748 if (conn_state->crtc == set->crtc) { 1749 ret = drm_atomic_set_crtc_for_connector(conn_state, 1750 NULL); 1751 if (ret) 1752 return ret; 1753 } 1754 1755 for (j = 0; j < set->num_connectors; j++) { 1756 if (set->connectors[j] == connector) { 1757 ret = drm_atomic_set_crtc_for_connector(conn_state, 1758 set->crtc); 1759 if (ret) 1760 return ret; 1761 break; 1762 } 1763 } 1764 } 1765 1766 for_each_crtc_in_state(state, crtc, crtc_state, i) { 1767 /* Don't update ->enable for the CRTC in the set_config request, 1768 * since a mismatch would indicate a bug in the upper layers. 1769 * The actual modeset code later on will catch any 1770 * inconsistencies here. */ 1771 if (crtc == set->crtc) 1772 continue; 1773 1774 if (!crtc_state->connector_mask) { 1775 ret = drm_atomic_set_mode_prop_for_crtc(crtc_state, 1776 NULL); 1777 if (ret < 0) 1778 return ret; 1779 1780 crtc_state->active = false; 1781 } 1782 } 1783 1784 return 0; 1785 } 1786 1787 /** 1788 * drm_atomic_helper_set_config - set a new config from userspace 1789 * @set: mode set configuration 1790 * 1791 * Provides a default crtc set_config handler using the atomic driver interface. 1792 * 1793 * Returns: 1794 * Returns 0 on success, negative errno numbers on failure. 1795 */ 1796 int drm_atomic_helper_set_config(struct drm_mode_set *set) 1797 { 1798 struct drm_atomic_state *state; 1799 struct drm_crtc *crtc = set->crtc; 1800 int ret = 0; 1801 1802 state = drm_atomic_state_alloc(crtc->dev); 1803 if (!state) 1804 return -ENOMEM; 1805 1806 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 1807 retry: 1808 ret = __drm_atomic_helper_set_config(set, state); 1809 if (ret != 0) 1810 goto fail; 1811 1812 ret = drm_atomic_commit(state); 1813 if (ret != 0) 1814 goto fail; 1815 1816 /* Driver takes ownership of state on successful commit. */ 1817 return 0; 1818 fail: 1819 if (ret == -EDEADLK) 1820 goto backoff; 1821 1822 drm_atomic_state_free(state); 1823 1824 return ret; 1825 backoff: 1826 drm_atomic_state_clear(state); 1827 drm_atomic_legacy_backoff(state); 1828 1829 /* 1830 * Someone might have exchanged the framebuffer while we dropped locks 1831 * in the backoff code. We need to fix up the fb refcount tracking the 1832 * core does for us. 1833 */ 1834 crtc->primary->old_fb = crtc->primary->fb; 1835 1836 goto retry; 1837 } 1838 EXPORT_SYMBOL(drm_atomic_helper_set_config); 1839 1840 /* just used from fb-helper and atomic-helper: */ 1841 int __drm_atomic_helper_set_config(struct drm_mode_set *set, 1842 struct drm_atomic_state *state) 1843 { 1844 struct drm_crtc_state *crtc_state; 1845 struct drm_plane_state *primary_state; 1846 struct drm_crtc *crtc = set->crtc; 1847 int hdisplay, vdisplay; 1848 int ret; 1849 1850 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1851 if (IS_ERR(crtc_state)) 1852 return PTR_ERR(crtc_state); 1853 1854 primary_state = drm_atomic_get_plane_state(state, crtc->primary); 1855 if (IS_ERR(primary_state)) 1856 return PTR_ERR(primary_state); 1857 1858 if (!set->mode) { 1859 WARN_ON(set->fb); 1860 WARN_ON(set->num_connectors); 1861 1862 ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL); 1863 if (ret != 0) 1864 return ret; 1865 1866 crtc_state->active = false; 1867 1868 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL); 1869 if (ret != 0) 1870 return ret; 1871 1872 drm_atomic_set_fb_for_plane(primary_state, NULL); 1873 1874 goto commit; 1875 } 1876 1877 WARN_ON(!set->fb); 1878 WARN_ON(!set->num_connectors); 1879 1880 ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode); 1881 if (ret != 0) 1882 return ret; 1883 1884 crtc_state->active = true; 1885 1886 ret = drm_atomic_set_crtc_for_plane(primary_state, crtc); 1887 if (ret != 0) 1888 return ret; 1889 1890 drm_crtc_get_hv_timing(set->mode, &hdisplay, &vdisplay); 1891 1892 drm_atomic_set_fb_for_plane(primary_state, set->fb); 1893 primary_state->crtc_x = 0; 1894 primary_state->crtc_y = 0; 1895 primary_state->crtc_w = hdisplay; 1896 primary_state->crtc_h = vdisplay; 1897 primary_state->src_x = set->x << 16; 1898 primary_state->src_y = set->y << 16; 1899 if (primary_state->rotation & (BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_270))) { 1900 primary_state->src_w = vdisplay << 16; 1901 primary_state->src_h = hdisplay << 16; 1902 } else { 1903 primary_state->src_w = hdisplay << 16; 1904 primary_state->src_h = vdisplay << 16; 1905 } 1906 1907 commit: 1908 ret = update_output_state(state, set); 1909 if (ret) 1910 return ret; 1911 1912 return 0; 1913 } 1914 1915 /** 1916 * drm_atomic_helper_disable_all - disable all currently active outputs 1917 * @dev: DRM device 1918 * @ctx: lock acquisition context 1919 * 1920 * Loops through all connectors, finding those that aren't turned off and then 1921 * turns them off by setting their DPMS mode to OFF and deactivating the CRTC 1922 * that they are connected to. 1923 * 1924 * This is used for example in suspend/resume to disable all currently active 1925 * functions when suspending. 1926 * 1927 * Note that if callers haven't already acquired all modeset locks this might 1928 * return -EDEADLK, which must be handled by calling drm_modeset_backoff(). 1929 * 1930 * Returns: 1931 * 0 on success or a negative error code on failure. 1932 * 1933 * See also: 1934 * drm_atomic_helper_suspend(), drm_atomic_helper_resume() 1935 */ 1936 int drm_atomic_helper_disable_all(struct drm_device *dev, 1937 struct drm_modeset_acquire_ctx *ctx) 1938 { 1939 struct drm_atomic_state *state; 1940 struct drm_connector *conn; 1941 int err; 1942 1943 state = drm_atomic_state_alloc(dev); 1944 if (!state) 1945 return -ENOMEM; 1946 1947 state->acquire_ctx = ctx; 1948 1949 drm_for_each_connector(conn, dev) { 1950 struct drm_crtc *crtc = conn->state->crtc; 1951 struct drm_crtc_state *crtc_state; 1952 1953 if (!crtc || conn->dpms != DRM_MODE_DPMS_ON) 1954 continue; 1955 1956 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1957 if (IS_ERR(crtc_state)) { 1958 err = PTR_ERR(crtc_state); 1959 goto free; 1960 } 1961 1962 crtc_state->active = false; 1963 } 1964 1965 err = drm_atomic_commit(state); 1966 1967 free: 1968 if (err < 0) 1969 drm_atomic_state_free(state); 1970 1971 return err; 1972 } 1973 EXPORT_SYMBOL(drm_atomic_helper_disable_all); 1974 1975 /** 1976 * drm_atomic_helper_suspend - subsystem-level suspend helper 1977 * @dev: DRM device 1978 * 1979 * Duplicates the current atomic state, disables all active outputs and then 1980 * returns a pointer to the original atomic state to the caller. Drivers can 1981 * pass this pointer to the drm_atomic_helper_resume() helper upon resume to 1982 * restore the output configuration that was active at the time the system 1983 * entered suspend. 1984 * 1985 * Note that it is potentially unsafe to use this. The atomic state object 1986 * returned by this function is assumed to be persistent. Drivers must ensure 1987 * that this holds true. Before calling this function, drivers must make sure 1988 * to suspend fbdev emulation so that nothing can be using the device. 1989 * 1990 * Returns: 1991 * A pointer to a copy of the state before suspend on success or an ERR_PTR()- 1992 * encoded error code on failure. Drivers should store the returned atomic 1993 * state object and pass it to the drm_atomic_helper_resume() helper upon 1994 * resume. 1995 * 1996 * See also: 1997 * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(), 1998 * drm_atomic_helper_resume() 1999 */ 2000 struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev) 2001 { 2002 struct drm_modeset_acquire_ctx ctx; 2003 struct drm_atomic_state *state; 2004 int err; 2005 2006 drm_modeset_acquire_init(&ctx, 0); 2007 2008 retry: 2009 err = drm_modeset_lock_all_ctx(dev, &ctx); 2010 if (err < 0) { 2011 state = ERR_PTR(err); 2012 goto unlock; 2013 } 2014 2015 state = drm_atomic_helper_duplicate_state(dev, &ctx); 2016 if (IS_ERR(state)) 2017 goto unlock; 2018 2019 err = drm_atomic_helper_disable_all(dev, &ctx); 2020 if (err < 0) { 2021 drm_atomic_state_free(state); 2022 state = ERR_PTR(err); 2023 goto unlock; 2024 } 2025 2026 unlock: 2027 if (PTR_ERR(state) == -EDEADLK) { 2028 drm_modeset_backoff(&ctx); 2029 goto retry; 2030 } 2031 2032 drm_modeset_drop_locks(&ctx); 2033 drm_modeset_acquire_fini(&ctx); 2034 return state; 2035 } 2036 EXPORT_SYMBOL(drm_atomic_helper_suspend); 2037 2038 /** 2039 * drm_atomic_helper_resume - subsystem-level resume helper 2040 * @dev: DRM device 2041 * @state: atomic state to resume to 2042 * 2043 * Calls drm_mode_config_reset() to synchronize hardware and software states, 2044 * grabs all modeset locks and commits the atomic state object. This can be 2045 * used in conjunction with the drm_atomic_helper_suspend() helper to 2046 * implement suspend/resume for drivers that support atomic mode-setting. 2047 * 2048 * Returns: 2049 * 0 on success or a negative error code on failure. 2050 * 2051 * See also: 2052 * drm_atomic_helper_suspend() 2053 */ 2054 int drm_atomic_helper_resume(struct drm_device *dev, 2055 struct drm_atomic_state *state) 2056 { 2057 struct drm_mode_config *config = &dev->mode_config; 2058 int err; 2059 2060 drm_mode_config_reset(dev); 2061 drm_modeset_lock_all(dev); 2062 state->acquire_ctx = config->acquire_ctx; 2063 err = drm_atomic_commit(state); 2064 drm_modeset_unlock_all(dev); 2065 2066 return err; 2067 } 2068 EXPORT_SYMBOL(drm_atomic_helper_resume); 2069 2070 /** 2071 * drm_atomic_helper_crtc_set_property - helper for crtc properties 2072 * @crtc: DRM crtc 2073 * @property: DRM property 2074 * @val: value of property 2075 * 2076 * Provides a default crtc set_property handler using the atomic driver 2077 * interface. 2078 * 2079 * RETURNS: 2080 * Zero on success, error code on failure 2081 */ 2082 int 2083 drm_atomic_helper_crtc_set_property(struct drm_crtc *crtc, 2084 struct drm_property *property, 2085 uint64_t val) 2086 { 2087 struct drm_atomic_state *state; 2088 struct drm_crtc_state *crtc_state; 2089 int ret = 0; 2090 2091 state = drm_atomic_state_alloc(crtc->dev); 2092 if (!state) 2093 return -ENOMEM; 2094 2095 /* ->set_property is always called with all locks held. */ 2096 state->acquire_ctx = crtc->dev->mode_config.acquire_ctx; 2097 retry: 2098 crtc_state = drm_atomic_get_crtc_state(state, crtc); 2099 if (IS_ERR(crtc_state)) { 2100 ret = PTR_ERR(crtc_state); 2101 goto fail; 2102 } 2103 2104 ret = drm_atomic_crtc_set_property(crtc, crtc_state, 2105 property, val); 2106 if (ret) 2107 goto fail; 2108 2109 ret = drm_atomic_commit(state); 2110 if (ret != 0) 2111 goto fail; 2112 2113 /* Driver takes ownership of state on successful commit. */ 2114 return 0; 2115 fail: 2116 if (ret == -EDEADLK) 2117 goto backoff; 2118 2119 drm_atomic_state_free(state); 2120 2121 return ret; 2122 backoff: 2123 drm_atomic_state_clear(state); 2124 drm_atomic_legacy_backoff(state); 2125 2126 goto retry; 2127 } 2128 EXPORT_SYMBOL(drm_atomic_helper_crtc_set_property); 2129 2130 /** 2131 * drm_atomic_helper_plane_set_property - helper for plane properties 2132 * @plane: DRM plane 2133 * @property: DRM property 2134 * @val: value of property 2135 * 2136 * Provides a default plane set_property handler using the atomic driver 2137 * interface. 2138 * 2139 * RETURNS: 2140 * Zero on success, error code on failure 2141 */ 2142 int 2143 drm_atomic_helper_plane_set_property(struct drm_plane *plane, 2144 struct drm_property *property, 2145 uint64_t val) 2146 { 2147 struct drm_atomic_state *state; 2148 struct drm_plane_state *plane_state; 2149 int ret = 0; 2150 2151 state = drm_atomic_state_alloc(plane->dev); 2152 if (!state) 2153 return -ENOMEM; 2154 2155 /* ->set_property is always called with all locks held. */ 2156 state->acquire_ctx = plane->dev->mode_config.acquire_ctx; 2157 retry: 2158 plane_state = drm_atomic_get_plane_state(state, plane); 2159 if (IS_ERR(plane_state)) { 2160 ret = PTR_ERR(plane_state); 2161 goto fail; 2162 } 2163 2164 ret = drm_atomic_plane_set_property(plane, plane_state, 2165 property, val); 2166 if (ret) 2167 goto fail; 2168 2169 ret = drm_atomic_commit(state); 2170 if (ret != 0) 2171 goto fail; 2172 2173 /* Driver takes ownership of state on successful commit. */ 2174 return 0; 2175 fail: 2176 if (ret == -EDEADLK) 2177 goto backoff; 2178 2179 drm_atomic_state_free(state); 2180 2181 return ret; 2182 backoff: 2183 drm_atomic_state_clear(state); 2184 drm_atomic_legacy_backoff(state); 2185 2186 goto retry; 2187 } 2188 EXPORT_SYMBOL(drm_atomic_helper_plane_set_property); 2189 2190 /** 2191 * drm_atomic_helper_connector_set_property - helper for connector properties 2192 * @connector: DRM connector 2193 * @property: DRM property 2194 * @val: value of property 2195 * 2196 * Provides a default connector set_property handler using the atomic driver 2197 * interface. 2198 * 2199 * RETURNS: 2200 * Zero on success, error code on failure 2201 */ 2202 int 2203 drm_atomic_helper_connector_set_property(struct drm_connector *connector, 2204 struct drm_property *property, 2205 uint64_t val) 2206 { 2207 struct drm_atomic_state *state; 2208 struct drm_connector_state *connector_state; 2209 int ret = 0; 2210 2211 state = drm_atomic_state_alloc(connector->dev); 2212 if (!state) 2213 return -ENOMEM; 2214 2215 /* ->set_property is always called with all locks held. */ 2216 state->acquire_ctx = connector->dev->mode_config.acquire_ctx; 2217 retry: 2218 connector_state = drm_atomic_get_connector_state(state, connector); 2219 if (IS_ERR(connector_state)) { 2220 ret = PTR_ERR(connector_state); 2221 goto fail; 2222 } 2223 2224 ret = drm_atomic_connector_set_property(connector, connector_state, 2225 property, val); 2226 if (ret) 2227 goto fail; 2228 2229 ret = drm_atomic_commit(state); 2230 if (ret != 0) 2231 goto fail; 2232 2233 /* Driver takes ownership of state on successful commit. */ 2234 return 0; 2235 fail: 2236 if (ret == -EDEADLK) 2237 goto backoff; 2238 2239 drm_atomic_state_free(state); 2240 2241 return ret; 2242 backoff: 2243 drm_atomic_state_clear(state); 2244 drm_atomic_legacy_backoff(state); 2245 2246 goto retry; 2247 } 2248 EXPORT_SYMBOL(drm_atomic_helper_connector_set_property); 2249 2250 /** 2251 * drm_atomic_helper_page_flip - execute a legacy page flip 2252 * @crtc: DRM crtc 2253 * @fb: DRM framebuffer 2254 * @event: optional DRM event to signal upon completion 2255 * @flags: flip flags for non-vblank sync'ed updates 2256 * 2257 * Provides a default page flip implementation using the atomic driver interface. 2258 * 2259 * Note that for now so called async page flips (i.e. updates which are not 2260 * synchronized to vblank) are not supported, since the atomic interfaces have 2261 * no provisions for this yet. 2262 * 2263 * Returns: 2264 * Returns 0 on success, negative errno numbers on failure. 2265 */ 2266 int drm_atomic_helper_page_flip(struct drm_crtc *crtc, 2267 struct drm_framebuffer *fb, 2268 struct drm_pending_vblank_event *event, 2269 uint32_t flags) 2270 { 2271 struct drm_plane *plane = crtc->primary; 2272 struct drm_atomic_state *state; 2273 struct drm_plane_state *plane_state; 2274 struct drm_crtc_state *crtc_state; 2275 int ret = 0; 2276 2277 if (flags & DRM_MODE_PAGE_FLIP_ASYNC) 2278 return -EINVAL; 2279 2280 state = drm_atomic_state_alloc(plane->dev); 2281 if (!state) 2282 return -ENOMEM; 2283 2284 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 2285 retry: 2286 crtc_state = drm_atomic_get_crtc_state(state, crtc); 2287 if (IS_ERR(crtc_state)) { 2288 ret = PTR_ERR(crtc_state); 2289 goto fail; 2290 } 2291 crtc_state->event = event; 2292 2293 plane_state = drm_atomic_get_plane_state(state, plane); 2294 if (IS_ERR(plane_state)) { 2295 ret = PTR_ERR(plane_state); 2296 goto fail; 2297 } 2298 2299 ret = drm_atomic_set_crtc_for_plane(plane_state, crtc); 2300 if (ret != 0) 2301 goto fail; 2302 drm_atomic_set_fb_for_plane(plane_state, fb); 2303 2304 /* Make sure we don't accidentally do a full modeset. */ 2305 state->allow_modeset = false; 2306 if (!crtc_state->active) { 2307 DRM_DEBUG_ATOMIC("[CRTC:%d] disabled, rejecting legacy flip\n", 2308 crtc->base.id); 2309 ret = -EINVAL; 2310 goto fail; 2311 } 2312 2313 ret = drm_atomic_async_commit(state); 2314 if (ret != 0) 2315 goto fail; 2316 2317 /* Driver takes ownership of state on successful async commit. */ 2318 return 0; 2319 fail: 2320 if (ret == -EDEADLK) 2321 goto backoff; 2322 2323 drm_atomic_state_free(state); 2324 2325 return ret; 2326 backoff: 2327 drm_atomic_state_clear(state); 2328 drm_atomic_legacy_backoff(state); 2329 2330 /* 2331 * Someone might have exchanged the framebuffer while we dropped locks 2332 * in the backoff code. We need to fix up the fb refcount tracking the 2333 * core does for us. 2334 */ 2335 plane->old_fb = plane->fb; 2336 2337 goto retry; 2338 } 2339 EXPORT_SYMBOL(drm_atomic_helper_page_flip); 2340 2341 /** 2342 * drm_atomic_helper_connector_dpms() - connector dpms helper implementation 2343 * @connector: affected connector 2344 * @mode: DPMS mode 2345 * 2346 * This is the main helper function provided by the atomic helper framework for 2347 * implementing the legacy DPMS connector interface. It computes the new desired 2348 * ->active state for the corresponding CRTC (if the connector is enabled) and 2349 * updates it. 2350 * 2351 * Returns: 2352 * Returns 0 on success, negative errno numbers on failure. 2353 */ 2354 int drm_atomic_helper_connector_dpms(struct drm_connector *connector, 2355 int mode) 2356 { 2357 struct drm_mode_config *config = &connector->dev->mode_config; 2358 struct drm_atomic_state *state; 2359 struct drm_crtc_state *crtc_state; 2360 struct drm_crtc *crtc; 2361 struct drm_connector *tmp_connector; 2362 int ret; 2363 bool active = false; 2364 int old_mode = connector->dpms; 2365 2366 if (mode != DRM_MODE_DPMS_ON) 2367 mode = DRM_MODE_DPMS_OFF; 2368 2369 connector->dpms = mode; 2370 crtc = connector->state->crtc; 2371 2372 if (!crtc) 2373 return 0; 2374 2375 state = drm_atomic_state_alloc(connector->dev); 2376 if (!state) 2377 return -ENOMEM; 2378 2379 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 2380 retry: 2381 crtc_state = drm_atomic_get_crtc_state(state, crtc); 2382 if (IS_ERR(crtc_state)) { 2383 ret = PTR_ERR(crtc_state); 2384 goto fail; 2385 } 2386 2387 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); 2388 2389 drm_for_each_connector(tmp_connector, connector->dev) { 2390 if (tmp_connector->state->crtc != crtc) 2391 continue; 2392 2393 if (tmp_connector->dpms == DRM_MODE_DPMS_ON) { 2394 active = true; 2395 break; 2396 } 2397 } 2398 crtc_state->active = active; 2399 2400 ret = drm_atomic_commit(state); 2401 if (ret != 0) 2402 goto fail; 2403 2404 /* Driver takes ownership of state on successful commit. */ 2405 return 0; 2406 fail: 2407 if (ret == -EDEADLK) 2408 goto backoff; 2409 2410 connector->dpms = old_mode; 2411 drm_atomic_state_free(state); 2412 2413 return ret; 2414 backoff: 2415 drm_atomic_state_clear(state); 2416 drm_atomic_legacy_backoff(state); 2417 2418 goto retry; 2419 } 2420 EXPORT_SYMBOL(drm_atomic_helper_connector_dpms); 2421 2422 /** 2423 * DOC: atomic state reset and initialization 2424 * 2425 * Both the drm core and the atomic helpers assume that there is always the full 2426 * and correct atomic software state for all connectors, CRTCs and planes 2427 * available. Which is a bit a problem on driver load and also after system 2428 * suspend. One way to solve this is to have a hardware state read-out 2429 * infrastructure which reconstructs the full software state (e.g. the i915 2430 * driver). 2431 * 2432 * The simpler solution is to just reset the software state to everything off, 2433 * which is easiest to do by calling drm_mode_config_reset(). To facilitate this 2434 * the atomic helpers provide default reset implementations for all hooks. 2435 * 2436 * On the upside the precise state tracking of atomic simplifies system suspend 2437 * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe 2438 * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume(). 2439 * For other drivers the building blocks are split out, see the documentation 2440 * for these functions. 2441 */ 2442 2443 /** 2444 * drm_atomic_helper_crtc_reset - default ->reset hook for CRTCs 2445 * @crtc: drm CRTC 2446 * 2447 * Resets the atomic state for @crtc by freeing the state pointer (which might 2448 * be NULL, e.g. at driver load time) and allocating a new empty state object. 2449 */ 2450 void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc) 2451 { 2452 if (crtc->state) 2453 drm_property_unreference_blob(crtc->state->mode_blob); 2454 kfree(crtc->state); 2455 crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL); 2456 2457 if (crtc->state) 2458 crtc->state->crtc = crtc; 2459 } 2460 EXPORT_SYMBOL(drm_atomic_helper_crtc_reset); 2461 2462 /** 2463 * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state 2464 * @crtc: CRTC object 2465 * @state: atomic CRTC state 2466 * 2467 * Copies atomic state from a CRTC's current state and resets inferred values. 2468 * This is useful for drivers that subclass the CRTC state. 2469 */ 2470 void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc, 2471 struct drm_crtc_state *state) 2472 { 2473 memcpy(state, crtc->state, sizeof(*state)); 2474 2475 if (state->mode_blob) 2476 drm_property_reference_blob(state->mode_blob); 2477 state->mode_changed = false; 2478 state->active_changed = false; 2479 state->planes_changed = false; 2480 state->connectors_changed = false; 2481 state->event = NULL; 2482 } 2483 EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state); 2484 2485 /** 2486 * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook 2487 * @crtc: drm CRTC 2488 * 2489 * Default CRTC state duplicate hook for drivers which don't have their own 2490 * subclassed CRTC state structure. 2491 */ 2492 struct drm_crtc_state * 2493 drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc) 2494 { 2495 struct drm_crtc_state *state; 2496 2497 if (WARN_ON(!crtc->state)) 2498 return NULL; 2499 2500 state = kmalloc(sizeof(*state), M_DRM, M_WAITOK); 2501 if (state) 2502 __drm_atomic_helper_crtc_duplicate_state(crtc, state); 2503 2504 return state; 2505 } 2506 EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state); 2507 2508 /** 2509 * __drm_atomic_helper_crtc_destroy_state - release CRTC state 2510 * @crtc: CRTC object 2511 * @state: CRTC state object to release 2512 * 2513 * Releases all resources stored in the CRTC state without actually freeing 2514 * the memory of the CRTC state. This is useful for drivers that subclass the 2515 * CRTC state. 2516 */ 2517 void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc, 2518 struct drm_crtc_state *state) 2519 { 2520 drm_property_unreference_blob(state->mode_blob); 2521 } 2522 EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state); 2523 2524 /** 2525 * drm_atomic_helper_crtc_destroy_state - default state destroy hook 2526 * @crtc: drm CRTC 2527 * @state: CRTC state object to release 2528 * 2529 * Default CRTC state destroy hook for drivers which don't have their own 2530 * subclassed CRTC state structure. 2531 */ 2532 void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc, 2533 struct drm_crtc_state *state) 2534 { 2535 __drm_atomic_helper_crtc_destroy_state(crtc, state); 2536 kfree(state); 2537 } 2538 EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state); 2539 2540 /** 2541 * drm_atomic_helper_plane_reset - default ->reset hook for planes 2542 * @plane: drm plane 2543 * 2544 * Resets the atomic state for @plane by freeing the state pointer (which might 2545 * be NULL, e.g. at driver load time) and allocating a new empty state object. 2546 */ 2547 void drm_atomic_helper_plane_reset(struct drm_plane *plane) 2548 { 2549 if (plane->state && plane->state->fb) 2550 drm_framebuffer_unreference(plane->state->fb); 2551 2552 kfree(plane->state); 2553 plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL); 2554 2555 if (plane->state) 2556 plane->state->plane = plane; 2557 } 2558 EXPORT_SYMBOL(drm_atomic_helper_plane_reset); 2559 2560 /** 2561 * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state 2562 * @plane: plane object 2563 * @state: atomic plane state 2564 * 2565 * Copies atomic state from a plane's current state. This is useful for 2566 * drivers that subclass the plane state. 2567 */ 2568 void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane, 2569 struct drm_plane_state *state) 2570 { 2571 memcpy(state, plane->state, sizeof(*state)); 2572 2573 if (state->fb) 2574 drm_framebuffer_reference(state->fb); 2575 } 2576 EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state); 2577 2578 /** 2579 * drm_atomic_helper_plane_duplicate_state - default state duplicate hook 2580 * @plane: drm plane 2581 * 2582 * Default plane state duplicate hook for drivers which don't have their own 2583 * subclassed plane state structure. 2584 */ 2585 struct drm_plane_state * 2586 drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane) 2587 { 2588 struct drm_plane_state *state; 2589 2590 if (WARN_ON(!plane->state)) 2591 return NULL; 2592 2593 state = kmalloc(sizeof(*state), M_DRM, M_WAITOK); 2594 if (state) 2595 __drm_atomic_helper_plane_duplicate_state(plane, state); 2596 2597 return state; 2598 } 2599 EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state); 2600 2601 /** 2602 * __drm_atomic_helper_plane_destroy_state - release plane state 2603 * @plane: plane object 2604 * @state: plane state object to release 2605 * 2606 * Releases all resources stored in the plane state without actually freeing 2607 * the memory of the plane state. This is useful for drivers that subclass the 2608 * plane state. 2609 */ 2610 void __drm_atomic_helper_plane_destroy_state(struct drm_plane *plane, 2611 struct drm_plane_state *state) 2612 { 2613 if (state->fb) 2614 drm_framebuffer_unreference(state->fb); 2615 } 2616 EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state); 2617 2618 /** 2619 * drm_atomic_helper_plane_destroy_state - default state destroy hook 2620 * @plane: drm plane 2621 * @state: plane state object to release 2622 * 2623 * Default plane state destroy hook for drivers which don't have their own 2624 * subclassed plane state structure. 2625 */ 2626 void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane, 2627 struct drm_plane_state *state) 2628 { 2629 __drm_atomic_helper_plane_destroy_state(plane, state); 2630 kfree(state); 2631 } 2632 EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state); 2633 2634 /** 2635 * __drm_atomic_helper_connector_reset - reset state on connector 2636 * @connector: drm connector 2637 * @conn_state: connector state to assign 2638 * 2639 * Initializes the newly allocated @conn_state and assigns it to 2640 * #connector ->state, usually required when initializing the drivers 2641 * or when called from the ->reset hook. 2642 * 2643 * This is useful for drivers that subclass the connector state. 2644 */ 2645 void 2646 __drm_atomic_helper_connector_reset(struct drm_connector *connector, 2647 struct drm_connector_state *conn_state) 2648 { 2649 if (conn_state) 2650 conn_state->connector = connector; 2651 2652 connector->state = conn_state; 2653 } 2654 EXPORT_SYMBOL(__drm_atomic_helper_connector_reset); 2655 2656 /** 2657 * drm_atomic_helper_connector_reset - default ->reset hook for connectors 2658 * @connector: drm connector 2659 * 2660 * Resets the atomic state for @connector by freeing the state pointer (which 2661 * might be NULL, e.g. at driver load time) and allocating a new empty state 2662 * object. 2663 */ 2664 void drm_atomic_helper_connector_reset(struct drm_connector *connector) 2665 { 2666 struct drm_connector_state *conn_state = 2667 kzalloc(sizeof(*conn_state), GFP_KERNEL); 2668 2669 kfree(connector->state); 2670 __drm_atomic_helper_connector_reset(connector, conn_state); 2671 } 2672 EXPORT_SYMBOL(drm_atomic_helper_connector_reset); 2673 2674 /** 2675 * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state 2676 * @connector: connector object 2677 * @state: atomic connector state 2678 * 2679 * Copies atomic state from a connector's current state. This is useful for 2680 * drivers that subclass the connector state. 2681 */ 2682 void 2683 __drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector, 2684 struct drm_connector_state *state) 2685 { 2686 memcpy(state, connector->state, sizeof(*state)); 2687 } 2688 EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state); 2689 2690 /** 2691 * drm_atomic_helper_connector_duplicate_state - default state duplicate hook 2692 * @connector: drm connector 2693 * 2694 * Default connector state duplicate hook for drivers which don't have their own 2695 * subclassed connector state structure. 2696 */ 2697 struct drm_connector_state * 2698 drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector) 2699 { 2700 struct drm_connector_state *state; 2701 2702 if (WARN_ON(!connector->state)) 2703 return NULL; 2704 2705 state = kmalloc(sizeof(*state), M_DRM, M_WAITOK); 2706 if (state) 2707 __drm_atomic_helper_connector_duplicate_state(connector, state); 2708 2709 return state; 2710 } 2711 EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state); 2712 2713 /** 2714 * drm_atomic_helper_duplicate_state - duplicate an atomic state object 2715 * @dev: DRM device 2716 * @ctx: lock acquisition context 2717 * 2718 * Makes a copy of the current atomic state by looping over all objects and 2719 * duplicating their respective states. This is used for example by suspend/ 2720 * resume support code to save the state prior to suspend such that it can 2721 * be restored upon resume. 2722 * 2723 * Note that this treats atomic state as persistent between save and restore. 2724 * Drivers must make sure that this is possible and won't result in confusion 2725 * or erroneous behaviour. 2726 * 2727 * Note that if callers haven't already acquired all modeset locks this might 2728 * return -EDEADLK, which must be handled by calling drm_modeset_backoff(). 2729 * 2730 * Returns: 2731 * A pointer to the copy of the atomic state object on success or an 2732 * ERR_PTR()-encoded error code on failure. 2733 * 2734 * See also: 2735 * drm_atomic_helper_suspend(), drm_atomic_helper_resume() 2736 */ 2737 struct drm_atomic_state * 2738 drm_atomic_helper_duplicate_state(struct drm_device *dev, 2739 struct drm_modeset_acquire_ctx *ctx) 2740 { 2741 struct drm_atomic_state *state; 2742 struct drm_connector *conn; 2743 struct drm_plane *plane; 2744 struct drm_crtc *crtc; 2745 int err = 0; 2746 2747 state = drm_atomic_state_alloc(dev); 2748 if (!state) 2749 return ERR_PTR(-ENOMEM); 2750 2751 state->acquire_ctx = ctx; 2752 2753 drm_for_each_crtc(crtc, dev) { 2754 struct drm_crtc_state *crtc_state; 2755 2756 crtc_state = drm_atomic_get_crtc_state(state, crtc); 2757 if (IS_ERR(crtc_state)) { 2758 err = PTR_ERR(crtc_state); 2759 goto free; 2760 } 2761 } 2762 2763 drm_for_each_plane(plane, dev) { 2764 struct drm_plane_state *plane_state; 2765 2766 plane_state = drm_atomic_get_plane_state(state, plane); 2767 if (IS_ERR(plane_state)) { 2768 err = PTR_ERR(plane_state); 2769 goto free; 2770 } 2771 } 2772 2773 drm_for_each_connector(conn, dev) { 2774 struct drm_connector_state *conn_state; 2775 2776 conn_state = drm_atomic_get_connector_state(state, conn); 2777 if (IS_ERR(conn_state)) { 2778 err = PTR_ERR(conn_state); 2779 goto free; 2780 } 2781 } 2782 2783 /* clear the acquire context so that it isn't accidentally reused */ 2784 state->acquire_ctx = NULL; 2785 2786 free: 2787 if (err < 0) { 2788 drm_atomic_state_free(state); 2789 state = ERR_PTR(err); 2790 } 2791 2792 return state; 2793 } 2794 EXPORT_SYMBOL(drm_atomic_helper_duplicate_state); 2795 2796 /** 2797 * __drm_atomic_helper_connector_destroy_state - release connector state 2798 * @connector: connector object 2799 * @state: connector state object to release 2800 * 2801 * Releases all resources stored in the connector state without actually 2802 * freeing the memory of the connector state. This is useful for drivers that 2803 * subclass the connector state. 2804 */ 2805 void 2806 __drm_atomic_helper_connector_destroy_state(struct drm_connector *connector, 2807 struct drm_connector_state *state) 2808 { 2809 /* 2810 * This is currently a placeholder so that drivers that subclass the 2811 * state will automatically do the right thing if code is ever added 2812 * to this function. 2813 */ 2814 } 2815 EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state); 2816 2817 /** 2818 * drm_atomic_helper_connector_destroy_state - default state destroy hook 2819 * @connector: drm connector 2820 * @state: connector state object to release 2821 * 2822 * Default connector state destroy hook for drivers which don't have their own 2823 * subclassed connector state structure. 2824 */ 2825 void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector, 2826 struct drm_connector_state *state) 2827 { 2828 __drm_atomic_helper_connector_destroy_state(connector, state); 2829 kfree(state); 2830 } 2831 EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state); 2832