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