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