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