/* * Copyright © 2015 Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. */ #include <linux/kernel.h> #include <drm/i915_drm.h> #include "i915_drv.h"#include "intel_drv.h" /** * DOC: Hotplug * * Simply put, hotplug occurs when a display is connected to or disconnected * from the system. However, there may be adapters and docking stations and * Display Port short pulses and MST devices involved, complicating matters. * * Hotplug in i915 is handled in many different levels of abstraction. * * The platform dependent interrupt handling code in i915_irq.c enables, * disables, and does preliminary handling of the interrupts. The interrupt * handlers gather the hotplug detect (HPD) information from relevant registers * into a platform independent mask of hotplug pins that have fired. * * The platform independent interrupt handler intel_hpd_irq_handler() in * intel_hotplug.c does hotplug irq storm detection and mitigation, and passes * further processing to appropriate bottom halves (Display Port specific and * regular hotplug). * * The Display Port work function i915_digport_work_func() calls into * intel_dp_hpd_pulse() via hooks, which handles DP short pulses and DP MST long * pulses, with failures and non-MST long pulses triggering regular hotplug * processing on the connector. * * The regular hotplug work function i915_hotplug_work_func() calls connector * detect hooks, and, if connector status changes, triggers sending of hotplug * uevent to userspace via drm_kms_helper_hotplug_event(). * * Finally, the userspace is responsible for triggering a modeset upon receiving * the hotplug uevent, disabling or enabling the crtc as needed. * * The hotplug interrupt storm detection and mitigation code keeps track of the * number of interrupts per hotplug pin per a period of time, and if the number * of interrupts exceeds a certain threshold, the interrupt is disabled for a * while before being re-enabled. The intention is to mitigate issues raising * from broken hardware triggering massive amounts of interrupts and grinding * the system to a halt. * * Current implementation expects that hotplug interrupt storm will not be * seen when display port sink is connected, hence on platforms whose DP * callback is handled by i915_digport_work_func reenabling of hpd is not * performed (it was never expected to be disabled in the first place ;) ) * this is specific to DP sinks handled by this routine and any other display * such as HDMI or DVI enabled on the same port will have proper logic since * it will use i915_hotplug_work_func where this logic is handled. */ /** * intel_hpd_pin_default - return default pin associated with certain port. * @dev_priv: private driver data pointer * @port: the hpd port to get associated pin * * It is only valid and used by digital port encoder. * * Return pin that is associatade with @port and HDP_NONE if no pin is * hard associated with that @port. */enum hpd_pin intel_hpd_pin_default(struct drm_i915_private *dev_priv,				   enum port port){	switch (port) {	case PORT_A:		return HPD_PORT_A;	case PORT_B:		return HPD_PORT_B;	case PORT_C:		return HPD_PORT_C;	case PORT_D:		return HPD_PORT_D;	case PORT_E:		return HPD_PORT_E;	case PORT_F:		if (IS_CNL_WITH_PORT_F(dev_priv))			return HPD_PORT_E;		return HPD_PORT_F;	default:		MISSING_CASE(port);		return HPD_NONE;	}} #define HPD_STORM_DETECT_PERIOD		1000#define HPD_STORM_REENABLE_DELAY	(2 * 60 * 1000) /** * intel_hpd_irq_storm_detect - gather stats and detect HPD IRQ storm on a pin * @dev_priv: private driver data pointer * @pin: the pin to gather stats on * @long_hpd: whether the HPD IRQ was long or short * * Gather stats about HPD IRQs from the specified @pin, and detect IRQ * storms. Only the pin specific stats and state are changed, the caller is * responsible for further action. * * The number of IRQs that are allowed within @HPD_STORM_DETECT_PERIOD is * stored in @dev_priv->hotplug.hpd_storm_threshold which defaults to * @HPD_STORM_DEFAULT_THRESHOLD. Long IRQs count as +10 to this threshold, and * short IRQs count as +1. If this threshold is exceeded, it's considered an * IRQ storm and the IRQ state is set to @HPD_MARK_DISABLED. * * By default, most systems will only count long IRQs towards * &dev_priv->hotplug.hpd_storm_threshold. However, some older systems also * suffer from short IRQ storms and must also track these. Because short IRQ * storms are naturally caused by sideband interactions with DP MST devices, * short IRQ detection is only enabled for systems without DP MST support. * Systems which are new enough to support DP MST are far less likely to * suffer from IRQ storms at all, so this is fine. * * The HPD threshold can be controlled through i915_hpd_storm_ctl in debugfs, * and should only be adjusted for automated hotplug testing. * * Return true if an IRQ storm was detected on @pin. */static bool intel_hpd_irq_storm_detect(struct drm_i915_private *dev_priv,				       enum hpd_pin pin, bool long_hpd){	struct i915_hotplug *hpd = &dev_priv->hotplug;	unsigned long start = hpd->stats[pin].last_jiffies;	unsigned long end = start + msecs_to_jiffies(HPD_STORM_DETECT_PERIOD);	const int increment = long_hpd ? 10 : 1;	const int threshold = hpd->hpd_storm_threshold;	bool storm = false; 	if (!threshold ||	    (!long_hpd && !dev_priv->hotplug.hpd_short_storm_enabled))		return false; 	if (!time_in_range(jiffies, start, end)) {		hpd->stats[pin].last_jiffies = jiffies;		hpd->stats[pin].count = 0;	} 	hpd->stats[pin].count += increment;	if (hpd->stats[pin].count > threshold) {		hpd->stats[pin].state = HPD_MARK_DISABLED;		DRM_DEBUG_KMS("HPD interrupt storm detected on PIN %d\n", pin);		storm = true;	} else {		DRM_DEBUG_KMS("Received HPD interrupt on PIN %d - cnt: %d\n", pin,			      hpd->stats[pin].count);	} 	return storm;} static voidintel_hpd_irq_storm_switch_to_polling(struct drm_i915_private *dev_priv){	struct drm_device *dev = &dev_priv->drm;	struct intel_connector *intel_connector;	struct intel_encoder *intel_encoder;	struct drm_connector *connector;	struct drm_connector_list_iter conn_iter;	enum hpd_pin pin;	bool hpd_disabled = false; 	lockdep_assert_held(&dev_priv->irq_lock); 	drm_connector_list_iter_begin(dev, &conn_iter);	drm_for_each_connector_iter(connector, &conn_iter) {		if (connector->polled != DRM_CONNECTOR_POLL_HPD)			continue; 		intel_connector = to_intel_connector(connector);		intel_encoder = intel_connector->encoder;		if (!intel_encoder)			continue; 		pin = intel_encoder->hpd_pin;		if (pin == HPD_NONE ||		    dev_priv->hotplug.stats[pin].state != HPD_MARK_DISABLED)			continue; 		DRM_INFO("HPD interrupt storm detected on connector %s: "			 "switching from hotplug detection to polling\n",			 connector->name); 		dev_priv->hotplug.stats[pin].state = HPD_DISABLED;		connector->polled = DRM_CONNECTOR_POLL_CONNECT			| DRM_CONNECTOR_POLL_DISCONNECT;		hpd_disabled = true;	}	drm_connector_list_iter_end(&conn_iter); 	/* Enable polling and queue hotplug re-enabling. */	if (hpd_disabled) {		drm_kms_helper_poll_enable(dev);		mod_delayed_work(system_wq, &dev_priv->hotplug.reenable_work,				 msecs_to_jiffies(HPD_STORM_REENABLE_DELAY));	}} static void intel_hpd_irq_storm_reenable_work(struct work_struct *work){	struct drm_i915_private *dev_priv =		container_of(work, typeof(*dev_priv),			     hotplug.reenable_work.work);	struct drm_device *dev = &dev_priv->drm;	intel_wakeref_t wakeref;	enum hpd_pin pin; 	wakeref = intel_runtime_pm_get(dev_priv); 	spin_lock_irq(&dev_priv->irq_lock);	for_each_hpd_pin(pin) {		struct drm_connector *connector;		struct drm_connector_list_iter conn_iter; 		if (dev_priv->hotplug.stats[pin].state != HPD_DISABLED)			continue; 		dev_priv->hotplug.stats[pin].state = HPD_ENABLED; 		drm_connector_list_iter_begin(dev, &conn_iter);		drm_for_each_connector_iter(connector, &conn_iter) {			struct intel_connector *intel_connector = to_intel_connector(connector); 			/* Don't check MST ports, they don't have pins */			if (!intel_connector->mst_port &&			    intel_connector->encoder->hpd_pin == pin) {				if (connector->polled != intel_connector->polled)					DRM_DEBUG_DRIVER("Reenabling HPD on connector %s\n",							 connector->name);				connector->polled = intel_connector->polled;				if (!connector->polled)					connector->polled = DRM_CONNECTOR_POLL_HPD;			}		}		drm_connector_list_iter_end(&conn_iter);	}	if (dev_priv->display_irqs_enabled && dev_priv->display.hpd_irq_setup)		dev_priv->display.hpd_irq_setup(dev_priv);	spin_unlock_irq(&dev_priv->irq_lock); 	intel_runtime_pm_put(dev_priv, wakeref);} bool intel_encoder_hotplug(struct intel_encoder *encoder,			   struct intel_connector *connector){	struct drm_device *dev = connector->base.dev;	enum drm_connector_status old_status; 	WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));	old_status = connector->base.status; 	connector->base.status =		drm_helper_probe_detect(&connector->base, NULL, false); 	if (old_status == connector->base.status)		return false; 	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",		      connector->base.base.id,		      connector->base.name,		      drm_get_connector_status_name(old_status),		      drm_get_connector_status_name(connector->base.status)); 	return true;} static bool intel_encoder_has_hpd_pulse(struct intel_encoder *encoder){	return intel_encoder_is_dig_port(encoder) &&		enc_to_dig_port(&encoder->base)->hpd_pulse != NULL;} static void i915_digport_work_func(struct work_struct *work){	struct drm_i915_private *dev_priv =		container_of(work, struct drm_i915_private, hotplug.dig_port_work);	u32 long_port_mask, short_port_mask;	struct intel_encoder *encoder;	u32 old_bits = 0; 	spin_lock_irq(&dev_priv->irq_lock);	long_port_mask = dev_priv->hotplug.long_port_mask;	dev_priv->hotplug.long_port_mask = 0;	short_port_mask = dev_priv->hotplug.short_port_mask;	dev_priv->hotplug.short_port_mask = 0;	spin_unlock_irq(&dev_priv->irq_lock); 	for_each_intel_encoder(&dev_priv->drm, encoder) {		struct intel_digital_port *dig_port;		enum port port = encoder->port;		bool long_hpd, short_hpd;		enum irqreturn ret; 		if (!intel_encoder_has_hpd_pulse(encoder))			continue; 		long_hpd = long_port_mask & BIT(port);		short_hpd = short_port_mask & BIT(port); 		if (!long_hpd && !short_hpd)			continue; 		dig_port = enc_to_dig_port(&encoder->base); 		ret = dig_port->hpd_pulse(dig_port, long_hpd);		if (ret == IRQ_NONE) {			/* fall back to old school hpd */			old_bits |= BIT(encoder->hpd_pin);		}	} 	if (old_bits) {		spin_lock_irq(&dev_priv->irq_lock);		dev_priv->hotplug.event_bits |= old_bits;		spin_unlock_irq(&dev_priv->irq_lock);		schedule_work(&dev_priv->hotplug.hotplug_work);	}} /* * Handle hotplug events outside the interrupt handler proper. */static void i915_hotplug_work_func(struct work_struct *work){	struct drm_i915_private *dev_priv =		container_of(work, struct drm_i915_private, hotplug.hotplug_work);	struct drm_device *dev = &dev_priv->drm;	struct intel_connector *intel_connector;	struct intel_encoder *intel_encoder;	struct drm_connector *connector;	struct drm_connector_list_iter conn_iter;	bool changed = false;	u32 hpd_event_bits; 	mutex_lock(&dev->mode_config.mutex);	DRM_DEBUG_KMS("running encoder hotplug functions\n"); 	spin_lock_irq(&dev_priv->irq_lock); 	hpd_event_bits = dev_priv->hotplug.event_bits;	dev_priv->hotplug.event_bits = 0; 	/* Enable polling for connectors which had HPD IRQ storms */	intel_hpd_irq_storm_switch_to_polling(dev_priv); 	spin_unlock_irq(&dev_priv->irq_lock); 	drm_connector_list_iter_begin(dev, &conn_iter);	drm_for_each_connector_iter(connector, &conn_iter) {		intel_connector = to_intel_connector(connector);		if (!intel_connector->encoder)			continue;		intel_encoder = intel_connector->encoder;		if (hpd_event_bits & (1 << intel_encoder->hpd_pin)) {			DRM_DEBUG_KMS("Connector %s (pin %i) received hotplug event.\n",				      connector->name, intel_encoder->hpd_pin); 			changed |= intel_encoder->hotplug(intel_encoder,							  intel_connector);		}	}	drm_connector_list_iter_end(&conn_iter);	mutex_unlock(&dev->mode_config.mutex); 	if (changed)		drm_kms_helper_hotplug_event(dev);}  /** * intel_hpd_irq_handler - main hotplug irq handler * @dev_priv: drm_i915_private * @pin_mask: a mask of hpd pins that have triggered the irq * @long_mask: a mask of hpd pins that may be long hpd pulses * * This is the main hotplug irq handler for all platforms. The platform specific * irq handlers call the platform specific hotplug irq handlers, which read and * decode the appropriate registers into bitmasks about hpd pins that have * triggered (@pin_mask), and which of those pins may be long pulses * (@long_mask). The @long_mask is ignored if the port corresponding to the pin * is not a digital port. * * Here, we do hotplug irq storm detection and mitigation, and pass further * processing to appropriate bottom halves. */void intel_hpd_irq_handler(struct drm_i915_private *dev_priv,			   u32 pin_mask, u32 long_mask){	struct intel_encoder *encoder;	bool storm_detected = false;	bool queue_dig = false, queue_hp = false;	u32 long_hpd_pulse_mask = 0;	u32 short_hpd_pulse_mask = 0;	enum hpd_pin pin; 	if (!pin_mask)		return; 	spin_lock(&dev_priv->irq_lock); 	/*	 * Determine whether ->hpd_pulse() exists for each pin, and	 * whether we have a short or a long pulse. This is needed	 * as each pin may have up to two encoders (HDMI and DP) and	 * only the one of them (DP) will have ->hpd_pulse().	 */	for_each_intel_encoder(&dev_priv->drm, encoder) {		bool has_hpd_pulse = intel_encoder_has_hpd_pulse(encoder);		enum port port = encoder->port;		bool long_hpd; 		pin = encoder->hpd_pin;		if (!(BIT(pin) & pin_mask))			continue; 		if (!has_hpd_pulse)			continue; 		long_hpd = long_mask & BIT(pin); 		DRM_DEBUG_DRIVER("digital hpd port %c - %s\n", port_name(port),				 long_hpd ? "long" : "short");		queue_dig = true; 		if (long_hpd) {			long_hpd_pulse_mask |= BIT(pin);			dev_priv->hotplug.long_port_mask |= BIT(port);		} else {			short_hpd_pulse_mask |= BIT(pin);			dev_priv->hotplug.short_port_mask |= BIT(port);		}	} 	/* Now process each pin just once */	for_each_hpd_pin(pin) {		bool long_hpd; 		if (!(BIT(pin) & pin_mask))			continue; 		if (dev_priv->hotplug.stats[pin].state == HPD_DISABLED) {			/*			 * On GMCH platforms the interrupt mask bits only			 * prevent irq generation, not the setting of the			 * hotplug bits itself. So only WARN about unexpected			 * interrupts on saner platforms.			 */			WARN_ONCE(!HAS_GMCH(dev_priv),				  "Received HPD interrupt on pin %d although disabled\n", pin);			continue;		} 		if (dev_priv->hotplug.stats[pin].state != HPD_ENABLED)			continue; 		/*		 * Delegate to ->hpd_pulse() if one of the encoders for this		 * pin has it, otherwise let the hotplug_work deal with this		 * pin directly.		 */		if (((short_hpd_pulse_mask | long_hpd_pulse_mask) & BIT(pin))) {			long_hpd = long_hpd_pulse_mask & BIT(pin);		} else {			dev_priv->hotplug.event_bits |= BIT(pin);			long_hpd = true;			queue_hp = true;		} 		if (intel_hpd_irq_storm_detect(dev_priv, pin, long_hpd)) {			dev_priv->hotplug.event_bits &= ~BIT(pin);			storm_detected = true;			queue_hp = true;		}	} 

Lines 1–500 of 686. Load more