1 /* 2 * Copyright (C) 2014 Red Hat 3 * Copyright (C) 2014 Intel Corp. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be included in 13 * all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 21 * OTHER DEALINGS IN THE SOFTWARE. 22 * 23 * Authors: 24 * Rob Clark <robdclark@gmail.com> 25 * Daniel Vetter <daniel.vetter@ffwll.ch> 26 */ 27 28 #include <drm/drmP.h> 29 #include <drm/drm_atomic.h> 30 #include <drm/drm_plane_helper.h> 31 #include <drm/drm_crtc_helper.h> 32 #include <drm/drm_atomic_helper.h> 33 #include <linux/fence.h> 34 35 /** 36 * DOC: overview 37 * 38 * This helper library provides implementations of check and commit functions on 39 * top of the CRTC modeset helper callbacks and the plane helper callbacks. It 40 * also provides convenience implementations for the atomic state handling 41 * callbacks for drivers which don't need to subclass the drm core structures to 42 * add their own additional internal state. 43 * 44 * This library also provides default implementations for the check callback in 45 * drm_atomic_helper_check and for the commit callback with 46 * drm_atomic_helper_commit. But the individual stages and callbacks are expose 47 * to allow drivers to mix and match and e.g. use the plane helpers only 48 * together with a driver private modeset implementation. 49 * 50 * This library also provides implementations for all the legacy driver 51 * interfaces on top of the atomic interface. See drm_atomic_helper_set_config, 52 * drm_atomic_helper_disable_plane, drm_atomic_helper_disable_plane and the 53 * various functions to implement set_property callbacks. New drivers must not 54 * implement these functions themselves but must use the provided helpers. 55 */ 56 static void 57 drm_atomic_helper_plane_changed(struct drm_atomic_state *state, 58 struct drm_plane_state *plane_state, 59 struct drm_plane *plane) 60 { 61 struct drm_crtc_state *crtc_state; 62 63 if (plane->state->crtc) { 64 crtc_state = state->crtc_states[drm_crtc_index(plane->state->crtc)]; 65 66 if (WARN_ON(!crtc_state)) 67 return; 68 69 crtc_state->planes_changed = true; 70 } 71 72 if (plane_state->crtc) { 73 crtc_state = 74 state->crtc_states[drm_crtc_index(plane_state->crtc)]; 75 76 if (WARN_ON(!crtc_state)) 77 return; 78 79 crtc_state->planes_changed = true; 80 } 81 } 82 83 static struct drm_crtc * 84 get_current_crtc_for_encoder(struct drm_device *dev, 85 struct drm_encoder *encoder) 86 { 87 struct drm_mode_config *config = &dev->mode_config; 88 struct drm_connector *connector; 89 90 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); 91 92 list_for_each_entry(connector, &config->connector_list, head) { 93 if (connector->state->best_encoder != encoder) 94 continue; 95 96 return connector->state->crtc; 97 } 98 99 return NULL; 100 } 101 102 static int 103 steal_encoder(struct drm_atomic_state *state, 104 struct drm_encoder *encoder, 105 struct drm_crtc *encoder_crtc) 106 { 107 struct drm_mode_config *config = &state->dev->mode_config; 108 struct drm_crtc_state *crtc_state; 109 struct drm_connector *connector; 110 struct drm_connector_state *connector_state; 111 int ret; 112 113 /* 114 * We can only steal an encoder coming from a connector, which means we 115 * must already hold the connection_mutex. 116 */ 117 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); 118 119 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d], stealing it\n", 120 encoder->base.id, encoder->name, 121 encoder_crtc->base.id); 122 123 crtc_state = drm_atomic_get_crtc_state(state, encoder_crtc); 124 if (IS_ERR(crtc_state)) 125 return PTR_ERR(crtc_state); 126 127 crtc_state->mode_changed = true; 128 129 list_for_each_entry(connector, &config->connector_list, head) { 130 if (connector->state->best_encoder != encoder) 131 continue; 132 133 DRM_DEBUG_ATOMIC("Stealing encoder from [CONNECTOR:%d:%s]\n", 134 connector->base.id, 135 connector->name); 136 137 connector_state = drm_atomic_get_connector_state(state, 138 connector); 139 if (IS_ERR(connector_state)) 140 return PTR_ERR(connector_state); 141 142 ret = drm_atomic_set_crtc_for_connector(connector_state, NULL); 143 if (ret) 144 return ret; 145 connector_state->best_encoder = NULL; 146 } 147 148 return 0; 149 } 150 151 static int 152 update_connector_routing(struct drm_atomic_state *state, int conn_idx) 153 { 154 const struct drm_connector_helper_funcs *funcs; 155 struct drm_encoder *new_encoder; 156 struct drm_crtc *encoder_crtc; 157 struct drm_connector *connector; 158 struct drm_connector_state *connector_state; 159 struct drm_crtc_state *crtc_state; 160 int idx, ret; 161 162 connector = state->connectors[conn_idx]; 163 connector_state = state->connector_states[conn_idx]; 164 165 if (!connector) 166 return 0; 167 168 DRM_DEBUG_ATOMIC("Updating routing for [CONNECTOR:%d:%s]\n", 169 connector->base.id, 170 connector->name); 171 172 if (connector->state->crtc != connector_state->crtc) { 173 if (connector->state->crtc) { 174 idx = drm_crtc_index(connector->state->crtc); 175 176 crtc_state = state->crtc_states[idx]; 177 crtc_state->mode_changed = true; 178 } 179 180 if (connector_state->crtc) { 181 idx = drm_crtc_index(connector_state->crtc); 182 183 crtc_state = state->crtc_states[idx]; 184 crtc_state->mode_changed = true; 185 } 186 } 187 188 if (!connector_state->crtc) { 189 DRM_DEBUG_ATOMIC("Disabling [CONNECTOR:%d:%s]\n", 190 connector->base.id, 191 connector->name); 192 193 connector_state->best_encoder = NULL; 194 195 return 0; 196 } 197 198 funcs = connector->helper_private; 199 new_encoder = funcs->best_encoder(connector); 200 201 if (!new_encoder) { 202 DRM_DEBUG_ATOMIC("No suitable encoder found for [CONNECTOR:%d:%s]\n", 203 connector->base.id, 204 connector->name); 205 return -EINVAL; 206 } 207 208 if (new_encoder == connector_state->best_encoder) { 209 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on [CRTC:%d]\n", 210 connector->base.id, 211 connector->name, 212 new_encoder->base.id, 213 new_encoder->name, 214 connector_state->crtc->base.id); 215 216 return 0; 217 } 218 219 encoder_crtc = get_current_crtc_for_encoder(state->dev, 220 new_encoder); 221 222 if (encoder_crtc) { 223 ret = steal_encoder(state, new_encoder, encoder_crtc); 224 if (ret) { 225 DRM_DEBUG_ATOMIC("Encoder stealing failed for [CONNECTOR:%d:%s]\n", 226 connector->base.id, 227 connector->name); 228 return ret; 229 } 230 } 231 232 connector_state->best_encoder = new_encoder; 233 idx = drm_crtc_index(connector_state->crtc); 234 235 crtc_state = state->crtc_states[idx]; 236 crtc_state->mode_changed = true; 237 238 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] using [ENCODER:%d:%s] on [CRTC:%d]\n", 239 connector->base.id, 240 connector->name, 241 new_encoder->base.id, 242 new_encoder->name, 243 connector_state->crtc->base.id); 244 245 return 0; 246 } 247 248 static int 249 mode_fixup(struct drm_atomic_state *state) 250 { 251 struct drm_crtc *crtc; 252 struct drm_crtc_state *crtc_state; 253 struct drm_connector *connector; 254 struct drm_connector_state *conn_state; 255 int i; 256 bool ret; 257 258 for_each_crtc_in_state(state, crtc, crtc_state, i) { 259 if (!crtc_state->mode_changed) 260 continue; 261 262 drm_mode_copy(&crtc_state->adjusted_mode, &crtc_state->mode); 263 } 264 265 for_each_connector_in_state(state, connector, conn_state, i) { 266 const struct drm_encoder_helper_funcs *funcs; 267 struct drm_encoder *encoder; 268 269 WARN_ON(!!conn_state->best_encoder != !!conn_state->crtc); 270 271 if (!conn_state->crtc || !conn_state->best_encoder) 272 continue; 273 274 crtc_state = 275 state->crtc_states[drm_crtc_index(conn_state->crtc)]; 276 277 /* 278 * Each encoder has at most one connector (since we always steal 279 * it away), so we won't call ->mode_fixup twice. 280 */ 281 encoder = conn_state->best_encoder; 282 funcs = encoder->helper_private; 283 284 if (encoder->bridge && encoder->bridge->funcs->mode_fixup) { 285 ret = encoder->bridge->funcs->mode_fixup( 286 encoder->bridge, &crtc_state->mode, 287 &crtc_state->adjusted_mode); 288 if (!ret) { 289 DRM_DEBUG_ATOMIC("Bridge fixup failed\n"); 290 return -EINVAL; 291 } 292 } 293 294 if (funcs->atomic_check) { 295 ret = funcs->atomic_check(encoder, crtc_state, 296 conn_state); 297 if (ret) { 298 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] check failed\n", 299 encoder->base.id, encoder->name); 300 return ret; 301 } 302 } else { 303 ret = funcs->mode_fixup(encoder, &crtc_state->mode, 304 &crtc_state->adjusted_mode); 305 if (!ret) { 306 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] fixup failed\n", 307 encoder->base.id, encoder->name); 308 return -EINVAL; 309 } 310 } 311 } 312 313 for_each_crtc_in_state(state, crtc, crtc_state, i) { 314 const struct drm_crtc_helper_funcs *funcs; 315 316 if (!crtc_state->mode_changed) 317 continue; 318 319 funcs = crtc->helper_private; 320 ret = funcs->mode_fixup(crtc, &crtc_state->mode, 321 &crtc_state->adjusted_mode); 322 if (!ret) { 323 DRM_DEBUG_ATOMIC("[CRTC:%d] fixup failed\n", 324 crtc->base.id); 325 return -EINVAL; 326 } 327 } 328 329 return 0; 330 } 331 332 static bool 333 needs_modeset(struct drm_crtc_state *state) 334 { 335 return state->mode_changed || state->active_changed; 336 } 337 338 /** 339 * drm_atomic_helper_check_modeset - validate state object for modeset changes 340 * @dev: DRM device 341 * @state: the driver state object 342 * 343 * Check the state object to see if the requested state is physically possible. 344 * This does all the crtc and connector related computations for an atomic 345 * update. It computes and updates crtc_state->mode_changed, adds any additional 346 * connectors needed for full modesets and calls down into ->mode_fixup 347 * functions of the driver backend. 348 * 349 * IMPORTANT: 350 * 351 * Drivers which update ->mode_changed (e.g. in their ->atomic_check hooks if a 352 * plane update can't be done without a full modeset) _must_ call this function 353 * afterwards after that change. It is permitted to call this function multiple 354 * times for the same update, e.g. when the ->atomic_check functions depend upon 355 * the adjusted dotclock for fifo space allocation and watermark computation. 356 * 357 * RETURNS 358 * Zero for success or -errno 359 */ 360 int 361 drm_atomic_helper_check_modeset(struct drm_device *dev, 362 struct drm_atomic_state *state) 363 { 364 struct drm_crtc *crtc; 365 struct drm_crtc_state *crtc_state; 366 struct drm_connector *connector; 367 struct drm_connector_state *connector_state; 368 int i, ret; 369 370 for_each_crtc_in_state(state, crtc, crtc_state, i) { 371 if (!drm_mode_equal(&crtc->state->mode, &crtc_state->mode)) { 372 DRM_DEBUG_ATOMIC("[CRTC:%d] mode changed\n", 373 crtc->base.id); 374 crtc_state->mode_changed = true; 375 } 376 377 if (crtc->state->enable != crtc_state->enable) { 378 DRM_DEBUG_ATOMIC("[CRTC:%d] enable changed\n", 379 crtc->base.id); 380 crtc_state->mode_changed = true; 381 } 382 } 383 384 for_each_connector_in_state(state, connector, connector_state, i) { 385 /* 386 * This only sets crtc->mode_changed for routing changes, 387 * drivers must set crtc->mode_changed themselves when connector 388 * properties need to be updated. 389 */ 390 ret = update_connector_routing(state, i); 391 if (ret) 392 return ret; 393 } 394 395 /* 396 * After all the routing has been prepared we need to add in any 397 * connector which is itself unchanged, but who's crtc changes it's 398 * configuration. This must be done before calling mode_fixup in case a 399 * crtc only changed its mode but has the same set of connectors. 400 */ 401 for_each_crtc_in_state(state, crtc, crtc_state, i) { 402 int num_connectors; 403 404 /* 405 * We must set ->active_changed after walking connectors for 406 * otherwise an update that only changes active would result in 407 * a full modeset because update_connector_routing force that. 408 */ 409 if (crtc->state->active != crtc_state->active) { 410 DRM_DEBUG_ATOMIC("[CRTC:%d] active changed\n", 411 crtc->base.id); 412 crtc_state->active_changed = true; 413 } 414 415 if (!needs_modeset(crtc_state)) 416 continue; 417 418 DRM_DEBUG_ATOMIC("[CRTC:%d] needs all connectors, enable: %c, active: %c\n", 419 crtc->base.id, 420 crtc_state->enable ? 'y' : 'n', 421 crtc_state->active ? 'y' : 'n'); 422 423 ret = drm_atomic_add_affected_connectors(state, crtc); 424 if (ret != 0) 425 return ret; 426 427 num_connectors = drm_atomic_connectors_for_crtc(state, 428 crtc); 429 430 if (crtc_state->enable != !!num_connectors) { 431 DRM_DEBUG_ATOMIC("[CRTC:%d] enabled/connectors mismatch\n", 432 crtc->base.id); 433 434 return -EINVAL; 435 } 436 } 437 438 return mode_fixup(state); 439 } 440 EXPORT_SYMBOL(drm_atomic_helper_check_modeset); 441 442 /** 443 * drm_atomic_helper_check_planes - validate state object for planes changes 444 * @dev: DRM device 445 * @state: the driver state object 446 * 447 * Check the state object to see if the requested state is physically possible. 448 * This does all the plane update related checks using by calling into the 449 * ->atomic_check hooks provided by the driver. 450 * 451 * RETURNS 452 * Zero for success or -errno 453 */ 454 int 455 drm_atomic_helper_check_planes(struct drm_device *dev, 456 struct drm_atomic_state *state) 457 { 458 struct drm_crtc *crtc; 459 struct drm_crtc_state *crtc_state; 460 struct drm_plane *plane; 461 struct drm_plane_state *plane_state; 462 int i, ret = 0; 463 464 for_each_plane_in_state(state, plane, plane_state, i) { 465 const struct drm_plane_helper_funcs *funcs; 466 467 funcs = plane->helper_private; 468 469 drm_atomic_helper_plane_changed(state, plane_state, plane); 470 471 if (!funcs || !funcs->atomic_check) 472 continue; 473 474 ret = funcs->atomic_check(plane, plane_state); 475 if (ret) { 476 DRM_DEBUG_ATOMIC("[PLANE:%d] atomic driver check failed\n", 477 plane->base.id); 478 return ret; 479 } 480 } 481 482 for_each_crtc_in_state(state, crtc, crtc_state, i) { 483 const struct drm_crtc_helper_funcs *funcs; 484 485 funcs = crtc->helper_private; 486 487 if (!funcs || !funcs->atomic_check) 488 continue; 489 490 ret = funcs->atomic_check(crtc, state->crtc_states[i]); 491 if (ret) { 492 DRM_DEBUG_ATOMIC("[CRTC:%d] atomic driver check failed\n", 493 crtc->base.id); 494 return ret; 495 } 496 } 497 498 return ret; 499 } 500 EXPORT_SYMBOL(drm_atomic_helper_check_planes); 501 502 /** 503 * drm_atomic_helper_check - validate state object 504 * @dev: DRM device 505 * @state: the driver state object 506 * 507 * Check the state object to see if the requested state is physically possible. 508 * Only crtcs and planes have check callbacks, so for any additional (global) 509 * checking that a driver needs it can simply wrap that around this function. 510 * Drivers without such needs can directly use this as their ->atomic_check() 511 * callback. 512 * 513 * This just wraps the two parts of the state checking for planes and modeset 514 * state in the default order: First it calls drm_atomic_helper_check_modeset() 515 * and then drm_atomic_helper_check_planes(). The assumption is that the 516 * ->atomic_check functions depend upon an updated adjusted_mode.clock to 517 * e.g. properly compute watermarks. 518 * 519 * RETURNS 520 * Zero for success or -errno 521 */ 522 int drm_atomic_helper_check(struct drm_device *dev, 523 struct drm_atomic_state *state) 524 { 525 int ret; 526 527 ret = drm_atomic_helper_check_modeset(dev, state); 528 if (ret) 529 return ret; 530 531 ret = drm_atomic_helper_check_planes(dev, state); 532 if (ret) 533 return ret; 534 535 return ret; 536 } 537 EXPORT_SYMBOL(drm_atomic_helper_check); 538 539 static void 540 disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state) 541 { 542 struct drm_connector *connector; 543 struct drm_connector_state *old_conn_state; 544 struct drm_crtc *crtc; 545 struct drm_crtc_state *old_crtc_state; 546 int i; 547 548 for_each_connector_in_state(old_state, connector, old_conn_state, i) { 549 const struct drm_encoder_helper_funcs *funcs; 550 struct drm_encoder *encoder; 551 struct drm_crtc_state *old_crtc_state; 552 553 /* Shut down everything that's in the changeset and currently 554 * still on. So need to check the old, saved state. */ 555 if (!old_conn_state->crtc) 556 continue; 557 558 old_crtc_state = old_state->crtc_states[drm_crtc_index(old_conn_state->crtc)]; 559 560 if (!old_crtc_state->active || 561 !needs_modeset(old_conn_state->crtc->state)) 562 continue; 563 564 encoder = old_conn_state->best_encoder; 565 566 /* We shouldn't get this far if we didn't previously have 567 * an encoder.. but WARN_ON() rather than explode. 568 */ 569 if (WARN_ON(!encoder)) 570 continue; 571 572 funcs = encoder->helper_private; 573 574 DRM_DEBUG_ATOMIC("disabling [ENCODER:%d:%s]\n", 575 encoder->base.id, encoder->name); 576 577 /* 578 * Each encoder has at most one connector (since we always steal 579 * it away), so we won't call disable hooks twice. 580 */ 581 if (encoder->bridge) 582 encoder->bridge->funcs->disable(encoder->bridge); 583 584 /* Right function depends upon target state. */ 585 if (connector->state->crtc && funcs->prepare) 586 funcs->prepare(encoder); 587 else if (funcs->disable) 588 funcs->disable(encoder); 589 else 590 funcs->dpms(encoder, DRM_MODE_DPMS_OFF); 591 592 if (encoder->bridge) 593 encoder->bridge->funcs->post_disable(encoder->bridge); 594 } 595 596 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 597 const struct drm_crtc_helper_funcs *funcs; 598 599 /* Shut down everything that needs a full modeset. */ 600 if (!needs_modeset(crtc->state)) 601 continue; 602 603 if (!old_crtc_state->active) 604 continue; 605 606 funcs = crtc->helper_private; 607 608 DRM_DEBUG_ATOMIC("disabling [CRTC:%d]\n", 609 crtc->base.id); 610 611 612 /* Right function depends upon target state. */ 613 if (crtc->state->enable && funcs->prepare) 614 funcs->prepare(crtc); 615 else if (funcs->disable) 616 funcs->disable(crtc); 617 else 618 funcs->dpms(crtc, DRM_MODE_DPMS_OFF); 619 } 620 } 621 622 static void 623 set_routing_links(struct drm_device *dev, struct drm_atomic_state *old_state) 624 { 625 struct drm_connector *connector; 626 struct drm_connector_state *old_conn_state; 627 struct drm_crtc *crtc; 628 struct drm_crtc_state *old_crtc_state; 629 int i; 630 631 /* clear out existing links */ 632 for_each_connector_in_state(old_state, connector, old_conn_state, i) { 633 if (!connector->encoder) 634 continue; 635 636 WARN_ON(!connector->encoder->crtc); 637 638 connector->encoder->crtc = NULL; 639 connector->encoder = NULL; 640 } 641 642 /* set new links */ 643 for_each_connector_in_state(old_state, connector, old_conn_state, i) { 644 if (!connector->state->crtc) 645 continue; 646 647 if (WARN_ON(!connector->state->best_encoder)) 648 continue; 649 650 connector->encoder = connector->state->best_encoder; 651 connector->encoder->crtc = connector->state->crtc; 652 } 653 654 /* set legacy state in the crtc structure */ 655 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 656 crtc->mode = crtc->state->mode; 657 crtc->enabled = crtc->state->enable; 658 crtc->x = crtc->primary->state->src_x >> 16; 659 crtc->y = crtc->primary->state->src_y >> 16; 660 } 661 } 662 663 static void 664 crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state) 665 { 666 struct drm_crtc *crtc; 667 struct drm_crtc_state *old_crtc_state; 668 struct drm_connector *connector; 669 struct drm_connector_state *old_conn_state; 670 int i; 671 672 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 673 const struct drm_crtc_helper_funcs *funcs; 674 675 if (!crtc->state->mode_changed) 676 continue; 677 678 funcs = crtc->helper_private; 679 680 if (crtc->state->enable && funcs->mode_set_nofb) { 681 DRM_DEBUG_ATOMIC("modeset on [CRTC:%d]\n", 682 crtc->base.id); 683 684 funcs->mode_set_nofb(crtc); 685 } 686 } 687 688 for_each_connector_in_state(old_state, connector, old_conn_state, i) { 689 const struct drm_encoder_helper_funcs *funcs; 690 struct drm_crtc_state *new_crtc_state; 691 struct drm_encoder *encoder; 692 struct drm_display_mode *mode, *adjusted_mode; 693 694 if (!connector->state->best_encoder) 695 continue; 696 697 encoder = connector->state->best_encoder; 698 funcs = encoder->helper_private; 699 new_crtc_state = connector->state->crtc->state; 700 mode = &new_crtc_state->mode; 701 adjusted_mode = &new_crtc_state->adjusted_mode; 702 703 if (!new_crtc_state->mode_changed) 704 continue; 705 706 DRM_DEBUG_ATOMIC("modeset on [ENCODER:%d:%s]\n", 707 encoder->base.id, encoder->name); 708 709 /* 710 * Each encoder has at most one connector (since we always steal 711 * it away), so we won't call mode_set hooks twice. 712 */ 713 if (funcs->mode_set) 714 funcs->mode_set(encoder, mode, adjusted_mode); 715 716 if (encoder->bridge && encoder->bridge->funcs->mode_set) 717 encoder->bridge->funcs->mode_set(encoder->bridge, 718 mode, adjusted_mode); 719 } 720 } 721 722 /** 723 * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs 724 * @dev: DRM device 725 * @old_state: atomic state object with old state structures 726 * 727 * This function shuts down all the outputs that need to be shut down and 728 * prepares them (if required) with the new mode. 729 * 730 * For compatability with legacy crtc helpers this should be called before 731 * drm_atomic_helper_commit_planes(), which is what the default commit function 732 * does. But drivers with different needs can group the modeset commits together 733 * and do the plane commits at the end. This is useful for drivers doing runtime 734 * PM since planes updates then only happen when the CRTC is actually enabled. 735 */ 736 void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev, 737 struct drm_atomic_state *old_state) 738 { 739 disable_outputs(dev, old_state); 740 set_routing_links(dev, old_state); 741 crtc_set_mode(dev, old_state); 742 } 743 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables); 744 745 /** 746 * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs 747 * @dev: DRM device 748 * @old_state: atomic state object with old state structures 749 * 750 * This function enables all the outputs with the new configuration which had to 751 * be turned off for the update. 752 * 753 * For compatability with legacy crtc helpers this should be called after 754 * drm_atomic_helper_commit_planes(), which is what the default commit function 755 * does. But drivers with different needs can group the modeset commits together 756 * and do the plane commits at the end. This is useful for drivers doing runtime 757 * PM since planes updates then only happen when the CRTC is actually enabled. 758 */ 759 void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev, 760 struct drm_atomic_state *old_state) 761 { 762 struct drm_crtc *crtc; 763 struct drm_crtc_state *old_crtc_state; 764 struct drm_connector *connector; 765 struct drm_connector_state *old_conn_state; 766 int i; 767 768 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 769 const struct drm_crtc_helper_funcs *funcs; 770 771 /* Need to filter out CRTCs where only planes change. */ 772 if (!needs_modeset(crtc->state)) 773 continue; 774 775 if (!crtc->state->active) 776 continue; 777 778 funcs = crtc->helper_private; 779 780 if (crtc->state->enable) { 781 DRM_DEBUG_ATOMIC("enabling [CRTC:%d]\n", 782 crtc->base.id); 783 784 if (funcs->enable) 785 funcs->enable(crtc); 786 else 787 funcs->commit(crtc); 788 } 789 } 790 791 for_each_connector_in_state(old_state, connector, old_conn_state, i) { 792 const struct drm_encoder_helper_funcs *funcs; 793 struct drm_encoder *encoder; 794 795 if (!connector->state->best_encoder) 796 continue; 797 798 if (!connector->state->crtc->state->active || 799 !needs_modeset(connector->state->crtc->state)) 800 continue; 801 802 encoder = connector->state->best_encoder; 803 funcs = encoder->helper_private; 804 805 DRM_DEBUG_ATOMIC("enabling [ENCODER:%d:%s]\n", 806 encoder->base.id, encoder->name); 807 808 /* 809 * Each encoder has at most one connector (since we always steal 810 * it away), so we won't call enable hooks twice. 811 */ 812 if (encoder->bridge) 813 encoder->bridge->funcs->pre_enable(encoder->bridge); 814 815 if (funcs->enable) 816 funcs->enable(encoder); 817 else 818 funcs->commit(encoder); 819 820 if (encoder->bridge) 821 encoder->bridge->funcs->enable(encoder->bridge); 822 } 823 } 824 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables); 825 826 static void wait_for_fences(struct drm_device *dev, 827 struct drm_atomic_state *state) 828 { 829 struct drm_plane *plane; 830 struct drm_plane_state *plane_state; 831 int i; 832 833 for_each_plane_in_state(state, plane, plane_state, i) { 834 if (!plane->state->fence) 835 continue; 836 837 WARN_ON(!plane->state->fb); 838 839 #if 0 840 fence_wait(plane->state->fence, false); 841 fence_put(plane->state->fence); 842 #endif 843 plane->state->fence = NULL; 844 } 845 } 846 847 static bool framebuffer_changed(struct drm_device *dev, 848 struct drm_atomic_state *old_state, 849 struct drm_crtc *crtc) 850 { 851 struct drm_plane *plane; 852 struct drm_plane_state *old_plane_state; 853 int i; 854 855 for_each_plane_in_state(old_state, plane, old_plane_state, i) { 856 if (plane->state->crtc != crtc && 857 old_plane_state->crtc != crtc) 858 continue; 859 860 if (plane->state->fb != old_plane_state->fb) 861 return true; 862 } 863 864 return false; 865 } 866 867 /** 868 * drm_atomic_helper_wait_for_vblanks - wait for vblank on crtcs 869 * @dev: DRM device 870 * @old_state: atomic state object with old state structures 871 * 872 * Helper to, after atomic commit, wait for vblanks on all effected 873 * crtcs (ie. before cleaning up old framebuffers using 874 * drm_atomic_helper_cleanup_planes()). It will only wait on crtcs where the 875 * framebuffers have actually changed to optimize for the legacy cursor and 876 * plane update use-case. 877 */ 878 void 879 drm_atomic_helper_wait_for_vblanks(struct drm_device *dev, 880 struct drm_atomic_state *old_state) 881 { 882 struct drm_crtc *crtc; 883 struct drm_crtc_state *old_crtc_state; 884 int i, ret; 885 886 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 887 /* No one cares about the old state, so abuse it for tracking 888 * and store whether we hold a vblank reference (and should do a 889 * vblank wait) in the ->enable boolean. */ 890 old_crtc_state->enable = false; 891 892 if (!crtc->state->enable) 893 continue; 894 895 /* Legacy cursor ioctls are completely unsynced, and userspace 896 * relies on that (by doing tons of cursor updates). */ 897 if (old_state->legacy_cursor_update) 898 continue; 899 900 if (!framebuffer_changed(dev, old_state, crtc)) 901 continue; 902 903 ret = drm_crtc_vblank_get(crtc); 904 if (ret != 0) 905 continue; 906 907 old_crtc_state->enable = true; 908 old_crtc_state->last_vblank_count = drm_vblank_count(dev, i); 909 } 910 911 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 912 if (!old_crtc_state->enable) 913 continue; 914 915 ret = wait_event_timeout(dev->vblank[i].queue, 916 old_crtc_state->last_vblank_count != 917 drm_vblank_count(dev, i), 918 msecs_to_jiffies(50)); 919 920 drm_crtc_vblank_put(crtc); 921 } 922 } 923 EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks); 924 925 /** 926 * drm_atomic_helper_commit - commit validated state object 927 * @dev: DRM device 928 * @state: the driver state object 929 * @async: asynchronous commit 930 * 931 * This function commits a with drm_atomic_helper_check() pre-validated state 932 * object. This can still fail when e.g. the framebuffer reservation fails. For 933 * now this doesn't implement asynchronous commits. 934 * 935 * RETURNS 936 * Zero for success or -errno. 937 */ 938 int drm_atomic_helper_commit(struct drm_device *dev, 939 struct drm_atomic_state *state, 940 bool async) 941 { 942 int ret; 943 944 if (async) 945 return -EBUSY; 946 947 ret = drm_atomic_helper_prepare_planes(dev, state); 948 if (ret) 949 return ret; 950 951 /* 952 * This is the point of no return - everything below never fails except 953 * when the hw goes bonghits. Which means we can commit the new state on 954 * the software side now. 955 */ 956 957 drm_atomic_helper_swap_state(dev, state); 958 959 /* 960 * Everything below can be run asynchronously without the need to grab 961 * any modeset locks at all under one condition: It must be guaranteed 962 * that the asynchronous work has either been cancelled (if the driver 963 * supports it, which at least requires that the framebuffers get 964 * cleaned up with drm_atomic_helper_cleanup_planes()) or completed 965 * before the new state gets committed on the software side with 966 * drm_atomic_helper_swap_state(). 967 * 968 * This scheme allows new atomic state updates to be prepared and 969 * checked in parallel to the asynchronous completion of the previous 970 * update. Which is important since compositors need to figure out the 971 * composition of the next frame right after having submitted the 972 * current layout. 973 */ 974 975 wait_for_fences(dev, state); 976 977 drm_atomic_helper_commit_modeset_disables(dev, state); 978 979 drm_atomic_helper_commit_planes(dev, state); 980 981 drm_atomic_helper_commit_modeset_enables(dev, state); 982 983 drm_atomic_helper_wait_for_vblanks(dev, state); 984 985 drm_atomic_helper_cleanup_planes(dev, state); 986 987 drm_atomic_state_free(state); 988 989 return 0; 990 } 991 EXPORT_SYMBOL(drm_atomic_helper_commit); 992 993 /** 994 * DOC: implementing async commit 995 * 996 * For now the atomic helpers don't support async commit directly. If there is 997 * real need it could be added though, using the dma-buf fence infrastructure 998 * for generic synchronization with outstanding rendering. 999 * 1000 * For now drivers have to implement async commit themselves, with the following 1001 * sequence being the recommended one: 1002 * 1003 * 1. Run drm_atomic_helper_prepare_planes() first. This is the only function 1004 * which commit needs to call which can fail, so we want to run it first and 1005 * synchronously. 1006 * 1007 * 2. Synchronize with any outstanding asynchronous commit worker threads which 1008 * might be affected the new state update. This can be done by either cancelling 1009 * or flushing the work items, depending upon whether the driver can deal with 1010 * cancelled updates. Note that it is important to ensure that the framebuffer 1011 * cleanup is still done when cancelling. 1012 * 1013 * For sufficient parallelism it is recommended to have a work item per crtc 1014 * (for updates which don't touch global state) and a global one. Then we only 1015 * need to synchronize with the crtc work items for changed crtcs and the global 1016 * work item, which allows nice concurrent updates on disjoint sets of crtcs. 1017 * 1018 * 3. The software state is updated synchronously with 1019 * drm_atomic_helper_swap_state. Doing this under the protection of all modeset 1020 * locks means concurrent callers never see inconsistent state. And doing this 1021 * while it's guaranteed that no relevant async worker runs means that async 1022 * workers do not need grab any locks. Actually they must not grab locks, for 1023 * otherwise the work flushing will deadlock. 1024 * 1025 * 4. Schedule a work item to do all subsequent steps, using the split-out 1026 * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and 1027 * then cleaning up the framebuffers after the old framebuffer is no longer 1028 * being displayed. 1029 */ 1030 1031 /** 1032 * drm_atomic_helper_prepare_planes - prepare plane resources before commit 1033 * @dev: DRM device 1034 * @state: atomic state object with new state structures 1035 * 1036 * This function prepares plane state, specifically framebuffers, for the new 1037 * configuration. If any failure is encountered this function will call 1038 * ->cleanup_fb on any already successfully prepared framebuffer. 1039 * 1040 * Returns: 1041 * 0 on success, negative error code on failure. 1042 */ 1043 int drm_atomic_helper_prepare_planes(struct drm_device *dev, 1044 struct drm_atomic_state *state) 1045 { 1046 int nplanes = dev->mode_config.num_total_plane; 1047 int ret, i; 1048 1049 for (i = 0; i < nplanes; i++) { 1050 const struct drm_plane_helper_funcs *funcs; 1051 struct drm_plane *plane = state->planes[i]; 1052 struct drm_plane_state *plane_state = state->plane_states[i]; 1053 struct drm_framebuffer *fb; 1054 1055 if (!plane) 1056 continue; 1057 1058 funcs = plane->helper_private; 1059 1060 fb = plane_state->fb; 1061 1062 if (fb && funcs->prepare_fb) { 1063 ret = funcs->prepare_fb(plane, fb, plane_state); 1064 if (ret) 1065 goto fail; 1066 } 1067 } 1068 1069 return 0; 1070 1071 fail: 1072 for (i--; i >= 0; i--) { 1073 const struct drm_plane_helper_funcs *funcs; 1074 struct drm_plane *plane = state->planes[i]; 1075 struct drm_plane_state *plane_state = state->plane_states[i]; 1076 struct drm_framebuffer *fb; 1077 1078 if (!plane) 1079 continue; 1080 1081 funcs = plane->helper_private; 1082 1083 fb = state->plane_states[i]->fb; 1084 1085 if (fb && funcs->cleanup_fb) 1086 funcs->cleanup_fb(plane, fb, plane_state); 1087 1088 } 1089 1090 return ret; 1091 } 1092 EXPORT_SYMBOL(drm_atomic_helper_prepare_planes); 1093 1094 /** 1095 * drm_atomic_helper_commit_planes - commit plane state 1096 * @dev: DRM device 1097 * @old_state: atomic state object with old state structures 1098 * 1099 * This function commits the new plane state using the plane and atomic helper 1100 * functions for planes and crtcs. It assumes that the atomic state has already 1101 * been pushed into the relevant object state pointers, since this step can no 1102 * longer fail. 1103 * 1104 * It still requires the global state object @old_state to know which planes and 1105 * crtcs need to be updated though. 1106 */ 1107 void drm_atomic_helper_commit_planes(struct drm_device *dev, 1108 struct drm_atomic_state *old_state) 1109 { 1110 struct drm_crtc *crtc; 1111 struct drm_crtc_state *old_crtc_state; 1112 struct drm_plane *plane; 1113 struct drm_plane_state *old_plane_state; 1114 int i; 1115 1116 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 1117 const struct drm_crtc_helper_funcs *funcs; 1118 1119 funcs = crtc->helper_private; 1120 1121 if (!funcs || !funcs->atomic_begin) 1122 continue; 1123 1124 funcs->atomic_begin(crtc); 1125 } 1126 1127 for_each_plane_in_state(old_state, plane, old_plane_state, i) { 1128 const struct drm_plane_helper_funcs *funcs; 1129 1130 funcs = plane->helper_private; 1131 1132 if (!funcs) 1133 continue; 1134 1135 old_plane_state = old_state->plane_states[i]; 1136 1137 /* 1138 * Special-case disabling the plane if drivers support it. 1139 */ 1140 if (drm_atomic_plane_disabling(plane, old_plane_state) && 1141 funcs->atomic_disable) 1142 funcs->atomic_disable(plane, old_plane_state); 1143 else 1144 funcs->atomic_update(plane, old_plane_state); 1145 } 1146 1147 for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) { 1148 const struct drm_crtc_helper_funcs *funcs; 1149 1150 funcs = crtc->helper_private; 1151 1152 if (!funcs || !funcs->atomic_flush) 1153 continue; 1154 1155 funcs->atomic_flush(crtc); 1156 } 1157 } 1158 EXPORT_SYMBOL(drm_atomic_helper_commit_planes); 1159 1160 /** 1161 * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit 1162 * @dev: DRM device 1163 * @old_state: atomic state object with old state structures 1164 * 1165 * This function cleans up plane state, specifically framebuffers, from the old 1166 * configuration. Hence the old configuration must be perserved in @old_state to 1167 * be able to call this function. 1168 * 1169 * This function must also be called on the new state when the atomic update 1170 * fails at any point after calling drm_atomic_helper_prepare_planes(). 1171 */ 1172 void drm_atomic_helper_cleanup_planes(struct drm_device *dev, 1173 struct drm_atomic_state *old_state) 1174 { 1175 struct drm_plane *plane; 1176 struct drm_plane_state *plane_state; 1177 int i; 1178 1179 for_each_plane_in_state(old_state, plane, plane_state, i) { 1180 const struct drm_plane_helper_funcs *funcs; 1181 struct drm_framebuffer *old_fb; 1182 1183 funcs = plane->helper_private; 1184 1185 old_fb = plane_state->fb; 1186 1187 if (old_fb && funcs->cleanup_fb) 1188 funcs->cleanup_fb(plane, old_fb, plane_state); 1189 } 1190 } 1191 EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes); 1192 1193 /** 1194 * drm_atomic_helper_swap_state - store atomic state into current sw state 1195 * @dev: DRM device 1196 * @state: atomic state 1197 * 1198 * This function stores the atomic state into the current state pointers in all 1199 * driver objects. It should be called after all failing steps have been done 1200 * and succeeded, but before the actual hardware state is committed. 1201 * 1202 * For cleanup and error recovery the current state for all changed objects will 1203 * be swaped into @state. 1204 * 1205 * With that sequence it fits perfectly into the plane prepare/cleanup sequence: 1206 * 1207 * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state. 1208 * 1209 * 2. Do any other steps that might fail. 1210 * 1211 * 3. Put the staged state into the current state pointers with this function. 1212 * 1213 * 4. Actually commit the hardware state. 1214 * 1215 * 5. Call drm_atomic_helper_cleanup_planes with @state, which since step 3 1216 * contains the old state. Also do any other cleanup required with that state. 1217 */ 1218 void drm_atomic_helper_swap_state(struct drm_device *dev, 1219 struct drm_atomic_state *state) 1220 { 1221 int i; 1222 1223 for (i = 0; i < dev->mode_config.num_connector; i++) { 1224 struct drm_connector *connector = state->connectors[i]; 1225 1226 if (!connector) 1227 continue; 1228 1229 connector->state->state = state; 1230 swap(state->connector_states[i], connector->state); 1231 connector->state->state = NULL; 1232 } 1233 1234 for (i = 0; i < dev->mode_config.num_crtc; i++) { 1235 struct drm_crtc *crtc = state->crtcs[i]; 1236 1237 if (!crtc) 1238 continue; 1239 1240 crtc->state->state = state; 1241 swap(state->crtc_states[i], crtc->state); 1242 crtc->state->state = NULL; 1243 } 1244 1245 for (i = 0; i < dev->mode_config.num_total_plane; i++) { 1246 struct drm_plane *plane = state->planes[i]; 1247 1248 if (!plane) 1249 continue; 1250 1251 plane->state->state = state; 1252 swap(state->plane_states[i], plane->state); 1253 plane->state->state = NULL; 1254 } 1255 } 1256 EXPORT_SYMBOL(drm_atomic_helper_swap_state); 1257 1258 /** 1259 * drm_atomic_helper_update_plane - Helper for primary plane update using atomic 1260 * @plane: plane object to update 1261 * @crtc: owning CRTC of owning plane 1262 * @fb: framebuffer to flip onto plane 1263 * @crtc_x: x offset of primary plane on crtc 1264 * @crtc_y: y offset of primary plane on crtc 1265 * @crtc_w: width of primary plane rectangle on crtc 1266 * @crtc_h: height of primary plane rectangle on crtc 1267 * @src_x: x offset of @fb for panning 1268 * @src_y: y offset of @fb for panning 1269 * @src_w: width of source rectangle in @fb 1270 * @src_h: height of source rectangle in @fb 1271 * 1272 * Provides a default plane update handler using the atomic driver interface. 1273 * 1274 * RETURNS: 1275 * Zero on success, error code on failure 1276 */ 1277 int drm_atomic_helper_update_plane(struct drm_plane *plane, 1278 struct drm_crtc *crtc, 1279 struct drm_framebuffer *fb, 1280 int crtc_x, int crtc_y, 1281 unsigned int crtc_w, unsigned int crtc_h, 1282 uint32_t src_x, uint32_t src_y, 1283 uint32_t src_w, uint32_t src_h) 1284 { 1285 struct drm_atomic_state *state; 1286 struct drm_plane_state *plane_state; 1287 int ret = 0; 1288 1289 state = drm_atomic_state_alloc(plane->dev); 1290 if (!state) 1291 return -ENOMEM; 1292 1293 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 1294 retry: 1295 plane_state = drm_atomic_get_plane_state(state, plane); 1296 if (IS_ERR(plane_state)) { 1297 ret = PTR_ERR(plane_state); 1298 goto fail; 1299 } 1300 1301 ret = drm_atomic_set_crtc_for_plane(plane_state, crtc); 1302 if (ret != 0) 1303 goto fail; 1304 drm_atomic_set_fb_for_plane(plane_state, fb); 1305 plane_state->crtc_x = crtc_x; 1306 plane_state->crtc_y = crtc_y; 1307 plane_state->crtc_h = crtc_h; 1308 plane_state->crtc_w = crtc_w; 1309 plane_state->src_x = src_x; 1310 plane_state->src_y = src_y; 1311 plane_state->src_h = src_h; 1312 plane_state->src_w = src_w; 1313 1314 ret = drm_atomic_commit(state); 1315 if (ret != 0) 1316 goto fail; 1317 1318 if (plane == crtc->cursor) 1319 state->legacy_cursor_update = true; 1320 1321 /* Driver takes ownership of state on successful commit. */ 1322 return 0; 1323 fail: 1324 if (ret == -EDEADLK) 1325 goto backoff; 1326 1327 drm_atomic_state_free(state); 1328 1329 return ret; 1330 backoff: 1331 drm_atomic_state_clear(state); 1332 drm_atomic_legacy_backoff(state); 1333 1334 /* 1335 * Someone might have exchanged the framebuffer while we dropped locks 1336 * in the backoff code. We need to fix up the fb refcount tracking the 1337 * core does for us. 1338 */ 1339 plane->old_fb = plane->fb; 1340 1341 goto retry; 1342 } 1343 EXPORT_SYMBOL(drm_atomic_helper_update_plane); 1344 1345 /** 1346 * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic 1347 * @plane: plane to disable 1348 * 1349 * Provides a default plane disable handler using the atomic driver interface. 1350 * 1351 * RETURNS: 1352 * Zero on success, error code on failure 1353 */ 1354 int drm_atomic_helper_disable_plane(struct drm_plane *plane) 1355 { 1356 struct drm_atomic_state *state; 1357 struct drm_plane_state *plane_state; 1358 int ret = 0; 1359 1360 /* 1361 * FIXME: Without plane->crtc set we can't get at the implicit legacy 1362 * acquire context. The real fix will be to wire the acquire ctx through 1363 * everywhere we need it, but meanwhile prevent chaos by just skipping 1364 * this noop. The critical case is the cursor ioctls which a) only grab 1365 * crtc/cursor-plane locks (so we need the crtc to get at the right 1366 * acquire context) and b) can try to disable the plane multiple times. 1367 */ 1368 if (!plane->crtc) 1369 return 0; 1370 1371 state = drm_atomic_state_alloc(plane->dev); 1372 if (!state) 1373 return -ENOMEM; 1374 1375 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(plane->crtc); 1376 retry: 1377 plane_state = drm_atomic_get_plane_state(state, plane); 1378 if (IS_ERR(plane_state)) { 1379 ret = PTR_ERR(plane_state); 1380 goto fail; 1381 } 1382 1383 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL); 1384 if (ret != 0) 1385 goto fail; 1386 drm_atomic_set_fb_for_plane(plane_state, NULL); 1387 plane_state->crtc_x = 0; 1388 plane_state->crtc_y = 0; 1389 plane_state->crtc_h = 0; 1390 plane_state->crtc_w = 0; 1391 plane_state->src_x = 0; 1392 plane_state->src_y = 0; 1393 plane_state->src_h = 0; 1394 plane_state->src_w = 0; 1395 1396 if (plane == plane->crtc->cursor) 1397 state->legacy_cursor_update = true; 1398 1399 ret = drm_atomic_commit(state); 1400 if (ret != 0) 1401 goto fail; 1402 1403 /* Driver takes ownership of state on successful commit. */ 1404 return 0; 1405 fail: 1406 if (ret == -EDEADLK) 1407 goto backoff; 1408 1409 drm_atomic_state_free(state); 1410 1411 return ret; 1412 backoff: 1413 drm_atomic_state_clear(state); 1414 drm_atomic_legacy_backoff(state); 1415 1416 /* 1417 * Someone might have exchanged the framebuffer while we dropped locks 1418 * in the backoff code. We need to fix up the fb refcount tracking the 1419 * core does for us. 1420 */ 1421 plane->old_fb = plane->fb; 1422 1423 goto retry; 1424 } 1425 EXPORT_SYMBOL(drm_atomic_helper_disable_plane); 1426 1427 static int update_output_state(struct drm_atomic_state *state, 1428 struct drm_mode_set *set) 1429 { 1430 struct drm_device *dev = set->crtc->dev; 1431 struct drm_crtc *crtc; 1432 struct drm_crtc_state *crtc_state; 1433 struct drm_connector *connector; 1434 struct drm_connector_state *conn_state; 1435 int ret, i, j; 1436 1437 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, 1438 state->acquire_ctx); 1439 if (ret) 1440 return ret; 1441 1442 /* First grab all affected connector/crtc states. */ 1443 for (i = 0; i < set->num_connectors; i++) { 1444 conn_state = drm_atomic_get_connector_state(state, 1445 set->connectors[i]); 1446 if (IS_ERR(conn_state)) 1447 return PTR_ERR(conn_state); 1448 } 1449 1450 for_each_crtc_in_state(state, crtc, crtc_state, i) { 1451 ret = drm_atomic_add_affected_connectors(state, crtc); 1452 if (ret) 1453 return ret; 1454 } 1455 1456 /* Then recompute connector->crtc links and crtc enabling state. */ 1457 for_each_connector_in_state(state, connector, conn_state, i) { 1458 if (conn_state->crtc == set->crtc) { 1459 ret = drm_atomic_set_crtc_for_connector(conn_state, 1460 NULL); 1461 if (ret) 1462 return ret; 1463 } 1464 1465 for (j = 0; j < set->num_connectors; j++) { 1466 if (set->connectors[j] == connector) { 1467 ret = drm_atomic_set_crtc_for_connector(conn_state, 1468 set->crtc); 1469 if (ret) 1470 return ret; 1471 break; 1472 } 1473 } 1474 } 1475 1476 for_each_crtc_in_state(state, crtc, crtc_state, i) { 1477 /* Don't update ->enable for the CRTC in the set_config request, 1478 * since a mismatch would indicate a bug in the upper layers. 1479 * The actual modeset code later on will catch any 1480 * inconsistencies here. */ 1481 if (crtc == set->crtc) 1482 continue; 1483 1484 crtc_state->enable = 1485 drm_atomic_connectors_for_crtc(state, crtc); 1486 } 1487 1488 return 0; 1489 } 1490 1491 /** 1492 * drm_atomic_helper_set_config - set a new config from userspace 1493 * @set: mode set configuration 1494 * 1495 * Provides a default crtc set_config handler using the atomic driver interface. 1496 * 1497 * Returns: 1498 * Returns 0 on success, negative errno numbers on failure. 1499 */ 1500 int drm_atomic_helper_set_config(struct drm_mode_set *set) 1501 { 1502 struct drm_atomic_state *state; 1503 struct drm_crtc *crtc = set->crtc; 1504 struct drm_crtc_state *crtc_state; 1505 struct drm_plane_state *primary_state; 1506 int ret = 0; 1507 1508 state = drm_atomic_state_alloc(crtc->dev); 1509 if (!state) 1510 return -ENOMEM; 1511 1512 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 1513 retry: 1514 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1515 if (IS_ERR(crtc_state)) { 1516 ret = PTR_ERR(crtc_state); 1517 goto fail; 1518 } 1519 1520 primary_state = drm_atomic_get_plane_state(state, crtc->primary); 1521 if (IS_ERR(primary_state)) { 1522 ret = PTR_ERR(primary_state); 1523 goto fail; 1524 } 1525 1526 if (!set->mode) { 1527 WARN_ON(set->fb); 1528 WARN_ON(set->num_connectors); 1529 1530 crtc_state->enable = false; 1531 crtc_state->active = false; 1532 1533 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL); 1534 if (ret != 0) 1535 goto fail; 1536 1537 drm_atomic_set_fb_for_plane(primary_state, NULL); 1538 1539 goto commit; 1540 } 1541 1542 WARN_ON(!set->fb); 1543 WARN_ON(!set->num_connectors); 1544 1545 crtc_state->enable = true; 1546 crtc_state->active = true; 1547 drm_mode_copy(&crtc_state->mode, set->mode); 1548 1549 ret = drm_atomic_set_crtc_for_plane(primary_state, crtc); 1550 if (ret != 0) 1551 goto fail; 1552 drm_atomic_set_fb_for_plane(primary_state, set->fb); 1553 primary_state->crtc_x = 0; 1554 primary_state->crtc_y = 0; 1555 primary_state->crtc_h = set->mode->vdisplay; 1556 primary_state->crtc_w = set->mode->hdisplay; 1557 primary_state->src_x = set->x << 16; 1558 primary_state->src_y = set->y << 16; 1559 primary_state->src_h = set->mode->vdisplay << 16; 1560 primary_state->src_w = set->mode->hdisplay << 16; 1561 1562 commit: 1563 ret = update_output_state(state, set); 1564 if (ret) 1565 goto fail; 1566 1567 ret = drm_atomic_commit(state); 1568 if (ret != 0) 1569 goto fail; 1570 1571 /* Driver takes ownership of state on successful commit. */ 1572 return 0; 1573 fail: 1574 if (ret == -EDEADLK) 1575 goto backoff; 1576 1577 drm_atomic_state_free(state); 1578 1579 return ret; 1580 backoff: 1581 drm_atomic_state_clear(state); 1582 drm_atomic_legacy_backoff(state); 1583 1584 /* 1585 * Someone might have exchanged the framebuffer while we dropped locks 1586 * in the backoff code. We need to fix up the fb refcount tracking the 1587 * core does for us. 1588 */ 1589 crtc->primary->old_fb = crtc->primary->fb; 1590 1591 goto retry; 1592 } 1593 EXPORT_SYMBOL(drm_atomic_helper_set_config); 1594 1595 /** 1596 * drm_atomic_helper_crtc_set_property - helper for crtc properties 1597 * @crtc: DRM crtc 1598 * @property: DRM property 1599 * @val: value of property 1600 * 1601 * Provides a default crtc set_property handler using the atomic driver 1602 * interface. 1603 * 1604 * RETURNS: 1605 * Zero on success, error code on failure 1606 */ 1607 int 1608 drm_atomic_helper_crtc_set_property(struct drm_crtc *crtc, 1609 struct drm_property *property, 1610 uint64_t val) 1611 { 1612 struct drm_atomic_state *state; 1613 struct drm_crtc_state *crtc_state; 1614 int ret = 0; 1615 1616 state = drm_atomic_state_alloc(crtc->dev); 1617 if (!state) 1618 return -ENOMEM; 1619 1620 /* ->set_property is always called with all locks held. */ 1621 state->acquire_ctx = crtc->dev->mode_config.acquire_ctx; 1622 retry: 1623 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1624 if (IS_ERR(crtc_state)) { 1625 ret = PTR_ERR(crtc_state); 1626 goto fail; 1627 } 1628 1629 ret = drm_atomic_crtc_set_property(crtc, crtc_state, 1630 property, val); 1631 if (ret) 1632 goto fail; 1633 1634 ret = drm_atomic_commit(state); 1635 if (ret != 0) 1636 goto fail; 1637 1638 /* Driver takes ownership of state on successful commit. */ 1639 return 0; 1640 fail: 1641 if (ret == -EDEADLK) 1642 goto backoff; 1643 1644 drm_atomic_state_free(state); 1645 1646 return ret; 1647 backoff: 1648 drm_atomic_state_clear(state); 1649 drm_atomic_legacy_backoff(state); 1650 1651 goto retry; 1652 } 1653 EXPORT_SYMBOL(drm_atomic_helper_crtc_set_property); 1654 1655 /** 1656 * drm_atomic_helper_plane_set_property - helper for plane properties 1657 * @plane: DRM plane 1658 * @property: DRM property 1659 * @val: value of property 1660 * 1661 * Provides a default plane set_property handler using the atomic driver 1662 * interface. 1663 * 1664 * RETURNS: 1665 * Zero on success, error code on failure 1666 */ 1667 int 1668 drm_atomic_helper_plane_set_property(struct drm_plane *plane, 1669 struct drm_property *property, 1670 uint64_t val) 1671 { 1672 struct drm_atomic_state *state; 1673 struct drm_plane_state *plane_state; 1674 int ret = 0; 1675 1676 state = drm_atomic_state_alloc(plane->dev); 1677 if (!state) 1678 return -ENOMEM; 1679 1680 /* ->set_property is always called with all locks held. */ 1681 state->acquire_ctx = plane->dev->mode_config.acquire_ctx; 1682 retry: 1683 plane_state = drm_atomic_get_plane_state(state, plane); 1684 if (IS_ERR(plane_state)) { 1685 ret = PTR_ERR(plane_state); 1686 goto fail; 1687 } 1688 1689 ret = drm_atomic_plane_set_property(plane, plane_state, 1690 property, val); 1691 if (ret) 1692 goto fail; 1693 1694 ret = drm_atomic_commit(state); 1695 if (ret != 0) 1696 goto fail; 1697 1698 /* Driver takes ownership of state on successful commit. */ 1699 return 0; 1700 fail: 1701 if (ret == -EDEADLK) 1702 goto backoff; 1703 1704 drm_atomic_state_free(state); 1705 1706 return ret; 1707 backoff: 1708 drm_atomic_state_clear(state); 1709 drm_atomic_legacy_backoff(state); 1710 1711 goto retry; 1712 } 1713 EXPORT_SYMBOL(drm_atomic_helper_plane_set_property); 1714 1715 /** 1716 * drm_atomic_helper_connector_set_property - helper for connector properties 1717 * @connector: DRM connector 1718 * @property: DRM property 1719 * @val: value of property 1720 * 1721 * Provides a default connector set_property handler using the atomic driver 1722 * interface. 1723 * 1724 * RETURNS: 1725 * Zero on success, error code on failure 1726 */ 1727 int 1728 drm_atomic_helper_connector_set_property(struct drm_connector *connector, 1729 struct drm_property *property, 1730 uint64_t val) 1731 { 1732 struct drm_atomic_state *state; 1733 struct drm_connector_state *connector_state; 1734 int ret = 0; 1735 1736 state = drm_atomic_state_alloc(connector->dev); 1737 if (!state) 1738 return -ENOMEM; 1739 1740 /* ->set_property is always called with all locks held. */ 1741 state->acquire_ctx = connector->dev->mode_config.acquire_ctx; 1742 retry: 1743 connector_state = drm_atomic_get_connector_state(state, connector); 1744 if (IS_ERR(connector_state)) { 1745 ret = PTR_ERR(connector_state); 1746 goto fail; 1747 } 1748 1749 ret = drm_atomic_connector_set_property(connector, connector_state, 1750 property, val); 1751 if (ret) 1752 goto fail; 1753 1754 ret = drm_atomic_commit(state); 1755 if (ret != 0) 1756 goto fail; 1757 1758 /* Driver takes ownership of state on successful commit. */ 1759 return 0; 1760 fail: 1761 if (ret == -EDEADLK) 1762 goto backoff; 1763 1764 drm_atomic_state_free(state); 1765 1766 return ret; 1767 backoff: 1768 drm_atomic_state_clear(state); 1769 drm_atomic_legacy_backoff(state); 1770 1771 goto retry; 1772 } 1773 EXPORT_SYMBOL(drm_atomic_helper_connector_set_property); 1774 1775 /** 1776 * drm_atomic_helper_page_flip - execute a legacy page flip 1777 * @crtc: DRM crtc 1778 * @fb: DRM framebuffer 1779 * @event: optional DRM event to signal upon completion 1780 * @flags: flip flags for non-vblank sync'ed updates 1781 * 1782 * Provides a default page flip implementation using the atomic driver interface. 1783 * 1784 * Note that for now so called async page flips (i.e. updates which are not 1785 * synchronized to vblank) are not supported, since the atomic interfaces have 1786 * no provisions for this yet. 1787 * 1788 * Returns: 1789 * Returns 0 on success, negative errno numbers on failure. 1790 */ 1791 int drm_atomic_helper_page_flip(struct drm_crtc *crtc, 1792 struct drm_framebuffer *fb, 1793 struct drm_pending_vblank_event *event, 1794 uint32_t flags) 1795 { 1796 struct drm_plane *plane = crtc->primary; 1797 struct drm_atomic_state *state; 1798 struct drm_plane_state *plane_state; 1799 struct drm_crtc_state *crtc_state; 1800 int ret = 0; 1801 1802 if (flags & DRM_MODE_PAGE_FLIP_ASYNC) 1803 return -EINVAL; 1804 1805 state = drm_atomic_state_alloc(plane->dev); 1806 if (!state) 1807 return -ENOMEM; 1808 1809 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 1810 retry: 1811 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1812 if (IS_ERR(crtc_state)) { 1813 ret = PTR_ERR(crtc_state); 1814 goto fail; 1815 } 1816 crtc_state->event = event; 1817 1818 plane_state = drm_atomic_get_plane_state(state, plane); 1819 if (IS_ERR(plane_state)) { 1820 ret = PTR_ERR(plane_state); 1821 goto fail; 1822 } 1823 1824 ret = drm_atomic_set_crtc_for_plane(plane_state, crtc); 1825 if (ret != 0) 1826 goto fail; 1827 drm_atomic_set_fb_for_plane(plane_state, fb); 1828 1829 ret = drm_atomic_async_commit(state); 1830 if (ret != 0) 1831 goto fail; 1832 1833 /* TODO: ->page_flip is the only driver callback where the core 1834 * doesn't update plane->fb. For now patch it up here. */ 1835 plane->fb = plane->state->fb; 1836 1837 /* Driver takes ownership of state on successful async commit. */ 1838 return 0; 1839 fail: 1840 if (ret == -EDEADLK) 1841 goto backoff; 1842 1843 drm_atomic_state_free(state); 1844 1845 return ret; 1846 backoff: 1847 drm_atomic_state_clear(state); 1848 drm_atomic_legacy_backoff(state); 1849 1850 /* 1851 * Someone might have exchanged the framebuffer while we dropped locks 1852 * in the backoff code. We need to fix up the fb refcount tracking the 1853 * core does for us. 1854 */ 1855 plane->old_fb = plane->fb; 1856 1857 goto retry; 1858 } 1859 EXPORT_SYMBOL(drm_atomic_helper_page_flip); 1860 1861 /** 1862 * drm_atomic_helper_connector_dpms() - connector dpms helper implementation 1863 * @connector: affected connector 1864 * @mode: DPMS mode 1865 * 1866 * This is the main helper function provided by the atomic helper framework for 1867 * implementing the legacy DPMS connector interface. It computes the new desired 1868 * ->active state for the corresponding CRTC (if the connector is enabled) and 1869 * updates it. 1870 */ 1871 void drm_atomic_helper_connector_dpms(struct drm_connector *connector, 1872 int mode) 1873 { 1874 struct drm_mode_config *config = &connector->dev->mode_config; 1875 struct drm_atomic_state *state; 1876 struct drm_crtc_state *crtc_state; 1877 struct drm_crtc *crtc; 1878 struct drm_connector *tmp_connector; 1879 int ret; 1880 bool active = false; 1881 1882 if (mode != DRM_MODE_DPMS_ON) 1883 mode = DRM_MODE_DPMS_OFF; 1884 1885 connector->dpms = mode; 1886 crtc = connector->state->crtc; 1887 1888 if (!crtc) 1889 return; 1890 1891 /* FIXME: ->dpms has no return value so can't forward the -ENOMEM. */ 1892 state = drm_atomic_state_alloc(connector->dev); 1893 if (!state) 1894 return; 1895 1896 state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc); 1897 retry: 1898 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1899 if (IS_ERR(crtc_state)) 1900 return; 1901 1902 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); 1903 1904 list_for_each_entry(tmp_connector, &config->connector_list, head) { 1905 if (tmp_connector->state->crtc != crtc) 1906 continue; 1907 1908 if (tmp_connector->dpms == DRM_MODE_DPMS_ON) { 1909 active = true; 1910 break; 1911 } 1912 } 1913 crtc_state->active = active; 1914 1915 ret = drm_atomic_commit(state); 1916 if (ret != 0) 1917 goto fail; 1918 1919 /* Driver takes ownership of state on successful async commit. */ 1920 return; 1921 fail: 1922 if (ret == -EDEADLK) 1923 goto backoff; 1924 1925 drm_atomic_state_free(state); 1926 1927 WARN(1, "Driver bug: Changing ->active failed with ret=%i\n", ret); 1928 1929 return; 1930 backoff: 1931 drm_atomic_state_clear(state); 1932 drm_atomic_legacy_backoff(state); 1933 1934 goto retry; 1935 } 1936 EXPORT_SYMBOL(drm_atomic_helper_connector_dpms); 1937 1938 /** 1939 * DOC: atomic state reset and initialization 1940 * 1941 * Both the drm core and the atomic helpers assume that there is always the full 1942 * and correct atomic software state for all connectors, CRTCs and planes 1943 * available. Which is a bit a problem on driver load and also after system 1944 * suspend. One way to solve this is to have a hardware state read-out 1945 * infrastructure which reconstructs the full software state (e.g. the i915 1946 * driver). 1947 * 1948 * The simpler solution is to just reset the software state to everything off, 1949 * which is easiest to do by calling drm_mode_config_reset(). To facilitate this 1950 * the atomic helpers provide default reset implementations for all hooks. 1951 */ 1952 1953 /** 1954 * drm_atomic_helper_crtc_reset - default ->reset hook for CRTCs 1955 * @crtc: drm CRTC 1956 * 1957 * Resets the atomic state for @crtc by freeing the state pointer (which might 1958 * be NULL, e.g. at driver load time) and allocating a new empty state object. 1959 */ 1960 void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc) 1961 { 1962 kfree(crtc->state); 1963 crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL); 1964 1965 if (crtc->state) 1966 crtc->state->crtc = crtc; 1967 } 1968 EXPORT_SYMBOL(drm_atomic_helper_crtc_reset); 1969 1970 /** 1971 * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state 1972 * @crtc: CRTC object 1973 * @state: atomic CRTC state 1974 * 1975 * Copies atomic state from a CRTC's current state and resets inferred values. 1976 * This is useful for drivers that subclass the CRTC state. 1977 */ 1978 void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc, 1979 struct drm_crtc_state *state) 1980 { 1981 memcpy(state, crtc->state, sizeof(*state)); 1982 1983 state->mode_changed = false; 1984 state->active_changed = false; 1985 state->planes_changed = false; 1986 state->event = NULL; 1987 } 1988 EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state); 1989 1990 /** 1991 * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook 1992 * @crtc: drm CRTC 1993 * 1994 * Default CRTC state duplicate hook for drivers which don't have their own 1995 * subclassed CRTC state structure. 1996 */ 1997 struct drm_crtc_state * 1998 drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc) 1999 { 2000 struct drm_crtc_state *state; 2001 2002 if (WARN_ON(!crtc->state)) 2003 return NULL; 2004 2005 state = kmalloc(sizeof(*state), M_DRM, M_WAITOK); 2006 if (state) 2007 __drm_atomic_helper_crtc_duplicate_state(crtc, state); 2008 2009 return state; 2010 } 2011 EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state); 2012 2013 /** 2014 * __drm_atomic_helper_crtc_destroy_state - release CRTC state 2015 * @crtc: CRTC object 2016 * @state: CRTC state object to release 2017 * 2018 * Releases all resources stored in the CRTC state without actually freeing 2019 * the memory of the CRTC state. This is useful for drivers that subclass the 2020 * CRTC state. 2021 */ 2022 void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc, 2023 struct drm_crtc_state *state) 2024 { 2025 /* 2026 * This is currently a placeholder so that drivers that subclass the 2027 * state will automatically do the right thing if code is ever added 2028 * to this function. 2029 */ 2030 } 2031 EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state); 2032 2033 /** 2034 * drm_atomic_helper_crtc_destroy_state - default state destroy hook 2035 * @crtc: drm CRTC 2036 * @state: CRTC state object to release 2037 * 2038 * Default CRTC state destroy hook for drivers which don't have their own 2039 * subclassed CRTC state structure. 2040 */ 2041 void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc, 2042 struct drm_crtc_state *state) 2043 { 2044 __drm_atomic_helper_crtc_destroy_state(crtc, state); 2045 kfree(state); 2046 } 2047 EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state); 2048 2049 /** 2050 * drm_atomic_helper_plane_reset - default ->reset hook for planes 2051 * @plane: drm plane 2052 * 2053 * Resets the atomic state for @plane by freeing the state pointer (which might 2054 * be NULL, e.g. at driver load time) and allocating a new empty state object. 2055 */ 2056 void drm_atomic_helper_plane_reset(struct drm_plane *plane) 2057 { 2058 if (plane->state && plane->state->fb) 2059 drm_framebuffer_unreference(plane->state->fb); 2060 2061 kfree(plane->state); 2062 plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL); 2063 2064 if (plane->state) 2065 plane->state->plane = plane; 2066 } 2067 EXPORT_SYMBOL(drm_atomic_helper_plane_reset); 2068 2069 /** 2070 * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state 2071 * @plane: plane object 2072 * @state: atomic plane state 2073 * 2074 * Copies atomic state from a plane's current state. This is useful for 2075 * drivers that subclass the plane state. 2076 */ 2077 void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane, 2078 struct drm_plane_state *state) 2079 { 2080 memcpy(state, plane->state, sizeof(*state)); 2081 2082 if (state->fb) 2083 drm_framebuffer_reference(state->fb); 2084 } 2085 EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state); 2086 2087 /** 2088 * drm_atomic_helper_plane_duplicate_state - default state duplicate hook 2089 * @plane: drm plane 2090 * 2091 * Default plane state duplicate hook for drivers which don't have their own 2092 * subclassed plane state structure. 2093 */ 2094 struct drm_plane_state * 2095 drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane) 2096 { 2097 struct drm_plane_state *state; 2098 2099 if (WARN_ON(!plane->state)) 2100 return NULL; 2101 2102 state = kmalloc(sizeof(*state), M_DRM, M_WAITOK); 2103 if (state) 2104 __drm_atomic_helper_plane_duplicate_state(plane, state); 2105 2106 return state; 2107 } 2108 EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state); 2109 2110 /** 2111 * __drm_atomic_helper_plane_destroy_state - release plane state 2112 * @plane: plane object 2113 * @state: plane state object to release 2114 * 2115 * Releases all resources stored in the plane state without actually freeing 2116 * the memory of the plane state. This is useful for drivers that subclass the 2117 * plane state. 2118 */ 2119 void __drm_atomic_helper_plane_destroy_state(struct drm_plane *plane, 2120 struct drm_plane_state *state) 2121 { 2122 if (state->fb) 2123 drm_framebuffer_unreference(state->fb); 2124 } 2125 EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state); 2126 2127 /** 2128 * drm_atomic_helper_plane_destroy_state - default state destroy hook 2129 * @plane: drm plane 2130 * @state: plane state object to release 2131 * 2132 * Default plane state destroy hook for drivers which don't have their own 2133 * subclassed plane state structure. 2134 */ 2135 void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane, 2136 struct drm_plane_state *state) 2137 { 2138 __drm_atomic_helper_plane_destroy_state(plane, state); 2139 kfree(state); 2140 } 2141 EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state); 2142 2143 /** 2144 * drm_atomic_helper_connector_reset - default ->reset hook for connectors 2145 * @connector: drm connector 2146 * 2147 * Resets the atomic state for @connector by freeing the state pointer (which 2148 * might be NULL, e.g. at driver load time) and allocating a new empty state 2149 * object. 2150 */ 2151 void drm_atomic_helper_connector_reset(struct drm_connector *connector) 2152 { 2153 kfree(connector->state); 2154 connector->state = kzalloc(sizeof(*connector->state), GFP_KERNEL); 2155 2156 if (connector->state) 2157 connector->state->connector = connector; 2158 } 2159 EXPORT_SYMBOL(drm_atomic_helper_connector_reset); 2160 2161 /** 2162 * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state 2163 * @connector: connector object 2164 * @state: atomic connector state 2165 * 2166 * Copies atomic state from a connector's current state. This is useful for 2167 * drivers that subclass the connector state. 2168 */ 2169 void 2170 __drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector, 2171 struct drm_connector_state *state) 2172 { 2173 memcpy(state, connector->state, sizeof(*state)); 2174 } 2175 EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state); 2176 2177 /** 2178 * drm_atomic_helper_connector_duplicate_state - default state duplicate hook 2179 * @connector: drm connector 2180 * 2181 * Default connector state duplicate hook for drivers which don't have their own 2182 * subclassed connector state structure. 2183 */ 2184 struct drm_connector_state * 2185 drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector) 2186 { 2187 struct drm_connector_state *state; 2188 2189 if (WARN_ON(!connector->state)) 2190 return NULL; 2191 2192 state = kmalloc(sizeof(*state), M_DRM, M_WAITOK); 2193 if (state) 2194 __drm_atomic_helper_connector_duplicate_state(connector, state); 2195 2196 return state; 2197 } 2198 EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state); 2199 2200 /** 2201 * __drm_atomic_helper_connector_destroy_state - release connector state 2202 * @connector: connector object 2203 * @state: connector state object to release 2204 * 2205 * Releases all resources stored in the connector state without actually 2206 * freeing the memory of the connector state. This is useful for drivers that 2207 * subclass the connector state. 2208 */ 2209 void 2210 __drm_atomic_helper_connector_destroy_state(struct drm_connector *connector, 2211 struct drm_connector_state *state) 2212 { 2213 /* 2214 * This is currently a placeholder so that drivers that subclass the 2215 * state will automatically do the right thing if code is ever added 2216 * to this function. 2217 */ 2218 } 2219 EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state); 2220 2221 /** 2222 * drm_atomic_helper_connector_destroy_state - default state destroy hook 2223 * @connector: drm connector 2224 * @state: connector state object to release 2225 * 2226 * Default connector state destroy hook for drivers which don't have their own 2227 * subclassed connector state structure. 2228 */ 2229 void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector, 2230 struct drm_connector_state *state) 2231 { 2232 __drm_atomic_helper_connector_destroy_state(connector, state); 2233 kfree(state); 2234 } 2235 EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state); 2236