1170 lines · c
1/*2 * Copyright © 2015 Intel Corporation3 *4 * Permission is hereby granted, free of charge, to any person obtaining a5 * copy of this software and associated documentation files (the "Software"),6 * to deal in the Software without restriction, including without limitation7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,8 * and/or sell copies of the Software, and to permit persons to whom the9 * Software is furnished to do so, subject to the following conditions:10 *11 * The above copyright notice and this permission notice (including the next12 * paragraph) shall be included in all copies or substantial portions of the13 * Software.14 *15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS21 * IN THE SOFTWARE.22 */23 24#include <linux/kernel.h>25 26#include "i915_drv.h"27#include "i915_irq.h"28#include "intel_display_power.h"29#include "intel_display_types.h"30#include "intel_hotplug.h"31#include "intel_hotplug_irq.h"32 33/**34 * DOC: Hotplug35 *36 * Simply put, hotplug occurs when a display is connected to or disconnected37 * from the system. However, there may be adapters and docking stations and38 * Display Port short pulses and MST devices involved, complicating matters.39 *40 * Hotplug in i915 is handled in many different levels of abstraction.41 *42 * The platform dependent interrupt handling code in i915_irq.c enables,43 * disables, and does preliminary handling of the interrupts. The interrupt44 * handlers gather the hotplug detect (HPD) information from relevant registers45 * into a platform independent mask of hotplug pins that have fired.46 *47 * The platform independent interrupt handler intel_hpd_irq_handler() in48 * intel_hotplug.c does hotplug irq storm detection and mitigation, and passes49 * further processing to appropriate bottom halves (Display Port specific and50 * regular hotplug).51 *52 * The Display Port work function i915_digport_work_func() calls into53 * intel_dp_hpd_pulse() via hooks, which handles DP short pulses and DP MST long54 * pulses, with failures and non-MST long pulses triggering regular hotplug55 * processing on the connector.56 *57 * The regular hotplug work function i915_hotplug_work_func() calls connector58 * detect hooks, and, if connector status changes, triggers sending of hotplug59 * uevent to userspace via drm_kms_helper_hotplug_event().60 *61 * Finally, the userspace is responsible for triggering a modeset upon receiving62 * the hotplug uevent, disabling or enabling the crtc as needed.63 *64 * The hotplug interrupt storm detection and mitigation code keeps track of the65 * number of interrupts per hotplug pin per a period of time, and if the number66 * of interrupts exceeds a certain threshold, the interrupt is disabled for a67 * while before being re-enabled. The intention is to mitigate issues raising68 * from broken hardware triggering massive amounts of interrupts and grinding69 * the system to a halt.70 *71 * Current implementation expects that hotplug interrupt storm will not be72 * seen when display port sink is connected, hence on platforms whose DP73 * callback is handled by i915_digport_work_func reenabling of hpd is not74 * performed (it was never expected to be disabled in the first place ;) )75 * this is specific to DP sinks handled by this routine and any other display76 * such as HDMI or DVI enabled on the same port will have proper logic since77 * it will use i915_hotplug_work_func where this logic is handled.78 */79 80/**81 * intel_hpd_pin_default - return default pin associated with certain port.82 * @dev_priv: private driver data pointer83 * @port: the hpd port to get associated pin84 *85 * It is only valid and used by digital port encoder.86 *87 * Return pin that is associatade with @port.88 */89enum hpd_pin intel_hpd_pin_default(struct drm_i915_private *dev_priv,90 enum port port)91{92 return HPD_PORT_A + port - PORT_A;93}94 95/* Threshold == 5 for long IRQs, 50 for short */96#define HPD_STORM_DEFAULT_THRESHOLD 5097 98#define HPD_STORM_DETECT_PERIOD 100099#define HPD_STORM_REENABLE_DELAY (2 * 60 * 1000)100#define HPD_RETRY_DELAY 1000101 102static enum hpd_pin103intel_connector_hpd_pin(struct intel_connector *connector)104{105 struct intel_encoder *encoder = intel_attached_encoder(connector);106 107 /*108 * MST connectors get their encoder attached dynamically109 * so need to make sure we have an encoder here. But since110 * MST encoders have their hpd_pin set to HPD_NONE we don't111 * have to special case them beyond that.112 */113 return encoder ? encoder->hpd_pin : HPD_NONE;114}115 116/**117 * intel_hpd_irq_storm_detect - gather stats and detect HPD IRQ storm on a pin118 * @dev_priv: private driver data pointer119 * @pin: the pin to gather stats on120 * @long_hpd: whether the HPD IRQ was long or short121 *122 * Gather stats about HPD IRQs from the specified @pin, and detect IRQ123 * storms. Only the pin specific stats and state are changed, the caller is124 * responsible for further action.125 *126 * The number of IRQs that are allowed within @HPD_STORM_DETECT_PERIOD is127 * stored in @dev_priv->display.hotplug.hpd_storm_threshold which defaults to128 * @HPD_STORM_DEFAULT_THRESHOLD. Long IRQs count as +10 to this threshold, and129 * short IRQs count as +1. If this threshold is exceeded, it's considered an130 * IRQ storm and the IRQ state is set to @HPD_MARK_DISABLED.131 *132 * By default, most systems will only count long IRQs towards133 * &dev_priv->display.hotplug.hpd_storm_threshold. However, some older systems also134 * suffer from short IRQ storms and must also track these. Because short IRQ135 * storms are naturally caused by sideband interactions with DP MST devices,136 * short IRQ detection is only enabled for systems without DP MST support.137 * Systems which are new enough to support DP MST are far less likely to138 * suffer from IRQ storms at all, so this is fine.139 *140 * The HPD threshold can be controlled through i915_hpd_storm_ctl in debugfs,141 * and should only be adjusted for automated hotplug testing.142 *143 * Return true if an IRQ storm was detected on @pin.144 */145static bool intel_hpd_irq_storm_detect(struct drm_i915_private *dev_priv,146 enum hpd_pin pin, bool long_hpd)147{148 struct intel_hotplug *hpd = &dev_priv->display.hotplug;149 unsigned long start = hpd->stats[pin].last_jiffies;150 unsigned long end = start + msecs_to_jiffies(HPD_STORM_DETECT_PERIOD);151 const int increment = long_hpd ? 10 : 1;152 const int threshold = hpd->hpd_storm_threshold;153 bool storm = false;154 155 if (!threshold ||156 (!long_hpd && !dev_priv->display.hotplug.hpd_short_storm_enabled))157 return false;158 159 if (!time_in_range(jiffies, start, end)) {160 hpd->stats[pin].last_jiffies = jiffies;161 hpd->stats[pin].count = 0;162 }163 164 hpd->stats[pin].count += increment;165 if (hpd->stats[pin].count > threshold) {166 hpd->stats[pin].state = HPD_MARK_DISABLED;167 drm_dbg_kms(&dev_priv->drm,168 "HPD interrupt storm detected on PIN %d\n", pin);169 storm = true;170 } else {171 drm_dbg_kms(&dev_priv->drm,172 "Received HPD interrupt on PIN %d - cnt: %d\n",173 pin,174 hpd->stats[pin].count);175 }176 177 return storm;178}179 180static bool detection_work_enabled(struct drm_i915_private *i915)181{182 lockdep_assert_held(&i915->irq_lock);183 184 return i915->display.hotplug.detection_work_enabled;185}186 187static bool188mod_delayed_detection_work(struct drm_i915_private *i915, struct delayed_work *work, int delay)189{190 lockdep_assert_held(&i915->irq_lock);191 192 if (!detection_work_enabled(i915))193 return false;194 195 return mod_delayed_work(i915->unordered_wq, work, delay);196}197 198static bool199queue_delayed_detection_work(struct drm_i915_private *i915, struct delayed_work *work, int delay)200{201 lockdep_assert_held(&i915->irq_lock);202 203 if (!detection_work_enabled(i915))204 return false;205 206 return queue_delayed_work(i915->unordered_wq, work, delay);207}208 209static bool210queue_detection_work(struct drm_i915_private *i915, struct work_struct *work)211{212 lockdep_assert_held(&i915->irq_lock);213 214 if (!detection_work_enabled(i915))215 return false;216 217 return queue_work(i915->unordered_wq, work);218}219 220static void221intel_hpd_irq_storm_switch_to_polling(struct drm_i915_private *dev_priv)222{223 struct drm_connector_list_iter conn_iter;224 struct intel_connector *connector;225 bool hpd_disabled = false;226 227 lockdep_assert_held(&dev_priv->irq_lock);228 229 drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);230 for_each_intel_connector_iter(connector, &conn_iter) {231 enum hpd_pin pin;232 233 if (connector->base.polled != DRM_CONNECTOR_POLL_HPD)234 continue;235 236 pin = intel_connector_hpd_pin(connector);237 if (pin == HPD_NONE ||238 dev_priv->display.hotplug.stats[pin].state != HPD_MARK_DISABLED)239 continue;240 241 drm_info(&dev_priv->drm,242 "HPD interrupt storm detected on connector %s: "243 "switching from hotplug detection to polling\n",244 connector->base.name);245 246 dev_priv->display.hotplug.stats[pin].state = HPD_DISABLED;247 connector->base.polled = DRM_CONNECTOR_POLL_CONNECT |248 DRM_CONNECTOR_POLL_DISCONNECT;249 hpd_disabled = true;250 }251 drm_connector_list_iter_end(&conn_iter);252 253 /* Enable polling and queue hotplug re-enabling. */254 if (hpd_disabled) {255 drm_kms_helper_poll_reschedule(&dev_priv->drm);256 mod_delayed_detection_work(dev_priv,257 &dev_priv->display.hotplug.reenable_work,258 msecs_to_jiffies(HPD_STORM_REENABLE_DELAY));259 }260}261 262static void intel_hpd_irq_storm_reenable_work(struct work_struct *work)263{264 struct drm_i915_private *dev_priv =265 container_of(work, typeof(*dev_priv),266 display.hotplug.reenable_work.work);267 struct drm_connector_list_iter conn_iter;268 struct intel_connector *connector;269 intel_wakeref_t wakeref;270 enum hpd_pin pin;271 272 wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);273 274 spin_lock_irq(&dev_priv->irq_lock);275 276 drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);277 for_each_intel_connector_iter(connector, &conn_iter) {278 pin = intel_connector_hpd_pin(connector);279 if (pin == HPD_NONE ||280 dev_priv->display.hotplug.stats[pin].state != HPD_DISABLED)281 continue;282 283 if (connector->base.polled != connector->polled)284 drm_dbg(&dev_priv->drm,285 "Reenabling HPD on connector %s\n",286 connector->base.name);287 connector->base.polled = connector->polled;288 }289 drm_connector_list_iter_end(&conn_iter);290 291 for_each_hpd_pin(pin) {292 if (dev_priv->display.hotplug.stats[pin].state == HPD_DISABLED)293 dev_priv->display.hotplug.stats[pin].state = HPD_ENABLED;294 }295 296 intel_hpd_irq_setup(dev_priv);297 298 spin_unlock_irq(&dev_priv->irq_lock);299 300 intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);301}302 303static enum intel_hotplug_state304intel_hotplug_detect_connector(struct intel_connector *connector)305{306 struct drm_device *dev = connector->base.dev;307 enum drm_connector_status old_status;308 u64 old_epoch_counter;309 int status;310 bool ret = false;311 312 drm_WARN_ON(dev, !mutex_is_locked(&dev->mode_config.mutex));313 old_status = connector->base.status;314 old_epoch_counter = connector->base.epoch_counter;315 316 status = drm_helper_probe_detect(&connector->base, NULL, false);317 if (!connector->base.force)318 connector->base.status = status;319 320 if (old_epoch_counter != connector->base.epoch_counter)321 ret = true;322 323 if (ret) {324 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] status updated from %s to %s (epoch counter %llu->%llu)\n",325 connector->base.base.id,326 connector->base.name,327 drm_get_connector_status_name(old_status),328 drm_get_connector_status_name(connector->base.status),329 old_epoch_counter,330 connector->base.epoch_counter);331 return INTEL_HOTPLUG_CHANGED;332 }333 return INTEL_HOTPLUG_UNCHANGED;334}335 336enum intel_hotplug_state337intel_encoder_hotplug(struct intel_encoder *encoder,338 struct intel_connector *connector)339{340 return intel_hotplug_detect_connector(connector);341}342 343static bool intel_encoder_has_hpd_pulse(struct intel_encoder *encoder)344{345 return intel_encoder_is_dig_port(encoder) &&346 enc_to_dig_port(encoder)->hpd_pulse != NULL;347}348 349static void i915_digport_work_func(struct work_struct *work)350{351 struct drm_i915_private *dev_priv =352 container_of(work, struct drm_i915_private, display.hotplug.dig_port_work);353 u32 long_port_mask, short_port_mask;354 struct intel_encoder *encoder;355 u32 old_bits = 0;356 357 spin_lock_irq(&dev_priv->irq_lock);358 long_port_mask = dev_priv->display.hotplug.long_port_mask;359 dev_priv->display.hotplug.long_port_mask = 0;360 short_port_mask = dev_priv->display.hotplug.short_port_mask;361 dev_priv->display.hotplug.short_port_mask = 0;362 spin_unlock_irq(&dev_priv->irq_lock);363 364 for_each_intel_encoder(&dev_priv->drm, encoder) {365 struct intel_digital_port *dig_port;366 enum port port = encoder->port;367 bool long_hpd, short_hpd;368 enum irqreturn ret;369 370 if (!intel_encoder_has_hpd_pulse(encoder))371 continue;372 373 long_hpd = long_port_mask & BIT(port);374 short_hpd = short_port_mask & BIT(port);375 376 if (!long_hpd && !short_hpd)377 continue;378 379 dig_port = enc_to_dig_port(encoder);380 381 ret = dig_port->hpd_pulse(dig_port, long_hpd);382 if (ret == IRQ_NONE) {383 /* fall back to old school hpd */384 old_bits |= BIT(encoder->hpd_pin);385 }386 }387 388 if (old_bits) {389 spin_lock_irq(&dev_priv->irq_lock);390 dev_priv->display.hotplug.event_bits |= old_bits;391 queue_delayed_detection_work(dev_priv,392 &dev_priv->display.hotplug.hotplug_work, 0);393 spin_unlock_irq(&dev_priv->irq_lock);394 }395}396 397/**398 * intel_hpd_trigger_irq - trigger an hpd irq event for a port399 * @dig_port: digital port400 *401 * Trigger an HPD interrupt event for the given port, emulating a short pulse402 * generated by the sink, and schedule the dig port work to handle it.403 */404void intel_hpd_trigger_irq(struct intel_digital_port *dig_port)405{406 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);407 408 spin_lock_irq(&i915->irq_lock);409 i915->display.hotplug.short_port_mask |= BIT(dig_port->base.port);410 spin_unlock_irq(&i915->irq_lock);411 412 queue_work(i915->display.hotplug.dp_wq, &i915->display.hotplug.dig_port_work);413}414 415/*416 * Handle hotplug events outside the interrupt handler proper.417 */418static void i915_hotplug_work_func(struct work_struct *work)419{420 struct drm_i915_private *dev_priv =421 container_of(work, struct drm_i915_private,422 display.hotplug.hotplug_work.work);423 struct drm_connector_list_iter conn_iter;424 struct intel_connector *connector;425 u32 changed = 0, retry = 0;426 u32 hpd_event_bits;427 u32 hpd_retry_bits;428 struct drm_connector *first_changed_connector = NULL;429 int changed_connectors = 0;430 431 mutex_lock(&dev_priv->drm.mode_config.mutex);432 drm_dbg_kms(&dev_priv->drm, "running encoder hotplug functions\n");433 434 spin_lock_irq(&dev_priv->irq_lock);435 436 hpd_event_bits = dev_priv->display.hotplug.event_bits;437 dev_priv->display.hotplug.event_bits = 0;438 hpd_retry_bits = dev_priv->display.hotplug.retry_bits;439 dev_priv->display.hotplug.retry_bits = 0;440 441 /* Enable polling for connectors which had HPD IRQ storms */442 intel_hpd_irq_storm_switch_to_polling(dev_priv);443 444 spin_unlock_irq(&dev_priv->irq_lock);445 446 /* Skip calling encode hotplug handlers if ignore long HPD set*/447 if (dev_priv->display.hotplug.ignore_long_hpd) {448 drm_dbg_kms(&dev_priv->drm, "Ignore HPD flag on - skip encoder hotplug handlers\n");449 mutex_unlock(&dev_priv->drm.mode_config.mutex);450 return;451 }452 453 drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);454 for_each_intel_connector_iter(connector, &conn_iter) {455 enum hpd_pin pin;456 u32 hpd_bit;457 458 pin = intel_connector_hpd_pin(connector);459 if (pin == HPD_NONE)460 continue;461 462 hpd_bit = BIT(pin);463 if ((hpd_event_bits | hpd_retry_bits) & hpd_bit) {464 struct intel_encoder *encoder =465 intel_attached_encoder(connector);466 467 if (hpd_event_bits & hpd_bit)468 connector->hotplug_retries = 0;469 else470 connector->hotplug_retries++;471 472 drm_dbg_kms(&dev_priv->drm,473 "Connector %s (pin %i) received hotplug event. (retry %d)\n",474 connector->base.name, pin,475 connector->hotplug_retries);476 477 switch (encoder->hotplug(encoder, connector)) {478 case INTEL_HOTPLUG_UNCHANGED:479 break;480 case INTEL_HOTPLUG_CHANGED:481 changed |= hpd_bit;482 changed_connectors++;483 if (!first_changed_connector) {484 drm_connector_get(&connector->base);485 first_changed_connector = &connector->base;486 }487 break;488 case INTEL_HOTPLUG_RETRY:489 retry |= hpd_bit;490 break;491 }492 }493 }494 drm_connector_list_iter_end(&conn_iter);495 mutex_unlock(&dev_priv->drm.mode_config.mutex);496 497 if (changed_connectors == 1)498 drm_kms_helper_connector_hotplug_event(first_changed_connector);499 else if (changed_connectors > 0)500 drm_kms_helper_hotplug_event(&dev_priv->drm);501 502 if (first_changed_connector)503 drm_connector_put(first_changed_connector);504 505 /* Remove shared HPD pins that have changed */506 retry &= ~changed;507 if (retry) {508 spin_lock_irq(&dev_priv->irq_lock);509 dev_priv->display.hotplug.retry_bits |= retry;510 511 mod_delayed_detection_work(dev_priv,512 &dev_priv->display.hotplug.hotplug_work,513 msecs_to_jiffies(HPD_RETRY_DELAY));514 spin_unlock_irq(&dev_priv->irq_lock);515 }516}517 518 519/**520 * intel_hpd_irq_handler - main hotplug irq handler521 * @dev_priv: drm_i915_private522 * @pin_mask: a mask of hpd pins that have triggered the irq523 * @long_mask: a mask of hpd pins that may be long hpd pulses524 *525 * This is the main hotplug irq handler for all platforms. The platform specific526 * irq handlers call the platform specific hotplug irq handlers, which read and527 * decode the appropriate registers into bitmasks about hpd pins that have528 * triggered (@pin_mask), and which of those pins may be long pulses529 * (@long_mask). The @long_mask is ignored if the port corresponding to the pin530 * is not a digital port.531 *532 * Here, we do hotplug irq storm detection and mitigation, and pass further533 * processing to appropriate bottom halves.534 */535void intel_hpd_irq_handler(struct drm_i915_private *dev_priv,536 u32 pin_mask, u32 long_mask)537{538 struct intel_encoder *encoder;539 bool storm_detected = false;540 bool queue_dig = false, queue_hp = false;541 u32 long_hpd_pulse_mask = 0;542 u32 short_hpd_pulse_mask = 0;543 enum hpd_pin pin;544 545 if (!pin_mask)546 return;547 548 spin_lock(&dev_priv->irq_lock);549 550 /*551 * Determine whether ->hpd_pulse() exists for each pin, and552 * whether we have a short or a long pulse. This is needed553 * as each pin may have up to two encoders (HDMI and DP) and554 * only the one of them (DP) will have ->hpd_pulse().555 */556 for_each_intel_encoder(&dev_priv->drm, encoder) {557 enum port port = encoder->port;558 bool long_hpd;559 560 pin = encoder->hpd_pin;561 if (!(BIT(pin) & pin_mask))562 continue;563 564 if (!intel_encoder_has_hpd_pulse(encoder))565 continue;566 567 long_hpd = long_mask & BIT(pin);568 569 drm_dbg(&dev_priv->drm,570 "digital hpd on [ENCODER:%d:%s] - %s\n",571 encoder->base.base.id, encoder->base.name,572 long_hpd ? "long" : "short");573 queue_dig = true;574 575 if (long_hpd) {576 long_hpd_pulse_mask |= BIT(pin);577 dev_priv->display.hotplug.long_port_mask |= BIT(port);578 } else {579 short_hpd_pulse_mask |= BIT(pin);580 dev_priv->display.hotplug.short_port_mask |= BIT(port);581 }582 }583 584 /* Now process each pin just once */585 for_each_hpd_pin(pin) {586 bool long_hpd;587 588 if (!(BIT(pin) & pin_mask))589 continue;590 591 if (dev_priv->display.hotplug.stats[pin].state == HPD_DISABLED) {592 /*593 * On GMCH platforms the interrupt mask bits only594 * prevent irq generation, not the setting of the595 * hotplug bits itself. So only WARN about unexpected596 * interrupts on saner platforms.597 */598 drm_WARN_ONCE(&dev_priv->drm, !HAS_GMCH(dev_priv),599 "Received HPD interrupt on pin %d although disabled\n",600 pin);601 continue;602 }603 604 if (dev_priv->display.hotplug.stats[pin].state != HPD_ENABLED)605 continue;606 607 /*608 * Delegate to ->hpd_pulse() if one of the encoders for this609 * pin has it, otherwise let the hotplug_work deal with this610 * pin directly.611 */612 if (((short_hpd_pulse_mask | long_hpd_pulse_mask) & BIT(pin))) {613 long_hpd = long_hpd_pulse_mask & BIT(pin);614 } else {615 dev_priv->display.hotplug.event_bits |= BIT(pin);616 long_hpd = true;617 queue_hp = true;618 }619 620 if (intel_hpd_irq_storm_detect(dev_priv, pin, long_hpd)) {621 dev_priv->display.hotplug.event_bits &= ~BIT(pin);622 storm_detected = true;623 queue_hp = true;624 }625 }626 627 /*628 * Disable any IRQs that storms were detected on. Polling enablement629 * happens later in our hotplug work.630 */631 if (storm_detected)632 intel_hpd_irq_setup(dev_priv);633 634 /*635 * Our hotplug handler can grab modeset locks (by calling down into the636 * fb helpers). Hence it must not be run on our own dev-priv->wq work637 * queue for otherwise the flush_work in the pageflip code will638 * deadlock.639 */640 if (queue_dig)641 queue_work(dev_priv->display.hotplug.dp_wq, &dev_priv->display.hotplug.dig_port_work);642 if (queue_hp)643 queue_delayed_detection_work(dev_priv,644 &dev_priv->display.hotplug.hotplug_work, 0);645 646 spin_unlock(&dev_priv->irq_lock);647}648 649/**650 * intel_hpd_init - initializes and enables hpd support651 * @dev_priv: i915 device instance652 *653 * This function enables the hotplug support. It requires that interrupts have654 * already been enabled with intel_irq_init_hw(). From this point on hotplug and655 * poll request can run concurrently to other code, so locking rules must be656 * obeyed.657 *658 * This is a separate step from interrupt enabling to simplify the locking rules659 * in the driver load and resume code.660 *661 * Also see: intel_hpd_poll_enable() and intel_hpd_poll_disable().662 */663void intel_hpd_init(struct drm_i915_private *dev_priv)664{665 int i;666 667 if (!HAS_DISPLAY(dev_priv))668 return;669 670 for_each_hpd_pin(i) {671 dev_priv->display.hotplug.stats[i].count = 0;672 dev_priv->display.hotplug.stats[i].state = HPD_ENABLED;673 }674 675 /*676 * Interrupt setup is already guaranteed to be single-threaded, this is677 * just to make the assert_spin_locked checks happy.678 */679 spin_lock_irq(&dev_priv->irq_lock);680 intel_hpd_irq_setup(dev_priv);681 spin_unlock_irq(&dev_priv->irq_lock);682}683 684static void i915_hpd_poll_detect_connectors(struct drm_i915_private *i915)685{686 struct drm_connector_list_iter conn_iter;687 struct intel_connector *connector;688 struct intel_connector *first_changed_connector = NULL;689 int changed = 0;690 691 mutex_lock(&i915->drm.mode_config.mutex);692 693 if (!i915->drm.mode_config.poll_enabled)694 goto out;695 696 drm_connector_list_iter_begin(&i915->drm, &conn_iter);697 for_each_intel_connector_iter(connector, &conn_iter) {698 if (!(connector->base.polled & DRM_CONNECTOR_POLL_HPD))699 continue;700 701 if (intel_hotplug_detect_connector(connector) != INTEL_HOTPLUG_CHANGED)702 continue;703 704 changed++;705 706 if (changed == 1) {707 drm_connector_get(&connector->base);708 first_changed_connector = connector;709 }710 }711 drm_connector_list_iter_end(&conn_iter);712 713out:714 mutex_unlock(&i915->drm.mode_config.mutex);715 716 if (!changed)717 return;718 719 if (changed == 1)720 drm_kms_helper_connector_hotplug_event(&first_changed_connector->base);721 else722 drm_kms_helper_hotplug_event(&i915->drm);723 724 drm_connector_put(&first_changed_connector->base);725}726 727static void i915_hpd_poll_init_work(struct work_struct *work)728{729 struct drm_i915_private *dev_priv =730 container_of(work, struct drm_i915_private,731 display.hotplug.poll_init_work);732 struct drm_connector_list_iter conn_iter;733 struct intel_connector *connector;734 intel_wakeref_t wakeref;735 bool enabled;736 737 mutex_lock(&dev_priv->drm.mode_config.mutex);738 739 enabled = READ_ONCE(dev_priv->display.hotplug.poll_enabled);740 /*741 * Prevent taking a power reference from this sequence of742 * i915_hpd_poll_init_work() -> drm_helper_hpd_irq_event() ->743 * connector detect which would requeue i915_hpd_poll_init_work()744 * and so risk an endless loop of this same sequence.745 */746 if (!enabled) {747 wakeref = intel_display_power_get(dev_priv,748 POWER_DOMAIN_DISPLAY_CORE);749 drm_WARN_ON(&dev_priv->drm,750 READ_ONCE(dev_priv->display.hotplug.poll_enabled));751 cancel_work(&dev_priv->display.hotplug.poll_init_work);752 }753 754 spin_lock_irq(&dev_priv->irq_lock);755 756 drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);757 for_each_intel_connector_iter(connector, &conn_iter) {758 enum hpd_pin pin;759 760 pin = intel_connector_hpd_pin(connector);761 if (pin == HPD_NONE)762 continue;763 764 if (dev_priv->display.hotplug.stats[pin].state == HPD_DISABLED)765 continue;766 767 connector->base.polled = connector->polled;768 769 if (enabled && connector->base.polled == DRM_CONNECTOR_POLL_HPD)770 connector->base.polled = DRM_CONNECTOR_POLL_CONNECT |771 DRM_CONNECTOR_POLL_DISCONNECT;772 }773 drm_connector_list_iter_end(&conn_iter);774 775 spin_unlock_irq(&dev_priv->irq_lock);776 777 if (enabled)778 drm_kms_helper_poll_reschedule(&dev_priv->drm);779 780 mutex_unlock(&dev_priv->drm.mode_config.mutex);781 782 /*783 * We might have missed any hotplugs that happened while we were784 * in the middle of disabling polling785 */786 if (!enabled) {787 i915_hpd_poll_detect_connectors(dev_priv);788 789 intel_display_power_put(dev_priv,790 POWER_DOMAIN_DISPLAY_CORE,791 wakeref);792 }793}794 795/**796 * intel_hpd_poll_enable - enable polling for connectors with hpd797 * @dev_priv: i915 device instance798 *799 * This function enables polling for all connectors which support HPD.800 * Under certain conditions HPD may not be functional. On most Intel GPUs,801 * this happens when we enter runtime suspend.802 * On Valleyview and Cherryview systems, this also happens when we shut off all803 * of the powerwells.804 *805 * Since this function can get called in contexts where we're already holding806 * dev->mode_config.mutex, we do the actual hotplug enabling in a seperate807 * worker.808 *809 * Also see: intel_hpd_init() and intel_hpd_poll_disable().810 */811void intel_hpd_poll_enable(struct drm_i915_private *dev_priv)812{813 if (!HAS_DISPLAY(dev_priv) ||814 !intel_display_device_enabled(dev_priv))815 return;816 817 WRITE_ONCE(dev_priv->display.hotplug.poll_enabled, true);818 819 /*820 * We might already be holding dev->mode_config.mutex, so do this in a821 * seperate worker822 * As well, there's no issue if we race here since we always reschedule823 * this worker anyway824 */825 spin_lock_irq(&dev_priv->irq_lock);826 queue_detection_work(dev_priv,827 &dev_priv->display.hotplug.poll_init_work);828 spin_unlock_irq(&dev_priv->irq_lock);829}830 831/**832 * intel_hpd_poll_disable - disable polling for connectors with hpd833 * @dev_priv: i915 device instance834 *835 * This function disables polling for all connectors which support HPD.836 * Under certain conditions HPD may not be functional. On most Intel GPUs,837 * this happens when we enter runtime suspend.838 * On Valleyview and Cherryview systems, this also happens when we shut off all839 * of the powerwells.840 *841 * Since this function can get called in contexts where we're already holding842 * dev->mode_config.mutex, we do the actual hotplug enabling in a seperate843 * worker.844 *845 * Also used during driver init to initialize connector->polled846 * appropriately for all connectors.847 *848 * Also see: intel_hpd_init() and intel_hpd_poll_enable().849 */850void intel_hpd_poll_disable(struct drm_i915_private *dev_priv)851{852 if (!HAS_DISPLAY(dev_priv))853 return;854 855 WRITE_ONCE(dev_priv->display.hotplug.poll_enabled, false);856 857 spin_lock_irq(&dev_priv->irq_lock);858 queue_detection_work(dev_priv,859 &dev_priv->display.hotplug.poll_init_work);860 spin_unlock_irq(&dev_priv->irq_lock);861}862 863void intel_hpd_init_early(struct drm_i915_private *i915)864{865 INIT_DELAYED_WORK(&i915->display.hotplug.hotplug_work,866 i915_hotplug_work_func);867 INIT_WORK(&i915->display.hotplug.dig_port_work, i915_digport_work_func);868 INIT_WORK(&i915->display.hotplug.poll_init_work, i915_hpd_poll_init_work);869 INIT_DELAYED_WORK(&i915->display.hotplug.reenable_work,870 intel_hpd_irq_storm_reenable_work);871 872 i915->display.hotplug.hpd_storm_threshold = HPD_STORM_DEFAULT_THRESHOLD;873 /* If we have MST support, we want to avoid doing short HPD IRQ storm874 * detection, as short HPD storms will occur as a natural part of875 * sideband messaging with MST.876 * On older platforms however, IRQ storms can occur with both long and877 * short pulses, as seen on some G4x systems.878 */879 i915->display.hotplug.hpd_short_storm_enabled = !HAS_DP_MST(i915);880}881 882static bool cancel_all_detection_work(struct drm_i915_private *i915)883{884 bool was_pending = false;885 886 if (cancel_delayed_work_sync(&i915->display.hotplug.hotplug_work))887 was_pending = true;888 if (cancel_work_sync(&i915->display.hotplug.poll_init_work))889 was_pending = true;890 if (cancel_delayed_work_sync(&i915->display.hotplug.reenable_work))891 was_pending = true;892 893 return was_pending;894}895 896void intel_hpd_cancel_work(struct drm_i915_private *dev_priv)897{898 if (!HAS_DISPLAY(dev_priv))899 return;900 901 spin_lock_irq(&dev_priv->irq_lock);902 903 dev_priv->display.hotplug.long_port_mask = 0;904 dev_priv->display.hotplug.short_port_mask = 0;905 dev_priv->display.hotplug.event_bits = 0;906 dev_priv->display.hotplug.retry_bits = 0;907 908 spin_unlock_irq(&dev_priv->irq_lock);909 910 cancel_work_sync(&dev_priv->display.hotplug.dig_port_work);911 912 /*913 * All other work triggered by hotplug events should be canceled by914 * now.915 */916 if (cancel_all_detection_work(dev_priv))917 drm_dbg_kms(&dev_priv->drm, "Hotplug detection work still active\n");918}919 920bool intel_hpd_disable(struct drm_i915_private *dev_priv, enum hpd_pin pin)921{922 bool ret = false;923 924 if (pin == HPD_NONE)925 return false;926 927 spin_lock_irq(&dev_priv->irq_lock);928 if (dev_priv->display.hotplug.stats[pin].state == HPD_ENABLED) {929 dev_priv->display.hotplug.stats[pin].state = HPD_DISABLED;930 ret = true;931 }932 spin_unlock_irq(&dev_priv->irq_lock);933 934 return ret;935}936 937void intel_hpd_enable(struct drm_i915_private *dev_priv, enum hpd_pin pin)938{939 if (pin == HPD_NONE)940 return;941 942 spin_lock_irq(&dev_priv->irq_lock);943 dev_priv->display.hotplug.stats[pin].state = HPD_ENABLED;944 spin_unlock_irq(&dev_priv->irq_lock);945}946 947static void queue_work_for_missed_irqs(struct drm_i915_private *i915)948{949 bool queue_work = false;950 enum hpd_pin pin;951 952 lockdep_assert_held(&i915->irq_lock);953 954 if (i915->display.hotplug.event_bits ||955 i915->display.hotplug.retry_bits)956 queue_work = true;957 958 for_each_hpd_pin(pin) {959 switch (i915->display.hotplug.stats[pin].state) {960 case HPD_MARK_DISABLED:961 queue_work = true;962 break;963 case HPD_ENABLED:964 break;965 default:966 MISSING_CASE(i915->display.hotplug.stats[pin].state);967 }968 }969 970 if (queue_work)971 queue_delayed_detection_work(i915, &i915->display.hotplug.hotplug_work, 0);972}973 974void intel_hpd_enable_detection_work(struct drm_i915_private *i915)975{976 spin_lock_irq(&i915->irq_lock);977 i915->display.hotplug.detection_work_enabled = true;978 queue_work_for_missed_irqs(i915);979 spin_unlock_irq(&i915->irq_lock);980}981 982void intel_hpd_disable_detection_work(struct drm_i915_private *i915)983{984 spin_lock_irq(&i915->irq_lock);985 i915->display.hotplug.detection_work_enabled = false;986 spin_unlock_irq(&i915->irq_lock);987 988 cancel_all_detection_work(i915);989}990 991bool intel_hpd_schedule_detection(struct drm_i915_private *i915)992{993 unsigned long flags;994 bool ret;995 996 spin_lock_irqsave(&i915->irq_lock, flags);997 ret = queue_delayed_detection_work(i915, &i915->display.hotplug.hotplug_work, 0);998 spin_unlock_irqrestore(&i915->irq_lock, flags);999 1000 return ret;1001}1002 1003static int i915_hpd_storm_ctl_show(struct seq_file *m, void *data)1004{1005 struct drm_i915_private *dev_priv = m->private;1006 struct intel_hotplug *hotplug = &dev_priv->display.hotplug;1007 1008 /* Synchronize with everything first in case there's been an HPD1009 * storm, but we haven't finished handling it in the kernel yet1010 */1011 intel_synchronize_irq(dev_priv);1012 flush_work(&dev_priv->display.hotplug.dig_port_work);1013 flush_delayed_work(&dev_priv->display.hotplug.hotplug_work);1014 1015 seq_printf(m, "Threshold: %d\n", hotplug->hpd_storm_threshold);1016 seq_printf(m, "Detected: %s\n",1017 str_yes_no(delayed_work_pending(&hotplug->reenable_work)));1018 1019 return 0;1020}1021 1022static ssize_t i915_hpd_storm_ctl_write(struct file *file,1023 const char __user *ubuf, size_t len,1024 loff_t *offp)1025{1026 struct seq_file *m = file->private_data;1027 struct drm_i915_private *dev_priv = m->private;1028 struct intel_hotplug *hotplug = &dev_priv->display.hotplug;1029 unsigned int new_threshold;1030 int i;1031 char *newline;1032 char tmp[16];1033 1034 if (len >= sizeof(tmp))1035 return -EINVAL;1036 1037 if (copy_from_user(tmp, ubuf, len))1038 return -EFAULT;1039 1040 tmp[len] = '\0';1041 1042 /* Strip newline, if any */1043 newline = strchr(tmp, '\n');1044 if (newline)1045 *newline = '\0';1046 1047 if (strcmp(tmp, "reset") == 0)1048 new_threshold = HPD_STORM_DEFAULT_THRESHOLD;1049 else if (kstrtouint(tmp, 10, &new_threshold) != 0)1050 return -EINVAL;1051 1052 if (new_threshold > 0)1053 drm_dbg_kms(&dev_priv->drm,1054 "Setting HPD storm detection threshold to %d\n",1055 new_threshold);1056 else1057 drm_dbg_kms(&dev_priv->drm, "Disabling HPD storm detection\n");1058 1059 spin_lock_irq(&dev_priv->irq_lock);1060 hotplug->hpd_storm_threshold = new_threshold;1061 /* Reset the HPD storm stats so we don't accidentally trigger a storm */1062 for_each_hpd_pin(i)1063 hotplug->stats[i].count = 0;1064 spin_unlock_irq(&dev_priv->irq_lock);1065 1066 /* Re-enable hpd immediately if we were in an irq storm */1067 flush_delayed_work(&dev_priv->display.hotplug.reenable_work);1068 1069 return len;1070}1071 1072static int i915_hpd_storm_ctl_open(struct inode *inode, struct file *file)1073{1074 return single_open(file, i915_hpd_storm_ctl_show, inode->i_private);1075}1076 1077static const struct file_operations i915_hpd_storm_ctl_fops = {1078 .owner = THIS_MODULE,1079 .open = i915_hpd_storm_ctl_open,1080 .read = seq_read,1081 .llseek = seq_lseek,1082 .release = single_release,1083 .write = i915_hpd_storm_ctl_write1084};1085 1086static int i915_hpd_short_storm_ctl_show(struct seq_file *m, void *data)1087{1088 struct drm_i915_private *dev_priv = m->private;1089 1090 seq_printf(m, "Enabled: %s\n",1091 str_yes_no(dev_priv->display.hotplug.hpd_short_storm_enabled));1092 1093 return 0;1094}1095 1096static int1097i915_hpd_short_storm_ctl_open(struct inode *inode, struct file *file)1098{1099 return single_open(file, i915_hpd_short_storm_ctl_show,1100 inode->i_private);1101}1102 1103static ssize_t i915_hpd_short_storm_ctl_write(struct file *file,1104 const char __user *ubuf,1105 size_t len, loff_t *offp)1106{1107 struct seq_file *m = file->private_data;1108 struct drm_i915_private *dev_priv = m->private;1109 struct intel_hotplug *hotplug = &dev_priv->display.hotplug;1110 char *newline;1111 char tmp[16];1112 int i;1113 bool new_state;1114 1115 if (len >= sizeof(tmp))1116 return -EINVAL;1117 1118 if (copy_from_user(tmp, ubuf, len))1119 return -EFAULT;1120 1121 tmp[len] = '\0';1122 1123 /* Strip newline, if any */1124 newline = strchr(tmp, '\n');1125 if (newline)1126 *newline = '\0';1127 1128 /* Reset to the "default" state for this system */1129 if (strcmp(tmp, "reset") == 0)1130 new_state = !HAS_DP_MST(dev_priv);1131 else if (kstrtobool(tmp, &new_state) != 0)1132 return -EINVAL;1133 1134 drm_dbg_kms(&dev_priv->drm, "%sabling HPD short storm detection\n",1135 new_state ? "En" : "Dis");1136 1137 spin_lock_irq(&dev_priv->irq_lock);1138 hotplug->hpd_short_storm_enabled = new_state;1139 /* Reset the HPD storm stats so we don't accidentally trigger a storm */1140 for_each_hpd_pin(i)1141 hotplug->stats[i].count = 0;1142 spin_unlock_irq(&dev_priv->irq_lock);1143 1144 /* Re-enable hpd immediately if we were in an irq storm */1145 flush_delayed_work(&dev_priv->display.hotplug.reenable_work);1146 1147 return len;1148}1149 1150static const struct file_operations i915_hpd_short_storm_ctl_fops = {1151 .owner = THIS_MODULE,1152 .open = i915_hpd_short_storm_ctl_open,1153 .read = seq_read,1154 .llseek = seq_lseek,1155 .release = single_release,1156 .write = i915_hpd_short_storm_ctl_write,1157};1158 1159void intel_hpd_debugfs_register(struct drm_i915_private *i915)1160{1161 struct drm_minor *minor = i915->drm.primary;1162 1163 debugfs_create_file("i915_hpd_storm_ctl", 0644, minor->debugfs_root,1164 i915, &i915_hpd_storm_ctl_fops);1165 debugfs_create_file("i915_hpd_short_storm_ctl", 0644, minor->debugfs_root,1166 i915, &i915_hpd_short_storm_ctl_fops);1167 debugfs_create_bool("i915_ignore_long_hpd", 0644, minor->debugfs_root,1168 &i915->display.hotplug.ignore_long_hpd);1169}1170