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