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