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/drmP.h> 36 #include <drm/drm_crtc.h> 37 #include <uapi_drm/drm_fourcc.h> 38 #include <drm/drm_crtc_helper.h> 39 #include <drm/drm_fb_helper.h> 40 #include <drm/drm_edid.h> 41 42 /** 43 * DOC: output probing helper overview 44 * 45 * This library provides some helper code for output probing. It provides an 46 * implementation of the core connector->fill_modes interface with 47 * drm_helper_probe_single_connector_modes. 48 * 49 * It also provides support for polling connectors with a work item and for 50 * generic hotplug interrupt handling where the driver doesn't or cannot keep 51 * track of a per-connector hpd interrupt. 52 * 53 * This helper library can be used independently of the modeset helper library. 54 * Drivers can also overwrite different parts e.g. use their own hotplug 55 * handling code to avoid probing unrelated outputs. 56 * 57 * The probe helpers share the function table structures with other display 58 * helper libraries. See struct &drm_connector_helper_funcs for the details. 59 */ 60 61 static bool drm_kms_helper_poll = true; 62 module_param_named(poll, drm_kms_helper_poll, bool, 0600); 63 64 static enum drm_mode_status 65 drm_mode_validate_flag(const struct drm_display_mode *mode, 66 int flags) 67 { 68 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) && 69 !(flags & DRM_MODE_FLAG_INTERLACE)) 70 return MODE_NO_INTERLACE; 71 72 if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) && 73 !(flags & DRM_MODE_FLAG_DBLSCAN)) 74 return MODE_NO_DBLESCAN; 75 76 if ((mode->flags & DRM_MODE_FLAG_3D_MASK) && 77 !(flags & DRM_MODE_FLAG_3D_MASK)) 78 return MODE_NO_STEREO; 79 80 return MODE_OK; 81 } 82 83 static int drm_helper_probe_add_cmdline_mode(struct drm_connector *connector) 84 { 85 struct drm_display_mode *mode; 86 87 if (!connector->cmdline_mode.specified) 88 return 0; 89 90 mode = drm_mode_create_from_cmdline_mode(connector->dev, 91 &connector->cmdline_mode); 92 if (mode == NULL) 93 return 0; 94 95 drm_mode_probed_add(connector, mode); 96 return 1; 97 } 98 99 #define DRM_OUTPUT_POLL_PERIOD (10*HZ) 100 /** 101 * drm_kms_helper_poll_enable_locked - re-enable output polling. 102 * @dev: drm_device 103 * 104 * This function re-enables the output polling work without 105 * locking the mode_config mutex. 106 * 107 * This is like drm_kms_helper_poll_enable() however it is to be 108 * called from a context where the mode_config mutex is locked 109 * already. 110 */ 111 void drm_kms_helper_poll_enable_locked(struct drm_device *dev) 112 { 113 bool poll = false; 114 struct drm_connector *connector; 115 116 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex)); 117 118 if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll) 119 return; 120 121 drm_for_each_connector(connector, dev) { 122 if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT | 123 DRM_CONNECTOR_POLL_DISCONNECT)) 124 poll = true; 125 } 126 127 if (poll) 128 schedule_delayed_work(&dev->mode_config.output_poll_work, DRM_OUTPUT_POLL_PERIOD); 129 } 130 EXPORT_SYMBOL(drm_kms_helper_poll_enable_locked); 131 132 /** 133 * drm_helper_probe_single_connector_modes - get complete set of display modes 134 * @connector: connector to probe 135 * @maxX: max width for modes 136 * @maxY: max height for modes 137 * 138 * Based on the helper callbacks implemented by @connector in struct 139 * &drm_connector_helper_funcs try to detect all valid modes. Modes will first 140 * be added to the connector's probed_modes list, then culled (based on validity 141 * and the @maxX, @maxY parameters) and put into the normal modes list. 142 * 143 * Intended to be used as a generic implementation of the ->fill_modes() 144 * @connector vfunc for drivers that use the CRTC helpers for output mode 145 * filtering and detection. 146 * 147 * The basic procedure is as follows 148 * 149 * 1. All modes currently on the connector's modes list are marked as stale 150 * 151 * 2. New modes are added to the connector's probed_modes list with 152 * drm_mode_probed_add(). New modes start their life with status as OK. 153 * Modes are added from a single source using the following priority order. 154 * 155 * - debugfs 'override_edid' (used for testing only) 156 * - firmware EDID (drm_load_edid_firmware()) 157 * - connector helper ->get_modes() vfunc 158 * - if the connector status is connector_status_connected, standard 159 * VESA DMT modes up to 1024x768 are automatically added 160 * (drm_add_modes_noedid()) 161 * 162 * Finally modes specified via the kernel command line (video=...) are 163 * added in addition to what the earlier probes produced 164 * (drm_helper_probe_add_cmdline_mode()). These modes are generated 165 * using the VESA GTF/CVT formulas. 166 * 167 * 3. Modes are moved from the probed_modes list to the modes list. Potential 168 * duplicates are merged together (see drm_mode_connector_list_update()). 169 * After this step the probed_modes list will be empty again. 170 * 171 * 4. Any non-stale mode on the modes list then undergoes validation 172 * 173 * - drm_mode_validate_basic() performs basic sanity checks 174 * - drm_mode_validate_size() filters out modes larger than @maxX and @maxY 175 * (if specified) 176 * - drm_mode_validate_flag() checks the modes againt basic connector 177 * capabilites (interlace_allowed,doublescan_allowed,stereo_allowed) 178 * - the optional connector ->mode_valid() helper can perform driver and/or 179 * hardware specific checks 180 * 181 * 5. Any mode whose status is not OK is pruned from the connector's modes list, 182 * accompanied by a debug message indicating the reason for the mode's 183 * rejection (see drm_mode_prune_invalid()). 184 * 185 * Returns: 186 * The number of modes found on @connector. 187 */ 188 int drm_helper_probe_single_connector_modes(struct drm_connector *connector, 189 uint32_t maxX, uint32_t maxY) 190 { 191 struct drm_device *dev = connector->dev; 192 struct drm_display_mode *mode; 193 const struct drm_connector_helper_funcs *connector_funcs = 194 connector->helper_private; 195 int count = 0; 196 int mode_flags = 0; 197 bool verbose_prune = true; 198 enum drm_connector_status old_status; 199 200 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex)); 201 202 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id, 203 connector->name); 204 /* set all old modes to the stale state */ 205 list_for_each_entry(mode, &connector->modes, head) 206 mode->status = MODE_STALE; 207 208 old_status = connector->status; 209 210 if (connector->force) { 211 if (connector->force == DRM_FORCE_ON || 212 connector->force == DRM_FORCE_ON_DIGITAL) 213 connector->status = connector_status_connected; 214 else 215 connector->status = connector_status_disconnected; 216 if (connector->funcs->force) 217 connector->funcs->force(connector); 218 } else { 219 connector->status = connector->funcs->detect(connector, true); 220 } 221 222 /* 223 * Normally either the driver's hpd code or the poll loop should 224 * pick up any changes and fire the hotplug event. But if 225 * userspace sneaks in a probe, we might miss a change. Hence 226 * check here, and if anything changed start the hotplug code. 227 */ 228 if (old_status != connector->status) { 229 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n", 230 connector->base.id, 231 connector->name, 232 drm_get_connector_status_name(old_status), 233 drm_get_connector_status_name(connector->status)); 234 235 /* 236 * The hotplug event code might call into the fb 237 * helpers, and so expects that we do not hold any 238 * locks. Fire up the poll struct instead, it will 239 * disable itself again. 240 */ 241 dev->mode_config.delayed_event = true; 242 if (dev->mode_config.poll_enabled) 243 schedule_delayed_work(&dev->mode_config.output_poll_work, 244 0); 245 } 246 247 /* Re-enable polling in case the global poll config changed. */ 248 if (drm_kms_helper_poll != dev->mode_config.poll_running) 249 drm_kms_helper_poll_enable_locked(dev); 250 251 dev->mode_config.poll_running = drm_kms_helper_poll; 252 253 if (connector->status == connector_status_disconnected) { 254 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n", 255 connector->base.id, connector->name); 256 drm_mode_connector_update_edid_property(connector, NULL); 257 verbose_prune = false; 258 goto prune; 259 } 260 261 if (connector->override_edid) { 262 struct edid *edid = (struct edid *) connector->edid_blob_ptr->data; 263 264 count = drm_add_edid_modes(connector, edid); 265 drm_edid_to_eld(connector, edid); 266 } else { 267 #ifdef CONFIG_DRM_LOAD_EDID_FIRMWARE 268 count = drm_load_edid_firmware(connector); 269 if (count == 0) 270 #endif 271 count = (*connector_funcs->get_modes)(connector); 272 } 273 274 if (count == 0 && connector->status == connector_status_connected) 275 count = drm_add_modes_noedid(connector, 1024, 768); 276 count += drm_helper_probe_add_cmdline_mode(connector); 277 if (count == 0) 278 goto prune; 279 280 drm_mode_connector_list_update(connector); 281 282 if (connector->interlace_allowed) 283 mode_flags |= DRM_MODE_FLAG_INTERLACE; 284 if (connector->doublescan_allowed) 285 mode_flags |= DRM_MODE_FLAG_DBLSCAN; 286 if (connector->stereo_allowed) 287 mode_flags |= DRM_MODE_FLAG_3D_MASK; 288 289 list_for_each_entry(mode, &connector->modes, head) { 290 if (mode->status == MODE_OK) 291 mode->status = drm_mode_validate_basic(mode); 292 293 if (mode->status == MODE_OK) 294 mode->status = drm_mode_validate_size(mode, maxX, maxY); 295 296 if (mode->status == MODE_OK) 297 mode->status = drm_mode_validate_flag(mode, mode_flags); 298 299 if (mode->status == MODE_OK && connector_funcs->mode_valid) 300 mode->status = connector_funcs->mode_valid(connector, 301 mode); 302 } 303 304 prune: 305 drm_mode_prune_invalid(dev, &connector->modes, verbose_prune); 306 307 if (list_empty(&connector->modes)) 308 return 0; 309 310 list_for_each_entry(mode, &connector->modes, head) 311 mode->vrefresh = drm_mode_vrefresh(mode); 312 313 drm_mode_sort(&connector->modes); 314 315 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id, 316 connector->name); 317 list_for_each_entry(mode, &connector->modes, head) { 318 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V); 319 drm_mode_debug_printmodeline(mode); 320 } 321 322 return count; 323 } 324 EXPORT_SYMBOL(drm_helper_probe_single_connector_modes); 325 326 /** 327 * drm_kms_helper_hotplug_event - fire off KMS hotplug events 328 * @dev: drm_device whose connector state changed 329 * 330 * This function fires off the uevent for userspace and also calls the 331 * output_poll_changed function, which is most commonly used to inform the fbdev 332 * emulation code and allow it to update the fbcon output configuration. 333 * 334 * Drivers should call this from their hotplug handling code when a change is 335 * detected. Note that this function does not do any output detection of its 336 * own, like drm_helper_hpd_irq_event() does - this is assumed to be done by the 337 * driver already. 338 * 339 * This function must be called from process context with no mode 340 * setting locks held. 341 */ 342 void drm_kms_helper_hotplug_event(struct drm_device *dev) 343 { 344 /* send a uevent + call fbdev */ 345 drm_sysfs_hotplug_event(dev); 346 if (dev->mode_config.funcs->output_poll_changed) 347 dev->mode_config.funcs->output_poll_changed(dev); 348 } 349 EXPORT_SYMBOL(drm_kms_helper_hotplug_event); 350 351 static void output_poll_execute(struct work_struct *work) 352 { 353 struct delayed_work *delayed_work = to_delayed_work(work); 354 struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work); 355 struct drm_connector *connector; 356 enum drm_connector_status old_status; 357 bool repoll = false, changed = false; 358 359 if (!drm_kms_helper_poll) 360 return; 361 362 mutex_lock(&dev->mode_config.mutex); 363 drm_for_each_connector(connector, dev) { 364 365 /* Ignore forced connectors. */ 366 if (connector->force) 367 continue; 368 369 /* Ignore HPD capable connectors and connectors where we don't 370 * want any hotplug detection at all for polling. */ 371 if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD) 372 continue; 373 374 old_status = connector->status; 375 /* if we are connected and don't want to poll for disconnect 376 skip it */ 377 if (old_status == connector_status_connected && 378 !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT)) 379 continue; 380 381 repoll = true; 382 383 connector->status = connector->funcs->detect(connector, false); 384 if (old_status != connector->status) { 385 const char *old, *new; 386 387 old = drm_get_connector_status_name(old_status); 388 new = drm_get_connector_status_name(connector->status); 389 390 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] " 391 "status updated from %s to %s\n", 392 connector->base.id, 393 connector->name, 394 old, new); 395 396 changed = true; 397 } 398 } 399 400 mutex_unlock(&dev->mode_config.mutex); 401 402 if (changed) 403 drm_kms_helper_hotplug_event(dev); 404 405 if (repoll) 406 schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD); 407 } 408 409 /** 410 * drm_kms_helper_poll_disable - disable output polling 411 * @dev: drm_device 412 * 413 * This function disables the output polling work. 414 * 415 * Drivers can call this helper from their device suspend implementation. It is 416 * not an error to call this even when output polling isn't enabled or arlready 417 * disabled. 418 */ 419 void drm_kms_helper_poll_disable(struct drm_device *dev) 420 { 421 if (!dev->mode_config.poll_enabled) 422 return; 423 cancel_delayed_work_sync(&dev->mode_config.output_poll_work); 424 } 425 EXPORT_SYMBOL(drm_kms_helper_poll_disable); 426 427 /** 428 * drm_kms_helper_poll_enable - re-enable output polling. 429 * @dev: drm_device 430 * 431 * This function re-enables the output polling work. 432 * 433 * Drivers can call this helper from their device resume implementation. It is 434 * an error to call this when the output polling support has not yet been set 435 * up. 436 */ 437 void drm_kms_helper_poll_enable(struct drm_device *dev) 438 { 439 mutex_lock(&dev->mode_config.mutex); 440 drm_kms_helper_poll_enable_locked(dev); 441 mutex_unlock(&dev->mode_config.mutex); 442 } 443 EXPORT_SYMBOL(drm_kms_helper_poll_enable); 444 445 /** 446 * drm_kms_helper_poll_init - initialize and enable output polling 447 * @dev: drm_device 448 * 449 * This function intializes and then also enables output polling support for 450 * @dev. Drivers which do not have reliable hotplug support in hardware can use 451 * this helper infrastructure to regularly poll such connectors for changes in 452 * their connection state. 453 * 454 * Drivers can control which connectors are polled by setting the 455 * DRM_CONNECTOR_POLL_CONNECT and DRM_CONNECTOR_POLL_DISCONNECT flags. On 456 * connectors where probing live outputs can result in visual distortion drivers 457 * should not set the DRM_CONNECTOR_POLL_DISCONNECT flag to avoid this. 458 * Connectors which have no flag or only DRM_CONNECTOR_POLL_HPD set are 459 * completely ignored by the polling logic. 460 * 461 * Note that a connector can be both polled and probed from the hotplug handler, 462 * in case the hotplug interrupt is known to be unreliable. 463 */ 464 void drm_kms_helper_poll_init(struct drm_device *dev) 465 { 466 INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute); 467 dev->mode_config.poll_enabled = true; 468 469 drm_kms_helper_poll_enable(dev); 470 } 471 EXPORT_SYMBOL(drm_kms_helper_poll_init); 472 473 /** 474 * drm_kms_helper_poll_fini - disable output polling and clean it up 475 * @dev: drm_device 476 */ 477 void drm_kms_helper_poll_fini(struct drm_device *dev) 478 { 479 drm_kms_helper_poll_disable(dev); 480 } 481 EXPORT_SYMBOL(drm_kms_helper_poll_fini); 482 483 /** 484 * drm_helper_hpd_irq_event - hotplug processing 485 * @dev: drm_device 486 * 487 * Drivers can use this helper function to run a detect cycle on all connectors 488 * which have the DRM_CONNECTOR_POLL_HPD flag set in their &polled member. All 489 * other connectors are ignored, which is useful to avoid reprobing fixed 490 * panels. 491 * 492 * This helper function is useful for drivers which can't or don't track hotplug 493 * interrupts for each connector. 494 * 495 * Drivers which support hotplug interrupts for each connector individually and 496 * which have a more fine-grained detect logic should bypass this code and 497 * directly call drm_kms_helper_hotplug_event() in case the connector state 498 * changed. 499 * 500 * This function must be called from process context with no mode 501 * setting locks held. 502 * 503 * Note that a connector can be both polled and probed from the hotplug handler, 504 * in case the hotplug interrupt is known to be unreliable. 505 */ 506 bool drm_helper_hpd_irq_event(struct drm_device *dev) 507 { 508 struct drm_connector *connector; 509 enum drm_connector_status old_status; 510 bool changed = false; 511 512 if (!dev->mode_config.poll_enabled) 513 return false; 514 515 mutex_lock(&dev->mode_config.mutex); 516 drm_for_each_connector(connector, dev) { 517 518 /* Only handle HPD capable connectors. */ 519 if (!(connector->polled & DRM_CONNECTOR_POLL_HPD)) 520 continue; 521 522 old_status = connector->status; 523 524 connector->status = connector->funcs->detect(connector, false); 525 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n", 526 connector->base.id, 527 connector->name, 528 drm_get_connector_status_name(old_status), 529 drm_get_connector_status_name(connector->status)); 530 if (old_status != connector->status) 531 changed = true; 532 } 533 534 mutex_unlock(&dev->mode_config.mutex); 535 536 if (changed) 537 drm_kms_helper_hotplug_event(dev); 538 539 return changed; 540 } 541 EXPORT_SYMBOL(drm_helper_hpd_irq_event); 542