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 && dev->mode_config.poll_running) { 778 drm_kms_helper_disable_hpd(dev); 779 dev->mode_config.poll_running = false; 780 goto out; 781 } 782 783 if (!mutex_trylock(&dev->mode_config.mutex)) { 784 repoll = true; 785 goto out; 786 } 787 788 drm_connector_list_iter_begin(dev, &conn_iter); 789 drm_for_each_connector_iter(connector, &conn_iter) { 790 /* Ignore forced connectors. */ 791 if (connector->force) 792 continue; 793 794 /* Ignore HPD capable connectors and connectors where we don't 795 * want any hotplug detection at all for polling. */ 796 if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD) 797 continue; 798 799 old_status = connector->status; 800 /* if we are connected and don't want to poll for disconnect 801 skip it */ 802 if (old_status == connector_status_connected && 803 !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT)) 804 continue; 805 806 repoll = true; 807 808 old_epoch_counter = connector->epoch_counter; 809 connector->status = drm_helper_probe_detect(connector, NULL, false); 810 if (old_epoch_counter != connector->epoch_counter) { 811 const char *old, *new; 812 813 /* 814 * The poll work sets force=false when calling detect so 815 * that drivers can avoid to do disruptive tests (e.g. 816 * when load detect cycles could cause flickering on 817 * other, running displays). This bears the risk that we 818 * flip-flop between unknown here in the poll work and 819 * the real state when userspace forces a full detect 820 * call after receiving a hotplug event due to this 821 * change. 822 * 823 * Hence clamp an unknown detect status to the old 824 * value. 825 */ 826 if (connector->status == connector_status_unknown) { 827 connector->status = old_status; 828 continue; 829 } 830 831 old = drm_get_connector_status_name(old_status); 832 new = drm_get_connector_status_name(connector->status); 833 834 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] " 835 "status updated from %s to %s\n", 836 connector->base.id, 837 connector->name, 838 old, new); 839 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] epoch counter %llu -> %llu\n", 840 connector->base.id, connector->name, 841 old_epoch_counter, connector->epoch_counter); 842 843 changed = true; 844 } 845 } 846 drm_connector_list_iter_end(&conn_iter); 847 848 mutex_unlock(&dev->mode_config.mutex); 849 850out: 851 if (changed) 852 drm_kms_helper_hotplug_event(dev); 853 854 if (repoll) 855 schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD); 856} 857 858/** 859 * drm_kms_helper_is_poll_worker - is %current task an output poll worker? 860 * 861 * Determine if %current task is an output poll worker. This can be used 862 * to select distinct code paths for output polling versus other contexts. 863 * 864 * One use case is to avoid a deadlock between the output poll worker and 865 * the autosuspend worker wherein the latter waits for polling to finish 866 * upon calling drm_kms_helper_poll_disable(), while the former waits for 867 * runtime suspend to finish upon calling pm_runtime_get_sync() in a 868 * connector ->detect hook. 869 */ 870bool drm_kms_helper_is_poll_worker(void) 871{ 872 return false; 873#ifdef __linux__ 874 struct work_struct *work = current_work(); 875 876 return work && work->func == output_poll_execute; 877#endif 878} 879EXPORT_SYMBOL(drm_kms_helper_is_poll_worker); 880 881/** 882 * drm_kms_helper_poll_disable - disable output polling 883 * @dev: drm_device 884 * 885 * This function disables the output polling work. 886 * 887 * Drivers can call this helper from their device suspend implementation. It is 888 * not an error to call this even when output polling isn't enabled or already 889 * disabled. Polling is re-enabled by calling drm_kms_helper_poll_enable(). 890 * 891 * If however, the polling was never initialized, this call will trigger a 892 * warning and return 893 * 894 * Note that calls to enable and disable polling must be strictly ordered, which 895 * is automatically the case when they're only call from suspend/resume 896 * callbacks. 897 */ 898void drm_kms_helper_poll_disable(struct drm_device *dev) 899{ 900 if (drm_WARN_ON(dev, !dev->mode_config.poll_enabled)) 901 return; 902 903 if (dev->mode_config.poll_running) 904 drm_kms_helper_disable_hpd(dev); 905 906 cancel_delayed_work_sync(&dev->mode_config.output_poll_work); 907 908 dev->mode_config.poll_running = false; 909} 910EXPORT_SYMBOL(drm_kms_helper_poll_disable); 911 912/** 913 * drm_kms_helper_poll_init - initialize and enable output polling 914 * @dev: drm_device 915 * 916 * This function initializes and then also enables output polling support for 917 * @dev. Drivers which do not have reliable hotplug support in hardware can use 918 * this helper infrastructure to regularly poll such connectors for changes in 919 * their connection state. 920 * 921 * Drivers can control which connectors are polled by setting the 922 * DRM_CONNECTOR_POLL_CONNECT and DRM_CONNECTOR_POLL_DISCONNECT flags. On 923 * connectors where probing live outputs can result in visual distortion drivers 924 * should not set the DRM_CONNECTOR_POLL_DISCONNECT flag to avoid this. 925 * Connectors which have no flag or only DRM_CONNECTOR_POLL_HPD set are 926 * completely ignored by the polling logic. 927 * 928 * Note that a connector can be both polled and probed from the hotplug handler, 929 * in case the hotplug interrupt is known to be unreliable. 930 */ 931void drm_kms_helper_poll_init(struct drm_device *dev) 932{ 933 INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute); 934 dev->mode_config.poll_enabled = true; 935 936 drm_kms_helper_poll_enable(dev); 937} 938EXPORT_SYMBOL(drm_kms_helper_poll_init); 939 940/** 941 * drm_kms_helper_poll_fini - disable output polling and clean it up 942 * @dev: drm_device 943 */ 944void drm_kms_helper_poll_fini(struct drm_device *dev) 945{ 946 if (!dev->mode_config.poll_enabled) 947 return; 948 949 drm_kms_helper_poll_disable(dev); 950 951 dev->mode_config.poll_enabled = false; 952} 953EXPORT_SYMBOL(drm_kms_helper_poll_fini); 954 955static bool check_connector_changed(struct drm_connector *connector) 956{ 957 struct drm_device *dev = connector->dev; 958 enum drm_connector_status old_status; 959 u64 old_epoch_counter; 960 961 /* Only handle HPD capable connectors. */ 962 drm_WARN_ON(dev, !(connector->polled & DRM_CONNECTOR_POLL_HPD)); 963 964 drm_WARN_ON(dev, !mutex_is_locked(&dev->mode_config.mutex)); 965 966 old_status = connector->status; 967 old_epoch_counter = connector->epoch_counter; 968 connector->status = drm_helper_probe_detect(connector, NULL, false); 969 970 if (old_epoch_counter == connector->epoch_counter) { 971 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Same epoch counter %llu\n", 972 connector->base.id, 973 connector->name, 974 connector->epoch_counter); 975 976 return false; 977 } 978 979 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] status updated from %s to %s\n", 980 connector->base.id, 981 connector->name, 982 drm_get_connector_status_name(old_status), 983 drm_get_connector_status_name(connector->status)); 984 985 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Changed epoch counter %llu => %llu\n", 986 connector->base.id, 987 connector->name, 988 old_epoch_counter, 989 connector->epoch_counter); 990 991 return true; 992} 993 994/** 995 * drm_connector_helper_hpd_irq_event - hotplug processing 996 * @connector: drm_connector 997 * 998 * Drivers can use this helper function to run a detect cycle on a connector 999 * which has the DRM_CONNECTOR_POLL_HPD flag set in its &polled member. 1000 * 1001 * This helper function is useful for drivers which can track hotplug 1002 * interrupts for a single connector. Drivers that want to send a 1003 * hotplug event for all connectors or can't track hotplug interrupts 1004 * per connector need to use drm_helper_hpd_irq_event(). 1005 * 1006 * This function must be called from process context with no mode 1007 * setting locks held. 1008 * 1009 * Note that a connector can be both polled and probed from the hotplug 1010 * handler, in case the hotplug interrupt is known to be unreliable. 1011 * 1012 * Returns: 1013 * A boolean indicating whether the connector status changed or not 1014 */ 1015bool drm_connector_helper_hpd_irq_event(struct drm_connector *connector) 1016{ 1017 struct drm_device *dev = connector->dev; 1018 bool changed; 1019 1020 mutex_lock(&dev->mode_config.mutex); 1021 changed = check_connector_changed(connector); 1022 mutex_unlock(&dev->mode_config.mutex); 1023 1024 if (changed) { 1025 drm_kms_helper_connector_hotplug_event(connector); 1026 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Sent hotplug event\n", 1027 connector->base.id, 1028 connector->name); 1029 } 1030 1031 return changed; 1032} 1033EXPORT_SYMBOL(drm_connector_helper_hpd_irq_event); 1034 1035/** 1036 * drm_helper_hpd_irq_event - hotplug processing 1037 * @dev: drm_device 1038 * 1039 * Drivers can use this helper function to run a detect cycle on all connectors 1040 * which have the DRM_CONNECTOR_POLL_HPD flag set in their &polled member. All 1041 * other connectors are ignored, which is useful to avoid reprobing fixed 1042 * panels. 1043 * 1044 * This helper function is useful for drivers which can't or don't track hotplug 1045 * interrupts for each connector. 1046 * 1047 * Drivers which support hotplug interrupts for each connector individually and 1048 * which have a more fine-grained detect logic can use 1049 * drm_connector_helper_hpd_irq_event(). Alternatively, they should bypass this 1050 * code and directly call drm_kms_helper_hotplug_event() in case the connector 1051 * state changed. 1052 * 1053 * This function must be called from process context with no mode 1054 * setting locks held. 1055 * 1056 * Note that a connector can be both polled and probed from the hotplug handler, 1057 * in case the hotplug interrupt is known to be unreliable. 1058 * 1059 * Returns: 1060 * A boolean indicating whether the connector status changed or not 1061 */ 1062bool drm_helper_hpd_irq_event(struct drm_device *dev) 1063{ 1064 struct drm_connector *connector, *first_changed_connector = NULL; 1065 struct drm_connector_list_iter conn_iter; 1066 int changed = 0; 1067 1068 if (!dev->mode_config.poll_enabled) 1069 return false; 1070 1071 mutex_lock(&dev->mode_config.mutex); 1072 drm_connector_list_iter_begin(dev, &conn_iter); 1073 drm_for_each_connector_iter(connector, &conn_iter) { 1074 /* Only handle HPD capable connectors. */ 1075 if (!(connector->polled & DRM_CONNECTOR_POLL_HPD)) 1076 continue; 1077 1078 if (check_connector_changed(connector)) { 1079 if (!first_changed_connector) { 1080 drm_connector_get(connector); 1081 first_changed_connector = connector; 1082 } 1083 1084 changed++; 1085 } 1086 } 1087 drm_connector_list_iter_end(&conn_iter); 1088 mutex_unlock(&dev->mode_config.mutex); 1089 1090 if (changed == 1) 1091 drm_kms_helper_connector_hotplug_event(first_changed_connector); 1092 else if (changed > 0) 1093 drm_kms_helper_hotplug_event(dev); 1094 1095 if (first_changed_connector) 1096 drm_connector_put(first_changed_connector); 1097 1098 return changed; 1099} 1100EXPORT_SYMBOL(drm_helper_hpd_irq_event); 1101 1102/** 1103 * drm_crtc_helper_mode_valid_fixed - Validates a display mode 1104 * @crtc: the crtc 1105 * @mode: the mode to validate 1106 * @fixed_mode: the display hardware's mode 1107 * 1108 * Returns: 1109 * MODE_OK on success, or another mode-status code otherwise. 1110 */ 1111enum drm_mode_status drm_crtc_helper_mode_valid_fixed(struct drm_crtc *crtc, 1112 const struct drm_display_mode *mode, 1113 const struct drm_display_mode *fixed_mode) 1114{ 1115 if (mode->hdisplay != fixed_mode->hdisplay && mode->vdisplay != fixed_mode->vdisplay) 1116 return MODE_ONE_SIZE; 1117 else if (mode->hdisplay != fixed_mode->hdisplay) 1118 return MODE_ONE_WIDTH; 1119 else if (mode->vdisplay != fixed_mode->vdisplay) 1120 return MODE_ONE_HEIGHT; 1121 1122 return MODE_OK; 1123} 1124EXPORT_SYMBOL(drm_crtc_helper_mode_valid_fixed); 1125 1126/** 1127 * drm_connector_helper_get_modes_from_ddc - Updates the connector's EDID 1128 * property from the connector's 1129 * DDC channel 1130 * @connector: The connector 1131 * 1132 * Returns: 1133 * The number of detected display modes. 1134 * 1135 * Uses a connector's DDC channel to retrieve EDID data and update the 1136 * connector's EDID property and display modes. Drivers can use this 1137 * function to implement struct &drm_connector_helper_funcs.get_modes 1138 * for connectors with a DDC channel. 1139 */ 1140int drm_connector_helper_get_modes_from_ddc(struct drm_connector *connector) 1141{ 1142 struct edid *edid; 1143 int count = 0; 1144 1145 if (!connector->ddc) 1146 return 0; 1147 1148 edid = drm_get_edid(connector, connector->ddc); 1149 1150 // clears property if EDID is NULL 1151 drm_connector_update_edid_property(connector, edid); 1152 1153 if (edid) { 1154 count = drm_add_edid_modes(connector, edid); 1155 kfree(edid); 1156 } 1157 1158 return count; 1159} 1160EXPORT_SYMBOL(drm_connector_helper_get_modes_from_ddc); 1161 1162/** 1163 * drm_connector_helper_get_modes_fixed - Duplicates a display mode for a connector 1164 * @connector: the connector 1165 * @fixed_mode: the display hardware's mode 1166 * 1167 * This function duplicates a display modes for a connector. Drivers for hardware 1168 * that only supports a single fixed mode can use this function in their connector's 1169 * get_modes helper. 1170 * 1171 * Returns: 1172 * The number of created modes. 1173 */ 1174int drm_connector_helper_get_modes_fixed(struct drm_connector *connector, 1175 const struct drm_display_mode *fixed_mode) 1176{ 1177 struct drm_device *dev = connector->dev; 1178 struct drm_display_mode *mode; 1179 1180 mode = drm_mode_duplicate(dev, fixed_mode); 1181 if (!mode) { 1182 drm_err(dev, "Failed to duplicate mode " DRM_MODE_FMT "\n", 1183 DRM_MODE_ARG(fixed_mode)); 1184 return 0; 1185 } 1186 1187 if (mode->name[0] == '\0') 1188 drm_mode_set_name(mode); 1189 1190 mode->type |= DRM_MODE_TYPE_PREFERRED; 1191 drm_mode_probed_add(connector, mode); 1192 1193 if (mode->width_mm) 1194 connector->display_info.width_mm = mode->width_mm; 1195 if (mode->height_mm) 1196 connector->display_info.height_mm = mode->height_mm; 1197 1198 return 1; 1199} 1200EXPORT_SYMBOL(drm_connector_helper_get_modes_fixed); 1201 1202/** 1203 * drm_connector_helper_get_modes - Read EDID and update connector. 1204 * @connector: The connector 1205 * 1206 * Read the EDID using drm_edid_read() (which requires that connector->ddc is 1207 * set), and update the connector using the EDID. 1208 * 1209 * This can be used as the "default" connector helper .get_modes() hook if the 1210 * driver does not need any special processing. This is sets the example what 1211 * custom .get_modes() hooks should do regarding EDID read and connector update. 1212 * 1213 * Returns: Number of modes. 1214 */ 1215int drm_connector_helper_get_modes(struct drm_connector *connector) 1216{ 1217 const struct drm_edid *drm_edid; 1218 int count; 1219 1220 drm_edid = drm_edid_read(connector); 1221 1222 /* 1223 * Unconditionally update the connector. If the EDID was read 1224 * successfully, fill in the connector information derived from the 1225 * EDID. Otherwise, if the EDID is NULL, clear the connector 1226 * information. 1227 */ 1228 drm_edid_connector_update(connector, drm_edid); 1229 1230 count = drm_edid_connector_add_modes(connector); 1231 1232 drm_edid_free(drm_edid); 1233 1234 return count; 1235} 1236EXPORT_SYMBOL(drm_connector_helper_get_modes); 1237 1238/** 1239 * drm_connector_helper_tv_get_modes - Fills the modes availables to a TV connector 1240 * @connector: The connector 1241 * 1242 * Fills the available modes for a TV connector based on the supported 1243 * TV modes, and the default mode expressed by the kernel command line. 1244 * 1245 * This can be used as the default TV connector helper .get_modes() hook 1246 * if the driver does not need any special processing. 1247 * 1248 * Returns: 1249 * The number of modes added to the connector. 1250 */ 1251int drm_connector_helper_tv_get_modes(struct drm_connector *connector) 1252{ 1253 struct drm_device *dev = connector->dev; 1254 struct drm_property *tv_mode_property = 1255 dev->mode_config.tv_mode_property; 1256 struct drm_cmdline_mode *cmdline = &connector->cmdline_mode; 1257 unsigned int ntsc_modes = BIT(DRM_MODE_TV_MODE_NTSC) | 1258 BIT(DRM_MODE_TV_MODE_NTSC_443) | 1259 BIT(DRM_MODE_TV_MODE_NTSC_J) | 1260 BIT(DRM_MODE_TV_MODE_PAL_M); 1261 unsigned int pal_modes = BIT(DRM_MODE_TV_MODE_PAL) | 1262 BIT(DRM_MODE_TV_MODE_PAL_N) | 1263 BIT(DRM_MODE_TV_MODE_SECAM); 1264 unsigned int tv_modes[2] = { UINT_MAX, UINT_MAX }; 1265 unsigned int i, supported_tv_modes = 0; 1266 1267 if (!tv_mode_property) 1268 return 0; 1269 1270 for (i = 0; i < tv_mode_property->num_values; i++) 1271 supported_tv_modes |= BIT(tv_mode_property->values[i]); 1272 1273 if ((supported_tv_modes & ntsc_modes) && 1274 (supported_tv_modes & pal_modes)) { 1275 uint64_t default_mode; 1276 1277 if (drm_object_property_get_default_value(&connector->base, 1278 tv_mode_property, 1279 &default_mode)) 1280 return 0; 1281 1282 if (cmdline->tv_mode_specified) 1283 default_mode = cmdline->tv_mode; 1284 1285 if (BIT(default_mode) & ntsc_modes) { 1286 tv_modes[0] = DRM_MODE_TV_MODE_NTSC; 1287 tv_modes[1] = DRM_MODE_TV_MODE_PAL; 1288 } else { 1289 tv_modes[0] = DRM_MODE_TV_MODE_PAL; 1290 tv_modes[1] = DRM_MODE_TV_MODE_NTSC; 1291 } 1292 } else if (supported_tv_modes & ntsc_modes) { 1293 tv_modes[0] = DRM_MODE_TV_MODE_NTSC; 1294 } else if (supported_tv_modes & pal_modes) { 1295 tv_modes[0] = DRM_MODE_TV_MODE_PAL; 1296 } else { 1297 return 0; 1298 } 1299 1300 for (i = 0; i < ARRAY_SIZE(tv_modes); i++) { 1301 struct drm_display_mode *mode; 1302 1303 if (tv_modes[i] == DRM_MODE_TV_MODE_NTSC) 1304 mode = drm_mode_analog_ntsc_480i(dev); 1305 else if (tv_modes[i] == DRM_MODE_TV_MODE_PAL) 1306 mode = drm_mode_analog_pal_576i(dev); 1307 else 1308 break; 1309 if (!mode) 1310 return i; 1311 if (!i) 1312 mode->type |= DRM_MODE_TYPE_PREFERRED; 1313 drm_mode_probed_add(connector, mode); 1314 } 1315 1316 return i; 1317} 1318EXPORT_SYMBOL(drm_connector_helper_tv_get_modes); 1319