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