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 66static bool drm_kms_helper_poll = true; 67module_param_named(poll, drm_kms_helper_poll, bool, 0600); 68 69static enum drm_mode_status 70drm_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 88static int 89drm_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 144static 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 179enum 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 190enum 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 202int 203drm_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 225static 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 241static 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) 265static 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 */ 303void 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} 315EXPORT_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 */ 333void drm_kms_helper_poll_reschedule(struct drm_device *dev) 334{ 335 if (dev->mode_config.poll_running) 336 reschedule_output_poll_work(dev); 337} 338EXPORT_SYMBOL(drm_kms_helper_poll_reschedule); 339 340static enum drm_connector_status 341drm_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 349retry: 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 */ 387int 388drm_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} 415EXPORT_SYMBOL(drm_helper_probe_detect); 416 417static 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 /* The .get_modes() callback should not return negative values. */ 426 if (count < 0) { 427 drm_err(connector->dev, ".get_modes() returned %pe\n", 428 ERR_PTR(count)); 429 count = 0; 430 } 431 432 /* 433 * Fallback for when DDC probe failed in drm_get_edid() and thus skipped 434 * override/firmware EDID. 435 */ 436 if (count == 0 && connector->status == connector_status_connected) 437 count = drm_edid_override_connector_update(connector); 438 439 return count; 440} 441 442static int __drm_helper_update_and_validate(struct drm_connector *connector, 443 uint32_t maxX, uint32_t maxY, 444 struct drm_modeset_acquire_ctx *ctx) 445{ 446 struct drm_device *dev = connector->dev; 447 struct drm_display_mode *mode; 448 int mode_flags = 0; 449 int ret; 450 451 drm_connector_list_update(connector); 452 453 if (connector->interlace_allowed) 454 mode_flags |= DRM_MODE_FLAG_INTERLACE; 455 if (connector->doublescan_allowed) 456 mode_flags |= DRM_MODE_FLAG_DBLSCAN; 457 if (connector->stereo_allowed) 458 mode_flags |= DRM_MODE_FLAG_3D_MASK; 459 460 list_for_each_entry(mode, &connector->modes, head) { 461 if (mode->status != MODE_OK) 462 continue; 463 464 mode->status = drm_mode_validate_driver(dev, mode); 465 if (mode->status != MODE_OK) 466 continue; 467 468 mode->status = drm_mode_validate_size(mode, maxX, maxY); 469 if (mode->status != MODE_OK) 470 continue; 471 472 mode->status = drm_mode_validate_flag(mode, mode_flags); 473 if (mode->status != MODE_OK) 474 continue; 475 476 ret = drm_mode_validate_pipeline(mode, connector, ctx, 477 &mode->status); 478 if (ret) { 479 drm_dbg_kms(dev, 480 "drm_mode_validate_pipeline failed: %d\n", 481 ret); 482 483 if (drm_WARN_ON_ONCE(dev, ret != -EDEADLK)) 484 mode->status = MODE_ERROR; 485 else 486 return -EDEADLK; 487 } 488 489 if (mode->status != MODE_OK) 490 continue; 491 mode->status = drm_mode_validate_ycbcr420(mode, connector); 492 } 493 494 return 0; 495} 496 497/** 498 * drm_helper_probe_single_connector_modes - get complete set of display modes 499 * @connector: connector to probe 500 * @maxX: max width for modes 501 * @maxY: max height for modes 502 * 503 * Based on the helper callbacks implemented by @connector in struct 504 * &drm_connector_helper_funcs try to detect all valid modes. Modes will first 505 * be added to the connector's probed_modes list, then culled (based on validity 506 * and the @maxX, @maxY parameters) and put into the normal modes list. 507 * 508 * Intended to be used as a generic implementation of the 509 * &drm_connector_funcs.fill_modes() vfunc for drivers that use the CRTC helpers 510 * for output mode filtering and detection. 511 * 512 * The basic procedure is as follows 513 * 514 * 1. All modes currently on the connector's modes list are marked as stale 515 * 516 * 2. New modes are added to the connector's probed_modes list with 517 * drm_mode_probed_add(). New modes start their life with status as OK. 518 * Modes are added from a single source using the following priority order. 519 * 520 * - &drm_connector_helper_funcs.get_modes vfunc 521 * - if the connector status is connector_status_connected, standard 522 * VESA DMT modes up to 1024x768 are automatically added 523 * (drm_add_modes_noedid()) 524 * 525 * Finally modes specified via the kernel command line (video=...) are 526 * added in addition to what the earlier probes produced 527 * (drm_helper_probe_add_cmdline_mode()). These modes are generated 528 * using the VESA GTF/CVT formulas. 529 * 530 * 3. Modes are moved from the probed_modes list to the modes list. Potential 531 * duplicates are merged together (see drm_connector_list_update()). 532 * After this step the probed_modes list will be empty again. 533 * 534 * 4. Any non-stale mode on the modes list then undergoes validation 535 * 536 * - drm_mode_validate_basic() performs basic sanity checks 537 * - drm_mode_validate_size() filters out modes larger than @maxX and @maxY 538 * (if specified) 539 * - drm_mode_validate_flag() checks the modes against basic connector 540 * capabilities (interlace_allowed,doublescan_allowed,stereo_allowed) 541 * - the optional &drm_connector_helper_funcs.mode_valid or 542 * &drm_connector_helper_funcs.mode_valid_ctx helpers can perform driver 543 * and/or sink specific checks 544 * - the optional &drm_crtc_helper_funcs.mode_valid, 545 * &drm_bridge_funcs.mode_valid and &drm_encoder_helper_funcs.mode_valid 546 * helpers can perform driver and/or source specific checks which are also 547 * enforced by the modeset/atomic helpers 548 * 549 * 5. Any mode whose status is not OK is pruned from the connector's modes list, 550 * accompanied by a debug message indicating the reason for the mode's 551 * rejection (see drm_mode_prune_invalid()). 552 * 553 * Returns: 554 * The number of modes found on @connector. 555 */ 556int drm_helper_probe_single_connector_modes(struct drm_connector *connector, 557 uint32_t maxX, uint32_t maxY) 558{ 559 struct drm_device *dev = connector->dev; 560 struct drm_display_mode *mode; 561 int count = 0, ret; 562 enum drm_connector_status old_status; 563 struct drm_modeset_acquire_ctx ctx; 564 565 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex)); 566 567 drm_modeset_acquire_init(&ctx, 0); 568 569 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id, 570 connector->name); 571 572retry: 573 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx); 574 if (ret == -EDEADLK) { 575 drm_modeset_backoff(&ctx); 576 goto retry; 577 } else 578 WARN_ON(ret < 0); 579 580 /* set all old modes to the stale state */ 581 list_for_each_entry(mode, &connector->modes, head) 582 mode->status = MODE_STALE; 583 584 old_status = connector->status; 585 586 if (connector->force) { 587 if (connector->force == DRM_FORCE_ON || 588 connector->force == DRM_FORCE_ON_DIGITAL) 589 connector->status = connector_status_connected; 590 else 591 connector->status = connector_status_disconnected; 592 if (connector->funcs->force) 593 connector->funcs->force(connector); 594 } else { 595 ret = drm_helper_probe_detect(connector, &ctx, true); 596 597 if (ret == -EDEADLK) { 598 drm_modeset_backoff(&ctx); 599 goto retry; 600 } else if (WARN(ret < 0, "Invalid return value %i for connector detection\n", ret)) 601 ret = connector_status_unknown; 602 603 connector->status = ret; 604 } 605 606 /* 607 * Normally either the driver's hpd code or the poll loop should 608 * pick up any changes and fire the hotplug event. But if 609 * userspace sneaks in a probe, we might miss a change. Hence 610 * check here, and if anything changed start the hotplug code. 611 */ 612 if (old_status != connector->status) { 613 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n", 614 connector->base.id, 615 connector->name, 616 drm_get_connector_status_name(old_status), 617 drm_get_connector_status_name(connector->status)); 618 619 /* 620 * The hotplug event code might call into the fb 621 * helpers, and so expects that we do not hold any 622 * locks. Fire up the poll struct instead, it will 623 * disable itself again. 624 */ 625 dev->mode_config.delayed_event = true; 626 if (dev->mode_config.poll_enabled) 627 mod_delayed_work(system_wq, 628 &dev->mode_config.output_poll_work, 629 0); 630 } 631 632 /* 633 * Re-enable polling in case the global poll config changed but polling 634 * is still initialized. 635 */ 636 if (dev->mode_config.poll_enabled) 637 drm_kms_helper_poll_enable(dev); 638 639 if (connector->status == connector_status_disconnected) { 640 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n", 641 connector->base.id, connector->name); 642 drm_connector_update_edid_property(connector, NULL); 643 drm_mode_prune_invalid(dev, &connector->modes, false); 644 goto exit; 645 } 646 647 count = drm_helper_probe_get_modes(connector); 648 649 if (count == 0 && (connector->status == connector_status_connected || 650 connector->status == connector_status_unknown)) { 651 count = drm_add_modes_noedid(connector, 1024, 768); 652 653 /* 654 * Section 4.2.2.6 (EDID Corruption Detection) of the DP 1.4a 655 * Link CTS specifies that 640x480 (the official "failsafe" 656 * mode) needs to be the default if there's no EDID. 657 */ 658 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) 659 drm_set_preferred_mode(connector, 640, 480); 660 } 661 count += drm_helper_probe_add_cmdline_mode(connector); 662 if (count != 0) { 663 ret = __drm_helper_update_and_validate(connector, maxX, maxY, &ctx); 664 if (ret == -EDEADLK) { 665 drm_modeset_backoff(&ctx); 666 goto retry; 667 } 668 } 669 670 drm_mode_prune_invalid(dev, &connector->modes, true); 671 672 /* 673 * Displayport spec section 5.2.1.2 ("Video Timing Format") says that 674 * all detachable sinks shall support 640x480 @60Hz as a fail safe 675 * mode. If all modes were pruned, perhaps because they need more 676 * lanes or a higher pixel clock than available, at least try to add 677 * in 640x480. 678 */ 679 if (list_empty(&connector->modes) && 680 connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) { 681 count = drm_add_modes_noedid(connector, 640, 480); 682 ret = __drm_helper_update_and_validate(connector, maxX, maxY, &ctx); 683 if (ret == -EDEADLK) { 684 drm_modeset_backoff(&ctx); 685 goto retry; 686 } 687 drm_mode_prune_invalid(dev, &connector->modes, true); 688 } 689 690exit: 691 drm_modeset_drop_locks(&ctx); 692 drm_modeset_acquire_fini(&ctx); 693 694 if (list_empty(&connector->modes)) 695 return 0; 696 697 drm_mode_sort(&connector->modes); 698 699 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id, 700 connector->name); 701 list_for_each_entry(mode, &connector->modes, head) { 702 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V); 703 drm_mode_debug_printmodeline(mode); 704 } 705 706 return count; 707} 708EXPORT_SYMBOL(drm_helper_probe_single_connector_modes); 709 710/** 711 * drm_kms_helper_hotplug_event - fire off KMS hotplug events 712 * @dev: drm_device whose connector state changed 713 * 714 * This function fires off the uevent for userspace and also calls the 715 * output_poll_changed function, which is most commonly used to inform the fbdev 716 * emulation code and allow it to update the fbcon output configuration. 717 * 718 * Drivers should call this from their hotplug handling code when a change is 719 * detected. Note that this function does not do any output detection of its 720 * own, like drm_helper_hpd_irq_event() does - this is assumed to be done by the 721 * driver already. 722 * 723 * This function must be called from process context with no mode 724 * setting locks held. 725 * 726 * If only a single connector has changed, consider calling 727 * drm_kms_helper_connector_hotplug_event() instead. 728 */ 729void drm_kms_helper_hotplug_event(struct drm_device *dev) 730{ 731 /* send a uevent + call fbdev */ 732 drm_sysfs_hotplug_event(dev); 733 if (dev->mode_config.funcs->output_poll_changed) 734 dev->mode_config.funcs->output_poll_changed(dev); 735 736 drm_client_dev_hotplug(dev); 737} 738EXPORT_SYMBOL(drm_kms_helper_hotplug_event); 739 740/** 741 * drm_kms_helper_connector_hotplug_event - fire off a KMS connector hotplug event 742 * @connector: drm_connector which has changed 743 * 744 * This is the same as drm_kms_helper_hotplug_event(), except it fires a more 745 * fine-grained uevent for a single connector. 746 */ 747void drm_kms_helper_connector_hotplug_event(struct drm_connector *connector) 748{ 749 struct drm_device *dev = connector->dev; 750 751 /* send a uevent + call fbdev */ 752 drm_sysfs_connector_hotplug_event(connector); 753 if (dev->mode_config.funcs->output_poll_changed) 754 dev->mode_config.funcs->output_poll_changed(dev); 755 756 drm_client_dev_hotplug(dev); 757} 758EXPORT_SYMBOL(drm_kms_helper_connector_hotplug_event); 759 760static void output_poll_execute(struct work_struct *work) 761{ 762 struct delayed_work *delayed_work = to_delayed_work(work); 763 struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work); 764 struct drm_connector *connector; 765 struct drm_connector_list_iter conn_iter; 766 enum drm_connector_status old_status; 767 bool repoll = false, changed; 768 u64 old_epoch_counter; 769 770 if (!dev->mode_config.poll_enabled) 771 return; 772 773 /* Pick up any changes detected by the probe functions. */ 774 changed = dev->mode_config.delayed_event; 775 dev->mode_config.delayed_event = false; 776 777 if (!drm_kms_helper_poll) { 778 if (dev->mode_config.poll_running) { 779 drm_kms_helper_disable_hpd(dev); 780 dev->mode_config.poll_running = false; 781 } 782 goto out; 783 } 784 785 if (!mutex_trylock(&dev->mode_config.mutex)) { 786 repoll = true; 787 goto out; 788 } 789 790 drm_connector_list_iter_begin(dev, &conn_iter); 791 drm_for_each_connector_iter(connector, &conn_iter) { 792 /* Ignore forced connectors. */ 793 if (connector->force) 794 continue; 795 796 /* Ignore HPD capable connectors and connectors where we don't 797 * want any hotplug detection at all for polling. */ 798 if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD) 799 continue; 800 801 old_status = connector->status; 802 /* if we are connected and don't want to poll for disconnect 803 skip it */ 804 if (old_status == connector_status_connected && 805 !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT)) 806 continue; 807 808 repoll = true; 809 810 old_epoch_counter = connector->epoch_counter; 811 connector->status = drm_helper_probe_detect(connector, NULL, false); 812 if (old_epoch_counter != connector->epoch_counter) { 813 const char *old, *new; 814 815 /* 816 * The poll work sets force=false when calling detect so 817 * that drivers can avoid to do disruptive tests (e.g. 818 * when load detect cycles could cause flickering on 819 * other, running displays). This bears the risk that we 820 * flip-flop between unknown here in the poll work and 821 * the real state when userspace forces a full detect 822 * call after receiving a hotplug event due to this 823 * change. 824 * 825 * Hence clamp an unknown detect status to the old 826 * value. 827 */ 828 if (connector->status == connector_status_unknown) { 829 connector->status = old_status; 830 continue; 831 } 832 833 old = drm_get_connector_status_name(old_status); 834 new = drm_get_connector_status_name(connector->status); 835 836 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] " 837 "status updated from %s to %s\n", 838 connector->base.id, 839 connector->name, 840 old, new); 841 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] epoch counter %llu -> %llu\n", 842 connector->base.id, connector->name, 843 old_epoch_counter, connector->epoch_counter); 844 845 changed = true; 846 } 847 } 848 drm_connector_list_iter_end(&conn_iter); 849 850 mutex_unlock(&dev->mode_config.mutex); 851 852out: 853 if (changed) 854 drm_kms_helper_hotplug_event(dev); 855 856 if (repoll) 857 schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD); 858} 859 860/** 861 * drm_kms_helper_is_poll_worker - is %current task an output poll worker? 862 * 863 * Determine if %current task is an output poll worker. This can be used 864 * to select distinct code paths for output polling versus other contexts. 865 * 866 * One use case is to avoid a deadlock between the output poll worker and 867 * the autosuspend worker wherein the latter waits for polling to finish 868 * upon calling drm_kms_helper_poll_disable(), while the former waits for 869 * runtime suspend to finish upon calling pm_runtime_get_sync() in a 870 * connector ->detect hook. 871 */ 872bool drm_kms_helper_is_poll_worker(void) 873{ 874 struct work_struct *work = current_work(); 875 876 return work && work->func == output_poll_execute; 877} 878EXPORT_SYMBOL(drm_kms_helper_is_poll_worker); 879 880/** 881 * drm_kms_helper_poll_disable - disable output polling 882 * @dev: drm_device 883 * 884 * This function disables the output polling work. 885 * 886 * Drivers can call this helper from their device suspend implementation. It is 887 * not an error to call this even when output polling isn't enabled or already 888 * disabled. Polling is re-enabled by calling drm_kms_helper_poll_enable(). 889 * 890 * If however, the polling was never initialized, this call will trigger a 891 * warning and return 892 * 893 * Note that calls to enable and disable polling must be strictly ordered, which 894 * is automatically the case when they're only call from suspend/resume 895 * callbacks. 896 */ 897void drm_kms_helper_poll_disable(struct drm_device *dev) 898{ 899 if (drm_WARN_ON(dev, !dev->mode_config.poll_enabled)) 900 return; 901 902 if (dev->mode_config.poll_running) 903 drm_kms_helper_disable_hpd(dev); 904 905 cancel_delayed_work_sync(&dev->mode_config.output_poll_work); 906 907 dev->mode_config.poll_running = false; 908} 909EXPORT_SYMBOL(drm_kms_helper_poll_disable); 910 911/** 912 * drm_kms_helper_poll_init - initialize and enable output polling 913 * @dev: drm_device 914 * 915 * This function initializes and then also enables output polling support for 916 * @dev. Drivers which do not have reliable hotplug support in hardware can use 917 * this helper infrastructure to regularly poll such connectors for changes in 918 * their connection state. 919 * 920 * Drivers can control which connectors are polled by setting the 921 * DRM_CONNECTOR_POLL_CONNECT and DRM_CONNECTOR_POLL_DISCONNECT flags. On 922 * connectors where probing live outputs can result in visual distortion drivers 923 * should not set the DRM_CONNECTOR_POLL_DISCONNECT flag to avoid this. 924 * Connectors which have no flag or only DRM_CONNECTOR_POLL_HPD set are 925 * completely ignored by the polling logic. 926 * 927 * Note that a connector can be both polled and probed from the hotplug handler, 928 * in case the hotplug interrupt is known to be unreliable. 929 */ 930void drm_kms_helper_poll_init(struct drm_device *dev) 931{ 932 INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute); 933 dev->mode_config.poll_enabled = true; 934 935 drm_kms_helper_poll_enable(dev); 936} 937EXPORT_SYMBOL(drm_kms_helper_poll_init); 938 939/** 940 * drm_kms_helper_poll_fini - disable output polling and clean it up 941 * @dev: drm_device 942 */ 943void drm_kms_helper_poll_fini(struct drm_device *dev) 944{ 945 if (!dev->mode_config.poll_enabled) 946 return; 947 948 drm_kms_helper_poll_disable(dev); 949 950 dev->mode_config.poll_enabled = false; 951} 952EXPORT_SYMBOL(drm_kms_helper_poll_fini); 953 954static bool check_connector_changed(struct drm_connector *connector) 955{ 956 struct drm_device *dev = connector->dev; 957 enum drm_connector_status old_status; 958 u64 old_epoch_counter; 959 960 /* Only handle HPD capable connectors. */ 961 drm_WARN_ON(dev, !(connector->polled & DRM_CONNECTOR_POLL_HPD)); 962 963 drm_WARN_ON(dev, !mutex_is_locked(&dev->mode_config.mutex)); 964 965 old_status = connector->status; 966 old_epoch_counter = connector->epoch_counter; 967 connector->status = drm_helper_probe_detect(connector, NULL, false); 968 969 if (old_epoch_counter == connector->epoch_counter) { 970 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Same epoch counter %llu\n", 971 connector->base.id, 972 connector->name, 973 connector->epoch_counter); 974 975 return false; 976 } 977 978 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] status updated from %s to %s\n", 979 connector->base.id, 980 connector->name, 981 drm_get_connector_status_name(old_status), 982 drm_get_connector_status_name(connector->status)); 983 984 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Changed epoch counter %llu => %llu\n", 985 connector->base.id, 986 connector->name, 987 old_epoch_counter, 988 connector->epoch_counter); 989 990 return true; 991} 992 993/** 994 * drm_connector_helper_hpd_irq_event - hotplug processing 995 * @connector: drm_connector 996 * 997 * Drivers can use this helper function to run a detect cycle on a connector 998 * which has the DRM_CONNECTOR_POLL_HPD flag set in its &polled member. 999 * 1000 * This helper function is useful for drivers which can track hotplug 1001 * interrupts for a single connector. Drivers that want to send a 1002 * hotplug event for all connectors or can't track hotplug interrupts 1003 * per connector need to use drm_helper_hpd_irq_event(). 1004 * 1005 * This function must be called from process context with no mode 1006 * setting locks held. 1007 * 1008 * Note that a connector can be both polled and probed from the hotplug 1009 * handler, in case the hotplug interrupt is known to be unreliable. 1010 * 1011 * Returns: 1012 * A boolean indicating whether the connector status changed or not 1013 */ 1014bool drm_connector_helper_hpd_irq_event(struct drm_connector *connector) 1015{ 1016 struct drm_device *dev = connector->dev; 1017 bool changed; 1018 1019 mutex_lock(&dev->mode_config.mutex); 1020 changed = check_connector_changed(connector); 1021 mutex_unlock(&dev->mode_config.mutex); 1022 1023 if (changed) { 1024 drm_kms_helper_connector_hotplug_event(connector); 1025 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Sent hotplug event\n", 1026 connector->base.id, 1027 connector->name); 1028 } 1029 1030 return changed; 1031} 1032EXPORT_SYMBOL(drm_connector_helper_hpd_irq_event); 1033 1034/** 1035 * drm_helper_hpd_irq_event - hotplug processing 1036 * @dev: drm_device 1037 * 1038 * Drivers can use this helper function to run a detect cycle on all connectors 1039 * which have the DRM_CONNECTOR_POLL_HPD flag set in their &polled member. All 1040 * other connectors are ignored, which is useful to avoid reprobing fixed 1041 * panels. 1042 * 1043 * This helper function is useful for drivers which can't or don't track hotplug 1044 * interrupts for each connector. 1045 * 1046 * Drivers which support hotplug interrupts for each connector individually and 1047 * which have a more fine-grained detect logic can use 1048 * drm_connector_helper_hpd_irq_event(). Alternatively, they should bypass this 1049 * code and directly call drm_kms_helper_hotplug_event() in case the connector 1050 * state changed. 1051 * 1052 * This function must be called from process context with no mode 1053 * setting locks held. 1054 * 1055 * Note that a connector can be both polled and probed from the hotplug handler, 1056 * in case the hotplug interrupt is known to be unreliable. 1057 * 1058 * Returns: 1059 * A boolean indicating whether the connector status changed or not 1060 */ 1061bool drm_helper_hpd_irq_event(struct drm_device *dev) 1062{ 1063 struct drm_connector *connector, *first_changed_connector = NULL; 1064 struct drm_connector_list_iter conn_iter; 1065 int changed = 0; 1066 1067 if (!dev->mode_config.poll_enabled) 1068 return false; 1069 1070 mutex_lock(&dev->mode_config.mutex); 1071 drm_connector_list_iter_begin(dev, &conn_iter); 1072 drm_for_each_connector_iter(connector, &conn_iter) { 1073 /* Only handle HPD capable connectors. */ 1074 if (!(connector->polled & DRM_CONNECTOR_POLL_HPD)) 1075 continue; 1076 1077 if (check_connector_changed(connector)) { 1078 if (!first_changed_connector) { 1079 drm_connector_get(connector); 1080 first_changed_connector = connector; 1081 } 1082 1083 changed++; 1084 } 1085 } 1086 drm_connector_list_iter_end(&conn_iter); 1087 mutex_unlock(&dev->mode_config.mutex); 1088 1089 if (changed == 1) 1090 drm_kms_helper_connector_hotplug_event(first_changed_connector); 1091 else if (changed > 0) 1092 drm_kms_helper_hotplug_event(dev); 1093 1094 if (first_changed_connector) 1095 drm_connector_put(first_changed_connector); 1096 1097 return changed; 1098} 1099EXPORT_SYMBOL(drm_helper_hpd_irq_event); 1100 1101/** 1102 * drm_crtc_helper_mode_valid_fixed - Validates a display mode 1103 * @crtc: the crtc 1104 * @mode: the mode to validate 1105 * @fixed_mode: the display hardware's mode 1106 * 1107 * Returns: 1108 * MODE_OK on success, or another mode-status code otherwise. 1109 */ 1110enum drm_mode_status drm_crtc_helper_mode_valid_fixed(struct drm_crtc *crtc, 1111 const struct drm_display_mode *mode, 1112 const struct drm_display_mode *fixed_mode) 1113{ 1114 if (mode->hdisplay != fixed_mode->hdisplay && mode->vdisplay != fixed_mode->vdisplay) 1115 return MODE_ONE_SIZE; 1116 else if (mode->hdisplay != fixed_mode->hdisplay) 1117 return MODE_ONE_WIDTH; 1118 else if (mode->vdisplay != fixed_mode->vdisplay) 1119 return MODE_ONE_HEIGHT; 1120 1121 return MODE_OK; 1122} 1123EXPORT_SYMBOL(drm_crtc_helper_mode_valid_fixed); 1124 1125/** 1126 * drm_connector_helper_get_modes_fixed - Duplicates a display mode for a connector 1127 * @connector: the connector 1128 * @fixed_mode: the display hardware's mode 1129 * 1130 * This function duplicates a display modes for a connector. Drivers for hardware 1131 * that only supports a single fixed mode can use this function in their connector's 1132 * get_modes helper. 1133 * 1134 * Returns: 1135 * The number of created modes. 1136 */ 1137int drm_connector_helper_get_modes_fixed(struct drm_connector *connector, 1138 const struct drm_display_mode *fixed_mode) 1139{ 1140 struct drm_device *dev = connector->dev; 1141 struct drm_display_mode *mode; 1142 1143 mode = drm_mode_duplicate(dev, fixed_mode); 1144 if (!mode) { 1145 drm_err(dev, "Failed to duplicate mode " DRM_MODE_FMT "\n", 1146 DRM_MODE_ARG(fixed_mode)); 1147 return 0; 1148 } 1149 1150 if (mode->name[0] == '\0') 1151 drm_mode_set_name(mode); 1152 1153 mode->type |= DRM_MODE_TYPE_PREFERRED; 1154 drm_mode_probed_add(connector, mode); 1155 1156 if (mode->width_mm) 1157 connector->display_info.width_mm = mode->width_mm; 1158 if (mode->height_mm) 1159 connector->display_info.height_mm = mode->height_mm; 1160 1161 return 1; 1162} 1163EXPORT_SYMBOL(drm_connector_helper_get_modes_fixed); 1164 1165/** 1166 * drm_connector_helper_get_modes - Read EDID and update connector. 1167 * @connector: The connector 1168 * 1169 * Read the EDID using drm_edid_read() (which requires that connector->ddc is 1170 * set), and update the connector using the EDID. 1171 * 1172 * This can be used as the "default" connector helper .get_modes() hook if the 1173 * driver does not need any special processing. This is sets the example what 1174 * custom .get_modes() hooks should do regarding EDID read and connector update. 1175 * 1176 * Returns: Number of modes. 1177 */ 1178int drm_connector_helper_get_modes(struct drm_connector *connector) 1179{ 1180 const struct drm_edid *drm_edid; 1181 int count; 1182 1183 drm_edid = drm_edid_read(connector); 1184 1185 /* 1186 * Unconditionally update the connector. If the EDID was read 1187 * successfully, fill in the connector information derived from the 1188 * EDID. Otherwise, if the EDID is NULL, clear the connector 1189 * information. 1190 */ 1191 drm_edid_connector_update(connector, drm_edid); 1192 1193 count = drm_edid_connector_add_modes(connector); 1194 1195 drm_edid_free(drm_edid); 1196 1197 return count; 1198} 1199EXPORT_SYMBOL(drm_connector_helper_get_modes); 1200 1201/** 1202 * drm_connector_helper_tv_get_modes - Fills the modes availables to a TV connector 1203 * @connector: The connector 1204 * 1205 * Fills the available modes for a TV connector based on the supported 1206 * TV modes, and the default mode expressed by the kernel command line. 1207 * 1208 * This can be used as the default TV connector helper .get_modes() hook 1209 * if the driver does not need any special processing. 1210 * 1211 * Returns: 1212 * The number of modes added to the connector. 1213 */ 1214int drm_connector_helper_tv_get_modes(struct drm_connector *connector) 1215{ 1216 struct drm_device *dev = connector->dev; 1217 struct drm_property *tv_mode_property = 1218 dev->mode_config.tv_mode_property; 1219 struct drm_cmdline_mode *cmdline = &connector->cmdline_mode; 1220 unsigned int ntsc_modes = BIT(DRM_MODE_TV_MODE_NTSC) | 1221 BIT(DRM_MODE_TV_MODE_NTSC_443) | 1222 BIT(DRM_MODE_TV_MODE_NTSC_J) | 1223 BIT(DRM_MODE_TV_MODE_PAL_M); 1224 unsigned int pal_modes = BIT(DRM_MODE_TV_MODE_PAL) | 1225 BIT(DRM_MODE_TV_MODE_PAL_N) | 1226 BIT(DRM_MODE_TV_MODE_SECAM); 1227 unsigned int tv_modes[2] = { UINT_MAX, UINT_MAX }; 1228 unsigned int i, supported_tv_modes = 0; 1229 1230 if (!tv_mode_property) 1231 return 0; 1232 1233 for (i = 0; i < tv_mode_property->num_values; i++) 1234 supported_tv_modes |= BIT(tv_mode_property->values[i]); 1235 1236 if ((supported_tv_modes & ntsc_modes) && 1237 (supported_tv_modes & pal_modes)) { 1238 uint64_t default_mode; 1239 1240 if (drm_object_property_get_default_value(&connector->base, 1241 tv_mode_property, 1242 &default_mode)) 1243 return 0; 1244 1245 if (cmdline->tv_mode_specified) 1246 default_mode = cmdline->tv_mode; 1247 1248 if (BIT(default_mode) & ntsc_modes) { 1249 tv_modes[0] = DRM_MODE_TV_MODE_NTSC; 1250 tv_modes[1] = DRM_MODE_TV_MODE_PAL; 1251 } else { 1252 tv_modes[0] = DRM_MODE_TV_MODE_PAL; 1253 tv_modes[1] = DRM_MODE_TV_MODE_NTSC; 1254 } 1255 } else if (supported_tv_modes & ntsc_modes) { 1256 tv_modes[0] = DRM_MODE_TV_MODE_NTSC; 1257 } else if (supported_tv_modes & pal_modes) { 1258 tv_modes[0] = DRM_MODE_TV_MODE_PAL; 1259 } else { 1260 return 0; 1261 } 1262 1263 for (i = 0; i < ARRAY_SIZE(tv_modes); i++) { 1264 struct drm_display_mode *mode; 1265 1266 if (tv_modes[i] == DRM_MODE_TV_MODE_NTSC) 1267 mode = drm_mode_analog_ntsc_480i(dev); 1268 else if (tv_modes[i] == DRM_MODE_TV_MODE_PAL) 1269 mode = drm_mode_analog_pal_576i(dev); 1270 else 1271 break; 1272 if (!mode) 1273 return i; 1274 if (!i) 1275 mode->type |= DRM_MODE_TYPE_PREFERRED; 1276 drm_mode_probed_add(connector, mode); 1277 } 1278 1279 return i; 1280} 1281EXPORT_SYMBOL(drm_connector_helper_tv_get_modes); 1282