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 bool 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 spin_lock(&crtc->commit_lock); 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 spin_unlock(&crtc->commit_lock); 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 spin_unlock(&crtc->commit_lock); 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 /** 1393 * drm_atomic_helper_setup_commit - setup possibly nonblocking commit 1394 * @state: new modeset state to be committed 1395 * @nonblock: whether nonblocking behavior is requested. 1396 * 1397 * This function prepares @state to be used by the atomic helper's support for 1398 * nonblocking commits. Drivers using the nonblocking commit infrastructure 1399 * should always call this function from their ->atomic_commit hook. 1400 * 1401 * To be able to use this support drivers need to use a few more helper 1402 * functions. drm_atomic_helper_wait_for_dependencies() must be called before 1403 * actually committing the hardware state, and for nonblocking commits this call 1404 * must be placed in the async worker. See also drm_atomic_helper_swap_state() 1405 * and it's stall parameter, for when a driver's commit hooks look at the 1406 * ->state pointers of struct &drm_crtc, &drm_plane or &drm_connector directly. 1407 * 1408 * Completion of the hardware commit step must be signalled using 1409 * drm_atomic_helper_commit_hw_done(). After this step the driver is not allowed 1410 * to read or change any permanent software or hardware modeset state. The only 1411 * exception is state protected by other means than &drm_modeset_lock locks. 1412 * Only the free standing @state with pointers to the old state structures can 1413 * be inspected, e.g. to clean up old buffers using 1414 * drm_atomic_helper_cleanup_planes(). 1415 * 1416 * At the very end, before cleaning up @state drivers must call 1417 * drm_atomic_helper_commit_cleanup_done(). 1418 * 1419 * This is all implemented by in drm_atomic_helper_commit(), giving drivers a 1420 * complete and esay-to-use default implementation of the atomic_commit() hook. 1421 * 1422 * The tracking of asynchronously executed and still pending commits is done 1423 * using the core structure &drm_crtc_commit. 1424 * 1425 * By default there's no need to clean up resources allocated by this function 1426 * explicitly: drm_atomic_state_default_clear() will take care of that 1427 * automatically. 1428 * 1429 * Returns: 1430 * 1431 * 0 on success. -EBUSY when userspace schedules nonblocking commits too fast, 1432 * -ENOMEM on allocation failures and -EINTR when a signal is pending. 1433 */ 1434 int drm_atomic_helper_setup_commit(struct drm_atomic_state *state, 1435 bool nonblock) 1436 { 1437 struct drm_crtc *crtc; 1438 struct drm_crtc_state *crtc_state; 1439 struct drm_crtc_commit *commit; 1440 int i, ret; 1441 1442 for_each_crtc_in_state(state, crtc, crtc_state, i) { 1443 commit = kzalloc(sizeof(*commit), GFP_KERNEL); 1444 if (!commit) 1445 return -ENOMEM; 1446 1447 init_completion(&commit->flip_done); 1448 init_completion(&commit->hw_done); 1449 init_completion(&commit->cleanup_done); 1450 INIT_LIST_HEAD(&commit->commit_entry); 1451 kref_init(&commit->ref); 1452 commit->crtc = crtc; 1453 1454 state->crtcs[i].commit = commit; 1455 1456 ret = stall_checks(crtc, nonblock); 1457 if (ret) 1458 return ret; 1459 1460 /* Drivers only send out events when at least either current or 1461 * new CRTC state is active. Complete right away if everything 1462 * stays off. */ 1463 if (!crtc->state->active && !crtc_state->active) { 1464 complete_all(&commit->flip_done); 1465 continue; 1466 } 1467 1468 /* Legacy cursor updates are fully unsynced. */ 1469 if (state->legacy_cursor_update) { 1470 complete_all(&commit->flip_done); 1471 continue; 1472 } 1473 1474 if (!crtc_state->event) { 1475 commit->event = kzalloc(sizeof(*commit->event), 1476 GFP_KERNEL); 1477 if (!commit->event) 1478 return -ENOMEM; 1479 1480 crtc_state->event = commit->event; 1481 } 1482 1483 crtc_state->event->base.completion = &commit->flip_done; 1484 } 1485 1486 return 0; 1487 } 1488 EXPORT_SYMBOL(drm_atomic_helper_setup_commit); 1489 1490 1491 static struct drm_crtc_commit *preceeding_commit(struct drm_crtc *crtc) 1492 { 1493 struct drm_crtc_commit *commit; 1494 int i = 0; 1495 1496 list_for_each_entry(commit, &crtc->commit_list, commit_entry) { 1497 /* skip the first entry, that's the current commit */ 1498 if (i == 1) 1499 return commit; 1500 i++; 1501 } 1502 1503 return NULL; 1504 } 1505 1506 /** 1507 * drm_atomic_helper_wait_for_dependencies - wait for required preceeding commits 1508 * @old_state: atomic state object with old state structures 1509 * 1510 * This function waits for all preceeding commits that touch the same CRTC as 1511 * @old_state to both be committed to the hardware (as signalled by 1512 * drm_atomic_helper_commit_hw_done) and executed by the hardware (as signalled 1513 * by calling drm_crtc_vblank_send_event on the event member of 1514 * &drm_crtc_state). 1515 * 1516 * This is part of the atomic helper support for nonblocking commits, see 1517 * drm_atomic_helper_setup_commit() for an overview. 1518 */ 1519 void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *old_state) 1520 { 1521 struct drm_crtc *crtc; 1522 struct drm_crtc_state *crtc_state; 1523 struct drm_crtc_commit *commit; 1524 int i; 1525 long ret; 1526 1527 for_each_crtc_in_state(old_state, crtc, crtc_state, i) { 1528 spin_lock(&crtc->commit_lock); 1529 commit = preceeding_commit(crtc); 1530 if (commit) 1531 drm_crtc_commit_get(commit); 1532 spin_unlock(&crtc->commit_lock); 1533 1534 if (!commit) 1535 continue; 1536 1537 ret = wait_for_completion_timeout(&commit->hw_done, 1538 10*HZ); 1539 if (ret == 0) 1540 DRM_ERROR("[CRTC:%d:%s] hw_done timed out\n", 1541 crtc->base.id, crtc->name); 1542 1543 /* Currently no support for overwriting flips, hence 1544 * stall for previous one to execute completely. */ 1545 ret = wait_for_completion_timeout(&commit->flip_done, 1546 10*HZ); 1547 if (ret == 0) 1548 DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n", 1549 crtc->base.id, crtc->name); 1550 1551 drm_crtc_commit_put(commit); 1552 } 1553 } 1554 EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies); 1555 1556 /** 1557 * drm_atomic_helper_commit_hw_done - setup possible nonblocking commit 1558 * @old_state: atomic state object with old state structures 1559 * 1560 * This function is used to signal completion of the hardware commit step. After 1561 * this step the driver is not allowed to read or change any permanent software 1562 * or hardware modeset state. The only exception is state protected by other 1563 * means than &drm_modeset_lock locks. 1564 * 1565 * Drivers should try to postpone any expensive or delayed cleanup work after 1566 * this function is called. 1567 * 1568 * This is part of the atomic helper support for nonblocking commits, see 1569 * drm_atomic_helper_setup_commit() for an overview. 1570 */ 1571 void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *old_state) 1572 { 1573 struct drm_crtc *crtc; 1574 struct drm_crtc_state *crtc_state; 1575 struct drm_crtc_commit *commit; 1576 int i; 1577 1578 for_each_crtc_in_state(old_state, crtc, crtc_state, i) { 1579 commit = old_state->crtcs[i].commit; 1580 if (!commit) 1581 continue; 1582 1583 /* backend must have consumed any event by now */ 1584 WARN_ON(crtc->state->event); 1585 spin_lock(&crtc->commit_lock); 1586 complete_all(&commit->hw_done); 1587 spin_unlock(&crtc->commit_lock); 1588 } 1589 } 1590 EXPORT_SYMBOL(drm_atomic_helper_commit_hw_done); 1591 1592 /** 1593 * drm_atomic_helper_commit_cleanup_done - signal completion of commit 1594 * @old_state: atomic state object with old state structures 1595 * 1596 * This signals completion of the atomic update @old_state, including any 1597 * cleanup work. If used, it must be called right before calling 1598 * drm_atomic_state_put(). 1599 * 1600 * This is part of the atomic helper support for nonblocking commits, see 1601 * drm_atomic_helper_setup_commit() for an overview. 1602 */ 1603 void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *old_state) 1604 { 1605 struct drm_crtc *crtc; 1606 struct drm_crtc_state *crtc_state; 1607 struct drm_crtc_commit *commit; 1608 int i; 1609 long ret; 1610 1611 for_each_crtc_in_state(old_state, crtc, crtc_state, i) { 1612 commit = old_state->crtcs[i].commit; 1613 if (WARN_ON(!commit)) 1614 continue; 1615 1616 spin_lock(&crtc->commit_lock); 1617 complete_all(&commit->cleanup_done); 1618 WARN_ON(!try_wait_for_completion(&commit->hw_done)); 1619 1620 /* commit_list borrows our reference, need to remove before we 1621 * clean up our drm_atomic_state. But only after it actually 1622 * completed, otherwise subsequent commits won't stall properly. */ 1623 if (try_wait_for_completion(&commit->flip_done)) 1624 goto del_commit; 1625 1626 spin_unlock(&crtc->commit_lock); 1627 1628 /* We must wait for the vblank event to signal our completion 1629 * before releasing our reference, since the vblank work does 1630 * not hold a reference of its own. */ 1631 ret = wait_for_completion_timeout(&commit->flip_done, 1632 10*HZ); 1633 if (ret == 0) 1634 DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n", 1635 crtc->base.id, crtc->name); 1636 1637 spin_lock(&crtc->commit_lock); 1638 del_commit: 1639 list_del(&commit->commit_entry); 1640 spin_unlock(&crtc->commit_lock); 1641 } 1642 } 1643 EXPORT_SYMBOL(drm_atomic_helper_commit_cleanup_done); 1644 1645 /** 1646 * drm_atomic_helper_prepare_planes - prepare plane resources before commit 1647 * @dev: DRM device 1648 * @state: atomic state object with new state structures 1649 * 1650 * This function prepares plane state, specifically framebuffers, for the new 1651 * configuration. If any failure is encountered this function will call 1652 * ->cleanup_fb on any already successfully prepared framebuffer. 1653 * 1654 * Returns: 1655 * 0 on success, negative error code on failure. 1656 */ 1657 int drm_atomic_helper_prepare_planes(struct drm_device *dev, 1658 struct drm_atomic_state *state) 1659 { 1660 struct drm_plane *plane; 1661 struct drm_plane_state *plane_state; 1662 int ret, i, j; 1663 1664 for_each_plane_in_state(state, plane, plane_state, i) { 1665 const struct drm_plane_helper_funcs *funcs; 1666 1667 funcs = plane->helper_private; 1668 1669 if (!drm_atomic_helper_framebuffer_changed(dev, state, plane_state->crtc)) 1670 continue; 1671 1672 if (funcs->prepare_fb) { 1673 ret = funcs->prepare_fb(plane, plane_state); 1674 if (ret) 1675 goto fail; 1676 } 1677 } 1678 1679 return 0; 1680 1681 fail: 1682 for_each_plane_in_state(state, plane, plane_state, j) { 1683 const struct drm_plane_helper_funcs *funcs; 1684 1685 if (j >= i) 1686 continue; 1687 1688 if (!drm_atomic_helper_framebuffer_changed(dev, state, plane_state->crtc)) 1689 continue; 1690 1691 funcs = plane->helper_private; 1692 1693 if (funcs->cleanup_fb) 1694 funcs->cleanup_fb(plane, plane_state); 1695 } 1696 1697 return ret; 1698 } 1699 EXPORT_SYMBOL(drm_atomic_helper_prepare_planes); 1700 1701 static bool plane_crtc_active(const struct drm_plane_state *state) 1702 { 1703 return state->crtc && state->crtc->state->active; 1704 } 1705 1706 /** 1707 * drm_atomic_helper_commit_planes - commit plane state 1708 * @dev: DRM device 1709 * @old_state: atomic state object with old state structures 1710 * @flags: flags for committing plane state 1711 * 1712 * This function commits the new plane state using the plane and atomic helper 1713 * functions for planes and crtcs. It assumes that the atomic state has already 1714 * been pushed into the relevant object state pointers, since this step can no 1715 * longer fail. 1716 * 1717 * It still requires the global state object @old_state to know which planes and 1718 * crtcs need to be updated though. 1719 * 1720 * Note that this function does all plane updates across all CRTCs in one step. 1721 * If the hardware can't support this approach look at 1722 * drm_atomic_helper_commit_planes_on_crtc() instead. 1723 * 1724 * Plane parameters can be updated by applications while the associated CRTC is 1725 * disabled. The DRM/KMS core will store the parameters in the plane state, 1726 * which will be available to the driver when the CRTC is turned on. As a result 1727 * most drivers don't need to be immediately notified of plane updates for a 1728 * disabled CRTC. 1729 * 1730 * Unless otherwise needed, drivers are advised to set the ACTIVE_ONLY flag in 1731 * @flags in order not to receive plane update notifications related to a 1732 * disabled CRTC. This avoids the need to manually ignore plane updates in 1733 * driver code when the driver and/or hardware can't or just don't need to deal 1734 * with updates on disabled CRTCs, for example when supporting runtime PM. 1735 * 1736 * Drivers may set the NO_DISABLE_AFTER_MODESET flag in @flags if the relevant 1737 * display controllers require to disable a CRTC's planes when the CRTC is 1738 * disabled. This function would skip the ->atomic_disable call for a plane if 1739 * the CRTC of the old plane state needs a modesetting operation. Of course, 1740 * the drivers need to disable the planes in their CRTC disable callbacks 1741 * since no one else would do that. 1742 * 1743 * The drm_atomic_helper_commit() default implementation doesn't set the 1744 * ACTIVE_ONLY flag to most closely match the behaviour of the legacy helpers. 1745 * This should not be copied blindly by drivers. 1746 */ 1747 void drm_atomic_helper_commit_planes(struct drm_device *dev, 1748 struct drm_atomic_state *old_state, 1749 uint32_t flags) 1750 { 1751 struct drm_crtc *crtc; 1752 struct drm_crtc_state *old_crtc_state; 1753 struct drm_plane *plane; 1754 struct drm_plane_state *old_plane_state; 1755 int i; 1756 bool active_only = flags & DRM_PLANE_COMMIT_ACTIVE_ONLY; 1757 bool no_disable = flags & DRM_PLANE_COMMIT_NO_DISABLE_AFTER_MODESET; 1758 1759 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 1760 const struct drm_crtc_helper_funcs *funcs; 1761 1762 funcs = crtc->helper_private; 1763 1764 if (!funcs || !funcs->atomic_begin) 1765 continue; 1766 1767 if (active_only && !crtc->state->active) 1768 continue; 1769 1770 funcs->atomic_begin(crtc, old_crtc_state); 1771 } 1772 1773 for_each_plane_in_state(old_state, plane, old_plane_state, i) { 1774 const struct drm_plane_helper_funcs *funcs; 1775 bool disabling; 1776 1777 funcs = plane->helper_private; 1778 1779 if (!funcs) 1780 continue; 1781 1782 disabling = drm_atomic_plane_disabling(plane, old_plane_state); 1783 1784 if (active_only) { 1785 /* 1786 * Skip planes related to inactive CRTCs. If the plane 1787 * is enabled use the state of the current CRTC. If the 1788 * plane is being disabled use the state of the old 1789 * CRTC to avoid skipping planes being disabled on an 1790 * active CRTC. 1791 */ 1792 if (!disabling && !plane_crtc_active(plane->state)) 1793 continue; 1794 if (disabling && !plane_crtc_active(old_plane_state)) 1795 continue; 1796 } 1797 1798 /* 1799 * Special-case disabling the plane if drivers support it. 1800 */ 1801 if (disabling && funcs->atomic_disable) { 1802 struct drm_crtc_state *crtc_state; 1803 1804 crtc_state = old_plane_state->crtc->state; 1805 1806 if (drm_atomic_crtc_needs_modeset(crtc_state) && 1807 no_disable) 1808 continue; 1809 1810 funcs->atomic_disable(plane, old_plane_state); 1811 } else if (plane->state->crtc || disabling) { 1812 funcs->atomic_update(plane, old_plane_state); 1813 } 1814 } 1815 1816 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 1817 const struct drm_crtc_helper_funcs *funcs; 1818 1819 funcs = crtc->helper_private; 1820 1821 if (!funcs || !funcs->atomic_flush) 1822 continue; 1823 1824 if (active_only && !crtc->state->active) 1825 continue; 1826 1827 funcs->atomic_flush(crtc, old_crtc_state); 1828 } 1829 } 1830 EXPORT_SYMBOL(drm_atomic_helper_commit_planes); 1831 1832 /** 1833 * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a crtc 1834 * @old_crtc_state: atomic state object with the old crtc state 1835 * 1836 * This function commits the new plane state using the plane and atomic helper 1837 * functions for planes on the specific crtc. It assumes that the atomic state 1838 * has already been pushed into the relevant object state pointers, since this 1839 * step can no longer fail. 1840 * 1841 * This function is useful when plane updates should be done crtc-by-crtc 1842 * instead of one global step like drm_atomic_helper_commit_planes() does. 1843 * 1844 * This function can only be savely used when planes are not allowed to move 1845 * between different CRTCs because this function doesn't handle inter-CRTC 1846 * depencies. Callers need to ensure that either no such depencies exist, 1847 * resolve them through ordering of commit calls or through some other means. 1848 */ 1849 void 1850 drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state) 1851 { 1852 const struct drm_crtc_helper_funcs *crtc_funcs; 1853 struct drm_crtc *crtc = old_crtc_state->crtc; 1854 struct drm_atomic_state *old_state = old_crtc_state->state; 1855 struct drm_plane *plane; 1856 unsigned plane_mask; 1857 1858 plane_mask = old_crtc_state->plane_mask; 1859 plane_mask |= crtc->state->plane_mask; 1860 1861 crtc_funcs = crtc->helper_private; 1862 if (crtc_funcs && crtc_funcs->atomic_begin) 1863 crtc_funcs->atomic_begin(crtc, old_crtc_state); 1864 1865 drm_for_each_plane_mask(plane, crtc->dev, plane_mask) { 1866 struct drm_plane_state *old_plane_state = 1867 drm_atomic_get_existing_plane_state(old_state, plane); 1868 const struct drm_plane_helper_funcs *plane_funcs; 1869 1870 plane_funcs = plane->helper_private; 1871 1872 if (!old_plane_state || !plane_funcs) 1873 continue; 1874 1875 WARN_ON(plane->state->crtc && plane->state->crtc != crtc); 1876 1877 if (drm_atomic_plane_disabling(plane, old_plane_state) && 1878 plane_funcs->atomic_disable) 1879 plane_funcs->atomic_disable(plane, old_plane_state); 1880 else if (plane->state->crtc || 1881 drm_atomic_plane_disabling(plane, old_plane_state)) 1882 plane_funcs->atomic_update(plane, old_plane_state); 1883 } 1884 1885 if (crtc_funcs && crtc_funcs->atomic_flush) 1886 crtc_funcs->atomic_flush(crtc, old_crtc_state); 1887 } 1888 EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc); 1889 1890 /** 1891 * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes 1892 * @old_crtc_state: atomic state object with the old CRTC state 1893 * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks 1894 * 1895 * Disables all planes associated with the given CRTC. This can be 1896 * used for instance in the CRTC helper atomic_disable callback to disable 1897 * all planes. 1898 * 1899 * If the atomic-parameter is set the function calls the CRTC's 1900 * atomic_begin hook before and atomic_flush hook after disabling the 1901 * planes. 1902 * 1903 * It is a bug to call this function without having implemented the 1904 * ->atomic_disable() plane hook. 1905 */ 1906 void 1907 drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state *old_crtc_state, 1908 bool atomic) 1909 { 1910 struct drm_crtc *crtc = old_crtc_state->crtc; 1911 const struct drm_crtc_helper_funcs *crtc_funcs = 1912 crtc->helper_private; 1913 struct drm_plane *plane; 1914 1915 if (atomic && crtc_funcs && crtc_funcs->atomic_begin) 1916 crtc_funcs->atomic_begin(crtc, NULL); 1917 1918 drm_atomic_crtc_state_for_each_plane(plane, old_crtc_state) { 1919 const struct drm_plane_helper_funcs *plane_funcs = 1920 plane->helper_private; 1921 1922 if (!plane_funcs) 1923 continue; 1924 1925 WARN_ON(!plane_funcs->atomic_disable); 1926 if (plane_funcs->atomic_disable) 1927 plane_funcs->atomic_disable(plane, NULL); 1928 } 1929 1930 if (atomic && crtc_funcs && crtc_funcs->atomic_flush) 1931 crtc_funcs->atomic_flush(crtc, NULL); 1932 } 1933 EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc); 1934 1935 /** 1936 * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit 1937 * @dev: DRM device 1938 * @old_state: atomic state object with old state structures 1939 * 1940 * This function cleans up plane state, specifically framebuffers, from the old 1941 * configuration. Hence the old configuration must be perserved in @old_state to 1942 * be able to call this function. 1943 * 1944 * This function must also be called on the new state when the atomic update 1945 * fails at any point after calling drm_atomic_helper_prepare_planes(). 1946 */ 1947 void drm_atomic_helper_cleanup_planes(struct drm_device *dev, 1948 struct drm_atomic_state *old_state) 1949 { 1950 struct drm_plane *plane; 1951 struct drm_plane_state *plane_state; 1952 int i; 1953 1954 for_each_plane_in_state(old_state, plane, plane_state, i) { 1955 const struct drm_plane_helper_funcs *funcs; 1956 1957 if (!drm_atomic_helper_framebuffer_changed(dev, old_state, plane_state->crtc)) 1958 continue; 1959 1960 funcs = plane->helper_private; 1961 1962 if (funcs->cleanup_fb) 1963 funcs->cleanup_fb(plane, plane_state); 1964 } 1965 } 1966 EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes); 1967 1968 /** 1969 * drm_atomic_helper_swap_state - store atomic state into current sw state 1970 * @state: atomic state 1971 * @stall: stall for proceeding commits 1972 * 1973 * This function stores the atomic state into the current state pointers in all 1974 * driver objects. It should be called after all failing steps have been done 1975 * and succeeded, but before the actual hardware state is committed. 1976 * 1977 * For cleanup and error recovery the current state for all changed objects will 1978 * be swaped into @state. 1979 * 1980 * With that sequence it fits perfectly into the plane prepare/cleanup sequence: 1981 * 1982 * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state. 1983 * 1984 * 2. Do any other steps that might fail. 1985 * 1986 * 3. Put the staged state into the current state pointers with this function. 1987 * 1988 * 4. Actually commit the hardware state. 1989 * 1990 * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3 1991 * contains the old state. Also do any other cleanup required with that state. 1992 * 1993 * @stall must be set when nonblocking commits for this driver directly access 1994 * the ->state pointer of &drm_plane, &drm_crtc or &drm_connector. With the 1995 * current atomic helpers this is almost always the case, since the helpers 1996 * don't pass the right state structures to the callbacks. 1997 */ 1998 void drm_atomic_helper_swap_state(struct drm_atomic_state *state, 1999 bool stall) 2000 { 2001 int i; 2002 long ret; 2003 struct drm_connector *connector; 2004 struct drm_connector_state *conn_state; 2005 struct drm_crtc *crtc; 2006 struct drm_crtc_state *crtc_state; 2007 struct drm_plane *plane; 2008 struct drm_plane_state *plane_state; 2009 struct drm_crtc_commit *commit; 2010 2011 if (stall) { 2012 for_each_crtc_in_state(state, crtc, crtc_state, i) { 2013 spin_lock(&crtc->commit_lock); 2014 commit = list_first_entry_or_null(&crtc->commit_list, 2015 struct drm_crtc_commit, commit_entry); 2016 if (commit) 2017 drm_crtc_commit_get(commit); 2018 spin_unlock(&crtc->commit_lock); 2019 2020 if (!commit) 2021 continue; 2022 2023 ret = wait_for_completion_timeout(&commit->hw_done, 2024 10*HZ); 2025 if (ret == 0) 2026 DRM_ERROR("[CRTC:%d:%s] hw_done timed out\n", 2027 crtc->base.id, crtc->name); 2028 drm_crtc_commit_put(commit); 2029 } 2030 } 2031 2032 for_each_connector_in_state(state, connector, conn_state, i) { 2033 connector->state->state = state; 2034 swap(state->connectors[i].state, connector->state); 2035 connector->state->state = NULL; 2036 } 2037 2038 for_each_crtc_in_state(state, crtc, crtc_state, i) { 2039 crtc->state->state = state; 2040 swap(state->crtcs[i].state, crtc->state); 2041 crtc->state->state = NULL; 2042 2043 if (state->crtcs[i].commit) { 2044 spin_lock(&crtc->commit_lock); 2045 list_add(&state->crtcs[i].commit->commit_entry, 2046 &crtc->commit_list); 2047 spin_unlock(&crtc->commit_lock); 2048 2049 state->crtcs[i].commit->event = NULL; 2050 } 2051 } 2052 2053 for_each_plane_in_state(state, plane, plane_state, i) { 2054 plane->state->state = state; 2055 swap(state->planes[i].state, plane->state); 2056 plane->state->state = NULL; 2057 } 2058 } 2059 EXPORT_SYMBOL(drm_atomic_helper_swap_state); 2060 2061 /** 2062 * drm_atomic_helper_update_plane - Helper for primary plane update using atomic 2063 * @plane: plane object to update 2064 * @crtc: owning CRTC of owning plane 2065 * @fb: framebuffer to flip onto plane 2066 * @crtc_x: x offset of primary plane on crtc 2067 * @crtc_y: y offset of primary plane on crtc 2068 * @crtc_w: width of primary plane rectangle on crtc 2069 * @crtc_h: height of primary plane rectangle on crtc 2070 * @src_x: x offset of @fb for panning 2071 * @src_y: y offset of @fb for panning 2072 * @src_w: width of source rectangle in @fb 2073 * @src_h: height of source rectangle in @fb 2074 * 2075 * Provides a default plane update handler using the atomic driver interface. 2076 * 2077 * RETURNS: 2078 * Zero on success, error code on failure 2079 */ 2080 int drm_atomic_helper_update_plane(struct drm_plane *plane, 2081 struct drm_crtc *crtc, 2082 struct drm_framebuffer *fb, 2083 int crtc_x, int crtc_y, 2084 unsigned int crtc_w, unsigned int crtc_h, 2085 uint32_t src_x, uint32_t src_y, 2086 uint32_t src_w, uint32_t src_h) 2087 { 2088 struct drm_atomic_state *state; 2089 struct drm_plane_state *plane_state; 2090 int ret = 0; 2091 2092 state = drm_atomic_state_alloc(plane->dev); 2093 if (!state) 2094 return -ENOMEM; 2095 2096 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 2097 retry: 2098 plane_state = drm_atomic_get_plane_state(state, plane); 2099 if (IS_ERR(plane_state)) { 2100 ret = PTR_ERR(plane_state); 2101 goto fail; 2102 } 2103 2104 ret = drm_atomic_set_crtc_for_plane(plane_state, crtc); 2105 if (ret != 0) 2106 goto fail; 2107 drm_atomic_set_fb_for_plane(plane_state, fb); 2108 plane_state->crtc_x = crtc_x; 2109 plane_state->crtc_y = crtc_y; 2110 plane_state->crtc_w = crtc_w; 2111 plane_state->crtc_h = crtc_h; 2112 plane_state->src_x = src_x; 2113 plane_state->src_y = src_y; 2114 plane_state->src_w = src_w; 2115 plane_state->src_h = src_h; 2116 2117 if (plane == crtc->cursor) 2118 state->legacy_cursor_update = true; 2119 2120 ret = drm_atomic_commit(state); 2121 fail: 2122 if (ret == -EDEADLK) 2123 goto backoff; 2124 2125 drm_atomic_state_put(state); 2126 return ret; 2127 2128 backoff: 2129 drm_atomic_state_clear(state); 2130 drm_atomic_legacy_backoff(state); 2131 2132 /* 2133 * Someone might have exchanged the framebuffer while we dropped locks 2134 * in the backoff code. We need to fix up the fb refcount tracking the 2135 * core does for us. 2136 */ 2137 plane->old_fb = plane->fb; 2138 2139 goto retry; 2140 } 2141 EXPORT_SYMBOL(drm_atomic_helper_update_plane); 2142 2143 /** 2144 * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic 2145 * @plane: plane to disable 2146 * 2147 * Provides a default plane disable handler using the atomic driver interface. 2148 * 2149 * RETURNS: 2150 * Zero on success, error code on failure 2151 */ 2152 int drm_atomic_helper_disable_plane(struct drm_plane *plane) 2153 { 2154 struct drm_atomic_state *state; 2155 struct drm_plane_state *plane_state; 2156 int ret = 0; 2157 2158 /* 2159 * FIXME: Without plane->crtc set we can't get at the implicit legacy 2160 * acquire context. The real fix will be to wire the acquire ctx through 2161 * everywhere we need it, but meanwhile prevent chaos by just skipping 2162 * this noop. The critical case is the cursor ioctls which a) only grab 2163 * crtc/cursor-plane locks (so we need the crtc to get at the right 2164 * acquire context) and b) can try to disable the plane multiple times. 2165 */ 2166 if (!plane->crtc) 2167 return 0; 2168 2169 state = drm_atomic_state_alloc(plane->dev); 2170 if (!state) 2171 return -ENOMEM; 2172 2173 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(plane->crtc); 2174 retry: 2175 plane_state = drm_atomic_get_plane_state(state, plane); 2176 if (IS_ERR(plane_state)) { 2177 ret = PTR_ERR(plane_state); 2178 goto fail; 2179 } 2180 2181 if (plane_state->crtc && (plane == plane->crtc->cursor)) 2182 plane_state->state->legacy_cursor_update = true; 2183 2184 ret = __drm_atomic_helper_disable_plane(plane, plane_state); 2185 if (ret != 0) 2186 goto fail; 2187 2188 ret = drm_atomic_commit(state); 2189 fail: 2190 if (ret == -EDEADLK) 2191 goto backoff; 2192 2193 drm_atomic_state_put(state); 2194 return ret; 2195 2196 backoff: 2197 drm_atomic_state_clear(state); 2198 drm_atomic_legacy_backoff(state); 2199 2200 /* 2201 * Someone might have exchanged the framebuffer while we dropped locks 2202 * in the backoff code. We need to fix up the fb refcount tracking the 2203 * core does for us. 2204 */ 2205 plane->old_fb = plane->fb; 2206 2207 goto retry; 2208 } 2209 EXPORT_SYMBOL(drm_atomic_helper_disable_plane); 2210 2211 /* just used from fb-helper and atomic-helper: */ 2212 int __drm_atomic_helper_disable_plane(struct drm_plane *plane, 2213 struct drm_plane_state *plane_state) 2214 { 2215 int ret; 2216 2217 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL); 2218 if (ret != 0) 2219 return ret; 2220 2221 drm_atomic_set_fb_for_plane(plane_state, NULL); 2222 plane_state->crtc_x = 0; 2223 plane_state->crtc_y = 0; 2224 plane_state->crtc_w = 0; 2225 plane_state->crtc_h = 0; 2226 plane_state->src_x = 0; 2227 plane_state->src_y = 0; 2228 plane_state->src_w = 0; 2229 plane_state->src_h = 0; 2230 2231 return 0; 2232 } 2233 2234 static int update_output_state(struct drm_atomic_state *state, 2235 struct drm_mode_set *set) 2236 { 2237 struct drm_device *dev = set->crtc->dev; 2238 struct drm_crtc *crtc; 2239 struct drm_crtc_state *crtc_state; 2240 struct drm_connector *connector; 2241 struct drm_connector_state *conn_state; 2242 int ret, i; 2243 2244 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, 2245 state->acquire_ctx); 2246 if (ret) 2247 return ret; 2248 2249 /* First disable all connectors on the target crtc. */ 2250 ret = drm_atomic_add_affected_connectors(state, set->crtc); 2251 if (ret) 2252 return ret; 2253 2254 for_each_connector_in_state(state, connector, conn_state, i) { 2255 if (conn_state->crtc == set->crtc) { 2256 ret = drm_atomic_set_crtc_for_connector(conn_state, 2257 NULL); 2258 if (ret) 2259 return ret; 2260 } 2261 } 2262 2263 /* Then set all connectors from set->connectors on the target crtc */ 2264 for (i = 0; i < set->num_connectors; i++) { 2265 conn_state = drm_atomic_get_connector_state(state, 2266 set->connectors[i]); 2267 if (IS_ERR(conn_state)) 2268 return PTR_ERR(conn_state); 2269 2270 ret = drm_atomic_set_crtc_for_connector(conn_state, 2271 set->crtc); 2272 if (ret) 2273 return ret; 2274 } 2275 2276 for_each_crtc_in_state(state, crtc, crtc_state, i) { 2277 /* Don't update ->enable for the CRTC in the set_config request, 2278 * since a mismatch would indicate a bug in the upper layers. 2279 * The actual modeset code later on will catch any 2280 * inconsistencies here. */ 2281 if (crtc == set->crtc) 2282 continue; 2283 2284 if (!crtc_state->connector_mask) { 2285 ret = drm_atomic_set_mode_prop_for_crtc(crtc_state, 2286 NULL); 2287 if (ret < 0) 2288 return ret; 2289 2290 crtc_state->active = false; 2291 } 2292 } 2293 2294 return 0; 2295 } 2296 2297 /** 2298 * drm_atomic_helper_set_config - set a new config from userspace 2299 * @set: mode set configuration 2300 * 2301 * Provides a default crtc set_config handler using the atomic driver interface. 2302 * 2303 * Returns: 2304 * Returns 0 on success, negative errno numbers on failure. 2305 */ 2306 int drm_atomic_helper_set_config(struct drm_mode_set *set) 2307 { 2308 struct drm_atomic_state *state; 2309 struct drm_crtc *crtc = set->crtc; 2310 int ret = 0; 2311 2312 state = drm_atomic_state_alloc(crtc->dev); 2313 if (!state) 2314 return -ENOMEM; 2315 2316 state->legacy_set_config = true; 2317 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 2318 retry: 2319 ret = __drm_atomic_helper_set_config(set, state); 2320 if (ret != 0) 2321 goto fail; 2322 2323 ret = drm_atomic_commit(state); 2324 fail: 2325 if (ret == -EDEADLK) 2326 goto backoff; 2327 2328 drm_atomic_state_put(state); 2329 return ret; 2330 2331 backoff: 2332 drm_atomic_state_clear(state); 2333 drm_atomic_legacy_backoff(state); 2334 2335 /* 2336 * Someone might have exchanged the framebuffer while we dropped locks 2337 * in the backoff code. We need to fix up the fb refcount tracking the 2338 * core does for us. 2339 */ 2340 crtc->primary->old_fb = crtc->primary->fb; 2341 2342 goto retry; 2343 } 2344 EXPORT_SYMBOL(drm_atomic_helper_set_config); 2345 2346 /* just used from fb-helper and atomic-helper: */ 2347 int __drm_atomic_helper_set_config(struct drm_mode_set *set, 2348 struct drm_atomic_state *state) 2349 { 2350 struct drm_crtc_state *crtc_state; 2351 struct drm_plane_state *primary_state; 2352 struct drm_crtc *crtc = set->crtc; 2353 int hdisplay, vdisplay; 2354 int ret; 2355 2356 crtc_state = drm_atomic_get_crtc_state(state, crtc); 2357 if (IS_ERR(crtc_state)) 2358 return PTR_ERR(crtc_state); 2359 2360 primary_state = drm_atomic_get_plane_state(state, crtc->primary); 2361 if (IS_ERR(primary_state)) 2362 return PTR_ERR(primary_state); 2363 2364 if (!set->mode) { 2365 WARN_ON(set->fb); 2366 WARN_ON(set->num_connectors); 2367 2368 ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL); 2369 if (ret != 0) 2370 return ret; 2371 2372 crtc_state->active = false; 2373 2374 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL); 2375 if (ret != 0) 2376 return ret; 2377 2378 drm_atomic_set_fb_for_plane(primary_state, NULL); 2379 2380 goto commit; 2381 } 2382 2383 WARN_ON(!set->fb); 2384 WARN_ON(!set->num_connectors); 2385 2386 ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode); 2387 if (ret != 0) 2388 return ret; 2389 2390 crtc_state->active = true; 2391 2392 ret = drm_atomic_set_crtc_for_plane(primary_state, crtc); 2393 if (ret != 0) 2394 return ret; 2395 2396 drm_crtc_get_hv_timing(set->mode, &hdisplay, &vdisplay); 2397 2398 drm_atomic_set_fb_for_plane(primary_state, set->fb); 2399 primary_state->crtc_x = 0; 2400 primary_state->crtc_y = 0; 2401 primary_state->crtc_w = hdisplay; 2402 primary_state->crtc_h = vdisplay; 2403 primary_state->src_x = set->x << 16; 2404 primary_state->src_y = set->y << 16; 2405 if (drm_rotation_90_or_270(primary_state->rotation)) { 2406 primary_state->src_w = vdisplay << 16; 2407 primary_state->src_h = hdisplay << 16; 2408 } else { 2409 primary_state->src_w = hdisplay << 16; 2410 primary_state->src_h = vdisplay << 16; 2411 } 2412 2413 commit: 2414 ret = update_output_state(state, set); 2415 if (ret) 2416 return ret; 2417 2418 return 0; 2419 } 2420 2421 /** 2422 * drm_atomic_helper_disable_all - disable all currently active outputs 2423 * @dev: DRM device 2424 * @ctx: lock acquisition context 2425 * 2426 * Loops through all connectors, finding those that aren't turned off and then 2427 * turns them off by setting their DPMS mode to OFF and deactivating the CRTC 2428 * that they are connected to. 2429 * 2430 * This is used for example in suspend/resume to disable all currently active 2431 * functions when suspending. 2432 * 2433 * Note that if callers haven't already acquired all modeset locks this might 2434 * return -EDEADLK, which must be handled by calling drm_modeset_backoff(). 2435 * 2436 * Returns: 2437 * 0 on success or a negative error code on failure. 2438 * 2439 * See also: 2440 * drm_atomic_helper_suspend(), drm_atomic_helper_resume() 2441 */ 2442 int drm_atomic_helper_disable_all(struct drm_device *dev, 2443 struct drm_modeset_acquire_ctx *ctx) 2444 { 2445 struct drm_atomic_state *state; 2446 struct drm_connector *conn; 2447 int err; 2448 2449 state = drm_atomic_state_alloc(dev); 2450 if (!state) 2451 return -ENOMEM; 2452 2453 state->acquire_ctx = ctx; 2454 2455 drm_for_each_connector(conn, dev) { 2456 struct drm_crtc *crtc = conn->state->crtc; 2457 struct drm_crtc_state *crtc_state; 2458 2459 if (!crtc || conn->dpms != DRM_MODE_DPMS_ON) 2460 continue; 2461 2462 crtc_state = drm_atomic_get_crtc_state(state, crtc); 2463 if (IS_ERR(crtc_state)) { 2464 err = PTR_ERR(crtc_state); 2465 goto free; 2466 } 2467 2468 crtc_state->active = false; 2469 } 2470 2471 err = drm_atomic_commit(state); 2472 free: 2473 drm_atomic_state_put(state); 2474 return err; 2475 } 2476 EXPORT_SYMBOL(drm_atomic_helper_disable_all); 2477 2478 /** 2479 * drm_atomic_helper_suspend - subsystem-level suspend helper 2480 * @dev: DRM device 2481 * 2482 * Duplicates the current atomic state, disables all active outputs and then 2483 * returns a pointer to the original atomic state to the caller. Drivers can 2484 * pass this pointer to the drm_atomic_helper_resume() helper upon resume to 2485 * restore the output configuration that was active at the time the system 2486 * entered suspend. 2487 * 2488 * Note that it is potentially unsafe to use this. The atomic state object 2489 * returned by this function is assumed to be persistent. Drivers must ensure 2490 * that this holds true. Before calling this function, drivers must make sure 2491 * to suspend fbdev emulation so that nothing can be using the device. 2492 * 2493 * Returns: 2494 * A pointer to a copy of the state before suspend on success or an ERR_PTR()- 2495 * encoded error code on failure. Drivers should store the returned atomic 2496 * state object and pass it to the drm_atomic_helper_resume() helper upon 2497 * resume. 2498 * 2499 * See also: 2500 * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(), 2501 * drm_atomic_helper_resume() 2502 */ 2503 struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev) 2504 { 2505 struct drm_modeset_acquire_ctx ctx; 2506 struct drm_atomic_state *state; 2507 int err; 2508 2509 drm_modeset_acquire_init(&ctx, 0); 2510 2511 retry: 2512 err = drm_modeset_lock_all_ctx(dev, &ctx); 2513 if (err < 0) { 2514 state = ERR_PTR(err); 2515 goto unlock; 2516 } 2517 2518 state = drm_atomic_helper_duplicate_state(dev, &ctx); 2519 if (IS_ERR(state)) 2520 goto unlock; 2521 2522 err = drm_atomic_helper_disable_all(dev, &ctx); 2523 if (err < 0) { 2524 drm_atomic_state_put(state); 2525 state = ERR_PTR(err); 2526 goto unlock; 2527 } 2528 2529 unlock: 2530 if (PTR_ERR(state) == -EDEADLK) { 2531 drm_modeset_backoff(&ctx); 2532 goto retry; 2533 } 2534 2535 drm_modeset_drop_locks(&ctx); 2536 drm_modeset_acquire_fini(&ctx); 2537 return state; 2538 } 2539 EXPORT_SYMBOL(drm_atomic_helper_suspend); 2540 2541 /** 2542 * drm_atomic_helper_resume - subsystem-level resume helper 2543 * @dev: DRM device 2544 * @state: atomic state to resume to 2545 * 2546 * Calls drm_mode_config_reset() to synchronize hardware and software states, 2547 * grabs all modeset locks and commits the atomic state object. This can be 2548 * used in conjunction with the drm_atomic_helper_suspend() helper to 2549 * implement suspend/resume for drivers that support atomic mode-setting. 2550 * 2551 * Returns: 2552 * 0 on success or a negative error code on failure. 2553 * 2554 * See also: 2555 * drm_atomic_helper_suspend() 2556 */ 2557 int drm_atomic_helper_resume(struct drm_device *dev, 2558 struct drm_atomic_state *state) 2559 { 2560 struct drm_mode_config *config = &dev->mode_config; 2561 int err; 2562 2563 drm_mode_config_reset(dev); 2564 drm_modeset_lock_all(dev); 2565 state->acquire_ctx = config->acquire_ctx; 2566 err = drm_atomic_commit(state); 2567 drm_modeset_unlock_all(dev); 2568 2569 return err; 2570 } 2571 EXPORT_SYMBOL(drm_atomic_helper_resume); 2572 2573 /** 2574 * drm_atomic_helper_crtc_set_property - helper for crtc properties 2575 * @crtc: DRM crtc 2576 * @property: DRM property 2577 * @val: value of property 2578 * 2579 * Provides a default crtc set_property handler using the atomic driver 2580 * interface. 2581 * 2582 * RETURNS: 2583 * Zero on success, error code on failure 2584 */ 2585 int 2586 drm_atomic_helper_crtc_set_property(struct drm_crtc *crtc, 2587 struct drm_property *property, 2588 uint64_t val) 2589 { 2590 struct drm_atomic_state *state; 2591 struct drm_crtc_state *crtc_state; 2592 int ret = 0; 2593 2594 state = drm_atomic_state_alloc(crtc->dev); 2595 if (!state) 2596 return -ENOMEM; 2597 2598 /* ->set_property is always called with all locks held. */ 2599 state->acquire_ctx = crtc->dev->mode_config.acquire_ctx; 2600 retry: 2601 crtc_state = drm_atomic_get_crtc_state(state, crtc); 2602 if (IS_ERR(crtc_state)) { 2603 ret = PTR_ERR(crtc_state); 2604 goto fail; 2605 } 2606 2607 ret = drm_atomic_crtc_set_property(crtc, crtc_state, 2608 property, val); 2609 if (ret) 2610 goto fail; 2611 2612 ret = drm_atomic_commit(state); 2613 fail: 2614 if (ret == -EDEADLK) 2615 goto backoff; 2616 2617 drm_atomic_state_put(state); 2618 return ret; 2619 2620 backoff: 2621 drm_atomic_state_clear(state); 2622 drm_atomic_legacy_backoff(state); 2623 2624 goto retry; 2625 } 2626 EXPORT_SYMBOL(drm_atomic_helper_crtc_set_property); 2627 2628 /** 2629 * drm_atomic_helper_plane_set_property - helper for plane properties 2630 * @plane: DRM plane 2631 * @property: DRM property 2632 * @val: value of property 2633 * 2634 * Provides a default plane set_property handler using the atomic driver 2635 * interface. 2636 * 2637 * RETURNS: 2638 * Zero on success, error code on failure 2639 */ 2640 int 2641 drm_atomic_helper_plane_set_property(struct drm_plane *plane, 2642 struct drm_property *property, 2643 uint64_t val) 2644 { 2645 struct drm_atomic_state *state; 2646 struct drm_plane_state *plane_state; 2647 int ret = 0; 2648 2649 state = drm_atomic_state_alloc(plane->dev); 2650 if (!state) 2651 return -ENOMEM; 2652 2653 /* ->set_property is always called with all locks held. */ 2654 state->acquire_ctx = plane->dev->mode_config.acquire_ctx; 2655 retry: 2656 plane_state = drm_atomic_get_plane_state(state, plane); 2657 if (IS_ERR(plane_state)) { 2658 ret = PTR_ERR(plane_state); 2659 goto fail; 2660 } 2661 2662 ret = drm_atomic_plane_set_property(plane, plane_state, 2663 property, val); 2664 if (ret) 2665 goto fail; 2666 2667 ret = drm_atomic_commit(state); 2668 fail: 2669 if (ret == -EDEADLK) 2670 goto backoff; 2671 2672 drm_atomic_state_put(state); 2673 return ret; 2674 2675 backoff: 2676 drm_atomic_state_clear(state); 2677 drm_atomic_legacy_backoff(state); 2678 2679 goto retry; 2680 } 2681 EXPORT_SYMBOL(drm_atomic_helper_plane_set_property); 2682 2683 /** 2684 * drm_atomic_helper_connector_set_property - helper for connector properties 2685 * @connector: DRM connector 2686 * @property: DRM property 2687 * @val: value of property 2688 * 2689 * Provides a default connector set_property handler using the atomic driver 2690 * interface. 2691 * 2692 * RETURNS: 2693 * Zero on success, error code on failure 2694 */ 2695 int 2696 drm_atomic_helper_connector_set_property(struct drm_connector *connector, 2697 struct drm_property *property, 2698 uint64_t val) 2699 { 2700 struct drm_atomic_state *state; 2701 struct drm_connector_state *connector_state; 2702 int ret = 0; 2703 2704 state = drm_atomic_state_alloc(connector->dev); 2705 if (!state) 2706 return -ENOMEM; 2707 2708 /* ->set_property is always called with all locks held. */ 2709 state->acquire_ctx = connector->dev->mode_config.acquire_ctx; 2710 retry: 2711 connector_state = drm_atomic_get_connector_state(state, connector); 2712 if (IS_ERR(connector_state)) { 2713 ret = PTR_ERR(connector_state); 2714 goto fail; 2715 } 2716 2717 ret = drm_atomic_connector_set_property(connector, connector_state, 2718 property, val); 2719 if (ret) 2720 goto fail; 2721 2722 ret = drm_atomic_commit(state); 2723 fail: 2724 if (ret == -EDEADLK) 2725 goto backoff; 2726 2727 drm_atomic_state_put(state); 2728 return ret; 2729 2730 backoff: 2731 drm_atomic_state_clear(state); 2732 drm_atomic_legacy_backoff(state); 2733 2734 goto retry; 2735 } 2736 EXPORT_SYMBOL(drm_atomic_helper_connector_set_property); 2737 2738 /** 2739 * drm_atomic_helper_page_flip - execute a legacy page flip 2740 * @crtc: DRM crtc 2741 * @fb: DRM framebuffer 2742 * @event: optional DRM event to signal upon completion 2743 * @flags: flip flags for non-vblank sync'ed updates 2744 * 2745 * Provides a default page flip implementation using the atomic driver interface. 2746 * 2747 * Note that for now so called async page flips (i.e. updates which are not 2748 * synchronized to vblank) are not supported, since the atomic interfaces have 2749 * no provisions for this yet. 2750 * 2751 * Returns: 2752 * Returns 0 on success, negative errno numbers on failure. 2753 */ 2754 int drm_atomic_helper_page_flip(struct drm_crtc *crtc, 2755 struct drm_framebuffer *fb, 2756 struct drm_pending_vblank_event *event, 2757 uint32_t flags) 2758 { 2759 struct drm_plane *plane = crtc->primary; 2760 struct drm_atomic_state *state; 2761 struct drm_plane_state *plane_state; 2762 struct drm_crtc_state *crtc_state; 2763 int ret = 0; 2764 2765 if (flags & DRM_MODE_PAGE_FLIP_ASYNC) 2766 return -EINVAL; 2767 2768 state = drm_atomic_state_alloc(plane->dev); 2769 if (!state) 2770 return -ENOMEM; 2771 2772 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 2773 retry: 2774 crtc_state = drm_atomic_get_crtc_state(state, crtc); 2775 if (IS_ERR(crtc_state)) { 2776 ret = PTR_ERR(crtc_state); 2777 goto fail; 2778 } 2779 crtc_state->event = event; 2780 2781 plane_state = drm_atomic_get_plane_state(state, plane); 2782 if (IS_ERR(plane_state)) { 2783 ret = PTR_ERR(plane_state); 2784 goto fail; 2785 } 2786 2787 ret = drm_atomic_set_crtc_for_plane(plane_state, crtc); 2788 if (ret != 0) 2789 goto fail; 2790 drm_atomic_set_fb_for_plane(plane_state, fb); 2791 2792 /* Make sure we don't accidentally do a full modeset. */ 2793 state->allow_modeset = false; 2794 if (!crtc_state->active) { 2795 DRM_DEBUG_ATOMIC("[CRTC:%d] disabled, rejecting legacy flip\n", 2796 crtc->base.id); 2797 ret = -EINVAL; 2798 goto fail; 2799 } 2800 2801 ret = drm_atomic_nonblocking_commit(state); 2802 fail: 2803 if (ret == -EDEADLK) 2804 goto backoff; 2805 2806 drm_atomic_state_put(state); 2807 return ret; 2808 2809 backoff: 2810 drm_atomic_state_clear(state); 2811 drm_atomic_legacy_backoff(state); 2812 2813 /* 2814 * Someone might have exchanged the framebuffer while we dropped locks 2815 * in the backoff code. We need to fix up the fb refcount tracking the 2816 * core does for us. 2817 */ 2818 plane->old_fb = plane->fb; 2819 2820 goto retry; 2821 } 2822 EXPORT_SYMBOL(drm_atomic_helper_page_flip); 2823 2824 /** 2825 * drm_atomic_helper_connector_dpms() - connector dpms helper implementation 2826 * @connector: affected connector 2827 * @mode: DPMS mode 2828 * 2829 * This is the main helper function provided by the atomic helper framework for 2830 * implementing the legacy DPMS connector interface. It computes the new desired 2831 * ->active state for the corresponding CRTC (if the connector is enabled) and 2832 * updates it. 2833 * 2834 * Returns: 2835 * Returns 0 on success, negative errno numbers on failure. 2836 */ 2837 int drm_atomic_helper_connector_dpms(struct drm_connector *connector, 2838 int mode) 2839 { 2840 struct drm_mode_config *config = &connector->dev->mode_config; 2841 struct drm_atomic_state *state; 2842 struct drm_crtc_state *crtc_state; 2843 struct drm_crtc *crtc; 2844 struct drm_connector *tmp_connector; 2845 int ret; 2846 bool active = false; 2847 int old_mode = connector->dpms; 2848 2849 if (mode != DRM_MODE_DPMS_ON) 2850 mode = DRM_MODE_DPMS_OFF; 2851 2852 connector->dpms = mode; 2853 crtc = connector->state->crtc; 2854 2855 if (!crtc) 2856 return 0; 2857 2858 state = drm_atomic_state_alloc(connector->dev); 2859 if (!state) 2860 return -ENOMEM; 2861 2862 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 2863 retry: 2864 crtc_state = drm_atomic_get_crtc_state(state, crtc); 2865 if (IS_ERR(crtc_state)) { 2866 ret = PTR_ERR(crtc_state); 2867 goto fail; 2868 } 2869 2870 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); 2871 2872 drm_for_each_connector(tmp_connector, connector->dev) { 2873 if (tmp_connector->state->crtc != crtc) 2874 continue; 2875 2876 if (tmp_connector->dpms == DRM_MODE_DPMS_ON) { 2877 active = true; 2878 break; 2879 } 2880 } 2881 crtc_state->active = active; 2882 2883 ret = drm_atomic_commit(state); 2884 fail: 2885 if (ret == -EDEADLK) 2886 goto backoff; 2887 if (ret != 0) 2888 connector->dpms = old_mode; 2889 drm_atomic_state_put(state); 2890 return ret; 2891 2892 backoff: 2893 drm_atomic_state_clear(state); 2894 drm_atomic_legacy_backoff(state); 2895 2896 goto retry; 2897 } 2898 EXPORT_SYMBOL(drm_atomic_helper_connector_dpms); 2899 2900 /** 2901 * drm_atomic_helper_best_encoder - Helper for &drm_connector_helper_funcs 2902 * ->best_encoder callback 2903 * @connector: Connector control structure 2904 * 2905 * This is a &drm_connector_helper_funcs ->best_encoder callback helper for 2906 * connectors that support exactly 1 encoder, statically determined at driver 2907 * init time. 2908 */ 2909 struct drm_encoder * 2910 drm_atomic_helper_best_encoder(struct drm_connector *connector) 2911 { 2912 WARN_ON(connector->encoder_ids[1]); 2913 return drm_encoder_find(connector->dev, connector->encoder_ids[0]); 2914 } 2915 EXPORT_SYMBOL(drm_atomic_helper_best_encoder); 2916 2917 /** 2918 * DOC: atomic state reset and initialization 2919 * 2920 * Both the drm core and the atomic helpers assume that there is always the full 2921 * and correct atomic software state for all connectors, CRTCs and planes 2922 * available. Which is a bit a problem on driver load and also after system 2923 * suspend. One way to solve this is to have a hardware state read-out 2924 * infrastructure which reconstructs the full software state (e.g. the i915 2925 * driver). 2926 * 2927 * The simpler solution is to just reset the software state to everything off, 2928 * which is easiest to do by calling drm_mode_config_reset(). To facilitate this 2929 * the atomic helpers provide default reset implementations for all hooks. 2930 * 2931 * On the upside the precise state tracking of atomic simplifies system suspend 2932 * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe 2933 * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume(). 2934 * For other drivers the building blocks are split out, see the documentation 2935 * for these functions. 2936 */ 2937 2938 /** 2939 * drm_atomic_helper_crtc_reset - default ->reset hook for CRTCs 2940 * @crtc: drm CRTC 2941 * 2942 * Resets the atomic state for @crtc by freeing the state pointer (which might 2943 * be NULL, e.g. at driver load time) and allocating a new empty state object. 2944 */ 2945 void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc) 2946 { 2947 if (crtc->state) 2948 __drm_atomic_helper_crtc_destroy_state(crtc->state); 2949 2950 kfree(crtc->state); 2951 crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL); 2952 2953 if (crtc->state) 2954 crtc->state->crtc = crtc; 2955 } 2956 EXPORT_SYMBOL(drm_atomic_helper_crtc_reset); 2957 2958 /** 2959 * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state 2960 * @crtc: CRTC object 2961 * @state: atomic CRTC state 2962 * 2963 * Copies atomic state from a CRTC's current state and resets inferred values. 2964 * This is useful for drivers that subclass the CRTC state. 2965 */ 2966 void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc, 2967 struct drm_crtc_state *state) 2968 { 2969 memcpy(state, crtc->state, sizeof(*state)); 2970 2971 if (state->mode_blob) 2972 drm_property_reference_blob(state->mode_blob); 2973 if (state->degamma_lut) 2974 drm_property_reference_blob(state->degamma_lut); 2975 if (state->ctm) 2976 drm_property_reference_blob(state->ctm); 2977 if (state->gamma_lut) 2978 drm_property_reference_blob(state->gamma_lut); 2979 state->mode_changed = false; 2980 state->active_changed = false; 2981 state->planes_changed = false; 2982 state->connectors_changed = false; 2983 state->color_mgmt_changed = false; 2984 state->zpos_changed = false; 2985 state->event = NULL; 2986 } 2987 EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state); 2988 2989 /** 2990 * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook 2991 * @crtc: drm CRTC 2992 * 2993 * Default CRTC state duplicate hook for drivers which don't have their own 2994 * subclassed CRTC state structure. 2995 */ 2996 struct drm_crtc_state * 2997 drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc) 2998 { 2999 struct drm_crtc_state *state; 3000 3001 if (WARN_ON(!crtc->state)) 3002 return NULL; 3003 3004 state = kmalloc(sizeof(*state), GFP_KERNEL); 3005 if (state) 3006 __drm_atomic_helper_crtc_duplicate_state(crtc, state); 3007 3008 return state; 3009 } 3010 EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state); 3011 3012 /** 3013 * __drm_atomic_helper_crtc_destroy_state - release CRTC state 3014 * @state: CRTC state object to release 3015 * 3016 * Releases all resources stored in the CRTC state without actually freeing 3017 * the memory of the CRTC state. This is useful for drivers that subclass the 3018 * CRTC state. 3019 */ 3020 void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state) 3021 { 3022 drm_property_unreference_blob(state->mode_blob); 3023 drm_property_unreference_blob(state->degamma_lut); 3024 drm_property_unreference_blob(state->ctm); 3025 drm_property_unreference_blob(state->gamma_lut); 3026 } 3027 EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state); 3028 3029 /** 3030 * drm_atomic_helper_crtc_destroy_state - default state destroy hook 3031 * @crtc: drm CRTC 3032 * @state: CRTC state object to release 3033 * 3034 * Default CRTC state destroy hook for drivers which don't have their own 3035 * subclassed CRTC state structure. 3036 */ 3037 void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc, 3038 struct drm_crtc_state *state) 3039 { 3040 __drm_atomic_helper_crtc_destroy_state(state); 3041 kfree(state); 3042 } 3043 EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state); 3044 3045 /** 3046 * drm_atomic_helper_plane_reset - default ->reset hook for planes 3047 * @plane: drm plane 3048 * 3049 * Resets the atomic state for @plane by freeing the state pointer (which might 3050 * be NULL, e.g. at driver load time) and allocating a new empty state object. 3051 */ 3052 void drm_atomic_helper_plane_reset(struct drm_plane *plane) 3053 { 3054 if (plane->state) 3055 __drm_atomic_helper_plane_destroy_state(plane->state); 3056 3057 kfree(plane->state); 3058 plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL); 3059 3060 if (plane->state) { 3061 plane->state->plane = plane; 3062 plane->state->rotation = DRM_ROTATE_0; 3063 } 3064 } 3065 EXPORT_SYMBOL(drm_atomic_helper_plane_reset); 3066 3067 /** 3068 * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state 3069 * @plane: plane object 3070 * @state: atomic plane state 3071 * 3072 * Copies atomic state from a plane's current state. This is useful for 3073 * drivers that subclass the plane state. 3074 */ 3075 void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane, 3076 struct drm_plane_state *state) 3077 { 3078 memcpy(state, plane->state, sizeof(*state)); 3079 3080 if (state->fb) 3081 drm_framebuffer_reference(state->fb); 3082 3083 state->fence = NULL; 3084 } 3085 EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state); 3086 3087 /** 3088 * drm_atomic_helper_plane_duplicate_state - default state duplicate hook 3089 * @plane: drm plane 3090 * 3091 * Default plane state duplicate hook for drivers which don't have their own 3092 * subclassed plane state structure. 3093 */ 3094 struct drm_plane_state * 3095 drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane) 3096 { 3097 struct drm_plane_state *state; 3098 3099 if (WARN_ON(!plane->state)) 3100 return NULL; 3101 3102 state = kmalloc(sizeof(*state), GFP_KERNEL); 3103 if (state) 3104 __drm_atomic_helper_plane_duplicate_state(plane, state); 3105 3106 return state; 3107 } 3108 EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state); 3109 3110 /** 3111 * __drm_atomic_helper_plane_destroy_state - release plane state 3112 * @state: plane state object to release 3113 * 3114 * Releases all resources stored in the plane state without actually freeing 3115 * the memory of the plane state. This is useful for drivers that subclass the 3116 * plane state. 3117 */ 3118 void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state) 3119 { 3120 if (state->fb) 3121 drm_framebuffer_unreference(state->fb); 3122 3123 if (state->fence) 3124 dma_fence_put(state->fence); 3125 } 3126 EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state); 3127 3128 /** 3129 * drm_atomic_helper_plane_destroy_state - default state destroy hook 3130 * @plane: drm plane 3131 * @state: plane state object to release 3132 * 3133 * Default plane state destroy hook for drivers which don't have their own 3134 * subclassed plane state structure. 3135 */ 3136 void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane, 3137 struct drm_plane_state *state) 3138 { 3139 __drm_atomic_helper_plane_destroy_state(state); 3140 kfree(state); 3141 } 3142 EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state); 3143 3144 /** 3145 * __drm_atomic_helper_connector_reset - reset state on connector 3146 * @connector: drm connector 3147 * @conn_state: connector state to assign 3148 * 3149 * Initializes the newly allocated @conn_state and assigns it to 3150 * #connector ->state, usually required when initializing the drivers 3151 * or when called from the ->reset hook. 3152 * 3153 * This is useful for drivers that subclass the connector state. 3154 */ 3155 void 3156 __drm_atomic_helper_connector_reset(struct drm_connector *connector, 3157 struct drm_connector_state *conn_state) 3158 { 3159 if (conn_state) 3160 conn_state->connector = connector; 3161 3162 connector->state = conn_state; 3163 } 3164 EXPORT_SYMBOL(__drm_atomic_helper_connector_reset); 3165 3166 /** 3167 * drm_atomic_helper_connector_reset - default ->reset hook for connectors 3168 * @connector: drm connector 3169 * 3170 * Resets the atomic state for @connector by freeing the state pointer (which 3171 * might be NULL, e.g. at driver load time) and allocating a new empty state 3172 * object. 3173 */ 3174 void drm_atomic_helper_connector_reset(struct drm_connector *connector) 3175 { 3176 struct drm_connector_state *conn_state = 3177 kzalloc(sizeof(*conn_state), GFP_KERNEL); 3178 3179 if (connector->state) 3180 __drm_atomic_helper_connector_destroy_state(connector->state); 3181 3182 kfree(connector->state); 3183 __drm_atomic_helper_connector_reset(connector, conn_state); 3184 } 3185 EXPORT_SYMBOL(drm_atomic_helper_connector_reset); 3186 3187 /** 3188 * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state 3189 * @connector: connector object 3190 * @state: atomic connector state 3191 * 3192 * Copies atomic state from a connector's current state. This is useful for 3193 * drivers that subclass the connector state. 3194 */ 3195 void 3196 __drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector, 3197 struct drm_connector_state *state) 3198 { 3199 memcpy(state, connector->state, sizeof(*state)); 3200 if (state->crtc) 3201 drm_connector_reference(connector); 3202 } 3203 EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state); 3204 3205 /** 3206 * drm_atomic_helper_connector_duplicate_state - default state duplicate hook 3207 * @connector: drm connector 3208 * 3209 * Default connector state duplicate hook for drivers which don't have their own 3210 * subclassed connector state structure. 3211 */ 3212 struct drm_connector_state * 3213 drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector) 3214 { 3215 struct drm_connector_state *state; 3216 3217 if (WARN_ON(!connector->state)) 3218 return NULL; 3219 3220 state = kmalloc(sizeof(*state), GFP_KERNEL); 3221 if (state) 3222 __drm_atomic_helper_connector_duplicate_state(connector, state); 3223 3224 return state; 3225 } 3226 EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state); 3227 3228 /** 3229 * drm_atomic_helper_duplicate_state - duplicate an atomic state object 3230 * @dev: DRM device 3231 * @ctx: lock acquisition context 3232 * 3233 * Makes a copy of the current atomic state by looping over all objects and 3234 * duplicating their respective states. This is used for example by suspend/ 3235 * resume support code to save the state prior to suspend such that it can 3236 * be restored upon resume. 3237 * 3238 * Note that this treats atomic state as persistent between save and restore. 3239 * Drivers must make sure that this is possible and won't result in confusion 3240 * or erroneous behaviour. 3241 * 3242 * Note that if callers haven't already acquired all modeset locks this might 3243 * return -EDEADLK, which must be handled by calling drm_modeset_backoff(). 3244 * 3245 * Returns: 3246 * A pointer to the copy of the atomic state object on success or an 3247 * ERR_PTR()-encoded error code on failure. 3248 * 3249 * See also: 3250 * drm_atomic_helper_suspend(), drm_atomic_helper_resume() 3251 */ 3252 struct drm_atomic_state * 3253 drm_atomic_helper_duplicate_state(struct drm_device *dev, 3254 struct drm_modeset_acquire_ctx *ctx) 3255 { 3256 struct drm_atomic_state *state; 3257 struct drm_connector *conn; 3258 struct drm_plane *plane; 3259 struct drm_crtc *crtc; 3260 int err = 0; 3261 3262 state = drm_atomic_state_alloc(dev); 3263 if (!state) 3264 return ERR_PTR(-ENOMEM); 3265 3266 state->acquire_ctx = ctx; 3267 3268 drm_for_each_crtc(crtc, dev) { 3269 struct drm_crtc_state *crtc_state; 3270 3271 crtc_state = drm_atomic_get_crtc_state(state, crtc); 3272 if (IS_ERR(crtc_state)) { 3273 err = PTR_ERR(crtc_state); 3274 goto free; 3275 } 3276 } 3277 3278 drm_for_each_plane(plane, dev) { 3279 struct drm_plane_state *plane_state; 3280 3281 plane_state = drm_atomic_get_plane_state(state, plane); 3282 if (IS_ERR(plane_state)) { 3283 err = PTR_ERR(plane_state); 3284 goto free; 3285 } 3286 } 3287 3288 drm_for_each_connector(conn, dev) { 3289 struct drm_connector_state *conn_state; 3290 3291 conn_state = drm_atomic_get_connector_state(state, conn); 3292 if (IS_ERR(conn_state)) { 3293 err = PTR_ERR(conn_state); 3294 goto free; 3295 } 3296 } 3297 3298 /* clear the acquire context so that it isn't accidentally reused */ 3299 state->acquire_ctx = NULL; 3300 3301 free: 3302 if (err < 0) { 3303 drm_atomic_state_put(state); 3304 state = ERR_PTR(err); 3305 } 3306 3307 return state; 3308 } 3309 EXPORT_SYMBOL(drm_atomic_helper_duplicate_state); 3310 3311 /** 3312 * __drm_atomic_helper_connector_destroy_state - release connector state 3313 * @state: connector state object to release 3314 * 3315 * Releases all resources stored in the connector state without actually 3316 * freeing the memory of the connector state. This is useful for drivers that 3317 * subclass the connector state. 3318 */ 3319 void 3320 __drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state) 3321 { 3322 /* 3323 * This is currently a placeholder so that drivers that subclass the 3324 * state will automatically do the right thing if code is ever added 3325 * to this function. 3326 */ 3327 if (state->crtc) 3328 drm_connector_unreference(state->connector); 3329 } 3330 EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state); 3331 3332 /** 3333 * drm_atomic_helper_connector_destroy_state - default state destroy hook 3334 * @connector: drm connector 3335 * @state: connector state object to release 3336 * 3337 * Default connector state destroy hook for drivers which don't have their own 3338 * subclassed connector state structure. 3339 */ 3340 void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector, 3341 struct drm_connector_state *state) 3342 { 3343 __drm_atomic_helper_connector_destroy_state(state); 3344 kfree(state); 3345 } 3346 EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state); 3347 3348 /** 3349 * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table 3350 * @crtc: CRTC object 3351 * @red: red correction table 3352 * @green: green correction table 3353 * @blue: green correction table 3354 * @size: size of the tables 3355 * 3356 * Implements support for legacy gamma correction table for drivers 3357 * that support color management through the DEGAMMA_LUT/GAMMA_LUT 3358 * properties. 3359 */ 3360 int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc, 3361 u16 *red, u16 *green, u16 *blue, 3362 uint32_t size) 3363 { 3364 struct drm_device *dev = crtc->dev; 3365 struct drm_mode_config *config = &dev->mode_config; 3366 struct drm_atomic_state *state; 3367 struct drm_crtc_state *crtc_state; 3368 struct drm_property_blob *blob = NULL; 3369 struct drm_color_lut *blob_data; 3370 int i, ret = 0; 3371 3372 state = drm_atomic_state_alloc(crtc->dev); 3373 if (!state) 3374 return -ENOMEM; 3375 3376 blob = drm_property_create_blob(dev, 3377 sizeof(struct drm_color_lut) * size, 3378 NULL); 3379 if (IS_ERR(blob)) { 3380 ret = PTR_ERR(blob); 3381 blob = NULL; 3382 goto fail; 3383 } 3384 3385 /* Prepare GAMMA_LUT with the legacy values. */ 3386 blob_data = (struct drm_color_lut *) blob->data; 3387 for (i = 0; i < size; i++) { 3388 blob_data[i].red = red[i]; 3389 blob_data[i].green = green[i]; 3390 blob_data[i].blue = blue[i]; 3391 } 3392 3393 state->acquire_ctx = crtc->dev->mode_config.acquire_ctx; 3394 retry: 3395 crtc_state = drm_atomic_get_crtc_state(state, crtc); 3396 if (IS_ERR(crtc_state)) { 3397 ret = PTR_ERR(crtc_state); 3398 goto fail; 3399 } 3400 3401 /* Reset DEGAMMA_LUT and CTM properties. */ 3402 ret = drm_atomic_crtc_set_property(crtc, crtc_state, 3403 config->degamma_lut_property, 0); 3404 if (ret) 3405 goto fail; 3406 3407 ret = drm_atomic_crtc_set_property(crtc, crtc_state, 3408 config->ctm_property, 0); 3409 if (ret) 3410 goto fail; 3411 3412 ret = drm_atomic_crtc_set_property(crtc, crtc_state, 3413 config->gamma_lut_property, blob->base.id); 3414 if (ret) 3415 goto fail; 3416 3417 ret = drm_atomic_commit(state); 3418 fail: 3419 if (ret == -EDEADLK) 3420 goto backoff; 3421 3422 drm_atomic_state_put(state); 3423 drm_property_unreference_blob(blob); 3424 return ret; 3425 3426 backoff: 3427 drm_atomic_state_clear(state); 3428 drm_atomic_legacy_backoff(state); 3429 3430 goto retry; 3431 } 3432 EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set); 3433