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/export.h> 33 #include <linux/moduleparam.h> 34 35 #include "drmP.h" 36 #include "drm_crtc.h" 37 #include "drm_fourcc.h" 38 #include "drm_crtc_helper.h" 39 #include "drm_fb_helper.h" 40 #include "drm_edid.h" 41 42 static bool drm_kms_helper_poll = true; 43 module_param_named(poll, drm_kms_helper_poll, bool, 0600); 44 45 static void drm_mode_validate_flag(struct drm_connector *connector, 46 int flags) 47 { 48 struct drm_display_mode *mode; 49 50 if (flags == (DRM_MODE_FLAG_DBLSCAN | DRM_MODE_FLAG_INTERLACE)) 51 return; 52 53 list_for_each_entry(mode, &connector->modes, head) { 54 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) && 55 !(flags & DRM_MODE_FLAG_INTERLACE)) 56 mode->status = MODE_NO_INTERLACE; 57 if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) && 58 !(flags & DRM_MODE_FLAG_DBLSCAN)) 59 mode->status = MODE_NO_DBLESCAN; 60 } 61 62 return; 63 } 64 65 /** 66 * drm_helper_probe_single_connector_modes - get complete set of display modes 67 * @dev: DRM device 68 * @maxX: max width for modes 69 * @maxY: max height for modes 70 * 71 * LOCKING: 72 * Caller must hold mode config lock. 73 * 74 * Based on @dev's mode_config layout, scan all the connectors and try to detect 75 * modes on them. Modes will first be added to the connector's probed_modes 76 * list, then culled (based on validity and the @maxX, @maxY parameters) and 77 * put into the normal modes list. 78 * 79 * Intended to be used either at bootup time or when major configuration 80 * changes have occurred. 81 * 82 * FIXME: take into account monitor limits 83 * 84 * RETURNS: 85 * Number of modes found on @connector. 86 */ 87 int drm_helper_probe_single_connector_modes(struct drm_connector *connector, 88 uint32_t maxX, uint32_t maxY) 89 { 90 struct drm_device *dev = connector->dev; 91 struct drm_display_mode *mode; 92 struct drm_connector_helper_funcs *connector_funcs = 93 connector->helper_private; 94 int count = 0; 95 int mode_flags = 0; 96 97 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id, 98 drm_get_connector_name(connector)); 99 /* set all modes to the unverified state */ 100 list_for_each_entry(mode, &connector->modes, head) 101 mode->status = MODE_UNVERIFIED; 102 103 if (connector->force) { 104 if (connector->force == DRM_FORCE_ON) 105 connector->status = connector_status_connected; 106 else 107 connector->status = connector_status_disconnected; 108 if (connector->funcs->force) 109 connector->funcs->force(connector); 110 } else { 111 connector->status = connector->funcs->detect(connector, true); 112 drm_kms_helper_poll_enable(dev); 113 } 114 115 if (connector->status == connector_status_disconnected) { 116 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n", 117 connector->base.id, drm_get_connector_name(connector)); 118 drm_mode_connector_update_edid_property(connector, NULL); 119 goto prune; 120 } 121 122 #ifdef CONFIG_DRM_LOAD_EDID_FIRMWARE 123 count = drm_load_edid_firmware(connector); 124 if (count == 0) 125 #endif 126 count = (*connector_funcs->get_modes)(connector); 127 128 if (count == 0 && connector->status == connector_status_connected) 129 count = drm_add_modes_noedid(connector, 1024, 768); 130 if (count == 0) 131 goto prune; 132 133 drm_mode_connector_list_update(connector); 134 135 if (maxX && maxY) 136 drm_mode_validate_size(dev, &connector->modes, maxX, 137 maxY, 0); 138 139 if (connector->interlace_allowed) 140 mode_flags |= DRM_MODE_FLAG_INTERLACE; 141 if (connector->doublescan_allowed) 142 mode_flags |= DRM_MODE_FLAG_DBLSCAN; 143 drm_mode_validate_flag(connector, mode_flags); 144 145 list_for_each_entry(mode, &connector->modes, head) { 146 if (mode->status == MODE_OK) 147 mode->status = connector_funcs->mode_valid(connector, 148 mode); 149 } 150 151 prune: 152 drm_mode_prune_invalid(dev, &connector->modes, true); 153 154 if (list_empty(&connector->modes)) 155 return 0; 156 157 drm_mode_sort(&connector->modes); 158 159 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id, 160 drm_get_connector_name(connector)); 161 list_for_each_entry(mode, &connector->modes, head) { 162 mode->vrefresh = drm_mode_vrefresh(mode); 163 164 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V); 165 drm_mode_debug_printmodeline(mode); 166 } 167 168 return count; 169 } 170 EXPORT_SYMBOL(drm_helper_probe_single_connector_modes); 171 172 /** 173 * drm_helper_encoder_in_use - check if a given encoder is in use 174 * @encoder: encoder to check 175 * 176 * LOCKING: 177 * Caller must hold mode config lock. 178 * 179 * Walk @encoders's DRM device's mode_config and see if it's in use. 180 * 181 * RETURNS: 182 * True if @encoder is part of the mode_config, false otherwise. 183 */ 184 bool drm_helper_encoder_in_use(struct drm_encoder *encoder) 185 { 186 struct drm_connector *connector; 187 struct drm_device *dev = encoder->dev; 188 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 189 if (connector->encoder == encoder) 190 return true; 191 return false; 192 } 193 EXPORT_SYMBOL(drm_helper_encoder_in_use); 194 195 /** 196 * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config 197 * @crtc: CRTC to check 198 * 199 * LOCKING: 200 * Caller must hold mode config lock. 201 * 202 * Walk @crtc's DRM device's mode_config and see if it's in use. 203 * 204 * RETURNS: 205 * True if @crtc is part of the mode_config, false otherwise. 206 */ 207 bool drm_helper_crtc_in_use(struct drm_crtc *crtc) 208 { 209 struct drm_encoder *encoder; 210 struct drm_device *dev = crtc->dev; 211 /* FIXME: Locking around list access? */ 212 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) 213 if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder)) 214 return true; 215 return false; 216 } 217 EXPORT_SYMBOL(drm_helper_crtc_in_use); 218 219 static void 220 drm_encoder_disable(struct drm_encoder *encoder) 221 { 222 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private; 223 224 if (encoder_funcs->disable) 225 (*encoder_funcs->disable)(encoder); 226 else 227 (*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF); 228 } 229 230 /** 231 * drm_helper_disable_unused_functions - disable unused objects 232 * @dev: DRM device 233 * 234 * LOCKING: 235 * Caller must hold mode config lock. 236 * 237 * If an connector or CRTC isn't part of @dev's mode_config, it can be disabled 238 * by calling its dpms function, which should power it off. 239 */ 240 void drm_helper_disable_unused_functions(struct drm_device *dev) 241 { 242 struct drm_encoder *encoder; 243 struct drm_connector *connector; 244 struct drm_crtc *crtc; 245 246 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 247 if (!connector->encoder) 248 continue; 249 if (connector->status == connector_status_disconnected) 250 connector->encoder = NULL; 251 } 252 253 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 254 if (!drm_helper_encoder_in_use(encoder)) { 255 drm_encoder_disable(encoder); 256 /* disconnector encoder from any connector */ 257 encoder->crtc = NULL; 258 } 259 } 260 261 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 262 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 263 crtc->enabled = drm_helper_crtc_in_use(crtc); 264 if (!crtc->enabled) { 265 if (crtc_funcs->disable) 266 (*crtc_funcs->disable)(crtc); 267 else 268 (*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF); 269 crtc->fb = NULL; 270 } 271 } 272 } 273 EXPORT_SYMBOL(drm_helper_disable_unused_functions); 274 275 /** 276 * drm_encoder_crtc_ok - can a given crtc drive a given encoder? 277 * @encoder: encoder to test 278 * @crtc: crtc to test 279 * 280 * Return false if @encoder can't be driven by @crtc, true otherwise. 281 */ 282 static bool drm_encoder_crtc_ok(struct drm_encoder *encoder, 283 struct drm_crtc *crtc) 284 { 285 struct drm_device *dev; 286 struct drm_crtc *tmp; 287 int crtc_mask = 1; 288 289 WARN(!crtc, "checking null crtc?\n"); 290 291 dev = crtc->dev; 292 293 list_for_each_entry(tmp, &dev->mode_config.crtc_list, head) { 294 if (tmp == crtc) 295 break; 296 crtc_mask <<= 1; 297 } 298 299 if (encoder->possible_crtcs & crtc_mask) 300 return true; 301 return false; 302 } 303 304 /* 305 * Check the CRTC we're going to map each output to vs. its current 306 * CRTC. If they don't match, we have to disable the output and the CRTC 307 * since the driver will have to re-route things. 308 */ 309 static void 310 drm_crtc_prepare_encoders(struct drm_device *dev) 311 { 312 struct drm_encoder_helper_funcs *encoder_funcs; 313 struct drm_encoder *encoder; 314 315 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 316 encoder_funcs = encoder->helper_private; 317 /* Disable unused encoders */ 318 if (encoder->crtc == NULL) 319 drm_encoder_disable(encoder); 320 /* Disable encoders whose CRTC is about to change */ 321 if (encoder_funcs->get_crtc && 322 encoder->crtc != (*encoder_funcs->get_crtc)(encoder)) 323 drm_encoder_disable(encoder); 324 } 325 } 326 327 /** 328 * drm_crtc_set_mode - set a mode 329 * @crtc: CRTC to program 330 * @mode: mode to use 331 * @x: width of mode 332 * @y: height of mode 333 * 334 * LOCKING: 335 * Caller must hold mode config lock. 336 * 337 * Try to set @mode on @crtc. Give @crtc and its associated connectors a chance 338 * to fixup or reject the mode prior to trying to set it. 339 * 340 * RETURNS: 341 * True if the mode was set successfully, or false otherwise. 342 */ 343 bool drm_crtc_helper_set_mode(struct drm_crtc *crtc, 344 struct drm_display_mode *mode, 345 int x, int y, 346 struct drm_framebuffer *old_fb) 347 { 348 struct drm_device *dev = crtc->dev; 349 struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode; 350 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 351 struct drm_encoder_helper_funcs *encoder_funcs; 352 int saved_x, saved_y; 353 struct drm_encoder *encoder; 354 bool ret = true; 355 356 crtc->enabled = drm_helper_crtc_in_use(crtc); 357 if (!crtc->enabled) 358 return true; 359 360 adjusted_mode = drm_mode_duplicate(dev, mode); 361 if (!adjusted_mode) 362 return false; 363 364 saved_hwmode = crtc->hwmode; 365 saved_mode = crtc->mode; 366 saved_x = crtc->x; 367 saved_y = crtc->y; 368 369 /* Update crtc values up front so the driver can rely on them for mode 370 * setting. 371 */ 372 crtc->mode = *mode; 373 crtc->x = x; 374 crtc->y = y; 375 376 /* Pass our mode to the connectors and the CRTC to give them a chance to 377 * adjust it according to limitations or connector properties, and also 378 * a chance to reject the mode entirely. 379 */ 380 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 381 382 if (encoder->crtc != crtc) 383 continue; 384 encoder_funcs = encoder->helper_private; 385 if (!(ret = encoder_funcs->mode_fixup(encoder, mode, 386 adjusted_mode))) { 387 DRM_DEBUG_KMS("Encoder fixup failed\n"); 388 goto done; 389 } 390 } 391 392 if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) { 393 DRM_DEBUG_KMS("CRTC fixup failed\n"); 394 goto done; 395 } 396 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id); 397 398 /* Prepare the encoders and CRTCs before setting the mode. */ 399 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 400 401 if (encoder->crtc != crtc) 402 continue; 403 encoder_funcs = encoder->helper_private; 404 /* Disable the encoders as the first thing we do. */ 405 encoder_funcs->prepare(encoder); 406 } 407 408 drm_crtc_prepare_encoders(dev); 409 410 crtc_funcs->prepare(crtc); 411 412 /* Set up the DPLL and any encoders state that needs to adjust or depend 413 * on the DPLL. 414 */ 415 ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb); 416 if (!ret) 417 goto done; 418 419 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 420 421 if (encoder->crtc != crtc) 422 continue; 423 424 DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n", 425 encoder->base.id, drm_get_encoder_name(encoder), 426 mode->base.id, mode->name); 427 encoder_funcs = encoder->helper_private; 428 encoder_funcs->mode_set(encoder, mode, adjusted_mode); 429 } 430 431 /* Now enable the clocks, plane, pipe, and connectors that we set up. */ 432 crtc_funcs->commit(crtc); 433 434 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 435 436 if (encoder->crtc != crtc) 437 continue; 438 439 encoder_funcs = encoder->helper_private; 440 encoder_funcs->commit(encoder); 441 442 } 443 444 /* Store real post-adjustment hardware mode. */ 445 crtc->hwmode = *adjusted_mode; 446 447 /* Calculate and store various constants which 448 * are later needed by vblank and swap-completion 449 * timestamping. They are derived from true hwmode. 450 */ 451 drm_calc_timestamping_constants(crtc); 452 453 /* FIXME: add subpixel order */ 454 done: 455 drm_mode_destroy(dev, adjusted_mode); 456 if (!ret) { 457 crtc->hwmode = saved_hwmode; 458 crtc->mode = saved_mode; 459 crtc->x = saved_x; 460 crtc->y = saved_y; 461 } 462 463 return ret; 464 } 465 EXPORT_SYMBOL(drm_crtc_helper_set_mode); 466 467 468 static int 469 drm_crtc_helper_disable(struct drm_crtc *crtc) 470 { 471 struct drm_device *dev = crtc->dev; 472 struct drm_connector *connector; 473 struct drm_encoder *encoder; 474 475 /* Decouple all encoders and their attached connectors from this crtc */ 476 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 477 if (encoder->crtc != crtc) 478 continue; 479 480 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 481 if (connector->encoder != encoder) 482 continue; 483 484 connector->encoder = NULL; 485 } 486 } 487 488 drm_helper_disable_unused_functions(dev); 489 return 0; 490 } 491 492 /** 493 * drm_crtc_helper_set_config - set a new config from userspace 494 * @crtc: CRTC to setup 495 * @crtc_info: user provided configuration 496 * @new_mode: new mode to set 497 * @connector_set: set of connectors for the new config 498 * @fb: new framebuffer 499 * 500 * LOCKING: 501 * Caller must hold mode config lock. 502 * 503 * Setup a new configuration, provided by the user in @crtc_info, and enable 504 * it. 505 * 506 * RETURNS: 507 * Zero. (FIXME) 508 */ 509 int drm_crtc_helper_set_config(struct drm_mode_set *set) 510 { 511 struct drm_device *dev; 512 struct drm_crtc *save_crtcs, *new_crtc, *crtc; 513 struct drm_encoder *save_encoders, *new_encoder, *encoder; 514 struct drm_framebuffer *old_fb = NULL; 515 bool mode_changed = false; /* if true do a full mode set */ 516 bool fb_changed = false; /* if true and !mode_changed just do a flip */ 517 struct drm_connector *save_connectors, *connector; 518 int count = 0, ro, fail = 0; 519 struct drm_crtc_helper_funcs *crtc_funcs; 520 struct drm_mode_set save_set; 521 int ret; 522 int i; 523 524 DRM_DEBUG_KMS("\n"); 525 526 if (!set) 527 return -EINVAL; 528 529 if (!set->crtc) 530 return -EINVAL; 531 532 if (!set->crtc->helper_private) 533 return -EINVAL; 534 535 crtc_funcs = set->crtc->helper_private; 536 537 if (!set->mode) 538 set->fb = NULL; 539 540 if (set->fb) { 541 DRM_DEBUG_KMS("[CRTC:%d] [FB:%d] #connectors=%d (x y) (%i %i)\n", 542 set->crtc->base.id, set->fb->base.id, 543 (int)set->num_connectors, set->x, set->y); 544 } else { 545 DRM_DEBUG_KMS("[CRTC:%d] [NOFB]\n", set->crtc->base.id); 546 return drm_crtc_helper_disable(set->crtc); 547 } 548 549 dev = set->crtc->dev; 550 551 /* Allocate space for the backup of all (non-pointer) crtc, encoder and 552 * connector data. */ 553 save_crtcs = kzalloc(dev->mode_config.num_crtc * 554 sizeof(struct drm_crtc), GFP_KERNEL); 555 if (!save_crtcs) 556 return -ENOMEM; 557 558 save_encoders = kzalloc(dev->mode_config.num_encoder * 559 sizeof(struct drm_encoder), GFP_KERNEL); 560 if (!save_encoders) { 561 kfree(save_crtcs); 562 return -ENOMEM; 563 } 564 565 save_connectors = kzalloc(dev->mode_config.num_connector * 566 sizeof(struct drm_connector), GFP_KERNEL); 567 if (!save_connectors) { 568 kfree(save_crtcs); 569 kfree(save_encoders); 570 return -ENOMEM; 571 } 572 573 /* Copy data. Note that driver private data is not affected. 574 * Should anything bad happen only the expected state is 575 * restored, not the drivers personal bookkeeping. 576 */ 577 count = 0; 578 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 579 save_crtcs[count++] = *crtc; 580 } 581 582 count = 0; 583 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 584 save_encoders[count++] = *encoder; 585 } 586 587 count = 0; 588 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 589 save_connectors[count++] = *connector; 590 } 591 592 save_set.crtc = set->crtc; 593 save_set.mode = &set->crtc->mode; 594 save_set.x = set->crtc->x; 595 save_set.y = set->crtc->y; 596 save_set.fb = set->crtc->fb; 597 598 /* We should be able to check here if the fb has the same properties 599 * and then just flip_or_move it */ 600 if (set->crtc->fb != set->fb) { 601 /* If we have no fb then treat it as a full mode set */ 602 if (set->crtc->fb == NULL) { 603 DRM_DEBUG_KMS("crtc has no fb, full mode set\n"); 604 mode_changed = true; 605 } else if (set->fb == NULL) { 606 mode_changed = true; 607 } else if (set->fb->depth != set->crtc->fb->depth) { 608 mode_changed = true; 609 } else if (set->fb->bits_per_pixel != 610 set->crtc->fb->bits_per_pixel) { 611 mode_changed = true; 612 } else 613 fb_changed = true; 614 } 615 616 if (set->x != set->crtc->x || set->y != set->crtc->y) 617 fb_changed = true; 618 619 if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) { 620 DRM_DEBUG_KMS("modes are different, full mode set\n"); 621 drm_mode_debug_printmodeline(&set->crtc->mode); 622 drm_mode_debug_printmodeline(set->mode); 623 mode_changed = true; 624 } 625 626 /* a) traverse passed in connector list and get encoders for them */ 627 count = 0; 628 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 629 struct drm_connector_helper_funcs *connector_funcs = 630 connector->helper_private; 631 new_encoder = connector->encoder; 632 for (ro = 0; ro < set->num_connectors; ro++) { 633 if (set->connectors[ro] == connector) { 634 new_encoder = connector_funcs->best_encoder(connector); 635 /* if we can't get an encoder for a connector 636 we are setting now - then fail */ 637 if (new_encoder == NULL) 638 /* don't break so fail path works correct */ 639 fail = 1; 640 break; 641 } 642 } 643 644 if (new_encoder != connector->encoder) { 645 DRM_DEBUG_KMS("encoder changed, full mode switch\n"); 646 mode_changed = true; 647 /* If the encoder is reused for another connector, then 648 * the appropriate crtc will be set later. 649 */ 650 if (connector->encoder) 651 connector->encoder->crtc = NULL; 652 connector->encoder = new_encoder; 653 } 654 } 655 656 if (fail) { 657 ret = -EINVAL; 658 goto fail; 659 } 660 661 count = 0; 662 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 663 if (!connector->encoder) 664 continue; 665 666 if (connector->encoder->crtc == set->crtc) 667 new_crtc = NULL; 668 else 669 new_crtc = connector->encoder->crtc; 670 671 for (ro = 0; ro < set->num_connectors; ro++) { 672 if (set->connectors[ro] == connector) 673 new_crtc = set->crtc; 674 } 675 676 /* Make sure the new CRTC will work with the encoder */ 677 if (new_crtc && 678 !drm_encoder_crtc_ok(connector->encoder, new_crtc)) { 679 ret = -EINVAL; 680 goto fail; 681 } 682 if (new_crtc != connector->encoder->crtc) { 683 DRM_DEBUG_KMS("crtc changed, full mode switch\n"); 684 mode_changed = true; 685 connector->encoder->crtc = new_crtc; 686 } 687 if (new_crtc) { 688 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d]\n", 689 connector->base.id, drm_get_connector_name(connector), 690 new_crtc->base.id); 691 } else { 692 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n", 693 connector->base.id, drm_get_connector_name(connector)); 694 } 695 } 696 697 /* mode_set_base is not a required function */ 698 if (fb_changed && !crtc_funcs->mode_set_base) 699 mode_changed = true; 700 701 if (mode_changed) { 702 set->crtc->enabled = drm_helper_crtc_in_use(set->crtc); 703 if (set->crtc->enabled) { 704 DRM_DEBUG_KMS("attempting to set mode from" 705 " userspace\n"); 706 drm_mode_debug_printmodeline(set->mode); 707 old_fb = set->crtc->fb; 708 set->crtc->fb = set->fb; 709 if (!drm_crtc_helper_set_mode(set->crtc, set->mode, 710 set->x, set->y, 711 old_fb)) { 712 DRM_ERROR("failed to set mode on [CRTC:%d]\n", 713 set->crtc->base.id); 714 set->crtc->fb = old_fb; 715 ret = -EINVAL; 716 goto fail; 717 } 718 DRM_DEBUG_KMS("Setting connector DPMS state to on\n"); 719 for (i = 0; i < set->num_connectors; i++) { 720 DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id, 721 drm_get_connector_name(set->connectors[i])); 722 set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON); 723 } 724 } 725 drm_helper_disable_unused_functions(dev); 726 } else if (fb_changed) { 727 set->crtc->x = set->x; 728 set->crtc->y = set->y; 729 730 old_fb = set->crtc->fb; 731 if (set->crtc->fb != set->fb) 732 set->crtc->fb = set->fb; 733 ret = crtc_funcs->mode_set_base(set->crtc, 734 set->x, set->y, old_fb); 735 if (ret != 0) { 736 set->crtc->fb = old_fb; 737 goto fail; 738 } 739 } 740 741 kfree(save_connectors); 742 kfree(save_encoders); 743 kfree(save_crtcs); 744 return 0; 745 746 fail: 747 /* Restore all previous data. */ 748 count = 0; 749 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 750 *crtc = save_crtcs[count++]; 751 } 752 753 count = 0; 754 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 755 *encoder = save_encoders[count++]; 756 } 757 758 count = 0; 759 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 760 *connector = save_connectors[count++]; 761 } 762 763 /* Try to restore the config */ 764 if (mode_changed && 765 !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x, 766 save_set.y, save_set.fb)) 767 DRM_ERROR("failed to restore config after modeset failure\n"); 768 769 kfree(save_connectors); 770 kfree(save_encoders); 771 kfree(save_crtcs); 772 return ret; 773 } 774 EXPORT_SYMBOL(drm_crtc_helper_set_config); 775 776 static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder) 777 { 778 int dpms = DRM_MODE_DPMS_OFF; 779 struct drm_connector *connector; 780 struct drm_device *dev = encoder->dev; 781 782 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 783 if (connector->encoder == encoder) 784 if (connector->dpms < dpms) 785 dpms = connector->dpms; 786 return dpms; 787 } 788 789 static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc) 790 { 791 int dpms = DRM_MODE_DPMS_OFF; 792 struct drm_connector *connector; 793 struct drm_device *dev = crtc->dev; 794 795 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 796 if (connector->encoder && connector->encoder->crtc == crtc) 797 if (connector->dpms < dpms) 798 dpms = connector->dpms; 799 return dpms; 800 } 801 802 /** 803 * drm_helper_connector_dpms 804 * @connector affected connector 805 * @mode DPMS mode 806 * 807 * Calls the low-level connector DPMS function, then 808 * calls appropriate encoder and crtc DPMS functions as well 809 */ 810 void drm_helper_connector_dpms(struct drm_connector *connector, int mode) 811 { 812 struct drm_encoder *encoder = connector->encoder; 813 struct drm_crtc *crtc = encoder ? encoder->crtc : NULL; 814 int old_dpms; 815 816 if (mode == connector->dpms) 817 return; 818 819 old_dpms = connector->dpms; 820 connector->dpms = mode; 821 822 /* from off to on, do crtc then encoder */ 823 if (mode < old_dpms) { 824 if (crtc) { 825 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 826 if (crtc_funcs->dpms) 827 (*crtc_funcs->dpms) (crtc, 828 drm_helper_choose_crtc_dpms(crtc)); 829 } 830 if (encoder) { 831 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private; 832 if (encoder_funcs->dpms) 833 (*encoder_funcs->dpms) (encoder, 834 drm_helper_choose_encoder_dpms(encoder)); 835 } 836 } 837 838 /* from on to off, do encoder then crtc */ 839 if (mode > old_dpms) { 840 if (encoder) { 841 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private; 842 if (encoder_funcs->dpms) 843 (*encoder_funcs->dpms) (encoder, 844 drm_helper_choose_encoder_dpms(encoder)); 845 } 846 if (crtc) { 847 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 848 if (crtc_funcs->dpms) 849 (*crtc_funcs->dpms) (crtc, 850 drm_helper_choose_crtc_dpms(crtc)); 851 } 852 } 853 854 return; 855 } 856 EXPORT_SYMBOL(drm_helper_connector_dpms); 857 858 int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb, 859 struct drm_mode_fb_cmd2 *mode_cmd) 860 { 861 int i; 862 863 fb->width = mode_cmd->width; 864 fb->height = mode_cmd->height; 865 for (i = 0; i < 4; i++) { 866 fb->pitches[i] = mode_cmd->pitches[i]; 867 fb->offsets[i] = mode_cmd->offsets[i]; 868 } 869 drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth, 870 &fb->bits_per_pixel); 871 fb->pixel_format = mode_cmd->pixel_format; 872 873 return 0; 874 } 875 EXPORT_SYMBOL(drm_helper_mode_fill_fb_struct); 876 877 int drm_helper_resume_force_mode(struct drm_device *dev) 878 { 879 struct drm_crtc *crtc; 880 struct drm_encoder *encoder; 881 struct drm_encoder_helper_funcs *encoder_funcs; 882 struct drm_crtc_helper_funcs *crtc_funcs; 883 int ret; 884 885 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 886 887 if (!crtc->enabled) 888 continue; 889 890 ret = drm_crtc_helper_set_mode(crtc, &crtc->mode, 891 crtc->x, crtc->y, crtc->fb); 892 893 if (ret == false) 894 DRM_ERROR("failed to set mode on crtc %p\n", crtc); 895 896 /* Turn off outputs that were already powered off */ 897 if (drm_helper_choose_crtc_dpms(crtc)) { 898 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 899 900 if(encoder->crtc != crtc) 901 continue; 902 903 encoder_funcs = encoder->helper_private; 904 if (encoder_funcs->dpms) 905 (*encoder_funcs->dpms) (encoder, 906 drm_helper_choose_encoder_dpms(encoder)); 907 } 908 909 crtc_funcs = crtc->helper_private; 910 if (crtc_funcs->dpms) 911 (*crtc_funcs->dpms) (crtc, 912 drm_helper_choose_crtc_dpms(crtc)); 913 } 914 } 915 /* disable the unused connectors while restoring the modesetting */ 916 drm_helper_disable_unused_functions(dev); 917 return 0; 918 } 919 EXPORT_SYMBOL(drm_helper_resume_force_mode); 920 921 #define DRM_OUTPUT_POLL_PERIOD (10*HZ) 922 static void output_poll_execute(struct work_struct *work) 923 { 924 struct delayed_work *delayed_work = to_delayed_work(work); 925 struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work); 926 struct drm_connector *connector; 927 enum drm_connector_status old_status; 928 bool repoll = false, changed = false; 929 930 if (!drm_kms_helper_poll) 931 return; 932 933 mutex_lock(&dev->mode_config.mutex); 934 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 935 936 /* if this is HPD or polled don't check it - 937 TV out for instance */ 938 if (!connector->polled) 939 continue; 940 941 else if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT)) 942 repoll = true; 943 944 old_status = connector->status; 945 /* if we are connected and don't want to poll for disconnect 946 skip it */ 947 if (old_status == connector_status_connected && 948 !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT) && 949 !(connector->polled & DRM_CONNECTOR_POLL_HPD)) 950 continue; 951 952 connector->status = connector->funcs->detect(connector, false); 953 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %d to %d\n", 954 connector->base.id, 955 drm_get_connector_name(connector), 956 old_status, connector->status); 957 if (old_status != connector->status) 958 changed = true; 959 } 960 961 mutex_unlock(&dev->mode_config.mutex); 962 963 if (changed) { 964 /* send a uevent + call fbdev */ 965 drm_sysfs_hotplug_event(dev); 966 if (dev->mode_config.funcs->output_poll_changed) 967 dev->mode_config.funcs->output_poll_changed(dev); 968 } 969 970 if (repoll) 971 queue_delayed_work(system_nrt_wq, delayed_work, DRM_OUTPUT_POLL_PERIOD); 972 } 973 974 void drm_kms_helper_poll_disable(struct drm_device *dev) 975 { 976 if (!dev->mode_config.poll_enabled) 977 return; 978 cancel_delayed_work_sync(&dev->mode_config.output_poll_work); 979 } 980 EXPORT_SYMBOL(drm_kms_helper_poll_disable); 981 982 void drm_kms_helper_poll_enable(struct drm_device *dev) 983 { 984 bool poll = false; 985 struct drm_connector *connector; 986 987 if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll) 988 return; 989 990 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 991 if (connector->polled) 992 poll = true; 993 } 994 995 if (poll) 996 queue_delayed_work(system_nrt_wq, &dev->mode_config.output_poll_work, DRM_OUTPUT_POLL_PERIOD); 997 } 998 EXPORT_SYMBOL(drm_kms_helper_poll_enable); 999 1000 void drm_kms_helper_poll_init(struct drm_device *dev) 1001 { 1002 INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute); 1003 dev->mode_config.poll_enabled = true; 1004 1005 drm_kms_helper_poll_enable(dev); 1006 } 1007 EXPORT_SYMBOL(drm_kms_helper_poll_init); 1008 1009 void drm_kms_helper_poll_fini(struct drm_device *dev) 1010 { 1011 drm_kms_helper_poll_disable(dev); 1012 } 1013 EXPORT_SYMBOL(drm_kms_helper_poll_fini); 1014 1015 void drm_helper_hpd_irq_event(struct drm_device *dev) 1016 { 1017 if (!dev->mode_config.poll_enabled) 1018 return; 1019 1020 /* kill timer and schedule immediate execution, this doesn't block */ 1021 cancel_delayed_work(&dev->mode_config.output_poll_work); 1022 if (drm_kms_helper_poll) 1023 queue_delayed_work(system_nrt_wq, &dev->mode_config.output_poll_work, 0); 1024 } 1025 EXPORT_SYMBOL(drm_helper_hpd_irq_event); 1026