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 "i915_irq.h"
28 #include "intel_display_types.h"
29 #include "intel_hotplug.h"
30 #include "intel_hotplug_irq.h"
31 
32 /**
33  * DOC: Hotplug
34  *
35  * Simply put, hotplug occurs when a display is connected to or disconnected
36  * from the system. However, there may be adapters and docking stations and
37  * Display Port short pulses and MST devices involved, complicating matters.
38  *
39  * Hotplug in i915 is handled in many different levels of abstraction.
40  *
41  * The platform dependent interrupt handling code in i915_irq.c enables,
42  * disables, and does preliminary handling of the interrupts. The interrupt
43  * handlers gather the hotplug detect (HPD) information from relevant registers
44  * into a platform independent mask of hotplug pins that have fired.
45  *
46  * The platform independent interrupt handler intel_hpd_irq_handler() in
47  * intel_hotplug.c does hotplug irq storm detection and mitigation, and passes
48  * further processing to appropriate bottom halves (Display Port specific and
49  * regular hotplug).
50  *
51  * The Display Port work function i915_digport_work_func() calls into
52  * intel_dp_hpd_pulse() via hooks, which handles DP short pulses and DP MST long
53  * pulses, with failures and non-MST long pulses triggering regular hotplug
54  * processing on the connector.
55  *
56  * The regular hotplug work function i915_hotplug_work_func() calls connector
57  * detect hooks, and, if connector status changes, triggers sending of hotplug
58  * uevent to userspace via drm_kms_helper_hotplug_event().
59  *
60  * Finally, the userspace is responsible for triggering a modeset upon receiving
61  * the hotplug uevent, disabling or enabling the crtc as needed.
62  *
63  * The hotplug interrupt storm detection and mitigation code keeps track of the
64  * number of interrupts per hotplug pin per a period of time, and if the number
65  * of interrupts exceeds a certain threshold, the interrupt is disabled for a
66  * while before being re-enabled. The intention is to mitigate issues raising
67  * from broken hardware triggering massive amounts of interrupts and grinding
68  * the system to a halt.
69  *
70  * Current implementation expects that hotplug interrupt storm will not be
71  * seen when display port sink is connected, hence on platforms whose DP
72  * callback is handled by i915_digport_work_func reenabling of hpd is not
73  * performed (it was never expected to be disabled in the first place ;) )
74  * this is specific to DP sinks handled by this routine and any other display
75  * such as HDMI or DVI enabled on the same port will have proper logic since
76  * it will use i915_hotplug_work_func where this logic is handled.
77  */
78 
79 /**
80  * intel_hpd_pin_default - return default pin associated with certain port.
81  * @dev_priv: private driver data pointer
82  * @port: the hpd port to get associated pin
83  *
84  * It is only valid and used by digital port encoder.
85  *
86  * Return pin that is associatade with @port.
87  */
intel_hpd_pin_default(struct drm_i915_private * dev_priv,enum port port)88 enum hpd_pin intel_hpd_pin_default(struct drm_i915_private *dev_priv,
89 				   enum port port)
90 {
91 	return HPD_PORT_A + port - PORT_A;
92 }
93 
94 /* Threshold == 5 for long IRQs, 50 for short */
95 #define HPD_STORM_DEFAULT_THRESHOLD	50
96 
97 #define HPD_STORM_DETECT_PERIOD		1000
98 #define HPD_STORM_REENABLE_DELAY	(2 * 60 * 1000)
99 #define HPD_RETRY_DELAY			1000
100 
101 static enum hpd_pin
intel_connector_hpd_pin(struct intel_connector * connector)102 intel_connector_hpd_pin(struct intel_connector *connector)
103 {
104 	struct intel_encoder *encoder = intel_attached_encoder(connector);
105 
106 	/*
107 	 * MST connectors get their encoder attached dynamically
108 	 * so need to make sure we have an encoder here. But since
109 	 * MST encoders have their hpd_pin set to HPD_NONE we don't
110 	 * have to special case them beyond that.
111 	 */
112 	return encoder ? encoder->hpd_pin : HPD_NONE;
113 }
114 
115 /**
116  * intel_hpd_irq_storm_detect - gather stats and detect HPD IRQ storm on a pin
117  * @dev_priv: private driver data pointer
118  * @pin: the pin to gather stats on
119  * @long_hpd: whether the HPD IRQ was long or short
120  *
121  * Gather stats about HPD IRQs from the specified @pin, and detect IRQ
122  * storms. Only the pin specific stats and state are changed, the caller is
123  * responsible for further action.
124  *
125  * The number of IRQs that are allowed within @HPD_STORM_DETECT_PERIOD is
126  * stored in @dev_priv->display.hotplug.hpd_storm_threshold which defaults to
127  * @HPD_STORM_DEFAULT_THRESHOLD. Long IRQs count as +10 to this threshold, and
128  * short IRQs count as +1. If this threshold is exceeded, it's considered an
129  * IRQ storm and the IRQ state is set to @HPD_MARK_DISABLED.
130  *
131  * By default, most systems will only count long IRQs towards
132  * &dev_priv->display.hotplug.hpd_storm_threshold. However, some older systems also
133  * suffer from short IRQ storms and must also track these. Because short IRQ
134  * storms are naturally caused by sideband interactions with DP MST devices,
135  * short IRQ detection is only enabled for systems without DP MST support.
136  * Systems which are new enough to support DP MST are far less likely to
137  * suffer from IRQ storms at all, so this is fine.
138  *
139  * The HPD threshold can be controlled through i915_hpd_storm_ctl in debugfs,
140  * and should only be adjusted for automated hotplug testing.
141  *
142  * Return true if an IRQ storm was detected on @pin.
143  */
intel_hpd_irq_storm_detect(struct drm_i915_private * dev_priv,enum hpd_pin pin,bool long_hpd)144 static bool intel_hpd_irq_storm_detect(struct drm_i915_private *dev_priv,
145 				       enum hpd_pin pin, bool long_hpd)
146 {
147 	struct intel_hotplug *hpd = &dev_priv->display.hotplug;
148 	unsigned long start = hpd->stats[pin].last_jiffies;
149 	unsigned long end = start + msecs_to_jiffies(HPD_STORM_DETECT_PERIOD);
150 	const int increment = long_hpd ? 10 : 1;
151 	const int threshold = hpd->hpd_storm_threshold;
152 	bool storm = false;
153 
154 	if (!threshold ||
155 	    (!long_hpd && !dev_priv->display.hotplug.hpd_short_storm_enabled))
156 		return false;
157 
158 	if (!time_in_range(jiffies, start, end)) {
159 		hpd->stats[pin].last_jiffies = jiffies;
160 		hpd->stats[pin].count = 0;
161 	}
162 
163 	hpd->stats[pin].count += increment;
164 	if (hpd->stats[pin].count > threshold) {
165 		hpd->stats[pin].state = HPD_MARK_DISABLED;
166 		drm_dbg_kms(&dev_priv->drm,
167 			    "HPD interrupt storm detected on PIN %d\n", pin);
168 		storm = true;
169 	} else {
170 		drm_dbg_kms(&dev_priv->drm,
171 			    "Received HPD interrupt on PIN %d - cnt: %d\n",
172 			      pin,
173 			      hpd->stats[pin].count);
174 	}
175 
176 	return storm;
177 }
178 
179 static void
intel_hpd_irq_storm_switch_to_polling(struct drm_i915_private * dev_priv)180 intel_hpd_irq_storm_switch_to_polling(struct drm_i915_private *dev_priv)
181 {
182 	struct drm_connector_list_iter conn_iter;
183 	struct intel_connector *connector;
184 	bool hpd_disabled = false;
185 
186 	lockdep_assert_held(&dev_priv->irq_lock);
187 
188 	drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);
189 	for_each_intel_connector_iter(connector, &conn_iter) {
190 		enum hpd_pin pin;
191 
192 		if (connector->base.polled != DRM_CONNECTOR_POLL_HPD)
193 			continue;
194 
195 		pin = intel_connector_hpd_pin(connector);
196 		if (pin == HPD_NONE ||
197 		    dev_priv->display.hotplug.stats[pin].state != HPD_MARK_DISABLED)
198 			continue;
199 
200 		drm_info(&dev_priv->drm,
201 			 "HPD interrupt storm detected on connector %s: "
202 			 "switching from hotplug detection to polling\n",
203 			 connector->base.name);
204 
205 		dev_priv->display.hotplug.stats[pin].state = HPD_DISABLED;
206 		connector->base.polled = DRM_CONNECTOR_POLL_CONNECT |
207 			DRM_CONNECTOR_POLL_DISCONNECT;
208 		hpd_disabled = true;
209 	}
210 	drm_connector_list_iter_end(&conn_iter);
211 
212 	/* Enable polling and queue hotplug re-enabling. */
213 	if (hpd_disabled) {
214 		drm_kms_helper_poll_reschedule(&dev_priv->drm);
215 		mod_delayed_work(dev_priv->unordered_wq,
216 				 &dev_priv->display.hotplug.reenable_work,
217 				 msecs_to_jiffies(HPD_STORM_REENABLE_DELAY));
218 	}
219 }
220 
intel_hpd_irq_storm_reenable_work(struct work_struct * work)221 static void intel_hpd_irq_storm_reenable_work(struct work_struct *work)
222 {
223 	struct drm_i915_private *dev_priv =
224 		container_of(work, typeof(*dev_priv),
225 			     display.hotplug.reenable_work.work);
226 	struct drm_connector_list_iter conn_iter;
227 	struct intel_connector *connector;
228 	intel_wakeref_t wakeref;
229 	enum hpd_pin pin;
230 
231 	wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
232 
233 	spin_lock_irq(&dev_priv->irq_lock);
234 
235 	drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);
236 	for_each_intel_connector_iter(connector, &conn_iter) {
237 		pin = intel_connector_hpd_pin(connector);
238 		if (pin == HPD_NONE ||
239 		    dev_priv->display.hotplug.stats[pin].state != HPD_DISABLED)
240 			continue;
241 
242 		if (connector->base.polled != connector->polled)
243 			drm_dbg(&dev_priv->drm,
244 				"Reenabling HPD on connector %s\n",
245 				connector->base.name);
246 		connector->base.polled = connector->polled;
247 	}
248 	drm_connector_list_iter_end(&conn_iter);
249 
250 	for_each_hpd_pin(pin) {
251 		if (dev_priv->display.hotplug.stats[pin].state == HPD_DISABLED)
252 			dev_priv->display.hotplug.stats[pin].state = HPD_ENABLED;
253 	}
254 
255 	intel_hpd_irq_setup(dev_priv);
256 
257 	spin_unlock_irq(&dev_priv->irq_lock);
258 
259 	intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
260 }
261 
262 enum intel_hotplug_state
intel_encoder_hotplug(struct intel_encoder * encoder,struct intel_connector * connector)263 intel_encoder_hotplug(struct intel_encoder *encoder,
264 		      struct intel_connector *connector)
265 {
266 	struct drm_device *dev = connector->base.dev;
267 	enum drm_connector_status old_status;
268 	u64 old_epoch_counter;
269 	bool ret = false;
270 
271 	drm_WARN_ON(dev, !mutex_is_locked(&dev->mode_config.mutex));
272 	old_status = connector->base.status;
273 	old_epoch_counter = connector->base.epoch_counter;
274 
275 	connector->base.status =
276 		drm_helper_probe_detect(&connector->base, NULL, false);
277 
278 	if (old_epoch_counter != connector->base.epoch_counter)
279 		ret = true;
280 
281 	if (ret) {
282 		drm_dbg_kms(dev, "[CONNECTOR:%d:%s] status updated from %s to %s (epoch counter %llu->%llu)\n",
283 			    connector->base.base.id,
284 			    connector->base.name,
285 			    drm_get_connector_status_name(old_status),
286 			    drm_get_connector_status_name(connector->base.status),
287 			    old_epoch_counter,
288 			    connector->base.epoch_counter);
289 		return INTEL_HOTPLUG_CHANGED;
290 	}
291 	return INTEL_HOTPLUG_UNCHANGED;
292 }
293 
intel_encoder_has_hpd_pulse(struct intel_encoder * encoder)294 static bool intel_encoder_has_hpd_pulse(struct intel_encoder *encoder)
295 {
296 	return intel_encoder_is_dig_port(encoder) &&
297 		enc_to_dig_port(encoder)->hpd_pulse != NULL;
298 }
299 
i915_digport_work_func(struct work_struct * work)300 static void i915_digport_work_func(struct work_struct *work)
301 {
302 	struct drm_i915_private *dev_priv =
303 		container_of(work, struct drm_i915_private, display.hotplug.dig_port_work);
304 	u32 long_port_mask, short_port_mask;
305 	struct intel_encoder *encoder;
306 	u32 old_bits = 0;
307 
308 	spin_lock_irq(&dev_priv->irq_lock);
309 	long_port_mask = dev_priv->display.hotplug.long_port_mask;
310 	dev_priv->display.hotplug.long_port_mask = 0;
311 	short_port_mask = dev_priv->display.hotplug.short_port_mask;
312 	dev_priv->display.hotplug.short_port_mask = 0;
313 	spin_unlock_irq(&dev_priv->irq_lock);
314 
315 	for_each_intel_encoder(&dev_priv->drm, encoder) {
316 		struct intel_digital_port *dig_port;
317 		enum port port = encoder->port;
318 		bool long_hpd, short_hpd;
319 		enum irqreturn ret;
320 
321 		if (!intel_encoder_has_hpd_pulse(encoder))
322 			continue;
323 
324 		long_hpd = long_port_mask & BIT(port);
325 		short_hpd = short_port_mask & BIT(port);
326 
327 		if (!long_hpd && !short_hpd)
328 			continue;
329 
330 		dig_port = enc_to_dig_port(encoder);
331 
332 		ret = dig_port->hpd_pulse(dig_port, long_hpd);
333 		if (ret == IRQ_NONE) {
334 			/* fall back to old school hpd */
335 			old_bits |= BIT(encoder->hpd_pin);
336 		}
337 	}
338 
339 	if (old_bits) {
340 		spin_lock_irq(&dev_priv->irq_lock);
341 		dev_priv->display.hotplug.event_bits |= old_bits;
342 		spin_unlock_irq(&dev_priv->irq_lock);
343 		queue_delayed_work(dev_priv->unordered_wq,
344 				   &dev_priv->display.hotplug.hotplug_work, 0);
345 	}
346 }
347 
348 /**
349  * intel_hpd_trigger_irq - trigger an hpd irq event for a port
350  * @dig_port: digital port
351  *
352  * Trigger an HPD interrupt event for the given port, emulating a short pulse
353  * generated by the sink, and schedule the dig port work to handle it.
354  */
intel_hpd_trigger_irq(struct intel_digital_port * dig_port)355 void intel_hpd_trigger_irq(struct intel_digital_port *dig_port)
356 {
357 	struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);
358 
359 	spin_lock_irq(&i915->irq_lock);
360 	i915->display.hotplug.short_port_mask |= BIT(dig_port->base.port);
361 	spin_unlock_irq(&i915->irq_lock);
362 
363 	queue_work(i915->display.hotplug.dp_wq, &i915->display.hotplug.dig_port_work);
364 }
365 
366 /*
367  * Handle hotplug events outside the interrupt handler proper.
368  */
i915_hotplug_work_func(struct work_struct * work)369 static void i915_hotplug_work_func(struct work_struct *work)
370 {
371 	struct drm_i915_private *dev_priv =
372 		container_of(work, struct drm_i915_private,
373 			     display.hotplug.hotplug_work.work);
374 	struct drm_connector_list_iter conn_iter;
375 	struct intel_connector *connector;
376 	u32 changed = 0, retry = 0;
377 	u32 hpd_event_bits;
378 	u32 hpd_retry_bits;
379 	struct drm_connector *first_changed_connector = NULL;
380 	int changed_connectors = 0;
381 
382 	mutex_lock(&dev_priv->drm.mode_config.mutex);
383 	drm_dbg_kms(&dev_priv->drm, "running encoder hotplug functions\n");
384 
385 	spin_lock_irq(&dev_priv->irq_lock);
386 
387 	hpd_event_bits = dev_priv->display.hotplug.event_bits;
388 	dev_priv->display.hotplug.event_bits = 0;
389 	hpd_retry_bits = dev_priv->display.hotplug.retry_bits;
390 	dev_priv->display.hotplug.retry_bits = 0;
391 
392 	/* Enable polling for connectors which had HPD IRQ storms */
393 	intel_hpd_irq_storm_switch_to_polling(dev_priv);
394 
395 	spin_unlock_irq(&dev_priv->irq_lock);
396 
397 	/* Skip calling encode hotplug handlers if ignore long HPD set*/
398 	if (dev_priv->display.hotplug.ignore_long_hpd) {
399 		drm_dbg_kms(&dev_priv->drm, "Ignore HPD flag on - skip encoder hotplug handlers\n");
400 		mutex_unlock(&dev_priv->drm.mode_config.mutex);
401 		return;
402 	}
403 
404 	drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);
405 	for_each_intel_connector_iter(connector, &conn_iter) {
406 		enum hpd_pin pin;
407 		u32 hpd_bit;
408 
409 		pin = intel_connector_hpd_pin(connector);
410 		if (pin == HPD_NONE)
411 			continue;
412 
413 		hpd_bit = BIT(pin);
414 		if ((hpd_event_bits | hpd_retry_bits) & hpd_bit) {
415 			struct intel_encoder *encoder =
416 				intel_attached_encoder(connector);
417 
418 			if (hpd_event_bits & hpd_bit)
419 				connector->hotplug_retries = 0;
420 			else
421 				connector->hotplug_retries++;
422 
423 			drm_dbg_kms(&dev_priv->drm,
424 				    "Connector %s (pin %i) received hotplug event. (retry %d)\n",
425 				    connector->base.name, pin,
426 				    connector->hotplug_retries);
427 
428 			switch (encoder->hotplug(encoder, connector)) {
429 			case INTEL_HOTPLUG_UNCHANGED:
430 				break;
431 			case INTEL_HOTPLUG_CHANGED:
432 				changed |= hpd_bit;
433 				changed_connectors++;
434 				if (!first_changed_connector) {
435 					drm_connector_get(&connector->base);
436 					first_changed_connector = &connector->base;
437 				}
438 				break;
439 			case INTEL_HOTPLUG_RETRY:
440 				retry |= hpd_bit;
441 				break;
442 			}
443 		}
444 	}
445 	drm_connector_list_iter_end(&conn_iter);
446 	mutex_unlock(&dev_priv->drm.mode_config.mutex);
447 
448 	if (changed_connectors == 1)
449 		drm_kms_helper_connector_hotplug_event(first_changed_connector);
450 	else if (changed_connectors > 0)
451 		drm_kms_helper_hotplug_event(&dev_priv->drm);
452 
453 	if (first_changed_connector)
454 		drm_connector_put(first_changed_connector);
455 
456 	/* Remove shared HPD pins that have changed */
457 	retry &= ~changed;
458 	if (retry) {
459 		spin_lock_irq(&dev_priv->irq_lock);
460 		dev_priv->display.hotplug.retry_bits |= retry;
461 		spin_unlock_irq(&dev_priv->irq_lock);
462 
463 		mod_delayed_work(dev_priv->unordered_wq,
464 				 &dev_priv->display.hotplug.hotplug_work,
465 				 msecs_to_jiffies(HPD_RETRY_DELAY));
466 	}
467 }
468 
469 
470 /**
471  * intel_hpd_irq_handler - main hotplug irq handler
472  * @dev_priv: drm_i915_private
473  * @pin_mask: a mask of hpd pins that have triggered the irq
474  * @long_mask: a mask of hpd pins that may be long hpd pulses
475  *
476  * This is the main hotplug irq handler for all platforms. The platform specific
477  * irq handlers call the platform specific hotplug irq handlers, which read and
478  * decode the appropriate registers into bitmasks about hpd pins that have
479  * triggered (@pin_mask), and which of those pins may be long pulses
480  * (@long_mask). The @long_mask is ignored if the port corresponding to the pin
481  * is not a digital port.
482  *
483  * Here, we do hotplug irq storm detection and mitigation, and pass further
484  * processing to appropriate bottom halves.
485  */
intel_hpd_irq_handler(struct drm_i915_private * dev_priv,u32 pin_mask,u32 long_mask)486 void intel_hpd_irq_handler(struct drm_i915_private *dev_priv,
487 			   u32 pin_mask, u32 long_mask)
488 {
489 	struct intel_encoder *encoder;
490 	bool storm_detected = false;
491 	bool queue_dig = false, queue_hp = false;
492 	u32 long_hpd_pulse_mask = 0;
493 	u32 short_hpd_pulse_mask = 0;
494 	enum hpd_pin pin;
495 
496 	if (!pin_mask)
497 		return;
498 
499 	spin_lock(&dev_priv->irq_lock);
500 
501 	/*
502 	 * Determine whether ->hpd_pulse() exists for each pin, and
503 	 * whether we have a short or a long pulse. This is needed
504 	 * as each pin may have up to two encoders (HDMI and DP) and
505 	 * only the one of them (DP) will have ->hpd_pulse().
506 	 */
507 	for_each_intel_encoder(&dev_priv->drm, encoder) {
508 		enum port port = encoder->port;
509 		bool long_hpd;
510 
511 		pin = encoder->hpd_pin;
512 		if (!(BIT(pin) & pin_mask))
513 			continue;
514 
515 		if (!intel_encoder_has_hpd_pulse(encoder))
516 			continue;
517 
518 		long_hpd = long_mask & BIT(pin);
519 
520 		drm_dbg(&dev_priv->drm,
521 			"digital hpd on [ENCODER:%d:%s] - %s\n",
522 			encoder->base.base.id, encoder->base.name,
523 			long_hpd ? "long" : "short");
524 		queue_dig = true;
525 
526 		if (long_hpd) {
527 			long_hpd_pulse_mask |= BIT(pin);
528 			dev_priv->display.hotplug.long_port_mask |= BIT(port);
529 		} else {
530 			short_hpd_pulse_mask |= BIT(pin);
531 			dev_priv->display.hotplug.short_port_mask |= BIT(port);
532 		}
533 	}
534 
535 	/* Now process each pin just once */
536 	for_each_hpd_pin(pin) {
537 		bool long_hpd;
538 
539 		if (!(BIT(pin) & pin_mask))
540 			continue;
541 
542 		if (dev_priv->display.hotplug.stats[pin].state == HPD_DISABLED) {
543 			/*
544 			 * On GMCH platforms the interrupt mask bits only
545 			 * prevent irq generation, not the setting of the
546 			 * hotplug bits itself. So only WARN about unexpected
547 			 * interrupts on saner platforms.
548 			 */
549 			drm_WARN_ONCE(&dev_priv->drm, !HAS_GMCH(dev_priv),
550 				      "Received HPD interrupt on pin %d although disabled\n",
551 				      pin);
552 			continue;
553 		}
554 
555 		if (dev_priv->display.hotplug.stats[pin].state != HPD_ENABLED)
556 			continue;
557 
558 		/*
559 		 * Delegate to ->hpd_pulse() if one of the encoders for this
560 		 * pin has it, otherwise let the hotplug_work deal with this
561 		 * pin directly.
562 		 */
563 		if (((short_hpd_pulse_mask | long_hpd_pulse_mask) & BIT(pin))) {
564 			long_hpd = long_hpd_pulse_mask & BIT(pin);
565 		} else {
566 			dev_priv->display.hotplug.event_bits |= BIT(pin);
567 			long_hpd = true;
568 			queue_hp = true;
569 		}
570 
571 		if (intel_hpd_irq_storm_detect(dev_priv, pin, long_hpd)) {
572 			dev_priv->display.hotplug.event_bits &= ~BIT(pin);
573 			storm_detected = true;
574 			queue_hp = true;
575 		}
576 	}
577 
578 	/*
579 	 * Disable any IRQs that storms were detected on. Polling enablement
580 	 * happens later in our hotplug work.
581 	 */
582 	if (storm_detected)
583 		intel_hpd_irq_setup(dev_priv);
584 	spin_unlock(&dev_priv->irq_lock);
585 
586 	/*
587 	 * Our hotplug handler can grab modeset locks (by calling down into the
588 	 * fb helpers). Hence it must not be run on our own dev-priv->wq work
589 	 * queue for otherwise the flush_work in the pageflip code will
590 	 * deadlock.
591 	 */
592 	if (queue_dig)
593 		queue_work(dev_priv->display.hotplug.dp_wq, &dev_priv->display.hotplug.dig_port_work);
594 	if (queue_hp)
595 		queue_delayed_work(dev_priv->unordered_wq,
596 				   &dev_priv->display.hotplug.hotplug_work, 0);
597 }
598 
599 /**
600  * intel_hpd_init - initializes and enables hpd support
601  * @dev_priv: i915 device instance
602  *
603  * This function enables the hotplug support. It requires that interrupts have
604  * already been enabled with intel_irq_init_hw(). From this point on hotplug and
605  * poll request can run concurrently to other code, so locking rules must be
606  * obeyed.
607  *
608  * This is a separate step from interrupt enabling to simplify the locking rules
609  * in the driver load and resume code.
610  *
611  * Also see: intel_hpd_poll_enable() and intel_hpd_poll_disable().
612  */
intel_hpd_init(struct drm_i915_private * dev_priv)613 void intel_hpd_init(struct drm_i915_private *dev_priv)
614 {
615 	int i;
616 
617 	if (!HAS_DISPLAY(dev_priv))
618 		return;
619 
620 	for_each_hpd_pin(i) {
621 		dev_priv->display.hotplug.stats[i].count = 0;
622 		dev_priv->display.hotplug.stats[i].state = HPD_ENABLED;
623 	}
624 
625 	/*
626 	 * Interrupt setup is already guaranteed to be single-threaded, this is
627 	 * just to make the assert_spin_locked checks happy.
628 	 */
629 	spin_lock_irq(&dev_priv->irq_lock);
630 	intel_hpd_irq_setup(dev_priv);
631 	spin_unlock_irq(&dev_priv->irq_lock);
632 }
633 
i915_hpd_poll_init_work(struct work_struct * work)634 static void i915_hpd_poll_init_work(struct work_struct *work)
635 {
636 	struct drm_i915_private *dev_priv =
637 		container_of(work, struct drm_i915_private,
638 			     display.hotplug.poll_init_work);
639 	struct drm_connector_list_iter conn_iter;
640 	struct intel_connector *connector;
641 	bool enabled;
642 
643 	mutex_lock(&dev_priv->drm.mode_config.mutex);
644 
645 	enabled = READ_ONCE(dev_priv->display.hotplug.poll_enabled);
646 
647 	drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);
648 	for_each_intel_connector_iter(connector, &conn_iter) {
649 		enum hpd_pin pin;
650 
651 		pin = intel_connector_hpd_pin(connector);
652 		if (pin == HPD_NONE)
653 			continue;
654 
655 		connector->base.polled = connector->polled;
656 
657 		if (enabled && connector->base.polled == DRM_CONNECTOR_POLL_HPD)
658 			connector->base.polled = DRM_CONNECTOR_POLL_CONNECT |
659 				DRM_CONNECTOR_POLL_DISCONNECT;
660 	}
661 	drm_connector_list_iter_end(&conn_iter);
662 
663 	if (enabled)
664 		drm_kms_helper_poll_reschedule(&dev_priv->drm);
665 
666 	mutex_unlock(&dev_priv->drm.mode_config.mutex);
667 
668 	/*
669 	 * We might have missed any hotplugs that happened while we were
670 	 * in the middle of disabling polling
671 	 */
672 	if (!enabled)
673 		drm_helper_hpd_irq_event(&dev_priv->drm);
674 }
675 
676 /**
677  * intel_hpd_poll_enable - enable polling for connectors with hpd
678  * @dev_priv: i915 device instance
679  *
680  * This function enables polling for all connectors which support HPD.
681  * Under certain conditions HPD may not be functional. On most Intel GPUs,
682  * this happens when we enter runtime suspend.
683  * On Valleyview and Cherryview systems, this also happens when we shut off all
684  * of the powerwells.
685  *
686  * Since this function can get called in contexts where we're already holding
687  * dev->mode_config.mutex, we do the actual hotplug enabling in a seperate
688  * worker.
689  *
690  * Also see: intel_hpd_init() and intel_hpd_poll_disable().
691  */
intel_hpd_poll_enable(struct drm_i915_private * dev_priv)692 void intel_hpd_poll_enable(struct drm_i915_private *dev_priv)
693 {
694 	if (!HAS_DISPLAY(dev_priv) ||
695 	    !INTEL_DISPLAY_ENABLED(dev_priv))
696 		return;
697 
698 	WRITE_ONCE(dev_priv->display.hotplug.poll_enabled, true);
699 
700 	/*
701 	 * We might already be holding dev->mode_config.mutex, so do this in a
702 	 * seperate worker
703 	 * As well, there's no issue if we race here since we always reschedule
704 	 * this worker anyway
705 	 */
706 	queue_work(dev_priv->unordered_wq,
707 		   &dev_priv->display.hotplug.poll_init_work);
708 }
709 
710 /**
711  * intel_hpd_poll_disable - disable polling for connectors with hpd
712  * @dev_priv: i915 device instance
713  *
714  * This function disables polling for all connectors which support HPD.
715  * Under certain conditions HPD may not be functional. On most Intel GPUs,
716  * this happens when we enter runtime suspend.
717  * On Valleyview and Cherryview systems, this also happens when we shut off all
718  * of the powerwells.
719  *
720  * Since this function can get called in contexts where we're already holding
721  * dev->mode_config.mutex, we do the actual hotplug enabling in a seperate
722  * worker.
723  *
724  * Also used during driver init to initialize connector->polled
725  * appropriately for all connectors.
726  *
727  * Also see: intel_hpd_init() and intel_hpd_poll_enable().
728  */
intel_hpd_poll_disable(struct drm_i915_private * dev_priv)729 void intel_hpd_poll_disable(struct drm_i915_private *dev_priv)
730 {
731 	if (!HAS_DISPLAY(dev_priv))
732 		return;
733 
734 	WRITE_ONCE(dev_priv->display.hotplug.poll_enabled, false);
735 	queue_work(dev_priv->unordered_wq,
736 		   &dev_priv->display.hotplug.poll_init_work);
737 }
738 
intel_hpd_init_early(struct drm_i915_private * i915)739 void intel_hpd_init_early(struct drm_i915_private *i915)
740 {
741 	INIT_DELAYED_WORK(&i915->display.hotplug.hotplug_work,
742 			  i915_hotplug_work_func);
743 	INIT_WORK(&i915->display.hotplug.dig_port_work, i915_digport_work_func);
744 	INIT_WORK(&i915->display.hotplug.poll_init_work, i915_hpd_poll_init_work);
745 	INIT_DELAYED_WORK(&i915->display.hotplug.reenable_work,
746 			  intel_hpd_irq_storm_reenable_work);
747 
748 	i915->display.hotplug.hpd_storm_threshold = HPD_STORM_DEFAULT_THRESHOLD;
749 	/* If we have MST support, we want to avoid doing short HPD IRQ storm
750 	 * detection, as short HPD storms will occur as a natural part of
751 	 * sideband messaging with MST.
752 	 * On older platforms however, IRQ storms can occur with both long and
753 	 * short pulses, as seen on some G4x systems.
754 	 */
755 	i915->display.hotplug.hpd_short_storm_enabled = !HAS_DP_MST(i915);
756 }
757 
intel_hpd_cancel_work(struct drm_i915_private * dev_priv)758 void intel_hpd_cancel_work(struct drm_i915_private *dev_priv)
759 {
760 	if (!HAS_DISPLAY(dev_priv))
761 		return;
762 
763 	spin_lock_irq(&dev_priv->irq_lock);
764 
765 	dev_priv->display.hotplug.long_port_mask = 0;
766 	dev_priv->display.hotplug.short_port_mask = 0;
767 	dev_priv->display.hotplug.event_bits = 0;
768 	dev_priv->display.hotplug.retry_bits = 0;
769 
770 	spin_unlock_irq(&dev_priv->irq_lock);
771 
772 	cancel_work_sync(&dev_priv->display.hotplug.dig_port_work);
773 	cancel_delayed_work_sync(&dev_priv->display.hotplug.hotplug_work);
774 	cancel_work_sync(&dev_priv->display.hotplug.poll_init_work);
775 	cancel_delayed_work_sync(&dev_priv->display.hotplug.reenable_work);
776 }
777 
intel_hpd_disable(struct drm_i915_private * dev_priv,enum hpd_pin pin)778 bool intel_hpd_disable(struct drm_i915_private *dev_priv, enum hpd_pin pin)
779 {
780 	bool ret = false;
781 
782 	if (pin == HPD_NONE)
783 		return false;
784 
785 	spin_lock_irq(&dev_priv->irq_lock);
786 	if (dev_priv->display.hotplug.stats[pin].state == HPD_ENABLED) {
787 		dev_priv->display.hotplug.stats[pin].state = HPD_DISABLED;
788 		ret = true;
789 	}
790 	spin_unlock_irq(&dev_priv->irq_lock);
791 
792 	return ret;
793 }
794 
intel_hpd_enable(struct drm_i915_private * dev_priv,enum hpd_pin pin)795 void intel_hpd_enable(struct drm_i915_private *dev_priv, enum hpd_pin pin)
796 {
797 	if (pin == HPD_NONE)
798 		return;
799 
800 	spin_lock_irq(&dev_priv->irq_lock);
801 	dev_priv->display.hotplug.stats[pin].state = HPD_ENABLED;
802 	spin_unlock_irq(&dev_priv->irq_lock);
803 }
804 
i915_hpd_storm_ctl_show(struct seq_file * m,void * data)805 static int i915_hpd_storm_ctl_show(struct seq_file *m, void *data)
806 {
807 	struct drm_i915_private *dev_priv = m->private;
808 	struct intel_hotplug *hotplug = &dev_priv->display.hotplug;
809 
810 	/* Synchronize with everything first in case there's been an HPD
811 	 * storm, but we haven't finished handling it in the kernel yet
812 	 */
813 	intel_synchronize_irq(dev_priv);
814 	flush_work(&dev_priv->display.hotplug.dig_port_work);
815 	flush_delayed_work(&dev_priv->display.hotplug.hotplug_work);
816 
817 	seq_printf(m, "Threshold: %d\n", hotplug->hpd_storm_threshold);
818 	seq_printf(m, "Detected: %s\n",
819 		   str_yes_no(delayed_work_pending(&hotplug->reenable_work)));
820 
821 	return 0;
822 }
823 
i915_hpd_storm_ctl_write(struct file * file,const char __user * ubuf,size_t len,loff_t * offp)824 static ssize_t i915_hpd_storm_ctl_write(struct file *file,
825 					const char __user *ubuf, size_t len,
826 					loff_t *offp)
827 {
828 	struct seq_file *m = file->private_data;
829 	struct drm_i915_private *dev_priv = m->private;
830 	struct intel_hotplug *hotplug = &dev_priv->display.hotplug;
831 	unsigned int new_threshold;
832 	int i;
833 	char *newline;
834 	char tmp[16];
835 
836 	if (len >= sizeof(tmp))
837 		return -EINVAL;
838 
839 	if (copy_from_user(tmp, ubuf, len))
840 		return -EFAULT;
841 
842 	tmp[len] = '\0';
843 
844 	/* Strip newline, if any */
845 	newline = strchr(tmp, '\n');
846 	if (newline)
847 		*newline = '\0';
848 
849 	if (strcmp(tmp, "reset") == 0)
850 		new_threshold = HPD_STORM_DEFAULT_THRESHOLD;
851 	else if (kstrtouint(tmp, 10, &new_threshold) != 0)
852 		return -EINVAL;
853 
854 	if (new_threshold > 0)
855 		drm_dbg_kms(&dev_priv->drm,
856 			    "Setting HPD storm detection threshold to %d\n",
857 			    new_threshold);
858 	else
859 		drm_dbg_kms(&dev_priv->drm, "Disabling HPD storm detection\n");
860 
861 	spin_lock_irq(&dev_priv->irq_lock);
862 	hotplug->hpd_storm_threshold = new_threshold;
863 	/* Reset the HPD storm stats so we don't accidentally trigger a storm */
864 	for_each_hpd_pin(i)
865 		hotplug->stats[i].count = 0;
866 	spin_unlock_irq(&dev_priv->irq_lock);
867 
868 	/* Re-enable hpd immediately if we were in an irq storm */
869 	flush_delayed_work(&dev_priv->display.hotplug.reenable_work);
870 
871 	return len;
872 }
873 
i915_hpd_storm_ctl_open(struct inode * inode,struct file * file)874 static int i915_hpd_storm_ctl_open(struct inode *inode, struct file *file)
875 {
876 	return single_open(file, i915_hpd_storm_ctl_show, inode->i_private);
877 }
878 
879 static const struct file_operations i915_hpd_storm_ctl_fops = {
880 	.owner = THIS_MODULE,
881 	.open = i915_hpd_storm_ctl_open,
882 	.read = seq_read,
883 	.llseek = seq_lseek,
884 	.release = single_release,
885 	.write = i915_hpd_storm_ctl_write
886 };
887 
i915_hpd_short_storm_ctl_show(struct seq_file * m,void * data)888 static int i915_hpd_short_storm_ctl_show(struct seq_file *m, void *data)
889 {
890 	struct drm_i915_private *dev_priv = m->private;
891 
892 	seq_printf(m, "Enabled: %s\n",
893 		   str_yes_no(dev_priv->display.hotplug.hpd_short_storm_enabled));
894 
895 	return 0;
896 }
897 
898 static int
i915_hpd_short_storm_ctl_open(struct inode * inode,struct file * file)899 i915_hpd_short_storm_ctl_open(struct inode *inode, struct file *file)
900 {
901 	return single_open(file, i915_hpd_short_storm_ctl_show,
902 			   inode->i_private);
903 }
904 
i915_hpd_short_storm_ctl_write(struct file * file,const char __user * ubuf,size_t len,loff_t * offp)905 static ssize_t i915_hpd_short_storm_ctl_write(struct file *file,
906 					      const char __user *ubuf,
907 					      size_t len, loff_t *offp)
908 {
909 	struct seq_file *m = file->private_data;
910 	struct drm_i915_private *dev_priv = m->private;
911 	struct intel_hotplug *hotplug = &dev_priv->display.hotplug;
912 	char *newline;
913 	char tmp[16];
914 	int i;
915 	bool new_state;
916 
917 	if (len >= sizeof(tmp))
918 		return -EINVAL;
919 
920 	if (copy_from_user(tmp, ubuf, len))
921 		return -EFAULT;
922 
923 	tmp[len] = '\0';
924 
925 	/* Strip newline, if any */
926 	newline = strchr(tmp, '\n');
927 	if (newline)
928 		*newline = '\0';
929 
930 	/* Reset to the "default" state for this system */
931 	if (strcmp(tmp, "reset") == 0)
932 		new_state = !HAS_DP_MST(dev_priv);
933 	else if (kstrtobool(tmp, &new_state) != 0)
934 		return -EINVAL;
935 
936 	drm_dbg_kms(&dev_priv->drm, "%sabling HPD short storm detection\n",
937 		    new_state ? "En" : "Dis");
938 
939 	spin_lock_irq(&dev_priv->irq_lock);
940 	hotplug->hpd_short_storm_enabled = new_state;
941 	/* Reset the HPD storm stats so we don't accidentally trigger a storm */
942 	for_each_hpd_pin(i)
943 		hotplug->stats[i].count = 0;
944 	spin_unlock_irq(&dev_priv->irq_lock);
945 
946 	/* Re-enable hpd immediately if we were in an irq storm */
947 	flush_delayed_work(&dev_priv->display.hotplug.reenable_work);
948 
949 	return len;
950 }
951 
952 static const struct file_operations i915_hpd_short_storm_ctl_fops = {
953 	.owner = THIS_MODULE,
954 	.open = i915_hpd_short_storm_ctl_open,
955 	.read = seq_read,
956 	.llseek = seq_lseek,
957 	.release = single_release,
958 	.write = i915_hpd_short_storm_ctl_write,
959 };
960 
intel_hpd_debugfs_register(struct drm_i915_private * i915)961 void intel_hpd_debugfs_register(struct drm_i915_private *i915)
962 {
963 	struct drm_minor *minor = i915->drm.primary;
964 
965 	debugfs_create_file("i915_hpd_storm_ctl", 0644, minor->debugfs_root,
966 			    i915, &i915_hpd_storm_ctl_fops);
967 	debugfs_create_file("i915_hpd_short_storm_ctl", 0644, minor->debugfs_root,
968 			    i915, &i915_hpd_short_storm_ctl_fops);
969 	debugfs_create_bool("i915_ignore_long_hpd", 0644, minor->debugfs_root,
970 			    &i915->display.hotplug.ignore_long_hpd);
971 }
972