1/* 2 * Copyright © 2015 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 */ 23 24#include <linux/kernel.h> 25 26#include "i915_drv.h" 27#include "intel_display_types.h" 28#include "intel_hotplug.h" 29 30/** 31 * DOC: Hotplug 32 * 33 * Simply put, hotplug occurs when a display is connected to or disconnected 34 * from the system. However, there may be adapters and docking stations and 35 * Display Port short pulses and MST devices involved, complicating matters. 36 * 37 * Hotplug in i915 is handled in many different levels of abstraction. 38 * 39 * The platform dependent interrupt handling code in i915_irq.c enables, 40 * disables, and does preliminary handling of the interrupts. The interrupt 41 * handlers gather the hotplug detect (HPD) information from relevant registers 42 * into a platform independent mask of hotplug pins that have fired. 43 * 44 * The platform independent interrupt handler intel_hpd_irq_handler() in 45 * intel_hotplug.c does hotplug irq storm detection and mitigation, and passes 46 * further processing to appropriate bottom halves (Display Port specific and 47 * regular hotplug). 48 * 49 * The Display Port work function i915_digport_work_func() calls into 50 * intel_dp_hpd_pulse() via hooks, which handles DP short pulses and DP MST long 51 * pulses, with failures and non-MST long pulses triggering regular hotplug 52 * processing on the connector. 53 * 54 * The regular hotplug work function i915_hotplug_work_func() calls connector 55 * detect hooks, and, if connector status changes, triggers sending of hotplug 56 * uevent to userspace via drm_kms_helper_hotplug_event(). 57 * 58 * Finally, the userspace is responsible for triggering a modeset upon receiving 59 * the hotplug uevent, disabling or enabling the crtc as needed. 60 * 61 * The hotplug interrupt storm detection and mitigation code keeps track of the 62 * number of interrupts per hotplug pin per a period of time, and if the number 63 * of interrupts exceeds a certain threshold, the interrupt is disabled for a 64 * while before being re-enabled. The intention is to mitigate issues raising 65 * from broken hardware triggering massive amounts of interrupts and grinding 66 * the system to a halt. 67 * 68 * Current implementation expects that hotplug interrupt storm will not be 69 * seen when display port sink is connected, hence on platforms whose DP 70 * callback is handled by i915_digport_work_func reenabling of hpd is not 71 * performed (it was never expected to be disabled in the first place ;) ) 72 * this is specific to DP sinks handled by this routine and any other display 73 * such as HDMI or DVI enabled on the same port will have proper logic since 74 * it will use i915_hotplug_work_func where this logic is handled. 75 */ 76 77/** 78 * intel_hpd_pin_default - return default pin associated with certain port. 79 * @dev_priv: private driver data pointer 80 * @port: the hpd port to get associated pin 81 * 82 * It is only valid and used by digital port encoder. 83 * 84 * Return pin that is associatade with @port. 85 */ 86enum hpd_pin intel_hpd_pin_default(struct drm_i915_private *dev_priv, 87 enum port port) 88{ 89 return HPD_PORT_A + port - PORT_A; 90} 91 92#define HPD_STORM_DETECT_PERIOD 1000 93#define HPD_STORM_REENABLE_DELAY (2 * 60 * 1000) 94#define HPD_RETRY_DELAY 1000 95 96static enum hpd_pin 97intel_connector_hpd_pin(struct intel_connector *connector) 98{ 99 struct intel_encoder *encoder = intel_attached_encoder(connector); 100 101 /* 102 * MST connectors get their encoder attached dynamically 103 * so need to make sure we have an encoder here. But since 104 * MST encoders have their hpd_pin set to HPD_NONE we don't 105 * have to special case them beyond that. 106 */ 107 return encoder ? encoder->hpd_pin : HPD_NONE; 108} 109 110/** 111 * intel_hpd_irq_storm_detect - gather stats and detect HPD IRQ storm on a pin 112 * @dev_priv: private driver data pointer 113 * @pin: the pin to gather stats on 114 * @long_hpd: whether the HPD IRQ was long or short 115 * 116 * Gather stats about HPD IRQs from the specified @pin, and detect IRQ 117 * storms. Only the pin specific stats and state are changed, the caller is 118 * responsible for further action. 119 * 120 * The number of IRQs that are allowed within @HPD_STORM_DETECT_PERIOD is 121 * stored in @dev_priv->hotplug.hpd_storm_threshold which defaults to 122 * @HPD_STORM_DEFAULT_THRESHOLD. Long IRQs count as +10 to this threshold, and 123 * short IRQs count as +1. If this threshold is exceeded, it's considered an 124 * IRQ storm and the IRQ state is set to @HPD_MARK_DISABLED. 125 * 126 * By default, most systems will only count long IRQs towards 127 * &dev_priv->hotplug.hpd_storm_threshold. However, some older systems also 128 * suffer from short IRQ storms and must also track these. Because short IRQ 129 * storms are naturally caused by sideband interactions with DP MST devices, 130 * short IRQ detection is only enabled for systems without DP MST support. 131 * Systems which are new enough to support DP MST are far less likely to 132 * suffer from IRQ storms at all, so this is fine. 133 * 134 * The HPD threshold can be controlled through i915_hpd_storm_ctl in debugfs, 135 * and should only be adjusted for automated hotplug testing. 136 * 137 * Return true if an IRQ storm was detected on @pin. 138 */ 139static bool intel_hpd_irq_storm_detect(struct drm_i915_private *dev_priv, 140 enum hpd_pin pin, bool long_hpd) 141{ 142 struct i915_hotplug *hpd = &dev_priv->hotplug; 143 unsigned long start = hpd->stats[pin].last_jiffies; 144 unsigned long end = start + msecs_to_jiffies(HPD_STORM_DETECT_PERIOD); 145 const int increment = long_hpd ? 10 : 1; 146 const int threshold = hpd->hpd_storm_threshold; 147 bool storm = false; 148 149 if (!threshold || 150 (!long_hpd && !dev_priv->hotplug.hpd_short_storm_enabled)) 151 return false; 152 153 if (!time_in_range(jiffies, start, end)) { 154 hpd->stats[pin].last_jiffies = jiffies; 155 hpd->stats[pin].count = 0; 156 } 157 158 hpd->stats[pin].count += increment; 159 if (hpd->stats[pin].count > threshold) { 160 hpd->stats[pin].state = HPD_MARK_DISABLED; 161 drm_dbg_kms(&dev_priv->drm, 162 "HPD interrupt storm detected on PIN %d\n", pin); 163 storm = true; 164 } else { 165 drm_dbg_kms(&dev_priv->drm, 166 "Received HPD interrupt on PIN %d - cnt: %d\n", 167 pin, 168 hpd->stats[pin].count); 169 } 170 171 return storm; 172} 173 174static void 175intel_hpd_irq_storm_switch_to_polling(struct drm_i915_private *dev_priv) 176{ 177 struct drm_device *dev = &dev_priv->drm; 178 struct drm_connector_list_iter conn_iter; 179 struct intel_connector *connector; 180 bool hpd_disabled = false; 181 182 lockdep_assert_held(&dev_priv->irq_lock); 183 184 drm_connector_list_iter_begin(dev, &conn_iter); 185 for_each_intel_connector_iter(connector, &conn_iter) { 186 enum hpd_pin pin; 187 188 if (connector->base.polled != DRM_CONNECTOR_POLL_HPD) 189 continue; 190 191 pin = intel_connector_hpd_pin(connector); 192 if (pin == HPD_NONE || 193 dev_priv->hotplug.stats[pin].state != HPD_MARK_DISABLED) 194 continue; 195 196 drm_info(&dev_priv->drm, 197 "HPD interrupt storm detected on connector %s: " 198 "switching from hotplug detection to polling\n", 199 connector->base.name); 200 201 dev_priv->hotplug.stats[pin].state = HPD_DISABLED; 202 connector->base.polled = DRM_CONNECTOR_POLL_CONNECT | 203 DRM_CONNECTOR_POLL_DISCONNECT; 204 hpd_disabled = true; 205 } 206 drm_connector_list_iter_end(&conn_iter); 207 208 /* Enable polling and queue hotplug re-enabling. */ 209 if (hpd_disabled) { 210 drm_kms_helper_poll_enable(dev); 211 mod_delayed_work(system_wq, &dev_priv->hotplug.reenable_work, 212 msecs_to_jiffies(HPD_STORM_REENABLE_DELAY)); 213 } 214} 215 216static void intel_hpd_irq_storm_reenable_work(struct work_struct *work) 217{ 218 struct drm_i915_private *dev_priv = 219 container_of(work, typeof(*dev_priv), 220 hotplug.reenable_work.work); 221 struct drm_device *dev = &dev_priv->drm; 222 struct drm_connector_list_iter conn_iter; 223 struct intel_connector *connector; 224 intel_wakeref_t wakeref; 225 enum hpd_pin pin; 226 227 wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm); 228 229 spin_lock_irq(&dev_priv->irq_lock); 230 231 drm_connector_list_iter_begin(dev, &conn_iter); 232 for_each_intel_connector_iter(connector, &conn_iter) { 233 pin = intel_connector_hpd_pin(connector); 234 if (pin == HPD_NONE || 235 dev_priv->hotplug.stats[pin].state != HPD_DISABLED) 236 continue; 237 238 if (connector->base.polled != connector->polled) 239 drm_dbg(&dev_priv->drm, 240 "Reenabling HPD on connector %s\n", 241 connector->base.name); 242 connector->base.polled = connector->polled; 243 } 244 drm_connector_list_iter_end(&conn_iter); 245 246 for_each_hpd_pin(pin) { 247 if (dev_priv->hotplug.stats[pin].state == HPD_DISABLED) 248 dev_priv->hotplug.stats[pin].state = HPD_ENABLED; 249 } 250 251 if (dev_priv->display_irqs_enabled && dev_priv->display.hpd_irq_setup) 252 dev_priv->display.hpd_irq_setup(dev_priv); 253 254 spin_unlock_irq(&dev_priv->irq_lock); 255 256 intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref); 257} 258 259enum intel_hotplug_state 260intel_encoder_hotplug(struct intel_encoder *encoder, 261 struct intel_connector *connector) 262{ 263 struct drm_device *dev = connector->base.dev; 264 enum drm_connector_status old_status; 265 u64 old_epoch_counter; 266 bool ret = false; 267 268 drm_WARN_ON(dev, !mutex_is_locked(&dev->mode_config.mutex)); 269 old_status = connector->base.status; 270 old_epoch_counter = connector->base.epoch_counter; 271 272 connector->base.status = 273 drm_helper_probe_detect(&connector->base, NULL, false); 274 275 if (old_epoch_counter != connector->base.epoch_counter) 276 ret = true; 277 278 if (ret) { 279 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s (epoch counter %llu->%llu)\n", 280 connector->base.base.id, 281 connector->base.name, 282 drm_get_connector_status_name(old_status), 283 drm_get_connector_status_name(connector->base.status), 284 old_epoch_counter, 285 connector->base.epoch_counter); 286 return INTEL_HOTPLUG_CHANGED; 287 } 288 return INTEL_HOTPLUG_UNCHANGED; 289} 290 291static bool intel_encoder_has_hpd_pulse(struct intel_encoder *encoder) 292{ 293 return intel_encoder_is_dig_port(encoder) && 294 enc_to_dig_port(encoder)->hpd_pulse != NULL; 295} 296 297static void i915_digport_work_func(struct work_struct *work) 298{ 299 struct drm_i915_private *dev_priv = 300 container_of(work, struct drm_i915_private, hotplug.dig_port_work); 301 u32 long_port_mask, short_port_mask; 302 struct intel_encoder *encoder; 303 u32 old_bits = 0; 304 305 spin_lock_irq(&dev_priv->irq_lock); 306 long_port_mask = dev_priv->hotplug.long_port_mask; 307 dev_priv->hotplug.long_port_mask = 0; 308 short_port_mask = dev_priv->hotplug.short_port_mask; 309 dev_priv->hotplug.short_port_mask = 0; 310 spin_unlock_irq(&dev_priv->irq_lock); 311 312 for_each_intel_encoder(&dev_priv->drm, encoder) { 313 struct intel_digital_port *dig_port; 314 enum port port = encoder->port; 315 bool long_hpd, short_hpd; 316 enum irqreturn ret; 317 318 if (!intel_encoder_has_hpd_pulse(encoder)) 319 continue; 320 321 long_hpd = long_port_mask & BIT(port); 322 short_hpd = short_port_mask & BIT(port); 323 324 if (!long_hpd && !short_hpd) 325 continue; 326 327 dig_port = enc_to_dig_port(encoder); 328 329 ret = dig_port->hpd_pulse(dig_port, long_hpd); 330 if (ret == IRQ_NONE) { 331 /* fall back to old school hpd */ 332 old_bits |= BIT(encoder->hpd_pin); 333 } 334 } 335 336 if (old_bits) { 337 spin_lock_irq(&dev_priv->irq_lock); 338 dev_priv->hotplug.event_bits |= old_bits; 339 spin_unlock_irq(&dev_priv->irq_lock); 340 queue_delayed_work(system_wq, &dev_priv->hotplug.hotplug_work, 0); 341 } 342} 343 344/** 345 * intel_hpd_trigger_irq - trigger an hpd irq event for a port 346 * @dig_port: digital port 347 * 348 * Trigger an HPD interrupt event for the given port, emulating a short pulse 349 * generated by the sink, and schedule the dig port work to handle it. 350 */ 351void intel_hpd_trigger_irq(struct intel_digital_port *dig_port) 352{ 353 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 354 355 spin_lock_irq(&i915->irq_lock); 356 i915->hotplug.short_port_mask |= BIT(dig_port->base.port); 357 spin_unlock_irq(&i915->irq_lock); 358 359 queue_work(i915->hotplug.dp_wq, &i915->hotplug.dig_port_work); 360} 361 362/* 363 * Handle hotplug events outside the interrupt handler proper. 364 */ 365static void i915_hotplug_work_func(struct work_struct *work) 366{ 367 struct drm_i915_private *dev_priv = 368 container_of(work, struct drm_i915_private, 369 hotplug.hotplug_work.work); 370 struct drm_device *dev = &dev_priv->drm; 371 struct drm_connector_list_iter conn_iter; 372 struct intel_connector *connector; 373 u32 changed = 0, retry = 0; 374 u32 hpd_event_bits; 375 u32 hpd_retry_bits; 376 377 mutex_lock(&dev->mode_config.mutex); 378 drm_dbg_kms(&dev_priv->drm, "running encoder hotplug functions\n"); 379 380 spin_lock_irq(&dev_priv->irq_lock); 381 382 hpd_event_bits = dev_priv->hotplug.event_bits; 383 dev_priv->hotplug.event_bits = 0; 384 hpd_retry_bits = dev_priv->hotplug.retry_bits; 385 dev_priv->hotplug.retry_bits = 0; 386 387 /* Enable polling for connectors which had HPD IRQ storms */ 388 intel_hpd_irq_storm_switch_to_polling(dev_priv); 389 390 spin_unlock_irq(&dev_priv->irq_lock); 391 392 drm_connector_list_iter_begin(dev, &conn_iter); 393 for_each_intel_connector_iter(connector, &conn_iter) { 394 enum hpd_pin pin; 395 u32 hpd_bit; 396 397 pin = intel_connector_hpd_pin(connector); 398 if (pin == HPD_NONE) 399 continue; 400 401 hpd_bit = BIT(pin); 402 if ((hpd_event_bits | hpd_retry_bits) & hpd_bit) { 403 struct intel_encoder *encoder = 404 intel_attached_encoder(connector); 405 406 if (hpd_event_bits & hpd_bit) 407 connector->hotplug_retries = 0; 408 else 409 connector->hotplug_retries++; 410 411 drm_dbg_kms(&dev_priv->drm, 412 "Connector %s (pin %i) received hotplug event. (retry %d)\n", 413 connector->base.name, pin, 414 connector->hotplug_retries); 415 416 switch (encoder->hotplug(encoder, connector)) { 417 case INTEL_HOTPLUG_UNCHANGED: 418 break; 419 case INTEL_HOTPLUG_CHANGED: 420 changed |= hpd_bit; 421 break; 422 case INTEL_HOTPLUG_RETRY: 423 retry |= hpd_bit; 424 break; 425 } 426 } 427 } 428 drm_connector_list_iter_end(&conn_iter); 429 mutex_unlock(&dev->mode_config.mutex); 430 431 if (changed) 432 drm_kms_helper_hotplug_event(dev); 433 434 /* Remove shared HPD pins that have changed */ 435 retry &= ~changed; 436 if (retry) { 437 spin_lock_irq(&dev_priv->irq_lock); 438 dev_priv->hotplug.retry_bits |= retry; 439 spin_unlock_irq(&dev_priv->irq_lock); 440 441 mod_delayed_work(system_wq, &dev_priv->hotplug.hotplug_work, 442 msecs_to_jiffies(HPD_RETRY_DELAY)); 443 } 444} 445 446 447/** 448 * intel_hpd_irq_handler - main hotplug irq handler 449 * @dev_priv: drm_i915_private 450 * @pin_mask: a mask of hpd pins that have triggered the irq 451 * @long_mask: a mask of hpd pins that may be long hpd pulses 452 * 453 * This is the main hotplug irq handler for all platforms. The platform specific 454 * irq handlers call the platform specific hotplug irq handlers, which read and 455 * decode the appropriate registers into bitmasks about hpd pins that have 456 * triggered (@pin_mask), and which of those pins may be long pulses 457 * (@long_mask). The @long_mask is ignored if the port corresponding to the pin 458 * is not a digital port. 459 * 460 * Here, we do hotplug irq storm detection and mitigation, and pass further 461 * processing to appropriate bottom halves. 462 */ 463void intel_hpd_irq_handler(struct drm_i915_private *dev_priv, 464 u32 pin_mask, u32 long_mask) 465{ 466 struct intel_encoder *encoder; 467 bool storm_detected = false; 468 bool queue_dig = false, queue_hp = false; 469 u32 long_hpd_pulse_mask = 0; 470 u32 short_hpd_pulse_mask = 0; 471 enum hpd_pin pin; 472 473 if (!pin_mask) 474 return; 475 476 spin_lock(&dev_priv->irq_lock); 477 478 /* 479 * Determine whether ->hpd_pulse() exists for each pin, and 480 * whether we have a short or a long pulse. This is needed 481 * as each pin may have up to two encoders (HDMI and DP) and 482 * only the one of them (DP) will have ->hpd_pulse(). 483 */ 484 for_each_intel_encoder(&dev_priv->drm, encoder) { 485 enum port port = encoder->port; 486 bool long_hpd; 487 488 pin = encoder->hpd_pin; 489 if (!(BIT(pin) & pin_mask)) 490 continue; 491 492 if (!intel_encoder_has_hpd_pulse(encoder)) 493 continue; 494 495 long_hpd = long_mask & BIT(pin); 496 497 drm_dbg(&dev_priv->drm, 498 "digital hpd on [ENCODER:%d:%s] - %s\n", 499 encoder->base.base.id, encoder->base.name, 500 long_hpd ? "long" : "short"); 501 queue_dig = true; 502 503 if (long_hpd) { 504 long_hpd_pulse_mask |= BIT(pin); 505 dev_priv->hotplug.long_port_mask |= BIT(port); 506 } else { 507 short_hpd_pulse_mask |= BIT(pin); 508 dev_priv->hotplug.short_port_mask |= BIT(port); 509 } 510 } 511 512 /* Now process each pin just once */ 513 for_each_hpd_pin(pin) { 514 bool long_hpd; 515 516 if (!(BIT(pin) & pin_mask)) 517 continue; 518 519 if (dev_priv->hotplug.stats[pin].state == HPD_DISABLED) { 520 /* 521 * On GMCH platforms the interrupt mask bits only 522 * prevent irq generation, not the setting of the 523 * hotplug bits itself. So only WARN about unexpected 524 * interrupts on saner platforms. 525 */ 526 drm_WARN_ONCE(&dev_priv->drm, !HAS_GMCH(dev_priv), 527 "Received HPD interrupt on pin %d although disabled\n", 528 pin); 529 continue; 530 } 531 532 if (dev_priv->hotplug.stats[pin].state != HPD_ENABLED) 533 continue; 534 535 /* 536 * Delegate to ->hpd_pulse() if one of the encoders for this 537 * pin has it, otherwise let the hotplug_work deal with this 538 * pin directly. 539 */ 540 if (((short_hpd_pulse_mask | long_hpd_pulse_mask) & BIT(pin))) { 541 long_hpd = long_hpd_pulse_mask & BIT(pin); 542 } else { 543 dev_priv->hotplug.event_bits |= BIT(pin); 544 long_hpd = true; 545 queue_hp = true; 546 } 547 548 if (intel_hpd_irq_storm_detect(dev_priv, pin, long_hpd)) { 549 dev_priv->hotplug.event_bits &= ~BIT(pin); 550 storm_detected = true; 551 queue_hp = true; 552 } 553 } 554 555 /* 556 * Disable any IRQs that storms were detected on. Polling enablement 557 * happens later in our hotplug work. 558 */ 559 if (storm_detected && dev_priv->display_irqs_enabled) 560 dev_priv->display.hpd_irq_setup(dev_priv); 561 spin_unlock(&dev_priv->irq_lock); 562 563 /* 564 * Our hotplug handler can grab modeset locks (by calling down into the 565 * fb helpers). Hence it must not be run on our own dev-priv->wq work 566 * queue for otherwise the flush_work in the pageflip code will 567 * deadlock. 568 */ 569 if (queue_dig) 570 queue_work(dev_priv->hotplug.dp_wq, &dev_priv->hotplug.dig_port_work); 571 if (queue_hp) 572 queue_delayed_work(system_wq, &dev_priv->hotplug.hotplug_work, 0); 573} 574 575/** 576 * intel_hpd_init - initializes and enables hpd support 577 * @dev_priv: i915 device instance 578 * 579 * This function enables the hotplug support. It requires that interrupts have 580 * already been enabled with intel_irq_init_hw(). From this point on hotplug and 581 * poll request can run concurrently to other code, so locking rules must be 582 * obeyed. 583 * 584 * This is a separate step from interrupt enabling to simplify the locking rules 585 * in the driver load and resume code. 586 * 587 * Also see: intel_hpd_poll_init(), which enables connector polling 588 */ 589void intel_hpd_init(struct drm_i915_private *dev_priv) 590{ 591 int i; 592 593 for_each_hpd_pin(i) { 594 dev_priv->hotplug.stats[i].count = 0; 595 dev_priv->hotplug.stats[i].state = HPD_ENABLED; 596 } 597 598 WRITE_ONCE(dev_priv->hotplug.poll_enabled, false); 599 schedule_work(&dev_priv->hotplug.poll_init_work); 600 601 /* 602 * Interrupt setup is already guaranteed to be single-threaded, this is 603 * just to make the assert_spin_locked checks happy. 604 */ 605 if (dev_priv->display_irqs_enabled && dev_priv->display.hpd_irq_setup) { 606 spin_lock_irq(&dev_priv->irq_lock); 607 if (dev_priv->display_irqs_enabled) 608 dev_priv->display.hpd_irq_setup(dev_priv); 609 spin_unlock_irq(&dev_priv->irq_lock); 610 } 611} 612 613static void i915_hpd_poll_init_work(struct work_struct *work) 614{ 615 struct drm_i915_private *dev_priv = 616 container_of(work, struct drm_i915_private, 617 hotplug.poll_init_work); 618 struct drm_device *dev = &dev_priv->drm; 619 struct drm_connector_list_iter conn_iter; 620 struct intel_connector *connector; 621 bool enabled; 622 623 mutex_lock(&dev->mode_config.mutex); 624 625 enabled = READ_ONCE(dev_priv->hotplug.poll_enabled); 626 627 drm_connector_list_iter_begin(dev, &conn_iter); 628 for_each_intel_connector_iter(connector, &conn_iter) { 629 enum hpd_pin pin; 630 631 pin = intel_connector_hpd_pin(connector); 632 if (pin == HPD_NONE) 633 continue; 634 635 connector->base.polled = connector->polled; 636 637 if (enabled && connector->base.polled == DRM_CONNECTOR_POLL_HPD) 638 connector->base.polled = DRM_CONNECTOR_POLL_CONNECT | 639 DRM_CONNECTOR_POLL_DISCONNECT; 640 } 641 drm_connector_list_iter_end(&conn_iter); 642 643 if (enabled) 644 drm_kms_helper_poll_enable(dev); 645 646 mutex_unlock(&dev->mode_config.mutex); 647 648 /* 649 * We might have missed any hotplugs that happened while we were 650 * in the middle of disabling polling 651 */ 652 if (!enabled) 653 drm_helper_hpd_irq_event(dev); 654} 655 656/** 657 * intel_hpd_poll_init - enables/disables polling for connectors with hpd 658 * @dev_priv: i915 device instance 659 * 660 * This function enables polling for all connectors, regardless of whether or 661 * not they support hotplug detection. Under certain conditions HPD may not be 662 * functional. On most Intel GPUs, this happens when we enter runtime suspend. 663 * On Valleyview and Cherryview systems, this also happens when we shut off all 664 * of the powerwells. 665 * 666 * Since this function can get called in contexts where we're already holding 667 * dev->mode_config.mutex, we do the actual hotplug enabling in a seperate 668 * worker. 669 * 670 * Also see: intel_hpd_init(), which restores hpd handling. 671 */ 672void intel_hpd_poll_init(struct drm_i915_private *dev_priv) 673{ 674 WRITE_ONCE(dev_priv->hotplug.poll_enabled, true); 675 676 /* 677 * We might already be holding dev->mode_config.mutex, so do this in a 678 * seperate worker 679 * As well, there's no issue if we race here since we always reschedule 680 * this worker anyway 681 */ 682 schedule_work(&dev_priv->hotplug.poll_init_work); 683} 684 685void intel_hpd_init_work(struct drm_i915_private *dev_priv) 686{ 687 INIT_DELAYED_WORK(&dev_priv->hotplug.hotplug_work, 688 i915_hotplug_work_func); 689 INIT_WORK(&dev_priv->hotplug.dig_port_work, i915_digport_work_func); 690 INIT_WORK(&dev_priv->hotplug.poll_init_work, i915_hpd_poll_init_work); 691 INIT_DELAYED_WORK(&dev_priv->hotplug.reenable_work, 692 intel_hpd_irq_storm_reenable_work); 693} 694 695void intel_hpd_cancel_work(struct drm_i915_private *dev_priv) 696{ 697 spin_lock_irq(&dev_priv->irq_lock); 698 699 dev_priv->hotplug.long_port_mask = 0; 700 dev_priv->hotplug.short_port_mask = 0; 701 dev_priv->hotplug.event_bits = 0; 702 dev_priv->hotplug.retry_bits = 0; 703 704 spin_unlock_irq(&dev_priv->irq_lock); 705 706 cancel_work_sync(&dev_priv->hotplug.dig_port_work); 707 cancel_delayed_work_sync(&dev_priv->hotplug.hotplug_work); 708 cancel_work_sync(&dev_priv->hotplug.poll_init_work); 709 cancel_delayed_work_sync(&dev_priv->hotplug.reenable_work); 710} 711 712bool intel_hpd_disable(struct drm_i915_private *dev_priv, enum hpd_pin pin) 713{ 714 bool ret = false; 715 716 if (pin == HPD_NONE) 717 return false; 718 719 spin_lock_irq(&dev_priv->irq_lock); 720 if (dev_priv->hotplug.stats[pin].state == HPD_ENABLED) { 721 dev_priv->hotplug.stats[pin].state = HPD_DISABLED; 722 ret = true; 723 } 724 spin_unlock_irq(&dev_priv->irq_lock); 725 726 return ret; 727} 728 729void intel_hpd_enable(struct drm_i915_private *dev_priv, enum hpd_pin pin) 730{ 731 if (pin == HPD_NONE) 732 return; 733 734 spin_lock_irq(&dev_priv->irq_lock); 735 dev_priv->hotplug.stats[pin].state = HPD_ENABLED; 736 spin_unlock_irq(&dev_priv->irq_lock); 737} 738