Branch data Line data Source code
1 : : /* i915_irq.c -- IRQ support for the I915 -*- linux-c -*-
2 : : */
3 : : /*
4 : : * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
5 : : * All Rights Reserved.
6 : : *
7 : : * Permission is hereby granted, free of charge, to any person obtaining a
8 : : * copy of this software and associated documentation files (the
9 : : * "Software"), to deal in the Software without restriction, including
10 : : * without limitation the rights to use, copy, modify, merge, publish,
11 : : * distribute, sub license, and/or sell copies of the Software, and to
12 : : * permit persons to whom the Software is furnished to do so, subject to
13 : : * the following conditions:
14 : : *
15 : : * The above copyright notice and this permission notice (including the
16 : : * next paragraph) shall be included in all copies or substantial portions
17 : : * of the Software.
18 : : *
19 : : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 : : * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 : : * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
22 : : * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
23 : : * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
24 : : * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
25 : : * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 : : *
27 : : */
28 : :
29 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30 : :
31 : : #include <linux/circ_buf.h>
32 : : #include <linux/slab.h>
33 : : #include <linux/sysrq.h>
34 : :
35 : : #include <drm/drm_drv.h>
36 : : #include <drm/drm_irq.h>
37 : : #include <drm/i915_drm.h>
38 : :
39 : : #include "display/intel_display_types.h"
40 : : #include "display/intel_fifo_underrun.h"
41 : : #include "display/intel_hotplug.h"
42 : : #include "display/intel_lpe_audio.h"
43 : : #include "display/intel_psr.h"
44 : :
45 : : #include "gt/intel_gt.h"
46 : : #include "gt/intel_gt_irq.h"
47 : : #include "gt/intel_gt_pm_irq.h"
48 : : #include "gt/intel_rps.h"
49 : :
50 : : #include "i915_drv.h"
51 : : #include "i915_irq.h"
52 : : #include "i915_trace.h"
53 : : #include "intel_pm.h"
54 : :
55 : : /**
56 : : * DOC: interrupt handling
57 : : *
58 : : * These functions provide the basic support for enabling and disabling the
59 : : * interrupt handling support. There's a lot more functionality in i915_irq.c
60 : : * and related files, but that will be described in separate chapters.
61 : : */
62 : :
63 : : typedef bool (*long_pulse_detect_func)(enum hpd_pin pin, u32 val);
64 : :
65 : : static const u32 hpd_ilk[HPD_NUM_PINS] = {
66 : : [HPD_PORT_A] = DE_DP_A_HOTPLUG,
67 : : };
68 : :
69 : : static const u32 hpd_ivb[HPD_NUM_PINS] = {
70 : : [HPD_PORT_A] = DE_DP_A_HOTPLUG_IVB,
71 : : };
72 : :
73 : : static const u32 hpd_bdw[HPD_NUM_PINS] = {
74 : : [HPD_PORT_A] = GEN8_PORT_DP_A_HOTPLUG,
75 : : };
76 : :
77 : : static const u32 hpd_ibx[HPD_NUM_PINS] = {
78 : : [HPD_CRT] = SDE_CRT_HOTPLUG,
79 : : [HPD_SDVO_B] = SDE_SDVOB_HOTPLUG,
80 : : [HPD_PORT_B] = SDE_PORTB_HOTPLUG,
81 : : [HPD_PORT_C] = SDE_PORTC_HOTPLUG,
82 : : [HPD_PORT_D] = SDE_PORTD_HOTPLUG
83 : : };
84 : :
85 : : static const u32 hpd_cpt[HPD_NUM_PINS] = {
86 : : [HPD_CRT] = SDE_CRT_HOTPLUG_CPT,
87 : : [HPD_SDVO_B] = SDE_SDVOB_HOTPLUG_CPT,
88 : : [HPD_PORT_B] = SDE_PORTB_HOTPLUG_CPT,
89 : : [HPD_PORT_C] = SDE_PORTC_HOTPLUG_CPT,
90 : : [HPD_PORT_D] = SDE_PORTD_HOTPLUG_CPT
91 : : };
92 : :
93 : : static const u32 hpd_spt[HPD_NUM_PINS] = {
94 : : [HPD_PORT_A] = SDE_PORTA_HOTPLUG_SPT,
95 : : [HPD_PORT_B] = SDE_PORTB_HOTPLUG_CPT,
96 : : [HPD_PORT_C] = SDE_PORTC_HOTPLUG_CPT,
97 : : [HPD_PORT_D] = SDE_PORTD_HOTPLUG_CPT,
98 : : [HPD_PORT_E] = SDE_PORTE_HOTPLUG_SPT
99 : : };
100 : :
101 : : static const u32 hpd_mask_i915[HPD_NUM_PINS] = {
102 : : [HPD_CRT] = CRT_HOTPLUG_INT_EN,
103 : : [HPD_SDVO_B] = SDVOB_HOTPLUG_INT_EN,
104 : : [HPD_SDVO_C] = SDVOC_HOTPLUG_INT_EN,
105 : : [HPD_PORT_B] = PORTB_HOTPLUG_INT_EN,
106 : : [HPD_PORT_C] = PORTC_HOTPLUG_INT_EN,
107 : : [HPD_PORT_D] = PORTD_HOTPLUG_INT_EN
108 : : };
109 : :
110 : : static const u32 hpd_status_g4x[HPD_NUM_PINS] = {
111 : : [HPD_CRT] = CRT_HOTPLUG_INT_STATUS,
112 : : [HPD_SDVO_B] = SDVOB_HOTPLUG_INT_STATUS_G4X,
113 : : [HPD_SDVO_C] = SDVOC_HOTPLUG_INT_STATUS_G4X,
114 : : [HPD_PORT_B] = PORTB_HOTPLUG_INT_STATUS,
115 : : [HPD_PORT_C] = PORTC_HOTPLUG_INT_STATUS,
116 : : [HPD_PORT_D] = PORTD_HOTPLUG_INT_STATUS
117 : : };
118 : :
119 : : static const u32 hpd_status_i915[HPD_NUM_PINS] = {
120 : : [HPD_CRT] = CRT_HOTPLUG_INT_STATUS,
121 : : [HPD_SDVO_B] = SDVOB_HOTPLUG_INT_STATUS_I915,
122 : : [HPD_SDVO_C] = SDVOC_HOTPLUG_INT_STATUS_I915,
123 : : [HPD_PORT_B] = PORTB_HOTPLUG_INT_STATUS,
124 : : [HPD_PORT_C] = PORTC_HOTPLUG_INT_STATUS,
125 : : [HPD_PORT_D] = PORTD_HOTPLUG_INT_STATUS
126 : : };
127 : :
128 : : /* BXT hpd list */
129 : : static const u32 hpd_bxt[HPD_NUM_PINS] = {
130 : : [HPD_PORT_A] = BXT_DE_PORT_HP_DDIA,
131 : : [HPD_PORT_B] = BXT_DE_PORT_HP_DDIB,
132 : : [HPD_PORT_C] = BXT_DE_PORT_HP_DDIC
133 : : };
134 : :
135 : : static const u32 hpd_gen11[HPD_NUM_PINS] = {
136 : : [HPD_PORT_C] = GEN11_TC1_HOTPLUG | GEN11_TBT1_HOTPLUG,
137 : : [HPD_PORT_D] = GEN11_TC2_HOTPLUG | GEN11_TBT2_HOTPLUG,
138 : : [HPD_PORT_E] = GEN11_TC3_HOTPLUG | GEN11_TBT3_HOTPLUG,
139 : : [HPD_PORT_F] = GEN11_TC4_HOTPLUG | GEN11_TBT4_HOTPLUG
140 : : };
141 : :
142 : : static const u32 hpd_gen12[HPD_NUM_PINS] = {
143 : : [HPD_PORT_D] = GEN11_TC1_HOTPLUG | GEN11_TBT1_HOTPLUG,
144 : : [HPD_PORT_E] = GEN11_TC2_HOTPLUG | GEN11_TBT2_HOTPLUG,
145 : : [HPD_PORT_F] = GEN11_TC3_HOTPLUG | GEN11_TBT3_HOTPLUG,
146 : : [HPD_PORT_G] = GEN11_TC4_HOTPLUG | GEN11_TBT4_HOTPLUG,
147 : : [HPD_PORT_H] = GEN12_TC5_HOTPLUG | GEN12_TBT5_HOTPLUG,
148 : : [HPD_PORT_I] = GEN12_TC6_HOTPLUG | GEN12_TBT6_HOTPLUG
149 : : };
150 : :
151 : : static const u32 hpd_icp[HPD_NUM_PINS] = {
152 : : [HPD_PORT_A] = SDE_DDI_HOTPLUG_ICP(PORT_A),
153 : : [HPD_PORT_B] = SDE_DDI_HOTPLUG_ICP(PORT_B),
154 : : [HPD_PORT_C] = SDE_TC_HOTPLUG_ICP(PORT_TC1),
155 : : [HPD_PORT_D] = SDE_TC_HOTPLUG_ICP(PORT_TC2),
156 : : [HPD_PORT_E] = SDE_TC_HOTPLUG_ICP(PORT_TC3),
157 : : [HPD_PORT_F] = SDE_TC_HOTPLUG_ICP(PORT_TC4),
158 : : };
159 : :
160 : : static const u32 hpd_tgp[HPD_NUM_PINS] = {
161 : : [HPD_PORT_A] = SDE_DDI_HOTPLUG_ICP(PORT_A),
162 : : [HPD_PORT_B] = SDE_DDI_HOTPLUG_ICP(PORT_B),
163 : : [HPD_PORT_C] = SDE_DDI_HOTPLUG_ICP(PORT_C),
164 : : [HPD_PORT_D] = SDE_TC_HOTPLUG_ICP(PORT_TC1),
165 : : [HPD_PORT_E] = SDE_TC_HOTPLUG_ICP(PORT_TC2),
166 : : [HPD_PORT_F] = SDE_TC_HOTPLUG_ICP(PORT_TC3),
167 : : [HPD_PORT_G] = SDE_TC_HOTPLUG_ICP(PORT_TC4),
168 : : [HPD_PORT_H] = SDE_TC_HOTPLUG_ICP(PORT_TC5),
169 : : [HPD_PORT_I] = SDE_TC_HOTPLUG_ICP(PORT_TC6),
170 : : };
171 : :
172 : 0 : void gen3_irq_reset(struct intel_uncore *uncore, i915_reg_t imr,
173 : : i915_reg_t iir, i915_reg_t ier)
174 : : {
175 : 0 : intel_uncore_write(uncore, imr, 0xffffffff);
176 : 0 : intel_uncore_posting_read(uncore, imr);
177 : :
178 : 0 : intel_uncore_write(uncore, ier, 0);
179 : :
180 : : /* IIR can theoretically queue up two events. Be paranoid. */
181 : 0 : intel_uncore_write(uncore, iir, 0xffffffff);
182 : 0 : intel_uncore_posting_read(uncore, iir);
183 : 0 : intel_uncore_write(uncore, iir, 0xffffffff);
184 : 0 : intel_uncore_posting_read(uncore, iir);
185 : 0 : }
186 : :
187 : 0 : void gen2_irq_reset(struct intel_uncore *uncore)
188 : : {
189 : 0 : intel_uncore_write16(uncore, GEN2_IMR, 0xffff);
190 : 0 : intel_uncore_posting_read16(uncore, GEN2_IMR);
191 : :
192 : 0 : intel_uncore_write16(uncore, GEN2_IER, 0);
193 : :
194 : : /* IIR can theoretically queue up two events. Be paranoid. */
195 : 0 : intel_uncore_write16(uncore, GEN2_IIR, 0xffff);
196 : 0 : intel_uncore_posting_read16(uncore, GEN2_IIR);
197 : 0 : intel_uncore_write16(uncore, GEN2_IIR, 0xffff);
198 : 0 : intel_uncore_posting_read16(uncore, GEN2_IIR);
199 : 0 : }
200 : :
201 : : /*
202 : : * We should clear IMR at preinstall/uninstall, and just check at postinstall.
203 : : */
204 : 0 : static void gen3_assert_iir_is_zero(struct intel_uncore *uncore, i915_reg_t reg)
205 : : {
206 : 0 : u32 val = intel_uncore_read(uncore, reg);
207 : :
208 [ # # ]: 0 : if (val == 0)
209 : : return;
210 : :
211 : 0 : WARN(1, "Interrupt register 0x%x is not zero: 0x%08x\n",
212 : : i915_mmio_reg_offset(reg), val);
213 : 0 : intel_uncore_write(uncore, reg, 0xffffffff);
214 : 0 : intel_uncore_posting_read(uncore, reg);
215 : 0 : intel_uncore_write(uncore, reg, 0xffffffff);
216 : 0 : intel_uncore_posting_read(uncore, reg);
217 : : }
218 : :
219 : 0 : static void gen2_assert_iir_is_zero(struct intel_uncore *uncore)
220 : : {
221 : 0 : u16 val = intel_uncore_read16(uncore, GEN2_IIR);
222 : :
223 [ # # ]: 0 : if (val == 0)
224 : : return;
225 : :
226 : 0 : WARN(1, "Interrupt register 0x%x is not zero: 0x%08x\n",
227 : : i915_mmio_reg_offset(GEN2_IIR), val);
228 : 0 : intel_uncore_write16(uncore, GEN2_IIR, 0xffff);
229 : 0 : intel_uncore_posting_read16(uncore, GEN2_IIR);
230 : 0 : intel_uncore_write16(uncore, GEN2_IIR, 0xffff);
231 : 0 : intel_uncore_posting_read16(uncore, GEN2_IIR);
232 : : }
233 : :
234 : 0 : void gen3_irq_init(struct intel_uncore *uncore,
235 : : i915_reg_t imr, u32 imr_val,
236 : : i915_reg_t ier, u32 ier_val,
237 : : i915_reg_t iir)
238 : : {
239 : 0 : gen3_assert_iir_is_zero(uncore, iir);
240 : :
241 : 0 : intel_uncore_write(uncore, ier, ier_val);
242 : 0 : intel_uncore_write(uncore, imr, imr_val);
243 : 0 : intel_uncore_posting_read(uncore, imr);
244 : 0 : }
245 : :
246 : 0 : void gen2_irq_init(struct intel_uncore *uncore,
247 : : u32 imr_val, u32 ier_val)
248 : : {
249 : 0 : gen2_assert_iir_is_zero(uncore);
250 : :
251 : 0 : intel_uncore_write16(uncore, GEN2_IER, ier_val);
252 : 0 : intel_uncore_write16(uncore, GEN2_IMR, imr_val);
253 : 0 : intel_uncore_posting_read16(uncore, GEN2_IMR);
254 : 0 : }
255 : :
256 : : /* For display hotplug interrupt */
257 : : static inline void
258 : 0 : i915_hotplug_interrupt_update_locked(struct drm_i915_private *dev_priv,
259 : : u32 mask,
260 : : u32 bits)
261 : : {
262 : 0 : u32 val;
263 : :
264 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
265 [ # # ]: 0 : WARN_ON(bits & ~mask);
266 : :
267 : 0 : val = I915_READ(PORT_HOTPLUG_EN);
268 : 0 : val &= ~mask;
269 : 0 : val |= bits;
270 : 0 : I915_WRITE(PORT_HOTPLUG_EN, val);
271 : 0 : }
272 : :
273 : : /**
274 : : * i915_hotplug_interrupt_update - update hotplug interrupt enable
275 : : * @dev_priv: driver private
276 : : * @mask: bits to update
277 : : * @bits: bits to enable
278 : : * NOTE: the HPD enable bits are modified both inside and outside
279 : : * of an interrupt context. To avoid that read-modify-write cycles
280 : : * interfer, these bits are protected by a spinlock. Since this
281 : : * function is usually not called from a context where the lock is
282 : : * held already, this function acquires the lock itself. A non-locking
283 : : * version is also available.
284 : : */
285 : 0 : void i915_hotplug_interrupt_update(struct drm_i915_private *dev_priv,
286 : : u32 mask,
287 : : u32 bits)
288 : : {
289 : 0 : spin_lock_irq(&dev_priv->irq_lock);
290 : 0 : i915_hotplug_interrupt_update_locked(dev_priv, mask, bits);
291 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
292 : 0 : }
293 : :
294 : : /**
295 : : * ilk_update_display_irq - update DEIMR
296 : : * @dev_priv: driver private
297 : : * @interrupt_mask: mask of interrupt bits to update
298 : : * @enabled_irq_mask: mask of interrupt bits to enable
299 : : */
300 : 0 : void ilk_update_display_irq(struct drm_i915_private *dev_priv,
301 : : u32 interrupt_mask,
302 : : u32 enabled_irq_mask)
303 : : {
304 : 0 : u32 new_val;
305 : :
306 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
307 : :
308 [ # # ]: 0 : WARN_ON(enabled_irq_mask & ~interrupt_mask);
309 : :
310 [ # # ]: 0 : if (WARN_ON(!intel_irqs_enabled(dev_priv)))
311 : : return;
312 : :
313 : 0 : new_val = dev_priv->irq_mask;
314 : 0 : new_val &= ~interrupt_mask;
315 : 0 : new_val |= (~enabled_irq_mask & interrupt_mask);
316 : :
317 [ # # ]: 0 : if (new_val != dev_priv->irq_mask) {
318 : 0 : dev_priv->irq_mask = new_val;
319 : 0 : I915_WRITE(DEIMR, dev_priv->irq_mask);
320 : 0 : POSTING_READ(DEIMR);
321 : : }
322 : : }
323 : :
324 : : /**
325 : : * bdw_update_port_irq - update DE port interrupt
326 : : * @dev_priv: driver private
327 : : * @interrupt_mask: mask of interrupt bits to update
328 : : * @enabled_irq_mask: mask of interrupt bits to enable
329 : : */
330 : 0 : static void bdw_update_port_irq(struct drm_i915_private *dev_priv,
331 : : u32 interrupt_mask,
332 : : u32 enabled_irq_mask)
333 : : {
334 : 0 : u32 new_val;
335 : 0 : u32 old_val;
336 : :
337 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
338 : :
339 [ # # ]: 0 : WARN_ON(enabled_irq_mask & ~interrupt_mask);
340 : :
341 [ # # ]: 0 : if (WARN_ON(!intel_irqs_enabled(dev_priv)))
342 : : return;
343 : :
344 : 0 : old_val = I915_READ(GEN8_DE_PORT_IMR);
345 : :
346 : 0 : new_val = old_val;
347 : 0 : new_val &= ~interrupt_mask;
348 : 0 : new_val |= (~enabled_irq_mask & interrupt_mask);
349 : :
350 [ # # ]: 0 : if (new_val != old_val) {
351 : 0 : I915_WRITE(GEN8_DE_PORT_IMR, new_val);
352 : 0 : POSTING_READ(GEN8_DE_PORT_IMR);
353 : : }
354 : : }
355 : :
356 : : /**
357 : : * bdw_update_pipe_irq - update DE pipe interrupt
358 : : * @dev_priv: driver private
359 : : * @pipe: pipe whose interrupt to update
360 : : * @interrupt_mask: mask of interrupt bits to update
361 : : * @enabled_irq_mask: mask of interrupt bits to enable
362 : : */
363 : 0 : void bdw_update_pipe_irq(struct drm_i915_private *dev_priv,
364 : : enum pipe pipe,
365 : : u32 interrupt_mask,
366 : : u32 enabled_irq_mask)
367 : : {
368 : 0 : u32 new_val;
369 : :
370 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
371 : :
372 [ # # ]: 0 : WARN_ON(enabled_irq_mask & ~interrupt_mask);
373 : :
374 [ # # ]: 0 : if (WARN_ON(!intel_irqs_enabled(dev_priv)))
375 : : return;
376 : :
377 : 0 : new_val = dev_priv->de_irq_mask[pipe];
378 : 0 : new_val &= ~interrupt_mask;
379 : 0 : new_val |= (~enabled_irq_mask & interrupt_mask);
380 : :
381 [ # # ]: 0 : if (new_val != dev_priv->de_irq_mask[pipe]) {
382 : 0 : dev_priv->de_irq_mask[pipe] = new_val;
383 : 0 : I915_WRITE(GEN8_DE_PIPE_IMR(pipe), dev_priv->de_irq_mask[pipe]);
384 : 0 : POSTING_READ(GEN8_DE_PIPE_IMR(pipe));
385 : : }
386 : : }
387 : :
388 : : /**
389 : : * ibx_display_interrupt_update - update SDEIMR
390 : : * @dev_priv: driver private
391 : : * @interrupt_mask: mask of interrupt bits to update
392 : : * @enabled_irq_mask: mask of interrupt bits to enable
393 : : */
394 : 0 : void ibx_display_interrupt_update(struct drm_i915_private *dev_priv,
395 : : u32 interrupt_mask,
396 : : u32 enabled_irq_mask)
397 : : {
398 : 0 : u32 sdeimr = I915_READ(SDEIMR);
399 : 0 : sdeimr &= ~interrupt_mask;
400 : 0 : sdeimr |= (~enabled_irq_mask & interrupt_mask);
401 : :
402 [ # # ]: 0 : WARN_ON(enabled_irq_mask & ~interrupt_mask);
403 : :
404 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
405 : :
406 [ # # ]: 0 : if (WARN_ON(!intel_irqs_enabled(dev_priv)))
407 : : return;
408 : :
409 : 0 : I915_WRITE(SDEIMR, sdeimr);
410 : 0 : POSTING_READ(SDEIMR);
411 : : }
412 : :
413 : 0 : u32 i915_pipestat_enable_mask(struct drm_i915_private *dev_priv,
414 : : enum pipe pipe)
415 : : {
416 : 0 : u32 status_mask = dev_priv->pipestat_irq_mask[pipe];
417 : 0 : u32 enable_mask = status_mask << 16;
418 : :
419 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
420 : :
421 [ # # ]: 0 : if (INTEL_GEN(dev_priv) < 5)
422 : 0 : goto out;
423 : :
424 : : /*
425 : : * On pipe A we don't support the PSR interrupt yet,
426 : : * on pipe B and C the same bit MBZ.
427 : : */
428 [ # # # # : 0 : if (WARN_ON_ONCE(status_mask & PIPE_A_PSR_STATUS_VLV))
# # ]
429 : : return 0;
430 : : /*
431 : : * On pipe B and C we don't support the PSR interrupt yet, on pipe
432 : : * A the same bit is for perf counters which we don't use either.
433 : : */
434 [ # # # # : 0 : if (WARN_ON_ONCE(status_mask & PIPE_B_PSR_STATUS_VLV))
# # ]
435 : : return 0;
436 : :
437 : 0 : enable_mask &= ~(PIPE_FIFO_UNDERRUN_STATUS |
438 : : SPRITE0_FLIP_DONE_INT_EN_VLV |
439 : : SPRITE1_FLIP_DONE_INT_EN_VLV);
440 [ # # ]: 0 : if (status_mask & SPRITE0_FLIP_DONE_INT_STATUS_VLV)
441 : 0 : enable_mask |= SPRITE0_FLIP_DONE_INT_EN_VLV;
442 [ # # ]: 0 : if (status_mask & SPRITE1_FLIP_DONE_INT_STATUS_VLV)
443 : 0 : enable_mask |= SPRITE1_FLIP_DONE_INT_EN_VLV;
444 : :
445 : 0 : out:
446 [ # # # # : 0 : WARN_ONCE(enable_mask & ~PIPESTAT_INT_ENABLE_MASK ||
# # # # ]
447 : : status_mask & ~PIPESTAT_INT_STATUS_MASK,
448 : : "pipe %c: enable_mask=0x%x, status_mask=0x%x\n",
449 : : pipe_name(pipe), enable_mask, status_mask);
450 : :
451 : : return enable_mask;
452 : : }
453 : :
454 : 0 : void i915_enable_pipestat(struct drm_i915_private *dev_priv,
455 : : enum pipe pipe, u32 status_mask)
456 : : {
457 : 0 : i915_reg_t reg = PIPESTAT(pipe);
458 : 0 : u32 enable_mask;
459 : :
460 [ # # # # ]: 0 : WARN_ONCE(status_mask & ~PIPESTAT_INT_STATUS_MASK,
461 : : "pipe %c: status_mask=0x%x\n",
462 : : pipe_name(pipe), status_mask);
463 : :
464 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
465 : 0 : WARN_ON(!intel_irqs_enabled(dev_priv));
466 : :
467 [ # # ]: 0 : if ((dev_priv->pipestat_irq_mask[pipe] & status_mask) == status_mask)
468 : : return;
469 : :
470 : 0 : dev_priv->pipestat_irq_mask[pipe] |= status_mask;
471 : 0 : enable_mask = i915_pipestat_enable_mask(dev_priv, pipe);
472 : :
473 : 0 : I915_WRITE(reg, enable_mask | status_mask);
474 : 0 : POSTING_READ(reg);
475 : : }
476 : :
477 : 0 : void i915_disable_pipestat(struct drm_i915_private *dev_priv,
478 : : enum pipe pipe, u32 status_mask)
479 : : {
480 : 0 : i915_reg_t reg = PIPESTAT(pipe);
481 : 0 : u32 enable_mask;
482 : :
483 [ # # # # ]: 0 : WARN_ONCE(status_mask & ~PIPESTAT_INT_STATUS_MASK,
484 : : "pipe %c: status_mask=0x%x\n",
485 : : pipe_name(pipe), status_mask);
486 : :
487 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
488 : 0 : WARN_ON(!intel_irqs_enabled(dev_priv));
489 : :
490 [ # # ]: 0 : if ((dev_priv->pipestat_irq_mask[pipe] & status_mask) == 0)
491 : : return;
492 : :
493 : 0 : dev_priv->pipestat_irq_mask[pipe] &= ~status_mask;
494 : 0 : enable_mask = i915_pipestat_enable_mask(dev_priv, pipe);
495 : :
496 : 0 : I915_WRITE(reg, enable_mask | status_mask);
497 : 0 : POSTING_READ(reg);
498 : : }
499 : :
500 : 0 : static bool i915_has_asle(struct drm_i915_private *dev_priv)
501 : : {
502 : 0 : if (!dev_priv->opregion.asle)
503 : : return false;
504 : :
505 [ # # ]: 0 : return IS_PINEVIEW(dev_priv) || IS_MOBILE(dev_priv);
506 : : }
507 : :
508 : : /**
509 : : * i915_enable_asle_pipestat - enable ASLE pipestat for OpRegion
510 : : * @dev_priv: i915 device private
511 : : */
512 : 0 : static void i915_enable_asle_pipestat(struct drm_i915_private *dev_priv)
513 : : {
514 [ # # # # ]: 0 : if (!i915_has_asle(dev_priv))
515 : : return;
516 : :
517 : 0 : spin_lock_irq(&dev_priv->irq_lock);
518 : :
519 : 0 : i915_enable_pipestat(dev_priv, PIPE_B, PIPE_LEGACY_BLC_EVENT_STATUS);
520 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 4)
521 : 0 : i915_enable_pipestat(dev_priv, PIPE_A,
522 : : PIPE_LEGACY_BLC_EVENT_STATUS);
523 : :
524 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
525 : : }
526 : :
527 : : /*
528 : : * This timing diagram depicts the video signal in and
529 : : * around the vertical blanking period.
530 : : *
531 : : * Assumptions about the fictitious mode used in this example:
532 : : * vblank_start >= 3
533 : : * vsync_start = vblank_start + 1
534 : : * vsync_end = vblank_start + 2
535 : : * vtotal = vblank_start + 3
536 : : *
537 : : * start of vblank:
538 : : * latch double buffered registers
539 : : * increment frame counter (ctg+)
540 : : * generate start of vblank interrupt (gen4+)
541 : : * |
542 : : * | frame start:
543 : : * | generate frame start interrupt (aka. vblank interrupt) (gmch)
544 : : * | may be shifted forward 1-3 extra lines via PIPECONF
545 : : * | |
546 : : * | | start of vsync:
547 : : * | | generate vsync interrupt
548 : : * | | |
549 : : * ___xxxx___ ___xxxx___ ___xxxx___ ___xxxx___ ___xxxx___ ___xxxx
550 : : * . \hs/ . \hs/ \hs/ \hs/ . \hs/
551 : : * ----va---> <-----------------vb--------------------> <--------va-------------
552 : : * | | <----vs-----> |
553 : : * -vbs-----> <---vbs+1---> <---vbs+2---> <-----0-----> <-----1-----> <-----2--- (scanline counter gen2)
554 : : * -vbs-2---> <---vbs-1---> <---vbs-----> <---vbs+1---> <---vbs+2---> <-----0--- (scanline counter gen3+)
555 : : * -vbs-2---> <---vbs-2---> <---vbs-1---> <---vbs-----> <---vbs+1---> <---vbs+2- (scanline counter hsw+ hdmi)
556 : : * | | |
557 : : * last visible pixel first visible pixel
558 : : * | increment frame counter (gen3/4)
559 : : * pixel counter = vblank_start * htotal pixel counter = 0 (gen3/4)
560 : : *
561 : : * x = horizontal active
562 : : * _ = horizontal blanking
563 : : * hs = horizontal sync
564 : : * va = vertical active
565 : : * vb = vertical blanking
566 : : * vs = vertical sync
567 : : * vbs = vblank_start (number)
568 : : *
569 : : * Summary:
570 : : * - most events happen at the start of horizontal sync
571 : : * - frame start happens at the start of horizontal blank, 1-4 lines
572 : : * (depending on PIPECONF settings) after the start of vblank
573 : : * - gen3/4 pixel and frame counter are synchronized with the start
574 : : * of horizontal active on the first line of vertical active
575 : : */
576 : :
577 : : /* Called from drm generic code, passed a 'crtc', which
578 : : * we use as a pipe index
579 : : */
580 : 0 : u32 i915_get_vblank_counter(struct drm_crtc *crtc)
581 : : {
582 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
583 [ # # ]: 0 : struct drm_vblank_crtc *vblank = &dev_priv->drm.vblank[drm_crtc_index(crtc)];
584 : 0 : const struct drm_display_mode *mode = &vblank->hwmode;
585 : 0 : enum pipe pipe = to_intel_crtc(crtc)->pipe;
586 : 0 : i915_reg_t high_frame, low_frame;
587 : 0 : u32 high1, high2, low, pixel, vbl_start, hsync_start, htotal;
588 : 0 : unsigned long irqflags;
589 : :
590 : : /*
591 : : * On i965gm TV output the frame counter only works up to
592 : : * the point when we enable the TV encoder. After that the
593 : : * frame counter ceases to work and reads zero. We need a
594 : : * vblank wait before enabling the TV encoder and so we
595 : : * have to enable vblank interrupts while the frame counter
596 : : * is still in a working state. However the core vblank code
597 : : * does not like us returning non-zero frame counter values
598 : : * when we've told it that we don't have a working frame
599 : : * counter. Thus we must stop non-zero values leaking out.
600 : : */
601 [ # # ]: 0 : if (!vblank->max_vblank_count)
602 : : return 0;
603 : :
604 : 0 : htotal = mode->crtc_htotal;
605 : 0 : hsync_start = mode->crtc_hsync_start;
606 : 0 : vbl_start = mode->crtc_vblank_start;
607 [ # # ]: 0 : if (mode->flags & DRM_MODE_FLAG_INTERLACE)
608 : 0 : vbl_start = DIV_ROUND_UP(vbl_start, 2);
609 : :
610 : : /* Convert to pixel count */
611 : 0 : vbl_start *= htotal;
612 : :
613 : : /* Start of vblank event occurs at start of hsync */
614 : 0 : vbl_start -= htotal - hsync_start;
615 : :
616 : 0 : high_frame = PIPEFRAME(pipe);
617 : 0 : low_frame = PIPEFRAMEPIXEL(pipe);
618 : :
619 : 0 : spin_lock_irqsave(&dev_priv->uncore.lock, irqflags);
620 : :
621 : : /*
622 : : * High & low register fields aren't synchronized, so make sure
623 : : * we get a low value that's stable across two reads of the high
624 : : * register.
625 : : */
626 : 0 : do {
627 : 0 : high1 = I915_READ_FW(high_frame) & PIPE_FRAME_HIGH_MASK;
628 : 0 : low = I915_READ_FW(low_frame);
629 : 0 : high2 = I915_READ_FW(high_frame) & PIPE_FRAME_HIGH_MASK;
630 [ # # ]: 0 : } while (high1 != high2);
631 : :
632 : 0 : spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags);
633 : :
634 : 0 : high1 >>= PIPE_FRAME_HIGH_SHIFT;
635 : 0 : pixel = low & PIPE_PIXEL_MASK;
636 : 0 : low >>= PIPE_FRAME_LOW_SHIFT;
637 : :
638 : : /*
639 : : * The frame counter increments at beginning of active.
640 : : * Cook up a vblank counter by also checking the pixel
641 : : * counter against vblank start.
642 : : */
643 : 0 : return (((high1 << 8) | low) + (pixel >= vbl_start)) & 0xffffff;
644 : : }
645 : :
646 : 0 : u32 g4x_get_vblank_counter(struct drm_crtc *crtc)
647 : : {
648 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
649 : 0 : enum pipe pipe = to_intel_crtc(crtc)->pipe;
650 : :
651 : 0 : return I915_READ(PIPE_FRMCOUNT_G4X(pipe));
652 : : }
653 : :
654 : : /*
655 : : * On certain encoders on certain platforms, pipe
656 : : * scanline register will not work to get the scanline,
657 : : * since the timings are driven from the PORT or issues
658 : : * with scanline register updates.
659 : : * This function will use Framestamp and current
660 : : * timestamp registers to calculate the scanline.
661 : : */
662 : 0 : static u32 __intel_get_crtc_scanline_from_timestamp(struct intel_crtc *crtc)
663 : : {
664 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
665 : 0 : struct drm_vblank_crtc *vblank =
666 : 0 : &crtc->base.dev->vblank[drm_crtc_index(&crtc->base)];
667 : 0 : const struct drm_display_mode *mode = &vblank->hwmode;
668 : 0 : u32 vblank_start = mode->crtc_vblank_start;
669 : 0 : u32 vtotal = mode->crtc_vtotal;
670 : 0 : u32 htotal = mode->crtc_htotal;
671 : 0 : u32 clock = mode->crtc_clock;
672 : 0 : u32 scanline, scan_prev_time, scan_curr_time, scan_post_time;
673 : :
674 : : /*
675 : : * To avoid the race condition where we might cross into the
676 : : * next vblank just between the PIPE_FRMTMSTMP and TIMESTAMP_CTR
677 : : * reads. We make sure we read PIPE_FRMTMSTMP and TIMESTAMP_CTR
678 : : * during the same frame.
679 : : */
680 : 0 : do {
681 : : /*
682 : : * This field provides read back of the display
683 : : * pipe frame time stamp. The time stamp value
684 : : * is sampled at every start of vertical blank.
685 : : */
686 : 0 : scan_prev_time = I915_READ_FW(PIPE_FRMTMSTMP(crtc->pipe));
687 : :
688 : : /*
689 : : * The TIMESTAMP_CTR register has the current
690 : : * time stamp value.
691 : : */
692 : 0 : scan_curr_time = I915_READ_FW(IVB_TIMESTAMP_CTR);
693 : :
694 : 0 : scan_post_time = I915_READ_FW(PIPE_FRMTMSTMP(crtc->pipe));
695 [ # # ]: 0 : } while (scan_post_time != scan_prev_time);
696 : :
697 : 0 : scanline = div_u64(mul_u32_u32(scan_curr_time - scan_prev_time,
698 : : clock), 1000 * htotal);
699 : 0 : scanline = min(scanline, vtotal - 1);
700 : 0 : scanline = (scanline + vblank_start) % vtotal;
701 : :
702 : 0 : return scanline;
703 : : }
704 : :
705 : : /* I915_READ_FW, only for fast reads of display block, no need for forcewake etc. */
706 : 0 : static int __intel_get_crtc_scanline(struct intel_crtc *crtc)
707 : : {
708 : 0 : struct drm_device *dev = crtc->base.dev;
709 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(dev);
710 : 0 : const struct drm_display_mode *mode;
711 : 0 : struct drm_vblank_crtc *vblank;
712 : 0 : enum pipe pipe = crtc->pipe;
713 : 0 : int position, vtotal;
714 : :
715 [ # # ]: 0 : if (!crtc->active)
716 : : return -1;
717 : :
718 [ # # ]: 0 : vblank = &crtc->base.dev->vblank[drm_crtc_index(&crtc->base)];
719 : 0 : mode = &vblank->hwmode;
720 : :
721 [ # # ]: 0 : if (mode->private_flags & I915_MODE_FLAG_GET_SCANLINE_FROM_TIMESTAMP)
722 : 0 : return __intel_get_crtc_scanline_from_timestamp(crtc);
723 : :
724 : 0 : vtotal = mode->crtc_vtotal;
725 [ # # ]: 0 : if (mode->flags & DRM_MODE_FLAG_INTERLACE)
726 : 0 : vtotal /= 2;
727 : :
728 [ # # ]: 0 : if (IS_GEN(dev_priv, 2))
729 : 0 : position = I915_READ_FW(PIPEDSL(pipe)) & DSL_LINEMASK_GEN2;
730 : : else
731 : 0 : position = I915_READ_FW(PIPEDSL(pipe)) & DSL_LINEMASK_GEN3;
732 : :
733 : : /*
734 : : * On HSW, the DSL reg (0x70000) appears to return 0 if we
735 : : * read it just before the start of vblank. So try it again
736 : : * so we don't accidentally end up spanning a vblank frame
737 : : * increment, causing the pipe_update_end() code to squak at us.
738 : : *
739 : : * The nature of this problem means we can't simply check the ISR
740 : : * bit and return the vblank start value; nor can we use the scanline
741 : : * debug register in the transcoder as it appears to have the same
742 : : * problem. We may need to extend this to include other platforms,
743 : : * but so far testing only shows the problem on HSW.
744 : : */
745 [ # # # # ]: 0 : if (HAS_DDI(dev_priv) && !position) {
746 : : int i, temp;
747 : :
748 [ # # ]: 0 : for (i = 0; i < 100; i++) {
749 : 0 : udelay(1);
750 : 0 : temp = I915_READ_FW(PIPEDSL(pipe)) & DSL_LINEMASK_GEN3;
751 [ # # ]: 0 : if (temp != position) {
752 : : position = temp;
753 : : break;
754 : : }
755 : : }
756 : : }
757 : :
758 : : /*
759 : : * See update_scanline_offset() for the details on the
760 : : * scanline_offset adjustment.
761 : : */
762 : 0 : return (position + crtc->scanline_offset) % vtotal;
763 : : }
764 : :
765 : 0 : bool i915_get_crtc_scanoutpos(struct drm_device *dev, unsigned int index,
766 : : bool in_vblank_irq, int *vpos, int *hpos,
767 : : ktime_t *stime, ktime_t *etime,
768 : : const struct drm_display_mode *mode)
769 : : {
770 : 0 : struct drm_i915_private *dev_priv = to_i915(dev);
771 : 0 : struct intel_crtc *crtc = to_intel_crtc(drm_crtc_from_index(dev, index));
772 : 0 : enum pipe pipe = crtc->pipe;
773 : 0 : int position;
774 : 0 : int vbl_start, vbl_end, hsync_start, htotal, vtotal;
775 : 0 : unsigned long irqflags;
776 [ # # ]: 0 : bool use_scanline_counter = INTEL_GEN(dev_priv) >= 5 ||
777 [ # # # # : 0 : IS_G4X(dev_priv) || IS_GEN(dev_priv, 2) ||
# # ]
778 [ # # ]: 0 : mode->private_flags & I915_MODE_FLAG_USE_SCANLINE_COUNTER;
779 : :
780 [ # # # # ]: 0 : if (WARN_ON(!mode->crtc_clock)) {
781 : 0 : DRM_DEBUG_DRIVER("trying to get scanoutpos for disabled "
782 : : "pipe %c\n", pipe_name(pipe));
783 : 0 : return false;
784 : : }
785 : :
786 : 0 : htotal = mode->crtc_htotal;
787 : 0 : hsync_start = mode->crtc_hsync_start;
788 : 0 : vtotal = mode->crtc_vtotal;
789 : 0 : vbl_start = mode->crtc_vblank_start;
790 : 0 : vbl_end = mode->crtc_vblank_end;
791 : :
792 [ # # ]: 0 : if (mode->flags & DRM_MODE_FLAG_INTERLACE) {
793 : 0 : vbl_start = DIV_ROUND_UP(vbl_start, 2);
794 : 0 : vbl_end /= 2;
795 : 0 : vtotal /= 2;
796 : : }
797 : :
798 : : /*
799 : : * Lock uncore.lock, as we will do multiple timing critical raw
800 : : * register reads, potentially with preemption disabled, so the
801 : : * following code must not block on uncore.lock.
802 : : */
803 : 0 : spin_lock_irqsave(&dev_priv->uncore.lock, irqflags);
804 : :
805 : : /* preempt_disable_rt() should go right here in PREEMPT_RT patchset. */
806 : :
807 : : /* Get optional system timestamp before query. */
808 [ # # ]: 0 : if (stime)
809 : 0 : *stime = ktime_get();
810 : :
811 [ # # ]: 0 : if (use_scanline_counter) {
812 : : /* No obvious pixelcount register. Only query vertical
813 : : * scanout position from Display scan line register.
814 : : */
815 : 0 : position = __intel_get_crtc_scanline(crtc);
816 : : } else {
817 : : /* Have access to pixelcount since start of frame.
818 : : * We can split this into vertical and horizontal
819 : : * scanout position.
820 : : */
821 : 0 : position = (I915_READ_FW(PIPEFRAMEPIXEL(pipe)) & PIPE_PIXEL_MASK) >> PIPE_PIXEL_SHIFT;
822 : :
823 : : /* convert to pixel counts */
824 : 0 : vbl_start *= htotal;
825 : 0 : vbl_end *= htotal;
826 : 0 : vtotal *= htotal;
827 : :
828 : : /*
829 : : * In interlaced modes, the pixel counter counts all pixels,
830 : : * so one field will have htotal more pixels. In order to avoid
831 : : * the reported position from jumping backwards when the pixel
832 : : * counter is beyond the length of the shorter field, just
833 : : * clamp the position the length of the shorter field. This
834 : : * matches how the scanline counter based position works since
835 : : * the scanline counter doesn't count the two half lines.
836 : : */
837 [ # # ]: 0 : if (position >= vtotal)
838 : 0 : position = vtotal - 1;
839 : :
840 : : /*
841 : : * Start of vblank interrupt is triggered at start of hsync,
842 : : * just prior to the first active line of vblank. However we
843 : : * consider lines to start at the leading edge of horizontal
844 : : * active. So, should we get here before we've crossed into
845 : : * the horizontal active of the first line in vblank, we would
846 : : * not set the DRM_SCANOUTPOS_INVBL flag. In order to fix that,
847 : : * always add htotal-hsync_start to the current pixel position.
848 : : */
849 : 0 : position = (position + htotal - hsync_start) % vtotal;
850 : : }
851 : :
852 : : /* Get optional system timestamp after query. */
853 [ # # ]: 0 : if (etime)
854 : 0 : *etime = ktime_get();
855 : :
856 : : /* preempt_enable_rt() should go right here in PREEMPT_RT patchset. */
857 : :
858 : 0 : spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags);
859 : :
860 : : /*
861 : : * While in vblank, position will be negative
862 : : * counting up towards 0 at vbl_end. And outside
863 : : * vblank, position will be positive counting
864 : : * up since vbl_end.
865 : : */
866 [ # # ]: 0 : if (position >= vbl_start)
867 : 0 : position -= vbl_end;
868 : : else
869 : 0 : position += vtotal - vbl_end;
870 : :
871 [ # # ]: 0 : if (use_scanline_counter) {
872 : 0 : *vpos = position;
873 : 0 : *hpos = 0;
874 : : } else {
875 : 0 : *vpos = position / htotal;
876 : 0 : *hpos = position - (*vpos * htotal);
877 : : }
878 : :
879 : : return true;
880 : : }
881 : :
882 : 0 : int intel_get_crtc_scanline(struct intel_crtc *crtc)
883 : : {
884 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
885 : 0 : unsigned long irqflags;
886 : 0 : int position;
887 : :
888 : 0 : spin_lock_irqsave(&dev_priv->uncore.lock, irqflags);
889 : 0 : position = __intel_get_crtc_scanline(crtc);
890 : 0 : spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags);
891 : :
892 : 0 : return position;
893 : : }
894 : :
895 : : /**
896 : : * ivb_parity_work - Workqueue called when a parity error interrupt
897 : : * occurred.
898 : : * @work: workqueue struct
899 : : *
900 : : * Doesn't actually do anything except notify userspace. As a consequence of
901 : : * this event, userspace should try to remap the bad rows since statistically
902 : : * it is likely the same row is more likely to go bad again.
903 : : */
904 : 0 : static void ivb_parity_work(struct work_struct *work)
905 : : {
906 : 0 : struct drm_i915_private *dev_priv =
907 : 0 : container_of(work, typeof(*dev_priv), l3_parity.error_work);
908 : 0 : struct intel_gt *gt = &dev_priv->gt;
909 : 0 : u32 error_status, row, bank, subbank;
910 : 0 : char *parity_event[6];
911 : 0 : u32 misccpctl;
912 : 0 : u8 slice = 0;
913 : :
914 : : /* We must turn off DOP level clock gating to access the L3 registers.
915 : : * In order to prevent a get/put style interface, acquire struct mutex
916 : : * any time we access those registers.
917 : : */
918 : 0 : mutex_lock(&dev_priv->drm.struct_mutex);
919 : :
920 : : /* If we've screwed up tracking, just let the interrupt fire again */
921 [ # # # # ]: 0 : if (WARN_ON(!dev_priv->l3_parity.which_slice))
922 : 0 : goto out;
923 : :
924 : 0 : misccpctl = I915_READ(GEN7_MISCCPCTL);
925 : 0 : I915_WRITE(GEN7_MISCCPCTL, misccpctl & ~GEN7_DOP_CLOCK_GATE_ENABLE);
926 : 0 : POSTING_READ(GEN7_MISCCPCTL);
927 : :
928 [ # # ]: 0 : while ((slice = ffs(dev_priv->l3_parity.which_slice)) != 0) {
929 : 0 : i915_reg_t reg;
930 : :
931 : 0 : slice--;
932 [ # # # # : 0 : if (WARN_ON_ONCE(slice >= NUM_L3_SLICES(dev_priv)))
# # # # #
# ]
933 : : break;
934 : :
935 : 0 : dev_priv->l3_parity.which_slice &= ~(1<<slice);
936 : :
937 : 0 : reg = GEN7_L3CDERRST1(slice);
938 : :
939 : 0 : error_status = I915_READ(reg);
940 : 0 : row = GEN7_PARITY_ERROR_ROW(error_status);
941 : 0 : bank = GEN7_PARITY_ERROR_BANK(error_status);
942 : 0 : subbank = GEN7_PARITY_ERROR_SUBBANK(error_status);
943 : :
944 : 0 : I915_WRITE(reg, GEN7_PARITY_ERROR_VALID | GEN7_L3CDERRST1_ENABLE);
945 : 0 : POSTING_READ(reg);
946 : :
947 : 0 : parity_event[0] = I915_L3_PARITY_UEVENT "=1";
948 : 0 : parity_event[1] = kasprintf(GFP_KERNEL, "ROW=%d", row);
949 : 0 : parity_event[2] = kasprintf(GFP_KERNEL, "BANK=%d", bank);
950 : 0 : parity_event[3] = kasprintf(GFP_KERNEL, "SUBBANK=%d", subbank);
951 : 0 : parity_event[4] = kasprintf(GFP_KERNEL, "SLICE=%d", slice);
952 : 0 : parity_event[5] = NULL;
953 : :
954 : 0 : kobject_uevent_env(&dev_priv->drm.primary->kdev->kobj,
955 : : KOBJ_CHANGE, parity_event);
956 : :
957 : 0 : DRM_DEBUG("Parity error: Slice = %d, Row = %d, Bank = %d, Sub bank = %d.\n",
958 : : slice, row, bank, subbank);
959 : :
960 : 0 : kfree(parity_event[4]);
961 : 0 : kfree(parity_event[3]);
962 : 0 : kfree(parity_event[2]);
963 : 0 : kfree(parity_event[1]);
964 : : }
965 : :
966 : 0 : I915_WRITE(GEN7_MISCCPCTL, misccpctl);
967 : :
968 : 0 : out:
969 [ # # ]: 0 : WARN_ON(dev_priv->l3_parity.which_slice);
970 : 0 : spin_lock_irq(>->irq_lock);
971 [ # # ]: 0 : gen5_gt_enable_irq(gt, GT_PARITY_ERROR(dev_priv));
972 : 0 : spin_unlock_irq(>->irq_lock);
973 : :
974 : 0 : mutex_unlock(&dev_priv->drm.struct_mutex);
975 : 0 : }
976 : :
977 : 0 : static bool gen11_port_hotplug_long_detect(enum hpd_pin pin, u32 val)
978 : : {
979 [ # # # # : 0 : switch (pin) {
# ]
980 : 0 : case HPD_PORT_C:
981 : 0 : return val & GEN11_HOTPLUG_CTL_LONG_DETECT(PORT_TC1);
982 : 0 : case HPD_PORT_D:
983 : 0 : return val & GEN11_HOTPLUG_CTL_LONG_DETECT(PORT_TC2);
984 : 0 : case HPD_PORT_E:
985 : 0 : return val & GEN11_HOTPLUG_CTL_LONG_DETECT(PORT_TC3);
986 : 0 : case HPD_PORT_F:
987 : 0 : return val & GEN11_HOTPLUG_CTL_LONG_DETECT(PORT_TC4);
988 : : default:
989 : : return false;
990 : : }
991 : : }
992 : :
993 : 0 : static bool gen12_port_hotplug_long_detect(enum hpd_pin pin, u32 val)
994 : : {
995 [ # # # # : 0 : switch (pin) {
# # # ]
996 : 0 : case HPD_PORT_D:
997 : 0 : return val & GEN11_HOTPLUG_CTL_LONG_DETECT(PORT_TC1);
998 : 0 : case HPD_PORT_E:
999 : 0 : return val & GEN11_HOTPLUG_CTL_LONG_DETECT(PORT_TC2);
1000 : 0 : case HPD_PORT_F:
1001 : 0 : return val & GEN11_HOTPLUG_CTL_LONG_DETECT(PORT_TC3);
1002 : 0 : case HPD_PORT_G:
1003 : 0 : return val & GEN11_HOTPLUG_CTL_LONG_DETECT(PORT_TC4);
1004 : 0 : case HPD_PORT_H:
1005 : 0 : return val & GEN11_HOTPLUG_CTL_LONG_DETECT(PORT_TC5);
1006 : 0 : case HPD_PORT_I:
1007 : 0 : return val & GEN11_HOTPLUG_CTL_LONG_DETECT(PORT_TC6);
1008 : : default:
1009 : : return false;
1010 : : }
1011 : : }
1012 : :
1013 : 0 : static bool bxt_port_hotplug_long_detect(enum hpd_pin pin, u32 val)
1014 : : {
1015 [ # # # # ]: 0 : switch (pin) {
1016 : 0 : case HPD_PORT_A:
1017 : 0 : return val & PORTA_HOTPLUG_LONG_DETECT;
1018 : 0 : case HPD_PORT_B:
1019 : 0 : return val & PORTB_HOTPLUG_LONG_DETECT;
1020 : 0 : case HPD_PORT_C:
1021 : 0 : return val & PORTC_HOTPLUG_LONG_DETECT;
1022 : : default:
1023 : : return false;
1024 : : }
1025 : : }
1026 : :
1027 : 0 : static bool icp_ddi_port_hotplug_long_detect(enum hpd_pin pin, u32 val)
1028 : : {
1029 [ # # # # ]: 0 : switch (pin) {
1030 : 0 : case HPD_PORT_A:
1031 : 0 : return val & SHOTPLUG_CTL_DDI_HPD_LONG_DETECT(PORT_A);
1032 : 0 : case HPD_PORT_B:
1033 : 0 : return val & SHOTPLUG_CTL_DDI_HPD_LONG_DETECT(PORT_B);
1034 : 0 : case HPD_PORT_C:
1035 : 0 : return val & SHOTPLUG_CTL_DDI_HPD_LONG_DETECT(PORT_C);
1036 : : default:
1037 : : return false;
1038 : : }
1039 : : }
1040 : :
1041 : 0 : static bool icp_tc_port_hotplug_long_detect(enum hpd_pin pin, u32 val)
1042 : : {
1043 [ # # # # : 0 : switch (pin) {
# ]
1044 : 0 : case HPD_PORT_C:
1045 : 0 : return val & ICP_TC_HPD_LONG_DETECT(PORT_TC1);
1046 : 0 : case HPD_PORT_D:
1047 : 0 : return val & ICP_TC_HPD_LONG_DETECT(PORT_TC2);
1048 : 0 : case HPD_PORT_E:
1049 : 0 : return val & ICP_TC_HPD_LONG_DETECT(PORT_TC3);
1050 : 0 : case HPD_PORT_F:
1051 : 0 : return val & ICP_TC_HPD_LONG_DETECT(PORT_TC4);
1052 : : default:
1053 : : return false;
1054 : : }
1055 : : }
1056 : :
1057 : 0 : static bool tgp_tc_port_hotplug_long_detect(enum hpd_pin pin, u32 val)
1058 : : {
1059 [ # # # # : 0 : switch (pin) {
# # # ]
1060 : 0 : case HPD_PORT_D:
1061 : 0 : return val & ICP_TC_HPD_LONG_DETECT(PORT_TC1);
1062 : 0 : case HPD_PORT_E:
1063 : 0 : return val & ICP_TC_HPD_LONG_DETECT(PORT_TC2);
1064 : 0 : case HPD_PORT_F:
1065 : 0 : return val & ICP_TC_HPD_LONG_DETECT(PORT_TC3);
1066 : 0 : case HPD_PORT_G:
1067 : 0 : return val & ICP_TC_HPD_LONG_DETECT(PORT_TC4);
1068 : 0 : case HPD_PORT_H:
1069 : 0 : return val & ICP_TC_HPD_LONG_DETECT(PORT_TC5);
1070 : 0 : case HPD_PORT_I:
1071 : 0 : return val & ICP_TC_HPD_LONG_DETECT(PORT_TC6);
1072 : : default:
1073 : : return false;
1074 : : }
1075 : : }
1076 : :
1077 : 0 : static bool spt_port_hotplug2_long_detect(enum hpd_pin pin, u32 val)
1078 : : {
1079 [ # # ]: 0 : switch (pin) {
1080 : 0 : case HPD_PORT_E:
1081 : 0 : return val & PORTE_HOTPLUG_LONG_DETECT;
1082 : : default:
1083 : : return false;
1084 : : }
1085 : : }
1086 : :
1087 : 0 : static bool spt_port_hotplug_long_detect(enum hpd_pin pin, u32 val)
1088 : : {
1089 [ # # # # : 0 : switch (pin) {
# ]
1090 : 0 : case HPD_PORT_A:
1091 : 0 : return val & PORTA_HOTPLUG_LONG_DETECT;
1092 : 0 : case HPD_PORT_B:
1093 : 0 : return val & PORTB_HOTPLUG_LONG_DETECT;
1094 : 0 : case HPD_PORT_C:
1095 : 0 : return val & PORTC_HOTPLUG_LONG_DETECT;
1096 : 0 : case HPD_PORT_D:
1097 : 0 : return val & PORTD_HOTPLUG_LONG_DETECT;
1098 : : default:
1099 : : return false;
1100 : : }
1101 : : }
1102 : :
1103 : 0 : static bool ilk_port_hotplug_long_detect(enum hpd_pin pin, u32 val)
1104 : : {
1105 [ # # ]: 0 : switch (pin) {
1106 : 0 : case HPD_PORT_A:
1107 : 0 : return val & DIGITAL_PORTA_HOTPLUG_LONG_DETECT;
1108 : : default:
1109 : : return false;
1110 : : }
1111 : : }
1112 : :
1113 : 0 : static bool pch_port_hotplug_long_detect(enum hpd_pin pin, u32 val)
1114 : : {
1115 [ # # # # ]: 0 : switch (pin) {
1116 : 0 : case HPD_PORT_B:
1117 : 0 : return val & PORTB_HOTPLUG_LONG_DETECT;
1118 : 0 : case HPD_PORT_C:
1119 : 0 : return val & PORTC_HOTPLUG_LONG_DETECT;
1120 : 0 : case HPD_PORT_D:
1121 : 0 : return val & PORTD_HOTPLUG_LONG_DETECT;
1122 : : default:
1123 : : return false;
1124 : : }
1125 : : }
1126 : :
1127 : 0 : static bool i9xx_port_hotplug_long_detect(enum hpd_pin pin, u32 val)
1128 : : {
1129 [ # # # # ]: 0 : switch (pin) {
1130 : 0 : case HPD_PORT_B:
1131 : 0 : return val & PORTB_HOTPLUG_INT_LONG_PULSE;
1132 : 0 : case HPD_PORT_C:
1133 : 0 : return val & PORTC_HOTPLUG_INT_LONG_PULSE;
1134 : 0 : case HPD_PORT_D:
1135 : 0 : return val & PORTD_HOTPLUG_INT_LONG_PULSE;
1136 : : default:
1137 : : return false;
1138 : : }
1139 : : }
1140 : :
1141 : : /*
1142 : : * Get a bit mask of pins that have triggered, and which ones may be long.
1143 : : * This can be called multiple times with the same masks to accumulate
1144 : : * hotplug detection results from several registers.
1145 : : *
1146 : : * Note that the caller is expected to zero out the masks initially.
1147 : : */
1148 : : static void intel_get_hpd_pins(struct drm_i915_private *dev_priv,
1149 : : u32 *pin_mask, u32 *long_mask,
1150 : : u32 hotplug_trigger, u32 dig_hotplug_reg,
1151 : : const u32 hpd[HPD_NUM_PINS],
1152 : : bool long_pulse_detect(enum hpd_pin pin, u32 val))
1153 : : {
1154 : : enum hpd_pin pin;
1155 : :
1156 : : BUILD_BUG_ON(BITS_PER_TYPE(*pin_mask) < HPD_NUM_PINS);
1157 : :
1158 : : for_each_hpd_pin(pin) {
1159 : : if ((hpd[pin] & hotplug_trigger) == 0)
1160 : : continue;
1161 : :
1162 : : *pin_mask |= BIT(pin);
1163 : :
1164 : : if (long_pulse_detect(pin, dig_hotplug_reg))
1165 : : *long_mask |= BIT(pin);
1166 : : }
1167 : :
1168 : : DRM_DEBUG_DRIVER("hotplug event received, stat 0x%08x, dig 0x%08x, pins 0x%08x, long 0x%08x\n",
1169 : : hotplug_trigger, dig_hotplug_reg, *pin_mask, *long_mask);
1170 : :
1171 : : }
1172 : :
1173 : 0 : static void gmbus_irq_handler(struct drm_i915_private *dev_priv)
1174 : : {
1175 : 0 : wake_up_all(&dev_priv->gmbus_wait_queue);
1176 : 0 : }
1177 : :
1178 : 0 : static void dp_aux_irq_handler(struct drm_i915_private *dev_priv)
1179 : : {
1180 : 0 : wake_up_all(&dev_priv->gmbus_wait_queue);
1181 : 0 : }
1182 : :
1183 : : #if defined(CONFIG_DEBUG_FS)
1184 : 0 : static void display_pipe_crc_irq_handler(struct drm_i915_private *dev_priv,
1185 : : enum pipe pipe,
1186 : : u32 crc0, u32 crc1,
1187 : : u32 crc2, u32 crc3,
1188 : : u32 crc4)
1189 : : {
1190 : 0 : struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[pipe];
1191 : 0 : struct intel_crtc *crtc = intel_get_crtc_for_pipe(dev_priv, pipe);
1192 : 0 : u32 crcs[5] = { crc0, crc1, crc2, crc3, crc4 };
1193 : :
1194 : 0 : trace_intel_pipe_crc(crtc, crcs);
1195 : :
1196 : 0 : spin_lock(&pipe_crc->lock);
1197 : : /*
1198 : : * For some not yet identified reason, the first CRC is
1199 : : * bonkers. So let's just wait for the next vblank and read
1200 : : * out the buggy result.
1201 : : *
1202 : : * On GEN8+ sometimes the second CRC is bonkers as well, so
1203 : : * don't trust that one either.
1204 : : */
1205 [ # # ]: 0 : if (pipe_crc->skipped <= 0 ||
1206 [ # # # # ]: 0 : (INTEL_GEN(dev_priv) >= 8 && pipe_crc->skipped == 1)) {
1207 : 0 : pipe_crc->skipped++;
1208 : 0 : spin_unlock(&pipe_crc->lock);
1209 : 0 : return;
1210 : : }
1211 : 0 : spin_unlock(&pipe_crc->lock);
1212 : :
1213 : 0 : drm_crtc_add_crc_entry(&crtc->base, true,
1214 : 0 : drm_crtc_accurate_vblank_count(&crtc->base),
1215 : : crcs);
1216 : : }
1217 : : #else
1218 : : static inline void
1219 : : display_pipe_crc_irq_handler(struct drm_i915_private *dev_priv,
1220 : : enum pipe pipe,
1221 : : u32 crc0, u32 crc1,
1222 : : u32 crc2, u32 crc3,
1223 : : u32 crc4) {}
1224 : : #endif
1225 : :
1226 : :
1227 : 0 : static void hsw_pipe_crc_irq_handler(struct drm_i915_private *dev_priv,
1228 : : enum pipe pipe)
1229 : : {
1230 : 0 : display_pipe_crc_irq_handler(dev_priv, pipe,
1231 : 0 : I915_READ(PIPE_CRC_RES_1_IVB(pipe)),
1232 : : 0, 0, 0, 0);
1233 : 0 : }
1234 : :
1235 : 0 : static void ivb_pipe_crc_irq_handler(struct drm_i915_private *dev_priv,
1236 : : enum pipe pipe)
1237 : : {
1238 : 0 : display_pipe_crc_irq_handler(dev_priv, pipe,
1239 : 0 : I915_READ(PIPE_CRC_RES_1_IVB(pipe)),
1240 : 0 : I915_READ(PIPE_CRC_RES_2_IVB(pipe)),
1241 : 0 : I915_READ(PIPE_CRC_RES_3_IVB(pipe)),
1242 : 0 : I915_READ(PIPE_CRC_RES_4_IVB(pipe)),
1243 : 0 : I915_READ(PIPE_CRC_RES_5_IVB(pipe)));
1244 : 0 : }
1245 : :
1246 : 0 : static void i9xx_pipe_crc_irq_handler(struct drm_i915_private *dev_priv,
1247 : : enum pipe pipe)
1248 : : {
1249 : 0 : u32 res1, res2;
1250 : :
1251 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 3)
1252 : 0 : res1 = I915_READ(PIPE_CRC_RES_RES1_I915(pipe));
1253 : : else
1254 : : res1 = 0;
1255 : :
1256 [ # # # # : 0 : if (INTEL_GEN(dev_priv) >= 5 || IS_G4X(dev_priv))
# # ]
1257 : 0 : res2 = I915_READ(PIPE_CRC_RES_RES2_G4X(pipe));
1258 : : else
1259 : : res2 = 0;
1260 : :
1261 : 0 : display_pipe_crc_irq_handler(dev_priv, pipe,
1262 : 0 : I915_READ(PIPE_CRC_RES_RED(pipe)),
1263 : 0 : I915_READ(PIPE_CRC_RES_GREEN(pipe)),
1264 : 0 : I915_READ(PIPE_CRC_RES_BLUE(pipe)),
1265 : : res1, res2);
1266 : 0 : }
1267 : :
1268 : 0 : static void i9xx_pipestat_irq_reset(struct drm_i915_private *dev_priv)
1269 : : {
1270 : 0 : enum pipe pipe;
1271 : :
1272 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
1273 : 0 : I915_WRITE(PIPESTAT(pipe),
1274 : : PIPESTAT_INT_STATUS_MASK |
1275 : : PIPE_FIFO_UNDERRUN_STATUS);
1276 : :
1277 : 0 : dev_priv->pipestat_irq_mask[pipe] = 0;
1278 : : }
1279 : 0 : }
1280 : :
1281 : 0 : static void i9xx_pipestat_irq_ack(struct drm_i915_private *dev_priv,
1282 : : u32 iir, u32 pipe_stats[I915_MAX_PIPES])
1283 : : {
1284 : 0 : enum pipe pipe;
1285 : :
1286 : 0 : spin_lock(&dev_priv->irq_lock);
1287 : :
1288 [ # # ]: 0 : if (!dev_priv->display_irqs_enabled) {
1289 : 0 : spin_unlock(&dev_priv->irq_lock);
1290 : 0 : return;
1291 : : }
1292 : :
1293 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
1294 : 0 : i915_reg_t reg;
1295 : 0 : u32 status_mask, enable_mask, iir_bit = 0;
1296 : :
1297 : : /*
1298 : : * PIPESTAT bits get signalled even when the interrupt is
1299 : : * disabled with the mask bits, and some of the status bits do
1300 : : * not generate interrupts at all (like the underrun bit). Hence
1301 : : * we need to be careful that we only handle what we want to
1302 : : * handle.
1303 : : */
1304 : :
1305 : : /* fifo underruns are filterered in the underrun handler. */
1306 : 0 : status_mask = PIPE_FIFO_UNDERRUN_STATUS;
1307 : :
1308 [ # # # ]: 0 : switch (pipe) {
1309 : : default:
1310 : : case PIPE_A:
1311 : : iir_bit = I915_DISPLAY_PIPE_A_EVENT_INTERRUPT;
1312 : : break;
1313 : 0 : case PIPE_B:
1314 : 0 : iir_bit = I915_DISPLAY_PIPE_B_EVENT_INTERRUPT;
1315 : 0 : break;
1316 : 0 : case PIPE_C:
1317 : 0 : iir_bit = I915_DISPLAY_PIPE_C_EVENT_INTERRUPT;
1318 : 0 : break;
1319 : : }
1320 [ # # ]: 0 : if (iir & iir_bit)
1321 : 0 : status_mask |= dev_priv->pipestat_irq_mask[pipe];
1322 : :
1323 : 0 : if (!status_mask)
1324 : : continue;
1325 : :
1326 : 0 : reg = PIPESTAT(pipe);
1327 : 0 : pipe_stats[pipe] = I915_READ(reg) & status_mask;
1328 : 0 : enable_mask = i915_pipestat_enable_mask(dev_priv, pipe);
1329 : :
1330 : : /*
1331 : : * Clear the PIPE*STAT regs before the IIR
1332 : : *
1333 : : * Toggle the enable bits to make sure we get an
1334 : : * edge in the ISR pipe event bit if we don't clear
1335 : : * all the enabled status bits. Otherwise the edge
1336 : : * triggered IIR on i965/g4x wouldn't notice that
1337 : : * an interrupt is still pending.
1338 : : */
1339 [ # # ]: 0 : if (pipe_stats[pipe]) {
1340 : 0 : I915_WRITE(reg, pipe_stats[pipe]);
1341 : 0 : I915_WRITE(reg, enable_mask);
1342 : : }
1343 : : }
1344 : 0 : spin_unlock(&dev_priv->irq_lock);
1345 : : }
1346 : :
1347 : 0 : static void i8xx_pipestat_irq_handler(struct drm_i915_private *dev_priv,
1348 : : u16 iir, u32 pipe_stats[I915_MAX_PIPES])
1349 : : {
1350 : 0 : enum pipe pipe;
1351 : :
1352 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
1353 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_VBLANK_INTERRUPT_STATUS)
1354 : 0 : drm_handle_vblank(&dev_priv->drm, pipe);
1355 : :
1356 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_CRC_DONE_INTERRUPT_STATUS)
1357 : 0 : i9xx_pipe_crc_irq_handler(dev_priv, pipe);
1358 : :
1359 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_FIFO_UNDERRUN_STATUS)
1360 : 0 : intel_cpu_fifo_underrun_irq_handler(dev_priv, pipe);
1361 : : }
1362 : 0 : }
1363 : :
1364 : 0 : static void i915_pipestat_irq_handler(struct drm_i915_private *dev_priv,
1365 : : u32 iir, u32 pipe_stats[I915_MAX_PIPES])
1366 : : {
1367 : 0 : bool blc_event = false;
1368 : 0 : enum pipe pipe;
1369 : :
1370 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
1371 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_VBLANK_INTERRUPT_STATUS)
1372 : 0 : drm_handle_vblank(&dev_priv->drm, pipe);
1373 : :
1374 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_LEGACY_BLC_EVENT_STATUS)
1375 : 0 : blc_event = true;
1376 : :
1377 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_CRC_DONE_INTERRUPT_STATUS)
1378 : 0 : i9xx_pipe_crc_irq_handler(dev_priv, pipe);
1379 : :
1380 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_FIFO_UNDERRUN_STATUS)
1381 : 0 : intel_cpu_fifo_underrun_irq_handler(dev_priv, pipe);
1382 : : }
1383 : :
1384 [ # # # # ]: 0 : if (blc_event || (iir & I915_ASLE_INTERRUPT))
1385 : 0 : intel_opregion_asle_intr(dev_priv);
1386 : 0 : }
1387 : :
1388 : 0 : static void i965_pipestat_irq_handler(struct drm_i915_private *dev_priv,
1389 : : u32 iir, u32 pipe_stats[I915_MAX_PIPES])
1390 : : {
1391 : 0 : bool blc_event = false;
1392 : 0 : enum pipe pipe;
1393 : :
1394 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
1395 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_START_VBLANK_INTERRUPT_STATUS)
1396 : 0 : drm_handle_vblank(&dev_priv->drm, pipe);
1397 : :
1398 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_LEGACY_BLC_EVENT_STATUS)
1399 : 0 : blc_event = true;
1400 : :
1401 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_CRC_DONE_INTERRUPT_STATUS)
1402 : 0 : i9xx_pipe_crc_irq_handler(dev_priv, pipe);
1403 : :
1404 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_FIFO_UNDERRUN_STATUS)
1405 : 0 : intel_cpu_fifo_underrun_irq_handler(dev_priv, pipe);
1406 : : }
1407 : :
1408 [ # # # # ]: 0 : if (blc_event || (iir & I915_ASLE_INTERRUPT))
1409 : 0 : intel_opregion_asle_intr(dev_priv);
1410 : :
1411 [ # # ]: 0 : if (pipe_stats[0] & PIPE_GMBUS_INTERRUPT_STATUS)
1412 : 0 : gmbus_irq_handler(dev_priv);
1413 : 0 : }
1414 : :
1415 : 0 : static void valleyview_pipestat_irq_handler(struct drm_i915_private *dev_priv,
1416 : : u32 pipe_stats[I915_MAX_PIPES])
1417 : : {
1418 : 0 : enum pipe pipe;
1419 : :
1420 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
1421 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_START_VBLANK_INTERRUPT_STATUS)
1422 : 0 : drm_handle_vblank(&dev_priv->drm, pipe);
1423 : :
1424 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_CRC_DONE_INTERRUPT_STATUS)
1425 : 0 : i9xx_pipe_crc_irq_handler(dev_priv, pipe);
1426 : :
1427 [ # # ]: 0 : if (pipe_stats[pipe] & PIPE_FIFO_UNDERRUN_STATUS)
1428 : 0 : intel_cpu_fifo_underrun_irq_handler(dev_priv, pipe);
1429 : : }
1430 : :
1431 [ # # ]: 0 : if (pipe_stats[0] & PIPE_GMBUS_INTERRUPT_STATUS)
1432 : 0 : gmbus_irq_handler(dev_priv);
1433 : 0 : }
1434 : :
1435 : 0 : static u32 i9xx_hpd_irq_ack(struct drm_i915_private *dev_priv)
1436 : : {
1437 : 0 : u32 hotplug_status = 0, hotplug_status_mask;
1438 : 0 : int i;
1439 : :
1440 [ # # # # : 0 : if (IS_G4X(dev_priv) ||
# # ]
1441 [ # # ]: 0 : IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
1442 : : hotplug_status_mask = HOTPLUG_INT_STATUS_G4X |
1443 : : DP_AUX_CHANNEL_MASK_INT_STATUS_G4X;
1444 : : else
1445 : : hotplug_status_mask = HOTPLUG_INT_STATUS_I915;
1446 : :
1447 : : /*
1448 : : * We absolutely have to clear all the pending interrupt
1449 : : * bits in PORT_HOTPLUG_STAT. Otherwise the ISR port
1450 : : * interrupt bit won't have an edge, and the i965/g4x
1451 : : * edge triggered IIR will not notice that an interrupt
1452 : : * is still pending. We can't use PORT_HOTPLUG_EN to
1453 : : * guarantee the edge as the act of toggling the enable
1454 : : * bits can itself generate a new hotplug interrupt :(
1455 : : */
1456 [ # # ]: 0 : for (i = 0; i < 10; i++) {
1457 : 0 : u32 tmp = I915_READ(PORT_HOTPLUG_STAT) & hotplug_status_mask;
1458 : :
1459 [ # # ]: 0 : if (tmp == 0)
1460 : 0 : return hotplug_status;
1461 : :
1462 : 0 : hotplug_status |= tmp;
1463 : 0 : I915_WRITE(PORT_HOTPLUG_STAT, hotplug_status);
1464 : : }
1465 : :
1466 [ # # ]: 0 : WARN_ONCE(1,
1467 : : "PORT_HOTPLUG_STAT did not clear (0x%08x)\n",
1468 : : I915_READ(PORT_HOTPLUG_STAT));
1469 : :
1470 : : return hotplug_status;
1471 : : }
1472 : :
1473 : 0 : static void i9xx_hpd_irq_handler(struct drm_i915_private *dev_priv,
1474 : : u32 hotplug_status)
1475 : : {
1476 : 0 : u32 pin_mask = 0, long_mask = 0;
1477 : :
1478 [ # # # # : 0 : if (IS_G4X(dev_priv) || IS_VALLEYVIEW(dev_priv) ||
# # # # ]
1479 : : IS_CHERRYVIEW(dev_priv)) {
1480 : 0 : u32 hotplug_trigger = hotplug_status & HOTPLUG_INT_STATUS_G4X;
1481 : :
1482 [ # # ]: 0 : if (hotplug_trigger) {
1483 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask,
1484 : : hotplug_trigger, hotplug_trigger,
1485 : : hpd_status_g4x,
1486 : : i9xx_port_hotplug_long_detect);
1487 : :
1488 : 0 : intel_hpd_irq_handler(dev_priv, pin_mask, long_mask);
1489 : : }
1490 : :
1491 [ # # ]: 0 : if (hotplug_status & DP_AUX_CHANNEL_MASK_INT_STATUS_G4X)
1492 : 0 : dp_aux_irq_handler(dev_priv);
1493 : : } else {
1494 : 0 : u32 hotplug_trigger = hotplug_status & HOTPLUG_INT_STATUS_I915;
1495 : :
1496 [ # # ]: 0 : if (hotplug_trigger) {
1497 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask,
1498 : : hotplug_trigger, hotplug_trigger,
1499 : : hpd_status_i915,
1500 : : i9xx_port_hotplug_long_detect);
1501 : 0 : intel_hpd_irq_handler(dev_priv, pin_mask, long_mask);
1502 : : }
1503 : : }
1504 : 0 : }
1505 : :
1506 : 0 : static irqreturn_t valleyview_irq_handler(int irq, void *arg)
1507 : : {
1508 : 0 : struct drm_i915_private *dev_priv = arg;
1509 : 0 : irqreturn_t ret = IRQ_NONE;
1510 : :
1511 : 0 : if (!intel_irqs_enabled(dev_priv))
1512 : : return IRQ_NONE;
1513 : :
1514 : : /* IRQs are synced during runtime_suspend, we don't require a wakeref */
1515 : 0 : disable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
1516 : :
1517 : 0 : do {
1518 : 0 : u32 iir, gt_iir, pm_iir;
1519 : 0 : u32 pipe_stats[I915_MAX_PIPES] = {};
1520 : 0 : u32 hotplug_status = 0;
1521 : 0 : u32 ier = 0;
1522 : :
1523 : 0 : gt_iir = I915_READ(GTIIR);
1524 : 0 : pm_iir = I915_READ(GEN6_PMIIR);
1525 : 0 : iir = I915_READ(VLV_IIR);
1526 : :
1527 [ # # ]: 0 : if (gt_iir == 0 && pm_iir == 0 && iir == 0)
1528 : : break;
1529 : :
1530 : 0 : ret = IRQ_HANDLED;
1531 : :
1532 : : /*
1533 : : * Theory on interrupt generation, based on empirical evidence:
1534 : : *
1535 : : * x = ((VLV_IIR & VLV_IER) ||
1536 : : * (((GT_IIR & GT_IER) || (GEN6_PMIIR & GEN6_PMIER)) &&
1537 : : * (VLV_MASTER_IER & MASTER_INTERRUPT_ENABLE)));
1538 : : *
1539 : : * A CPU interrupt will only be raised when 'x' has a 0->1 edge.
1540 : : * Hence we clear MASTER_INTERRUPT_ENABLE and VLV_IER to
1541 : : * guarantee the CPU interrupt will be raised again even if we
1542 : : * don't end up clearing all the VLV_IIR, GT_IIR, GEN6_PMIIR
1543 : : * bits this time around.
1544 : : */
1545 : 0 : I915_WRITE(VLV_MASTER_IER, 0);
1546 : 0 : ier = I915_READ(VLV_IER);
1547 : 0 : I915_WRITE(VLV_IER, 0);
1548 : :
1549 [ # # ]: 0 : if (gt_iir)
1550 : 0 : I915_WRITE(GTIIR, gt_iir);
1551 [ # # ]: 0 : if (pm_iir)
1552 : 0 : I915_WRITE(GEN6_PMIIR, pm_iir);
1553 : :
1554 [ # # ]: 0 : if (iir & I915_DISPLAY_PORT_INTERRUPT)
1555 : 0 : hotplug_status = i9xx_hpd_irq_ack(dev_priv);
1556 : :
1557 : : /* Call regardless, as some status bits might not be
1558 : : * signalled in iir */
1559 : 0 : i9xx_pipestat_irq_ack(dev_priv, iir, pipe_stats);
1560 : :
1561 [ # # ]: 0 : if (iir & (I915_LPE_PIPE_A_INTERRUPT |
1562 : : I915_LPE_PIPE_B_INTERRUPT))
1563 : 0 : intel_lpe_audio_irq_handler(dev_priv);
1564 : :
1565 : : /*
1566 : : * VLV_IIR is single buffered, and reflects the level
1567 : : * from PIPESTAT/PORT_HOTPLUG_STAT, hence clear it last.
1568 : : */
1569 [ # # ]: 0 : if (iir)
1570 : 0 : I915_WRITE(VLV_IIR, iir);
1571 : :
1572 : 0 : I915_WRITE(VLV_IER, ier);
1573 : 0 : I915_WRITE(VLV_MASTER_IER, MASTER_INTERRUPT_ENABLE);
1574 : :
1575 [ # # ]: 0 : if (gt_iir)
1576 : 0 : gen6_gt_irq_handler(&dev_priv->gt, gt_iir);
1577 [ # # ]: 0 : if (pm_iir)
1578 : 0 : gen6_rps_irq_handler(&dev_priv->gt.rps, pm_iir);
1579 : :
1580 [ # # ]: 0 : if (hotplug_status)
1581 : 0 : i9xx_hpd_irq_handler(dev_priv, hotplug_status);
1582 : :
1583 : 0 : valleyview_pipestat_irq_handler(dev_priv, pipe_stats);
1584 : 0 : } while (0);
1585 : :
1586 : 0 : enable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
1587 : :
1588 : 0 : return ret;
1589 : : }
1590 : :
1591 : 0 : static irqreturn_t cherryview_irq_handler(int irq, void *arg)
1592 : : {
1593 : 0 : struct drm_i915_private *dev_priv = arg;
1594 : 0 : irqreturn_t ret = IRQ_NONE;
1595 : :
1596 : 0 : if (!intel_irqs_enabled(dev_priv))
1597 : : return IRQ_NONE;
1598 : :
1599 : : /* IRQs are synced during runtime_suspend, we don't require a wakeref */
1600 : 0 : disable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
1601 : :
1602 : 0 : do {
1603 : 0 : u32 master_ctl, iir;
1604 : 0 : u32 pipe_stats[I915_MAX_PIPES] = {};
1605 : 0 : u32 hotplug_status = 0;
1606 : 0 : u32 gt_iir[4];
1607 : 0 : u32 ier = 0;
1608 : :
1609 : 0 : master_ctl = I915_READ(GEN8_MASTER_IRQ) & ~GEN8_MASTER_IRQ_CONTROL;
1610 : 0 : iir = I915_READ(VLV_IIR);
1611 : :
1612 [ # # ]: 0 : if (master_ctl == 0 && iir == 0)
1613 : : break;
1614 : :
1615 : 0 : ret = IRQ_HANDLED;
1616 : :
1617 : : /*
1618 : : * Theory on interrupt generation, based on empirical evidence:
1619 : : *
1620 : : * x = ((VLV_IIR & VLV_IER) ||
1621 : : * ((GEN8_MASTER_IRQ & ~GEN8_MASTER_IRQ_CONTROL) &&
1622 : : * (GEN8_MASTER_IRQ & GEN8_MASTER_IRQ_CONTROL)));
1623 : : *
1624 : : * A CPU interrupt will only be raised when 'x' has a 0->1 edge.
1625 : : * Hence we clear GEN8_MASTER_IRQ_CONTROL and VLV_IER to
1626 : : * guarantee the CPU interrupt will be raised again even if we
1627 : : * don't end up clearing all the VLV_IIR and GEN8_MASTER_IRQ_CONTROL
1628 : : * bits this time around.
1629 : : */
1630 : 0 : I915_WRITE(GEN8_MASTER_IRQ, 0);
1631 : 0 : ier = I915_READ(VLV_IER);
1632 : 0 : I915_WRITE(VLV_IER, 0);
1633 : :
1634 : 0 : gen8_gt_irq_ack(&dev_priv->gt, master_ctl, gt_iir);
1635 : :
1636 [ # # ]: 0 : if (iir & I915_DISPLAY_PORT_INTERRUPT)
1637 : 0 : hotplug_status = i9xx_hpd_irq_ack(dev_priv);
1638 : :
1639 : : /* Call regardless, as some status bits might not be
1640 : : * signalled in iir */
1641 : 0 : i9xx_pipestat_irq_ack(dev_priv, iir, pipe_stats);
1642 : :
1643 [ # # ]: 0 : if (iir & (I915_LPE_PIPE_A_INTERRUPT |
1644 : : I915_LPE_PIPE_B_INTERRUPT |
1645 : : I915_LPE_PIPE_C_INTERRUPT))
1646 : 0 : intel_lpe_audio_irq_handler(dev_priv);
1647 : :
1648 : : /*
1649 : : * VLV_IIR is single buffered, and reflects the level
1650 : : * from PIPESTAT/PORT_HOTPLUG_STAT, hence clear it last.
1651 : : */
1652 [ # # ]: 0 : if (iir)
1653 : 0 : I915_WRITE(VLV_IIR, iir);
1654 : :
1655 : 0 : I915_WRITE(VLV_IER, ier);
1656 : 0 : I915_WRITE(GEN8_MASTER_IRQ, GEN8_MASTER_IRQ_CONTROL);
1657 : :
1658 : 0 : gen8_gt_irq_handler(&dev_priv->gt, master_ctl, gt_iir);
1659 : :
1660 [ # # ]: 0 : if (hotplug_status)
1661 : 0 : i9xx_hpd_irq_handler(dev_priv, hotplug_status);
1662 : :
1663 : 0 : valleyview_pipestat_irq_handler(dev_priv, pipe_stats);
1664 : 0 : } while (0);
1665 : :
1666 : 0 : enable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
1667 : :
1668 : 0 : return ret;
1669 : : }
1670 : :
1671 : 0 : static void ibx_hpd_irq_handler(struct drm_i915_private *dev_priv,
1672 : : u32 hotplug_trigger,
1673 : : const u32 hpd[HPD_NUM_PINS])
1674 : : {
1675 : 0 : u32 dig_hotplug_reg, pin_mask = 0, long_mask = 0;
1676 : :
1677 : : /*
1678 : : * Somehow the PCH doesn't seem to really ack the interrupt to the CPU
1679 : : * unless we touch the hotplug register, even if hotplug_trigger is
1680 : : * zero. Not acking leads to "The master control interrupt lied (SDE)!"
1681 : : * errors.
1682 : : */
1683 : 0 : dig_hotplug_reg = I915_READ(PCH_PORT_HOTPLUG);
1684 [ # # ]: 0 : if (!hotplug_trigger) {
1685 : 0 : u32 mask = PORTA_HOTPLUG_STATUS_MASK |
1686 : : PORTD_HOTPLUG_STATUS_MASK |
1687 : : PORTC_HOTPLUG_STATUS_MASK |
1688 : : PORTB_HOTPLUG_STATUS_MASK;
1689 : 0 : dig_hotplug_reg &= ~mask;
1690 : : }
1691 : :
1692 : 0 : I915_WRITE(PCH_PORT_HOTPLUG, dig_hotplug_reg);
1693 [ # # ]: 0 : if (!hotplug_trigger)
1694 : 0 : return;
1695 : :
1696 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask, hotplug_trigger,
1697 : : dig_hotplug_reg, hpd,
1698 : : pch_port_hotplug_long_detect);
1699 : :
1700 : 0 : intel_hpd_irq_handler(dev_priv, pin_mask, long_mask);
1701 : : }
1702 : :
1703 : 0 : static void ibx_irq_handler(struct drm_i915_private *dev_priv, u32 pch_iir)
1704 : : {
1705 : 0 : enum pipe pipe;
1706 : 0 : u32 hotplug_trigger = pch_iir & SDE_HOTPLUG_MASK;
1707 : :
1708 : 0 : ibx_hpd_irq_handler(dev_priv, hotplug_trigger, hpd_ibx);
1709 : :
1710 [ # # ]: 0 : if (pch_iir & SDE_AUDIO_POWER_MASK) {
1711 : 0 : int port = ffs((pch_iir & SDE_AUDIO_POWER_MASK) >>
1712 : : SDE_AUDIO_POWER_SHIFT);
1713 : 0 : DRM_DEBUG_DRIVER("PCH audio power change on port %d\n",
1714 : : port_name(port));
1715 : : }
1716 : :
1717 [ # # ]: 0 : if (pch_iir & SDE_AUX_MASK)
1718 : 0 : dp_aux_irq_handler(dev_priv);
1719 : :
1720 [ # # ]: 0 : if (pch_iir & SDE_GMBUS)
1721 : 0 : gmbus_irq_handler(dev_priv);
1722 : :
1723 [ # # ]: 0 : if (pch_iir & SDE_AUDIO_HDCP_MASK)
1724 : 0 : DRM_DEBUG_DRIVER("PCH HDCP audio interrupt\n");
1725 : :
1726 [ # # ]: 0 : if (pch_iir & SDE_AUDIO_TRANS_MASK)
1727 : 0 : DRM_DEBUG_DRIVER("PCH transcoder audio interrupt\n");
1728 : :
1729 [ # # ]: 0 : if (pch_iir & SDE_POISON)
1730 : 0 : DRM_ERROR("PCH poison interrupt\n");
1731 : :
1732 [ # # ]: 0 : if (pch_iir & SDE_FDI_MASK)
1733 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe)
1734 : 0 : DRM_DEBUG_DRIVER(" pipe %c FDI IIR: 0x%08x\n",
1735 : : pipe_name(pipe),
1736 : : I915_READ(FDI_RX_IIR(pipe)));
1737 : :
1738 [ # # ]: 0 : if (pch_iir & (SDE_TRANSB_CRC_DONE | SDE_TRANSA_CRC_DONE))
1739 : 0 : DRM_DEBUG_DRIVER("PCH transcoder CRC done interrupt\n");
1740 : :
1741 [ # # ]: 0 : if (pch_iir & (SDE_TRANSB_CRC_ERR | SDE_TRANSA_CRC_ERR))
1742 : 0 : DRM_DEBUG_DRIVER("PCH transcoder CRC error interrupt\n");
1743 : :
1744 [ # # ]: 0 : if (pch_iir & SDE_TRANSA_FIFO_UNDER)
1745 : 0 : intel_pch_fifo_underrun_irq_handler(dev_priv, PIPE_A);
1746 : :
1747 [ # # ]: 0 : if (pch_iir & SDE_TRANSB_FIFO_UNDER)
1748 : 0 : intel_pch_fifo_underrun_irq_handler(dev_priv, PIPE_B);
1749 : 0 : }
1750 : :
1751 : 0 : static void ivb_err_int_handler(struct drm_i915_private *dev_priv)
1752 : : {
1753 : 0 : u32 err_int = I915_READ(GEN7_ERR_INT);
1754 : 0 : enum pipe pipe;
1755 : :
1756 [ # # ]: 0 : if (err_int & ERR_INT_POISON)
1757 : 0 : DRM_ERROR("Poison interrupt\n");
1758 : :
1759 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
1760 [ # # ]: 0 : if (err_int & ERR_INT_FIFO_UNDERRUN(pipe))
1761 : 0 : intel_cpu_fifo_underrun_irq_handler(dev_priv, pipe);
1762 : :
1763 [ # # ]: 0 : if (err_int & ERR_INT_PIPE_CRC_DONE(pipe)) {
1764 [ # # ]: 0 : if (IS_IVYBRIDGE(dev_priv))
1765 : 0 : ivb_pipe_crc_irq_handler(dev_priv, pipe);
1766 : : else
1767 : 0 : hsw_pipe_crc_irq_handler(dev_priv, pipe);
1768 : : }
1769 : : }
1770 : :
1771 : 0 : I915_WRITE(GEN7_ERR_INT, err_int);
1772 : 0 : }
1773 : :
1774 : 0 : static void cpt_serr_int_handler(struct drm_i915_private *dev_priv)
1775 : : {
1776 : 0 : u32 serr_int = I915_READ(SERR_INT);
1777 : 0 : enum pipe pipe;
1778 : :
1779 [ # # ]: 0 : if (serr_int & SERR_INT_POISON)
1780 : 0 : DRM_ERROR("PCH poison interrupt\n");
1781 : :
1782 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe)
1783 [ # # ]: 0 : if (serr_int & SERR_INT_TRANS_FIFO_UNDERRUN(pipe))
1784 : 0 : intel_pch_fifo_underrun_irq_handler(dev_priv, pipe);
1785 : :
1786 : 0 : I915_WRITE(SERR_INT, serr_int);
1787 : 0 : }
1788 : :
1789 : 0 : static void cpt_irq_handler(struct drm_i915_private *dev_priv, u32 pch_iir)
1790 : : {
1791 : 0 : enum pipe pipe;
1792 : 0 : u32 hotplug_trigger = pch_iir & SDE_HOTPLUG_MASK_CPT;
1793 : :
1794 : 0 : ibx_hpd_irq_handler(dev_priv, hotplug_trigger, hpd_cpt);
1795 : :
1796 [ # # ]: 0 : if (pch_iir & SDE_AUDIO_POWER_MASK_CPT) {
1797 : 0 : int port = ffs((pch_iir & SDE_AUDIO_POWER_MASK_CPT) >>
1798 : : SDE_AUDIO_POWER_SHIFT_CPT);
1799 : 0 : DRM_DEBUG_DRIVER("PCH audio power change on port %c\n",
1800 : : port_name(port));
1801 : : }
1802 : :
1803 [ # # ]: 0 : if (pch_iir & SDE_AUX_MASK_CPT)
1804 : 0 : dp_aux_irq_handler(dev_priv);
1805 : :
1806 [ # # ]: 0 : if (pch_iir & SDE_GMBUS_CPT)
1807 : 0 : gmbus_irq_handler(dev_priv);
1808 : :
1809 [ # # ]: 0 : if (pch_iir & SDE_AUDIO_CP_REQ_CPT)
1810 : 0 : DRM_DEBUG_DRIVER("Audio CP request interrupt\n");
1811 : :
1812 [ # # ]: 0 : if (pch_iir & SDE_AUDIO_CP_CHG_CPT)
1813 : 0 : DRM_DEBUG_DRIVER("Audio CP change interrupt\n");
1814 : :
1815 [ # # ]: 0 : if (pch_iir & SDE_FDI_MASK_CPT)
1816 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe)
1817 : 0 : DRM_DEBUG_DRIVER(" pipe %c FDI IIR: 0x%08x\n",
1818 : : pipe_name(pipe),
1819 : : I915_READ(FDI_RX_IIR(pipe)));
1820 : :
1821 [ # # ]: 0 : if (pch_iir & SDE_ERROR_CPT)
1822 : 0 : cpt_serr_int_handler(dev_priv);
1823 : 0 : }
1824 : :
1825 : 0 : static void icp_irq_handler(struct drm_i915_private *dev_priv, u32 pch_iir)
1826 : : {
1827 : 0 : u32 ddi_hotplug_trigger, tc_hotplug_trigger;
1828 : 0 : u32 pin_mask = 0, long_mask = 0;
1829 : 0 : bool (*tc_port_hotplug_long_detect)(enum hpd_pin pin, u32 val);
1830 : 0 : const u32 *pins;
1831 : :
1832 [ # # ]: 0 : if (HAS_PCH_TGP(dev_priv)) {
1833 : 0 : ddi_hotplug_trigger = pch_iir & SDE_DDI_MASK_TGP;
1834 : 0 : tc_hotplug_trigger = pch_iir & SDE_TC_MASK_TGP;
1835 : 0 : tc_port_hotplug_long_detect = tgp_tc_port_hotplug_long_detect;
1836 : 0 : pins = hpd_tgp;
1837 [ # # ]: 0 : } else if (HAS_PCH_JSP(dev_priv)) {
1838 : 0 : ddi_hotplug_trigger = pch_iir & SDE_DDI_MASK_TGP;
1839 : 0 : tc_hotplug_trigger = 0;
1840 : 0 : pins = hpd_tgp;
1841 [ # # ]: 0 : } else if (HAS_PCH_MCC(dev_priv)) {
1842 : 0 : ddi_hotplug_trigger = pch_iir & SDE_DDI_MASK_ICP;
1843 : 0 : tc_hotplug_trigger = pch_iir & SDE_TC_HOTPLUG_ICP(PORT_TC1);
1844 : 0 : tc_port_hotplug_long_detect = icp_tc_port_hotplug_long_detect;
1845 : 0 : pins = hpd_icp;
1846 : : } else {
1847 [ # # ]: 0 : WARN(!HAS_PCH_ICP(dev_priv),
1848 : : "Unrecognized PCH type 0x%x\n", INTEL_PCH_TYPE(dev_priv));
1849 : :
1850 : 0 : ddi_hotplug_trigger = pch_iir & SDE_DDI_MASK_ICP;
1851 : 0 : tc_hotplug_trigger = pch_iir & SDE_TC_MASK_ICP;
1852 : 0 : tc_port_hotplug_long_detect = icp_tc_port_hotplug_long_detect;
1853 : 0 : pins = hpd_icp;
1854 : : }
1855 : :
1856 [ # # ]: 0 : if (ddi_hotplug_trigger) {
1857 : 0 : u32 dig_hotplug_reg;
1858 : :
1859 : 0 : dig_hotplug_reg = I915_READ(SHOTPLUG_CTL_DDI);
1860 : 0 : I915_WRITE(SHOTPLUG_CTL_DDI, dig_hotplug_reg);
1861 : :
1862 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask,
1863 : : ddi_hotplug_trigger,
1864 : : dig_hotplug_reg, pins,
1865 : : icp_ddi_port_hotplug_long_detect);
1866 : : }
1867 : :
1868 [ # # ]: 0 : if (tc_hotplug_trigger) {
1869 : 0 : u32 dig_hotplug_reg;
1870 : :
1871 : 0 : dig_hotplug_reg = I915_READ(SHOTPLUG_CTL_TC);
1872 : 0 : I915_WRITE(SHOTPLUG_CTL_TC, dig_hotplug_reg);
1873 : :
1874 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask,
1875 : : tc_hotplug_trigger,
1876 : : dig_hotplug_reg, pins,
1877 : : tc_port_hotplug_long_detect);
1878 : : }
1879 : :
1880 [ # # ]: 0 : if (pin_mask)
1881 : 0 : intel_hpd_irq_handler(dev_priv, pin_mask, long_mask);
1882 : :
1883 [ # # ]: 0 : if (pch_iir & SDE_GMBUS_ICP)
1884 : 0 : gmbus_irq_handler(dev_priv);
1885 : 0 : }
1886 : :
1887 : 0 : static void spt_irq_handler(struct drm_i915_private *dev_priv, u32 pch_iir)
1888 : : {
1889 : 0 : u32 hotplug_trigger = pch_iir & SDE_HOTPLUG_MASK_SPT &
1890 : : ~SDE_PORTE_HOTPLUG_SPT;
1891 : 0 : u32 hotplug2_trigger = pch_iir & SDE_PORTE_HOTPLUG_SPT;
1892 : 0 : u32 pin_mask = 0, long_mask = 0;
1893 : :
1894 [ # # ]: 0 : if (hotplug_trigger) {
1895 : 0 : u32 dig_hotplug_reg;
1896 : :
1897 : 0 : dig_hotplug_reg = I915_READ(PCH_PORT_HOTPLUG);
1898 : 0 : I915_WRITE(PCH_PORT_HOTPLUG, dig_hotplug_reg);
1899 : :
1900 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask,
1901 : : hotplug_trigger, dig_hotplug_reg, hpd_spt,
1902 : : spt_port_hotplug_long_detect);
1903 : : }
1904 : :
1905 [ # # ]: 0 : if (hotplug2_trigger) {
1906 : 0 : u32 dig_hotplug_reg;
1907 : :
1908 : 0 : dig_hotplug_reg = I915_READ(PCH_PORT_HOTPLUG2);
1909 : 0 : I915_WRITE(PCH_PORT_HOTPLUG2, dig_hotplug_reg);
1910 : :
1911 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask,
1912 : : hotplug2_trigger, dig_hotplug_reg, hpd_spt,
1913 : : spt_port_hotplug2_long_detect);
1914 : : }
1915 : :
1916 [ # # ]: 0 : if (pin_mask)
1917 : 0 : intel_hpd_irq_handler(dev_priv, pin_mask, long_mask);
1918 : :
1919 [ # # ]: 0 : if (pch_iir & SDE_GMBUS_CPT)
1920 : 0 : gmbus_irq_handler(dev_priv);
1921 : 0 : }
1922 : :
1923 : 0 : static void ilk_hpd_irq_handler(struct drm_i915_private *dev_priv,
1924 : : u32 hotplug_trigger,
1925 : : const u32 hpd[HPD_NUM_PINS])
1926 : : {
1927 : 0 : u32 dig_hotplug_reg, pin_mask = 0, long_mask = 0;
1928 : :
1929 : 0 : dig_hotplug_reg = I915_READ(DIGITAL_PORT_HOTPLUG_CNTRL);
1930 : 0 : I915_WRITE(DIGITAL_PORT_HOTPLUG_CNTRL, dig_hotplug_reg);
1931 : :
1932 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask, hotplug_trigger,
1933 : : dig_hotplug_reg, hpd,
1934 : : ilk_port_hotplug_long_detect);
1935 : :
1936 : 0 : intel_hpd_irq_handler(dev_priv, pin_mask, long_mask);
1937 : 0 : }
1938 : :
1939 : 0 : static void ilk_display_irq_handler(struct drm_i915_private *dev_priv,
1940 : : u32 de_iir)
1941 : : {
1942 : 0 : enum pipe pipe;
1943 : 0 : u32 hotplug_trigger = de_iir & DE_DP_A_HOTPLUG;
1944 : :
1945 [ # # ]: 0 : if (hotplug_trigger)
1946 : 0 : ilk_hpd_irq_handler(dev_priv, hotplug_trigger, hpd_ilk);
1947 : :
1948 [ # # ]: 0 : if (de_iir & DE_AUX_CHANNEL_A)
1949 : 0 : dp_aux_irq_handler(dev_priv);
1950 : :
1951 [ # # ]: 0 : if (de_iir & DE_GSE)
1952 : 0 : intel_opregion_asle_intr(dev_priv);
1953 : :
1954 [ # # ]: 0 : if (de_iir & DE_POISON)
1955 : 0 : DRM_ERROR("Poison interrupt\n");
1956 : :
1957 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
1958 [ # # ]: 0 : if (de_iir & DE_PIPE_VBLANK(pipe))
1959 : 0 : drm_handle_vblank(&dev_priv->drm, pipe);
1960 : :
1961 [ # # ]: 0 : if (de_iir & DE_PIPE_FIFO_UNDERRUN(pipe))
1962 : 0 : intel_cpu_fifo_underrun_irq_handler(dev_priv, pipe);
1963 : :
1964 [ # # ]: 0 : if (de_iir & DE_PIPE_CRC_DONE(pipe))
1965 : 0 : i9xx_pipe_crc_irq_handler(dev_priv, pipe);
1966 : : }
1967 : :
1968 : : /* check event from PCH */
1969 [ # # ]: 0 : if (de_iir & DE_PCH_EVENT) {
1970 : 0 : u32 pch_iir = I915_READ(SDEIIR);
1971 : :
1972 [ # # ]: 0 : if (HAS_PCH_CPT(dev_priv))
1973 : 0 : cpt_irq_handler(dev_priv, pch_iir);
1974 : : else
1975 : 0 : ibx_irq_handler(dev_priv, pch_iir);
1976 : :
1977 : : /* should clear PCH hotplug event before clear CPU irq */
1978 : 0 : I915_WRITE(SDEIIR, pch_iir);
1979 : : }
1980 : :
1981 [ # # # # ]: 0 : if (IS_GEN(dev_priv, 5) && de_iir & DE_PCU_EVENT)
1982 : 0 : gen5_rps_irq_handler(&dev_priv->gt.rps);
1983 : 0 : }
1984 : :
1985 : 0 : static void ivb_display_irq_handler(struct drm_i915_private *dev_priv,
1986 : : u32 de_iir)
1987 : : {
1988 : 0 : enum pipe pipe;
1989 : 0 : u32 hotplug_trigger = de_iir & DE_DP_A_HOTPLUG_IVB;
1990 : :
1991 [ # # ]: 0 : if (hotplug_trigger)
1992 : 0 : ilk_hpd_irq_handler(dev_priv, hotplug_trigger, hpd_ivb);
1993 : :
1994 [ # # ]: 0 : if (de_iir & DE_ERR_INT_IVB)
1995 : 0 : ivb_err_int_handler(dev_priv);
1996 : :
1997 [ # # ]: 0 : if (de_iir & DE_EDP_PSR_INT_HSW) {
1998 : 0 : u32 psr_iir = I915_READ(EDP_PSR_IIR);
1999 : :
2000 : 0 : intel_psr_irq_handler(dev_priv, psr_iir);
2001 : 0 : I915_WRITE(EDP_PSR_IIR, psr_iir);
2002 : : }
2003 : :
2004 [ # # ]: 0 : if (de_iir & DE_AUX_CHANNEL_A_IVB)
2005 : 0 : dp_aux_irq_handler(dev_priv);
2006 : :
2007 [ # # ]: 0 : if (de_iir & DE_GSE_IVB)
2008 : 0 : intel_opregion_asle_intr(dev_priv);
2009 : :
2010 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
2011 [ # # ]: 0 : if (de_iir & (DE_PIPE_VBLANK_IVB(pipe)))
2012 : 0 : drm_handle_vblank(&dev_priv->drm, pipe);
2013 : : }
2014 : :
2015 : : /* check event from PCH */
2016 [ # # # # ]: 0 : if (!HAS_PCH_NOP(dev_priv) && (de_iir & DE_PCH_EVENT_IVB)) {
2017 : 0 : u32 pch_iir = I915_READ(SDEIIR);
2018 : :
2019 : 0 : cpt_irq_handler(dev_priv, pch_iir);
2020 : :
2021 : : /* clear PCH hotplug event before clear CPU irq */
2022 : 0 : I915_WRITE(SDEIIR, pch_iir);
2023 : : }
2024 : 0 : }
2025 : :
2026 : : /*
2027 : : * To handle irqs with the minimum potential races with fresh interrupts, we:
2028 : : * 1 - Disable Master Interrupt Control.
2029 : : * 2 - Find the source(s) of the interrupt.
2030 : : * 3 - Clear the Interrupt Identity bits (IIR).
2031 : : * 4 - Process the interrupt(s) that had bits set in the IIRs.
2032 : : * 5 - Re-enable Master Interrupt Control.
2033 : : */
2034 : 0 : static irqreturn_t ilk_irq_handler(int irq, void *arg)
2035 : : {
2036 : 0 : struct drm_i915_private *dev_priv = arg;
2037 : 0 : u32 de_iir, gt_iir, de_ier, sde_ier = 0;
2038 : 0 : irqreturn_t ret = IRQ_NONE;
2039 : :
2040 : 0 : if (!intel_irqs_enabled(dev_priv))
2041 : : return IRQ_NONE;
2042 : :
2043 : : /* IRQs are synced during runtime_suspend, we don't require a wakeref */
2044 : 0 : disable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
2045 : :
2046 : : /* disable master interrupt before clearing iir */
2047 : 0 : de_ier = I915_READ(DEIER);
2048 : 0 : I915_WRITE(DEIER, de_ier & ~DE_MASTER_IRQ_CONTROL);
2049 : :
2050 : : /* Disable south interrupts. We'll only write to SDEIIR once, so further
2051 : : * interrupts will will be stored on its back queue, and then we'll be
2052 : : * able to process them after we restore SDEIER (as soon as we restore
2053 : : * it, we'll get an interrupt if SDEIIR still has something to process
2054 : : * due to its back queue). */
2055 [ # # ]: 0 : if (!HAS_PCH_NOP(dev_priv)) {
2056 : 0 : sde_ier = I915_READ(SDEIER);
2057 : 0 : I915_WRITE(SDEIER, 0);
2058 : : }
2059 : :
2060 : : /* Find, clear, then process each source of interrupt */
2061 : :
2062 : 0 : gt_iir = I915_READ(GTIIR);
2063 [ # # ]: 0 : if (gt_iir) {
2064 : 0 : I915_WRITE(GTIIR, gt_iir);
2065 : 0 : ret = IRQ_HANDLED;
2066 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 6)
2067 : 0 : gen6_gt_irq_handler(&dev_priv->gt, gt_iir);
2068 : : else
2069 : 0 : gen5_gt_irq_handler(&dev_priv->gt, gt_iir);
2070 : : }
2071 : :
2072 : 0 : de_iir = I915_READ(DEIIR);
2073 [ # # ]: 0 : if (de_iir) {
2074 : 0 : I915_WRITE(DEIIR, de_iir);
2075 : 0 : ret = IRQ_HANDLED;
2076 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 7)
2077 : 0 : ivb_display_irq_handler(dev_priv, de_iir);
2078 : : else
2079 : 0 : ilk_display_irq_handler(dev_priv, de_iir);
2080 : : }
2081 : :
2082 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 6) {
2083 : 0 : u32 pm_iir = I915_READ(GEN6_PMIIR);
2084 [ # # ]: 0 : if (pm_iir) {
2085 : 0 : I915_WRITE(GEN6_PMIIR, pm_iir);
2086 : 0 : ret = IRQ_HANDLED;
2087 : 0 : gen6_rps_irq_handler(&dev_priv->gt.rps, pm_iir);
2088 : : }
2089 : : }
2090 : :
2091 : 0 : I915_WRITE(DEIER, de_ier);
2092 [ # # ]: 0 : if (!HAS_PCH_NOP(dev_priv))
2093 : 0 : I915_WRITE(SDEIER, sde_ier);
2094 : :
2095 : : /* IRQs are synced during runtime_suspend, we don't require a wakeref */
2096 : 0 : enable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
2097 : :
2098 : 0 : return ret;
2099 : : }
2100 : :
2101 : 0 : static void bxt_hpd_irq_handler(struct drm_i915_private *dev_priv,
2102 : : u32 hotplug_trigger,
2103 : : const u32 hpd[HPD_NUM_PINS])
2104 : : {
2105 : 0 : u32 dig_hotplug_reg, pin_mask = 0, long_mask = 0;
2106 : :
2107 : 0 : dig_hotplug_reg = I915_READ(PCH_PORT_HOTPLUG);
2108 : 0 : I915_WRITE(PCH_PORT_HOTPLUG, dig_hotplug_reg);
2109 : :
2110 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask, hotplug_trigger,
2111 : : dig_hotplug_reg, hpd,
2112 : : bxt_port_hotplug_long_detect);
2113 : :
2114 : 0 : intel_hpd_irq_handler(dev_priv, pin_mask, long_mask);
2115 : 0 : }
2116 : :
2117 : 0 : static void gen11_hpd_irq_handler(struct drm_i915_private *dev_priv, u32 iir)
2118 : : {
2119 : 0 : u32 pin_mask = 0, long_mask = 0;
2120 : 0 : u32 trigger_tc = iir & GEN11_DE_TC_HOTPLUG_MASK;
2121 : 0 : u32 trigger_tbt = iir & GEN11_DE_TBT_HOTPLUG_MASK;
2122 : 0 : long_pulse_detect_func long_pulse_detect;
2123 : 0 : const u32 *hpd;
2124 : :
2125 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 12) {
2126 : : long_pulse_detect = gen12_port_hotplug_long_detect;
2127 : : hpd = hpd_gen12;
2128 : : } else {
2129 : 0 : long_pulse_detect = gen11_port_hotplug_long_detect;
2130 : 0 : hpd = hpd_gen11;
2131 : : }
2132 : :
2133 [ # # ]: 0 : if (trigger_tc) {
2134 : 0 : u32 dig_hotplug_reg;
2135 : :
2136 : 0 : dig_hotplug_reg = I915_READ(GEN11_TC_HOTPLUG_CTL);
2137 : 0 : I915_WRITE(GEN11_TC_HOTPLUG_CTL, dig_hotplug_reg);
2138 : :
2139 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask, trigger_tc,
2140 : : dig_hotplug_reg, hpd, long_pulse_detect);
2141 : : }
2142 : :
2143 [ # # ]: 0 : if (trigger_tbt) {
2144 : 0 : u32 dig_hotplug_reg;
2145 : :
2146 : 0 : dig_hotplug_reg = I915_READ(GEN11_TBT_HOTPLUG_CTL);
2147 : 0 : I915_WRITE(GEN11_TBT_HOTPLUG_CTL, dig_hotplug_reg);
2148 : :
2149 : 0 : intel_get_hpd_pins(dev_priv, &pin_mask, &long_mask, trigger_tbt,
2150 : : dig_hotplug_reg, hpd, long_pulse_detect);
2151 : : }
2152 : :
2153 [ # # ]: 0 : if (pin_mask)
2154 : 0 : intel_hpd_irq_handler(dev_priv, pin_mask, long_mask);
2155 : : else
2156 : 0 : DRM_ERROR("Unexpected DE HPD interrupt 0x%08x\n", iir);
2157 : 0 : }
2158 : :
2159 : 0 : static u32 gen8_de_port_aux_mask(struct drm_i915_private *dev_priv)
2160 : : {
2161 : 0 : u32 mask;
2162 : :
2163 : 0 : if (INTEL_GEN(dev_priv) >= 12)
2164 : : return TGL_DE_PORT_AUX_DDIA |
2165 : : TGL_DE_PORT_AUX_DDIB |
2166 : : TGL_DE_PORT_AUX_DDIC |
2167 : : TGL_DE_PORT_AUX_USBC1 |
2168 : : TGL_DE_PORT_AUX_USBC2 |
2169 : : TGL_DE_PORT_AUX_USBC3 |
2170 : : TGL_DE_PORT_AUX_USBC4 |
2171 : : TGL_DE_PORT_AUX_USBC5 |
2172 : : TGL_DE_PORT_AUX_USBC6;
2173 : :
2174 : :
2175 : 0 : mask = GEN8_AUX_CHANNEL_A;
2176 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9)
2177 : 0 : mask |= GEN9_AUX_CHANNEL_B |
2178 : : GEN9_AUX_CHANNEL_C |
2179 : : GEN9_AUX_CHANNEL_D;
2180 : :
2181 [ # # # # ]: 0 : if (IS_CNL_WITH_PORT_F(dev_priv) || IS_GEN(dev_priv, 11))
2182 : 0 : mask |= CNL_AUX_CHANNEL_F;
2183 : :
2184 [ # # ]: 0 : if (IS_GEN(dev_priv, 11))
2185 : 0 : mask |= ICL_AUX_CHANNEL_E;
2186 : :
2187 : : return mask;
2188 : : }
2189 : :
2190 : 0 : static u32 gen8_de_pipe_fault_mask(struct drm_i915_private *dev_priv)
2191 : : {
2192 : 0 : if (INTEL_GEN(dev_priv) >= 11)
2193 : : return GEN11_DE_PIPE_IRQ_FAULT_ERRORS;
2194 [ # # ]: 0 : else if (INTEL_GEN(dev_priv) >= 9)
2195 : : return GEN9_DE_PIPE_IRQ_FAULT_ERRORS;
2196 : : else
2197 : 0 : return GEN8_DE_PIPE_IRQ_FAULT_ERRORS;
2198 : : }
2199 : :
2200 : : static void
2201 : 0 : gen8_de_misc_irq_handler(struct drm_i915_private *dev_priv, u32 iir)
2202 : : {
2203 : 0 : bool found = false;
2204 : :
2205 [ # # ]: 0 : if (iir & GEN8_DE_MISC_GSE) {
2206 : 0 : intel_opregion_asle_intr(dev_priv);
2207 : 0 : found = true;
2208 : : }
2209 : :
2210 [ # # ]: 0 : if (iir & GEN8_DE_EDP_PSR) {
2211 : 0 : u32 psr_iir;
2212 : 0 : i915_reg_t iir_reg;
2213 : :
2214 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 12)
2215 : 0 : iir_reg = TRANS_PSR_IIR(dev_priv->psr.transcoder);
2216 : : else
2217 : : iir_reg = EDP_PSR_IIR;
2218 : :
2219 : 0 : psr_iir = I915_READ(iir_reg);
2220 : 0 : I915_WRITE(iir_reg, psr_iir);
2221 : :
2222 [ # # ]: 0 : if (psr_iir)
2223 : 0 : found = true;
2224 : :
2225 : 0 : intel_psr_irq_handler(dev_priv, psr_iir);
2226 : : }
2227 : :
2228 [ # # ]: 0 : if (!found)
2229 : 0 : DRM_ERROR("Unexpected DE Misc interrupt\n");
2230 : 0 : }
2231 : :
2232 : : static irqreturn_t
2233 : 0 : gen8_de_irq_handler(struct drm_i915_private *dev_priv, u32 master_ctl)
2234 : : {
2235 : 0 : irqreturn_t ret = IRQ_NONE;
2236 : 0 : u32 iir;
2237 : 0 : enum pipe pipe;
2238 : :
2239 [ # # ]: 0 : if (master_ctl & GEN8_DE_MISC_IRQ) {
2240 : 0 : iir = I915_READ(GEN8_DE_MISC_IIR);
2241 [ # # ]: 0 : if (iir) {
2242 : 0 : I915_WRITE(GEN8_DE_MISC_IIR, iir);
2243 : 0 : ret = IRQ_HANDLED;
2244 : 0 : gen8_de_misc_irq_handler(dev_priv, iir);
2245 : : } else {
2246 : 0 : DRM_ERROR("The master control interrupt lied (DE MISC)!\n");
2247 : : }
2248 : : }
2249 : :
2250 [ # # # # ]: 0 : if (INTEL_GEN(dev_priv) >= 11 && (master_ctl & GEN11_DE_HPD_IRQ)) {
2251 : 0 : iir = I915_READ(GEN11_DE_HPD_IIR);
2252 [ # # ]: 0 : if (iir) {
2253 : 0 : I915_WRITE(GEN11_DE_HPD_IIR, iir);
2254 : 0 : ret = IRQ_HANDLED;
2255 : 0 : gen11_hpd_irq_handler(dev_priv, iir);
2256 : : } else {
2257 : 0 : DRM_ERROR("The master control interrupt lied, (DE HPD)!\n");
2258 : : }
2259 : : }
2260 : :
2261 [ # # ]: 0 : if (master_ctl & GEN8_DE_PORT_IRQ) {
2262 : 0 : iir = I915_READ(GEN8_DE_PORT_IIR);
2263 [ # # ]: 0 : if (iir) {
2264 : 0 : u32 tmp_mask;
2265 : 0 : bool found = false;
2266 : :
2267 : 0 : I915_WRITE(GEN8_DE_PORT_IIR, iir);
2268 : 0 : ret = IRQ_HANDLED;
2269 : :
2270 [ # # # # ]: 0 : if (iir & gen8_de_port_aux_mask(dev_priv)) {
2271 : 0 : dp_aux_irq_handler(dev_priv);
2272 : 0 : found = true;
2273 : : }
2274 : :
2275 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
2276 : 0 : tmp_mask = iir & BXT_DE_PORT_HOTPLUG_MASK;
2277 [ # # ]: 0 : if (tmp_mask) {
2278 : 0 : bxt_hpd_irq_handler(dev_priv, tmp_mask,
2279 : : hpd_bxt);
2280 : 0 : found = true;
2281 : : }
2282 [ # # ]: 0 : } else if (IS_BROADWELL(dev_priv)) {
2283 : 0 : tmp_mask = iir & GEN8_PORT_DP_A_HOTPLUG;
2284 [ # # ]: 0 : if (tmp_mask) {
2285 : 0 : ilk_hpd_irq_handler(dev_priv,
2286 : : tmp_mask, hpd_bdw);
2287 : 0 : found = true;
2288 : : }
2289 : : }
2290 : :
2291 [ # # # # : 0 : if (IS_GEN9_LP(dev_priv) && (iir & BXT_DE_PORT_GMBUS)) {
# # ]
2292 : 0 : gmbus_irq_handler(dev_priv);
2293 : 0 : found = true;
2294 : : }
2295 : :
2296 [ # # ]: 0 : if (!found)
2297 : 0 : DRM_ERROR("Unexpected DE Port interrupt\n");
2298 : : }
2299 : : else
2300 : 0 : DRM_ERROR("The master control interrupt lied (DE PORT)!\n");
2301 : : }
2302 : :
2303 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
2304 : 0 : u32 fault_errors;
2305 : :
2306 [ # # ]: 0 : if (!(master_ctl & GEN8_DE_PIPE_IRQ(pipe)))
2307 : 0 : continue;
2308 : :
2309 : 0 : iir = I915_READ(GEN8_DE_PIPE_IIR(pipe));
2310 [ # # ]: 0 : if (!iir) {
2311 : 0 : DRM_ERROR("The master control interrupt lied (DE PIPE)!\n");
2312 : 0 : continue;
2313 : : }
2314 : :
2315 : 0 : ret = IRQ_HANDLED;
2316 : 0 : I915_WRITE(GEN8_DE_PIPE_IIR(pipe), iir);
2317 : :
2318 [ # # ]: 0 : if (iir & GEN8_PIPE_VBLANK)
2319 : 0 : drm_handle_vblank(&dev_priv->drm, pipe);
2320 : :
2321 [ # # ]: 0 : if (iir & GEN8_PIPE_CDCLK_CRC_DONE)
2322 : 0 : hsw_pipe_crc_irq_handler(dev_priv, pipe);
2323 : :
2324 [ # # ]: 0 : if (iir & GEN8_PIPE_FIFO_UNDERRUN)
2325 : 0 : intel_cpu_fifo_underrun_irq_handler(dev_priv, pipe);
2326 : :
2327 [ # # ]: 0 : fault_errors = iir & gen8_de_pipe_fault_mask(dev_priv);
2328 [ # # ]: 0 : if (fault_errors)
2329 : 0 : DRM_ERROR("Fault errors on pipe %c: 0x%08x\n",
2330 : : pipe_name(pipe),
2331 : : fault_errors);
2332 : : }
2333 : :
2334 [ # # ]: 0 : if (HAS_PCH_SPLIT(dev_priv) && !HAS_PCH_NOP(dev_priv) &&
2335 [ # # ]: 0 : master_ctl & GEN8_DE_PCH_IRQ) {
2336 : : /*
2337 : : * FIXME(BDW): Assume for now that the new interrupt handling
2338 : : * scheme also closed the SDE interrupt handling race we've seen
2339 : : * on older pch-split platforms. But this needs testing.
2340 : : */
2341 : 0 : iir = I915_READ(SDEIIR);
2342 [ # # ]: 0 : if (iir) {
2343 : 0 : I915_WRITE(SDEIIR, iir);
2344 : 0 : ret = IRQ_HANDLED;
2345 : :
2346 [ # # ]: 0 : if (INTEL_PCH_TYPE(dev_priv) >= PCH_ICP)
2347 : 0 : icp_irq_handler(dev_priv, iir);
2348 [ # # ]: 0 : else if (INTEL_PCH_TYPE(dev_priv) >= PCH_SPT)
2349 : 0 : spt_irq_handler(dev_priv, iir);
2350 : : else
2351 : 0 : cpt_irq_handler(dev_priv, iir);
2352 : : } else {
2353 : : /*
2354 : : * Like on previous PCH there seems to be something
2355 : : * fishy going on with forwarding PCH interrupts.
2356 : : */
2357 : 0 : DRM_DEBUG_DRIVER("The master control interrupt lied (SDE)!\n");
2358 : : }
2359 : : }
2360 : :
2361 : 0 : return ret;
2362 : : }
2363 : :
2364 : 0 : static inline u32 gen8_master_intr_disable(void __iomem * const regs)
2365 : : {
2366 : 0 : raw_reg_write(regs, GEN8_MASTER_IRQ, 0);
2367 : :
2368 : : /*
2369 : : * Now with master disabled, get a sample of level indications
2370 : : * for this interrupt. Indications will be cleared on related acks.
2371 : : * New indications can and will light up during processing,
2372 : : * and will generate new interrupt after enabling master.
2373 : : */
2374 : 0 : return raw_reg_read(regs, GEN8_MASTER_IRQ);
2375 : : }
2376 : :
2377 : 0 : static inline void gen8_master_intr_enable(void __iomem * const regs)
2378 : : {
2379 : 0 : raw_reg_write(regs, GEN8_MASTER_IRQ, GEN8_MASTER_IRQ_CONTROL);
2380 : : }
2381 : :
2382 : 0 : static irqreturn_t gen8_irq_handler(int irq, void *arg)
2383 : : {
2384 : 0 : struct drm_i915_private *dev_priv = arg;
2385 : 0 : void __iomem * const regs = dev_priv->uncore.regs;
2386 : 0 : u32 master_ctl;
2387 : 0 : u32 gt_iir[4];
2388 : :
2389 : 0 : if (!intel_irqs_enabled(dev_priv))
2390 : : return IRQ_NONE;
2391 : :
2392 : 0 : master_ctl = gen8_master_intr_disable(regs);
2393 [ # # ]: 0 : if (!master_ctl) {
2394 : 0 : gen8_master_intr_enable(regs);
2395 : 0 : return IRQ_NONE;
2396 : : }
2397 : :
2398 : : /* Find, clear, then process each source of interrupt */
2399 : 0 : gen8_gt_irq_ack(&dev_priv->gt, master_ctl, gt_iir);
2400 : :
2401 : : /* IRQs are synced during runtime_suspend, we don't require a wakeref */
2402 [ # # ]: 0 : if (master_ctl & ~GEN8_GT_IRQS) {
2403 : 0 : disable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
2404 : 0 : gen8_de_irq_handler(dev_priv, master_ctl);
2405 : 0 : enable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
2406 : : }
2407 : :
2408 : 0 : gen8_master_intr_enable(regs);
2409 : :
2410 : 0 : gen8_gt_irq_handler(&dev_priv->gt, master_ctl, gt_iir);
2411 : :
2412 : 0 : return IRQ_HANDLED;
2413 : : }
2414 : :
2415 : : static u32
2416 : : gen11_gu_misc_irq_ack(struct intel_gt *gt, const u32 master_ctl)
2417 : : {
2418 : : void __iomem * const regs = gt->uncore->regs;
2419 : : u32 iir;
2420 : :
2421 : : if (!(master_ctl & GEN11_GU_MISC_IRQ))
2422 : : return 0;
2423 : :
2424 : : iir = raw_reg_read(regs, GEN11_GU_MISC_IIR);
2425 : : if (likely(iir))
2426 : : raw_reg_write(regs, GEN11_GU_MISC_IIR, iir);
2427 : :
2428 : : return iir;
2429 : : }
2430 : :
2431 : : static void
2432 : : gen11_gu_misc_irq_handler(struct intel_gt *gt, const u32 iir)
2433 : : {
2434 : : if (iir & GEN11_GU_MISC_GSE)
2435 : : intel_opregion_asle_intr(gt->i915);
2436 : : }
2437 : :
2438 : 0 : static inline u32 gen11_master_intr_disable(void __iomem * const regs)
2439 : : {
2440 : 0 : raw_reg_write(regs, GEN11_GFX_MSTR_IRQ, 0);
2441 : :
2442 : : /*
2443 : : * Now with master disabled, get a sample of level indications
2444 : : * for this interrupt. Indications will be cleared on related acks.
2445 : : * New indications can and will light up during processing,
2446 : : * and will generate new interrupt after enabling master.
2447 : : */
2448 : 0 : return raw_reg_read(regs, GEN11_GFX_MSTR_IRQ);
2449 : : }
2450 : :
2451 : 0 : static inline void gen11_master_intr_enable(void __iomem * const regs)
2452 : : {
2453 : 0 : raw_reg_write(regs, GEN11_GFX_MSTR_IRQ, GEN11_MASTER_IRQ);
2454 : 0 : }
2455 : :
2456 : : static void
2457 : 0 : gen11_display_irq_handler(struct drm_i915_private *i915)
2458 : : {
2459 : 0 : void __iomem * const regs = i915->uncore.regs;
2460 : 0 : const u32 disp_ctl = raw_reg_read(regs, GEN11_DISPLAY_INT_CTL);
2461 : :
2462 : 0 : disable_rpm_wakeref_asserts(&i915->runtime_pm);
2463 : : /*
2464 : : * GEN11_DISPLAY_INT_CTL has same format as GEN8_MASTER_IRQ
2465 : : * for the display related bits.
2466 : : */
2467 : 0 : raw_reg_write(regs, GEN11_DISPLAY_INT_CTL, 0x0);
2468 : 0 : gen8_de_irq_handler(i915, disp_ctl);
2469 : 0 : raw_reg_write(regs, GEN11_DISPLAY_INT_CTL,
2470 : : GEN11_DISPLAY_IRQ_ENABLE);
2471 : :
2472 : 0 : enable_rpm_wakeref_asserts(&i915->runtime_pm);
2473 : 0 : }
2474 : :
2475 : : static __always_inline irqreturn_t
2476 : 0 : __gen11_irq_handler(struct drm_i915_private * const i915,
2477 : : u32 (*intr_disable)(void __iomem * const regs),
2478 : : void (*intr_enable)(void __iomem * const regs))
2479 : : {
2480 : 0 : void __iomem * const regs = i915->uncore.regs;
2481 : 0 : struct intel_gt *gt = &i915->gt;
2482 : 0 : u32 master_ctl;
2483 : 0 : u32 gu_misc_iir;
2484 : :
2485 [ # # ]: 0 : if (!intel_irqs_enabled(i915))
2486 : : return IRQ_NONE;
2487 : :
2488 : 0 : master_ctl = intr_disable(regs);
2489 [ # # ]: 0 : if (!master_ctl) {
2490 : 0 : intr_enable(regs);
2491 : : return IRQ_NONE;
2492 : : }
2493 : :
2494 : : /* Find, clear, then process each source of interrupt. */
2495 : 0 : gen11_gt_irq_handler(gt, master_ctl);
2496 : :
2497 : : /* IRQs are synced during runtime_suspend, we don't require a wakeref */
2498 [ # # ]: 0 : if (master_ctl & GEN11_DISPLAY_IRQ)
2499 : 0 : gen11_display_irq_handler(i915);
2500 : :
2501 : 0 : gu_misc_iir = gen11_gu_misc_irq_ack(gt, master_ctl);
2502 : :
2503 : 0 : intr_enable(regs);
2504 : :
2505 : 0 : gen11_gu_misc_irq_handler(gt, gu_misc_iir);
2506 : :
2507 : 0 : return IRQ_HANDLED;
2508 : : }
2509 : :
2510 : 0 : static irqreturn_t gen11_irq_handler(int irq, void *arg)
2511 : : {
2512 : 0 : return __gen11_irq_handler(arg,
2513 : : gen11_master_intr_disable,
2514 : : gen11_master_intr_enable);
2515 : : }
2516 : :
2517 : : /* Called from drm generic code, passed 'crtc' which
2518 : : * we use as a pipe index
2519 : : */
2520 : 0 : int i8xx_enable_vblank(struct drm_crtc *crtc)
2521 : : {
2522 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
2523 : 0 : enum pipe pipe = to_intel_crtc(crtc)->pipe;
2524 : 0 : unsigned long irqflags;
2525 : :
2526 : 0 : spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
2527 : 0 : i915_enable_pipestat(dev_priv, pipe, PIPE_VBLANK_INTERRUPT_STATUS);
2528 : 0 : spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
2529 : :
2530 : 0 : return 0;
2531 : : }
2532 : :
2533 : 0 : int i915gm_enable_vblank(struct drm_crtc *crtc)
2534 : : {
2535 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
2536 : :
2537 : : /*
2538 : : * Vblank interrupts fail to wake the device up from C2+.
2539 : : * Disabling render clock gating during C-states avoids
2540 : : * the problem. There is a small power cost so we do this
2541 : : * only when vblank interrupts are actually enabled.
2542 : : */
2543 [ # # ]: 0 : if (dev_priv->vblank_enabled++ == 0)
2544 : 0 : I915_WRITE(SCPD0, _MASKED_BIT_ENABLE(CSTATE_RENDER_CLOCK_GATE_DISABLE));
2545 : :
2546 : 0 : return i8xx_enable_vblank(crtc);
2547 : : }
2548 : :
2549 : 0 : int i965_enable_vblank(struct drm_crtc *crtc)
2550 : : {
2551 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
2552 : 0 : enum pipe pipe = to_intel_crtc(crtc)->pipe;
2553 : 0 : unsigned long irqflags;
2554 : :
2555 : 0 : spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
2556 : 0 : i915_enable_pipestat(dev_priv, pipe,
2557 : : PIPE_START_VBLANK_INTERRUPT_STATUS);
2558 : 0 : spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
2559 : :
2560 : 0 : return 0;
2561 : : }
2562 : :
2563 : 0 : int ilk_enable_vblank(struct drm_crtc *crtc)
2564 : : {
2565 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
2566 : 0 : enum pipe pipe = to_intel_crtc(crtc)->pipe;
2567 : 0 : unsigned long irqflags;
2568 : 0 : u32 bit = INTEL_GEN(dev_priv) >= 7 ?
2569 [ # # ]: 0 : DE_PIPE_VBLANK_IVB(pipe) : DE_PIPE_VBLANK(pipe);
2570 : :
2571 : 0 : spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
2572 : 0 : ilk_enable_display_irq(dev_priv, bit);
2573 : 0 : spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
2574 : :
2575 : : /* Even though there is no DMC, frame counter can get stuck when
2576 : : * PSR is active as no frames are generated.
2577 : : */
2578 [ # # ]: 0 : if (HAS_PSR(dev_priv))
2579 : 0 : drm_crtc_vblank_restore(crtc);
2580 : :
2581 : 0 : return 0;
2582 : : }
2583 : :
2584 : 0 : int bdw_enable_vblank(struct drm_crtc *crtc)
2585 : : {
2586 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
2587 : 0 : enum pipe pipe = to_intel_crtc(crtc)->pipe;
2588 : 0 : unsigned long irqflags;
2589 : :
2590 : 0 : spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
2591 : 0 : bdw_enable_pipe_irq(dev_priv, pipe, GEN8_PIPE_VBLANK);
2592 : 0 : spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
2593 : :
2594 : : /* Even if there is no DMC, frame counter can get stuck when
2595 : : * PSR is active as no frames are generated, so check only for PSR.
2596 : : */
2597 [ # # ]: 0 : if (HAS_PSR(dev_priv))
2598 : 0 : drm_crtc_vblank_restore(crtc);
2599 : :
2600 : 0 : return 0;
2601 : : }
2602 : :
2603 : : /* Called from drm generic code, passed 'crtc' which
2604 : : * we use as a pipe index
2605 : : */
2606 : 0 : void i8xx_disable_vblank(struct drm_crtc *crtc)
2607 : : {
2608 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
2609 : 0 : enum pipe pipe = to_intel_crtc(crtc)->pipe;
2610 : 0 : unsigned long irqflags;
2611 : :
2612 : 0 : spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
2613 : 0 : i915_disable_pipestat(dev_priv, pipe, PIPE_VBLANK_INTERRUPT_STATUS);
2614 : 0 : spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
2615 : 0 : }
2616 : :
2617 : 0 : void i915gm_disable_vblank(struct drm_crtc *crtc)
2618 : : {
2619 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
2620 : :
2621 : 0 : i8xx_disable_vblank(crtc);
2622 : :
2623 [ # # ]: 0 : if (--dev_priv->vblank_enabled == 0)
2624 : 0 : I915_WRITE(SCPD0, _MASKED_BIT_DISABLE(CSTATE_RENDER_CLOCK_GATE_DISABLE));
2625 : 0 : }
2626 : :
2627 : 0 : void i965_disable_vblank(struct drm_crtc *crtc)
2628 : : {
2629 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
2630 : 0 : enum pipe pipe = to_intel_crtc(crtc)->pipe;
2631 : 0 : unsigned long irqflags;
2632 : :
2633 : 0 : spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
2634 : 0 : i915_disable_pipestat(dev_priv, pipe,
2635 : : PIPE_START_VBLANK_INTERRUPT_STATUS);
2636 : 0 : spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
2637 : 0 : }
2638 : :
2639 : 0 : void ilk_disable_vblank(struct drm_crtc *crtc)
2640 : : {
2641 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
2642 : 0 : enum pipe pipe = to_intel_crtc(crtc)->pipe;
2643 : 0 : unsigned long irqflags;
2644 : 0 : u32 bit = INTEL_GEN(dev_priv) >= 7 ?
2645 [ # # ]: 0 : DE_PIPE_VBLANK_IVB(pipe) : DE_PIPE_VBLANK(pipe);
2646 : :
2647 : 0 : spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
2648 : 0 : ilk_disable_display_irq(dev_priv, bit);
2649 : 0 : spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
2650 : 0 : }
2651 : :
2652 : 0 : void bdw_disable_vblank(struct drm_crtc *crtc)
2653 : : {
2654 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
2655 : 0 : enum pipe pipe = to_intel_crtc(crtc)->pipe;
2656 : 0 : unsigned long irqflags;
2657 : :
2658 : 0 : spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
2659 : 0 : bdw_disable_pipe_irq(dev_priv, pipe, GEN8_PIPE_VBLANK);
2660 : 0 : spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
2661 : 0 : }
2662 : :
2663 : 0 : static void ibx_irq_reset(struct drm_i915_private *dev_priv)
2664 : : {
2665 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
2666 : :
2667 [ # # ]: 0 : if (HAS_PCH_NOP(dev_priv))
2668 : 0 : return;
2669 : :
2670 : 0 : GEN3_IRQ_RESET(uncore, SDE);
2671 : :
2672 [ # # ]: 0 : if (HAS_PCH_CPT(dev_priv) || HAS_PCH_LPT(dev_priv))
2673 : 0 : I915_WRITE(SERR_INT, 0xffffffff);
2674 : : }
2675 : :
2676 : : /*
2677 : : * SDEIER is also touched by the interrupt handler to work around missed PCH
2678 : : * interrupts. Hence we can't update it after the interrupt handler is enabled -
2679 : : * instead we unconditionally enable all PCH interrupt sources here, but then
2680 : : * only unmask them as needed with SDEIMR.
2681 : : *
2682 : : * This function needs to be called before interrupts are enabled.
2683 : : */
2684 : 0 : static void ibx_irq_pre_postinstall(struct drm_i915_private *dev_priv)
2685 : : {
2686 [ # # ]: 0 : if (HAS_PCH_NOP(dev_priv))
2687 : : return;
2688 : :
2689 [ # # ]: 0 : WARN_ON(I915_READ(SDEIER) != 0);
2690 : 0 : I915_WRITE(SDEIER, 0xffffffff);
2691 : 0 : POSTING_READ(SDEIER);
2692 : : }
2693 : :
2694 : 0 : static void vlv_display_irq_reset(struct drm_i915_private *dev_priv)
2695 : : {
2696 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
2697 : :
2698 [ # # ]: 0 : if (IS_CHERRYVIEW(dev_priv))
2699 : 0 : intel_uncore_write(uncore, DPINVGTT, DPINVGTT_STATUS_MASK_CHV);
2700 : : else
2701 : 0 : intel_uncore_write(uncore, DPINVGTT, DPINVGTT_STATUS_MASK);
2702 : :
2703 : 0 : i915_hotplug_interrupt_update_locked(dev_priv, 0xffffffff, 0);
2704 : 0 : intel_uncore_write(uncore, PORT_HOTPLUG_STAT, I915_READ(PORT_HOTPLUG_STAT));
2705 : :
2706 : 0 : i9xx_pipestat_irq_reset(dev_priv);
2707 : :
2708 : 0 : GEN3_IRQ_RESET(uncore, VLV_);
2709 : 0 : dev_priv->irq_mask = ~0u;
2710 : 0 : }
2711 : :
2712 : 0 : static void vlv_display_irq_postinstall(struct drm_i915_private *dev_priv)
2713 : : {
2714 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
2715 : :
2716 : 0 : u32 pipestat_mask;
2717 : 0 : u32 enable_mask;
2718 : 0 : enum pipe pipe;
2719 : :
2720 : 0 : pipestat_mask = PIPE_CRC_DONE_INTERRUPT_STATUS;
2721 : :
2722 : 0 : i915_enable_pipestat(dev_priv, PIPE_A, PIPE_GMBUS_INTERRUPT_STATUS);
2723 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe)
2724 : 0 : i915_enable_pipestat(dev_priv, pipe, pipestat_mask);
2725 : :
2726 : 0 : enable_mask = I915_DISPLAY_PORT_INTERRUPT |
2727 : : I915_DISPLAY_PIPE_A_EVENT_INTERRUPT |
2728 : : I915_DISPLAY_PIPE_B_EVENT_INTERRUPT |
2729 : : I915_LPE_PIPE_A_INTERRUPT |
2730 : : I915_LPE_PIPE_B_INTERRUPT;
2731 : :
2732 [ # # ]: 0 : if (IS_CHERRYVIEW(dev_priv))
2733 : 0 : enable_mask |= I915_DISPLAY_PIPE_C_EVENT_INTERRUPT |
2734 : : I915_LPE_PIPE_C_INTERRUPT;
2735 : :
2736 [ # # ]: 0 : WARN_ON(dev_priv->irq_mask != ~0u);
2737 : :
2738 : 0 : dev_priv->irq_mask = ~enable_mask;
2739 : :
2740 : 0 : GEN3_IRQ_INIT(uncore, VLV_, dev_priv->irq_mask, enable_mask);
2741 : 0 : }
2742 : :
2743 : : /* drm_dma.h hooks
2744 : : */
2745 : 0 : static void ilk_irq_reset(struct drm_i915_private *dev_priv)
2746 : : {
2747 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
2748 : :
2749 : 0 : GEN3_IRQ_RESET(uncore, DE);
2750 [ # # ]: 0 : if (IS_GEN(dev_priv, 7))
2751 : 0 : intel_uncore_write(uncore, GEN7_ERR_INT, 0xffffffff);
2752 : :
2753 [ # # ]: 0 : if (IS_HASWELL(dev_priv)) {
2754 : 0 : intel_uncore_write(uncore, EDP_PSR_IMR, 0xffffffff);
2755 : 0 : intel_uncore_write(uncore, EDP_PSR_IIR, 0xffffffff);
2756 : : }
2757 : :
2758 : 0 : gen5_gt_irq_reset(&dev_priv->gt);
2759 : :
2760 : 0 : ibx_irq_reset(dev_priv);
2761 : 0 : }
2762 : :
2763 : 0 : static void valleyview_irq_reset(struct drm_i915_private *dev_priv)
2764 : : {
2765 : 0 : I915_WRITE(VLV_MASTER_IER, 0);
2766 : 0 : POSTING_READ(VLV_MASTER_IER);
2767 : :
2768 : 0 : gen5_gt_irq_reset(&dev_priv->gt);
2769 : :
2770 : 0 : spin_lock_irq(&dev_priv->irq_lock);
2771 [ # # ]: 0 : if (dev_priv->display_irqs_enabled)
2772 : 0 : vlv_display_irq_reset(dev_priv);
2773 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
2774 : 0 : }
2775 : :
2776 : 0 : static void gen8_irq_reset(struct drm_i915_private *dev_priv)
2777 : : {
2778 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
2779 : 0 : enum pipe pipe;
2780 : :
2781 : 0 : gen8_master_intr_disable(dev_priv->uncore.regs);
2782 : :
2783 : 0 : gen8_gt_irq_reset(&dev_priv->gt);
2784 : :
2785 : 0 : intel_uncore_write(uncore, EDP_PSR_IMR, 0xffffffff);
2786 : 0 : intel_uncore_write(uncore, EDP_PSR_IIR, 0xffffffff);
2787 : :
2788 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe)
2789 [ # # ]: 0 : if (intel_display_power_is_enabled(dev_priv,
2790 : 0 : POWER_DOMAIN_PIPE(pipe)))
2791 : 0 : GEN8_IRQ_RESET_NDX(uncore, DE_PIPE, pipe);
2792 : :
2793 : 0 : GEN3_IRQ_RESET(uncore, GEN8_DE_PORT_);
2794 : 0 : GEN3_IRQ_RESET(uncore, GEN8_DE_MISC_);
2795 : 0 : GEN3_IRQ_RESET(uncore, GEN8_PCU_);
2796 : :
2797 [ # # ]: 0 : if (HAS_PCH_SPLIT(dev_priv))
2798 : 0 : ibx_irq_reset(dev_priv);
2799 : 0 : }
2800 : :
2801 : 0 : static void gen11_display_irq_reset(struct drm_i915_private *dev_priv)
2802 : : {
2803 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
2804 : 0 : enum pipe pipe;
2805 : :
2806 : 0 : intel_uncore_write(uncore, GEN11_DISPLAY_INT_CTL, 0);
2807 : :
2808 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 12) {
2809 : : enum transcoder trans;
2810 : :
2811 [ # # ]: 0 : for (trans = TRANSCODER_A; trans <= TRANSCODER_D; trans++) {
2812 : 0 : enum intel_display_power_domain domain;
2813 : :
2814 : 0 : domain = POWER_DOMAIN_TRANSCODER(trans);
2815 [ # # ]: 0 : if (!intel_display_power_is_enabled(dev_priv, domain))
2816 : 0 : continue;
2817 : :
2818 : 0 : intel_uncore_write(uncore, TRANS_PSR_IMR(trans), 0xffffffff);
2819 : 0 : intel_uncore_write(uncore, TRANS_PSR_IIR(trans), 0xffffffff);
2820 : : }
2821 : : } else {
2822 : 0 : intel_uncore_write(uncore, EDP_PSR_IMR, 0xffffffff);
2823 : 0 : intel_uncore_write(uncore, EDP_PSR_IIR, 0xffffffff);
2824 : : }
2825 : :
2826 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe)
2827 [ # # ]: 0 : if (intel_display_power_is_enabled(dev_priv,
2828 : 0 : POWER_DOMAIN_PIPE(pipe)))
2829 : 0 : GEN8_IRQ_RESET_NDX(uncore, DE_PIPE, pipe);
2830 : :
2831 : 0 : GEN3_IRQ_RESET(uncore, GEN8_DE_PORT_);
2832 : 0 : GEN3_IRQ_RESET(uncore, GEN8_DE_MISC_);
2833 : 0 : GEN3_IRQ_RESET(uncore, GEN11_DE_HPD_);
2834 : :
2835 [ # # ]: 0 : if (INTEL_PCH_TYPE(dev_priv) >= PCH_ICP)
2836 : 0 : GEN3_IRQ_RESET(uncore, SDE);
2837 : 0 : }
2838 : :
2839 : 0 : static void gen11_irq_reset(struct drm_i915_private *dev_priv)
2840 : : {
2841 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
2842 : :
2843 : 0 : gen11_master_intr_disable(dev_priv->uncore.regs);
2844 : :
2845 : 0 : gen11_gt_irq_reset(&dev_priv->gt);
2846 : 0 : gen11_display_irq_reset(dev_priv);
2847 : :
2848 : 0 : GEN3_IRQ_RESET(uncore, GEN11_GU_MISC_);
2849 : 0 : GEN3_IRQ_RESET(uncore, GEN8_PCU_);
2850 : 0 : }
2851 : :
2852 : 0 : void gen8_irq_power_well_post_enable(struct drm_i915_private *dev_priv,
2853 : : u8 pipe_mask)
2854 : : {
2855 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
2856 : :
2857 : 0 : u32 extra_ier = GEN8_PIPE_VBLANK | GEN8_PIPE_FIFO_UNDERRUN;
2858 : 0 : enum pipe pipe;
2859 : :
2860 : 0 : spin_lock_irq(&dev_priv->irq_lock);
2861 : :
2862 : 0 : if (!intel_irqs_enabled(dev_priv)) {
2863 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
2864 : 0 : return;
2865 : : }
2866 : :
2867 [ # # # # : 0 : for_each_pipe_masked(dev_priv, pipe, pipe_mask)
# # ]
2868 : 0 : GEN8_IRQ_INIT_NDX(uncore, DE_PIPE, pipe,
2869 : : dev_priv->de_irq_mask[pipe],
2870 : : ~dev_priv->de_irq_mask[pipe] | extra_ier);
2871 : :
2872 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
2873 : : }
2874 : :
2875 : 0 : void gen8_irq_power_well_pre_disable(struct drm_i915_private *dev_priv,
2876 : : u8 pipe_mask)
2877 : : {
2878 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
2879 : 0 : enum pipe pipe;
2880 : :
2881 : 0 : spin_lock_irq(&dev_priv->irq_lock);
2882 : :
2883 : 0 : if (!intel_irqs_enabled(dev_priv)) {
2884 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
2885 : 0 : return;
2886 : : }
2887 : :
2888 [ # # # # : 0 : for_each_pipe_masked(dev_priv, pipe, pipe_mask)
# # ]
2889 : 0 : GEN8_IRQ_RESET_NDX(uncore, DE_PIPE, pipe);
2890 : :
2891 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
2892 : :
2893 : : /* make sure we're done processing display irqs */
2894 : 0 : intel_synchronize_irq(dev_priv);
2895 : : }
2896 : :
2897 : 0 : static void cherryview_irq_reset(struct drm_i915_private *dev_priv)
2898 : : {
2899 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
2900 : :
2901 : 0 : I915_WRITE(GEN8_MASTER_IRQ, 0);
2902 : 0 : POSTING_READ(GEN8_MASTER_IRQ);
2903 : :
2904 : 0 : gen8_gt_irq_reset(&dev_priv->gt);
2905 : :
2906 : 0 : GEN3_IRQ_RESET(uncore, GEN8_PCU_);
2907 : :
2908 : 0 : spin_lock_irq(&dev_priv->irq_lock);
2909 [ # # ]: 0 : if (dev_priv->display_irqs_enabled)
2910 : 0 : vlv_display_irq_reset(dev_priv);
2911 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
2912 : 0 : }
2913 : :
2914 : 0 : static u32 intel_hpd_enabled_irqs(struct drm_i915_private *dev_priv,
2915 : : const u32 hpd[HPD_NUM_PINS])
2916 : : {
2917 : 0 : struct intel_encoder *encoder;
2918 : 0 : u32 enabled_irqs = 0;
2919 : :
2920 [ # # # # : 0 : for_each_intel_encoder(&dev_priv->drm, encoder)
# # # # #
# # # # #
# # # # #
# ]
2921 [ # # # # : 0 : if (dev_priv->hotplug.stats[encoder->hpd_pin].state == HPD_ENABLED)
# # # # #
# # # # #
# # # # ]
2922 : 0 : enabled_irqs |= hpd[encoder->hpd_pin];
2923 : :
2924 : 0 : return enabled_irqs;
2925 : : }
2926 : :
2927 : 0 : static void ibx_hpd_detection_setup(struct drm_i915_private *dev_priv)
2928 : : {
2929 : 0 : u32 hotplug;
2930 : :
2931 : : /*
2932 : : * Enable digital hotplug on the PCH, and configure the DP short pulse
2933 : : * duration to 2ms (which is the minimum in the Display Port spec).
2934 : : * The pulse duration bits are reserved on LPT+.
2935 : : */
2936 : 0 : hotplug = I915_READ(PCH_PORT_HOTPLUG);
2937 : 0 : hotplug &= ~(PORTB_PULSE_DURATION_MASK |
2938 : : PORTC_PULSE_DURATION_MASK |
2939 : : PORTD_PULSE_DURATION_MASK);
2940 : 0 : hotplug |= PORTB_HOTPLUG_ENABLE | PORTB_PULSE_DURATION_2ms;
2941 : 0 : hotplug |= PORTC_HOTPLUG_ENABLE | PORTC_PULSE_DURATION_2ms;
2942 : 0 : hotplug |= PORTD_HOTPLUG_ENABLE | PORTD_PULSE_DURATION_2ms;
2943 : : /*
2944 : : * When CPU and PCH are on the same package, port A
2945 : : * HPD must be enabled in both north and south.
2946 : : */
2947 [ # # ]: 0 : if (HAS_PCH_LPT_LP(dev_priv))
2948 : 0 : hotplug |= PORTA_HOTPLUG_ENABLE;
2949 : 0 : I915_WRITE(PCH_PORT_HOTPLUG, hotplug);
2950 : 0 : }
2951 : :
2952 : 0 : static void ibx_hpd_irq_setup(struct drm_i915_private *dev_priv)
2953 : : {
2954 : 0 : u32 hotplug_irqs, enabled_irqs;
2955 : :
2956 [ # # ]: 0 : if (HAS_PCH_IBX(dev_priv)) {
2957 : 0 : hotplug_irqs = SDE_HOTPLUG_MASK;
2958 : 0 : enabled_irqs = intel_hpd_enabled_irqs(dev_priv, hpd_ibx);
2959 : : } else {
2960 : 0 : hotplug_irqs = SDE_HOTPLUG_MASK_CPT;
2961 : 0 : enabled_irqs = intel_hpd_enabled_irqs(dev_priv, hpd_cpt);
2962 : : }
2963 : :
2964 : 0 : ibx_display_interrupt_update(dev_priv, hotplug_irqs, enabled_irqs);
2965 : :
2966 : 0 : ibx_hpd_detection_setup(dev_priv);
2967 : 0 : }
2968 : :
2969 : 0 : static void icp_hpd_detection_setup(struct drm_i915_private *dev_priv,
2970 : : u32 ddi_hotplug_enable_mask,
2971 : : u32 tc_hotplug_enable_mask)
2972 : : {
2973 : 0 : u32 hotplug;
2974 : :
2975 : 0 : hotplug = I915_READ(SHOTPLUG_CTL_DDI);
2976 : 0 : hotplug |= ddi_hotplug_enable_mask;
2977 : 0 : I915_WRITE(SHOTPLUG_CTL_DDI, hotplug);
2978 : :
2979 [ # # ]: 0 : if (tc_hotplug_enable_mask) {
2980 : 0 : hotplug = I915_READ(SHOTPLUG_CTL_TC);
2981 : 0 : hotplug |= tc_hotplug_enable_mask;
2982 : 0 : I915_WRITE(SHOTPLUG_CTL_TC, hotplug);
2983 : : }
2984 : 0 : }
2985 : :
2986 : 0 : static void icp_hpd_irq_setup(struct drm_i915_private *dev_priv,
2987 : : u32 sde_ddi_mask, u32 sde_tc_mask,
2988 : : u32 ddi_enable_mask, u32 tc_enable_mask,
2989 : : const u32 *pins)
2990 : : {
2991 : 0 : u32 hotplug_irqs, enabled_irqs;
2992 : :
2993 : 0 : hotplug_irqs = sde_ddi_mask | sde_tc_mask;
2994 : 0 : enabled_irqs = intel_hpd_enabled_irqs(dev_priv, pins);
2995 : :
2996 : 0 : I915_WRITE(SHPD_FILTER_CNT, SHPD_FILTER_CNT_500_ADJ);
2997 : :
2998 : 0 : ibx_display_interrupt_update(dev_priv, hotplug_irqs, enabled_irqs);
2999 : :
3000 : 0 : icp_hpd_detection_setup(dev_priv, ddi_enable_mask, tc_enable_mask);
3001 : 0 : }
3002 : :
3003 : : /*
3004 : : * EHL doesn't need most of gen11_hpd_irq_setup, it's handling only the
3005 : : * equivalent of SDE.
3006 : : */
3007 : 0 : static void mcc_hpd_irq_setup(struct drm_i915_private *dev_priv)
3008 : : {
3009 : 0 : icp_hpd_irq_setup(dev_priv,
3010 : : SDE_DDI_MASK_ICP, SDE_TC_HOTPLUG_ICP(PORT_TC1),
3011 : : ICP_DDI_HPD_ENABLE_MASK, ICP_TC_HPD_ENABLE(PORT_TC1),
3012 : : hpd_icp);
3013 : 0 : }
3014 : :
3015 : : /*
3016 : : * JSP behaves exactly the same as MCC above except that port C is mapped to
3017 : : * the DDI-C pins instead of the TC1 pins. This means we should follow TGP's
3018 : : * masks & tables rather than ICP's masks & tables.
3019 : : */
3020 : 0 : static void jsp_hpd_irq_setup(struct drm_i915_private *dev_priv)
3021 : : {
3022 : 0 : icp_hpd_irq_setup(dev_priv,
3023 : : SDE_DDI_MASK_TGP, 0,
3024 : : TGP_DDI_HPD_ENABLE_MASK, 0,
3025 : : hpd_tgp);
3026 : 0 : }
3027 : :
3028 : 0 : static void gen11_hpd_detection_setup(struct drm_i915_private *dev_priv)
3029 : : {
3030 : 0 : u32 hotplug;
3031 : :
3032 : 0 : hotplug = I915_READ(GEN11_TC_HOTPLUG_CTL);
3033 : 0 : hotplug |= GEN11_HOTPLUG_CTL_ENABLE(PORT_TC1) |
3034 : : GEN11_HOTPLUG_CTL_ENABLE(PORT_TC2) |
3035 : : GEN11_HOTPLUG_CTL_ENABLE(PORT_TC3) |
3036 : : GEN11_HOTPLUG_CTL_ENABLE(PORT_TC4);
3037 : 0 : I915_WRITE(GEN11_TC_HOTPLUG_CTL, hotplug);
3038 : :
3039 : 0 : hotplug = I915_READ(GEN11_TBT_HOTPLUG_CTL);
3040 : 0 : hotplug |= GEN11_HOTPLUG_CTL_ENABLE(PORT_TC1) |
3041 : : GEN11_HOTPLUG_CTL_ENABLE(PORT_TC2) |
3042 : : GEN11_HOTPLUG_CTL_ENABLE(PORT_TC3) |
3043 : : GEN11_HOTPLUG_CTL_ENABLE(PORT_TC4);
3044 : 0 : I915_WRITE(GEN11_TBT_HOTPLUG_CTL, hotplug);
3045 : 0 : }
3046 : :
3047 : 0 : static void gen11_hpd_irq_setup(struct drm_i915_private *dev_priv)
3048 : : {
3049 : 0 : u32 hotplug_irqs, enabled_irqs;
3050 : 0 : const u32 *hpd;
3051 : 0 : u32 val;
3052 : :
3053 : 0 : hpd = INTEL_GEN(dev_priv) >= 12 ? hpd_gen12 : hpd_gen11;
3054 : 0 : enabled_irqs = intel_hpd_enabled_irqs(dev_priv, hpd);
3055 : 0 : hotplug_irqs = GEN11_DE_TC_HOTPLUG_MASK | GEN11_DE_TBT_HOTPLUG_MASK;
3056 : :
3057 : 0 : val = I915_READ(GEN11_DE_HPD_IMR);
3058 : 0 : val &= ~hotplug_irqs;
3059 : 0 : I915_WRITE(GEN11_DE_HPD_IMR, val);
3060 : 0 : POSTING_READ(GEN11_DE_HPD_IMR);
3061 : :
3062 : 0 : gen11_hpd_detection_setup(dev_priv);
3063 : :
3064 [ # # ]: 0 : if (INTEL_PCH_TYPE(dev_priv) >= PCH_TGP)
3065 : 0 : icp_hpd_irq_setup(dev_priv, SDE_DDI_MASK_TGP, SDE_TC_MASK_TGP,
3066 : : TGP_DDI_HPD_ENABLE_MASK,
3067 : : TGP_TC_HPD_ENABLE_MASK, hpd_tgp);
3068 [ # # ]: 0 : else if (INTEL_PCH_TYPE(dev_priv) >= PCH_ICP)
3069 : 0 : icp_hpd_irq_setup(dev_priv, SDE_DDI_MASK_ICP, SDE_TC_MASK_ICP,
3070 : : ICP_DDI_HPD_ENABLE_MASK,
3071 : : ICP_TC_HPD_ENABLE_MASK, hpd_icp);
3072 : 0 : }
3073 : :
3074 : 0 : static void spt_hpd_detection_setup(struct drm_i915_private *dev_priv)
3075 : : {
3076 : 0 : u32 val, hotplug;
3077 : :
3078 : : /* Display WA #1179 WaHardHangonHotPlug: cnp */
3079 [ # # ]: 0 : if (HAS_PCH_CNP(dev_priv)) {
3080 : 0 : val = I915_READ(SOUTH_CHICKEN1);
3081 : 0 : val &= ~CHASSIS_CLK_REQ_DURATION_MASK;
3082 : 0 : val |= CHASSIS_CLK_REQ_DURATION(0xf);
3083 : 0 : I915_WRITE(SOUTH_CHICKEN1, val);
3084 : : }
3085 : :
3086 : : /* Enable digital hotplug on the PCH */
3087 : 0 : hotplug = I915_READ(PCH_PORT_HOTPLUG);
3088 : 0 : hotplug |= PORTA_HOTPLUG_ENABLE |
3089 : : PORTB_HOTPLUG_ENABLE |
3090 : : PORTC_HOTPLUG_ENABLE |
3091 : : PORTD_HOTPLUG_ENABLE;
3092 : 0 : I915_WRITE(PCH_PORT_HOTPLUG, hotplug);
3093 : :
3094 : 0 : hotplug = I915_READ(PCH_PORT_HOTPLUG2);
3095 : 0 : hotplug |= PORTE_HOTPLUG_ENABLE;
3096 : 0 : I915_WRITE(PCH_PORT_HOTPLUG2, hotplug);
3097 : 0 : }
3098 : :
3099 : 0 : static void spt_hpd_irq_setup(struct drm_i915_private *dev_priv)
3100 : : {
3101 : 0 : u32 hotplug_irqs, enabled_irqs;
3102 : :
3103 [ # # ]: 0 : if (INTEL_PCH_TYPE(dev_priv) >= PCH_CNP)
3104 : 0 : I915_WRITE(SHPD_FILTER_CNT, SHPD_FILTER_CNT_500_ADJ);
3105 : :
3106 : 0 : hotplug_irqs = SDE_HOTPLUG_MASK_SPT;
3107 : 0 : enabled_irqs = intel_hpd_enabled_irqs(dev_priv, hpd_spt);
3108 : :
3109 : 0 : ibx_display_interrupt_update(dev_priv, hotplug_irqs, enabled_irqs);
3110 : :
3111 : 0 : spt_hpd_detection_setup(dev_priv);
3112 : 0 : }
3113 : :
3114 : 0 : static void ilk_hpd_detection_setup(struct drm_i915_private *dev_priv)
3115 : : {
3116 : 0 : u32 hotplug;
3117 : :
3118 : : /*
3119 : : * Enable digital hotplug on the CPU, and configure the DP short pulse
3120 : : * duration to 2ms (which is the minimum in the Display Port spec)
3121 : : * The pulse duration bits are reserved on HSW+.
3122 : : */
3123 : 0 : hotplug = I915_READ(DIGITAL_PORT_HOTPLUG_CNTRL);
3124 : 0 : hotplug &= ~DIGITAL_PORTA_PULSE_DURATION_MASK;
3125 : 0 : hotplug |= DIGITAL_PORTA_HOTPLUG_ENABLE |
3126 : : DIGITAL_PORTA_PULSE_DURATION_2ms;
3127 : 0 : I915_WRITE(DIGITAL_PORT_HOTPLUG_CNTRL, hotplug);
3128 : 0 : }
3129 : :
3130 : 0 : static void ilk_hpd_irq_setup(struct drm_i915_private *dev_priv)
3131 : : {
3132 : 0 : u32 hotplug_irqs, enabled_irqs;
3133 : :
3134 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 8) {
3135 : 0 : hotplug_irqs = GEN8_PORT_DP_A_HOTPLUG;
3136 : 0 : enabled_irqs = intel_hpd_enabled_irqs(dev_priv, hpd_bdw);
3137 : :
3138 : 0 : bdw_update_port_irq(dev_priv, hotplug_irqs, enabled_irqs);
3139 [ # # ]: 0 : } else if (INTEL_GEN(dev_priv) >= 7) {
3140 : 0 : hotplug_irqs = DE_DP_A_HOTPLUG_IVB;
3141 : 0 : enabled_irqs = intel_hpd_enabled_irqs(dev_priv, hpd_ivb);
3142 : :
3143 : 0 : ilk_update_display_irq(dev_priv, hotplug_irqs, enabled_irqs);
3144 : : } else {
3145 : 0 : hotplug_irqs = DE_DP_A_HOTPLUG;
3146 : 0 : enabled_irqs = intel_hpd_enabled_irqs(dev_priv, hpd_ilk);
3147 : :
3148 : 0 : ilk_update_display_irq(dev_priv, hotplug_irqs, enabled_irqs);
3149 : : }
3150 : :
3151 : 0 : ilk_hpd_detection_setup(dev_priv);
3152 : :
3153 : 0 : ibx_hpd_irq_setup(dev_priv);
3154 : 0 : }
3155 : :
3156 : 0 : static void __bxt_hpd_detection_setup(struct drm_i915_private *dev_priv,
3157 : : u32 enabled_irqs)
3158 : : {
3159 : 0 : u32 hotplug;
3160 : :
3161 : 0 : hotplug = I915_READ(PCH_PORT_HOTPLUG);
3162 : 0 : hotplug |= PORTA_HOTPLUG_ENABLE |
3163 : : PORTB_HOTPLUG_ENABLE |
3164 : : PORTC_HOTPLUG_ENABLE;
3165 : :
3166 : 0 : DRM_DEBUG_KMS("Invert bit setting: hp_ctl:%x hp_port:%x\n",
3167 : : hotplug, enabled_irqs);
3168 : 0 : hotplug &= ~BXT_DDI_HPD_INVERT_MASK;
3169 : :
3170 : : /*
3171 : : * For BXT invert bit has to be set based on AOB design
3172 : : * for HPD detection logic, update it based on VBT fields.
3173 : : */
3174 [ # # # # ]: 0 : if ((enabled_irqs & BXT_DE_PORT_HP_DDIA) &&
3175 : 0 : intel_bios_is_port_hpd_inverted(dev_priv, PORT_A))
3176 : 0 : hotplug |= BXT_DDIA_HPD_INVERT;
3177 [ # # # # ]: 0 : if ((enabled_irqs & BXT_DE_PORT_HP_DDIB) &&
3178 : 0 : intel_bios_is_port_hpd_inverted(dev_priv, PORT_B))
3179 : 0 : hotplug |= BXT_DDIB_HPD_INVERT;
3180 [ # # # # ]: 0 : if ((enabled_irqs & BXT_DE_PORT_HP_DDIC) &&
3181 : 0 : intel_bios_is_port_hpd_inverted(dev_priv, PORT_C))
3182 : 0 : hotplug |= BXT_DDIC_HPD_INVERT;
3183 : :
3184 : 0 : I915_WRITE(PCH_PORT_HOTPLUG, hotplug);
3185 : 0 : }
3186 : :
3187 : 0 : static void bxt_hpd_detection_setup(struct drm_i915_private *dev_priv)
3188 : : {
3189 : 0 : __bxt_hpd_detection_setup(dev_priv, BXT_DE_PORT_HOTPLUG_MASK);
3190 : 0 : }
3191 : :
3192 : 0 : static void bxt_hpd_irq_setup(struct drm_i915_private *dev_priv)
3193 : : {
3194 : 0 : u32 hotplug_irqs, enabled_irqs;
3195 : :
3196 : 0 : enabled_irqs = intel_hpd_enabled_irqs(dev_priv, hpd_bxt);
3197 : 0 : hotplug_irqs = BXT_DE_PORT_HOTPLUG_MASK;
3198 : :
3199 : 0 : bdw_update_port_irq(dev_priv, hotplug_irqs, enabled_irqs);
3200 : :
3201 : 0 : __bxt_hpd_detection_setup(dev_priv, enabled_irqs);
3202 : 0 : }
3203 : :
3204 : 0 : static void ibx_irq_postinstall(struct drm_i915_private *dev_priv)
3205 : : {
3206 : 0 : u32 mask;
3207 : :
3208 [ # # ]: 0 : if (HAS_PCH_NOP(dev_priv))
3209 : 0 : return;
3210 : :
3211 [ # # ]: 0 : if (HAS_PCH_IBX(dev_priv))
3212 : : mask = SDE_GMBUS | SDE_AUX_MASK | SDE_POISON;
3213 [ # # ]: 0 : else if (HAS_PCH_CPT(dev_priv) || HAS_PCH_LPT(dev_priv))
3214 : : mask = SDE_GMBUS_CPT | SDE_AUX_MASK_CPT;
3215 : : else
3216 : 0 : mask = SDE_GMBUS_CPT;
3217 : :
3218 : 0 : gen3_assert_iir_is_zero(&dev_priv->uncore, SDEIIR);
3219 : 0 : I915_WRITE(SDEIMR, ~mask);
3220 : :
3221 [ # # ]: 0 : if (HAS_PCH_IBX(dev_priv) || HAS_PCH_CPT(dev_priv) ||
3222 : : HAS_PCH_LPT(dev_priv))
3223 : 0 : ibx_hpd_detection_setup(dev_priv);
3224 : : else
3225 : 0 : spt_hpd_detection_setup(dev_priv);
3226 : : }
3227 : :
3228 : 0 : static void ilk_irq_postinstall(struct drm_i915_private *dev_priv)
3229 : : {
3230 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
3231 : 0 : u32 display_mask, extra_mask;
3232 : :
3233 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 7) {
3234 : : display_mask = (DE_MASTER_IRQ_CONTROL | DE_GSE_IVB |
3235 : : DE_PCH_EVENT_IVB | DE_AUX_CHANNEL_A_IVB);
3236 : : extra_mask = (DE_PIPEC_VBLANK_IVB | DE_PIPEB_VBLANK_IVB |
3237 : : DE_PIPEA_VBLANK_IVB | DE_ERR_INT_IVB |
3238 : : DE_DP_A_HOTPLUG_IVB);
3239 : : } else {
3240 : 0 : display_mask = (DE_MASTER_IRQ_CONTROL | DE_GSE | DE_PCH_EVENT |
3241 : : DE_AUX_CHANNEL_A | DE_PIPEB_CRC_DONE |
3242 : : DE_PIPEA_CRC_DONE | DE_POISON);
3243 : 0 : extra_mask = (DE_PIPEA_VBLANK | DE_PIPEB_VBLANK | DE_PCU_EVENT |
3244 : : DE_PIPEB_FIFO_UNDERRUN | DE_PIPEA_FIFO_UNDERRUN |
3245 : : DE_DP_A_HOTPLUG);
3246 : : }
3247 : :
3248 [ # # ]: 0 : if (IS_HASWELL(dev_priv)) {
3249 : 0 : gen3_assert_iir_is_zero(uncore, EDP_PSR_IIR);
3250 : 0 : display_mask |= DE_EDP_PSR_INT_HSW;
3251 : : }
3252 : :
3253 : 0 : dev_priv->irq_mask = ~display_mask;
3254 : :
3255 : 0 : ibx_irq_pre_postinstall(dev_priv);
3256 : :
3257 : 0 : GEN3_IRQ_INIT(uncore, DE, dev_priv->irq_mask,
3258 : : display_mask | extra_mask);
3259 : :
3260 : 0 : gen5_gt_irq_postinstall(&dev_priv->gt);
3261 : :
3262 : 0 : ilk_hpd_detection_setup(dev_priv);
3263 : :
3264 : 0 : ibx_irq_postinstall(dev_priv);
3265 : :
3266 [ # # # # ]: 0 : if (IS_IRONLAKE_M(dev_priv)) {
3267 : : /* Enable PCU event interrupts
3268 : : *
3269 : : * spinlocking not required here for correctness since interrupt
3270 : : * setup is guaranteed to run in single-threaded context. But we
3271 : : * need it to make the assert_spin_locked happy. */
3272 : 0 : spin_lock_irq(&dev_priv->irq_lock);
3273 : 0 : ilk_enable_display_irq(dev_priv, DE_PCU_EVENT);
3274 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
3275 : : }
3276 : 0 : }
3277 : :
3278 : 0 : void valleyview_enable_display_irqs(struct drm_i915_private *dev_priv)
3279 : : {
3280 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
3281 : :
3282 [ # # ]: 0 : if (dev_priv->display_irqs_enabled)
3283 : : return;
3284 : :
3285 : 0 : dev_priv->display_irqs_enabled = true;
3286 : :
3287 : 0 : if (intel_irqs_enabled(dev_priv)) {
3288 : 0 : vlv_display_irq_reset(dev_priv);
3289 : 0 : vlv_display_irq_postinstall(dev_priv);
3290 : : }
3291 : : }
3292 : :
3293 : 0 : void valleyview_disable_display_irqs(struct drm_i915_private *dev_priv)
3294 : : {
3295 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
3296 : :
3297 [ # # ]: 0 : if (!dev_priv->display_irqs_enabled)
3298 : : return;
3299 : :
3300 : 0 : dev_priv->display_irqs_enabled = false;
3301 : :
3302 : 0 : if (intel_irqs_enabled(dev_priv))
3303 : 0 : vlv_display_irq_reset(dev_priv);
3304 : : }
3305 : :
3306 : :
3307 : 0 : static void valleyview_irq_postinstall(struct drm_i915_private *dev_priv)
3308 : : {
3309 : 0 : gen5_gt_irq_postinstall(&dev_priv->gt);
3310 : :
3311 : 0 : spin_lock_irq(&dev_priv->irq_lock);
3312 [ # # ]: 0 : if (dev_priv->display_irqs_enabled)
3313 : 0 : vlv_display_irq_postinstall(dev_priv);
3314 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
3315 : :
3316 : 0 : I915_WRITE(VLV_MASTER_IER, MASTER_INTERRUPT_ENABLE);
3317 : 0 : POSTING_READ(VLV_MASTER_IER);
3318 : 0 : }
3319 : :
3320 : 0 : static void gen8_de_irq_postinstall(struct drm_i915_private *dev_priv)
3321 : : {
3322 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
3323 : :
3324 : 0 : u32 de_pipe_masked = GEN8_PIPE_CDCLK_CRC_DONE;
3325 : 0 : u32 de_pipe_enables;
3326 : 0 : u32 de_port_masked = GEN8_AUX_CHANNEL_A;
3327 : 0 : u32 de_port_enables;
3328 : 0 : u32 de_misc_masked = GEN8_DE_EDP_PSR;
3329 : 0 : enum pipe pipe;
3330 : :
3331 [ # # ]: 0 : if (INTEL_GEN(dev_priv) <= 10)
3332 : 0 : de_misc_masked |= GEN8_DE_MISC_GSE;
3333 : :
3334 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9) {
3335 : 0 : de_pipe_masked |= GEN9_DE_PIPE_IRQ_FAULT_ERRORS;
3336 : 0 : de_port_masked |= GEN9_AUX_CHANNEL_B | GEN9_AUX_CHANNEL_C |
3337 : : GEN9_AUX_CHANNEL_D;
3338 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv))
3339 : 0 : de_port_masked |= BXT_DE_PORT_GMBUS;
3340 : : } else {
3341 : : de_pipe_masked |= GEN8_DE_PIPE_IRQ_FAULT_ERRORS;
3342 : : }
3343 : :
3344 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 11)
3345 : 0 : de_port_masked |= ICL_AUX_CHANNEL_E;
3346 : :
3347 [ # # # # ]: 0 : if (IS_CNL_WITH_PORT_F(dev_priv) || INTEL_GEN(dev_priv) >= 11)
3348 : 0 : de_port_masked |= CNL_AUX_CHANNEL_F;
3349 : :
3350 : 0 : de_pipe_enables = de_pipe_masked | GEN8_PIPE_VBLANK |
3351 : : GEN8_PIPE_FIFO_UNDERRUN;
3352 : :
3353 : 0 : de_port_enables = de_port_masked;
3354 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv))
3355 : 0 : de_port_enables |= BXT_DE_PORT_HOTPLUG_MASK;
3356 [ # # ]: 0 : else if (IS_BROADWELL(dev_priv))
3357 : 0 : de_port_enables |= GEN8_PORT_DP_A_HOTPLUG;
3358 : :
3359 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 12) {
3360 : : enum transcoder trans;
3361 : :
3362 [ # # ]: 0 : for (trans = TRANSCODER_A; trans <= TRANSCODER_D; trans++) {
3363 : 0 : enum intel_display_power_domain domain;
3364 : :
3365 : 0 : domain = POWER_DOMAIN_TRANSCODER(trans);
3366 [ # # ]: 0 : if (!intel_display_power_is_enabled(dev_priv, domain))
3367 : 0 : continue;
3368 : :
3369 : 0 : gen3_assert_iir_is_zero(uncore, TRANS_PSR_IIR(trans));
3370 : : }
3371 : : } else {
3372 : 0 : gen3_assert_iir_is_zero(uncore, EDP_PSR_IIR);
3373 : : }
3374 : :
3375 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
3376 : 0 : dev_priv->de_irq_mask[pipe] = ~de_pipe_masked;
3377 : :
3378 [ # # ]: 0 : if (intel_display_power_is_enabled(dev_priv,
3379 : 0 : POWER_DOMAIN_PIPE(pipe)))
3380 : 0 : GEN8_IRQ_INIT_NDX(uncore, DE_PIPE, pipe,
3381 : : dev_priv->de_irq_mask[pipe],
3382 : : de_pipe_enables);
3383 : : }
3384 : :
3385 : 0 : GEN3_IRQ_INIT(uncore, GEN8_DE_PORT_, ~de_port_masked, de_port_enables);
3386 : 0 : GEN3_IRQ_INIT(uncore, GEN8_DE_MISC_, ~de_misc_masked, de_misc_masked);
3387 : :
3388 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 11) {
3389 : 0 : u32 de_hpd_masked = 0;
3390 : 0 : u32 de_hpd_enables = GEN11_DE_TC_HOTPLUG_MASK |
3391 : : GEN11_DE_TBT_HOTPLUG_MASK;
3392 : :
3393 : 0 : GEN3_IRQ_INIT(uncore, GEN11_DE_HPD_, ~de_hpd_masked,
3394 : : de_hpd_enables);
3395 : 0 : gen11_hpd_detection_setup(dev_priv);
3396 [ # # # # ]: 0 : } else if (IS_GEN9_LP(dev_priv)) {
3397 : 0 : bxt_hpd_detection_setup(dev_priv);
3398 [ # # ]: 0 : } else if (IS_BROADWELL(dev_priv)) {
3399 : 0 : ilk_hpd_detection_setup(dev_priv);
3400 : : }
3401 : 0 : }
3402 : :
3403 : 0 : static void gen8_irq_postinstall(struct drm_i915_private *dev_priv)
3404 : : {
3405 [ # # ]: 0 : if (HAS_PCH_SPLIT(dev_priv))
3406 : 0 : ibx_irq_pre_postinstall(dev_priv);
3407 : :
3408 : 0 : gen8_gt_irq_postinstall(&dev_priv->gt);
3409 : 0 : gen8_de_irq_postinstall(dev_priv);
3410 : :
3411 [ # # ]: 0 : if (HAS_PCH_SPLIT(dev_priv))
3412 : 0 : ibx_irq_postinstall(dev_priv);
3413 : :
3414 : 0 : gen8_master_intr_enable(dev_priv->uncore.regs);
3415 : 0 : }
3416 : :
3417 : 0 : static void icp_irq_postinstall(struct drm_i915_private *dev_priv)
3418 : : {
3419 : 0 : u32 mask = SDE_GMBUS_ICP;
3420 : :
3421 [ # # ]: 0 : WARN_ON(I915_READ(SDEIER) != 0);
3422 : 0 : I915_WRITE(SDEIER, 0xffffffff);
3423 : 0 : POSTING_READ(SDEIER);
3424 : :
3425 : 0 : gen3_assert_iir_is_zero(&dev_priv->uncore, SDEIIR);
3426 : 0 : I915_WRITE(SDEIMR, ~mask);
3427 : :
3428 [ # # ]: 0 : if (HAS_PCH_TGP(dev_priv))
3429 : 0 : icp_hpd_detection_setup(dev_priv, TGP_DDI_HPD_ENABLE_MASK,
3430 : : TGP_TC_HPD_ENABLE_MASK);
3431 [ # # ]: 0 : else if (HAS_PCH_JSP(dev_priv))
3432 : 0 : icp_hpd_detection_setup(dev_priv, TGP_DDI_HPD_ENABLE_MASK, 0);
3433 [ # # ]: 0 : else if (HAS_PCH_MCC(dev_priv))
3434 : 0 : icp_hpd_detection_setup(dev_priv, ICP_DDI_HPD_ENABLE_MASK,
3435 : : ICP_TC_HPD_ENABLE(PORT_TC1));
3436 : : else
3437 : 0 : icp_hpd_detection_setup(dev_priv, ICP_DDI_HPD_ENABLE_MASK,
3438 : : ICP_TC_HPD_ENABLE_MASK);
3439 : 0 : }
3440 : :
3441 : 0 : static void gen11_irq_postinstall(struct drm_i915_private *dev_priv)
3442 : : {
3443 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
3444 : 0 : u32 gu_misc_masked = GEN11_GU_MISC_GSE;
3445 : :
3446 [ # # ]: 0 : if (INTEL_PCH_TYPE(dev_priv) >= PCH_ICP)
3447 : 0 : icp_irq_postinstall(dev_priv);
3448 : :
3449 : 0 : gen11_gt_irq_postinstall(&dev_priv->gt);
3450 : 0 : gen8_de_irq_postinstall(dev_priv);
3451 : :
3452 : 0 : GEN3_IRQ_INIT(uncore, GEN11_GU_MISC_, ~gu_misc_masked, gu_misc_masked);
3453 : :
3454 : 0 : I915_WRITE(GEN11_DISPLAY_INT_CTL, GEN11_DISPLAY_IRQ_ENABLE);
3455 : :
3456 : 0 : gen11_master_intr_enable(uncore->regs);
3457 : 0 : POSTING_READ(GEN11_GFX_MSTR_IRQ);
3458 : 0 : }
3459 : :
3460 : 0 : static void cherryview_irq_postinstall(struct drm_i915_private *dev_priv)
3461 : : {
3462 : 0 : gen8_gt_irq_postinstall(&dev_priv->gt);
3463 : :
3464 : 0 : spin_lock_irq(&dev_priv->irq_lock);
3465 [ # # ]: 0 : if (dev_priv->display_irqs_enabled)
3466 : 0 : vlv_display_irq_postinstall(dev_priv);
3467 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
3468 : :
3469 : 0 : I915_WRITE(GEN8_MASTER_IRQ, GEN8_MASTER_IRQ_CONTROL);
3470 : 0 : POSTING_READ(GEN8_MASTER_IRQ);
3471 : 0 : }
3472 : :
3473 : 0 : static void i8xx_irq_reset(struct drm_i915_private *dev_priv)
3474 : : {
3475 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
3476 : :
3477 : 0 : i9xx_pipestat_irq_reset(dev_priv);
3478 : :
3479 : 0 : GEN2_IRQ_RESET(uncore);
3480 : 0 : }
3481 : :
3482 : 0 : static void i8xx_irq_postinstall(struct drm_i915_private *dev_priv)
3483 : : {
3484 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
3485 : 0 : u16 enable_mask;
3486 : :
3487 : 0 : intel_uncore_write16(uncore,
3488 : : EMR,
3489 : : ~(I915_ERROR_PAGE_TABLE |
3490 : : I915_ERROR_MEMORY_REFRESH));
3491 : :
3492 : : /* Unmask the interrupts that we always want on. */
3493 : 0 : dev_priv->irq_mask =
3494 : : ~(I915_DISPLAY_PIPE_A_EVENT_INTERRUPT |
3495 : : I915_DISPLAY_PIPE_B_EVENT_INTERRUPT |
3496 : : I915_MASTER_ERROR_INTERRUPT);
3497 : :
3498 : 0 : enable_mask =
3499 : : I915_DISPLAY_PIPE_A_EVENT_INTERRUPT |
3500 : : I915_DISPLAY_PIPE_B_EVENT_INTERRUPT |
3501 : : I915_MASTER_ERROR_INTERRUPT |
3502 : : I915_USER_INTERRUPT;
3503 : :
3504 : 0 : GEN2_IRQ_INIT(uncore, dev_priv->irq_mask, enable_mask);
3505 : :
3506 : : /* Interrupt setup is already guaranteed to be single-threaded, this is
3507 : : * just to make the assert_spin_locked check happy. */
3508 : 0 : spin_lock_irq(&dev_priv->irq_lock);
3509 : 0 : i915_enable_pipestat(dev_priv, PIPE_A, PIPE_CRC_DONE_INTERRUPT_STATUS);
3510 : 0 : i915_enable_pipestat(dev_priv, PIPE_B, PIPE_CRC_DONE_INTERRUPT_STATUS);
3511 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
3512 : 0 : }
3513 : :
3514 : 0 : static void i8xx_error_irq_ack(struct drm_i915_private *i915,
3515 : : u16 *eir, u16 *eir_stuck)
3516 : : {
3517 : 0 : struct intel_uncore *uncore = &i915->uncore;
3518 : 0 : u16 emr;
3519 : :
3520 : 0 : *eir = intel_uncore_read16(uncore, EIR);
3521 : :
3522 [ # # ]: 0 : if (*eir)
3523 : 0 : intel_uncore_write16(uncore, EIR, *eir);
3524 : :
3525 : 0 : *eir_stuck = intel_uncore_read16(uncore, EIR);
3526 [ # # ]: 0 : if (*eir_stuck == 0)
3527 : : return;
3528 : :
3529 : : /*
3530 : : * Toggle all EMR bits to make sure we get an edge
3531 : : * in the ISR master error bit if we don't clear
3532 : : * all the EIR bits. Otherwise the edge triggered
3533 : : * IIR on i965/g4x wouldn't notice that an interrupt
3534 : : * is still pending. Also some EIR bits can't be
3535 : : * cleared except by handling the underlying error
3536 : : * (or by a GPU reset) so we mask any bit that
3537 : : * remains set.
3538 : : */
3539 : 0 : emr = intel_uncore_read16(uncore, EMR);
3540 : 0 : intel_uncore_write16(uncore, EMR, 0xffff);
3541 : 0 : intel_uncore_write16(uncore, EMR, emr | *eir_stuck);
3542 : : }
3543 : :
3544 : 0 : static void i8xx_error_irq_handler(struct drm_i915_private *dev_priv,
3545 : : u16 eir, u16 eir_stuck)
3546 : : {
3547 : 0 : DRM_DEBUG("Master Error: EIR 0x%04x\n", eir);
3548 : :
3549 [ # # ]: 0 : if (eir_stuck)
3550 : 0 : DRM_DEBUG_DRIVER("EIR stuck: 0x%04x, masked\n", eir_stuck);
3551 : 0 : }
3552 : :
3553 : 0 : static void i9xx_error_irq_ack(struct drm_i915_private *dev_priv,
3554 : : u32 *eir, u32 *eir_stuck)
3555 : : {
3556 : 0 : u32 emr;
3557 : :
3558 : 0 : *eir = I915_READ(EIR);
3559 : :
3560 : 0 : I915_WRITE(EIR, *eir);
3561 : :
3562 : 0 : *eir_stuck = I915_READ(EIR);
3563 [ # # ]: 0 : if (*eir_stuck == 0)
3564 : : return;
3565 : :
3566 : : /*
3567 : : * Toggle all EMR bits to make sure we get an edge
3568 : : * in the ISR master error bit if we don't clear
3569 : : * all the EIR bits. Otherwise the edge triggered
3570 : : * IIR on i965/g4x wouldn't notice that an interrupt
3571 : : * is still pending. Also some EIR bits can't be
3572 : : * cleared except by handling the underlying error
3573 : : * (or by a GPU reset) so we mask any bit that
3574 : : * remains set.
3575 : : */
3576 : 0 : emr = I915_READ(EMR);
3577 : 0 : I915_WRITE(EMR, 0xffffffff);
3578 : 0 : I915_WRITE(EMR, emr | *eir_stuck);
3579 : : }
3580 : :
3581 : : static void i9xx_error_irq_handler(struct drm_i915_private *dev_priv,
3582 : : u32 eir, u32 eir_stuck)
3583 : : {
3584 : : DRM_DEBUG("Master Error, EIR 0x%08x\n", eir);
3585 : :
3586 : : if (eir_stuck)
3587 : : DRM_DEBUG_DRIVER("EIR stuck: 0x%08x, masked\n", eir_stuck);
3588 : : }
3589 : :
3590 : 0 : static irqreturn_t i8xx_irq_handler(int irq, void *arg)
3591 : : {
3592 : 0 : struct drm_i915_private *dev_priv = arg;
3593 : 0 : irqreturn_t ret = IRQ_NONE;
3594 : :
3595 : 0 : if (!intel_irqs_enabled(dev_priv))
3596 : : return IRQ_NONE;
3597 : :
3598 : : /* IRQs are synced during runtime_suspend, we don't require a wakeref */
3599 : 0 : disable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
3600 : :
3601 : 0 : do {
3602 : 0 : u32 pipe_stats[I915_MAX_PIPES] = {};
3603 : 0 : u16 eir = 0, eir_stuck = 0;
3604 : 0 : u16 iir;
3605 : :
3606 : 0 : iir = intel_uncore_read16(&dev_priv->uncore, GEN2_IIR);
3607 [ # # ]: 0 : if (iir == 0)
3608 : : break;
3609 : :
3610 : 0 : ret = IRQ_HANDLED;
3611 : :
3612 : : /* Call regardless, as some status bits might not be
3613 : : * signalled in iir */
3614 : 0 : i9xx_pipestat_irq_ack(dev_priv, iir, pipe_stats);
3615 : :
3616 [ # # ]: 0 : if (iir & I915_MASTER_ERROR_INTERRUPT)
3617 : 0 : i8xx_error_irq_ack(dev_priv, &eir, &eir_stuck);
3618 : :
3619 : 0 : intel_uncore_write16(&dev_priv->uncore, GEN2_IIR, iir);
3620 : :
3621 [ # # ]: 0 : if (iir & I915_USER_INTERRUPT)
3622 : 0 : intel_engine_signal_breadcrumbs(dev_priv->engine[RCS0]);
3623 : :
3624 [ # # ]: 0 : if (iir & I915_MASTER_ERROR_INTERRUPT)
3625 : 0 : i8xx_error_irq_handler(dev_priv, eir, eir_stuck);
3626 : :
3627 : 0 : i8xx_pipestat_irq_handler(dev_priv, iir, pipe_stats);
3628 : 0 : } while (0);
3629 : :
3630 : 0 : enable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
3631 : :
3632 : 0 : return ret;
3633 : : }
3634 : :
3635 : 0 : static void i915_irq_reset(struct drm_i915_private *dev_priv)
3636 : : {
3637 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
3638 : :
3639 [ # # ]: 0 : if (I915_HAS_HOTPLUG(dev_priv)) {
3640 : 0 : i915_hotplug_interrupt_update(dev_priv, 0xffffffff, 0);
3641 : 0 : I915_WRITE(PORT_HOTPLUG_STAT, I915_READ(PORT_HOTPLUG_STAT));
3642 : : }
3643 : :
3644 : 0 : i9xx_pipestat_irq_reset(dev_priv);
3645 : :
3646 : 0 : GEN3_IRQ_RESET(uncore, GEN2_);
3647 : 0 : }
3648 : :
3649 : 0 : static void i915_irq_postinstall(struct drm_i915_private *dev_priv)
3650 : : {
3651 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
3652 : 0 : u32 enable_mask;
3653 : :
3654 : 0 : I915_WRITE(EMR, ~(I915_ERROR_PAGE_TABLE |
3655 : : I915_ERROR_MEMORY_REFRESH));
3656 : :
3657 : : /* Unmask the interrupts that we always want on. */
3658 : 0 : dev_priv->irq_mask =
3659 : : ~(I915_ASLE_INTERRUPT |
3660 : : I915_DISPLAY_PIPE_A_EVENT_INTERRUPT |
3661 : : I915_DISPLAY_PIPE_B_EVENT_INTERRUPT |
3662 : : I915_MASTER_ERROR_INTERRUPT);
3663 : :
3664 : 0 : enable_mask =
3665 : : I915_ASLE_INTERRUPT |
3666 : : I915_DISPLAY_PIPE_A_EVENT_INTERRUPT |
3667 : : I915_DISPLAY_PIPE_B_EVENT_INTERRUPT |
3668 : : I915_MASTER_ERROR_INTERRUPT |
3669 : : I915_USER_INTERRUPT;
3670 : :
3671 [ # # ]: 0 : if (I915_HAS_HOTPLUG(dev_priv)) {
3672 : : /* Enable in IER... */
3673 : 0 : enable_mask |= I915_DISPLAY_PORT_INTERRUPT;
3674 : : /* and unmask in IMR */
3675 : 0 : dev_priv->irq_mask &= ~I915_DISPLAY_PORT_INTERRUPT;
3676 : : }
3677 : :
3678 : 0 : GEN3_IRQ_INIT(uncore, GEN2_, dev_priv->irq_mask, enable_mask);
3679 : :
3680 : : /* Interrupt setup is already guaranteed to be single-threaded, this is
3681 : : * just to make the assert_spin_locked check happy. */
3682 : 0 : spin_lock_irq(&dev_priv->irq_lock);
3683 : 0 : i915_enable_pipestat(dev_priv, PIPE_A, PIPE_CRC_DONE_INTERRUPT_STATUS);
3684 : 0 : i915_enable_pipestat(dev_priv, PIPE_B, PIPE_CRC_DONE_INTERRUPT_STATUS);
3685 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
3686 : :
3687 : 0 : i915_enable_asle_pipestat(dev_priv);
3688 : 0 : }
3689 : :
3690 : 0 : static irqreturn_t i915_irq_handler(int irq, void *arg)
3691 : : {
3692 : 0 : struct drm_i915_private *dev_priv = arg;
3693 : 0 : irqreturn_t ret = IRQ_NONE;
3694 : :
3695 : 0 : if (!intel_irqs_enabled(dev_priv))
3696 : : return IRQ_NONE;
3697 : :
3698 : : /* IRQs are synced during runtime_suspend, we don't require a wakeref */
3699 : 0 : disable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
3700 : :
3701 : 0 : do {
3702 : 0 : u32 pipe_stats[I915_MAX_PIPES] = {};
3703 : 0 : u32 eir = 0, eir_stuck = 0;
3704 : 0 : u32 hotplug_status = 0;
3705 : 0 : u32 iir;
3706 : :
3707 : 0 : iir = I915_READ(GEN2_IIR);
3708 [ # # ]: 0 : if (iir == 0)
3709 : : break;
3710 : :
3711 : 0 : ret = IRQ_HANDLED;
3712 : :
3713 [ # # ]: 0 : if (I915_HAS_HOTPLUG(dev_priv) &&
3714 [ # # ]: 0 : iir & I915_DISPLAY_PORT_INTERRUPT)
3715 : 0 : hotplug_status = i9xx_hpd_irq_ack(dev_priv);
3716 : :
3717 : : /* Call regardless, as some status bits might not be
3718 : : * signalled in iir */
3719 : 0 : i9xx_pipestat_irq_ack(dev_priv, iir, pipe_stats);
3720 : :
3721 [ # # ]: 0 : if (iir & I915_MASTER_ERROR_INTERRUPT)
3722 : 0 : i9xx_error_irq_ack(dev_priv, &eir, &eir_stuck);
3723 : :
3724 : 0 : I915_WRITE(GEN2_IIR, iir);
3725 : :
3726 [ # # ]: 0 : if (iir & I915_USER_INTERRUPT)
3727 : 0 : intel_engine_signal_breadcrumbs(dev_priv->engine[RCS0]);
3728 : :
3729 [ # # ]: 0 : if (iir & I915_MASTER_ERROR_INTERRUPT)
3730 : 0 : i9xx_error_irq_handler(dev_priv, eir, eir_stuck);
3731 : :
3732 [ # # ]: 0 : if (hotplug_status)
3733 : 0 : i9xx_hpd_irq_handler(dev_priv, hotplug_status);
3734 : :
3735 : 0 : i915_pipestat_irq_handler(dev_priv, iir, pipe_stats);
3736 : 0 : } while (0);
3737 : :
3738 : 0 : enable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
3739 : :
3740 : 0 : return ret;
3741 : : }
3742 : :
3743 : 0 : static void i965_irq_reset(struct drm_i915_private *dev_priv)
3744 : : {
3745 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
3746 : :
3747 : 0 : i915_hotplug_interrupt_update(dev_priv, 0xffffffff, 0);
3748 : 0 : I915_WRITE(PORT_HOTPLUG_STAT, I915_READ(PORT_HOTPLUG_STAT));
3749 : :
3750 : 0 : i9xx_pipestat_irq_reset(dev_priv);
3751 : :
3752 : 0 : GEN3_IRQ_RESET(uncore, GEN2_);
3753 : 0 : }
3754 : :
3755 : 0 : static void i965_irq_postinstall(struct drm_i915_private *dev_priv)
3756 : : {
3757 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
3758 : 0 : u32 enable_mask;
3759 : 0 : u32 error_mask;
3760 : :
3761 : : /*
3762 : : * Enable some error detection, note the instruction error mask
3763 : : * bit is reserved, so we leave it masked.
3764 : : */
3765 [ # # # # ]: 0 : if (IS_G4X(dev_priv)) {
3766 : : error_mask = ~(GM45_ERROR_PAGE_TABLE |
3767 : : GM45_ERROR_MEM_PRIV |
3768 : : GM45_ERROR_CP_PRIV |
3769 : : I915_ERROR_MEMORY_REFRESH);
3770 : : } else {
3771 : : error_mask = ~(I915_ERROR_PAGE_TABLE |
3772 : : I915_ERROR_MEMORY_REFRESH);
3773 : : }
3774 : 0 : I915_WRITE(EMR, error_mask);
3775 : :
3776 : : /* Unmask the interrupts that we always want on. */
3777 : 0 : dev_priv->irq_mask =
3778 : : ~(I915_ASLE_INTERRUPT |
3779 : : I915_DISPLAY_PORT_INTERRUPT |
3780 : : I915_DISPLAY_PIPE_A_EVENT_INTERRUPT |
3781 : : I915_DISPLAY_PIPE_B_EVENT_INTERRUPT |
3782 : : I915_MASTER_ERROR_INTERRUPT);
3783 : :
3784 : 0 : enable_mask =
3785 : : I915_ASLE_INTERRUPT |
3786 : : I915_DISPLAY_PORT_INTERRUPT |
3787 : : I915_DISPLAY_PIPE_A_EVENT_INTERRUPT |
3788 : : I915_DISPLAY_PIPE_B_EVENT_INTERRUPT |
3789 : : I915_MASTER_ERROR_INTERRUPT |
3790 : : I915_USER_INTERRUPT;
3791 : :
3792 [ # # # # ]: 0 : if (IS_G4X(dev_priv))
3793 : : enable_mask |= I915_BSD_USER_INTERRUPT;
3794 : :
3795 : 0 : GEN3_IRQ_INIT(uncore, GEN2_, dev_priv->irq_mask, enable_mask);
3796 : :
3797 : : /* Interrupt setup is already guaranteed to be single-threaded, this is
3798 : : * just to make the assert_spin_locked check happy. */
3799 : 0 : spin_lock_irq(&dev_priv->irq_lock);
3800 : 0 : i915_enable_pipestat(dev_priv, PIPE_A, PIPE_GMBUS_INTERRUPT_STATUS);
3801 : 0 : i915_enable_pipestat(dev_priv, PIPE_A, PIPE_CRC_DONE_INTERRUPT_STATUS);
3802 : 0 : i915_enable_pipestat(dev_priv, PIPE_B, PIPE_CRC_DONE_INTERRUPT_STATUS);
3803 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
3804 : :
3805 : 0 : i915_enable_asle_pipestat(dev_priv);
3806 : 0 : }
3807 : :
3808 : 0 : static void i915_hpd_irq_setup(struct drm_i915_private *dev_priv)
3809 : : {
3810 : 0 : u32 hotplug_en;
3811 : :
3812 : 0 : lockdep_assert_held(&dev_priv->irq_lock);
3813 : :
3814 : : /* Note HDMI and DP share hotplug bits */
3815 : : /* enable bits are the same for all generations */
3816 : 0 : hotplug_en = intel_hpd_enabled_irqs(dev_priv, hpd_mask_i915);
3817 : : /* Programming the CRT detection parameters tends
3818 : : to generate a spurious hotplug event about three
3819 : : seconds later. So just do it once.
3820 : : */
3821 [ # # # # ]: 0 : if (IS_G4X(dev_priv))
3822 : 0 : hotplug_en |= CRT_HOTPLUG_ACTIVATION_PERIOD_64;
3823 : 0 : hotplug_en |= CRT_HOTPLUG_VOLTAGE_COMPARE_50;
3824 : :
3825 : : /* Ignore TV since it's buggy */
3826 : 0 : i915_hotplug_interrupt_update_locked(dev_priv,
3827 : : HOTPLUG_INT_EN_MASK |
3828 : : CRT_HOTPLUG_VOLTAGE_COMPARE_MASK |
3829 : : CRT_HOTPLUG_ACTIVATION_PERIOD_64,
3830 : : hotplug_en);
3831 : 0 : }
3832 : :
3833 : 0 : static irqreturn_t i965_irq_handler(int irq, void *arg)
3834 : : {
3835 : 0 : struct drm_i915_private *dev_priv = arg;
3836 : 0 : irqreturn_t ret = IRQ_NONE;
3837 : :
3838 : 0 : if (!intel_irqs_enabled(dev_priv))
3839 : : return IRQ_NONE;
3840 : :
3841 : : /* IRQs are synced during runtime_suspend, we don't require a wakeref */
3842 : 0 : disable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
3843 : :
3844 : 0 : do {
3845 : 0 : u32 pipe_stats[I915_MAX_PIPES] = {};
3846 : 0 : u32 eir = 0, eir_stuck = 0;
3847 : 0 : u32 hotplug_status = 0;
3848 : 0 : u32 iir;
3849 : :
3850 : 0 : iir = I915_READ(GEN2_IIR);
3851 [ # # ]: 0 : if (iir == 0)
3852 : : break;
3853 : :
3854 : 0 : ret = IRQ_HANDLED;
3855 : :
3856 [ # # ]: 0 : if (iir & I915_DISPLAY_PORT_INTERRUPT)
3857 : 0 : hotplug_status = i9xx_hpd_irq_ack(dev_priv);
3858 : :
3859 : : /* Call regardless, as some status bits might not be
3860 : : * signalled in iir */
3861 : 0 : i9xx_pipestat_irq_ack(dev_priv, iir, pipe_stats);
3862 : :
3863 [ # # ]: 0 : if (iir & I915_MASTER_ERROR_INTERRUPT)
3864 : 0 : i9xx_error_irq_ack(dev_priv, &eir, &eir_stuck);
3865 : :
3866 : 0 : I915_WRITE(GEN2_IIR, iir);
3867 : :
3868 [ # # ]: 0 : if (iir & I915_USER_INTERRUPT)
3869 : 0 : intel_engine_signal_breadcrumbs(dev_priv->engine[RCS0]);
3870 : :
3871 [ # # ]: 0 : if (iir & I915_BSD_USER_INTERRUPT)
3872 : 0 : intel_engine_signal_breadcrumbs(dev_priv->engine[VCS0]);
3873 : :
3874 [ # # ]: 0 : if (iir & I915_MASTER_ERROR_INTERRUPT)
3875 : 0 : i9xx_error_irq_handler(dev_priv, eir, eir_stuck);
3876 : :
3877 [ # # ]: 0 : if (hotplug_status)
3878 : 0 : i9xx_hpd_irq_handler(dev_priv, hotplug_status);
3879 : :
3880 : 0 : i965_pipestat_irq_handler(dev_priv, iir, pipe_stats);
3881 : 0 : } while (0);
3882 : :
3883 : 0 : enable_rpm_wakeref_asserts(&dev_priv->runtime_pm);
3884 : :
3885 : 0 : return ret;
3886 : : }
3887 : :
3888 : : /**
3889 : : * intel_irq_init - initializes irq support
3890 : : * @dev_priv: i915 device instance
3891 : : *
3892 : : * This function initializes all the irq support including work items, timers
3893 : : * and all the vtables. It does not setup the interrupt itself though.
3894 : : */
3895 : 0 : void intel_irq_init(struct drm_i915_private *dev_priv)
3896 : : {
3897 : 0 : struct drm_device *dev = &dev_priv->drm;
3898 : 0 : int i;
3899 : :
3900 : 0 : intel_hpd_init_work(dev_priv);
3901 : :
3902 : 0 : INIT_WORK(&dev_priv->l3_parity.error_work, ivb_parity_work);
3903 [ # # ]: 0 : for (i = 0; i < MAX_L3_SLICES; ++i)
3904 : 0 : dev_priv->l3_parity.remap_info[i] = NULL;
3905 : :
3906 : : /* pre-gen11 the guc irqs bits are in the upper 16 bits of the pm reg */
3907 [ # # # # ]: 0 : if (HAS_GT_UC(dev_priv) && INTEL_GEN(dev_priv) < 11)
3908 : 0 : dev_priv->gt.pm_guc_events = GUC_INTR_GUC2HOST << 16;
3909 : :
3910 : 0 : dev->vblank_disable_immediate = true;
3911 : :
3912 : : /* Most platforms treat the display irq block as an always-on
3913 : : * power domain. vlv/chv can disable it at runtime and need
3914 : : * special care to avoid writing any of the display block registers
3915 : : * outside of the power domain. We defer setting up the display irqs
3916 : : * in this case to the runtime pm.
3917 : : */
3918 : 0 : dev_priv->display_irqs_enabled = true;
3919 [ # # # # ]: 0 : if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
3920 : 0 : dev_priv->display_irqs_enabled = false;
3921 : :
3922 : 0 : dev_priv->hotplug.hpd_storm_threshold = HPD_STORM_DEFAULT_THRESHOLD;
3923 : : /* If we have MST support, we want to avoid doing short HPD IRQ storm
3924 : : * detection, as short HPD storms will occur as a natural part of
3925 : : * sideband messaging with MST.
3926 : : * On older platforms however, IRQ storms can occur with both long and
3927 : : * short pulses, as seen on some G4x systems.
3928 : : */
3929 : 0 : dev_priv->hotplug.hpd_short_storm_enabled = !HAS_DP_MST(dev_priv);
3930 : :
3931 [ # # ]: 0 : if (HAS_GMCH(dev_priv)) {
3932 [ # # ]: 0 : if (I915_HAS_HOTPLUG(dev_priv))
3933 : 0 : dev_priv->display.hpd_irq_setup = i915_hpd_irq_setup;
3934 : : } else {
3935 [ # # ]: 0 : if (HAS_PCH_JSP(dev_priv))
3936 : 0 : dev_priv->display.hpd_irq_setup = jsp_hpd_irq_setup;
3937 [ # # ]: 0 : else if (HAS_PCH_MCC(dev_priv))
3938 : 0 : dev_priv->display.hpd_irq_setup = mcc_hpd_irq_setup;
3939 [ # # ]: 0 : else if (INTEL_GEN(dev_priv) >= 11)
3940 : 0 : dev_priv->display.hpd_irq_setup = gen11_hpd_irq_setup;
3941 [ # # # # ]: 0 : else if (IS_GEN9_LP(dev_priv))
3942 : 0 : dev_priv->display.hpd_irq_setup = bxt_hpd_irq_setup;
3943 [ # # ]: 0 : else if (INTEL_PCH_TYPE(dev_priv) >= PCH_SPT)
3944 : 0 : dev_priv->display.hpd_irq_setup = spt_hpd_irq_setup;
3945 : : else
3946 : 0 : dev_priv->display.hpd_irq_setup = ilk_hpd_irq_setup;
3947 : : }
3948 : 0 : }
3949 : :
3950 : : /**
3951 : : * intel_irq_fini - deinitializes IRQ support
3952 : : * @i915: i915 device instance
3953 : : *
3954 : : * This function deinitializes all the IRQ support.
3955 : : */
3956 : 0 : void intel_irq_fini(struct drm_i915_private *i915)
3957 : : {
3958 : 0 : int i;
3959 : :
3960 [ # # ]: 0 : for (i = 0; i < MAX_L3_SLICES; ++i)
3961 : 0 : kfree(i915->l3_parity.remap_info[i]);
3962 : 0 : }
3963 : :
3964 : 0 : static irq_handler_t intel_irq_handler(struct drm_i915_private *dev_priv)
3965 : : {
3966 [ # # ]: 0 : if (HAS_GMCH(dev_priv)) {
3967 [ # # ]: 0 : if (IS_CHERRYVIEW(dev_priv))
3968 : : return cherryview_irq_handler;
3969 [ # # ]: 0 : else if (IS_VALLEYVIEW(dev_priv))
3970 : : return valleyview_irq_handler;
3971 [ # # ]: 0 : else if (IS_GEN(dev_priv, 4))
3972 : : return i965_irq_handler;
3973 [ # # ]: 0 : else if (IS_GEN(dev_priv, 3))
3974 : : return i915_irq_handler;
3975 : : else
3976 : 0 : return i8xx_irq_handler;
3977 : : } else {
3978 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 11)
3979 : : return gen11_irq_handler;
3980 [ # # ]: 0 : else if (INTEL_GEN(dev_priv) >= 8)
3981 : : return gen8_irq_handler;
3982 : : else
3983 : 0 : return ilk_irq_handler;
3984 : : }
3985 : : }
3986 : :
3987 : 0 : static void intel_irq_reset(struct drm_i915_private *dev_priv)
3988 : : {
3989 [ # # ]: 0 : if (HAS_GMCH(dev_priv)) {
3990 [ # # ]: 0 : if (IS_CHERRYVIEW(dev_priv))
3991 : 0 : cherryview_irq_reset(dev_priv);
3992 [ # # ]: 0 : else if (IS_VALLEYVIEW(dev_priv))
3993 : 0 : valleyview_irq_reset(dev_priv);
3994 [ # # ]: 0 : else if (IS_GEN(dev_priv, 4))
3995 : 0 : i965_irq_reset(dev_priv);
3996 [ # # ]: 0 : else if (IS_GEN(dev_priv, 3))
3997 : 0 : i915_irq_reset(dev_priv);
3998 : : else
3999 : 0 : i8xx_irq_reset(dev_priv);
4000 : : } else {
4001 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 11)
4002 : 0 : gen11_irq_reset(dev_priv);
4003 [ # # ]: 0 : else if (INTEL_GEN(dev_priv) >= 8)
4004 : 0 : gen8_irq_reset(dev_priv);
4005 : : else
4006 : 0 : ilk_irq_reset(dev_priv);
4007 : : }
4008 : 0 : }
4009 : :
4010 : 0 : static void intel_irq_postinstall(struct drm_i915_private *dev_priv)
4011 : : {
4012 [ # # ]: 0 : if (HAS_GMCH(dev_priv)) {
4013 [ # # ]: 0 : if (IS_CHERRYVIEW(dev_priv))
4014 : 0 : cherryview_irq_postinstall(dev_priv);
4015 [ # # ]: 0 : else if (IS_VALLEYVIEW(dev_priv))
4016 : 0 : valleyview_irq_postinstall(dev_priv);
4017 [ # # ]: 0 : else if (IS_GEN(dev_priv, 4))
4018 : 0 : i965_irq_postinstall(dev_priv);
4019 [ # # ]: 0 : else if (IS_GEN(dev_priv, 3))
4020 : 0 : i915_irq_postinstall(dev_priv);
4021 : : else
4022 : 0 : i8xx_irq_postinstall(dev_priv);
4023 : : } else {
4024 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 11)
4025 : 0 : gen11_irq_postinstall(dev_priv);
4026 [ # # ]: 0 : else if (INTEL_GEN(dev_priv) >= 8)
4027 : 0 : gen8_irq_postinstall(dev_priv);
4028 : : else
4029 : 0 : ilk_irq_postinstall(dev_priv);
4030 : : }
4031 : 0 : }
4032 : :
4033 : : /**
4034 : : * intel_irq_install - enables the hardware interrupt
4035 : : * @dev_priv: i915 device instance
4036 : : *
4037 : : * This function enables the hardware interrupt handling, but leaves the hotplug
4038 : : * handling still disabled. It is called after intel_irq_init().
4039 : : *
4040 : : * In the driver load and resume code we need working interrupts in a few places
4041 : : * but don't want to deal with the hassle of concurrent probe and hotplug
4042 : : * workers. Hence the split into this two-stage approach.
4043 : : */
4044 : 0 : int intel_irq_install(struct drm_i915_private *dev_priv)
4045 : : {
4046 : 0 : int irq = dev_priv->drm.pdev->irq;
4047 : 0 : int ret;
4048 : :
4049 : : /*
4050 : : * We enable some interrupt sources in our postinstall hooks, so mark
4051 : : * interrupts as enabled _before_ actually enabling them to avoid
4052 : : * special cases in our ordering checks.
4053 : : */
4054 : 0 : dev_priv->runtime_pm.irqs_enabled = true;
4055 : :
4056 : 0 : dev_priv->drm.irq_enabled = true;
4057 : :
4058 : 0 : intel_irq_reset(dev_priv);
4059 : :
4060 : 0 : ret = request_irq(irq, intel_irq_handler(dev_priv),
4061 : : IRQF_SHARED, DRIVER_NAME, dev_priv);
4062 [ # # ]: 0 : if (ret < 0) {
4063 : 0 : dev_priv->drm.irq_enabled = false;
4064 : 0 : return ret;
4065 : : }
4066 : :
4067 : 0 : intel_irq_postinstall(dev_priv);
4068 : :
4069 : 0 : return ret;
4070 : : }
4071 : :
4072 : : /**
4073 : : * intel_irq_uninstall - finilizes all irq handling
4074 : : * @dev_priv: i915 device instance
4075 : : *
4076 : : * This stops interrupt and hotplug handling and unregisters and frees all
4077 : : * resources acquired in the init functions.
4078 : : */
4079 : 0 : void intel_irq_uninstall(struct drm_i915_private *dev_priv)
4080 : : {
4081 : 0 : int irq = dev_priv->drm.pdev->irq;
4082 : :
4083 : : /*
4084 : : * FIXME we can get called twice during driver probe
4085 : : * error handling as well as during driver remove due to
4086 : : * intel_modeset_driver_remove() calling us out of sequence.
4087 : : * Would be nice if it didn't do that...
4088 : : */
4089 [ # # ]: 0 : if (!dev_priv->drm.irq_enabled)
4090 : : return;
4091 : :
4092 : 0 : dev_priv->drm.irq_enabled = false;
4093 : :
4094 : 0 : intel_irq_reset(dev_priv);
4095 : :
4096 : 0 : free_irq(irq, dev_priv);
4097 : :
4098 : 0 : intel_hpd_cancel_work(dev_priv);
4099 : 0 : dev_priv->runtime_pm.irqs_enabled = false;
4100 : : }
4101 : :
4102 : : /**
4103 : : * intel_runtime_pm_disable_interrupts - runtime interrupt disabling
4104 : : * @dev_priv: i915 device instance
4105 : : *
4106 : : * This function is used to disable interrupts at runtime, both in the runtime
4107 : : * pm and the system suspend/resume code.
4108 : : */
4109 : 0 : void intel_runtime_pm_disable_interrupts(struct drm_i915_private *dev_priv)
4110 : : {
4111 : 0 : intel_irq_reset(dev_priv);
4112 : 0 : dev_priv->runtime_pm.irqs_enabled = false;
4113 : 0 : intel_synchronize_irq(dev_priv);
4114 : 0 : }
4115 : :
4116 : : /**
4117 : : * intel_runtime_pm_enable_interrupts - runtime interrupt enabling
4118 : : * @dev_priv: i915 device instance
4119 : : *
4120 : : * This function is used to enable interrupts at runtime, both in the runtime
4121 : : * pm and the system suspend/resume code.
4122 : : */
4123 : 0 : void intel_runtime_pm_enable_interrupts(struct drm_i915_private *dev_priv)
4124 : : {
4125 : 0 : dev_priv->runtime_pm.irqs_enabled = true;
4126 : 0 : intel_irq_reset(dev_priv);
4127 : 0 : intel_irq_postinstall(dev_priv);
4128 : 0 : }
4129 : :
4130 : 0 : bool intel_irqs_enabled(struct drm_i915_private *dev_priv)
4131 : : {
4132 : : /*
4133 : : * We only use drm_irq_uninstall() at unload and VT switch, so
4134 : : * this is the only thing we need to check.
4135 : : */
4136 [ # # # # : 0 : return dev_priv->runtime_pm.irqs_enabled;
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # #
# ]
4137 : : }
4138 : :
4139 : 0 : void intel_synchronize_irq(struct drm_i915_private *i915)
4140 : : {
4141 : 0 : synchronize_irq(i915->drm.pdev->irq);
4142 : 0 : }
|
