1 /* 2 * Copyright (c) 2006-2008 Intel Corporation 3 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie> 4 * 5 * DRM core CRTC related functions 6 * 7 * Permission to use, copy, modify, distribute, and sell this software and its 8 * documentation for any purpose is hereby granted without fee, provided that 9 * the above copyright notice appear in all copies and that both that copyright 10 * notice and this permission notice appear in supporting documentation, and 11 * that the name of the copyright holders not be used in advertising or 12 * publicity pertaining to distribution of the software without specific, 13 * written prior permission. The copyright holders make no representations 14 * about the suitability of this software for any purpose. It is provided "as 15 * is" without express or implied warranty. 16 * 17 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 18 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 19 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR 20 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 21 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 22 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 23 * OF THIS SOFTWARE. 24 * 25 * Authors: 26 * Keith Packard 27 * Eric Anholt <eric@anholt.net> 28 * Dave Airlie <airlied@linux.ie> 29 * Jesse Barnes <jesse.barnes@intel.com> 30 */ 31 32 #include <linux/kernel.h> 33 #include <linux/export.h> 34 #include <linux/moduleparam.h> 35 36 #include <drm/drmP.h> 37 #include <drm/drm_atomic.h> 38 #include <drm/drm_crtc.h> 39 #include <drm/drm_fourcc.h> 40 #include <drm/drm_crtc_helper.h> 41 #include <drm/drm_fb_helper.h> 42 #include <drm/drm_plane_helper.h> 43 #include <drm/drm_atomic_helper.h> 44 #include <drm/drm_edid.h> 45 46 /** 47 * DOC: overview 48 * 49 * The CRTC modeset helper library provides a default set_config implementation 50 * in drm_crtc_helper_set_config(). Plus a few other convenience functions using 51 * the same callbacks which drivers can use to e.g. restore the modeset 52 * configuration on resume with drm_helper_resume_force_mode(). 53 * 54 * Note that this helper library doesn't track the current power state of CRTCs 55 * and encoders. It can call callbacks like ->dpms() even though the hardware is 56 * already in the desired state. This deficiency has been fixed in the atomic 57 * helpers. 58 * 59 * The driver callbacks are mostly compatible with the atomic modeset helpers, 60 * except for the handling of the primary plane: Atomic helpers require that the 61 * primary plane is implemented as a real standalone plane and not directly tied 62 * to the CRTC state. For easier transition this library provides functions to 63 * implement the old semantics required by the CRTC helpers using the new plane 64 * and atomic helper callbacks. 65 * 66 * Drivers are strongly urged to convert to the atomic helpers (by way of first 67 * converting to the plane helpers). New drivers must not use these functions 68 * but need to implement the atomic interface instead, potentially using the 69 * atomic helpers for that. 70 * 71 * These legacy modeset helpers use the same function table structures as 72 * all other modesetting helpers. See the documentation for struct 73 * &drm_crtc_helper_funcs, struct &drm_encoder_helper_funcs and struct 74 * &drm_connector_helper_funcs. 75 */ 76 77 /** 78 * drm_helper_move_panel_connectors_to_head() - move panels to the front in the 79 * connector list 80 * @dev: drm device to operate on 81 * 82 * Some userspace presumes that the first connected connector is the main 83 * display, where it's supposed to display e.g. the login screen. For 84 * laptops, this should be the main panel. Use this function to sort all 85 * (eDP/LVDS) panels to the front of the connector list, instead of 86 * painstakingly trying to initialize them in the right order. 87 */ 88 void drm_helper_move_panel_connectors_to_head(struct drm_device *dev) 89 { 90 struct drm_connector *connector, *tmp; 91 struct list_head panel_list; 92 93 INIT_LIST_HEAD(&panel_list); 94 95 list_for_each_entry_safe(connector, tmp, 96 &dev->mode_config.connector_list, head) { 97 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS || 98 connector->connector_type == DRM_MODE_CONNECTOR_eDP) 99 list_move_tail(&connector->head, &panel_list); 100 } 101 102 list_splice(&panel_list, &dev->mode_config.connector_list); 103 } 104 EXPORT_SYMBOL(drm_helper_move_panel_connectors_to_head); 105 106 /** 107 * drm_helper_encoder_in_use - check if a given encoder is in use 108 * @encoder: encoder to check 109 * 110 * Checks whether @encoder is with the current mode setting output configuration 111 * in use by any connector. This doesn't mean that it is actually enabled since 112 * the DPMS state is tracked separately. 113 * 114 * Returns: 115 * True if @encoder is used, false otherwise. 116 */ 117 bool drm_helper_encoder_in_use(struct drm_encoder *encoder) 118 { 119 struct drm_connector *connector; 120 struct drm_device *dev = encoder->dev; 121 122 /* 123 * We can expect this mutex to be locked if we are not panicking. 124 * Locking is currently fubar in the panic handler. 125 */ 126 #if 0 127 if (!oops_in_progress) { 128 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex)); 129 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex)); 130 } 131 #endif 132 133 drm_for_each_connector(connector, dev) 134 if (connector->encoder == encoder) 135 return true; 136 return false; 137 } 138 EXPORT_SYMBOL(drm_helper_encoder_in_use); 139 140 /** 141 * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config 142 * @crtc: CRTC to check 143 * 144 * Checks whether @crtc is with the current mode setting output configuration 145 * in use by any connector. This doesn't mean that it is actually enabled since 146 * the DPMS state is tracked separately. 147 * 148 * Returns: 149 * True if @crtc is used, false otherwise. 150 */ 151 bool drm_helper_crtc_in_use(struct drm_crtc *crtc) 152 { 153 struct drm_encoder *encoder; 154 struct drm_device *dev = crtc->dev; 155 156 /* 157 * We can expect this mutex to be locked if we are not panicking. 158 * Locking is currently fubar in the panic handler. 159 */ 160 #if 0 161 if (!oops_in_progress) 162 #endif 163 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex)); 164 165 drm_for_each_encoder(encoder, dev) 166 if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder)) 167 return true; 168 return false; 169 } 170 EXPORT_SYMBOL(drm_helper_crtc_in_use); 171 172 static void 173 drm_encoder_disable(struct drm_encoder *encoder) 174 { 175 const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private; 176 177 if (!encoder_funcs) 178 return; 179 180 drm_bridge_disable(encoder->bridge); 181 182 if (encoder_funcs->disable) 183 (*encoder_funcs->disable)(encoder); 184 else if (encoder_funcs->dpms) 185 (*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF); 186 187 drm_bridge_post_disable(encoder->bridge); 188 } 189 190 static void __drm_helper_disable_unused_functions(struct drm_device *dev) 191 { 192 struct drm_encoder *encoder; 193 struct drm_crtc *crtc; 194 195 drm_warn_on_modeset_not_all_locked(dev); 196 197 drm_for_each_encoder(encoder, dev) { 198 if (!drm_helper_encoder_in_use(encoder)) { 199 drm_encoder_disable(encoder); 200 /* disconnect encoder from any connector */ 201 encoder->crtc = NULL; 202 } 203 } 204 205 drm_for_each_crtc(crtc, dev) { 206 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 207 crtc->enabled = drm_helper_crtc_in_use(crtc); 208 if (!crtc->enabled) { 209 if (crtc_funcs->disable) 210 (*crtc_funcs->disable)(crtc); 211 else 212 (*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF); 213 crtc->primary->fb = NULL; 214 } 215 } 216 } 217 218 /** 219 * drm_helper_disable_unused_functions - disable unused objects 220 * @dev: DRM device 221 * 222 * This function walks through the entire mode setting configuration of @dev. It 223 * will remove any CRTC links of unused encoders and encoder links of 224 * disconnected connectors. Then it will disable all unused encoders and CRTCs 225 * either by calling their disable callback if available or by calling their 226 * dpms callback with DRM_MODE_DPMS_OFF. 227 * 228 * NOTE: 229 * 230 * This function is part of the legacy modeset helper library and will cause 231 * major confusion with atomic drivers. This is because atomic helpers guarantee 232 * to never call ->disable() hooks on a disabled function, or ->enable() hooks 233 * on an enabled functions. drm_helper_disable_unused_functions() on the other 234 * hand throws such guarantees into the wind and calls disable hooks 235 * unconditionally on unused functions. 236 */ 237 void drm_helper_disable_unused_functions(struct drm_device *dev) 238 { 239 drm_modeset_lock_all(dev); 240 __drm_helper_disable_unused_functions(dev); 241 drm_modeset_unlock_all(dev); 242 } 243 EXPORT_SYMBOL(drm_helper_disable_unused_functions); 244 245 /* 246 * Check the CRTC we're going to map each output to vs. its current 247 * CRTC. If they don't match, we have to disable the output and the CRTC 248 * since the driver will have to re-route things. 249 */ 250 static void 251 drm_crtc_prepare_encoders(struct drm_device *dev) 252 { 253 const struct drm_encoder_helper_funcs *encoder_funcs; 254 struct drm_encoder *encoder; 255 256 drm_for_each_encoder(encoder, dev) { 257 encoder_funcs = encoder->helper_private; 258 if (!encoder_funcs) 259 continue; 260 261 /* Disable unused encoders */ 262 if (encoder->crtc == NULL) 263 drm_encoder_disable(encoder); 264 /* Disable encoders whose CRTC is about to change */ 265 if (encoder_funcs->get_crtc && 266 encoder->crtc != (*encoder_funcs->get_crtc)(encoder)) 267 drm_encoder_disable(encoder); 268 } 269 } 270 271 /** 272 * drm_crtc_helper_set_mode - internal helper to set a mode 273 * @crtc: CRTC to program 274 * @mode: mode to use 275 * @x: horizontal offset into the surface 276 * @y: vertical offset into the surface 277 * @old_fb: old framebuffer, for cleanup 278 * 279 * Try to set @mode on @crtc. Give @crtc and its associated connectors a chance 280 * to fixup or reject the mode prior to trying to set it. This is an internal 281 * helper that drivers could e.g. use to update properties that require the 282 * entire output pipe to be disabled and re-enabled in a new configuration. For 283 * example for changing whether audio is enabled on a hdmi link or for changing 284 * panel fitter or dither attributes. It is also called by the 285 * drm_crtc_helper_set_config() helper function to drive the mode setting 286 * sequence. 287 * 288 * Returns: 289 * True if the mode was set successfully, false otherwise. 290 */ 291 bool drm_crtc_helper_set_mode(struct drm_crtc *crtc, 292 struct drm_display_mode *mode, 293 int x, int y, 294 struct drm_framebuffer *old_fb) 295 { 296 struct drm_device *dev = crtc->dev; 297 struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode; 298 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 299 const struct drm_encoder_helper_funcs *encoder_funcs; 300 int saved_x, saved_y; 301 bool saved_enabled; 302 struct drm_encoder *encoder; 303 bool ret = true; 304 305 drm_warn_on_modeset_not_all_locked(dev); 306 307 saved_enabled = crtc->enabled; 308 crtc->enabled = drm_helper_crtc_in_use(crtc); 309 if (!crtc->enabled) 310 return true; 311 312 adjusted_mode = drm_mode_duplicate(dev, mode); 313 if (!adjusted_mode) { 314 crtc->enabled = saved_enabled; 315 return false; 316 } 317 318 saved_mode = crtc->mode; 319 saved_hwmode = crtc->hwmode; 320 saved_x = crtc->x; 321 saved_y = crtc->y; 322 323 /* Update crtc values up front so the driver can rely on them for mode 324 * setting. 325 */ 326 crtc->mode = *mode; 327 crtc->x = x; 328 crtc->y = y; 329 330 /* Pass our mode to the connectors and the CRTC to give them a chance to 331 * adjust it according to limitations or connector properties, and also 332 * a chance to reject the mode entirely. 333 */ 334 drm_for_each_encoder(encoder, dev) { 335 336 if (encoder->crtc != crtc) 337 continue; 338 339 encoder_funcs = encoder->helper_private; 340 if (!encoder_funcs) 341 continue; 342 343 ret = drm_bridge_mode_fixup(encoder->bridge, 344 mode, adjusted_mode); 345 if (!ret) { 346 DRM_DEBUG_KMS("Bridge fixup failed\n"); 347 goto done; 348 } 349 350 encoder_funcs = encoder->helper_private; 351 if (encoder_funcs->mode_fixup) { 352 if (!(ret = encoder_funcs->mode_fixup(encoder, mode, 353 adjusted_mode))) { 354 DRM_DEBUG_KMS("Encoder fixup failed\n"); 355 goto done; 356 } 357 } 358 } 359 360 if (crtc_funcs->mode_fixup) { 361 if (!(ret = crtc_funcs->mode_fixup(crtc, mode, 362 adjusted_mode))) { 363 DRM_DEBUG_KMS("CRTC fixup failed\n"); 364 goto done; 365 } 366 } 367 DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name); 368 369 crtc->hwmode = *adjusted_mode; 370 371 /* Prepare the encoders and CRTCs before setting the mode. */ 372 drm_for_each_encoder(encoder, dev) { 373 374 if (encoder->crtc != crtc) 375 continue; 376 377 encoder_funcs = encoder->helper_private; 378 if (!encoder_funcs) 379 continue; 380 381 drm_bridge_disable(encoder->bridge); 382 383 /* Disable the encoders as the first thing we do. */ 384 if (encoder_funcs->prepare) 385 encoder_funcs->prepare(encoder); 386 387 drm_bridge_post_disable(encoder->bridge); 388 } 389 390 drm_crtc_prepare_encoders(dev); 391 392 crtc_funcs->prepare(crtc); 393 394 /* Set up the DPLL and any encoders state that needs to adjust or depend 395 * on the DPLL. 396 */ 397 ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb); 398 if (!ret) 399 goto done; 400 401 drm_for_each_encoder(encoder, dev) { 402 403 if (encoder->crtc != crtc) 404 continue; 405 406 encoder_funcs = encoder->helper_private; 407 if (!encoder_funcs) 408 continue; 409 410 DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n", 411 encoder->base.id, encoder->name, 412 mode->base.id, mode->name); 413 if (encoder_funcs->mode_set) 414 encoder_funcs->mode_set(encoder, mode, adjusted_mode); 415 416 drm_bridge_mode_set(encoder->bridge, mode, adjusted_mode); 417 } 418 419 /* Now enable the clocks, plane, pipe, and connectors that we set up. */ 420 crtc_funcs->commit(crtc); 421 422 drm_for_each_encoder(encoder, dev) { 423 424 if (encoder->crtc != crtc) 425 continue; 426 427 encoder_funcs = encoder->helper_private; 428 if (!encoder_funcs) 429 continue; 430 431 drm_bridge_pre_enable(encoder->bridge); 432 433 if (encoder_funcs->commit) 434 encoder_funcs->commit(encoder); 435 436 drm_bridge_enable(encoder->bridge); 437 } 438 439 /* Calculate and store various constants which 440 * are later needed by vblank and swap-completion 441 * timestamping. They are derived from true hwmode. 442 */ 443 drm_calc_timestamping_constants(crtc, &crtc->hwmode); 444 445 /* FIXME: add subpixel order */ 446 done: 447 drm_mode_destroy(dev, adjusted_mode); 448 if (!ret) { 449 crtc->enabled = saved_enabled; 450 crtc->mode = saved_mode; 451 crtc->hwmode = saved_hwmode; 452 crtc->x = saved_x; 453 crtc->y = saved_y; 454 } 455 456 return ret; 457 } 458 EXPORT_SYMBOL(drm_crtc_helper_set_mode); 459 460 static void 461 drm_crtc_helper_disable(struct drm_crtc *crtc) 462 { 463 struct drm_device *dev = crtc->dev; 464 struct drm_connector *connector; 465 struct drm_encoder *encoder; 466 467 /* Decouple all encoders and their attached connectors from this crtc */ 468 drm_for_each_encoder(encoder, dev) { 469 if (encoder->crtc != crtc) 470 continue; 471 472 drm_for_each_connector(connector, dev) { 473 if (connector->encoder != encoder) 474 continue; 475 476 connector->encoder = NULL; 477 478 /* 479 * drm_helper_disable_unused_functions() ought to be 480 * doing this, but since we've decoupled the encoder 481 * from the connector above, the required connection 482 * between them is henceforth no longer available. 483 */ 484 connector->dpms = DRM_MODE_DPMS_OFF; 485 486 /* we keep a reference while the encoder is bound */ 487 drm_connector_unreference(connector); 488 } 489 } 490 491 __drm_helper_disable_unused_functions(dev); 492 } 493 494 /** 495 * drm_crtc_helper_set_config - set a new config from userspace 496 * @set: mode set configuration 497 * 498 * The drm_crtc_helper_set_config() helper function implements the set_config 499 * callback of struct &drm_crtc_funcs for drivers using the legacy CRTC helpers. 500 * 501 * It first tries to locate the best encoder for each connector by calling the 502 * connector ->best_encoder() (struct &drm_connector_helper_funcs) helper 503 * operation. 504 * 505 * After locating the appropriate encoders, the helper function will call the 506 * mode_fixup encoder and CRTC helper operations to adjust the requested mode, 507 * or reject it completely in which case an error will be returned to the 508 * application. If the new configuration after mode adjustment is identical to 509 * the current configuration the helper function will return without performing 510 * any other operation. 511 * 512 * If the adjusted mode is identical to the current mode but changes to the 513 * frame buffer need to be applied, the drm_crtc_helper_set_config() function 514 * will call the CRTC ->mode_set_base() (struct &drm_crtc_helper_funcs) helper 515 * operation. 516 * 517 * If the adjusted mode differs from the current mode, or if the 518 * ->mode_set_base() helper operation is not provided, the helper function 519 * performs a full mode set sequence by calling the ->prepare(), ->mode_set() 520 * and ->commit() CRTC and encoder helper operations, in that order. 521 * Alternatively it can also use the dpms and disable helper operations. For 522 * details see struct &drm_crtc_helper_funcs and struct 523 * &drm_encoder_helper_funcs. 524 * 525 * This function is deprecated. New drivers must implement atomic modeset 526 * support, for which this function is unsuitable. Instead drivers should use 527 * drm_atomic_helper_set_config(). 528 * 529 * Returns: 530 * Returns 0 on success, negative errno numbers on failure. 531 */ 532 int drm_crtc_helper_set_config(struct drm_mode_set *set) 533 { 534 struct drm_device *dev; 535 struct drm_crtc **save_encoder_crtcs, *new_crtc; 536 struct drm_encoder **save_connector_encoders, *new_encoder, *encoder; 537 bool mode_changed = false; /* if true do a full mode set */ 538 bool fb_changed = false; /* if true and !mode_changed just do a flip */ 539 struct drm_connector *connector; 540 int count = 0, ro, fail = 0; 541 const struct drm_crtc_helper_funcs *crtc_funcs; 542 struct drm_mode_set save_set; 543 int ret; 544 int i; 545 546 DRM_DEBUG_KMS("\n"); 547 548 BUG_ON(!set); 549 BUG_ON(!set->crtc); 550 BUG_ON(!set->crtc->helper_private); 551 552 /* Enforce sane interface api - has been abused by the fb helper. */ 553 BUG_ON(!set->mode && set->fb); 554 BUG_ON(set->fb && set->num_connectors == 0); 555 556 crtc_funcs = set->crtc->helper_private; 557 558 if (!set->mode) 559 set->fb = NULL; 560 561 if (set->fb) { 562 DRM_DEBUG_KMS("[CRTC:%d:%s] [FB:%d] #connectors=%d (x y) (%i %i)\n", 563 set->crtc->base.id, set->crtc->name, 564 set->fb->base.id, 565 (int)set->num_connectors, set->x, set->y); 566 } else { 567 DRM_DEBUG_KMS("[CRTC:%d:%s] [NOFB]\n", 568 set->crtc->base.id, set->crtc->name); 569 drm_crtc_helper_disable(set->crtc); 570 return 0; 571 } 572 573 dev = set->crtc->dev; 574 575 drm_warn_on_modeset_not_all_locked(dev); 576 577 /* 578 * Allocate space for the backup of all (non-pointer) encoder and 579 * connector data. 580 */ 581 save_encoder_crtcs = kzalloc(dev->mode_config.num_encoder * 582 sizeof(struct drm_crtc *), GFP_KERNEL); 583 if (!save_encoder_crtcs) 584 return -ENOMEM; 585 586 save_connector_encoders = kzalloc(dev->mode_config.num_connector * 587 sizeof(struct drm_encoder *), GFP_KERNEL); 588 if (!save_connector_encoders) { 589 kfree(save_encoder_crtcs); 590 return -ENOMEM; 591 } 592 593 /* 594 * Copy data. Note that driver private data is not affected. 595 * Should anything bad happen only the expected state is 596 * restored, not the drivers personal bookkeeping. 597 */ 598 count = 0; 599 drm_for_each_encoder(encoder, dev) { 600 save_encoder_crtcs[count++] = encoder->crtc; 601 } 602 603 count = 0; 604 drm_for_each_connector(connector, dev) { 605 save_connector_encoders[count++] = connector->encoder; 606 } 607 608 save_set.crtc = set->crtc; 609 save_set.mode = &set->crtc->mode; 610 save_set.x = set->crtc->x; 611 save_set.y = set->crtc->y; 612 save_set.fb = set->crtc->primary->fb; 613 614 /* We should be able to check here if the fb has the same properties 615 * and then just flip_or_move it */ 616 if (set->crtc->primary->fb != set->fb) { 617 /* If we have no fb then treat it as a full mode set */ 618 if (set->crtc->primary->fb == NULL) { 619 DRM_DEBUG_KMS("crtc has no fb, full mode set\n"); 620 mode_changed = true; 621 } else if (set->fb->pixel_format != 622 set->crtc->primary->fb->pixel_format) { 623 mode_changed = true; 624 } else 625 fb_changed = true; 626 } 627 628 if (set->x != set->crtc->x || set->y != set->crtc->y) 629 fb_changed = true; 630 631 if (!drm_mode_equal(set->mode, &set->crtc->mode)) { 632 DRM_DEBUG_KMS("modes are different, full mode set\n"); 633 drm_mode_debug_printmodeline(&set->crtc->mode); 634 drm_mode_debug_printmodeline(set->mode); 635 mode_changed = true; 636 } 637 638 /* take a reference on all unbound connectors in set, reuse the 639 * already taken reference for bound connectors 640 */ 641 for (ro = 0; ro < set->num_connectors; ro++) { 642 if (set->connectors[ro]->encoder) 643 continue; 644 drm_connector_reference(set->connectors[ro]); 645 } 646 647 /* a) traverse passed in connector list and get encoders for them */ 648 count = 0; 649 drm_for_each_connector(connector, dev) { 650 const struct drm_connector_helper_funcs *connector_funcs = 651 connector->helper_private; 652 new_encoder = connector->encoder; 653 for (ro = 0; ro < set->num_connectors; ro++) { 654 if (set->connectors[ro] == connector) { 655 new_encoder = connector_funcs->best_encoder(connector); 656 /* if we can't get an encoder for a connector 657 we are setting now - then fail */ 658 if (new_encoder == NULL) 659 /* don't break so fail path works correct */ 660 fail = 1; 661 662 if (connector->dpms != DRM_MODE_DPMS_ON) { 663 DRM_DEBUG_KMS("connector dpms not on, full mode switch\n"); 664 mode_changed = true; 665 } 666 667 break; 668 } 669 } 670 671 if (new_encoder != connector->encoder) { 672 DRM_DEBUG_KMS("encoder changed, full mode switch\n"); 673 mode_changed = true; 674 /* If the encoder is reused for another connector, then 675 * the appropriate crtc will be set later. 676 */ 677 if (connector->encoder) 678 connector->encoder->crtc = NULL; 679 connector->encoder = new_encoder; 680 } 681 } 682 683 if (fail) { 684 ret = -EINVAL; 685 goto fail; 686 } 687 688 count = 0; 689 drm_for_each_connector(connector, dev) { 690 if (!connector->encoder) 691 continue; 692 693 if (connector->encoder->crtc == set->crtc) 694 new_crtc = NULL; 695 else 696 new_crtc = connector->encoder->crtc; 697 698 for (ro = 0; ro < set->num_connectors; ro++) { 699 if (set->connectors[ro] == connector) 700 new_crtc = set->crtc; 701 } 702 703 /* Make sure the new CRTC will work with the encoder */ 704 if (new_crtc && 705 !drm_encoder_crtc_ok(connector->encoder, new_crtc)) { 706 ret = -EINVAL; 707 goto fail; 708 } 709 if (new_crtc != connector->encoder->crtc) { 710 DRM_DEBUG_KMS("crtc changed, full mode switch\n"); 711 mode_changed = true; 712 connector->encoder->crtc = new_crtc; 713 } 714 if (new_crtc) { 715 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d:%s]\n", 716 connector->base.id, connector->name, 717 new_crtc->base.id, new_crtc->name); 718 } else { 719 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n", 720 connector->base.id, connector->name); 721 } 722 } 723 724 /* mode_set_base is not a required function */ 725 if (fb_changed && !crtc_funcs->mode_set_base) 726 mode_changed = true; 727 728 if (mode_changed) { 729 if (drm_helper_crtc_in_use(set->crtc)) { 730 DRM_DEBUG_KMS("attempting to set mode from" 731 " userspace\n"); 732 drm_mode_debug_printmodeline(set->mode); 733 set->crtc->primary->fb = set->fb; 734 if (!drm_crtc_helper_set_mode(set->crtc, set->mode, 735 set->x, set->y, 736 save_set.fb)) { 737 DRM_ERROR("failed to set mode on [CRTC:%d:%s]\n", 738 set->crtc->base.id, set->crtc->name); 739 set->crtc->primary->fb = save_set.fb; 740 ret = -EINVAL; 741 goto fail; 742 } 743 DRM_DEBUG_KMS("Setting connector DPMS state to on\n"); 744 for (i = 0; i < set->num_connectors; i++) { 745 DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id, 746 set->connectors[i]->name); 747 set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON); 748 } 749 } 750 __drm_helper_disable_unused_functions(dev); 751 } else if (fb_changed) { 752 set->crtc->x = set->x; 753 set->crtc->y = set->y; 754 set->crtc->primary->fb = set->fb; 755 ret = crtc_funcs->mode_set_base(set->crtc, 756 set->x, set->y, save_set.fb); 757 if (ret != 0) { 758 set->crtc->x = save_set.x; 759 set->crtc->y = save_set.y; 760 set->crtc->primary->fb = save_set.fb; 761 goto fail; 762 } 763 } 764 765 kfree(save_connector_encoders); 766 kfree(save_encoder_crtcs); 767 return 0; 768 769 fail: 770 /* Restore all previous data. */ 771 count = 0; 772 drm_for_each_encoder(encoder, dev) { 773 encoder->crtc = save_encoder_crtcs[count++]; 774 } 775 776 count = 0; 777 drm_for_each_connector(connector, dev) { 778 connector->encoder = save_connector_encoders[count++]; 779 } 780 781 /* after fail drop reference on all unbound connectors in set, let 782 * bound connectors keep their reference 783 */ 784 for (ro = 0; ro < set->num_connectors; ro++) { 785 if (set->connectors[ro]->encoder) 786 continue; 787 drm_connector_unreference(set->connectors[ro]); 788 } 789 790 /* Try to restore the config */ 791 if (mode_changed && 792 !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x, 793 save_set.y, save_set.fb)) 794 DRM_ERROR("failed to restore config after modeset failure\n"); 795 796 kfree(save_connector_encoders); 797 kfree(save_encoder_crtcs); 798 return ret; 799 } 800 EXPORT_SYMBOL(drm_crtc_helper_set_config); 801 802 static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder) 803 { 804 int dpms = DRM_MODE_DPMS_OFF; 805 struct drm_connector *connector; 806 struct drm_device *dev = encoder->dev; 807 808 drm_for_each_connector(connector, dev) 809 if (connector->encoder == encoder) 810 if (connector->dpms < dpms) 811 dpms = connector->dpms; 812 return dpms; 813 } 814 815 /* Helper which handles bridge ordering around encoder dpms */ 816 static void drm_helper_encoder_dpms(struct drm_encoder *encoder, int mode) 817 { 818 struct drm_bridge *bridge = encoder->bridge; 819 const struct drm_encoder_helper_funcs *encoder_funcs; 820 821 encoder_funcs = encoder->helper_private; 822 if (!encoder_funcs) 823 return; 824 825 if (mode == DRM_MODE_DPMS_ON) 826 drm_bridge_pre_enable(bridge); 827 else 828 drm_bridge_disable(bridge); 829 830 if (encoder_funcs->dpms) 831 encoder_funcs->dpms(encoder, mode); 832 833 if (mode == DRM_MODE_DPMS_ON) 834 drm_bridge_enable(bridge); 835 else 836 drm_bridge_post_disable(bridge); 837 } 838 839 static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc) 840 { 841 int dpms = DRM_MODE_DPMS_OFF; 842 struct drm_connector *connector; 843 struct drm_device *dev = crtc->dev; 844 845 drm_for_each_connector(connector, dev) 846 if (connector->encoder && connector->encoder->crtc == crtc) 847 if (connector->dpms < dpms) 848 dpms = connector->dpms; 849 return dpms; 850 } 851 852 /** 853 * drm_helper_connector_dpms() - connector dpms helper implementation 854 * @connector: affected connector 855 * @mode: DPMS mode 856 * 857 * The drm_helper_connector_dpms() helper function implements the ->dpms() 858 * callback of struct &drm_connector_funcs for drivers using the legacy CRTC helpers. 859 * 860 * This is the main helper function provided by the CRTC helper framework for 861 * implementing the DPMS connector attribute. It computes the new desired DPMS 862 * state for all encoders and CRTCs in the output mesh and calls the ->dpms() 863 * callbacks provided by the driver in struct &drm_crtc_helper_funcs and struct 864 * &drm_encoder_helper_funcs appropriately. 865 * 866 * This function is deprecated. New drivers must implement atomic modeset 867 * support, for which this function is unsuitable. Instead drivers should use 868 * drm_atomic_helper_connector_dpms(). 869 * 870 * Returns: 871 * Always returns 0. 872 */ 873 int drm_helper_connector_dpms(struct drm_connector *connector, int mode) 874 { 875 struct drm_encoder *encoder = connector->encoder; 876 struct drm_crtc *crtc = encoder ? encoder->crtc : NULL; 877 int old_dpms, encoder_dpms = DRM_MODE_DPMS_OFF; 878 879 if (mode == connector->dpms) 880 return 0; 881 882 old_dpms = connector->dpms; 883 connector->dpms = mode; 884 885 if (encoder) 886 encoder_dpms = drm_helper_choose_encoder_dpms(encoder); 887 888 /* from off to on, do crtc then encoder */ 889 if (mode < old_dpms) { 890 if (crtc) { 891 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 892 if (crtc_funcs->dpms) 893 (*crtc_funcs->dpms) (crtc, 894 drm_helper_choose_crtc_dpms(crtc)); 895 } 896 if (encoder) 897 drm_helper_encoder_dpms(encoder, encoder_dpms); 898 } 899 900 /* from on to off, do encoder then crtc */ 901 if (mode > old_dpms) { 902 if (encoder) 903 drm_helper_encoder_dpms(encoder, encoder_dpms); 904 if (crtc) { 905 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 906 if (crtc_funcs->dpms) 907 (*crtc_funcs->dpms) (crtc, 908 drm_helper_choose_crtc_dpms(crtc)); 909 } 910 } 911 912 return 0; 913 } 914 EXPORT_SYMBOL(drm_helper_connector_dpms); 915 916 /** 917 * drm_helper_mode_fill_fb_struct - fill out framebuffer metadata 918 * @fb: drm_framebuffer object to fill out 919 * @mode_cmd: metadata from the userspace fb creation request 920 * 921 * This helper can be used in a drivers fb_create callback to pre-fill the fb's 922 * metadata fields. 923 */ 924 void drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb, 925 const struct drm_mode_fb_cmd2 *mode_cmd) 926 { 927 int i; 928 929 fb->width = mode_cmd->width; 930 fb->height = mode_cmd->height; 931 for (i = 0; i < 4; i++) { 932 fb->pitches[i] = mode_cmd->pitches[i]; 933 fb->offsets[i] = mode_cmd->offsets[i]; 934 fb->modifier[i] = mode_cmd->modifier[i]; 935 } 936 drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth, 937 &fb->bits_per_pixel); 938 fb->pixel_format = mode_cmd->pixel_format; 939 fb->flags = mode_cmd->flags; 940 } 941 EXPORT_SYMBOL(drm_helper_mode_fill_fb_struct); 942 943 /** 944 * drm_helper_resume_force_mode - force-restore mode setting configuration 945 * @dev: drm_device which should be restored 946 * 947 * Drivers which use the mode setting helpers can use this function to 948 * force-restore the mode setting configuration e.g. on resume or when something 949 * else might have trampled over the hw state (like some overzealous old BIOSen 950 * tended to do). 951 * 952 * This helper doesn't provide a error return value since restoring the old 953 * config should never fail due to resource allocation issues since the driver 954 * has successfully set the restored configuration already. Hence this should 955 * boil down to the equivalent of a few dpms on calls, which also don't provide 956 * an error code. 957 * 958 * Drivers where simply restoring an old configuration again might fail (e.g. 959 * due to slight differences in allocating shared resources when the 960 * configuration is restored in a different order than when userspace set it up) 961 * need to use their own restore logic. 962 * 963 * This function is deprecated. New drivers should implement atomic mode- 964 * setting and use the atomic suspend/resume helpers. 965 * 966 * See also: 967 * drm_atomic_helper_suspend(), drm_atomic_helper_resume() 968 */ 969 void drm_helper_resume_force_mode(struct drm_device *dev) 970 { 971 struct drm_crtc *crtc; 972 struct drm_encoder *encoder; 973 const struct drm_crtc_helper_funcs *crtc_funcs; 974 int encoder_dpms; 975 bool ret; 976 977 drm_modeset_lock_all(dev); 978 drm_for_each_crtc(crtc, dev) { 979 980 if (!crtc->enabled) 981 continue; 982 983 ret = drm_crtc_helper_set_mode(crtc, &crtc->mode, 984 crtc->x, crtc->y, crtc->primary->fb); 985 986 /* Restoring the old config should never fail! */ 987 if (ret == false) 988 DRM_ERROR("failed to set mode on crtc %p\n", crtc); 989 990 /* Turn off outputs that were already powered off */ 991 if (drm_helper_choose_crtc_dpms(crtc)) { 992 drm_for_each_encoder(encoder, dev) { 993 994 if(encoder->crtc != crtc) 995 continue; 996 997 encoder_dpms = drm_helper_choose_encoder_dpms( 998 encoder); 999 1000 drm_helper_encoder_dpms(encoder, encoder_dpms); 1001 } 1002 1003 crtc_funcs = crtc->helper_private; 1004 if (crtc_funcs->dpms) 1005 (*crtc_funcs->dpms) (crtc, 1006 drm_helper_choose_crtc_dpms(crtc)); 1007 } 1008 } 1009 1010 /* disable the unused connectors while restoring the modesetting */ 1011 __drm_helper_disable_unused_functions(dev); 1012 drm_modeset_unlock_all(dev); 1013 } 1014 EXPORT_SYMBOL(drm_helper_resume_force_mode); 1015 1016 /** 1017 * drm_helper_crtc_mode_set - mode_set implementation for atomic plane helpers 1018 * @crtc: DRM CRTC 1019 * @mode: DRM display mode which userspace requested 1020 * @adjusted_mode: DRM display mode adjusted by ->mode_fixup callbacks 1021 * @x: x offset of the CRTC scanout area on the underlying framebuffer 1022 * @y: y offset of the CRTC scanout area on the underlying framebuffer 1023 * @old_fb: previous framebuffer 1024 * 1025 * This function implements a callback useable as the ->mode_set callback 1026 * required by the CRTC helpers. Besides the atomic plane helper functions for 1027 * the primary plane the driver must also provide the ->mode_set_nofb callback 1028 * to set up the CRTC. 1029 * 1030 * This is a transitional helper useful for converting drivers to the atomic 1031 * interfaces. 1032 */ 1033 int drm_helper_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode, 1034 struct drm_display_mode *adjusted_mode, int x, int y, 1035 struct drm_framebuffer *old_fb) 1036 { 1037 struct drm_crtc_state *crtc_state; 1038 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 1039 int ret; 1040 1041 if (crtc->funcs->atomic_duplicate_state) 1042 crtc_state = crtc->funcs->atomic_duplicate_state(crtc); 1043 else { 1044 if (!crtc->state) 1045 drm_atomic_helper_crtc_reset(crtc); 1046 1047 crtc_state = drm_atomic_helper_crtc_duplicate_state(crtc); 1048 } 1049 1050 if (!crtc_state) 1051 return -ENOMEM; 1052 1053 crtc_state->planes_changed = true; 1054 crtc_state->mode_changed = true; 1055 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode); 1056 if (ret) 1057 goto out; 1058 drm_mode_copy(&crtc_state->adjusted_mode, adjusted_mode); 1059 1060 if (crtc_funcs->atomic_check) { 1061 ret = crtc_funcs->atomic_check(crtc, crtc_state); 1062 if (ret) 1063 goto out; 1064 } 1065 1066 swap(crtc->state, crtc_state); 1067 1068 crtc_funcs->mode_set_nofb(crtc); 1069 1070 ret = drm_helper_crtc_mode_set_base(crtc, x, y, old_fb); 1071 1072 out: 1073 if (crtc_state) { 1074 if (crtc->funcs->atomic_destroy_state) 1075 crtc->funcs->atomic_destroy_state(crtc, crtc_state); 1076 else 1077 drm_atomic_helper_crtc_destroy_state(crtc, crtc_state); 1078 } 1079 1080 return ret; 1081 } 1082 EXPORT_SYMBOL(drm_helper_crtc_mode_set); 1083 1084 /** 1085 * drm_helper_crtc_mode_set_base - mode_set_base implementation for atomic plane helpers 1086 * @crtc: DRM CRTC 1087 * @x: x offset of the CRTC scanout area on the underlying framebuffer 1088 * @y: y offset of the CRTC scanout area on the underlying framebuffer 1089 * @old_fb: previous framebuffer 1090 * 1091 * This function implements a callback useable as the ->mode_set_base used 1092 * required by the CRTC helpers. The driver must provide the atomic plane helper 1093 * functions for the primary plane. 1094 * 1095 * This is a transitional helper useful for converting drivers to the atomic 1096 * interfaces. 1097 */ 1098 int drm_helper_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y, 1099 struct drm_framebuffer *old_fb) 1100 { 1101 struct drm_plane_state *plane_state; 1102 struct drm_plane *plane = crtc->primary; 1103 1104 if (plane->funcs->atomic_duplicate_state) 1105 plane_state = plane->funcs->atomic_duplicate_state(plane); 1106 else { 1107 if (!plane->state) 1108 drm_atomic_helper_plane_reset(plane); 1109 1110 plane_state = drm_atomic_helper_plane_duplicate_state(plane); 1111 } 1112 if (!plane_state) 1113 return -ENOMEM; 1114 plane_state->plane = plane; 1115 1116 plane_state->crtc = crtc; 1117 drm_atomic_set_fb_for_plane(plane_state, crtc->primary->fb); 1118 plane_state->crtc_x = 0; 1119 plane_state->crtc_y = 0; 1120 plane_state->crtc_h = crtc->mode.vdisplay; 1121 plane_state->crtc_w = crtc->mode.hdisplay; 1122 plane_state->src_x = x << 16; 1123 plane_state->src_y = y << 16; 1124 plane_state->src_h = crtc->mode.vdisplay << 16; 1125 plane_state->src_w = crtc->mode.hdisplay << 16; 1126 1127 return drm_plane_helper_commit(plane, plane_state, old_fb); 1128 } 1129 EXPORT_SYMBOL(drm_helper_crtc_mode_set_base); 1130 1131 /** 1132 * drm_helper_crtc_enable_color_mgmt - enable color management properties 1133 * @crtc: DRM CRTC 1134 * @degamma_lut_size: the size of the degamma lut (before CSC) 1135 * @gamma_lut_size: the size of the gamma lut (after CSC) 1136 * 1137 * This function lets the driver enable the color correction properties on a 1138 * CRTC. This includes 3 degamma, csc and gamma properties that userspace can 1139 * set and 2 size properties to inform the userspace of the lut sizes. 1140 */ 1141 void drm_helper_crtc_enable_color_mgmt(struct drm_crtc *crtc, 1142 int degamma_lut_size, 1143 int gamma_lut_size) 1144 { 1145 struct drm_device *dev = crtc->dev; 1146 struct drm_mode_config *config = &dev->mode_config; 1147 1148 drm_object_attach_property(&crtc->base, 1149 config->degamma_lut_property, 0); 1150 drm_object_attach_property(&crtc->base, 1151 config->ctm_property, 0); 1152 drm_object_attach_property(&crtc->base, 1153 config->gamma_lut_property, 0); 1154 1155 drm_object_attach_property(&crtc->base, 1156 config->degamma_lut_size_property, 1157 degamma_lut_size); 1158 drm_object_attach_property(&crtc->base, 1159 config->gamma_lut_size_property, 1160 gamma_lut_size); 1161 } 1162 EXPORT_SYMBOL(drm_helper_crtc_enable_color_mgmt); 1163