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