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