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 <drm/drm_bridge.h> 36 #include <drm/drm_client.h> 37 #include <drm/drm_crtc.h> 38 #include <drm/drm_edid.h> 39 #include <drm/drm_fourcc.h> 40 #include <drm/drm_modeset_helper_vtables.h> 41 #include <drm/drm_print.h> 42 #include <drm/drm_probe_helper.h> 43 #include <drm/drm_sysfs.h> 44 45 #include "drm_crtc_helper_internal.h" 46 47 /** 48 * DOC: output probing helper overview 49 * 50 * This library provides some helper code for output probing. It provides an 51 * implementation of the core &drm_connector_funcs.fill_modes interface with 52 * drm_helper_probe_single_connector_modes(). 53 * 54 * It also provides support for polling connectors with a work item and for 55 * generic hotplug interrupt handling where the driver doesn't or cannot keep 56 * track of a per-connector hpd interrupt. 57 * 58 * This helper library can be used independently of the modeset helper library. 59 * Drivers can also overwrite different parts e.g. use their own hotplug 60 * handling code to avoid probing unrelated outputs. 61 * 62 * The probe helpers share the function table structures with other display 63 * helper libraries. See &struct drm_connector_helper_funcs for the details. 64 */ 65 66 static bool drm_kms_helper_poll = true; 67 module_param_named(poll, drm_kms_helper_poll, bool, 0600); 68 69 static enum drm_mode_status 70 drm_mode_validate_flag(const struct drm_display_mode *mode, 71 int flags) 72 { 73 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) && 74 !(flags & DRM_MODE_FLAG_INTERLACE)) 75 return MODE_NO_INTERLACE; 76 77 if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) && 78 !(flags & DRM_MODE_FLAG_DBLSCAN)) 79 return MODE_NO_DBLESCAN; 80 81 if ((mode->flags & DRM_MODE_FLAG_3D_MASK) && 82 !(flags & DRM_MODE_FLAG_3D_MASK)) 83 return MODE_NO_STEREO; 84 85 return MODE_OK; 86 } 87 88 static int 89 drm_mode_validate_pipeline(struct drm_display_mode *mode, 90 struct drm_connector *connector, 91 struct drm_modeset_acquire_ctx *ctx, 92 enum drm_mode_status *status) 93 { 94 struct drm_device *dev = connector->dev; 95 struct drm_encoder *encoder; 96 int ret; 97 98 /* Step 1: Validate against connector */ 99 ret = drm_connector_mode_valid(connector, mode, ctx, status); 100 if (ret || *status != MODE_OK) 101 return ret; 102 103 /* Step 2: Validate against encoders and crtcs */ 104 drm_connector_for_each_possible_encoder(connector, encoder) { 105 struct drm_bridge *bridge; 106 struct drm_crtc *crtc; 107 108 *status = drm_encoder_mode_valid(encoder, mode); 109 if (*status != MODE_OK) { 110 /* No point in continuing for crtc check as this encoder 111 * will not accept the mode anyway. If all encoders 112 * reject the mode then, at exit, ret will not be 113 * MODE_OK. */ 114 continue; 115 } 116 117 bridge = drm_bridge_chain_get_first_bridge(encoder); 118 *status = drm_bridge_chain_mode_valid(bridge, 119 &connector->display_info, 120 mode); 121 if (*status != MODE_OK) { 122 /* There is also no point in continuing for crtc check 123 * here. */ 124 continue; 125 } 126 127 drm_for_each_crtc(crtc, dev) { 128 if (!drm_encoder_crtc_ok(encoder, crtc)) 129 continue; 130 131 *status = drm_crtc_mode_valid(crtc, mode); 132 if (*status == MODE_OK) { 133 /* If we get to this point there is at least 134 * one combination of encoder+crtc that works 135 * for this mode. Lets return now. */ 136 return 0; 137 } 138 } 139 } 140 141 return 0; 142 } 143 144 static int drm_helper_probe_add_cmdline_mode(struct drm_connector *connector) 145 { 146 struct drm_cmdline_mode *cmdline_mode; 147 struct drm_display_mode *mode; 148 149 cmdline_mode = &connector->cmdline_mode; 150 if (!cmdline_mode->specified) 151 return 0; 152 153 /* Only add a GTF mode if we find no matching probed modes */ 154 list_for_each_entry(mode, &connector->probed_modes, head) { 155 if (mode->hdisplay != cmdline_mode->xres || 156 mode->vdisplay != cmdline_mode->yres) 157 continue; 158 159 if (cmdline_mode->refresh_specified) { 160 /* The probed mode's vrefresh is set until later */ 161 if (drm_mode_vrefresh(mode) != cmdline_mode->refresh) 162 continue; 163 } 164 165 /* Mark the matching mode as being preferred by the user */ 166 mode->type |= DRM_MODE_TYPE_USERDEF; 167 return 0; 168 } 169 170 mode = drm_mode_create_from_cmdline_mode(connector->dev, 171 cmdline_mode); 172 if (mode == NULL) 173 return 0; 174 175 drm_mode_probed_add(connector, mode); 176 return 1; 177 } 178 179 enum drm_mode_status drm_crtc_mode_valid(struct drm_crtc *crtc, 180 const struct drm_display_mode *mode) 181 { 182 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 183 184 if (!crtc_funcs || !crtc_funcs->mode_valid) 185 return MODE_OK; 186 187 return crtc_funcs->mode_valid(crtc, mode); 188 } 189 190 enum drm_mode_status drm_encoder_mode_valid(struct drm_encoder *encoder, 191 const struct drm_display_mode *mode) 192 { 193 const struct drm_encoder_helper_funcs *encoder_funcs = 194 encoder->helper_private; 195 196 if (!encoder_funcs || !encoder_funcs->mode_valid) 197 return MODE_OK; 198 199 return encoder_funcs->mode_valid(encoder, mode); 200 } 201 202 int 203 drm_connector_mode_valid(struct drm_connector *connector, 204 struct drm_display_mode *mode, 205 struct drm_modeset_acquire_ctx *ctx, 206 enum drm_mode_status *status) 207 { 208 const struct drm_connector_helper_funcs *connector_funcs = 209 connector->helper_private; 210 int ret = 0; 211 212 if (!connector_funcs) 213 *status = MODE_OK; 214 else if (connector_funcs->mode_valid_ctx) 215 ret = connector_funcs->mode_valid_ctx(connector, mode, ctx, 216 status); 217 else if (connector_funcs->mode_valid) 218 *status = connector_funcs->mode_valid(connector, mode); 219 else 220 *status = MODE_OK; 221 222 return ret; 223 } 224 225 static void drm_kms_helper_disable_hpd(struct drm_device *dev) 226 { 227 struct drm_connector *connector; 228 struct drm_connector_list_iter conn_iter; 229 230 drm_connector_list_iter_begin(dev, &conn_iter); 231 drm_for_each_connector_iter(connector, &conn_iter) { 232 const struct drm_connector_helper_funcs *funcs = 233 connector->helper_private; 234 235 if (funcs && funcs->disable_hpd) 236 funcs->disable_hpd(connector); 237 } 238 drm_connector_list_iter_end(&conn_iter); 239 } 240 241 static bool drm_kms_helper_enable_hpd(struct drm_device *dev) 242 { 243 bool poll = false; 244 struct drm_connector *connector; 245 struct drm_connector_list_iter conn_iter; 246 247 drm_connector_list_iter_begin(dev, &conn_iter); 248 drm_for_each_connector_iter(connector, &conn_iter) { 249 const struct drm_connector_helper_funcs *funcs = 250 connector->helper_private; 251 252 if (funcs && funcs->enable_hpd) 253 funcs->enable_hpd(connector); 254 255 if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT | 256 DRM_CONNECTOR_POLL_DISCONNECT)) 257 poll = true; 258 } 259 drm_connector_list_iter_end(&conn_iter); 260 261 return poll; 262 } 263 264 #define DRM_OUTPUT_POLL_PERIOD (10*HZ) 265 static void reschedule_output_poll_work(struct drm_device *dev) 266 { 267 unsigned long delay = DRM_OUTPUT_POLL_PERIOD; 268 269 if (dev->mode_config.delayed_event) 270 /* 271 * FIXME: 272 * 273 * Use short (1s) delay to handle the initial delayed event. 274 * This delay should not be needed, but Optimus/nouveau will 275 * fail in a mysterious way if the delayed event is handled as 276 * soon as possible like it is done in 277 * drm_helper_probe_single_connector_modes() in case the poll 278 * was enabled before. 279 */ 280 delay = HZ; 281 282 schedule_delayed_work(&dev->mode_config.output_poll_work, delay); 283 } 284 285 /** 286 * drm_kms_helper_poll_enable - re-enable output polling. 287 * @dev: drm_device 288 * 289 * This function re-enables the output polling work, after it has been 290 * temporarily disabled using drm_kms_helper_poll_disable(), for example over 291 * suspend/resume. 292 * 293 * Drivers can call this helper from their device resume implementation. It is 294 * not an error to call this even when output polling isn't enabled. 295 * 296 * If device polling was never initialized before, this call will trigger a 297 * warning and return. 298 * 299 * Note that calls to enable and disable polling must be strictly ordered, which 300 * is automatically the case when they're only call from suspend/resume 301 * callbacks. 302 */ 303 void drm_kms_helper_poll_enable(struct drm_device *dev) 304 { 305 if (drm_WARN_ON_ONCE(dev, !dev->mode_config.poll_enabled) || 306 !drm_kms_helper_poll || dev->mode_config.poll_running) 307 return; 308 309 if (drm_kms_helper_enable_hpd(dev) || 310 dev->mode_config.delayed_event) 311 reschedule_output_poll_work(dev); 312 313 dev->mode_config.poll_running = true; 314 } 315 EXPORT_SYMBOL(drm_kms_helper_poll_enable); 316 317 /** 318 * drm_kms_helper_poll_reschedule - reschedule the output polling work 319 * @dev: drm_device 320 * 321 * This function reschedules the output polling work, after polling for a 322 * connector has been enabled. 323 * 324 * Drivers must call this helper after enabling polling for a connector by 325 * setting %DRM_CONNECTOR_POLL_CONNECT / %DRM_CONNECTOR_POLL_DISCONNECT flags 326 * in drm_connector::polled. Note that after disabling polling by clearing these 327 * flags for a connector will stop the output polling work automatically if 328 * the polling is disabled for all other connectors as well. 329 * 330 * The function can be called only after polling has been enabled by calling 331 * drm_kms_helper_poll_init() / drm_kms_helper_poll_enable(). 332 */ 333 void drm_kms_helper_poll_reschedule(struct drm_device *dev) 334 { 335 if (dev->mode_config.poll_running) 336 reschedule_output_poll_work(dev); 337 } 338 EXPORT_SYMBOL(drm_kms_helper_poll_reschedule); 339 340 static enum drm_connector_status 341 drm_helper_probe_detect_ctx(struct drm_connector *connector, bool force) 342 { 343 const struct drm_connector_helper_funcs *funcs = connector->helper_private; 344 struct drm_modeset_acquire_ctx ctx; 345 int ret; 346 347 drm_modeset_acquire_init(&ctx, 0); 348 349 retry: 350 ret = drm_modeset_lock(&connector->dev->mode_config.connection_mutex, &ctx); 351 if (!ret) { 352 if (funcs->detect_ctx) 353 ret = funcs->detect_ctx(connector, &ctx, force); 354 else if (connector->funcs->detect) 355 ret = connector->funcs->detect(connector, force); 356 else 357 ret = connector_status_connected; 358 } 359 360 if (ret == -EDEADLK) { 361 drm_modeset_backoff(&ctx); 362 goto retry; 363 } 364 365 if (WARN_ON(ret < 0)) 366 ret = connector_status_unknown; 367 368 if (ret != connector->status) 369 connector->epoch_counter += 1; 370 371 drm_modeset_drop_locks(&ctx); 372 drm_modeset_acquire_fini(&ctx); 373 374 return ret; 375 } 376 377 /** 378 * drm_helper_probe_detect - probe connector status 379 * @connector: connector to probe 380 * @ctx: acquire_ctx, or NULL to let this function handle locking. 381 * @force: Whether destructive probe operations should be performed. 382 * 383 * This function calls the detect callbacks of the connector. 384 * This function returns &drm_connector_status, or 385 * if @ctx is set, it might also return -EDEADLK. 386 */ 387 int 388 drm_helper_probe_detect(struct drm_connector *connector, 389 struct drm_modeset_acquire_ctx *ctx, 390 bool force) 391 { 392 const struct drm_connector_helper_funcs *funcs = connector->helper_private; 393 struct drm_device *dev = connector->dev; 394 int ret; 395 396 if (!ctx) 397 return drm_helper_probe_detect_ctx(connector, force); 398 399 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, ctx); 400 if (ret) 401 return ret; 402 403 if (funcs->detect_ctx) 404 ret = funcs->detect_ctx(connector, ctx, force); 405 else if (connector->funcs->detect) 406 ret = connector->funcs->detect(connector, force); 407 else 408 ret = connector_status_connected; 409 410 if (ret != connector->status) 411 connector->epoch_counter += 1; 412 413 return ret; 414 } 415 EXPORT_SYMBOL(drm_helper_probe_detect); 416 417 static int drm_helper_probe_get_modes(struct drm_connector *connector) 418 { 419 const struct drm_connector_helper_funcs *connector_funcs = 420 connector->helper_private; 421 int count; 422 423 count = connector_funcs->get_modes(connector); 424 425 /* 426 * Fallback for when DDC probe failed in drm_get_edid() and thus skipped 427 * override/firmware EDID. 428 */ 429 if (count == 0 && connector->status == connector_status_connected) 430 count = drm_edid_override_connector_update(connector); 431 432 return count; 433 } 434 435 static int __drm_helper_update_and_validate(struct drm_connector *connector, 436 uint32_t maxX, uint32_t maxY, 437 struct drm_modeset_acquire_ctx *ctx) 438 { 439 struct drm_device *dev = connector->dev; 440 struct drm_display_mode *mode; 441 int mode_flags = 0; 442 int ret; 443 444 drm_connector_list_update(connector); 445 446 if (connector->interlace_allowed) 447 mode_flags |= DRM_MODE_FLAG_INTERLACE; 448 if (connector->doublescan_allowed) 449 mode_flags |= DRM_MODE_FLAG_DBLSCAN; 450 if (connector->stereo_allowed) 451 mode_flags |= DRM_MODE_FLAG_3D_MASK; 452 453 list_for_each_entry(mode, &connector->modes, head) { 454 if (mode->status != MODE_OK) 455 continue; 456 457 mode->status = drm_mode_validate_driver(dev, mode); 458 if (mode->status != MODE_OK) 459 continue; 460 461 mode->status = drm_mode_validate_size(mode, maxX, maxY); 462 if (mode->status != MODE_OK) 463 continue; 464 465 mode->status = drm_mode_validate_flag(mode, mode_flags); 466 if (mode->status != MODE_OK) 467 continue; 468 469 ret = drm_mode_validate_pipeline(mode, connector, ctx, 470 &mode->status); 471 if (ret) { 472 drm_dbg_kms(dev, 473 "drm_mode_validate_pipeline failed: %d\n", 474 ret); 475 476 if (drm_WARN_ON_ONCE(dev, ret != -EDEADLK)) 477 mode->status = MODE_ERROR; 478 else 479 return -EDEADLK; 480 } 481 482 if (mode->status != MODE_OK) 483 continue; 484 mode->status = drm_mode_validate_ycbcr420(mode, connector); 485 } 486 487 return 0; 488 } 489 490 /** 491 * drm_helper_probe_single_connector_modes - get complete set of display modes 492 * @connector: connector to probe 493 * @maxX: max width for modes 494 * @maxY: max height for modes 495 * 496 * Based on the helper callbacks implemented by @connector in struct 497 * &drm_connector_helper_funcs try to detect all valid modes. Modes will first 498 * be added to the connector's probed_modes list, then culled (based on validity 499 * and the @maxX, @maxY parameters) and put into the normal modes list. 500 * 501 * Intended to be used as a generic implementation of the 502 * &drm_connector_funcs.fill_modes() vfunc for drivers that use the CRTC helpers 503 * for output mode filtering and detection. 504 * 505 * The basic procedure is as follows 506 * 507 * 1. All modes currently on the connector's modes list are marked as stale 508 * 509 * 2. New modes are added to the connector's probed_modes list with 510 * drm_mode_probed_add(). New modes start their life with status as OK. 511 * Modes are added from a single source using the following priority order. 512 * 513 * - &drm_connector_helper_funcs.get_modes vfunc 514 * - if the connector status is connector_status_connected, standard 515 * VESA DMT modes up to 1024x768 are automatically added 516 * (drm_add_modes_noedid()) 517 * 518 * Finally modes specified via the kernel command line (video=...) are 519 * added in addition to what the earlier probes produced 520 * (drm_helper_probe_add_cmdline_mode()). These modes are generated 521 * using the VESA GTF/CVT formulas. 522 * 523 * 3. Modes are moved from the probed_modes list to the modes list. Potential 524 * duplicates are merged together (see drm_connector_list_update()). 525 * After this step the probed_modes list will be empty again. 526 * 527 * 4. Any non-stale mode on the modes list then undergoes validation 528 * 529 * - drm_mode_validate_basic() performs basic sanity checks 530 * - drm_mode_validate_size() filters out modes larger than @maxX and @maxY 531 * (if specified) 532 * - drm_mode_validate_flag() checks the modes against basic connector 533 * capabilities (interlace_allowed,doublescan_allowed,stereo_allowed) 534 * - the optional &drm_connector_helper_funcs.mode_valid or 535 * &drm_connector_helper_funcs.mode_valid_ctx helpers can perform driver 536 * and/or sink specific checks 537 * - the optional &drm_crtc_helper_funcs.mode_valid, 538 * &drm_bridge_funcs.mode_valid and &drm_encoder_helper_funcs.mode_valid 539 * helpers can perform driver and/or source specific checks which are also 540 * enforced by the modeset/atomic helpers 541 * 542 * 5. Any mode whose status is not OK is pruned from the connector's modes list, 543 * accompanied by a debug message indicating the reason for the mode's 544 * rejection (see drm_mode_prune_invalid()). 545 * 546 * Returns: 547 * The number of modes found on @connector. 548 */ 549 int drm_helper_probe_single_connector_modes(struct drm_connector *connector, 550 uint32_t maxX, uint32_t maxY) 551 { 552 struct drm_device *dev = connector->dev; 553 struct drm_display_mode *mode; 554 int count = 0, ret; 555 enum drm_connector_status old_status; 556 struct drm_modeset_acquire_ctx ctx; 557 558 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex)); 559 560 drm_modeset_acquire_init(&ctx, 0); 561 562 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id, 563 connector->name); 564 565 retry: 566 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx); 567 if (ret == -EDEADLK) { 568 drm_modeset_backoff(&ctx); 569 goto retry; 570 } else 571 WARN_ON(ret < 0); 572 573 /* set all old modes to the stale state */ 574 list_for_each_entry(mode, &connector->modes, head) 575 mode->status = MODE_STALE; 576 577 old_status = connector->status; 578 579 if (connector->force) { 580 if (connector->force == DRM_FORCE_ON || 581 connector->force == DRM_FORCE_ON_DIGITAL) 582 connector->status = connector_status_connected; 583 else 584 connector->status = connector_status_disconnected; 585 if (connector->funcs->force) 586 connector->funcs->force(connector); 587 } else { 588 ret = drm_helper_probe_detect(connector, &ctx, true); 589 590 if (ret == -EDEADLK) { 591 drm_modeset_backoff(&ctx); 592 goto retry; 593 } else if (WARN(ret < 0, "Invalid return value %i for connector detection\n", ret)) 594 ret = connector_status_unknown; 595 596 connector->status = ret; 597 } 598 599 /* 600 * Normally either the driver's hpd code or the poll loop should 601 * pick up any changes and fire the hotplug event. But if 602 * userspace sneaks in a probe, we might miss a change. Hence 603 * check here, and if anything changed start the hotplug code. 604 */ 605 if (old_status != connector->status) { 606 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n", 607 connector->base.id, 608 connector->name, 609 drm_get_connector_status_name(old_status), 610 drm_get_connector_status_name(connector->status)); 611 612 /* 613 * The hotplug event code might call into the fb 614 * helpers, and so expects that we do not hold any 615 * locks. Fire up the poll struct instead, it will 616 * disable itself again. 617 */ 618 dev->mode_config.delayed_event = true; 619 if (dev->mode_config.poll_enabled) 620 mod_delayed_work(system_wq, 621 &dev->mode_config.output_poll_work, 622 0); 623 } 624 625 /* 626 * Re-enable polling in case the global poll config changed but polling 627 * is still initialized. 628 */ 629 if (dev->mode_config.poll_enabled) 630 drm_kms_helper_poll_enable(dev); 631 632 if (connector->status == connector_status_disconnected) { 633 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n", 634 connector->base.id, connector->name); 635 drm_connector_update_edid_property(connector, NULL); 636 drm_mode_prune_invalid(dev, &connector->modes, false); 637 goto exit; 638 } 639 640 count = drm_helper_probe_get_modes(connector); 641 642 if (count == 0 && (connector->status == connector_status_connected || 643 connector->status == connector_status_unknown)) { 644 count = drm_add_modes_noedid(connector, 1024, 768); 645 646 /* 647 * Section 4.2.2.6 (EDID Corruption Detection) of the DP 1.4a 648 * Link CTS specifies that 640x480 (the official "failsafe" 649 * mode) needs to be the default if there's no EDID. 650 */ 651 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) 652 drm_set_preferred_mode(connector, 640, 480); 653 } 654 count += drm_helper_probe_add_cmdline_mode(connector); 655 if (count != 0) { 656 ret = __drm_helper_update_and_validate(connector, maxX, maxY, &ctx); 657 if (ret == -EDEADLK) { 658 drm_modeset_backoff(&ctx); 659 goto retry; 660 } 661 } 662 663 drm_mode_prune_invalid(dev, &connector->modes, true); 664 665 /* 666 * Displayport spec section 5.2.1.2 ("Video Timing Format") says that 667 * all detachable sinks shall support 640x480 @60Hz as a fail safe 668 * mode. If all modes were pruned, perhaps because they need more 669 * lanes or a higher pixel clock than available, at least try to add 670 * in 640x480. 671 */ 672 if (list_empty(&connector->modes) && 673 connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) { 674 count = drm_add_modes_noedid(connector, 640, 480); 675 ret = __drm_helper_update_and_validate(connector, maxX, maxY, &ctx); 676 if (ret == -EDEADLK) { 677 drm_modeset_backoff(&ctx); 678 goto retry; 679 } 680 drm_mode_prune_invalid(dev, &connector->modes, true); 681 } 682 683 exit: 684 drm_modeset_drop_locks(&ctx); 685 drm_modeset_acquire_fini(&ctx); 686 687 if (list_empty(&connector->modes)) 688 return 0; 689 690 drm_mode_sort(&connector->modes); 691 692 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id, 693 connector->name); 694 list_for_each_entry(mode, &connector->modes, head) { 695 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V); 696 drm_mode_debug_printmodeline(mode); 697 } 698 699 return count; 700 } 701 EXPORT_SYMBOL(drm_helper_probe_single_connector_modes); 702 703 /** 704 * drm_kms_helper_hotplug_event - fire off KMS hotplug events 705 * @dev: drm_device whose connector state changed 706 * 707 * This function fires off the uevent for userspace and also calls the 708 * output_poll_changed function, which is most commonly used to inform the fbdev 709 * emulation code and allow it to update the fbcon output configuration. 710 * 711 * Drivers should call this from their hotplug handling code when a change is 712 * detected. Note that this function does not do any output detection of its 713 * own, like drm_helper_hpd_irq_event() does - this is assumed to be done by the 714 * driver already. 715 * 716 * This function must be called from process context with no mode 717 * setting locks held. 718 * 719 * If only a single connector has changed, consider calling 720 * drm_kms_helper_connector_hotplug_event() instead. 721 */ 722 void drm_kms_helper_hotplug_event(struct drm_device *dev) 723 { 724 /* send a uevent + call fbdev */ 725 drm_sysfs_hotplug_event(dev); 726 if (dev->mode_config.funcs->output_poll_changed) 727 dev->mode_config.funcs->output_poll_changed(dev); 728 729 drm_client_dev_hotplug(dev); 730 } 731 EXPORT_SYMBOL(drm_kms_helper_hotplug_event); 732 733 /** 734 * drm_kms_helper_connector_hotplug_event - fire off a KMS connector hotplug event 735 * @connector: drm_connector which has changed 736 * 737 * This is the same as drm_kms_helper_hotplug_event(), except it fires a more 738 * fine-grained uevent for a single connector. 739 */ 740 void drm_kms_helper_connector_hotplug_event(struct drm_connector *connector) 741 { 742 struct drm_device *dev = connector->dev; 743 744 /* send a uevent + call fbdev */ 745 drm_sysfs_connector_hotplug_event(connector); 746 if (dev->mode_config.funcs->output_poll_changed) 747 dev->mode_config.funcs->output_poll_changed(dev); 748 749 drm_client_dev_hotplug(dev); 750 } 751 EXPORT_SYMBOL(drm_kms_helper_connector_hotplug_event); 752 753 static void output_poll_execute(struct work_struct *work) 754 { 755 struct delayed_work *delayed_work = to_delayed_work(work); 756 struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work); 757 struct drm_connector *connector; 758 struct drm_connector_list_iter conn_iter; 759 enum drm_connector_status old_status; 760 bool repoll = false, changed; 761 u64 old_epoch_counter; 762 763 if (!dev->mode_config.poll_enabled) 764 return; 765 766 /* Pick up any changes detected by the probe functions. */ 767 changed = dev->mode_config.delayed_event; 768 dev->mode_config.delayed_event = false; 769 770 if (!drm_kms_helper_poll && dev->mode_config.poll_running) { 771 drm_kms_helper_disable_hpd(dev); 772 dev->mode_config.poll_running = false; 773 goto out; 774 } 775 776 if (!mutex_trylock(&dev->mode_config.mutex)) { 777 repoll = true; 778 goto out; 779 } 780 781 drm_connector_list_iter_begin(dev, &conn_iter); 782 drm_for_each_connector_iter(connector, &conn_iter) { 783 /* Ignore forced connectors. */ 784 if (connector->force) 785 continue; 786 787 /* Ignore HPD capable connectors and connectors where we don't 788 * want any hotplug detection at all for polling. */ 789 if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD) 790 continue; 791 792 old_status = connector->status; 793 /* if we are connected and don't want to poll for disconnect 794 skip it */ 795 if (old_status == connector_status_connected && 796 !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT)) 797 continue; 798 799 repoll = true; 800 801 old_epoch_counter = connector->epoch_counter; 802 connector->status = drm_helper_probe_detect(connector, NULL, false); 803 if (old_epoch_counter != connector->epoch_counter) { 804 const char *old, *new; 805 806 /* 807 * The poll work sets force=false when calling detect so 808 * that drivers can avoid to do disruptive tests (e.g. 809 * when load detect cycles could cause flickering on 810 * other, running displays). This bears the risk that we 811 * flip-flop between unknown here in the poll work and 812 * the real state when userspace forces a full detect 813 * call after receiving a hotplug event due to this 814 * change. 815 * 816 * Hence clamp an unknown detect status to the old 817 * value. 818 */ 819 if (connector->status == connector_status_unknown) { 820 connector->status = old_status; 821 continue; 822 } 823 824 old = drm_get_connector_status_name(old_status); 825 new = drm_get_connector_status_name(connector->status); 826 827 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] " 828 "status updated from %s to %s\n", 829 connector->base.id, 830 connector->name, 831 old, new); 832 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] epoch counter %llu -> %llu\n", 833 connector->base.id, connector->name, 834 old_epoch_counter, connector->epoch_counter); 835 836 changed = true; 837 } 838 } 839 drm_connector_list_iter_end(&conn_iter); 840 841 mutex_unlock(&dev->mode_config.mutex); 842 843 out: 844 if (changed) 845 drm_kms_helper_hotplug_event(dev); 846 847 if (repoll) 848 schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD); 849 } 850 851 /** 852 * drm_kms_helper_is_poll_worker - is %current task an output poll worker? 853 * 854 * Determine if %current task is an output poll worker. This can be used 855 * to select distinct code paths for output polling versus other contexts. 856 * 857 * One use case is to avoid a deadlock between the output poll worker and 858 * the autosuspend worker wherein the latter waits for polling to finish 859 * upon calling drm_kms_helper_poll_disable(), while the former waits for 860 * runtime suspend to finish upon calling pm_runtime_get_sync() in a 861 * connector ->detect hook. 862 */ 863 bool drm_kms_helper_is_poll_worker(void) 864 { 865 struct work_struct *work = current_work(); 866 867 return work && work->func == output_poll_execute; 868 } 869 EXPORT_SYMBOL(drm_kms_helper_is_poll_worker); 870 871 /** 872 * drm_kms_helper_poll_disable - disable output polling 873 * @dev: drm_device 874 * 875 * This function disables the output polling work. 876 * 877 * Drivers can call this helper from their device suspend implementation. It is 878 * not an error to call this even when output polling isn't enabled or already 879 * disabled. Polling is re-enabled by calling drm_kms_helper_poll_enable(). 880 * 881 * If however, the polling was never initialized, this call will trigger a 882 * warning and return 883 * 884 * Note that calls to enable and disable polling must be strictly ordered, which 885 * is automatically the case when they're only call from suspend/resume 886 * callbacks. 887 */ 888 void drm_kms_helper_poll_disable(struct drm_device *dev) 889 { 890 if (drm_WARN_ON(dev, !dev->mode_config.poll_enabled)) 891 return; 892 893 if (dev->mode_config.poll_running) 894 drm_kms_helper_disable_hpd(dev); 895 896 cancel_delayed_work_sync(&dev->mode_config.output_poll_work); 897 898 dev->mode_config.poll_running = false; 899 } 900 EXPORT_SYMBOL(drm_kms_helper_poll_disable); 901 902 /** 903 * drm_kms_helper_poll_init - initialize and enable output polling 904 * @dev: drm_device 905 * 906 * This function initializes and then also enables output polling support for 907 * @dev. Drivers which do not have reliable hotplug support in hardware can use 908 * this helper infrastructure to regularly poll such connectors for changes in 909 * their connection state. 910 * 911 * Drivers can control which connectors are polled by setting the 912 * DRM_CONNECTOR_POLL_CONNECT and DRM_CONNECTOR_POLL_DISCONNECT flags. On 913 * connectors where probing live outputs can result in visual distortion drivers 914 * should not set the DRM_CONNECTOR_POLL_DISCONNECT flag to avoid this. 915 * Connectors which have no flag or only DRM_CONNECTOR_POLL_HPD set are 916 * completely ignored by the polling logic. 917 * 918 * Note that a connector can be both polled and probed from the hotplug handler, 919 * in case the hotplug interrupt is known to be unreliable. 920 */ 921 void drm_kms_helper_poll_init(struct drm_device *dev) 922 { 923 INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute); 924 dev->mode_config.poll_enabled = true; 925 926 drm_kms_helper_poll_enable(dev); 927 } 928 EXPORT_SYMBOL(drm_kms_helper_poll_init); 929 930 /** 931 * drm_kms_helper_poll_fini - disable output polling and clean it up 932 * @dev: drm_device 933 */ 934 void drm_kms_helper_poll_fini(struct drm_device *dev) 935 { 936 if (!dev->mode_config.poll_enabled) 937 return; 938 939 drm_kms_helper_poll_disable(dev); 940 941 dev->mode_config.poll_enabled = false; 942 } 943 EXPORT_SYMBOL(drm_kms_helper_poll_fini); 944 945 static bool check_connector_changed(struct drm_connector *connector) 946 { 947 struct drm_device *dev = connector->dev; 948 enum drm_connector_status old_status; 949 u64 old_epoch_counter; 950 951 /* Only handle HPD capable connectors. */ 952 drm_WARN_ON(dev, !(connector->polled & DRM_CONNECTOR_POLL_HPD)); 953 954 drm_WARN_ON(dev, !mutex_is_locked(&dev->mode_config.mutex)); 955 956 old_status = connector->status; 957 old_epoch_counter = connector->epoch_counter; 958 connector->status = drm_helper_probe_detect(connector, NULL, false); 959 960 if (old_epoch_counter == connector->epoch_counter) { 961 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Same epoch counter %llu\n", 962 connector->base.id, 963 connector->name, 964 connector->epoch_counter); 965 966 return false; 967 } 968 969 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] status updated from %s to %s\n", 970 connector->base.id, 971 connector->name, 972 drm_get_connector_status_name(old_status), 973 drm_get_connector_status_name(connector->status)); 974 975 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Changed epoch counter %llu => %llu\n", 976 connector->base.id, 977 connector->name, 978 old_epoch_counter, 979 connector->epoch_counter); 980 981 return true; 982 } 983 984 /** 985 * drm_connector_helper_hpd_irq_event - hotplug processing 986 * @connector: drm_connector 987 * 988 * Drivers can use this helper function to run a detect cycle on a connector 989 * which has the DRM_CONNECTOR_POLL_HPD flag set in its &polled member. 990 * 991 * This helper function is useful for drivers which can track hotplug 992 * interrupts for a single connector. Drivers that want to send a 993 * hotplug event for all connectors or can't track hotplug interrupts 994 * per connector need to use drm_helper_hpd_irq_event(). 995 * 996 * This function must be called from process context with no mode 997 * setting locks held. 998 * 999 * Note that a connector can be both polled and probed from the hotplug 1000 * handler, in case the hotplug interrupt is known to be unreliable. 1001 * 1002 * Returns: 1003 * A boolean indicating whether the connector status changed or not 1004 */ 1005 bool drm_connector_helper_hpd_irq_event(struct drm_connector *connector) 1006 { 1007 struct drm_device *dev = connector->dev; 1008 bool changed; 1009 1010 mutex_lock(&dev->mode_config.mutex); 1011 changed = check_connector_changed(connector); 1012 mutex_unlock(&dev->mode_config.mutex); 1013 1014 if (changed) { 1015 drm_kms_helper_connector_hotplug_event(connector); 1016 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Sent hotplug event\n", 1017 connector->base.id, 1018 connector->name); 1019 } 1020 1021 return changed; 1022 } 1023 EXPORT_SYMBOL(drm_connector_helper_hpd_irq_event); 1024 1025 /** 1026 * drm_helper_hpd_irq_event - hotplug processing 1027 * @dev: drm_device 1028 * 1029 * Drivers can use this helper function to run a detect cycle on all connectors 1030 * which have the DRM_CONNECTOR_POLL_HPD flag set in their &polled member. All 1031 * other connectors are ignored, which is useful to avoid reprobing fixed 1032 * panels. 1033 * 1034 * This helper function is useful for drivers which can't or don't track hotplug 1035 * interrupts for each connector. 1036 * 1037 * Drivers which support hotplug interrupts for each connector individually and 1038 * which have a more fine-grained detect logic can use 1039 * drm_connector_helper_hpd_irq_event(). Alternatively, they should bypass this 1040 * code and directly call drm_kms_helper_hotplug_event() in case the connector 1041 * state changed. 1042 * 1043 * This function must be called from process context with no mode 1044 * setting locks held. 1045 * 1046 * Note that a connector can be both polled and probed from the hotplug handler, 1047 * in case the hotplug interrupt is known to be unreliable. 1048 * 1049 * Returns: 1050 * A boolean indicating whether the connector status changed or not 1051 */ 1052 bool drm_helper_hpd_irq_event(struct drm_device *dev) 1053 { 1054 struct drm_connector *connector, *first_changed_connector = NULL; 1055 struct drm_connector_list_iter conn_iter; 1056 int changed = 0; 1057 1058 if (!dev->mode_config.poll_enabled) 1059 return false; 1060 1061 mutex_lock(&dev->mode_config.mutex); 1062 drm_connector_list_iter_begin(dev, &conn_iter); 1063 drm_for_each_connector_iter(connector, &conn_iter) { 1064 /* Only handle HPD capable connectors. */ 1065 if (!(connector->polled & DRM_CONNECTOR_POLL_HPD)) 1066 continue; 1067 1068 if (check_connector_changed(connector)) { 1069 if (!first_changed_connector) { 1070 drm_connector_get(connector); 1071 first_changed_connector = connector; 1072 } 1073 1074 changed++; 1075 } 1076 } 1077 drm_connector_list_iter_end(&conn_iter); 1078 mutex_unlock(&dev->mode_config.mutex); 1079 1080 if (changed == 1) 1081 drm_kms_helper_connector_hotplug_event(first_changed_connector); 1082 else if (changed > 0) 1083 drm_kms_helper_hotplug_event(dev); 1084 1085 if (first_changed_connector) 1086 drm_connector_put(first_changed_connector); 1087 1088 return changed; 1089 } 1090 EXPORT_SYMBOL(drm_helper_hpd_irq_event); 1091 1092 /** 1093 * drm_crtc_helper_mode_valid_fixed - Validates a display mode 1094 * @crtc: the crtc 1095 * @mode: the mode to validate 1096 * @fixed_mode: the display hardware's mode 1097 * 1098 * Returns: 1099 * MODE_OK on success, or another mode-status code otherwise. 1100 */ 1101 enum drm_mode_status drm_crtc_helper_mode_valid_fixed(struct drm_crtc *crtc, 1102 const struct drm_display_mode *mode, 1103 const struct drm_display_mode *fixed_mode) 1104 { 1105 if (mode->hdisplay != fixed_mode->hdisplay && mode->vdisplay != fixed_mode->vdisplay) 1106 return MODE_ONE_SIZE; 1107 else if (mode->hdisplay != fixed_mode->hdisplay) 1108 return MODE_ONE_WIDTH; 1109 else if (mode->vdisplay != fixed_mode->vdisplay) 1110 return MODE_ONE_HEIGHT; 1111 1112 return MODE_OK; 1113 } 1114 EXPORT_SYMBOL(drm_crtc_helper_mode_valid_fixed); 1115 1116 /** 1117 * drm_connector_helper_get_modes_fixed - Duplicates a display mode for a connector 1118 * @connector: the connector 1119 * @fixed_mode: the display hardware's mode 1120 * 1121 * This function duplicates a display modes for a connector. Drivers for hardware 1122 * that only supports a single fixed mode can use this function in their connector's 1123 * get_modes helper. 1124 * 1125 * Returns: 1126 * The number of created modes. 1127 */ 1128 int drm_connector_helper_get_modes_fixed(struct drm_connector *connector, 1129 const struct drm_display_mode *fixed_mode) 1130 { 1131 struct drm_device *dev = connector->dev; 1132 struct drm_display_mode *mode; 1133 1134 mode = drm_mode_duplicate(dev, fixed_mode); 1135 if (!mode) { 1136 drm_err(dev, "Failed to duplicate mode " DRM_MODE_FMT "\n", 1137 DRM_MODE_ARG(fixed_mode)); 1138 return 0; 1139 } 1140 1141 if (mode->name[0] == '\0') 1142 drm_mode_set_name(mode); 1143 1144 mode->type |= DRM_MODE_TYPE_PREFERRED; 1145 drm_mode_probed_add(connector, mode); 1146 1147 if (mode->width_mm) 1148 connector->display_info.width_mm = mode->width_mm; 1149 if (mode->height_mm) 1150 connector->display_info.height_mm = mode->height_mm; 1151 1152 return 1; 1153 } 1154 EXPORT_SYMBOL(drm_connector_helper_get_modes_fixed); 1155 1156 /** 1157 * drm_connector_helper_get_modes - Read EDID and update connector. 1158 * @connector: The connector 1159 * 1160 * Read the EDID using drm_edid_read() (which requires that connector->ddc is 1161 * set), and update the connector using the EDID. 1162 * 1163 * This can be used as the "default" connector helper .get_modes() hook if the 1164 * driver does not need any special processing. This is sets the example what 1165 * custom .get_modes() hooks should do regarding EDID read and connector update. 1166 * 1167 * Returns: Number of modes. 1168 */ 1169 int drm_connector_helper_get_modes(struct drm_connector *connector) 1170 { 1171 const struct drm_edid *drm_edid; 1172 int count; 1173 1174 drm_edid = drm_edid_read(connector); 1175 1176 /* 1177 * Unconditionally update the connector. If the EDID was read 1178 * successfully, fill in the connector information derived from the 1179 * EDID. Otherwise, if the EDID is NULL, clear the connector 1180 * information. 1181 */ 1182 drm_edid_connector_update(connector, drm_edid); 1183 1184 count = drm_edid_connector_add_modes(connector); 1185 1186 drm_edid_free(drm_edid); 1187 1188 return count; 1189 } 1190 EXPORT_SYMBOL(drm_connector_helper_get_modes); 1191 1192 /** 1193 * drm_connector_helper_tv_get_modes - Fills the modes availables to a TV connector 1194 * @connector: The connector 1195 * 1196 * Fills the available modes for a TV connector based on the supported 1197 * TV modes, and the default mode expressed by the kernel command line. 1198 * 1199 * This can be used as the default TV connector helper .get_modes() hook 1200 * if the driver does not need any special processing. 1201 * 1202 * Returns: 1203 * The number of modes added to the connector. 1204 */ 1205 int drm_connector_helper_tv_get_modes(struct drm_connector *connector) 1206 { 1207 struct drm_device *dev = connector->dev; 1208 struct drm_property *tv_mode_property = 1209 dev->mode_config.tv_mode_property; 1210 struct drm_cmdline_mode *cmdline = &connector->cmdline_mode; 1211 unsigned int ntsc_modes = BIT(DRM_MODE_TV_MODE_NTSC) | 1212 BIT(DRM_MODE_TV_MODE_NTSC_443) | 1213 BIT(DRM_MODE_TV_MODE_NTSC_J) | 1214 BIT(DRM_MODE_TV_MODE_PAL_M); 1215 unsigned int pal_modes = BIT(DRM_MODE_TV_MODE_PAL) | 1216 BIT(DRM_MODE_TV_MODE_PAL_N) | 1217 BIT(DRM_MODE_TV_MODE_SECAM); 1218 unsigned int tv_modes[2] = { UINT_MAX, UINT_MAX }; 1219 unsigned int i, supported_tv_modes = 0; 1220 1221 if (!tv_mode_property) 1222 return 0; 1223 1224 for (i = 0; i < tv_mode_property->num_values; i++) 1225 supported_tv_modes |= BIT(tv_mode_property->values[i]); 1226 1227 if ((supported_tv_modes & ntsc_modes) && 1228 (supported_tv_modes & pal_modes)) { 1229 uint64_t default_mode; 1230 1231 if (drm_object_property_get_default_value(&connector->base, 1232 tv_mode_property, 1233 &default_mode)) 1234 return 0; 1235 1236 if (cmdline->tv_mode_specified) 1237 default_mode = cmdline->tv_mode; 1238 1239 if (BIT(default_mode) & ntsc_modes) { 1240 tv_modes[0] = DRM_MODE_TV_MODE_NTSC; 1241 tv_modes[1] = DRM_MODE_TV_MODE_PAL; 1242 } else { 1243 tv_modes[0] = DRM_MODE_TV_MODE_PAL; 1244 tv_modes[1] = DRM_MODE_TV_MODE_NTSC; 1245 } 1246 } else if (supported_tv_modes & ntsc_modes) { 1247 tv_modes[0] = DRM_MODE_TV_MODE_NTSC; 1248 } else if (supported_tv_modes & pal_modes) { 1249 tv_modes[0] = DRM_MODE_TV_MODE_PAL; 1250 } else { 1251 return 0; 1252 } 1253 1254 for (i = 0; i < ARRAY_SIZE(tv_modes); i++) { 1255 struct drm_display_mode *mode; 1256 1257 if (tv_modes[i] == DRM_MODE_TV_MODE_NTSC) 1258 mode = drm_mode_analog_ntsc_480i(dev); 1259 else if (tv_modes[i] == DRM_MODE_TV_MODE_PAL) 1260 mode = drm_mode_analog_pal_576i(dev); 1261 else 1262 break; 1263 if (!mode) 1264 return i; 1265 if (!i) 1266 mode->type |= DRM_MODE_TYPE_PREFERRED; 1267 drm_mode_probed_add(connector, mode); 1268 } 1269 1270 return i; 1271 } 1272 EXPORT_SYMBOL(drm_connector_helper_tv_get_modes); 1273