2 * Copyright © 2006-2007 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
24 * Eric Anholt <eric@anholt.net>
27 #include <linux/dmi.h>
28 #include <linux/module.h>
29 #include <linux/input.h>
30 #include <linux/i2c.h>
31 #include <linux/kernel.h>
32 #include <linux/slab.h>
33 #include <linux/vgaarb.h>
34 #include <drm/drm_edid.h>
36 #include "intel_drv.h"
37 #include "intel_frontbuffer.h"
38 #include <drm/i915_drm.h>
40 #include "i915_gem_dmabuf.h"
41 #include "intel_dsi.h"
42 #include "i915_trace.h"
43 #include <drm/drm_atomic.h>
44 #include <drm/drm_atomic_helper.h>
45 #include <drm/drm_dp_helper.h>
46 #include <drm/drm_crtc_helper.h>
47 #include <drm/drm_plane_helper.h>
48 #include <drm/drm_rect.h>
49 #include <linux/dma_remapping.h>
50 #include <linux/reservation.h>
52 static bool is_mmio_work(struct intel_flip_work
*work
)
54 return work
->mmio_work
.func
;
57 /* Primary plane formats for gen <= 3 */
58 static const uint32_t i8xx_primary_formats
[] = {
65 /* Primary plane formats for gen >= 4 */
66 static const uint32_t i965_primary_formats
[] = {
71 DRM_FORMAT_XRGB2101010
,
72 DRM_FORMAT_XBGR2101010
,
75 static const uint32_t skl_primary_formats
[] = {
82 DRM_FORMAT_XRGB2101010
,
83 DRM_FORMAT_XBGR2101010
,
91 static const uint32_t intel_cursor_formats
[] = {
95 static void i9xx_crtc_clock_get(struct intel_crtc
*crtc
,
96 struct intel_crtc_state
*pipe_config
);
97 static void ironlake_pch_clock_get(struct intel_crtc
*crtc
,
98 struct intel_crtc_state
*pipe_config
);
100 static int intel_framebuffer_init(struct drm_device
*dev
,
101 struct intel_framebuffer
*ifb
,
102 struct drm_mode_fb_cmd2
*mode_cmd
,
103 struct drm_i915_gem_object
*obj
);
104 static void i9xx_set_pipeconf(struct intel_crtc
*intel_crtc
);
105 static void intel_set_pipe_timings(struct intel_crtc
*intel_crtc
);
106 static void intel_set_pipe_src_size(struct intel_crtc
*intel_crtc
);
107 static void intel_cpu_transcoder_set_m_n(struct intel_crtc
*crtc
,
108 struct intel_link_m_n
*m_n
,
109 struct intel_link_m_n
*m2_n2
);
110 static void ironlake_set_pipeconf(struct drm_crtc
*crtc
);
111 static void haswell_set_pipeconf(struct drm_crtc
*crtc
);
112 static void haswell_set_pipemisc(struct drm_crtc
*crtc
);
113 static void vlv_prepare_pll(struct intel_crtc
*crtc
,
114 const struct intel_crtc_state
*pipe_config
);
115 static void chv_prepare_pll(struct intel_crtc
*crtc
,
116 const struct intel_crtc_state
*pipe_config
);
117 static void intel_begin_crtc_commit(struct drm_crtc
*, struct drm_crtc_state
*);
118 static void intel_finish_crtc_commit(struct drm_crtc
*, struct drm_crtc_state
*);
119 static void skl_init_scalers(struct drm_device
*dev
, struct intel_crtc
*intel_crtc
,
120 struct intel_crtc_state
*crtc_state
);
121 static void skylake_pfit_enable(struct intel_crtc
*crtc
);
122 static void ironlake_pfit_disable(struct intel_crtc
*crtc
, bool force
);
123 static void ironlake_pfit_enable(struct intel_crtc
*crtc
);
124 static void intel_modeset_setup_hw_state(struct drm_device
*dev
);
125 static void intel_pre_disable_primary_noatomic(struct drm_crtc
*crtc
);
126 static int ilk_max_pixel_rate(struct drm_atomic_state
*state
);
127 static int bxt_calc_cdclk(int max_pixclk
);
132 } dot
, vco
, n
, m
, m1
, m2
, p
, p1
;
136 int p2_slow
, p2_fast
;
140 /* returns HPLL frequency in kHz */
141 static int valleyview_get_vco(struct drm_i915_private
*dev_priv
)
143 int hpll_freq
, vco_freq
[] = { 800, 1600, 2000, 2400 };
145 /* Obtain SKU information */
146 mutex_lock(&dev_priv
->sb_lock
);
147 hpll_freq
= vlv_cck_read(dev_priv
, CCK_FUSE_REG
) &
148 CCK_FUSE_HPLL_FREQ_MASK
;
149 mutex_unlock(&dev_priv
->sb_lock
);
151 return vco_freq
[hpll_freq
] * 1000;
154 int vlv_get_cck_clock(struct drm_i915_private
*dev_priv
,
155 const char *name
, u32 reg
, int ref_freq
)
160 mutex_lock(&dev_priv
->sb_lock
);
161 val
= vlv_cck_read(dev_priv
, reg
);
162 mutex_unlock(&dev_priv
->sb_lock
);
164 divider
= val
& CCK_FREQUENCY_VALUES
;
166 WARN((val
& CCK_FREQUENCY_STATUS
) !=
167 (divider
<< CCK_FREQUENCY_STATUS_SHIFT
),
168 "%s change in progress\n", name
);
170 return DIV_ROUND_CLOSEST(ref_freq
<< 1, divider
+ 1);
173 static int vlv_get_cck_clock_hpll(struct drm_i915_private
*dev_priv
,
174 const char *name
, u32 reg
)
176 if (dev_priv
->hpll_freq
== 0)
177 dev_priv
->hpll_freq
= valleyview_get_vco(dev_priv
);
179 return vlv_get_cck_clock(dev_priv
, name
, reg
,
180 dev_priv
->hpll_freq
);
184 intel_pch_rawclk(struct drm_i915_private
*dev_priv
)
186 return (I915_READ(PCH_RAWCLK_FREQ
) & RAWCLK_FREQ_MASK
) * 1000;
190 intel_vlv_hrawclk(struct drm_i915_private
*dev_priv
)
192 /* RAWCLK_FREQ_VLV register updated from power well code */
193 return vlv_get_cck_clock_hpll(dev_priv
, "hrawclk",
194 CCK_DISPLAY_REF_CLOCK_CONTROL
);
198 intel_g4x_hrawclk(struct drm_i915_private
*dev_priv
)
202 /* hrawclock is 1/4 the FSB frequency */
203 clkcfg
= I915_READ(CLKCFG
);
204 switch (clkcfg
& CLKCFG_FSB_MASK
) {
213 case CLKCFG_FSB_1067
:
215 case CLKCFG_FSB_1333
:
217 /* these two are just a guess; one of them might be right */
218 case CLKCFG_FSB_1600
:
219 case CLKCFG_FSB_1600_ALT
:
226 void intel_update_rawclk(struct drm_i915_private
*dev_priv
)
228 if (HAS_PCH_SPLIT(dev_priv
))
229 dev_priv
->rawclk_freq
= intel_pch_rawclk(dev_priv
);
230 else if (IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
))
231 dev_priv
->rawclk_freq
= intel_vlv_hrawclk(dev_priv
);
232 else if (IS_G4X(dev_priv
) || IS_PINEVIEW(dev_priv
))
233 dev_priv
->rawclk_freq
= intel_g4x_hrawclk(dev_priv
);
235 return; /* no rawclk on other platforms, or no need to know it */
237 DRM_DEBUG_DRIVER("rawclk rate: %d kHz\n", dev_priv
->rawclk_freq
);
240 static void intel_update_czclk(struct drm_i915_private
*dev_priv
)
242 if (!(IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
)))
245 dev_priv
->czclk_freq
= vlv_get_cck_clock_hpll(dev_priv
, "czclk",
246 CCK_CZ_CLOCK_CONTROL
);
248 DRM_DEBUG_DRIVER("CZ clock rate: %d kHz\n", dev_priv
->czclk_freq
);
251 static inline u32
/* units of 100MHz */
252 intel_fdi_link_freq(struct drm_i915_private
*dev_priv
,
253 const struct intel_crtc_state
*pipe_config
)
255 if (HAS_DDI(dev_priv
))
256 return pipe_config
->port_clock
; /* SPLL */
257 else if (IS_GEN5(dev_priv
))
258 return ((I915_READ(FDI_PLL_BIOS_0
) & FDI_PLL_FB_CLOCK_MASK
) + 2) * 10000;
263 static const struct intel_limit intel_limits_i8xx_dac
= {
264 .dot
= { .min
= 25000, .max
= 350000 },
265 .vco
= { .min
= 908000, .max
= 1512000 },
266 .n
= { .min
= 2, .max
= 16 },
267 .m
= { .min
= 96, .max
= 140 },
268 .m1
= { .min
= 18, .max
= 26 },
269 .m2
= { .min
= 6, .max
= 16 },
270 .p
= { .min
= 4, .max
= 128 },
271 .p1
= { .min
= 2, .max
= 33 },
272 .p2
= { .dot_limit
= 165000,
273 .p2_slow
= 4, .p2_fast
= 2 },
276 static const struct intel_limit intel_limits_i8xx_dvo
= {
277 .dot
= { .min
= 25000, .max
= 350000 },
278 .vco
= { .min
= 908000, .max
= 1512000 },
279 .n
= { .min
= 2, .max
= 16 },
280 .m
= { .min
= 96, .max
= 140 },
281 .m1
= { .min
= 18, .max
= 26 },
282 .m2
= { .min
= 6, .max
= 16 },
283 .p
= { .min
= 4, .max
= 128 },
284 .p1
= { .min
= 2, .max
= 33 },
285 .p2
= { .dot_limit
= 165000,
286 .p2_slow
= 4, .p2_fast
= 4 },
289 static const struct intel_limit intel_limits_i8xx_lvds
= {
290 .dot
= { .min
= 25000, .max
= 350000 },
291 .vco
= { .min
= 908000, .max
= 1512000 },
292 .n
= { .min
= 2, .max
= 16 },
293 .m
= { .min
= 96, .max
= 140 },
294 .m1
= { .min
= 18, .max
= 26 },
295 .m2
= { .min
= 6, .max
= 16 },
296 .p
= { .min
= 4, .max
= 128 },
297 .p1
= { .min
= 1, .max
= 6 },
298 .p2
= { .dot_limit
= 165000,
299 .p2_slow
= 14, .p2_fast
= 7 },
302 static const struct intel_limit intel_limits_i9xx_sdvo
= {
303 .dot
= { .min
= 20000, .max
= 400000 },
304 .vco
= { .min
= 1400000, .max
= 2800000 },
305 .n
= { .min
= 1, .max
= 6 },
306 .m
= { .min
= 70, .max
= 120 },
307 .m1
= { .min
= 8, .max
= 18 },
308 .m2
= { .min
= 3, .max
= 7 },
309 .p
= { .min
= 5, .max
= 80 },
310 .p1
= { .min
= 1, .max
= 8 },
311 .p2
= { .dot_limit
= 200000,
312 .p2_slow
= 10, .p2_fast
= 5 },
315 static const struct intel_limit intel_limits_i9xx_lvds
= {
316 .dot
= { .min
= 20000, .max
= 400000 },
317 .vco
= { .min
= 1400000, .max
= 2800000 },
318 .n
= { .min
= 1, .max
= 6 },
319 .m
= { .min
= 70, .max
= 120 },
320 .m1
= { .min
= 8, .max
= 18 },
321 .m2
= { .min
= 3, .max
= 7 },
322 .p
= { .min
= 7, .max
= 98 },
323 .p1
= { .min
= 1, .max
= 8 },
324 .p2
= { .dot_limit
= 112000,
325 .p2_slow
= 14, .p2_fast
= 7 },
329 static const struct intel_limit intel_limits_g4x_sdvo
= {
330 .dot
= { .min
= 25000, .max
= 270000 },
331 .vco
= { .min
= 1750000, .max
= 3500000},
332 .n
= { .min
= 1, .max
= 4 },
333 .m
= { .min
= 104, .max
= 138 },
334 .m1
= { .min
= 17, .max
= 23 },
335 .m2
= { .min
= 5, .max
= 11 },
336 .p
= { .min
= 10, .max
= 30 },
337 .p1
= { .min
= 1, .max
= 3},
338 .p2
= { .dot_limit
= 270000,
344 static const struct intel_limit intel_limits_g4x_hdmi
= {
345 .dot
= { .min
= 22000, .max
= 400000 },
346 .vco
= { .min
= 1750000, .max
= 3500000},
347 .n
= { .min
= 1, .max
= 4 },
348 .m
= { .min
= 104, .max
= 138 },
349 .m1
= { .min
= 16, .max
= 23 },
350 .m2
= { .min
= 5, .max
= 11 },
351 .p
= { .min
= 5, .max
= 80 },
352 .p1
= { .min
= 1, .max
= 8},
353 .p2
= { .dot_limit
= 165000,
354 .p2_slow
= 10, .p2_fast
= 5 },
357 static const struct intel_limit intel_limits_g4x_single_channel_lvds
= {
358 .dot
= { .min
= 20000, .max
= 115000 },
359 .vco
= { .min
= 1750000, .max
= 3500000 },
360 .n
= { .min
= 1, .max
= 3 },
361 .m
= { .min
= 104, .max
= 138 },
362 .m1
= { .min
= 17, .max
= 23 },
363 .m2
= { .min
= 5, .max
= 11 },
364 .p
= { .min
= 28, .max
= 112 },
365 .p1
= { .min
= 2, .max
= 8 },
366 .p2
= { .dot_limit
= 0,
367 .p2_slow
= 14, .p2_fast
= 14
371 static const struct intel_limit intel_limits_g4x_dual_channel_lvds
= {
372 .dot
= { .min
= 80000, .max
= 224000 },
373 .vco
= { .min
= 1750000, .max
= 3500000 },
374 .n
= { .min
= 1, .max
= 3 },
375 .m
= { .min
= 104, .max
= 138 },
376 .m1
= { .min
= 17, .max
= 23 },
377 .m2
= { .min
= 5, .max
= 11 },
378 .p
= { .min
= 14, .max
= 42 },
379 .p1
= { .min
= 2, .max
= 6 },
380 .p2
= { .dot_limit
= 0,
381 .p2_slow
= 7, .p2_fast
= 7
385 static const struct intel_limit intel_limits_pineview_sdvo
= {
386 .dot
= { .min
= 20000, .max
= 400000},
387 .vco
= { .min
= 1700000, .max
= 3500000 },
388 /* Pineview's Ncounter is a ring counter */
389 .n
= { .min
= 3, .max
= 6 },
390 .m
= { .min
= 2, .max
= 256 },
391 /* Pineview only has one combined m divider, which we treat as m2. */
392 .m1
= { .min
= 0, .max
= 0 },
393 .m2
= { .min
= 0, .max
= 254 },
394 .p
= { .min
= 5, .max
= 80 },
395 .p1
= { .min
= 1, .max
= 8 },
396 .p2
= { .dot_limit
= 200000,
397 .p2_slow
= 10, .p2_fast
= 5 },
400 static const struct intel_limit intel_limits_pineview_lvds
= {
401 .dot
= { .min
= 20000, .max
= 400000 },
402 .vco
= { .min
= 1700000, .max
= 3500000 },
403 .n
= { .min
= 3, .max
= 6 },
404 .m
= { .min
= 2, .max
= 256 },
405 .m1
= { .min
= 0, .max
= 0 },
406 .m2
= { .min
= 0, .max
= 254 },
407 .p
= { .min
= 7, .max
= 112 },
408 .p1
= { .min
= 1, .max
= 8 },
409 .p2
= { .dot_limit
= 112000,
410 .p2_slow
= 14, .p2_fast
= 14 },
413 /* Ironlake / Sandybridge
415 * We calculate clock using (register_value + 2) for N/M1/M2, so here
416 * the range value for them is (actual_value - 2).
418 static const struct intel_limit intel_limits_ironlake_dac
= {
419 .dot
= { .min
= 25000, .max
= 350000 },
420 .vco
= { .min
= 1760000, .max
= 3510000 },
421 .n
= { .min
= 1, .max
= 5 },
422 .m
= { .min
= 79, .max
= 127 },
423 .m1
= { .min
= 12, .max
= 22 },
424 .m2
= { .min
= 5, .max
= 9 },
425 .p
= { .min
= 5, .max
= 80 },
426 .p1
= { .min
= 1, .max
= 8 },
427 .p2
= { .dot_limit
= 225000,
428 .p2_slow
= 10, .p2_fast
= 5 },
431 static const struct intel_limit intel_limits_ironlake_single_lvds
= {
432 .dot
= { .min
= 25000, .max
= 350000 },
433 .vco
= { .min
= 1760000, .max
= 3510000 },
434 .n
= { .min
= 1, .max
= 3 },
435 .m
= { .min
= 79, .max
= 118 },
436 .m1
= { .min
= 12, .max
= 22 },
437 .m2
= { .min
= 5, .max
= 9 },
438 .p
= { .min
= 28, .max
= 112 },
439 .p1
= { .min
= 2, .max
= 8 },
440 .p2
= { .dot_limit
= 225000,
441 .p2_slow
= 14, .p2_fast
= 14 },
444 static const struct intel_limit intel_limits_ironlake_dual_lvds
= {
445 .dot
= { .min
= 25000, .max
= 350000 },
446 .vco
= { .min
= 1760000, .max
= 3510000 },
447 .n
= { .min
= 1, .max
= 3 },
448 .m
= { .min
= 79, .max
= 127 },
449 .m1
= { .min
= 12, .max
= 22 },
450 .m2
= { .min
= 5, .max
= 9 },
451 .p
= { .min
= 14, .max
= 56 },
452 .p1
= { .min
= 2, .max
= 8 },
453 .p2
= { .dot_limit
= 225000,
454 .p2_slow
= 7, .p2_fast
= 7 },
457 /* LVDS 100mhz refclk limits. */
458 static const struct intel_limit intel_limits_ironlake_single_lvds_100m
= {
459 .dot
= { .min
= 25000, .max
= 350000 },
460 .vco
= { .min
= 1760000, .max
= 3510000 },
461 .n
= { .min
= 1, .max
= 2 },
462 .m
= { .min
= 79, .max
= 126 },
463 .m1
= { .min
= 12, .max
= 22 },
464 .m2
= { .min
= 5, .max
= 9 },
465 .p
= { .min
= 28, .max
= 112 },
466 .p1
= { .min
= 2, .max
= 8 },
467 .p2
= { .dot_limit
= 225000,
468 .p2_slow
= 14, .p2_fast
= 14 },
471 static const struct intel_limit intel_limits_ironlake_dual_lvds_100m
= {
472 .dot
= { .min
= 25000, .max
= 350000 },
473 .vco
= { .min
= 1760000, .max
= 3510000 },
474 .n
= { .min
= 1, .max
= 3 },
475 .m
= { .min
= 79, .max
= 126 },
476 .m1
= { .min
= 12, .max
= 22 },
477 .m2
= { .min
= 5, .max
= 9 },
478 .p
= { .min
= 14, .max
= 42 },
479 .p1
= { .min
= 2, .max
= 6 },
480 .p2
= { .dot_limit
= 225000,
481 .p2_slow
= 7, .p2_fast
= 7 },
484 static const struct intel_limit intel_limits_vlv
= {
486 * These are the data rate limits (measured in fast clocks)
487 * since those are the strictest limits we have. The fast
488 * clock and actual rate limits are more relaxed, so checking
489 * them would make no difference.
491 .dot
= { .min
= 25000 * 5, .max
= 270000 * 5 },
492 .vco
= { .min
= 4000000, .max
= 6000000 },
493 .n
= { .min
= 1, .max
= 7 },
494 .m1
= { .min
= 2, .max
= 3 },
495 .m2
= { .min
= 11, .max
= 156 },
496 .p1
= { .min
= 2, .max
= 3 },
497 .p2
= { .p2_slow
= 2, .p2_fast
= 20 }, /* slow=min, fast=max */
500 static const struct intel_limit intel_limits_chv
= {
502 * These are the data rate limits (measured in fast clocks)
503 * since those are the strictest limits we have. The fast
504 * clock and actual rate limits are more relaxed, so checking
505 * them would make no difference.
507 .dot
= { .min
= 25000 * 5, .max
= 540000 * 5},
508 .vco
= { .min
= 4800000, .max
= 6480000 },
509 .n
= { .min
= 1, .max
= 1 },
510 .m1
= { .min
= 2, .max
= 2 },
511 .m2
= { .min
= 24 << 22, .max
= 175 << 22 },
512 .p1
= { .min
= 2, .max
= 4 },
513 .p2
= { .p2_slow
= 1, .p2_fast
= 14 },
516 static const struct intel_limit intel_limits_bxt
= {
517 /* FIXME: find real dot limits */
518 .dot
= { .min
= 0, .max
= INT_MAX
},
519 .vco
= { .min
= 4800000, .max
= 6700000 },
520 .n
= { .min
= 1, .max
= 1 },
521 .m1
= { .min
= 2, .max
= 2 },
522 /* FIXME: find real m2 limits */
523 .m2
= { .min
= 2 << 22, .max
= 255 << 22 },
524 .p1
= { .min
= 2, .max
= 4 },
525 .p2
= { .p2_slow
= 1, .p2_fast
= 20 },
529 needs_modeset(struct drm_crtc_state
*state
)
531 return drm_atomic_crtc_needs_modeset(state
);
535 * Platform specific helpers to calculate the port PLL loopback- (clock.m),
536 * and post-divider (clock.p) values, pre- (clock.vco) and post-divided fast
537 * (clock.dot) clock rates. This fast dot clock is fed to the port's IO logic.
538 * The helpers' return value is the rate of the clock that is fed to the
539 * display engine's pipe which can be the above fast dot clock rate or a
540 * divided-down version of it.
542 /* m1 is reserved as 0 in Pineview, n is a ring counter */
543 static int pnv_calc_dpll_params(int refclk
, struct dpll
*clock
)
545 clock
->m
= clock
->m2
+ 2;
546 clock
->p
= clock
->p1
* clock
->p2
;
547 if (WARN_ON(clock
->n
== 0 || clock
->p
== 0))
549 clock
->vco
= DIV_ROUND_CLOSEST(refclk
* clock
->m
, clock
->n
);
550 clock
->dot
= DIV_ROUND_CLOSEST(clock
->vco
, clock
->p
);
555 static uint32_t i9xx_dpll_compute_m(struct dpll
*dpll
)
557 return 5 * (dpll
->m1
+ 2) + (dpll
->m2
+ 2);
560 static int i9xx_calc_dpll_params(int refclk
, struct dpll
*clock
)
562 clock
->m
= i9xx_dpll_compute_m(clock
);
563 clock
->p
= clock
->p1
* clock
->p2
;
564 if (WARN_ON(clock
->n
+ 2 == 0 || clock
->p
== 0))
566 clock
->vco
= DIV_ROUND_CLOSEST(refclk
* clock
->m
, clock
->n
+ 2);
567 clock
->dot
= DIV_ROUND_CLOSEST(clock
->vco
, clock
->p
);
572 static int vlv_calc_dpll_params(int refclk
, struct dpll
*clock
)
574 clock
->m
= clock
->m1
* clock
->m2
;
575 clock
->p
= clock
->p1
* clock
->p2
;
576 if (WARN_ON(clock
->n
== 0 || clock
->p
== 0))
578 clock
->vco
= DIV_ROUND_CLOSEST(refclk
* clock
->m
, clock
->n
);
579 clock
->dot
= DIV_ROUND_CLOSEST(clock
->vco
, clock
->p
);
581 return clock
->dot
/ 5;
584 int chv_calc_dpll_params(int refclk
, struct dpll
*clock
)
586 clock
->m
= clock
->m1
* clock
->m2
;
587 clock
->p
= clock
->p1
* clock
->p2
;
588 if (WARN_ON(clock
->n
== 0 || clock
->p
== 0))
590 clock
->vco
= DIV_ROUND_CLOSEST_ULL((uint64_t)refclk
* clock
->m
,
592 clock
->dot
= DIV_ROUND_CLOSEST(clock
->vco
, clock
->p
);
594 return clock
->dot
/ 5;
597 #define INTELPllInvalid(s) do { /* DRM_DEBUG(s); */ return false; } while (0)
599 * Returns whether the given set of divisors are valid for a given refclk with
600 * the given connectors.
603 static bool intel_PLL_is_valid(struct drm_device
*dev
,
604 const struct intel_limit
*limit
,
605 const struct dpll
*clock
)
607 if (clock
->n
< limit
->n
.min
|| limit
->n
.max
< clock
->n
)
608 INTELPllInvalid("n out of range\n");
609 if (clock
->p1
< limit
->p1
.min
|| limit
->p1
.max
< clock
->p1
)
610 INTELPllInvalid("p1 out of range\n");
611 if (clock
->m2
< limit
->m2
.min
|| limit
->m2
.max
< clock
->m2
)
612 INTELPllInvalid("m2 out of range\n");
613 if (clock
->m1
< limit
->m1
.min
|| limit
->m1
.max
< clock
->m1
)
614 INTELPllInvalid("m1 out of range\n");
616 if (!IS_PINEVIEW(dev
) && !IS_VALLEYVIEW(dev
) &&
617 !IS_CHERRYVIEW(dev
) && !IS_BROXTON(dev
))
618 if (clock
->m1
<= clock
->m2
)
619 INTELPllInvalid("m1 <= m2\n");
621 if (!IS_VALLEYVIEW(dev
) && !IS_CHERRYVIEW(dev
) && !IS_BROXTON(dev
)) {
622 if (clock
->p
< limit
->p
.min
|| limit
->p
.max
< clock
->p
)
623 INTELPllInvalid("p out of range\n");
624 if (clock
->m
< limit
->m
.min
|| limit
->m
.max
< clock
->m
)
625 INTELPllInvalid("m out of range\n");
628 if (clock
->vco
< limit
->vco
.min
|| limit
->vco
.max
< clock
->vco
)
629 INTELPllInvalid("vco out of range\n");
630 /* XXX: We may need to be checking "Dot clock" depending on the multiplier,
631 * connector, etc., rather than just a single range.
633 if (clock
->dot
< limit
->dot
.min
|| limit
->dot
.max
< clock
->dot
)
634 INTELPllInvalid("dot out of range\n");
640 i9xx_select_p2_div(const struct intel_limit
*limit
,
641 const struct intel_crtc_state
*crtc_state
,
644 struct drm_device
*dev
= crtc_state
->base
.crtc
->dev
;
646 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
)) {
648 * For LVDS just rely on its current settings for dual-channel.
649 * We haven't figured out how to reliably set up different
650 * single/dual channel state, if we even can.
652 if (intel_is_dual_link_lvds(dev
))
653 return limit
->p2
.p2_fast
;
655 return limit
->p2
.p2_slow
;
657 if (target
< limit
->p2
.dot_limit
)
658 return limit
->p2
.p2_slow
;
660 return limit
->p2
.p2_fast
;
665 * Returns a set of divisors for the desired target clock with the given
666 * refclk, or FALSE. The returned values represent the clock equation:
667 * reflck * (5 * (m1 + 2) + (m2 + 2)) / (n + 2) / p1 / p2.
669 * Target and reference clocks are specified in kHz.
671 * If match_clock is provided, then best_clock P divider must match the P
672 * divider from @match_clock used for LVDS downclocking.
675 i9xx_find_best_dpll(const struct intel_limit
*limit
,
676 struct intel_crtc_state
*crtc_state
,
677 int target
, int refclk
, struct dpll
*match_clock
,
678 struct dpll
*best_clock
)
680 struct drm_device
*dev
= crtc_state
->base
.crtc
->dev
;
684 memset(best_clock
, 0, sizeof(*best_clock
));
686 clock
.p2
= i9xx_select_p2_div(limit
, crtc_state
, target
);
688 for (clock
.m1
= limit
->m1
.min
; clock
.m1
<= limit
->m1
.max
;
690 for (clock
.m2
= limit
->m2
.min
;
691 clock
.m2
<= limit
->m2
.max
; clock
.m2
++) {
692 if (clock
.m2
>= clock
.m1
)
694 for (clock
.n
= limit
->n
.min
;
695 clock
.n
<= limit
->n
.max
; clock
.n
++) {
696 for (clock
.p1
= limit
->p1
.min
;
697 clock
.p1
<= limit
->p1
.max
; clock
.p1
++) {
700 i9xx_calc_dpll_params(refclk
, &clock
);
701 if (!intel_PLL_is_valid(dev
, limit
,
705 clock
.p
!= match_clock
->p
)
708 this_err
= abs(clock
.dot
- target
);
709 if (this_err
< err
) {
718 return (err
!= target
);
722 * Returns a set of divisors for the desired target clock with the given
723 * refclk, or FALSE. The returned values represent the clock equation:
724 * reflck * (5 * (m1 + 2) + (m2 + 2)) / (n + 2) / p1 / p2.
726 * Target and reference clocks are specified in kHz.
728 * If match_clock is provided, then best_clock P divider must match the P
729 * divider from @match_clock used for LVDS downclocking.
732 pnv_find_best_dpll(const struct intel_limit
*limit
,
733 struct intel_crtc_state
*crtc_state
,
734 int target
, int refclk
, struct dpll
*match_clock
,
735 struct dpll
*best_clock
)
737 struct drm_device
*dev
= crtc_state
->base
.crtc
->dev
;
741 memset(best_clock
, 0, sizeof(*best_clock
));
743 clock
.p2
= i9xx_select_p2_div(limit
, crtc_state
, target
);
745 for (clock
.m1
= limit
->m1
.min
; clock
.m1
<= limit
->m1
.max
;
747 for (clock
.m2
= limit
->m2
.min
;
748 clock
.m2
<= limit
->m2
.max
; clock
.m2
++) {
749 for (clock
.n
= limit
->n
.min
;
750 clock
.n
<= limit
->n
.max
; clock
.n
++) {
751 for (clock
.p1
= limit
->p1
.min
;
752 clock
.p1
<= limit
->p1
.max
; clock
.p1
++) {
755 pnv_calc_dpll_params(refclk
, &clock
);
756 if (!intel_PLL_is_valid(dev
, limit
,
760 clock
.p
!= match_clock
->p
)
763 this_err
= abs(clock
.dot
- target
);
764 if (this_err
< err
) {
773 return (err
!= target
);
777 * Returns a set of divisors for the desired target clock with the given
778 * refclk, or FALSE. The returned values represent the clock equation:
779 * reflck * (5 * (m1 + 2) + (m2 + 2)) / (n + 2) / p1 / p2.
781 * Target and reference clocks are specified in kHz.
783 * If match_clock is provided, then best_clock P divider must match the P
784 * divider from @match_clock used for LVDS downclocking.
787 g4x_find_best_dpll(const struct intel_limit
*limit
,
788 struct intel_crtc_state
*crtc_state
,
789 int target
, int refclk
, struct dpll
*match_clock
,
790 struct dpll
*best_clock
)
792 struct drm_device
*dev
= crtc_state
->base
.crtc
->dev
;
796 /* approximately equals target * 0.00585 */
797 int err_most
= (target
>> 8) + (target
>> 9);
799 memset(best_clock
, 0, sizeof(*best_clock
));
801 clock
.p2
= i9xx_select_p2_div(limit
, crtc_state
, target
);
803 max_n
= limit
->n
.max
;
804 /* based on hardware requirement, prefer smaller n to precision */
805 for (clock
.n
= limit
->n
.min
; clock
.n
<= max_n
; clock
.n
++) {
806 /* based on hardware requirement, prefere larger m1,m2 */
807 for (clock
.m1
= limit
->m1
.max
;
808 clock
.m1
>= limit
->m1
.min
; clock
.m1
--) {
809 for (clock
.m2
= limit
->m2
.max
;
810 clock
.m2
>= limit
->m2
.min
; clock
.m2
--) {
811 for (clock
.p1
= limit
->p1
.max
;
812 clock
.p1
>= limit
->p1
.min
; clock
.p1
--) {
815 i9xx_calc_dpll_params(refclk
, &clock
);
816 if (!intel_PLL_is_valid(dev
, limit
,
820 this_err
= abs(clock
.dot
- target
);
821 if (this_err
< err_most
) {
835 * Check if the calculated PLL configuration is more optimal compared to the
836 * best configuration and error found so far. Return the calculated error.
838 static bool vlv_PLL_is_optimal(struct drm_device
*dev
, int target_freq
,
839 const struct dpll
*calculated_clock
,
840 const struct dpll
*best_clock
,
841 unsigned int best_error_ppm
,
842 unsigned int *error_ppm
)
845 * For CHV ignore the error and consider only the P value.
846 * Prefer a bigger P value based on HW requirements.
848 if (IS_CHERRYVIEW(dev
)) {
851 return calculated_clock
->p
> best_clock
->p
;
854 if (WARN_ON_ONCE(!target_freq
))
857 *error_ppm
= div_u64(1000000ULL *
858 abs(target_freq
- calculated_clock
->dot
),
861 * Prefer a better P value over a better (smaller) error if the error
862 * is small. Ensure this preference for future configurations too by
863 * setting the error to 0.
865 if (*error_ppm
< 100 && calculated_clock
->p
> best_clock
->p
) {
871 return *error_ppm
+ 10 < best_error_ppm
;
875 * Returns a set of divisors for the desired target clock with the given
876 * refclk, or FALSE. The returned values represent the clock equation:
877 * reflck * (5 * (m1 + 2) + (m2 + 2)) / (n + 2) / p1 / p2.
880 vlv_find_best_dpll(const struct intel_limit
*limit
,
881 struct intel_crtc_state
*crtc_state
,
882 int target
, int refclk
, struct dpll
*match_clock
,
883 struct dpll
*best_clock
)
885 struct intel_crtc
*crtc
= to_intel_crtc(crtc_state
->base
.crtc
);
886 struct drm_device
*dev
= crtc
->base
.dev
;
888 unsigned int bestppm
= 1000000;
889 /* min update 19.2 MHz */
890 int max_n
= min(limit
->n
.max
, refclk
/ 19200);
893 target
*= 5; /* fast clock */
895 memset(best_clock
, 0, sizeof(*best_clock
));
897 /* based on hardware requirement, prefer smaller n to precision */
898 for (clock
.n
= limit
->n
.min
; clock
.n
<= max_n
; clock
.n
++) {
899 for (clock
.p1
= limit
->p1
.max
; clock
.p1
>= limit
->p1
.min
; clock
.p1
--) {
900 for (clock
.p2
= limit
->p2
.p2_fast
; clock
.p2
>= limit
->p2
.p2_slow
;
901 clock
.p2
-= clock
.p2
> 10 ? 2 : 1) {
902 clock
.p
= clock
.p1
* clock
.p2
;
903 /* based on hardware requirement, prefer bigger m1,m2 values */
904 for (clock
.m1
= limit
->m1
.min
; clock
.m1
<= limit
->m1
.max
; clock
.m1
++) {
907 clock
.m2
= DIV_ROUND_CLOSEST(target
* clock
.p
* clock
.n
,
910 vlv_calc_dpll_params(refclk
, &clock
);
912 if (!intel_PLL_is_valid(dev
, limit
,
916 if (!vlv_PLL_is_optimal(dev
, target
,
934 * Returns a set of divisors for the desired target clock with the given
935 * refclk, or FALSE. The returned values represent the clock equation:
936 * reflck * (5 * (m1 + 2) + (m2 + 2)) / (n + 2) / p1 / p2.
939 chv_find_best_dpll(const struct intel_limit
*limit
,
940 struct intel_crtc_state
*crtc_state
,
941 int target
, int refclk
, struct dpll
*match_clock
,
942 struct dpll
*best_clock
)
944 struct intel_crtc
*crtc
= to_intel_crtc(crtc_state
->base
.crtc
);
945 struct drm_device
*dev
= crtc
->base
.dev
;
946 unsigned int best_error_ppm
;
951 memset(best_clock
, 0, sizeof(*best_clock
));
952 best_error_ppm
= 1000000;
955 * Based on hardware doc, the n always set to 1, and m1 always
956 * set to 2. If requires to support 200Mhz refclk, we need to
957 * revisit this because n may not 1 anymore.
959 clock
.n
= 1, clock
.m1
= 2;
960 target
*= 5; /* fast clock */
962 for (clock
.p1
= limit
->p1
.max
; clock
.p1
>= limit
->p1
.min
; clock
.p1
--) {
963 for (clock
.p2
= limit
->p2
.p2_fast
;
964 clock
.p2
>= limit
->p2
.p2_slow
;
965 clock
.p2
-= clock
.p2
> 10 ? 2 : 1) {
966 unsigned int error_ppm
;
968 clock
.p
= clock
.p1
* clock
.p2
;
970 m2
= DIV_ROUND_CLOSEST_ULL(((uint64_t)target
* clock
.p
*
971 clock
.n
) << 22, refclk
* clock
.m1
);
973 if (m2
> INT_MAX
/clock
.m1
)
978 chv_calc_dpll_params(refclk
, &clock
);
980 if (!intel_PLL_is_valid(dev
, limit
, &clock
))
983 if (!vlv_PLL_is_optimal(dev
, target
, &clock
, best_clock
,
984 best_error_ppm
, &error_ppm
))
988 best_error_ppm
= error_ppm
;
996 bool bxt_find_best_dpll(struct intel_crtc_state
*crtc_state
, int target_clock
,
997 struct dpll
*best_clock
)
1000 const struct intel_limit
*limit
= &intel_limits_bxt
;
1002 return chv_find_best_dpll(limit
, crtc_state
,
1003 target_clock
, refclk
, NULL
, best_clock
);
1006 bool intel_crtc_active(struct drm_crtc
*crtc
)
1008 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
1010 /* Be paranoid as we can arrive here with only partial
1011 * state retrieved from the hardware during setup.
1013 * We can ditch the adjusted_mode.crtc_clock check as soon
1014 * as Haswell has gained clock readout/fastboot support.
1016 * We can ditch the crtc->primary->fb check as soon as we can
1017 * properly reconstruct framebuffers.
1019 * FIXME: The intel_crtc->active here should be switched to
1020 * crtc->state->active once we have proper CRTC states wired up
1023 return intel_crtc
->active
&& crtc
->primary
->state
->fb
&&
1024 intel_crtc
->config
->base
.adjusted_mode
.crtc_clock
;
1027 enum transcoder
intel_pipe_to_cpu_transcoder(struct drm_i915_private
*dev_priv
,
1030 struct drm_crtc
*crtc
= dev_priv
->pipe_to_crtc_mapping
[pipe
];
1031 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
1033 return intel_crtc
->config
->cpu_transcoder
;
1036 static bool pipe_dsl_stopped(struct drm_device
*dev
, enum pipe pipe
)
1038 struct drm_i915_private
*dev_priv
= to_i915(dev
);
1039 i915_reg_t reg
= PIPEDSL(pipe
);
1044 line_mask
= DSL_LINEMASK_GEN2
;
1046 line_mask
= DSL_LINEMASK_GEN3
;
1048 line1
= I915_READ(reg
) & line_mask
;
1050 line2
= I915_READ(reg
) & line_mask
;
1052 return line1
== line2
;
1056 * intel_wait_for_pipe_off - wait for pipe to turn off
1057 * @crtc: crtc whose pipe to wait for
1059 * After disabling a pipe, we can't wait for vblank in the usual way,
1060 * spinning on the vblank interrupt status bit, since we won't actually
1061 * see an interrupt when the pipe is disabled.
1063 * On Gen4 and above:
1064 * wait for the pipe register state bit to turn off
1067 * wait for the display line value to settle (it usually
1068 * ends up stopping at the start of the next frame).
1071 static void intel_wait_for_pipe_off(struct intel_crtc
*crtc
)
1073 struct drm_device
*dev
= crtc
->base
.dev
;
1074 struct drm_i915_private
*dev_priv
= to_i915(dev
);
1075 enum transcoder cpu_transcoder
= crtc
->config
->cpu_transcoder
;
1076 enum pipe pipe
= crtc
->pipe
;
1078 if (INTEL_INFO(dev
)->gen
>= 4) {
1079 i915_reg_t reg
= PIPECONF(cpu_transcoder
);
1081 /* Wait for the Pipe State to go off */
1082 if (intel_wait_for_register(dev_priv
,
1083 reg
, I965_PIPECONF_ACTIVE
, 0,
1085 WARN(1, "pipe_off wait timed out\n");
1087 /* Wait for the display line to settle */
1088 if (wait_for(pipe_dsl_stopped(dev
, pipe
), 100))
1089 WARN(1, "pipe_off wait timed out\n");
1093 /* Only for pre-ILK configs */
1094 void assert_pll(struct drm_i915_private
*dev_priv
,
1095 enum pipe pipe
, bool state
)
1100 val
= I915_READ(DPLL(pipe
));
1101 cur_state
= !!(val
& DPLL_VCO_ENABLE
);
1102 I915_STATE_WARN(cur_state
!= state
,
1103 "PLL state assertion failure (expected %s, current %s)\n",
1104 onoff(state
), onoff(cur_state
));
1107 /* XXX: the dsi pll is shared between MIPI DSI ports */
1108 void assert_dsi_pll(struct drm_i915_private
*dev_priv
, bool state
)
1113 mutex_lock(&dev_priv
->sb_lock
);
1114 val
= vlv_cck_read(dev_priv
, CCK_REG_DSI_PLL_CONTROL
);
1115 mutex_unlock(&dev_priv
->sb_lock
);
1117 cur_state
= val
& DSI_PLL_VCO_EN
;
1118 I915_STATE_WARN(cur_state
!= state
,
1119 "DSI PLL state assertion failure (expected %s, current %s)\n",
1120 onoff(state
), onoff(cur_state
));
1123 static void assert_fdi_tx(struct drm_i915_private
*dev_priv
,
1124 enum pipe pipe
, bool state
)
1127 enum transcoder cpu_transcoder
= intel_pipe_to_cpu_transcoder(dev_priv
,
1130 if (HAS_DDI(dev_priv
)) {
1131 /* DDI does not have a specific FDI_TX register */
1132 u32 val
= I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder
));
1133 cur_state
= !!(val
& TRANS_DDI_FUNC_ENABLE
);
1135 u32 val
= I915_READ(FDI_TX_CTL(pipe
));
1136 cur_state
= !!(val
& FDI_TX_ENABLE
);
1138 I915_STATE_WARN(cur_state
!= state
,
1139 "FDI TX state assertion failure (expected %s, current %s)\n",
1140 onoff(state
), onoff(cur_state
));
1142 #define assert_fdi_tx_enabled(d, p) assert_fdi_tx(d, p, true)
1143 #define assert_fdi_tx_disabled(d, p) assert_fdi_tx(d, p, false)
1145 static void assert_fdi_rx(struct drm_i915_private
*dev_priv
,
1146 enum pipe pipe
, bool state
)
1151 val
= I915_READ(FDI_RX_CTL(pipe
));
1152 cur_state
= !!(val
& FDI_RX_ENABLE
);
1153 I915_STATE_WARN(cur_state
!= state
,
1154 "FDI RX state assertion failure (expected %s, current %s)\n",
1155 onoff(state
), onoff(cur_state
));
1157 #define assert_fdi_rx_enabled(d, p) assert_fdi_rx(d, p, true)
1158 #define assert_fdi_rx_disabled(d, p) assert_fdi_rx(d, p, false)
1160 static void assert_fdi_tx_pll_enabled(struct drm_i915_private
*dev_priv
,
1165 /* ILK FDI PLL is always enabled */
1166 if (IS_GEN5(dev_priv
))
1169 /* On Haswell, DDI ports are responsible for the FDI PLL setup */
1170 if (HAS_DDI(dev_priv
))
1173 val
= I915_READ(FDI_TX_CTL(pipe
));
1174 I915_STATE_WARN(!(val
& FDI_TX_PLL_ENABLE
), "FDI TX PLL assertion failure, should be active but is disabled\n");
1177 void assert_fdi_rx_pll(struct drm_i915_private
*dev_priv
,
1178 enum pipe pipe
, bool state
)
1183 val
= I915_READ(FDI_RX_CTL(pipe
));
1184 cur_state
= !!(val
& FDI_RX_PLL_ENABLE
);
1185 I915_STATE_WARN(cur_state
!= state
,
1186 "FDI RX PLL assertion failure (expected %s, current %s)\n",
1187 onoff(state
), onoff(cur_state
));
1190 void assert_panel_unlocked(struct drm_i915_private
*dev_priv
,
1193 struct drm_device
*dev
= &dev_priv
->drm
;
1196 enum pipe panel_pipe
= PIPE_A
;
1199 if (WARN_ON(HAS_DDI(dev
)))
1202 if (HAS_PCH_SPLIT(dev
)) {
1205 pp_reg
= PP_CONTROL(0);
1206 port_sel
= I915_READ(PP_ON_DELAYS(0)) & PANEL_PORT_SELECT_MASK
;
1208 if (port_sel
== PANEL_PORT_SELECT_LVDS
&&
1209 I915_READ(PCH_LVDS
) & LVDS_PIPEB_SELECT
)
1210 panel_pipe
= PIPE_B
;
1211 /* XXX: else fix for eDP */
1212 } else if (IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
)) {
1213 /* presumably write lock depends on pipe, not port select */
1214 pp_reg
= PP_CONTROL(pipe
);
1217 pp_reg
= PP_CONTROL(0);
1218 if (I915_READ(LVDS
) & LVDS_PIPEB_SELECT
)
1219 panel_pipe
= PIPE_B
;
1222 val
= I915_READ(pp_reg
);
1223 if (!(val
& PANEL_POWER_ON
) ||
1224 ((val
& PANEL_UNLOCK_MASK
) == PANEL_UNLOCK_REGS
))
1227 I915_STATE_WARN(panel_pipe
== pipe
&& locked
,
1228 "panel assertion failure, pipe %c regs locked\n",
1232 static void assert_cursor(struct drm_i915_private
*dev_priv
,
1233 enum pipe pipe
, bool state
)
1235 struct drm_device
*dev
= &dev_priv
->drm
;
1238 if (IS_845G(dev
) || IS_I865G(dev
))
1239 cur_state
= I915_READ(CURCNTR(PIPE_A
)) & CURSOR_ENABLE
;
1241 cur_state
= I915_READ(CURCNTR(pipe
)) & CURSOR_MODE
;
1243 I915_STATE_WARN(cur_state
!= state
,
1244 "cursor on pipe %c assertion failure (expected %s, current %s)\n",
1245 pipe_name(pipe
), onoff(state
), onoff(cur_state
));
1247 #define assert_cursor_enabled(d, p) assert_cursor(d, p, true)
1248 #define assert_cursor_disabled(d, p) assert_cursor(d, p, false)
1250 void assert_pipe(struct drm_i915_private
*dev_priv
,
1251 enum pipe pipe
, bool state
)
1254 enum transcoder cpu_transcoder
= intel_pipe_to_cpu_transcoder(dev_priv
,
1256 enum intel_display_power_domain power_domain
;
1258 /* if we need the pipe quirk it must be always on */
1259 if ((pipe
== PIPE_A
&& dev_priv
->quirks
& QUIRK_PIPEA_FORCE
) ||
1260 (pipe
== PIPE_B
&& dev_priv
->quirks
& QUIRK_PIPEB_FORCE
))
1263 power_domain
= POWER_DOMAIN_TRANSCODER(cpu_transcoder
);
1264 if (intel_display_power_get_if_enabled(dev_priv
, power_domain
)) {
1265 u32 val
= I915_READ(PIPECONF(cpu_transcoder
));
1266 cur_state
= !!(val
& PIPECONF_ENABLE
);
1268 intel_display_power_put(dev_priv
, power_domain
);
1273 I915_STATE_WARN(cur_state
!= state
,
1274 "pipe %c assertion failure (expected %s, current %s)\n",
1275 pipe_name(pipe
), onoff(state
), onoff(cur_state
));
1278 static void assert_plane(struct drm_i915_private
*dev_priv
,
1279 enum plane plane
, bool state
)
1284 val
= I915_READ(DSPCNTR(plane
));
1285 cur_state
= !!(val
& DISPLAY_PLANE_ENABLE
);
1286 I915_STATE_WARN(cur_state
!= state
,
1287 "plane %c assertion failure (expected %s, current %s)\n",
1288 plane_name(plane
), onoff(state
), onoff(cur_state
));
1291 #define assert_plane_enabled(d, p) assert_plane(d, p, true)
1292 #define assert_plane_disabled(d, p) assert_plane(d, p, false)
1294 static void assert_planes_disabled(struct drm_i915_private
*dev_priv
,
1297 struct drm_device
*dev
= &dev_priv
->drm
;
1300 /* Primary planes are fixed to pipes on gen4+ */
1301 if (INTEL_INFO(dev
)->gen
>= 4) {
1302 u32 val
= I915_READ(DSPCNTR(pipe
));
1303 I915_STATE_WARN(val
& DISPLAY_PLANE_ENABLE
,
1304 "plane %c assertion failure, should be disabled but not\n",
1309 /* Need to check both planes against the pipe */
1310 for_each_pipe(dev_priv
, i
) {
1311 u32 val
= I915_READ(DSPCNTR(i
));
1312 enum pipe cur_pipe
= (val
& DISPPLANE_SEL_PIPE_MASK
) >>
1313 DISPPLANE_SEL_PIPE_SHIFT
;
1314 I915_STATE_WARN((val
& DISPLAY_PLANE_ENABLE
) && pipe
== cur_pipe
,
1315 "plane %c assertion failure, should be off on pipe %c but is still active\n",
1316 plane_name(i
), pipe_name(pipe
));
1320 static void assert_sprites_disabled(struct drm_i915_private
*dev_priv
,
1323 struct drm_device
*dev
= &dev_priv
->drm
;
1326 if (INTEL_INFO(dev
)->gen
>= 9) {
1327 for_each_sprite(dev_priv
, pipe
, sprite
) {
1328 u32 val
= I915_READ(PLANE_CTL(pipe
, sprite
));
1329 I915_STATE_WARN(val
& PLANE_CTL_ENABLE
,
1330 "plane %d assertion failure, should be off on pipe %c but is still active\n",
1331 sprite
, pipe_name(pipe
));
1333 } else if (IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
)) {
1334 for_each_sprite(dev_priv
, pipe
, sprite
) {
1335 u32 val
= I915_READ(SPCNTR(pipe
, sprite
));
1336 I915_STATE_WARN(val
& SP_ENABLE
,
1337 "sprite %c assertion failure, should be off on pipe %c but is still active\n",
1338 sprite_name(pipe
, sprite
), pipe_name(pipe
));
1340 } else if (INTEL_INFO(dev
)->gen
>= 7) {
1341 u32 val
= I915_READ(SPRCTL(pipe
));
1342 I915_STATE_WARN(val
& SPRITE_ENABLE
,
1343 "sprite %c assertion failure, should be off on pipe %c but is still active\n",
1344 plane_name(pipe
), pipe_name(pipe
));
1345 } else if (INTEL_INFO(dev
)->gen
>= 5) {
1346 u32 val
= I915_READ(DVSCNTR(pipe
));
1347 I915_STATE_WARN(val
& DVS_ENABLE
,
1348 "sprite %c assertion failure, should be off on pipe %c but is still active\n",
1349 plane_name(pipe
), pipe_name(pipe
));
1353 static void assert_vblank_disabled(struct drm_crtc
*crtc
)
1355 if (I915_STATE_WARN_ON(drm_crtc_vblank_get(crtc
) == 0))
1356 drm_crtc_vblank_put(crtc
);
1359 void assert_pch_transcoder_disabled(struct drm_i915_private
*dev_priv
,
1365 val
= I915_READ(PCH_TRANSCONF(pipe
));
1366 enabled
= !!(val
& TRANS_ENABLE
);
1367 I915_STATE_WARN(enabled
,
1368 "transcoder assertion failed, should be off on pipe %c but is still active\n",
1372 static bool dp_pipe_enabled(struct drm_i915_private
*dev_priv
,
1373 enum pipe pipe
, u32 port_sel
, u32 val
)
1375 if ((val
& DP_PORT_EN
) == 0)
1378 if (HAS_PCH_CPT(dev_priv
)) {
1379 u32 trans_dp_ctl
= I915_READ(TRANS_DP_CTL(pipe
));
1380 if ((trans_dp_ctl
& TRANS_DP_PORT_SEL_MASK
) != port_sel
)
1382 } else if (IS_CHERRYVIEW(dev_priv
)) {
1383 if ((val
& DP_PIPE_MASK_CHV
) != DP_PIPE_SELECT_CHV(pipe
))
1386 if ((val
& DP_PIPE_MASK
) != (pipe
<< 30))
1392 static bool hdmi_pipe_enabled(struct drm_i915_private
*dev_priv
,
1393 enum pipe pipe
, u32 val
)
1395 if ((val
& SDVO_ENABLE
) == 0)
1398 if (HAS_PCH_CPT(dev_priv
)) {
1399 if ((val
& SDVO_PIPE_SEL_MASK_CPT
) != SDVO_PIPE_SEL_CPT(pipe
))
1401 } else if (IS_CHERRYVIEW(dev_priv
)) {
1402 if ((val
& SDVO_PIPE_SEL_MASK_CHV
) != SDVO_PIPE_SEL_CHV(pipe
))
1405 if ((val
& SDVO_PIPE_SEL_MASK
) != SDVO_PIPE_SEL(pipe
))
1411 static bool lvds_pipe_enabled(struct drm_i915_private
*dev_priv
,
1412 enum pipe pipe
, u32 val
)
1414 if ((val
& LVDS_PORT_EN
) == 0)
1417 if (HAS_PCH_CPT(dev_priv
)) {
1418 if ((val
& PORT_TRANS_SEL_MASK
) != PORT_TRANS_SEL_CPT(pipe
))
1421 if ((val
& LVDS_PIPE_MASK
) != LVDS_PIPE(pipe
))
1427 static bool adpa_pipe_enabled(struct drm_i915_private
*dev_priv
,
1428 enum pipe pipe
, u32 val
)
1430 if ((val
& ADPA_DAC_ENABLE
) == 0)
1432 if (HAS_PCH_CPT(dev_priv
)) {
1433 if ((val
& PORT_TRANS_SEL_MASK
) != PORT_TRANS_SEL_CPT(pipe
))
1436 if ((val
& ADPA_PIPE_SELECT_MASK
) != ADPA_PIPE_SELECT(pipe
))
1442 static void assert_pch_dp_disabled(struct drm_i915_private
*dev_priv
,
1443 enum pipe pipe
, i915_reg_t reg
,
1446 u32 val
= I915_READ(reg
);
1447 I915_STATE_WARN(dp_pipe_enabled(dev_priv
, pipe
, port_sel
, val
),
1448 "PCH DP (0x%08x) enabled on transcoder %c, should be disabled\n",
1449 i915_mmio_reg_offset(reg
), pipe_name(pipe
));
1451 I915_STATE_WARN(HAS_PCH_IBX(dev_priv
) && (val
& DP_PORT_EN
) == 0
1452 && (val
& DP_PIPEB_SELECT
),
1453 "IBX PCH dp port still using transcoder B\n");
1456 static void assert_pch_hdmi_disabled(struct drm_i915_private
*dev_priv
,
1457 enum pipe pipe
, i915_reg_t reg
)
1459 u32 val
= I915_READ(reg
);
1460 I915_STATE_WARN(hdmi_pipe_enabled(dev_priv
, pipe
, val
),
1461 "PCH HDMI (0x%08x) enabled on transcoder %c, should be disabled\n",
1462 i915_mmio_reg_offset(reg
), pipe_name(pipe
));
1464 I915_STATE_WARN(HAS_PCH_IBX(dev_priv
) && (val
& SDVO_ENABLE
) == 0
1465 && (val
& SDVO_PIPE_B_SELECT
),
1466 "IBX PCH hdmi port still using transcoder B\n");
1469 static void assert_pch_ports_disabled(struct drm_i915_private
*dev_priv
,
1474 assert_pch_dp_disabled(dev_priv
, pipe
, PCH_DP_B
, TRANS_DP_PORT_SEL_B
);
1475 assert_pch_dp_disabled(dev_priv
, pipe
, PCH_DP_C
, TRANS_DP_PORT_SEL_C
);
1476 assert_pch_dp_disabled(dev_priv
, pipe
, PCH_DP_D
, TRANS_DP_PORT_SEL_D
);
1478 val
= I915_READ(PCH_ADPA
);
1479 I915_STATE_WARN(adpa_pipe_enabled(dev_priv
, pipe
, val
),
1480 "PCH VGA enabled on transcoder %c, should be disabled\n",
1483 val
= I915_READ(PCH_LVDS
);
1484 I915_STATE_WARN(lvds_pipe_enabled(dev_priv
, pipe
, val
),
1485 "PCH LVDS enabled on transcoder %c, should be disabled\n",
1488 assert_pch_hdmi_disabled(dev_priv
, pipe
, PCH_HDMIB
);
1489 assert_pch_hdmi_disabled(dev_priv
, pipe
, PCH_HDMIC
);
1490 assert_pch_hdmi_disabled(dev_priv
, pipe
, PCH_HDMID
);
1493 static void _vlv_enable_pll(struct intel_crtc
*crtc
,
1494 const struct intel_crtc_state
*pipe_config
)
1496 struct drm_i915_private
*dev_priv
= to_i915(crtc
->base
.dev
);
1497 enum pipe pipe
= crtc
->pipe
;
1499 I915_WRITE(DPLL(pipe
), pipe_config
->dpll_hw_state
.dpll
);
1500 POSTING_READ(DPLL(pipe
));
1503 if (intel_wait_for_register(dev_priv
,
1508 DRM_ERROR("DPLL %d failed to lock\n", pipe
);
1511 static void vlv_enable_pll(struct intel_crtc
*crtc
,
1512 const struct intel_crtc_state
*pipe_config
)
1514 struct drm_i915_private
*dev_priv
= to_i915(crtc
->base
.dev
);
1515 enum pipe pipe
= crtc
->pipe
;
1517 assert_pipe_disabled(dev_priv
, pipe
);
1519 /* PLL is protected by panel, make sure we can write it */
1520 assert_panel_unlocked(dev_priv
, pipe
);
1522 if (pipe_config
->dpll_hw_state
.dpll
& DPLL_VCO_ENABLE
)
1523 _vlv_enable_pll(crtc
, pipe_config
);
1525 I915_WRITE(DPLL_MD(pipe
), pipe_config
->dpll_hw_state
.dpll_md
);
1526 POSTING_READ(DPLL_MD(pipe
));
1530 static void _chv_enable_pll(struct intel_crtc
*crtc
,
1531 const struct intel_crtc_state
*pipe_config
)
1533 struct drm_i915_private
*dev_priv
= to_i915(crtc
->base
.dev
);
1534 enum pipe pipe
= crtc
->pipe
;
1535 enum dpio_channel port
= vlv_pipe_to_channel(pipe
);
1538 mutex_lock(&dev_priv
->sb_lock
);
1540 /* Enable back the 10bit clock to display controller */
1541 tmp
= vlv_dpio_read(dev_priv
, pipe
, CHV_CMN_DW14(port
));
1542 tmp
|= DPIO_DCLKP_EN
;
1543 vlv_dpio_write(dev_priv
, pipe
, CHV_CMN_DW14(port
), tmp
);
1545 mutex_unlock(&dev_priv
->sb_lock
);
1548 * Need to wait > 100ns between dclkp clock enable bit and PLL enable.
1553 I915_WRITE(DPLL(pipe
), pipe_config
->dpll_hw_state
.dpll
);
1555 /* Check PLL is locked */
1556 if (intel_wait_for_register(dev_priv
,
1557 DPLL(pipe
), DPLL_LOCK_VLV
, DPLL_LOCK_VLV
,
1559 DRM_ERROR("PLL %d failed to lock\n", pipe
);
1562 static void chv_enable_pll(struct intel_crtc
*crtc
,
1563 const struct intel_crtc_state
*pipe_config
)
1565 struct drm_i915_private
*dev_priv
= to_i915(crtc
->base
.dev
);
1566 enum pipe pipe
= crtc
->pipe
;
1568 assert_pipe_disabled(dev_priv
, pipe
);
1570 /* PLL is protected by panel, make sure we can write it */
1571 assert_panel_unlocked(dev_priv
, pipe
);
1573 if (pipe_config
->dpll_hw_state
.dpll
& DPLL_VCO_ENABLE
)
1574 _chv_enable_pll(crtc
, pipe_config
);
1576 if (pipe
!= PIPE_A
) {
1578 * WaPixelRepeatModeFixForC0:chv
1580 * DPLLCMD is AWOL. Use chicken bits to propagate
1581 * the value from DPLLBMD to either pipe B or C.
1583 I915_WRITE(CBR4_VLV
, pipe
== PIPE_B
? CBR_DPLLBMD_PIPE_B
: CBR_DPLLBMD_PIPE_C
);
1584 I915_WRITE(DPLL_MD(PIPE_B
), pipe_config
->dpll_hw_state
.dpll_md
);
1585 I915_WRITE(CBR4_VLV
, 0);
1586 dev_priv
->chv_dpll_md
[pipe
] = pipe_config
->dpll_hw_state
.dpll_md
;
1589 * DPLLB VGA mode also seems to cause problems.
1590 * We should always have it disabled.
1592 WARN_ON((I915_READ(DPLL(PIPE_B
)) & DPLL_VGA_MODE_DIS
) == 0);
1594 I915_WRITE(DPLL_MD(pipe
), pipe_config
->dpll_hw_state
.dpll_md
);
1595 POSTING_READ(DPLL_MD(pipe
));
1599 static int intel_num_dvo_pipes(struct drm_device
*dev
)
1601 struct intel_crtc
*crtc
;
1604 for_each_intel_crtc(dev
, crtc
) {
1605 count
+= crtc
->base
.state
->active
&&
1606 intel_crtc_has_type(crtc
->config
, INTEL_OUTPUT_DVO
);
1612 static void i9xx_enable_pll(struct intel_crtc
*crtc
)
1614 struct drm_device
*dev
= crtc
->base
.dev
;
1615 struct drm_i915_private
*dev_priv
= to_i915(dev
);
1616 i915_reg_t reg
= DPLL(crtc
->pipe
);
1617 u32 dpll
= crtc
->config
->dpll_hw_state
.dpll
;
1619 assert_pipe_disabled(dev_priv
, crtc
->pipe
);
1621 /* PLL is protected by panel, make sure we can write it */
1622 if (IS_MOBILE(dev
) && !IS_I830(dev
))
1623 assert_panel_unlocked(dev_priv
, crtc
->pipe
);
1625 /* Enable DVO 2x clock on both PLLs if necessary */
1626 if (IS_I830(dev
) && intel_num_dvo_pipes(dev
) > 0) {
1628 * It appears to be important that we don't enable this
1629 * for the current pipe before otherwise configuring the
1630 * PLL. No idea how this should be handled if multiple
1631 * DVO outputs are enabled simultaneosly.
1633 dpll
|= DPLL_DVO_2X_MODE
;
1634 I915_WRITE(DPLL(!crtc
->pipe
),
1635 I915_READ(DPLL(!crtc
->pipe
)) | DPLL_DVO_2X_MODE
);
1639 * Apparently we need to have VGA mode enabled prior to changing
1640 * the P1/P2 dividers. Otherwise the DPLL will keep using the old
1641 * dividers, even though the register value does change.
1645 I915_WRITE(reg
, dpll
);
1647 /* Wait for the clocks to stabilize. */
1651 if (INTEL_INFO(dev
)->gen
>= 4) {
1652 I915_WRITE(DPLL_MD(crtc
->pipe
),
1653 crtc
->config
->dpll_hw_state
.dpll_md
);
1655 /* The pixel multiplier can only be updated once the
1656 * DPLL is enabled and the clocks are stable.
1658 * So write it again.
1660 I915_WRITE(reg
, dpll
);
1663 /* We do this three times for luck */
1664 I915_WRITE(reg
, dpll
);
1666 udelay(150); /* wait for warmup */
1667 I915_WRITE(reg
, dpll
);
1669 udelay(150); /* wait for warmup */
1670 I915_WRITE(reg
, dpll
);
1672 udelay(150); /* wait for warmup */
1676 * i9xx_disable_pll - disable a PLL
1677 * @dev_priv: i915 private structure
1678 * @pipe: pipe PLL to disable
1680 * Disable the PLL for @pipe, making sure the pipe is off first.
1682 * Note! This is for pre-ILK only.
1684 static void i9xx_disable_pll(struct intel_crtc
*crtc
)
1686 struct drm_device
*dev
= crtc
->base
.dev
;
1687 struct drm_i915_private
*dev_priv
= to_i915(dev
);
1688 enum pipe pipe
= crtc
->pipe
;
1690 /* Disable DVO 2x clock on both PLLs if necessary */
1692 intel_crtc_has_type(crtc
->config
, INTEL_OUTPUT_DVO
) &&
1693 !intel_num_dvo_pipes(dev
)) {
1694 I915_WRITE(DPLL(PIPE_B
),
1695 I915_READ(DPLL(PIPE_B
)) & ~DPLL_DVO_2X_MODE
);
1696 I915_WRITE(DPLL(PIPE_A
),
1697 I915_READ(DPLL(PIPE_A
)) & ~DPLL_DVO_2X_MODE
);
1700 /* Don't disable pipe or pipe PLLs if needed */
1701 if ((pipe
== PIPE_A
&& dev_priv
->quirks
& QUIRK_PIPEA_FORCE
) ||
1702 (pipe
== PIPE_B
&& dev_priv
->quirks
& QUIRK_PIPEB_FORCE
))
1705 /* Make sure the pipe isn't still relying on us */
1706 assert_pipe_disabled(dev_priv
, pipe
);
1708 I915_WRITE(DPLL(pipe
), DPLL_VGA_MODE_DIS
);
1709 POSTING_READ(DPLL(pipe
));
1712 static void vlv_disable_pll(struct drm_i915_private
*dev_priv
, enum pipe pipe
)
1716 /* Make sure the pipe isn't still relying on us */
1717 assert_pipe_disabled(dev_priv
, pipe
);
1719 val
= DPLL_INTEGRATED_REF_CLK_VLV
|
1720 DPLL_REF_CLK_ENABLE_VLV
| DPLL_VGA_MODE_DIS
;
1722 val
|= DPLL_INTEGRATED_CRI_CLK_VLV
;
1724 I915_WRITE(DPLL(pipe
), val
);
1725 POSTING_READ(DPLL(pipe
));
1728 static void chv_disable_pll(struct drm_i915_private
*dev_priv
, enum pipe pipe
)
1730 enum dpio_channel port
= vlv_pipe_to_channel(pipe
);
1733 /* Make sure the pipe isn't still relying on us */
1734 assert_pipe_disabled(dev_priv
, pipe
);
1736 val
= DPLL_SSC_REF_CLK_CHV
|
1737 DPLL_REF_CLK_ENABLE_VLV
| DPLL_VGA_MODE_DIS
;
1739 val
|= DPLL_INTEGRATED_CRI_CLK_VLV
;
1741 I915_WRITE(DPLL(pipe
), val
);
1742 POSTING_READ(DPLL(pipe
));
1744 mutex_lock(&dev_priv
->sb_lock
);
1746 /* Disable 10bit clock to display controller */
1747 val
= vlv_dpio_read(dev_priv
, pipe
, CHV_CMN_DW14(port
));
1748 val
&= ~DPIO_DCLKP_EN
;
1749 vlv_dpio_write(dev_priv
, pipe
, CHV_CMN_DW14(port
), val
);
1751 mutex_unlock(&dev_priv
->sb_lock
);
1754 void vlv_wait_port_ready(struct drm_i915_private
*dev_priv
,
1755 struct intel_digital_port
*dport
,
1756 unsigned int expected_mask
)
1759 i915_reg_t dpll_reg
;
1761 switch (dport
->port
) {
1763 port_mask
= DPLL_PORTB_READY_MASK
;
1767 port_mask
= DPLL_PORTC_READY_MASK
;
1769 expected_mask
<<= 4;
1772 port_mask
= DPLL_PORTD_READY_MASK
;
1773 dpll_reg
= DPIO_PHY_STATUS
;
1779 if (intel_wait_for_register(dev_priv
,
1780 dpll_reg
, port_mask
, expected_mask
,
1782 WARN(1, "timed out waiting for port %c ready: got 0x%x, expected 0x%x\n",
1783 port_name(dport
->port
), I915_READ(dpll_reg
) & port_mask
, expected_mask
);
1786 static void ironlake_enable_pch_transcoder(struct drm_i915_private
*dev_priv
,
1789 struct drm_device
*dev
= &dev_priv
->drm
;
1790 struct drm_crtc
*crtc
= dev_priv
->pipe_to_crtc_mapping
[pipe
];
1791 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
1793 uint32_t val
, pipeconf_val
;
1795 /* Make sure PCH DPLL is enabled */
1796 assert_shared_dpll_enabled(dev_priv
, intel_crtc
->config
->shared_dpll
);
1798 /* FDI must be feeding us bits for PCH ports */
1799 assert_fdi_tx_enabled(dev_priv
, pipe
);
1800 assert_fdi_rx_enabled(dev_priv
, pipe
);
1802 if (HAS_PCH_CPT(dev
)) {
1803 /* Workaround: Set the timing override bit before enabling the
1804 * pch transcoder. */
1805 reg
= TRANS_CHICKEN2(pipe
);
1806 val
= I915_READ(reg
);
1807 val
|= TRANS_CHICKEN2_TIMING_OVERRIDE
;
1808 I915_WRITE(reg
, val
);
1811 reg
= PCH_TRANSCONF(pipe
);
1812 val
= I915_READ(reg
);
1813 pipeconf_val
= I915_READ(PIPECONF(pipe
));
1815 if (HAS_PCH_IBX(dev_priv
)) {
1817 * Make the BPC in transcoder be consistent with
1818 * that in pipeconf reg. For HDMI we must use 8bpc
1819 * here for both 8bpc and 12bpc.
1821 val
&= ~PIPECONF_BPC_MASK
;
1822 if (intel_crtc_has_type(intel_crtc
->config
, INTEL_OUTPUT_HDMI
))
1823 val
|= PIPECONF_8BPC
;
1825 val
|= pipeconf_val
& PIPECONF_BPC_MASK
;
1828 val
&= ~TRANS_INTERLACE_MASK
;
1829 if ((pipeconf_val
& PIPECONF_INTERLACE_MASK
) == PIPECONF_INTERLACED_ILK
)
1830 if (HAS_PCH_IBX(dev_priv
) &&
1831 intel_crtc_has_type(intel_crtc
->config
, INTEL_OUTPUT_SDVO
))
1832 val
|= TRANS_LEGACY_INTERLACED_ILK
;
1834 val
|= TRANS_INTERLACED
;
1836 val
|= TRANS_PROGRESSIVE
;
1838 I915_WRITE(reg
, val
| TRANS_ENABLE
);
1839 if (intel_wait_for_register(dev_priv
,
1840 reg
, TRANS_STATE_ENABLE
, TRANS_STATE_ENABLE
,
1842 DRM_ERROR("failed to enable transcoder %c\n", pipe_name(pipe
));
1845 static void lpt_enable_pch_transcoder(struct drm_i915_private
*dev_priv
,
1846 enum transcoder cpu_transcoder
)
1848 u32 val
, pipeconf_val
;
1850 /* FDI must be feeding us bits for PCH ports */
1851 assert_fdi_tx_enabled(dev_priv
, (enum pipe
) cpu_transcoder
);
1852 assert_fdi_rx_enabled(dev_priv
, TRANSCODER_A
);
1854 /* Workaround: set timing override bit. */
1855 val
= I915_READ(TRANS_CHICKEN2(PIPE_A
));
1856 val
|= TRANS_CHICKEN2_TIMING_OVERRIDE
;
1857 I915_WRITE(TRANS_CHICKEN2(PIPE_A
), val
);
1860 pipeconf_val
= I915_READ(PIPECONF(cpu_transcoder
));
1862 if ((pipeconf_val
& PIPECONF_INTERLACE_MASK_HSW
) ==
1863 PIPECONF_INTERLACED_ILK
)
1864 val
|= TRANS_INTERLACED
;
1866 val
|= TRANS_PROGRESSIVE
;
1868 I915_WRITE(LPT_TRANSCONF
, val
);
1869 if (intel_wait_for_register(dev_priv
,
1874 DRM_ERROR("Failed to enable PCH transcoder\n");
1877 static void ironlake_disable_pch_transcoder(struct drm_i915_private
*dev_priv
,
1880 struct drm_device
*dev
= &dev_priv
->drm
;
1884 /* FDI relies on the transcoder */
1885 assert_fdi_tx_disabled(dev_priv
, pipe
);
1886 assert_fdi_rx_disabled(dev_priv
, pipe
);
1888 /* Ports must be off as well */
1889 assert_pch_ports_disabled(dev_priv
, pipe
);
1891 reg
= PCH_TRANSCONF(pipe
);
1892 val
= I915_READ(reg
);
1893 val
&= ~TRANS_ENABLE
;
1894 I915_WRITE(reg
, val
);
1895 /* wait for PCH transcoder off, transcoder state */
1896 if (intel_wait_for_register(dev_priv
,
1897 reg
, TRANS_STATE_ENABLE
, 0,
1899 DRM_ERROR("failed to disable transcoder %c\n", pipe_name(pipe
));
1901 if (HAS_PCH_CPT(dev
)) {
1902 /* Workaround: Clear the timing override chicken bit again. */
1903 reg
= TRANS_CHICKEN2(pipe
);
1904 val
= I915_READ(reg
);
1905 val
&= ~TRANS_CHICKEN2_TIMING_OVERRIDE
;
1906 I915_WRITE(reg
, val
);
1910 static void lpt_disable_pch_transcoder(struct drm_i915_private
*dev_priv
)
1914 val
= I915_READ(LPT_TRANSCONF
);
1915 val
&= ~TRANS_ENABLE
;
1916 I915_WRITE(LPT_TRANSCONF
, val
);
1917 /* wait for PCH transcoder off, transcoder state */
1918 if (intel_wait_for_register(dev_priv
,
1919 LPT_TRANSCONF
, TRANS_STATE_ENABLE
, 0,
1921 DRM_ERROR("Failed to disable PCH transcoder\n");
1923 /* Workaround: clear timing override bit. */
1924 val
= I915_READ(TRANS_CHICKEN2(PIPE_A
));
1925 val
&= ~TRANS_CHICKEN2_TIMING_OVERRIDE
;
1926 I915_WRITE(TRANS_CHICKEN2(PIPE_A
), val
);
1930 * intel_enable_pipe - enable a pipe, asserting requirements
1931 * @crtc: crtc responsible for the pipe
1933 * Enable @crtc's pipe, making sure that various hardware specific requirements
1934 * are met, if applicable, e.g. PLL enabled, LVDS pairs enabled, etc.
1936 static void intel_enable_pipe(struct intel_crtc
*crtc
)
1938 struct drm_device
*dev
= crtc
->base
.dev
;
1939 struct drm_i915_private
*dev_priv
= to_i915(dev
);
1940 enum pipe pipe
= crtc
->pipe
;
1941 enum transcoder cpu_transcoder
= crtc
->config
->cpu_transcoder
;
1942 enum pipe pch_transcoder
;
1946 DRM_DEBUG_KMS("enabling pipe %c\n", pipe_name(pipe
));
1948 assert_planes_disabled(dev_priv
, pipe
);
1949 assert_cursor_disabled(dev_priv
, pipe
);
1950 assert_sprites_disabled(dev_priv
, pipe
);
1952 if (HAS_PCH_LPT(dev_priv
))
1953 pch_transcoder
= TRANSCODER_A
;
1955 pch_transcoder
= pipe
;
1958 * A pipe without a PLL won't actually be able to drive bits from
1959 * a plane. On ILK+ the pipe PLLs are integrated, so we don't
1962 if (HAS_GMCH_DISPLAY(dev_priv
)) {
1963 if (intel_crtc_has_type(crtc
->config
, INTEL_OUTPUT_DSI
))
1964 assert_dsi_pll_enabled(dev_priv
);
1966 assert_pll_enabled(dev_priv
, pipe
);
1968 if (crtc
->config
->has_pch_encoder
) {
1969 /* if driving the PCH, we need FDI enabled */
1970 assert_fdi_rx_pll_enabled(dev_priv
, pch_transcoder
);
1971 assert_fdi_tx_pll_enabled(dev_priv
,
1972 (enum pipe
) cpu_transcoder
);
1974 /* FIXME: assert CPU port conditions for SNB+ */
1977 reg
= PIPECONF(cpu_transcoder
);
1978 val
= I915_READ(reg
);
1979 if (val
& PIPECONF_ENABLE
) {
1980 WARN_ON(!((pipe
== PIPE_A
&& dev_priv
->quirks
& QUIRK_PIPEA_FORCE
) ||
1981 (pipe
== PIPE_B
&& dev_priv
->quirks
& QUIRK_PIPEB_FORCE
)));
1985 I915_WRITE(reg
, val
| PIPECONF_ENABLE
);
1989 * Until the pipe starts DSL will read as 0, which would cause
1990 * an apparent vblank timestamp jump, which messes up also the
1991 * frame count when it's derived from the timestamps. So let's
1992 * wait for the pipe to start properly before we call
1993 * drm_crtc_vblank_on()
1995 if (dev
->max_vblank_count
== 0 &&
1996 wait_for(intel_get_crtc_scanline(crtc
) != crtc
->scanline_offset
, 50))
1997 DRM_ERROR("pipe %c didn't start\n", pipe_name(pipe
));
2001 * intel_disable_pipe - disable a pipe, asserting requirements
2002 * @crtc: crtc whose pipes is to be disabled
2004 * Disable the pipe of @crtc, making sure that various hardware
2005 * specific requirements are met, if applicable, e.g. plane
2006 * disabled, panel fitter off, etc.
2008 * Will wait until the pipe has shut down before returning.
2010 static void intel_disable_pipe(struct intel_crtc
*crtc
)
2012 struct drm_i915_private
*dev_priv
= to_i915(crtc
->base
.dev
);
2013 enum transcoder cpu_transcoder
= crtc
->config
->cpu_transcoder
;
2014 enum pipe pipe
= crtc
->pipe
;
2018 DRM_DEBUG_KMS("disabling pipe %c\n", pipe_name(pipe
));
2021 * Make sure planes won't keep trying to pump pixels to us,
2022 * or we might hang the display.
2024 assert_planes_disabled(dev_priv
, pipe
);
2025 assert_cursor_disabled(dev_priv
, pipe
);
2026 assert_sprites_disabled(dev_priv
, pipe
);
2028 reg
= PIPECONF(cpu_transcoder
);
2029 val
= I915_READ(reg
);
2030 if ((val
& PIPECONF_ENABLE
) == 0)
2034 * Double wide has implications for planes
2035 * so best keep it disabled when not needed.
2037 if (crtc
->config
->double_wide
)
2038 val
&= ~PIPECONF_DOUBLE_WIDE
;
2040 /* Don't disable pipe or pipe PLLs if needed */
2041 if (!(pipe
== PIPE_A
&& dev_priv
->quirks
& QUIRK_PIPEA_FORCE
) &&
2042 !(pipe
== PIPE_B
&& dev_priv
->quirks
& QUIRK_PIPEB_FORCE
))
2043 val
&= ~PIPECONF_ENABLE
;
2045 I915_WRITE(reg
, val
);
2046 if ((val
& PIPECONF_ENABLE
) == 0)
2047 intel_wait_for_pipe_off(crtc
);
2050 static unsigned int intel_tile_size(const struct drm_i915_private
*dev_priv
)
2052 return IS_GEN2(dev_priv
) ? 2048 : 4096;
2055 static unsigned int intel_tile_width_bytes(const struct drm_i915_private
*dev_priv
,
2056 uint64_t fb_modifier
, unsigned int cpp
)
2058 switch (fb_modifier
) {
2059 case DRM_FORMAT_MOD_NONE
:
2061 case I915_FORMAT_MOD_X_TILED
:
2062 if (IS_GEN2(dev_priv
))
2066 case I915_FORMAT_MOD_Y_TILED
:
2067 if (IS_GEN2(dev_priv
) || HAS_128_BYTE_Y_TILING(dev_priv
))
2071 case I915_FORMAT_MOD_Yf_TILED
:
2087 MISSING_CASE(fb_modifier
);
2092 unsigned int intel_tile_height(const struct drm_i915_private
*dev_priv
,
2093 uint64_t fb_modifier
, unsigned int cpp
)
2095 if (fb_modifier
== DRM_FORMAT_MOD_NONE
)
2098 return intel_tile_size(dev_priv
) /
2099 intel_tile_width_bytes(dev_priv
, fb_modifier
, cpp
);
2102 /* Return the tile dimensions in pixel units */
2103 static void intel_tile_dims(const struct drm_i915_private
*dev_priv
,
2104 unsigned int *tile_width
,
2105 unsigned int *tile_height
,
2106 uint64_t fb_modifier
,
2109 unsigned int tile_width_bytes
=
2110 intel_tile_width_bytes(dev_priv
, fb_modifier
, cpp
);
2112 *tile_width
= tile_width_bytes
/ cpp
;
2113 *tile_height
= intel_tile_size(dev_priv
) / tile_width_bytes
;
2117 intel_fb_align_height(struct drm_device
*dev
, unsigned int height
,
2118 uint32_t pixel_format
, uint64_t fb_modifier
)
2120 unsigned int cpp
= drm_format_plane_cpp(pixel_format
, 0);
2121 unsigned int tile_height
= intel_tile_height(to_i915(dev
), fb_modifier
, cpp
);
2123 return ALIGN(height
, tile_height
);
2126 unsigned int intel_rotation_info_size(const struct intel_rotation_info
*rot_info
)
2128 unsigned int size
= 0;
2131 for (i
= 0 ; i
< ARRAY_SIZE(rot_info
->plane
); i
++)
2132 size
+= rot_info
->plane
[i
].width
* rot_info
->plane
[i
].height
;
2138 intel_fill_fb_ggtt_view(struct i915_ggtt_view
*view
,
2139 const struct drm_framebuffer
*fb
,
2140 unsigned int rotation
)
2142 if (intel_rotation_90_or_270(rotation
)) {
2143 *view
= i915_ggtt_view_rotated
;
2144 view
->params
.rotated
= to_intel_framebuffer(fb
)->rot_info
;
2146 *view
= i915_ggtt_view_normal
;
2150 static unsigned int intel_linear_alignment(const struct drm_i915_private
*dev_priv
)
2152 if (INTEL_INFO(dev_priv
)->gen
>= 9)
2154 else if (IS_BROADWATER(dev_priv
) || IS_CRESTLINE(dev_priv
) ||
2155 IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
))
2157 else if (INTEL_INFO(dev_priv
)->gen
>= 4)
2163 static unsigned int intel_surf_alignment(const struct drm_i915_private
*dev_priv
,
2164 uint64_t fb_modifier
)
2166 switch (fb_modifier
) {
2167 case DRM_FORMAT_MOD_NONE
:
2168 return intel_linear_alignment(dev_priv
);
2169 case I915_FORMAT_MOD_X_TILED
:
2170 if (INTEL_INFO(dev_priv
)->gen
>= 9)
2173 case I915_FORMAT_MOD_Y_TILED
:
2174 case I915_FORMAT_MOD_Yf_TILED
:
2175 return 1 * 1024 * 1024;
2177 MISSING_CASE(fb_modifier
);
2183 intel_pin_and_fence_fb_obj(struct drm_framebuffer
*fb
, unsigned int rotation
)
2185 struct drm_device
*dev
= fb
->dev
;
2186 struct drm_i915_private
*dev_priv
= to_i915(dev
);
2187 struct drm_i915_gem_object
*obj
= intel_fb_obj(fb
);
2188 struct i915_ggtt_view view
;
2189 struct i915_vma
*vma
;
2192 WARN_ON(!mutex_is_locked(&dev
->struct_mutex
));
2194 alignment
= intel_surf_alignment(dev_priv
, fb
->modifier
[0]);
2196 intel_fill_fb_ggtt_view(&view
, fb
, rotation
);
2198 /* Note that the w/a also requires 64 PTE of padding following the
2199 * bo. We currently fill all unused PTE with the shadow page and so
2200 * we should always have valid PTE following the scanout preventing
2203 if (intel_scanout_needs_vtd_wa(dev_priv
) && alignment
< 256 * 1024)
2204 alignment
= 256 * 1024;
2207 * Global gtt pte registers are special registers which actually forward
2208 * writes to a chunk of system memory. Which means that there is no risk
2209 * that the register values disappear as soon as we call
2210 * intel_runtime_pm_put(), so it is correct to wrap only the
2211 * pin/unpin/fence and not more.
2213 intel_runtime_pm_get(dev_priv
);
2215 vma
= i915_gem_object_pin_to_display_plane(obj
, alignment
, &view
);
2219 if (i915_vma_is_map_and_fenceable(vma
)) {
2220 /* Install a fence for tiled scan-out. Pre-i965 always needs a
2221 * fence, whereas 965+ only requires a fence if using
2222 * framebuffer compression. For simplicity, we always, when
2223 * possible, install a fence as the cost is not that onerous.
2225 * If we fail to fence the tiled scanout, then either the
2226 * modeset will reject the change (which is highly unlikely as
2227 * the affected systems, all but one, do not have unmappable
2228 * space) or we will not be able to enable full powersaving
2229 * techniques (also likely not to apply due to various limits
2230 * FBC and the like impose on the size of the buffer, which
2231 * presumably we violated anyway with this unmappable buffer).
2232 * Anyway, it is presumably better to stumble onwards with
2233 * something and try to run the system in a "less than optimal"
2234 * mode that matches the user configuration.
2236 if (i915_vma_get_fence(vma
) == 0)
2237 i915_vma_pin_fence(vma
);
2241 intel_runtime_pm_put(dev_priv
);
2245 void intel_unpin_fb_obj(struct drm_framebuffer
*fb
, unsigned int rotation
)
2247 struct drm_i915_gem_object
*obj
= intel_fb_obj(fb
);
2248 struct i915_ggtt_view view
;
2249 struct i915_vma
*vma
;
2251 WARN_ON(!mutex_is_locked(&obj
->base
.dev
->struct_mutex
));
2253 intel_fill_fb_ggtt_view(&view
, fb
, rotation
);
2254 vma
= i915_gem_object_to_ggtt(obj
, &view
);
2256 i915_vma_unpin_fence(vma
);
2257 i915_gem_object_unpin_from_display_plane(vma
);
2260 static int intel_fb_pitch(const struct drm_framebuffer
*fb
, int plane
,
2261 unsigned int rotation
)
2263 if (intel_rotation_90_or_270(rotation
))
2264 return to_intel_framebuffer(fb
)->rotated
[plane
].pitch
;
2266 return fb
->pitches
[plane
];
2270 * Convert the x/y offsets into a linear offset.
2271 * Only valid with 0/180 degree rotation, which is fine since linear
2272 * offset is only used with linear buffers on pre-hsw and tiled buffers
2273 * with gen2/3, and 90/270 degree rotations isn't supported on any of them.
2275 u32
intel_fb_xy_to_linear(int x
, int y
,
2276 const struct intel_plane_state
*state
,
2279 const struct drm_framebuffer
*fb
= state
->base
.fb
;
2280 unsigned int cpp
= drm_format_plane_cpp(fb
->pixel_format
, plane
);
2281 unsigned int pitch
= fb
->pitches
[plane
];
2283 return y
* pitch
+ x
* cpp
;
2287 * Add the x/y offsets derived from fb->offsets[] to the user
2288 * specified plane src x/y offsets. The resulting x/y offsets
2289 * specify the start of scanout from the beginning of the gtt mapping.
2291 void intel_add_fb_offsets(int *x
, int *y
,
2292 const struct intel_plane_state
*state
,
2296 const struct intel_framebuffer
*intel_fb
= to_intel_framebuffer(state
->base
.fb
);
2297 unsigned int rotation
= state
->base
.rotation
;
2299 if (intel_rotation_90_or_270(rotation
)) {
2300 *x
+= intel_fb
->rotated
[plane
].x
;
2301 *y
+= intel_fb
->rotated
[plane
].y
;
2303 *x
+= intel_fb
->normal
[plane
].x
;
2304 *y
+= intel_fb
->normal
[plane
].y
;
2309 * Input tile dimensions and pitch must already be
2310 * rotated to match x and y, and in pixel units.
2312 static u32
_intel_adjust_tile_offset(int *x
, int *y
,
2313 unsigned int tile_width
,
2314 unsigned int tile_height
,
2315 unsigned int tile_size
,
2316 unsigned int pitch_tiles
,
2320 unsigned int pitch_pixels
= pitch_tiles
* tile_width
;
2323 WARN_ON(old_offset
& (tile_size
- 1));
2324 WARN_ON(new_offset
& (tile_size
- 1));
2325 WARN_ON(new_offset
> old_offset
);
2327 tiles
= (old_offset
- new_offset
) / tile_size
;
2329 *y
+= tiles
/ pitch_tiles
* tile_height
;
2330 *x
+= tiles
% pitch_tiles
* tile_width
;
2332 /* minimize x in case it got needlessly big */
2333 *y
+= *x
/ pitch_pixels
* tile_height
;
2340 * Adjust the tile offset by moving the difference into
2343 static u32
intel_adjust_tile_offset(int *x
, int *y
,
2344 const struct intel_plane_state
*state
, int plane
,
2345 u32 old_offset
, u32 new_offset
)
2347 const struct drm_i915_private
*dev_priv
= to_i915(state
->base
.plane
->dev
);
2348 const struct drm_framebuffer
*fb
= state
->base
.fb
;
2349 unsigned int cpp
= drm_format_plane_cpp(fb
->pixel_format
, plane
);
2350 unsigned int rotation
= state
->base
.rotation
;
2351 unsigned int pitch
= intel_fb_pitch(fb
, plane
, rotation
);
2353 WARN_ON(new_offset
> old_offset
);
2355 if (fb
->modifier
[plane
] != DRM_FORMAT_MOD_NONE
) {
2356 unsigned int tile_size
, tile_width
, tile_height
;
2357 unsigned int pitch_tiles
;
2359 tile_size
= intel_tile_size(dev_priv
);
2360 intel_tile_dims(dev_priv
, &tile_width
, &tile_height
,
2361 fb
->modifier
[plane
], cpp
);
2363 if (intel_rotation_90_or_270(rotation
)) {
2364 pitch_tiles
= pitch
/ tile_height
;
2365 swap(tile_width
, tile_height
);
2367 pitch_tiles
= pitch
/ (tile_width
* cpp
);
2370 _intel_adjust_tile_offset(x
, y
, tile_width
, tile_height
,
2371 tile_size
, pitch_tiles
,
2372 old_offset
, new_offset
);
2374 old_offset
+= *y
* pitch
+ *x
* cpp
;
2376 *y
= (old_offset
- new_offset
) / pitch
;
2377 *x
= ((old_offset
- new_offset
) - *y
* pitch
) / cpp
;
2384 * Computes the linear offset to the base tile and adjusts
2385 * x, y. bytes per pixel is assumed to be a power-of-two.
2387 * In the 90/270 rotated case, x and y are assumed
2388 * to be already rotated to match the rotated GTT view, and
2389 * pitch is the tile_height aligned framebuffer height.
2391 * This function is used when computing the derived information
2392 * under intel_framebuffer, so using any of that information
2393 * here is not allowed. Anything under drm_framebuffer can be
2394 * used. This is why the user has to pass in the pitch since it
2395 * is specified in the rotated orientation.
2397 static u32
_intel_compute_tile_offset(const struct drm_i915_private
*dev_priv
,
2399 const struct drm_framebuffer
*fb
, int plane
,
2401 unsigned int rotation
,
2404 uint64_t fb_modifier
= fb
->modifier
[plane
];
2405 unsigned int cpp
= drm_format_plane_cpp(fb
->pixel_format
, plane
);
2406 u32 offset
, offset_aligned
;
2411 if (fb_modifier
!= DRM_FORMAT_MOD_NONE
) {
2412 unsigned int tile_size
, tile_width
, tile_height
;
2413 unsigned int tile_rows
, tiles
, pitch_tiles
;
2415 tile_size
= intel_tile_size(dev_priv
);
2416 intel_tile_dims(dev_priv
, &tile_width
, &tile_height
,
2419 if (intel_rotation_90_or_270(rotation
)) {
2420 pitch_tiles
= pitch
/ tile_height
;
2421 swap(tile_width
, tile_height
);
2423 pitch_tiles
= pitch
/ (tile_width
* cpp
);
2426 tile_rows
= *y
/ tile_height
;
2429 tiles
= *x
/ tile_width
;
2432 offset
= (tile_rows
* pitch_tiles
+ tiles
) * tile_size
;
2433 offset_aligned
= offset
& ~alignment
;
2435 _intel_adjust_tile_offset(x
, y
, tile_width
, tile_height
,
2436 tile_size
, pitch_tiles
,
2437 offset
, offset_aligned
);
2439 offset
= *y
* pitch
+ *x
* cpp
;
2440 offset_aligned
= offset
& ~alignment
;
2442 *y
= (offset
& alignment
) / pitch
;
2443 *x
= ((offset
& alignment
) - *y
* pitch
) / cpp
;
2446 return offset_aligned
;
2449 u32
intel_compute_tile_offset(int *x
, int *y
,
2450 const struct intel_plane_state
*state
,
2453 const struct drm_i915_private
*dev_priv
= to_i915(state
->base
.plane
->dev
);
2454 const struct drm_framebuffer
*fb
= state
->base
.fb
;
2455 unsigned int rotation
= state
->base
.rotation
;
2456 int pitch
= intel_fb_pitch(fb
, plane
, rotation
);
2459 /* AUX_DIST needs only 4K alignment */
2460 if (fb
->pixel_format
== DRM_FORMAT_NV12
&& plane
== 1)
2463 alignment
= intel_surf_alignment(dev_priv
, fb
->modifier
[plane
]);
2465 return _intel_compute_tile_offset(dev_priv
, x
, y
, fb
, plane
, pitch
,
2466 rotation
, alignment
);
2469 /* Convert the fb->offset[] linear offset into x/y offsets */
2470 static void intel_fb_offset_to_xy(int *x
, int *y
,
2471 const struct drm_framebuffer
*fb
, int plane
)
2473 unsigned int cpp
= drm_format_plane_cpp(fb
->pixel_format
, plane
);
2474 unsigned int pitch
= fb
->pitches
[plane
];
2475 u32 linear_offset
= fb
->offsets
[plane
];
2477 *y
= linear_offset
/ pitch
;
2478 *x
= linear_offset
% pitch
/ cpp
;
2481 static unsigned int intel_fb_modifier_to_tiling(uint64_t fb_modifier
)
2483 switch (fb_modifier
) {
2484 case I915_FORMAT_MOD_X_TILED
:
2485 return I915_TILING_X
;
2486 case I915_FORMAT_MOD_Y_TILED
:
2487 return I915_TILING_Y
;
2489 return I915_TILING_NONE
;
2494 intel_fill_fb_info(struct drm_i915_private
*dev_priv
,
2495 struct drm_framebuffer
*fb
)
2497 struct intel_framebuffer
*intel_fb
= to_intel_framebuffer(fb
);
2498 struct intel_rotation_info
*rot_info
= &intel_fb
->rot_info
;
2499 u32 gtt_offset_rotated
= 0;
2500 unsigned int max_size
= 0;
2501 uint32_t format
= fb
->pixel_format
;
2502 int i
, num_planes
= drm_format_num_planes(format
);
2503 unsigned int tile_size
= intel_tile_size(dev_priv
);
2505 for (i
= 0; i
< num_planes
; i
++) {
2506 unsigned int width
, height
;
2507 unsigned int cpp
, size
;
2511 cpp
= drm_format_plane_cpp(format
, i
);
2512 width
= drm_format_plane_width(fb
->width
, format
, i
);
2513 height
= drm_format_plane_height(fb
->height
, format
, i
);
2515 intel_fb_offset_to_xy(&x
, &y
, fb
, i
);
2518 * The fence (if used) is aligned to the start of the object
2519 * so having the framebuffer wrap around across the edge of the
2520 * fenced region doesn't really work. We have no API to configure
2521 * the fence start offset within the object (nor could we probably
2522 * on gen2/3). So it's just easier if we just require that the
2523 * fb layout agrees with the fence layout. We already check that the
2524 * fb stride matches the fence stride elsewhere.
2526 if (i915_gem_object_is_tiled(intel_fb
->obj
) &&
2527 (x
+ width
) * cpp
> fb
->pitches
[i
]) {
2528 DRM_DEBUG("bad fb plane %d offset: 0x%x\n",
2534 * First pixel of the framebuffer from
2535 * the start of the normal gtt mapping.
2537 intel_fb
->normal
[i
].x
= x
;
2538 intel_fb
->normal
[i
].y
= y
;
2540 offset
= _intel_compute_tile_offset(dev_priv
, &x
, &y
,
2541 fb
, 0, fb
->pitches
[i
],
2542 DRM_ROTATE_0
, tile_size
);
2543 offset
/= tile_size
;
2545 if (fb
->modifier
[i
] != DRM_FORMAT_MOD_NONE
) {
2546 unsigned int tile_width
, tile_height
;
2547 unsigned int pitch_tiles
;
2550 intel_tile_dims(dev_priv
, &tile_width
, &tile_height
,
2551 fb
->modifier
[i
], cpp
);
2553 rot_info
->plane
[i
].offset
= offset
;
2554 rot_info
->plane
[i
].stride
= DIV_ROUND_UP(fb
->pitches
[i
], tile_width
* cpp
);
2555 rot_info
->plane
[i
].width
= DIV_ROUND_UP(x
+ width
, tile_width
);
2556 rot_info
->plane
[i
].height
= DIV_ROUND_UP(y
+ height
, tile_height
);
2558 intel_fb
->rotated
[i
].pitch
=
2559 rot_info
->plane
[i
].height
* tile_height
;
2561 /* how many tiles does this plane need */
2562 size
= rot_info
->plane
[i
].stride
* rot_info
->plane
[i
].height
;
2564 * If the plane isn't horizontally tile aligned,
2565 * we need one more tile.
2570 /* rotate the x/y offsets to match the GTT view */
2576 rot_info
->plane
[i
].width
* tile_width
,
2577 rot_info
->plane
[i
].height
* tile_height
,
2582 /* rotate the tile dimensions to match the GTT view */
2583 pitch_tiles
= intel_fb
->rotated
[i
].pitch
/ tile_height
;
2584 swap(tile_width
, tile_height
);
2587 * We only keep the x/y offsets, so push all of the
2588 * gtt offset into the x/y offsets.
2590 _intel_adjust_tile_offset(&x
, &y
, tile_size
,
2591 tile_width
, tile_height
, pitch_tiles
,
2592 gtt_offset_rotated
* tile_size
, 0);
2594 gtt_offset_rotated
+= rot_info
->plane
[i
].width
* rot_info
->plane
[i
].height
;
2597 * First pixel of the framebuffer from
2598 * the start of the rotated gtt mapping.
2600 intel_fb
->rotated
[i
].x
= x
;
2601 intel_fb
->rotated
[i
].y
= y
;
2603 size
= DIV_ROUND_UP((y
+ height
) * fb
->pitches
[i
] +
2604 x
* cpp
, tile_size
);
2607 /* how many tiles in total needed in the bo */
2608 max_size
= max(max_size
, offset
+ size
);
2611 if (max_size
* tile_size
> to_intel_framebuffer(fb
)->obj
->base
.size
) {
2612 DRM_DEBUG("fb too big for bo (need %u bytes, have %zu bytes)\n",
2613 max_size
* tile_size
, to_intel_framebuffer(fb
)->obj
->base
.size
);
2620 static int i9xx_format_to_fourcc(int format
)
2623 case DISPPLANE_8BPP
:
2624 return DRM_FORMAT_C8
;
2625 case DISPPLANE_BGRX555
:
2626 return DRM_FORMAT_XRGB1555
;
2627 case DISPPLANE_BGRX565
:
2628 return DRM_FORMAT_RGB565
;
2630 case DISPPLANE_BGRX888
:
2631 return DRM_FORMAT_XRGB8888
;
2632 case DISPPLANE_RGBX888
:
2633 return DRM_FORMAT_XBGR8888
;
2634 case DISPPLANE_BGRX101010
:
2635 return DRM_FORMAT_XRGB2101010
;
2636 case DISPPLANE_RGBX101010
:
2637 return DRM_FORMAT_XBGR2101010
;
2641 static int skl_format_to_fourcc(int format
, bool rgb_order
, bool alpha
)
2644 case PLANE_CTL_FORMAT_RGB_565
:
2645 return DRM_FORMAT_RGB565
;
2647 case PLANE_CTL_FORMAT_XRGB_8888
:
2650 return DRM_FORMAT_ABGR8888
;
2652 return DRM_FORMAT_XBGR8888
;
2655 return DRM_FORMAT_ARGB8888
;
2657 return DRM_FORMAT_XRGB8888
;
2659 case PLANE_CTL_FORMAT_XRGB_2101010
:
2661 return DRM_FORMAT_XBGR2101010
;
2663 return DRM_FORMAT_XRGB2101010
;
2668 intel_alloc_initial_plane_obj(struct intel_crtc
*crtc
,
2669 struct intel_initial_plane_config
*plane_config
)
2671 struct drm_device
*dev
= crtc
->base
.dev
;
2672 struct drm_i915_private
*dev_priv
= to_i915(dev
);
2673 struct i915_ggtt
*ggtt
= &dev_priv
->ggtt
;
2674 struct drm_i915_gem_object
*obj
= NULL
;
2675 struct drm_mode_fb_cmd2 mode_cmd
= { 0 };
2676 struct drm_framebuffer
*fb
= &plane_config
->fb
->base
;
2677 u32 base_aligned
= round_down(plane_config
->base
, PAGE_SIZE
);
2678 u32 size_aligned
= round_up(plane_config
->base
+ plane_config
->size
,
2681 size_aligned
-= base_aligned
;
2683 if (plane_config
->size
== 0)
2686 /* If the FB is too big, just don't use it since fbdev is not very
2687 * important and we should probably use that space with FBC or other
2689 if (size_aligned
* 2 > ggtt
->stolen_usable_size
)
2692 mutex_lock(&dev
->struct_mutex
);
2694 obj
= i915_gem_object_create_stolen_for_preallocated(dev
,
2699 mutex_unlock(&dev
->struct_mutex
);
2703 if (plane_config
->tiling
== I915_TILING_X
)
2704 obj
->tiling_and_stride
= fb
->pitches
[0] | I915_TILING_X
;
2706 mode_cmd
.pixel_format
= fb
->pixel_format
;
2707 mode_cmd
.width
= fb
->width
;
2708 mode_cmd
.height
= fb
->height
;
2709 mode_cmd
.pitches
[0] = fb
->pitches
[0];
2710 mode_cmd
.modifier
[0] = fb
->modifier
[0];
2711 mode_cmd
.flags
= DRM_MODE_FB_MODIFIERS
;
2713 if (intel_framebuffer_init(dev
, to_intel_framebuffer(fb
),
2715 DRM_DEBUG_KMS("intel fb init failed\n");
2719 mutex_unlock(&dev
->struct_mutex
);
2721 DRM_DEBUG_KMS("initial plane fb obj %p\n", obj
);
2725 i915_gem_object_put(obj
);
2726 mutex_unlock(&dev
->struct_mutex
);
2730 /* Update plane->state->fb to match plane->fb after driver-internal updates */
2732 update_state_fb(struct drm_plane
*plane
)
2734 if (plane
->fb
== plane
->state
->fb
)
2737 if (plane
->state
->fb
)
2738 drm_framebuffer_unreference(plane
->state
->fb
);
2739 plane
->state
->fb
= plane
->fb
;
2740 if (plane
->state
->fb
)
2741 drm_framebuffer_reference(plane
->state
->fb
);
2745 intel_find_initial_plane_obj(struct intel_crtc
*intel_crtc
,
2746 struct intel_initial_plane_config
*plane_config
)
2748 struct drm_device
*dev
= intel_crtc
->base
.dev
;
2749 struct drm_i915_private
*dev_priv
= to_i915(dev
);
2751 struct intel_crtc
*i
;
2752 struct drm_i915_gem_object
*obj
;
2753 struct drm_plane
*primary
= intel_crtc
->base
.primary
;
2754 struct drm_plane_state
*plane_state
= primary
->state
;
2755 struct drm_crtc_state
*crtc_state
= intel_crtc
->base
.state
;
2756 struct intel_plane
*intel_plane
= to_intel_plane(primary
);
2757 struct intel_plane_state
*intel_state
=
2758 to_intel_plane_state(plane_state
);
2759 struct drm_framebuffer
*fb
;
2761 if (!plane_config
->fb
)
2764 if (intel_alloc_initial_plane_obj(intel_crtc
, plane_config
)) {
2765 fb
= &plane_config
->fb
->base
;
2769 kfree(plane_config
->fb
);
2772 * Failed to alloc the obj, check to see if we should share
2773 * an fb with another CRTC instead
2775 for_each_crtc(dev
, c
) {
2776 i
= to_intel_crtc(c
);
2778 if (c
== &intel_crtc
->base
)
2784 fb
= c
->primary
->fb
;
2788 obj
= intel_fb_obj(fb
);
2789 if (i915_gem_object_ggtt_offset(obj
, NULL
) == plane_config
->base
) {
2790 drm_framebuffer_reference(fb
);
2796 * We've failed to reconstruct the BIOS FB. Current display state
2797 * indicates that the primary plane is visible, but has a NULL FB,
2798 * which will lead to problems later if we don't fix it up. The
2799 * simplest solution is to just disable the primary plane now and
2800 * pretend the BIOS never had it enabled.
2802 to_intel_plane_state(plane_state
)->base
.visible
= false;
2803 crtc_state
->plane_mask
&= ~(1 << drm_plane_index(primary
));
2804 intel_pre_disable_primary_noatomic(&intel_crtc
->base
);
2805 intel_plane
->disable_plane(primary
, &intel_crtc
->base
);
2810 plane_state
->src_x
= 0;
2811 plane_state
->src_y
= 0;
2812 plane_state
->src_w
= fb
->width
<< 16;
2813 plane_state
->src_h
= fb
->height
<< 16;
2815 plane_state
->crtc_x
= 0;
2816 plane_state
->crtc_y
= 0;
2817 plane_state
->crtc_w
= fb
->width
;
2818 plane_state
->crtc_h
= fb
->height
;
2820 intel_state
->base
.src
.x1
= plane_state
->src_x
;
2821 intel_state
->base
.src
.y1
= plane_state
->src_y
;
2822 intel_state
->base
.src
.x2
= plane_state
->src_x
+ plane_state
->src_w
;
2823 intel_state
->base
.src
.y2
= plane_state
->src_y
+ plane_state
->src_h
;
2824 intel_state
->base
.dst
.x1
= plane_state
->crtc_x
;
2825 intel_state
->base
.dst
.y1
= plane_state
->crtc_y
;
2826 intel_state
->base
.dst
.x2
= plane_state
->crtc_x
+ plane_state
->crtc_w
;
2827 intel_state
->base
.dst
.y2
= plane_state
->crtc_y
+ plane_state
->crtc_h
;
2829 obj
= intel_fb_obj(fb
);
2830 if (i915_gem_object_is_tiled(obj
))
2831 dev_priv
->preserve_bios_swizzle
= true;
2833 drm_framebuffer_reference(fb
);
2834 primary
->fb
= primary
->state
->fb
= fb
;
2835 primary
->crtc
= primary
->state
->crtc
= &intel_crtc
->base
;
2836 intel_crtc
->base
.state
->plane_mask
|= (1 << drm_plane_index(primary
));
2837 atomic_or(to_intel_plane(primary
)->frontbuffer_bit
,
2838 &obj
->frontbuffer_bits
);
2841 static int skl_max_plane_width(const struct drm_framebuffer
*fb
, int plane
,
2842 unsigned int rotation
)
2844 int cpp
= drm_format_plane_cpp(fb
->pixel_format
, plane
);
2846 switch (fb
->modifier
[plane
]) {
2847 case DRM_FORMAT_MOD_NONE
:
2848 case I915_FORMAT_MOD_X_TILED
:
2861 case I915_FORMAT_MOD_Y_TILED
:
2862 case I915_FORMAT_MOD_Yf_TILED
:
2877 MISSING_CASE(fb
->modifier
[plane
]);
2883 static int skl_check_main_surface(struct intel_plane_state
*plane_state
)
2885 const struct drm_i915_private
*dev_priv
= to_i915(plane_state
->base
.plane
->dev
);
2886 const struct drm_framebuffer
*fb
= plane_state
->base
.fb
;
2887 unsigned int rotation
= plane_state
->base
.rotation
;
2888 int x
= plane_state
->base
.src
.x1
>> 16;
2889 int y
= plane_state
->base
.src
.y1
>> 16;
2890 int w
= drm_rect_width(&plane_state
->base
.src
) >> 16;
2891 int h
= drm_rect_height(&plane_state
->base
.src
) >> 16;
2892 int max_width
= skl_max_plane_width(fb
, 0, rotation
);
2893 int max_height
= 4096;
2894 u32 alignment
, offset
, aux_offset
= plane_state
->aux
.offset
;
2896 if (w
> max_width
|| h
> max_height
) {
2897 DRM_DEBUG_KMS("requested Y/RGB source size %dx%d too big (limit %dx%d)\n",
2898 w
, h
, max_width
, max_height
);
2902 intel_add_fb_offsets(&x
, &y
, plane_state
, 0);
2903 offset
= intel_compute_tile_offset(&x
, &y
, plane_state
, 0);
2905 alignment
= intel_surf_alignment(dev_priv
, fb
->modifier
[0]);
2908 * AUX surface offset is specified as the distance from the
2909 * main surface offset, and it must be non-negative. Make
2910 * sure that is what we will get.
2912 if (offset
> aux_offset
)
2913 offset
= intel_adjust_tile_offset(&x
, &y
, plane_state
, 0,
2914 offset
, aux_offset
& ~(alignment
- 1));
2917 * When using an X-tiled surface, the plane blows up
2918 * if the x offset + width exceed the stride.
2920 * TODO: linear and Y-tiled seem fine, Yf untested,
2922 if (fb
->modifier
[0] == I915_FORMAT_MOD_X_TILED
) {
2923 int cpp
= drm_format_plane_cpp(fb
->pixel_format
, 0);
2925 while ((x
+ w
) * cpp
> fb
->pitches
[0]) {
2927 DRM_DEBUG_KMS("Unable to find suitable display surface offset\n");
2931 offset
= intel_adjust_tile_offset(&x
, &y
, plane_state
, 0,
2932 offset
, offset
- alignment
);
2936 plane_state
->main
.offset
= offset
;
2937 plane_state
->main
.x
= x
;
2938 plane_state
->main
.y
= y
;
2943 static int skl_check_nv12_aux_surface(struct intel_plane_state
*plane_state
)
2945 const struct drm_framebuffer
*fb
= plane_state
->base
.fb
;
2946 unsigned int rotation
= plane_state
->base
.rotation
;
2947 int max_width
= skl_max_plane_width(fb
, 1, rotation
);
2948 int max_height
= 4096;
2949 int x
= plane_state
->base
.src
.x1
>> 17;
2950 int y
= plane_state
->base
.src
.y1
>> 17;
2951 int w
= drm_rect_width(&plane_state
->base
.src
) >> 17;
2952 int h
= drm_rect_height(&plane_state
->base
.src
) >> 17;
2955 intel_add_fb_offsets(&x
, &y
, plane_state
, 1);
2956 offset
= intel_compute_tile_offset(&x
, &y
, plane_state
, 1);
2958 /* FIXME not quite sure how/if these apply to the chroma plane */
2959 if (w
> max_width
|| h
> max_height
) {
2960 DRM_DEBUG_KMS("CbCr source size %dx%d too big (limit %dx%d)\n",
2961 w
, h
, max_width
, max_height
);
2965 plane_state
->aux
.offset
= offset
;
2966 plane_state
->aux
.x
= x
;
2967 plane_state
->aux
.y
= y
;
2972 int skl_check_plane_surface(struct intel_plane_state
*plane_state
)
2974 const struct drm_framebuffer
*fb
= plane_state
->base
.fb
;
2975 unsigned int rotation
= plane_state
->base
.rotation
;
2978 /* Rotate src coordinates to match rotated GTT view */
2979 if (intel_rotation_90_or_270(rotation
))
2980 drm_rect_rotate(&plane_state
->base
.src
,
2981 fb
->width
, fb
->height
, DRM_ROTATE_270
);
2984 * Handle the AUX surface first since
2985 * the main surface setup depends on it.
2987 if (fb
->pixel_format
== DRM_FORMAT_NV12
) {
2988 ret
= skl_check_nv12_aux_surface(plane_state
);
2992 plane_state
->aux
.offset
= ~0xfff;
2993 plane_state
->aux
.x
= 0;
2994 plane_state
->aux
.y
= 0;
2997 ret
= skl_check_main_surface(plane_state
);
3004 static void i9xx_update_primary_plane(struct drm_plane
*primary
,
3005 const struct intel_crtc_state
*crtc_state
,
3006 const struct intel_plane_state
*plane_state
)
3008 struct drm_device
*dev
= primary
->dev
;
3009 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3010 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc_state
->base
.crtc
);
3011 struct drm_framebuffer
*fb
= plane_state
->base
.fb
;
3012 struct drm_i915_gem_object
*obj
= intel_fb_obj(fb
);
3013 int plane
= intel_crtc
->plane
;
3016 i915_reg_t reg
= DSPCNTR(plane
);
3017 unsigned int rotation
= plane_state
->base
.rotation
;
3018 int x
= plane_state
->base
.src
.x1
>> 16;
3019 int y
= plane_state
->base
.src
.y1
>> 16;
3021 dspcntr
= DISPPLANE_GAMMA_ENABLE
;
3023 dspcntr
|= DISPLAY_PLANE_ENABLE
;
3025 if (INTEL_INFO(dev
)->gen
< 4) {
3026 if (intel_crtc
->pipe
== PIPE_B
)
3027 dspcntr
|= DISPPLANE_SEL_PIPE_B
;
3029 /* pipesrc and dspsize control the size that is scaled from,
3030 * which should always be the user's requested size.
3032 I915_WRITE(DSPSIZE(plane
),
3033 ((crtc_state
->pipe_src_h
- 1) << 16) |
3034 (crtc_state
->pipe_src_w
- 1));
3035 I915_WRITE(DSPPOS(plane
), 0);
3036 } else if (IS_CHERRYVIEW(dev
) && plane
== PLANE_B
) {
3037 I915_WRITE(PRIMSIZE(plane
),
3038 ((crtc_state
->pipe_src_h
- 1) << 16) |
3039 (crtc_state
->pipe_src_w
- 1));
3040 I915_WRITE(PRIMPOS(plane
), 0);
3041 I915_WRITE(PRIMCNSTALPHA(plane
), 0);
3044 switch (fb
->pixel_format
) {
3046 dspcntr
|= DISPPLANE_8BPP
;
3048 case DRM_FORMAT_XRGB1555
:
3049 dspcntr
|= DISPPLANE_BGRX555
;
3051 case DRM_FORMAT_RGB565
:
3052 dspcntr
|= DISPPLANE_BGRX565
;
3054 case DRM_FORMAT_XRGB8888
:
3055 dspcntr
|= DISPPLANE_BGRX888
;
3057 case DRM_FORMAT_XBGR8888
:
3058 dspcntr
|= DISPPLANE_RGBX888
;
3060 case DRM_FORMAT_XRGB2101010
:
3061 dspcntr
|= DISPPLANE_BGRX101010
;
3063 case DRM_FORMAT_XBGR2101010
:
3064 dspcntr
|= DISPPLANE_RGBX101010
;
3070 if (INTEL_GEN(dev_priv
) >= 4 &&
3071 fb
->modifier
[0] == I915_FORMAT_MOD_X_TILED
)
3072 dspcntr
|= DISPPLANE_TILED
;
3075 dspcntr
|= DISPPLANE_TRICKLE_FEED_DISABLE
;
3077 intel_add_fb_offsets(&x
, &y
, plane_state
, 0);
3079 if (INTEL_INFO(dev
)->gen
>= 4)
3080 intel_crtc
->dspaddr_offset
=
3081 intel_compute_tile_offset(&x
, &y
, plane_state
, 0);
3083 if (rotation
== DRM_ROTATE_180
) {
3084 dspcntr
|= DISPPLANE_ROTATE_180
;
3086 x
+= (crtc_state
->pipe_src_w
- 1);
3087 y
+= (crtc_state
->pipe_src_h
- 1);
3090 linear_offset
= intel_fb_xy_to_linear(x
, y
, plane_state
, 0);
3092 if (INTEL_INFO(dev
)->gen
< 4)
3093 intel_crtc
->dspaddr_offset
= linear_offset
;
3095 intel_crtc
->adjusted_x
= x
;
3096 intel_crtc
->adjusted_y
= y
;
3098 I915_WRITE(reg
, dspcntr
);
3100 I915_WRITE(DSPSTRIDE(plane
), fb
->pitches
[0]);
3101 if (INTEL_INFO(dev
)->gen
>= 4) {
3102 I915_WRITE(DSPSURF(plane
),
3103 intel_fb_gtt_offset(fb
, rotation
) +
3104 intel_crtc
->dspaddr_offset
);
3105 I915_WRITE(DSPTILEOFF(plane
), (y
<< 16) | x
);
3106 I915_WRITE(DSPLINOFF(plane
), linear_offset
);
3108 I915_WRITE(DSPADDR(plane
), i915_gem_object_ggtt_offset(obj
, NULL
) + linear_offset
);
3112 static void i9xx_disable_primary_plane(struct drm_plane
*primary
,
3113 struct drm_crtc
*crtc
)
3115 struct drm_device
*dev
= crtc
->dev
;
3116 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3117 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
3118 int plane
= intel_crtc
->plane
;
3120 I915_WRITE(DSPCNTR(plane
), 0);
3121 if (INTEL_INFO(dev_priv
)->gen
>= 4)
3122 I915_WRITE(DSPSURF(plane
), 0);
3124 I915_WRITE(DSPADDR(plane
), 0);
3125 POSTING_READ(DSPCNTR(plane
));
3128 static void ironlake_update_primary_plane(struct drm_plane
*primary
,
3129 const struct intel_crtc_state
*crtc_state
,
3130 const struct intel_plane_state
*plane_state
)
3132 struct drm_device
*dev
= primary
->dev
;
3133 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3134 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc_state
->base
.crtc
);
3135 struct drm_framebuffer
*fb
= plane_state
->base
.fb
;
3136 int plane
= intel_crtc
->plane
;
3139 i915_reg_t reg
= DSPCNTR(plane
);
3140 unsigned int rotation
= plane_state
->base
.rotation
;
3141 int x
= plane_state
->base
.src
.x1
>> 16;
3142 int y
= plane_state
->base
.src
.y1
>> 16;
3144 dspcntr
= DISPPLANE_GAMMA_ENABLE
;
3145 dspcntr
|= DISPLAY_PLANE_ENABLE
;
3147 if (IS_HASWELL(dev
) || IS_BROADWELL(dev
))
3148 dspcntr
|= DISPPLANE_PIPE_CSC_ENABLE
;
3150 switch (fb
->pixel_format
) {
3152 dspcntr
|= DISPPLANE_8BPP
;
3154 case DRM_FORMAT_RGB565
:
3155 dspcntr
|= DISPPLANE_BGRX565
;
3157 case DRM_FORMAT_XRGB8888
:
3158 dspcntr
|= DISPPLANE_BGRX888
;
3160 case DRM_FORMAT_XBGR8888
:
3161 dspcntr
|= DISPPLANE_RGBX888
;
3163 case DRM_FORMAT_XRGB2101010
:
3164 dspcntr
|= DISPPLANE_BGRX101010
;
3166 case DRM_FORMAT_XBGR2101010
:
3167 dspcntr
|= DISPPLANE_RGBX101010
;
3173 if (fb
->modifier
[0] == I915_FORMAT_MOD_X_TILED
)
3174 dspcntr
|= DISPPLANE_TILED
;
3176 if (!IS_HASWELL(dev
) && !IS_BROADWELL(dev
))
3177 dspcntr
|= DISPPLANE_TRICKLE_FEED_DISABLE
;
3179 intel_add_fb_offsets(&x
, &y
, plane_state
, 0);
3181 intel_crtc
->dspaddr_offset
=
3182 intel_compute_tile_offset(&x
, &y
, plane_state
, 0);
3184 if (rotation
== DRM_ROTATE_180
) {
3185 dspcntr
|= DISPPLANE_ROTATE_180
;
3187 if (!IS_HASWELL(dev
) && !IS_BROADWELL(dev
)) {
3188 x
+= (crtc_state
->pipe_src_w
- 1);
3189 y
+= (crtc_state
->pipe_src_h
- 1);
3193 linear_offset
= intel_fb_xy_to_linear(x
, y
, plane_state
, 0);
3195 intel_crtc
->adjusted_x
= x
;
3196 intel_crtc
->adjusted_y
= y
;
3198 I915_WRITE(reg
, dspcntr
);
3200 I915_WRITE(DSPSTRIDE(plane
), fb
->pitches
[0]);
3201 I915_WRITE(DSPSURF(plane
),
3202 intel_fb_gtt_offset(fb
, rotation
) +
3203 intel_crtc
->dspaddr_offset
);
3204 if (IS_HASWELL(dev
) || IS_BROADWELL(dev
)) {
3205 I915_WRITE(DSPOFFSET(plane
), (y
<< 16) | x
);
3207 I915_WRITE(DSPTILEOFF(plane
), (y
<< 16) | x
);
3208 I915_WRITE(DSPLINOFF(plane
), linear_offset
);
3213 u32
intel_fb_stride_alignment(const struct drm_i915_private
*dev_priv
,
3214 uint64_t fb_modifier
, uint32_t pixel_format
)
3216 if (fb_modifier
== DRM_FORMAT_MOD_NONE
) {
3219 int cpp
= drm_format_plane_cpp(pixel_format
, 0);
3221 return intel_tile_width_bytes(dev_priv
, fb_modifier
, cpp
);
3225 u32
intel_fb_gtt_offset(struct drm_framebuffer
*fb
,
3226 unsigned int rotation
)
3228 struct drm_i915_gem_object
*obj
= intel_fb_obj(fb
);
3229 struct i915_ggtt_view view
;
3230 struct i915_vma
*vma
;
3232 intel_fill_fb_ggtt_view(&view
, fb
, rotation
);
3234 vma
= i915_gem_object_to_ggtt(obj
, &view
);
3235 if (WARN(!vma
, "ggtt vma for display object not found! (view=%u)\n",
3239 return i915_ggtt_offset(vma
);
3242 static void skl_detach_scaler(struct intel_crtc
*intel_crtc
, int id
)
3244 struct drm_device
*dev
= intel_crtc
->base
.dev
;
3245 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3247 I915_WRITE(SKL_PS_CTRL(intel_crtc
->pipe
, id
), 0);
3248 I915_WRITE(SKL_PS_WIN_POS(intel_crtc
->pipe
, id
), 0);
3249 I915_WRITE(SKL_PS_WIN_SZ(intel_crtc
->pipe
, id
), 0);
3253 * This function detaches (aka. unbinds) unused scalers in hardware
3255 static void skl_detach_scalers(struct intel_crtc
*intel_crtc
)
3257 struct intel_crtc_scaler_state
*scaler_state
;
3260 scaler_state
= &intel_crtc
->config
->scaler_state
;
3262 /* loop through and disable scalers that aren't in use */
3263 for (i
= 0; i
< intel_crtc
->num_scalers
; i
++) {
3264 if (!scaler_state
->scalers
[i
].in_use
)
3265 skl_detach_scaler(intel_crtc
, i
);
3269 u32
skl_plane_stride(const struct drm_framebuffer
*fb
, int plane
,
3270 unsigned int rotation
)
3272 const struct drm_i915_private
*dev_priv
= to_i915(fb
->dev
);
3273 u32 stride
= intel_fb_pitch(fb
, plane
, rotation
);
3276 * The stride is either expressed as a multiple of 64 bytes chunks for
3277 * linear buffers or in number of tiles for tiled buffers.
3279 if (intel_rotation_90_or_270(rotation
)) {
3280 int cpp
= drm_format_plane_cpp(fb
->pixel_format
, plane
);
3282 stride
/= intel_tile_height(dev_priv
, fb
->modifier
[0], cpp
);
3284 stride
/= intel_fb_stride_alignment(dev_priv
, fb
->modifier
[0],
3291 u32
skl_plane_ctl_format(uint32_t pixel_format
)
3293 switch (pixel_format
) {
3295 return PLANE_CTL_FORMAT_INDEXED
;
3296 case DRM_FORMAT_RGB565
:
3297 return PLANE_CTL_FORMAT_RGB_565
;
3298 case DRM_FORMAT_XBGR8888
:
3299 return PLANE_CTL_FORMAT_XRGB_8888
| PLANE_CTL_ORDER_RGBX
;
3300 case DRM_FORMAT_XRGB8888
:
3301 return PLANE_CTL_FORMAT_XRGB_8888
;
3303 * XXX: For ARBG/ABGR formats we default to expecting scanout buffers
3304 * to be already pre-multiplied. We need to add a knob (or a different
3305 * DRM_FORMAT) for user-space to configure that.
3307 case DRM_FORMAT_ABGR8888
:
3308 return PLANE_CTL_FORMAT_XRGB_8888
| PLANE_CTL_ORDER_RGBX
|
3309 PLANE_CTL_ALPHA_SW_PREMULTIPLY
;
3310 case DRM_FORMAT_ARGB8888
:
3311 return PLANE_CTL_FORMAT_XRGB_8888
|
3312 PLANE_CTL_ALPHA_SW_PREMULTIPLY
;
3313 case DRM_FORMAT_XRGB2101010
:
3314 return PLANE_CTL_FORMAT_XRGB_2101010
;
3315 case DRM_FORMAT_XBGR2101010
:
3316 return PLANE_CTL_ORDER_RGBX
| PLANE_CTL_FORMAT_XRGB_2101010
;
3317 case DRM_FORMAT_YUYV
:
3318 return PLANE_CTL_FORMAT_YUV422
| PLANE_CTL_YUV422_YUYV
;
3319 case DRM_FORMAT_YVYU
:
3320 return PLANE_CTL_FORMAT_YUV422
| PLANE_CTL_YUV422_YVYU
;
3321 case DRM_FORMAT_UYVY
:
3322 return PLANE_CTL_FORMAT_YUV422
| PLANE_CTL_YUV422_UYVY
;
3323 case DRM_FORMAT_VYUY
:
3324 return PLANE_CTL_FORMAT_YUV422
| PLANE_CTL_YUV422_VYUY
;
3326 MISSING_CASE(pixel_format
);
3332 u32
skl_plane_ctl_tiling(uint64_t fb_modifier
)
3334 switch (fb_modifier
) {
3335 case DRM_FORMAT_MOD_NONE
:
3337 case I915_FORMAT_MOD_X_TILED
:
3338 return PLANE_CTL_TILED_X
;
3339 case I915_FORMAT_MOD_Y_TILED
:
3340 return PLANE_CTL_TILED_Y
;
3341 case I915_FORMAT_MOD_Yf_TILED
:
3342 return PLANE_CTL_TILED_YF
;
3344 MISSING_CASE(fb_modifier
);
3350 u32
skl_plane_ctl_rotation(unsigned int rotation
)
3356 * DRM_ROTATE_ is counter clockwise to stay compatible with Xrandr
3357 * while i915 HW rotation is clockwise, thats why this swapping.
3360 return PLANE_CTL_ROTATE_270
;
3361 case DRM_ROTATE_180
:
3362 return PLANE_CTL_ROTATE_180
;
3363 case DRM_ROTATE_270
:
3364 return PLANE_CTL_ROTATE_90
;
3366 MISSING_CASE(rotation
);
3372 static void skylake_update_primary_plane(struct drm_plane
*plane
,
3373 const struct intel_crtc_state
*crtc_state
,
3374 const struct intel_plane_state
*plane_state
)
3376 struct drm_device
*dev
= plane
->dev
;
3377 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3378 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc_state
->base
.crtc
);
3379 struct drm_framebuffer
*fb
= plane_state
->base
.fb
;
3380 int pipe
= intel_crtc
->pipe
;
3382 unsigned int rotation
= plane_state
->base
.rotation
;
3383 u32 stride
= skl_plane_stride(fb
, 0, rotation
);
3384 u32 surf_addr
= plane_state
->main
.offset
;
3385 int scaler_id
= plane_state
->scaler_id
;
3386 int src_x
= plane_state
->main
.x
;
3387 int src_y
= plane_state
->main
.y
;
3388 int src_w
= drm_rect_width(&plane_state
->base
.src
) >> 16;
3389 int src_h
= drm_rect_height(&plane_state
->base
.src
) >> 16;
3390 int dst_x
= plane_state
->base
.dst
.x1
;
3391 int dst_y
= plane_state
->base
.dst
.y1
;
3392 int dst_w
= drm_rect_width(&plane_state
->base
.dst
);
3393 int dst_h
= drm_rect_height(&plane_state
->base
.dst
);
3395 plane_ctl
= PLANE_CTL_ENABLE
|
3396 PLANE_CTL_PIPE_GAMMA_ENABLE
|
3397 PLANE_CTL_PIPE_CSC_ENABLE
;
3399 plane_ctl
|= skl_plane_ctl_format(fb
->pixel_format
);
3400 plane_ctl
|= skl_plane_ctl_tiling(fb
->modifier
[0]);
3401 plane_ctl
|= PLANE_CTL_PLANE_GAMMA_DISABLE
;
3402 plane_ctl
|= skl_plane_ctl_rotation(rotation
);
3404 /* Sizes are 0 based */
3410 intel_crtc
->adjusted_x
= src_x
;
3411 intel_crtc
->adjusted_y
= src_y
;
3413 I915_WRITE(PLANE_CTL(pipe
, 0), plane_ctl
);
3414 I915_WRITE(PLANE_OFFSET(pipe
, 0), (src_y
<< 16) | src_x
);
3415 I915_WRITE(PLANE_STRIDE(pipe
, 0), stride
);
3416 I915_WRITE(PLANE_SIZE(pipe
, 0), (src_h
<< 16) | src_w
);
3418 if (scaler_id
>= 0) {
3419 uint32_t ps_ctrl
= 0;
3421 WARN_ON(!dst_w
|| !dst_h
);
3422 ps_ctrl
= PS_SCALER_EN
| PS_PLANE_SEL(0) |
3423 crtc_state
->scaler_state
.scalers
[scaler_id
].mode
;
3424 I915_WRITE(SKL_PS_CTRL(pipe
, scaler_id
), ps_ctrl
);
3425 I915_WRITE(SKL_PS_PWR_GATE(pipe
, scaler_id
), 0);
3426 I915_WRITE(SKL_PS_WIN_POS(pipe
, scaler_id
), (dst_x
<< 16) | dst_y
);
3427 I915_WRITE(SKL_PS_WIN_SZ(pipe
, scaler_id
), (dst_w
<< 16) | dst_h
);
3428 I915_WRITE(PLANE_POS(pipe
, 0), 0);
3430 I915_WRITE(PLANE_POS(pipe
, 0), (dst_y
<< 16) | dst_x
);
3433 I915_WRITE(PLANE_SURF(pipe
, 0),
3434 intel_fb_gtt_offset(fb
, rotation
) + surf_addr
);
3436 POSTING_READ(PLANE_SURF(pipe
, 0));
3439 static void skylake_disable_primary_plane(struct drm_plane
*primary
,
3440 struct drm_crtc
*crtc
)
3442 struct drm_device
*dev
= crtc
->dev
;
3443 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3444 int pipe
= to_intel_crtc(crtc
)->pipe
;
3446 I915_WRITE(PLANE_CTL(pipe
, 0), 0);
3447 I915_WRITE(PLANE_SURF(pipe
, 0), 0);
3448 POSTING_READ(PLANE_SURF(pipe
, 0));
3451 /* Assume fb object is pinned & idle & fenced and just update base pointers */
3453 intel_pipe_set_base_atomic(struct drm_crtc
*crtc
, struct drm_framebuffer
*fb
,
3454 int x
, int y
, enum mode_set_atomic state
)
3456 /* Support for kgdboc is disabled, this needs a major rework. */
3457 DRM_ERROR("legacy panic handler not supported any more.\n");
3462 static void intel_complete_page_flips(struct drm_i915_private
*dev_priv
)
3464 struct intel_crtc
*crtc
;
3466 for_each_intel_crtc(&dev_priv
->drm
, crtc
)
3467 intel_finish_page_flip_cs(dev_priv
, crtc
->pipe
);
3470 static void intel_update_primary_planes(struct drm_device
*dev
)
3472 struct drm_crtc
*crtc
;
3474 for_each_crtc(dev
, crtc
) {
3475 struct intel_plane
*plane
= to_intel_plane(crtc
->primary
);
3476 struct intel_plane_state
*plane_state
=
3477 to_intel_plane_state(plane
->base
.state
);
3479 if (plane_state
->base
.visible
)
3480 plane
->update_plane(&plane
->base
,
3481 to_intel_crtc_state(crtc
->state
),
3487 __intel_display_resume(struct drm_device
*dev
,
3488 struct drm_atomic_state
*state
)
3490 struct drm_crtc_state
*crtc_state
;
3491 struct drm_crtc
*crtc
;
3494 intel_modeset_setup_hw_state(dev
);
3495 i915_redisable_vga(dev
);
3500 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
3502 * Force recalculation even if we restore
3503 * current state. With fast modeset this may not result
3504 * in a modeset when the state is compatible.
3506 crtc_state
->mode_changed
= true;
3509 /* ignore any reset values/BIOS leftovers in the WM registers */
3510 to_intel_atomic_state(state
)->skip_intermediate_wm
= true;
3512 ret
= drm_atomic_commit(state
);
3514 WARN_ON(ret
== -EDEADLK
);
3518 static bool gpu_reset_clobbers_display(struct drm_i915_private
*dev_priv
)
3520 return intel_has_gpu_reset(dev_priv
) &&
3521 INTEL_GEN(dev_priv
) < 5 && !IS_G4X(dev_priv
);
3524 void intel_prepare_reset(struct drm_i915_private
*dev_priv
)
3526 struct drm_device
*dev
= &dev_priv
->drm
;
3527 struct drm_modeset_acquire_ctx
*ctx
= &dev_priv
->reset_ctx
;
3528 struct drm_atomic_state
*state
;
3532 * Need mode_config.mutex so that we don't
3533 * trample ongoing ->detect() and whatnot.
3535 mutex_lock(&dev
->mode_config
.mutex
);
3536 drm_modeset_acquire_init(ctx
, 0);
3538 ret
= drm_modeset_lock_all_ctx(dev
, ctx
);
3539 if (ret
!= -EDEADLK
)
3542 drm_modeset_backoff(ctx
);
3545 /* reset doesn't touch the display, but flips might get nuked anyway, */
3546 if (!i915
.force_reset_modeset_test
&&
3547 !gpu_reset_clobbers_display(dev_priv
))
3551 * Disabling the crtcs gracefully seems nicer. Also the
3552 * g33 docs say we should at least disable all the planes.
3554 state
= drm_atomic_helper_duplicate_state(dev
, ctx
);
3555 if (IS_ERR(state
)) {
3556 ret
= PTR_ERR(state
);
3558 DRM_ERROR("Duplicating state failed with %i\n", ret
);
3562 ret
= drm_atomic_helper_disable_all(dev
, ctx
);
3564 DRM_ERROR("Suspending crtc's failed with %i\n", ret
);
3568 dev_priv
->modeset_restore_state
= state
;
3569 state
->acquire_ctx
= ctx
;
3573 drm_atomic_state_free(state
);
3576 void intel_finish_reset(struct drm_i915_private
*dev_priv
)
3578 struct drm_device
*dev
= &dev_priv
->drm
;
3579 struct drm_modeset_acquire_ctx
*ctx
= &dev_priv
->reset_ctx
;
3580 struct drm_atomic_state
*state
= dev_priv
->modeset_restore_state
;
3584 * Flips in the rings will be nuked by the reset,
3585 * so complete all pending flips so that user space
3586 * will get its events and not get stuck.
3588 intel_complete_page_flips(dev_priv
);
3590 dev_priv
->modeset_restore_state
= NULL
;
3592 /* reset doesn't touch the display */
3593 if (!gpu_reset_clobbers_display(dev_priv
)) {
3596 * Flips in the rings have been nuked by the reset,
3597 * so update the base address of all primary
3598 * planes to the the last fb to make sure we're
3599 * showing the correct fb after a reset.
3601 * FIXME: Atomic will make this obsolete since we won't schedule
3602 * CS-based flips (which might get lost in gpu resets) any more.
3604 intel_update_primary_planes(dev
);
3606 ret
= __intel_display_resume(dev
, state
);
3608 DRM_ERROR("Restoring old state failed with %i\n", ret
);
3612 * The display has been reset as well,
3613 * so need a full re-initialization.
3615 intel_runtime_pm_disable_interrupts(dev_priv
);
3616 intel_runtime_pm_enable_interrupts(dev_priv
);
3618 intel_modeset_init_hw(dev
);
3620 spin_lock_irq(&dev_priv
->irq_lock
);
3621 if (dev_priv
->display
.hpd_irq_setup
)
3622 dev_priv
->display
.hpd_irq_setup(dev_priv
);
3623 spin_unlock_irq(&dev_priv
->irq_lock
);
3625 ret
= __intel_display_resume(dev
, state
);
3627 DRM_ERROR("Restoring old state failed with %i\n", ret
);
3629 intel_hpd_init(dev_priv
);
3632 drm_modeset_drop_locks(ctx
);
3633 drm_modeset_acquire_fini(ctx
);
3634 mutex_unlock(&dev
->mode_config
.mutex
);
3637 static bool intel_crtc_has_pending_flip(struct drm_crtc
*crtc
)
3639 struct drm_device
*dev
= crtc
->dev
;
3640 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
3641 unsigned reset_counter
;
3644 reset_counter
= i915_reset_counter(&to_i915(dev
)->gpu_error
);
3645 if (intel_crtc
->reset_counter
!= reset_counter
)
3648 spin_lock_irq(&dev
->event_lock
);
3649 pending
= to_intel_crtc(crtc
)->flip_work
!= NULL
;
3650 spin_unlock_irq(&dev
->event_lock
);
3655 static void intel_update_pipe_config(struct intel_crtc
*crtc
,
3656 struct intel_crtc_state
*old_crtc_state
)
3658 struct drm_device
*dev
= crtc
->base
.dev
;
3659 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3660 struct intel_crtc_state
*pipe_config
=
3661 to_intel_crtc_state(crtc
->base
.state
);
3663 /* drm_atomic_helper_update_legacy_modeset_state might not be called. */
3664 crtc
->base
.mode
= crtc
->base
.state
->mode
;
3666 DRM_DEBUG_KMS("Updating pipe size %ix%i -> %ix%i\n",
3667 old_crtc_state
->pipe_src_w
, old_crtc_state
->pipe_src_h
,
3668 pipe_config
->pipe_src_w
, pipe_config
->pipe_src_h
);
3671 * Update pipe size and adjust fitter if needed: the reason for this is
3672 * that in compute_mode_changes we check the native mode (not the pfit
3673 * mode) to see if we can flip rather than do a full mode set. In the
3674 * fastboot case, we'll flip, but if we don't update the pipesrc and
3675 * pfit state, we'll end up with a big fb scanned out into the wrong
3679 I915_WRITE(PIPESRC(crtc
->pipe
),
3680 ((pipe_config
->pipe_src_w
- 1) << 16) |
3681 (pipe_config
->pipe_src_h
- 1));
3683 /* on skylake this is done by detaching scalers */
3684 if (INTEL_INFO(dev
)->gen
>= 9) {
3685 skl_detach_scalers(crtc
);
3687 if (pipe_config
->pch_pfit
.enabled
)
3688 skylake_pfit_enable(crtc
);
3689 } else if (HAS_PCH_SPLIT(dev
)) {
3690 if (pipe_config
->pch_pfit
.enabled
)
3691 ironlake_pfit_enable(crtc
);
3692 else if (old_crtc_state
->pch_pfit
.enabled
)
3693 ironlake_pfit_disable(crtc
, true);
3697 static void intel_fdi_normal_train(struct drm_crtc
*crtc
)
3699 struct drm_device
*dev
= crtc
->dev
;
3700 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3701 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
3702 int pipe
= intel_crtc
->pipe
;
3706 /* enable normal train */
3707 reg
= FDI_TX_CTL(pipe
);
3708 temp
= I915_READ(reg
);
3709 if (IS_IVYBRIDGE(dev
)) {
3710 temp
&= ~FDI_LINK_TRAIN_NONE_IVB
;
3711 temp
|= FDI_LINK_TRAIN_NONE_IVB
| FDI_TX_ENHANCE_FRAME_ENABLE
;
3713 temp
&= ~FDI_LINK_TRAIN_NONE
;
3714 temp
|= FDI_LINK_TRAIN_NONE
| FDI_TX_ENHANCE_FRAME_ENABLE
;
3716 I915_WRITE(reg
, temp
);
3718 reg
= FDI_RX_CTL(pipe
);
3719 temp
= I915_READ(reg
);
3720 if (HAS_PCH_CPT(dev
)) {
3721 temp
&= ~FDI_LINK_TRAIN_PATTERN_MASK_CPT
;
3722 temp
|= FDI_LINK_TRAIN_NORMAL_CPT
;
3724 temp
&= ~FDI_LINK_TRAIN_NONE
;
3725 temp
|= FDI_LINK_TRAIN_NONE
;
3727 I915_WRITE(reg
, temp
| FDI_RX_ENHANCE_FRAME_ENABLE
);
3729 /* wait one idle pattern time */
3733 /* IVB wants error correction enabled */
3734 if (IS_IVYBRIDGE(dev
))
3735 I915_WRITE(reg
, I915_READ(reg
) | FDI_FS_ERRC_ENABLE
|
3736 FDI_FE_ERRC_ENABLE
);
3739 /* The FDI link training functions for ILK/Ibexpeak. */
3740 static void ironlake_fdi_link_train(struct drm_crtc
*crtc
)
3742 struct drm_device
*dev
= crtc
->dev
;
3743 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3744 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
3745 int pipe
= intel_crtc
->pipe
;
3749 /* FDI needs bits from pipe first */
3750 assert_pipe_enabled(dev_priv
, pipe
);
3752 /* Train 1: umask FDI RX Interrupt symbol_lock and bit_lock bit
3754 reg
= FDI_RX_IMR(pipe
);
3755 temp
= I915_READ(reg
);
3756 temp
&= ~FDI_RX_SYMBOL_LOCK
;
3757 temp
&= ~FDI_RX_BIT_LOCK
;
3758 I915_WRITE(reg
, temp
);
3762 /* enable CPU FDI TX and PCH FDI RX */
3763 reg
= FDI_TX_CTL(pipe
);
3764 temp
= I915_READ(reg
);
3765 temp
&= ~FDI_DP_PORT_WIDTH_MASK
;
3766 temp
|= FDI_DP_PORT_WIDTH(intel_crtc
->config
->fdi_lanes
);
3767 temp
&= ~FDI_LINK_TRAIN_NONE
;
3768 temp
|= FDI_LINK_TRAIN_PATTERN_1
;
3769 I915_WRITE(reg
, temp
| FDI_TX_ENABLE
);
3771 reg
= FDI_RX_CTL(pipe
);
3772 temp
= I915_READ(reg
);
3773 temp
&= ~FDI_LINK_TRAIN_NONE
;
3774 temp
|= FDI_LINK_TRAIN_PATTERN_1
;
3775 I915_WRITE(reg
, temp
| FDI_RX_ENABLE
);
3780 /* Ironlake workaround, enable clock pointer after FDI enable*/
3781 I915_WRITE(FDI_RX_CHICKEN(pipe
), FDI_RX_PHASE_SYNC_POINTER_OVR
);
3782 I915_WRITE(FDI_RX_CHICKEN(pipe
), FDI_RX_PHASE_SYNC_POINTER_OVR
|
3783 FDI_RX_PHASE_SYNC_POINTER_EN
);
3785 reg
= FDI_RX_IIR(pipe
);
3786 for (tries
= 0; tries
< 5; tries
++) {
3787 temp
= I915_READ(reg
);
3788 DRM_DEBUG_KMS("FDI_RX_IIR 0x%x\n", temp
);
3790 if ((temp
& FDI_RX_BIT_LOCK
)) {
3791 DRM_DEBUG_KMS("FDI train 1 done.\n");
3792 I915_WRITE(reg
, temp
| FDI_RX_BIT_LOCK
);
3797 DRM_ERROR("FDI train 1 fail!\n");
3800 reg
= FDI_TX_CTL(pipe
);
3801 temp
= I915_READ(reg
);
3802 temp
&= ~FDI_LINK_TRAIN_NONE
;
3803 temp
|= FDI_LINK_TRAIN_PATTERN_2
;
3804 I915_WRITE(reg
, temp
);
3806 reg
= FDI_RX_CTL(pipe
);
3807 temp
= I915_READ(reg
);
3808 temp
&= ~FDI_LINK_TRAIN_NONE
;
3809 temp
|= FDI_LINK_TRAIN_PATTERN_2
;
3810 I915_WRITE(reg
, temp
);
3815 reg
= FDI_RX_IIR(pipe
);
3816 for (tries
= 0; tries
< 5; tries
++) {
3817 temp
= I915_READ(reg
);
3818 DRM_DEBUG_KMS("FDI_RX_IIR 0x%x\n", temp
);
3820 if (temp
& FDI_RX_SYMBOL_LOCK
) {
3821 I915_WRITE(reg
, temp
| FDI_RX_SYMBOL_LOCK
);
3822 DRM_DEBUG_KMS("FDI train 2 done.\n");
3827 DRM_ERROR("FDI train 2 fail!\n");
3829 DRM_DEBUG_KMS("FDI train done\n");
3833 static const int snb_b_fdi_train_param
[] = {
3834 FDI_LINK_TRAIN_400MV_0DB_SNB_B
,
3835 FDI_LINK_TRAIN_400MV_6DB_SNB_B
,
3836 FDI_LINK_TRAIN_600MV_3_5DB_SNB_B
,
3837 FDI_LINK_TRAIN_800MV_0DB_SNB_B
,
3840 /* The FDI link training functions for SNB/Cougarpoint. */
3841 static void gen6_fdi_link_train(struct drm_crtc
*crtc
)
3843 struct drm_device
*dev
= crtc
->dev
;
3844 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3845 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
3846 int pipe
= intel_crtc
->pipe
;
3850 /* Train 1: umask FDI RX Interrupt symbol_lock and bit_lock bit
3852 reg
= FDI_RX_IMR(pipe
);
3853 temp
= I915_READ(reg
);
3854 temp
&= ~FDI_RX_SYMBOL_LOCK
;
3855 temp
&= ~FDI_RX_BIT_LOCK
;
3856 I915_WRITE(reg
, temp
);
3861 /* enable CPU FDI TX and PCH FDI RX */
3862 reg
= FDI_TX_CTL(pipe
);
3863 temp
= I915_READ(reg
);
3864 temp
&= ~FDI_DP_PORT_WIDTH_MASK
;
3865 temp
|= FDI_DP_PORT_WIDTH(intel_crtc
->config
->fdi_lanes
);
3866 temp
&= ~FDI_LINK_TRAIN_NONE
;
3867 temp
|= FDI_LINK_TRAIN_PATTERN_1
;
3868 temp
&= ~FDI_LINK_TRAIN_VOL_EMP_MASK
;
3870 temp
|= FDI_LINK_TRAIN_400MV_0DB_SNB_B
;
3871 I915_WRITE(reg
, temp
| FDI_TX_ENABLE
);
3873 I915_WRITE(FDI_RX_MISC(pipe
),
3874 FDI_RX_TP1_TO_TP2_48
| FDI_RX_FDI_DELAY_90
);
3876 reg
= FDI_RX_CTL(pipe
);
3877 temp
= I915_READ(reg
);
3878 if (HAS_PCH_CPT(dev
)) {
3879 temp
&= ~FDI_LINK_TRAIN_PATTERN_MASK_CPT
;
3880 temp
|= FDI_LINK_TRAIN_PATTERN_1_CPT
;
3882 temp
&= ~FDI_LINK_TRAIN_NONE
;
3883 temp
|= FDI_LINK_TRAIN_PATTERN_1
;
3885 I915_WRITE(reg
, temp
| FDI_RX_ENABLE
);
3890 for (i
= 0; i
< 4; i
++) {
3891 reg
= FDI_TX_CTL(pipe
);
3892 temp
= I915_READ(reg
);
3893 temp
&= ~FDI_LINK_TRAIN_VOL_EMP_MASK
;
3894 temp
|= snb_b_fdi_train_param
[i
];
3895 I915_WRITE(reg
, temp
);
3900 for (retry
= 0; retry
< 5; retry
++) {
3901 reg
= FDI_RX_IIR(pipe
);
3902 temp
= I915_READ(reg
);
3903 DRM_DEBUG_KMS("FDI_RX_IIR 0x%x\n", temp
);
3904 if (temp
& FDI_RX_BIT_LOCK
) {
3905 I915_WRITE(reg
, temp
| FDI_RX_BIT_LOCK
);
3906 DRM_DEBUG_KMS("FDI train 1 done.\n");
3915 DRM_ERROR("FDI train 1 fail!\n");
3918 reg
= FDI_TX_CTL(pipe
);
3919 temp
= I915_READ(reg
);
3920 temp
&= ~FDI_LINK_TRAIN_NONE
;
3921 temp
|= FDI_LINK_TRAIN_PATTERN_2
;
3923 temp
&= ~FDI_LINK_TRAIN_VOL_EMP_MASK
;
3925 temp
|= FDI_LINK_TRAIN_400MV_0DB_SNB_B
;
3927 I915_WRITE(reg
, temp
);
3929 reg
= FDI_RX_CTL(pipe
);
3930 temp
= I915_READ(reg
);
3931 if (HAS_PCH_CPT(dev
)) {
3932 temp
&= ~FDI_LINK_TRAIN_PATTERN_MASK_CPT
;
3933 temp
|= FDI_LINK_TRAIN_PATTERN_2_CPT
;
3935 temp
&= ~FDI_LINK_TRAIN_NONE
;
3936 temp
|= FDI_LINK_TRAIN_PATTERN_2
;
3938 I915_WRITE(reg
, temp
);
3943 for (i
= 0; i
< 4; i
++) {
3944 reg
= FDI_TX_CTL(pipe
);
3945 temp
= I915_READ(reg
);
3946 temp
&= ~FDI_LINK_TRAIN_VOL_EMP_MASK
;
3947 temp
|= snb_b_fdi_train_param
[i
];
3948 I915_WRITE(reg
, temp
);
3953 for (retry
= 0; retry
< 5; retry
++) {
3954 reg
= FDI_RX_IIR(pipe
);
3955 temp
= I915_READ(reg
);
3956 DRM_DEBUG_KMS("FDI_RX_IIR 0x%x\n", temp
);
3957 if (temp
& FDI_RX_SYMBOL_LOCK
) {
3958 I915_WRITE(reg
, temp
| FDI_RX_SYMBOL_LOCK
);
3959 DRM_DEBUG_KMS("FDI train 2 done.\n");
3968 DRM_ERROR("FDI train 2 fail!\n");
3970 DRM_DEBUG_KMS("FDI train done.\n");
3973 /* Manual link training for Ivy Bridge A0 parts */
3974 static void ivb_manual_fdi_link_train(struct drm_crtc
*crtc
)
3976 struct drm_device
*dev
= crtc
->dev
;
3977 struct drm_i915_private
*dev_priv
= to_i915(dev
);
3978 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
3979 int pipe
= intel_crtc
->pipe
;
3983 /* Train 1: umask FDI RX Interrupt symbol_lock and bit_lock bit
3985 reg
= FDI_RX_IMR(pipe
);
3986 temp
= I915_READ(reg
);
3987 temp
&= ~FDI_RX_SYMBOL_LOCK
;
3988 temp
&= ~FDI_RX_BIT_LOCK
;
3989 I915_WRITE(reg
, temp
);
3994 DRM_DEBUG_KMS("FDI_RX_IIR before link train 0x%x\n",
3995 I915_READ(FDI_RX_IIR(pipe
)));
3997 /* Try each vswing and preemphasis setting twice before moving on */
3998 for (j
= 0; j
< ARRAY_SIZE(snb_b_fdi_train_param
) * 2; j
++) {
3999 /* disable first in case we need to retry */
4000 reg
= FDI_TX_CTL(pipe
);
4001 temp
= I915_READ(reg
);
4002 temp
&= ~(FDI_LINK_TRAIN_AUTO
| FDI_LINK_TRAIN_NONE_IVB
);
4003 temp
&= ~FDI_TX_ENABLE
;
4004 I915_WRITE(reg
, temp
);
4006 reg
= FDI_RX_CTL(pipe
);
4007 temp
= I915_READ(reg
);
4008 temp
&= ~FDI_LINK_TRAIN_AUTO
;
4009 temp
&= ~FDI_LINK_TRAIN_PATTERN_MASK_CPT
;
4010 temp
&= ~FDI_RX_ENABLE
;
4011 I915_WRITE(reg
, temp
);
4013 /* enable CPU FDI TX and PCH FDI RX */
4014 reg
= FDI_TX_CTL(pipe
);
4015 temp
= I915_READ(reg
);
4016 temp
&= ~FDI_DP_PORT_WIDTH_MASK
;
4017 temp
|= FDI_DP_PORT_WIDTH(intel_crtc
->config
->fdi_lanes
);
4018 temp
|= FDI_LINK_TRAIN_PATTERN_1_IVB
;
4019 temp
&= ~FDI_LINK_TRAIN_VOL_EMP_MASK
;
4020 temp
|= snb_b_fdi_train_param
[j
/2];
4021 temp
|= FDI_COMPOSITE_SYNC
;
4022 I915_WRITE(reg
, temp
| FDI_TX_ENABLE
);
4024 I915_WRITE(FDI_RX_MISC(pipe
),
4025 FDI_RX_TP1_TO_TP2_48
| FDI_RX_FDI_DELAY_90
);
4027 reg
= FDI_RX_CTL(pipe
);
4028 temp
= I915_READ(reg
);
4029 temp
|= FDI_LINK_TRAIN_PATTERN_1_CPT
;
4030 temp
|= FDI_COMPOSITE_SYNC
;
4031 I915_WRITE(reg
, temp
| FDI_RX_ENABLE
);
4034 udelay(1); /* should be 0.5us */
4036 for (i
= 0; i
< 4; i
++) {
4037 reg
= FDI_RX_IIR(pipe
);
4038 temp
= I915_READ(reg
);
4039 DRM_DEBUG_KMS("FDI_RX_IIR 0x%x\n", temp
);
4041 if (temp
& FDI_RX_BIT_LOCK
||
4042 (I915_READ(reg
) & FDI_RX_BIT_LOCK
)) {
4043 I915_WRITE(reg
, temp
| FDI_RX_BIT_LOCK
);
4044 DRM_DEBUG_KMS("FDI train 1 done, level %i.\n",
4048 udelay(1); /* should be 0.5us */
4051 DRM_DEBUG_KMS("FDI train 1 fail on vswing %d\n", j
/ 2);
4056 reg
= FDI_TX_CTL(pipe
);
4057 temp
= I915_READ(reg
);
4058 temp
&= ~FDI_LINK_TRAIN_NONE_IVB
;
4059 temp
|= FDI_LINK_TRAIN_PATTERN_2_IVB
;
4060 I915_WRITE(reg
, temp
);
4062 reg
= FDI_RX_CTL(pipe
);
4063 temp
= I915_READ(reg
);
4064 temp
&= ~FDI_LINK_TRAIN_PATTERN_MASK_CPT
;
4065 temp
|= FDI_LINK_TRAIN_PATTERN_2_CPT
;
4066 I915_WRITE(reg
, temp
);
4069 udelay(2); /* should be 1.5us */
4071 for (i
= 0; i
< 4; i
++) {
4072 reg
= FDI_RX_IIR(pipe
);
4073 temp
= I915_READ(reg
);
4074 DRM_DEBUG_KMS("FDI_RX_IIR 0x%x\n", temp
);
4076 if (temp
& FDI_RX_SYMBOL_LOCK
||
4077 (I915_READ(reg
) & FDI_RX_SYMBOL_LOCK
)) {
4078 I915_WRITE(reg
, temp
| FDI_RX_SYMBOL_LOCK
);
4079 DRM_DEBUG_KMS("FDI train 2 done, level %i.\n",
4083 udelay(2); /* should be 1.5us */
4086 DRM_DEBUG_KMS("FDI train 2 fail on vswing %d\n", j
/ 2);
4090 DRM_DEBUG_KMS("FDI train done.\n");
4093 static void ironlake_fdi_pll_enable(struct intel_crtc
*intel_crtc
)
4095 struct drm_device
*dev
= intel_crtc
->base
.dev
;
4096 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4097 int pipe
= intel_crtc
->pipe
;
4101 /* enable PCH FDI RX PLL, wait warmup plus DMI latency */
4102 reg
= FDI_RX_CTL(pipe
);
4103 temp
= I915_READ(reg
);
4104 temp
&= ~(FDI_DP_PORT_WIDTH_MASK
| (0x7 << 16));
4105 temp
|= FDI_DP_PORT_WIDTH(intel_crtc
->config
->fdi_lanes
);
4106 temp
|= (I915_READ(PIPECONF(pipe
)) & PIPECONF_BPC_MASK
) << 11;
4107 I915_WRITE(reg
, temp
| FDI_RX_PLL_ENABLE
);
4112 /* Switch from Rawclk to PCDclk */
4113 temp
= I915_READ(reg
);
4114 I915_WRITE(reg
, temp
| FDI_PCDCLK
);
4119 /* Enable CPU FDI TX PLL, always on for Ironlake */
4120 reg
= FDI_TX_CTL(pipe
);
4121 temp
= I915_READ(reg
);
4122 if ((temp
& FDI_TX_PLL_ENABLE
) == 0) {
4123 I915_WRITE(reg
, temp
| FDI_TX_PLL_ENABLE
);
4130 static void ironlake_fdi_pll_disable(struct intel_crtc
*intel_crtc
)
4132 struct drm_device
*dev
= intel_crtc
->base
.dev
;
4133 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4134 int pipe
= intel_crtc
->pipe
;
4138 /* Switch from PCDclk to Rawclk */
4139 reg
= FDI_RX_CTL(pipe
);
4140 temp
= I915_READ(reg
);
4141 I915_WRITE(reg
, temp
& ~FDI_PCDCLK
);
4143 /* Disable CPU FDI TX PLL */
4144 reg
= FDI_TX_CTL(pipe
);
4145 temp
= I915_READ(reg
);
4146 I915_WRITE(reg
, temp
& ~FDI_TX_PLL_ENABLE
);
4151 reg
= FDI_RX_CTL(pipe
);
4152 temp
= I915_READ(reg
);
4153 I915_WRITE(reg
, temp
& ~FDI_RX_PLL_ENABLE
);
4155 /* Wait for the clocks to turn off. */
4160 static void ironlake_fdi_disable(struct drm_crtc
*crtc
)
4162 struct drm_device
*dev
= crtc
->dev
;
4163 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4164 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
4165 int pipe
= intel_crtc
->pipe
;
4169 /* disable CPU FDI tx and PCH FDI rx */
4170 reg
= FDI_TX_CTL(pipe
);
4171 temp
= I915_READ(reg
);
4172 I915_WRITE(reg
, temp
& ~FDI_TX_ENABLE
);
4175 reg
= FDI_RX_CTL(pipe
);
4176 temp
= I915_READ(reg
);
4177 temp
&= ~(0x7 << 16);
4178 temp
|= (I915_READ(PIPECONF(pipe
)) & PIPECONF_BPC_MASK
) << 11;
4179 I915_WRITE(reg
, temp
& ~FDI_RX_ENABLE
);
4184 /* Ironlake workaround, disable clock pointer after downing FDI */
4185 if (HAS_PCH_IBX(dev
))
4186 I915_WRITE(FDI_RX_CHICKEN(pipe
), FDI_RX_PHASE_SYNC_POINTER_OVR
);
4188 /* still set train pattern 1 */
4189 reg
= FDI_TX_CTL(pipe
);
4190 temp
= I915_READ(reg
);
4191 temp
&= ~FDI_LINK_TRAIN_NONE
;
4192 temp
|= FDI_LINK_TRAIN_PATTERN_1
;
4193 I915_WRITE(reg
, temp
);
4195 reg
= FDI_RX_CTL(pipe
);
4196 temp
= I915_READ(reg
);
4197 if (HAS_PCH_CPT(dev
)) {
4198 temp
&= ~FDI_LINK_TRAIN_PATTERN_MASK_CPT
;
4199 temp
|= FDI_LINK_TRAIN_PATTERN_1_CPT
;
4201 temp
&= ~FDI_LINK_TRAIN_NONE
;
4202 temp
|= FDI_LINK_TRAIN_PATTERN_1
;
4204 /* BPC in FDI rx is consistent with that in PIPECONF */
4205 temp
&= ~(0x07 << 16);
4206 temp
|= (I915_READ(PIPECONF(pipe
)) & PIPECONF_BPC_MASK
) << 11;
4207 I915_WRITE(reg
, temp
);
4213 bool intel_has_pending_fb_unpin(struct drm_device
*dev
)
4215 struct intel_crtc
*crtc
;
4217 /* Note that we don't need to be called with mode_config.lock here
4218 * as our list of CRTC objects is static for the lifetime of the
4219 * device and so cannot disappear as we iterate. Similarly, we can
4220 * happily treat the predicates as racy, atomic checks as userspace
4221 * cannot claim and pin a new fb without at least acquring the
4222 * struct_mutex and so serialising with us.
4224 for_each_intel_crtc(dev
, crtc
) {
4225 if (atomic_read(&crtc
->unpin_work_count
) == 0)
4228 if (crtc
->flip_work
)
4229 intel_wait_for_vblank(dev
, crtc
->pipe
);
4237 static void page_flip_completed(struct intel_crtc
*intel_crtc
)
4239 struct drm_i915_private
*dev_priv
= to_i915(intel_crtc
->base
.dev
);
4240 struct intel_flip_work
*work
= intel_crtc
->flip_work
;
4242 intel_crtc
->flip_work
= NULL
;
4245 drm_crtc_send_vblank_event(&intel_crtc
->base
, work
->event
);
4247 drm_crtc_vblank_put(&intel_crtc
->base
);
4249 wake_up_all(&dev_priv
->pending_flip_queue
);
4250 queue_work(dev_priv
->wq
, &work
->unpin_work
);
4252 trace_i915_flip_complete(intel_crtc
->plane
,
4253 work
->pending_flip_obj
);
4256 static int intel_crtc_wait_for_pending_flips(struct drm_crtc
*crtc
)
4258 struct drm_device
*dev
= crtc
->dev
;
4259 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4262 WARN_ON(waitqueue_active(&dev_priv
->pending_flip_queue
));
4264 ret
= wait_event_interruptible_timeout(
4265 dev_priv
->pending_flip_queue
,
4266 !intel_crtc_has_pending_flip(crtc
),
4273 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
4274 struct intel_flip_work
*work
;
4276 spin_lock_irq(&dev
->event_lock
);
4277 work
= intel_crtc
->flip_work
;
4278 if (work
&& !is_mmio_work(work
)) {
4279 WARN_ONCE(1, "Removing stuck page flip\n");
4280 page_flip_completed(intel_crtc
);
4282 spin_unlock_irq(&dev
->event_lock
);
4288 static void lpt_disable_iclkip(struct drm_i915_private
*dev_priv
)
4292 I915_WRITE(PIXCLK_GATE
, PIXCLK_GATE_GATE
);
4294 mutex_lock(&dev_priv
->sb_lock
);
4296 temp
= intel_sbi_read(dev_priv
, SBI_SSCCTL6
, SBI_ICLK
);
4297 temp
|= SBI_SSCCTL_DISABLE
;
4298 intel_sbi_write(dev_priv
, SBI_SSCCTL6
, temp
, SBI_ICLK
);
4300 mutex_unlock(&dev_priv
->sb_lock
);
4303 /* Program iCLKIP clock to the desired frequency */
4304 static void lpt_program_iclkip(struct drm_crtc
*crtc
)
4306 struct drm_i915_private
*dev_priv
= to_i915(crtc
->dev
);
4307 int clock
= to_intel_crtc(crtc
)->config
->base
.adjusted_mode
.crtc_clock
;
4308 u32 divsel
, phaseinc
, auxdiv
, phasedir
= 0;
4311 lpt_disable_iclkip(dev_priv
);
4313 /* The iCLK virtual clock root frequency is in MHz,
4314 * but the adjusted_mode->crtc_clock in in KHz. To get the
4315 * divisors, it is necessary to divide one by another, so we
4316 * convert the virtual clock precision to KHz here for higher
4319 for (auxdiv
= 0; auxdiv
< 2; auxdiv
++) {
4320 u32 iclk_virtual_root_freq
= 172800 * 1000;
4321 u32 iclk_pi_range
= 64;
4322 u32 desired_divisor
;
4324 desired_divisor
= DIV_ROUND_CLOSEST(iclk_virtual_root_freq
,
4326 divsel
= (desired_divisor
/ iclk_pi_range
) - 2;
4327 phaseinc
= desired_divisor
% iclk_pi_range
;
4330 * Near 20MHz is a corner case which is
4331 * out of range for the 7-bit divisor
4337 /* This should not happen with any sane values */
4338 WARN_ON(SBI_SSCDIVINTPHASE_DIVSEL(divsel
) &
4339 ~SBI_SSCDIVINTPHASE_DIVSEL_MASK
);
4340 WARN_ON(SBI_SSCDIVINTPHASE_DIR(phasedir
) &
4341 ~SBI_SSCDIVINTPHASE_INCVAL_MASK
);
4343 DRM_DEBUG_KMS("iCLKIP clock: found settings for %dKHz refresh rate: auxdiv=%x, divsel=%x, phasedir=%x, phaseinc=%x\n",
4350 mutex_lock(&dev_priv
->sb_lock
);
4352 /* Program SSCDIVINTPHASE6 */
4353 temp
= intel_sbi_read(dev_priv
, SBI_SSCDIVINTPHASE6
, SBI_ICLK
);
4354 temp
&= ~SBI_SSCDIVINTPHASE_DIVSEL_MASK
;
4355 temp
|= SBI_SSCDIVINTPHASE_DIVSEL(divsel
);
4356 temp
&= ~SBI_SSCDIVINTPHASE_INCVAL_MASK
;
4357 temp
|= SBI_SSCDIVINTPHASE_INCVAL(phaseinc
);
4358 temp
|= SBI_SSCDIVINTPHASE_DIR(phasedir
);
4359 temp
|= SBI_SSCDIVINTPHASE_PROPAGATE
;
4360 intel_sbi_write(dev_priv
, SBI_SSCDIVINTPHASE6
, temp
, SBI_ICLK
);
4362 /* Program SSCAUXDIV */
4363 temp
= intel_sbi_read(dev_priv
, SBI_SSCAUXDIV6
, SBI_ICLK
);
4364 temp
&= ~SBI_SSCAUXDIV_FINALDIV2SEL(1);
4365 temp
|= SBI_SSCAUXDIV_FINALDIV2SEL(auxdiv
);
4366 intel_sbi_write(dev_priv
, SBI_SSCAUXDIV6
, temp
, SBI_ICLK
);
4368 /* Enable modulator and associated divider */
4369 temp
= intel_sbi_read(dev_priv
, SBI_SSCCTL6
, SBI_ICLK
);
4370 temp
&= ~SBI_SSCCTL_DISABLE
;
4371 intel_sbi_write(dev_priv
, SBI_SSCCTL6
, temp
, SBI_ICLK
);
4373 mutex_unlock(&dev_priv
->sb_lock
);
4375 /* Wait for initialization time */
4378 I915_WRITE(PIXCLK_GATE
, PIXCLK_GATE_UNGATE
);
4381 int lpt_get_iclkip(struct drm_i915_private
*dev_priv
)
4383 u32 divsel
, phaseinc
, auxdiv
;
4384 u32 iclk_virtual_root_freq
= 172800 * 1000;
4385 u32 iclk_pi_range
= 64;
4386 u32 desired_divisor
;
4389 if ((I915_READ(PIXCLK_GATE
) & PIXCLK_GATE_UNGATE
) == 0)
4392 mutex_lock(&dev_priv
->sb_lock
);
4394 temp
= intel_sbi_read(dev_priv
, SBI_SSCCTL6
, SBI_ICLK
);
4395 if (temp
& SBI_SSCCTL_DISABLE
) {
4396 mutex_unlock(&dev_priv
->sb_lock
);
4400 temp
= intel_sbi_read(dev_priv
, SBI_SSCDIVINTPHASE6
, SBI_ICLK
);
4401 divsel
= (temp
& SBI_SSCDIVINTPHASE_DIVSEL_MASK
) >>
4402 SBI_SSCDIVINTPHASE_DIVSEL_SHIFT
;
4403 phaseinc
= (temp
& SBI_SSCDIVINTPHASE_INCVAL_MASK
) >>
4404 SBI_SSCDIVINTPHASE_INCVAL_SHIFT
;
4406 temp
= intel_sbi_read(dev_priv
, SBI_SSCAUXDIV6
, SBI_ICLK
);
4407 auxdiv
= (temp
& SBI_SSCAUXDIV_FINALDIV2SEL_MASK
) >>
4408 SBI_SSCAUXDIV_FINALDIV2SEL_SHIFT
;
4410 mutex_unlock(&dev_priv
->sb_lock
);
4412 desired_divisor
= (divsel
+ 2) * iclk_pi_range
+ phaseinc
;
4414 return DIV_ROUND_CLOSEST(iclk_virtual_root_freq
,
4415 desired_divisor
<< auxdiv
);
4418 static void ironlake_pch_transcoder_set_timings(struct intel_crtc
*crtc
,
4419 enum pipe pch_transcoder
)
4421 struct drm_device
*dev
= crtc
->base
.dev
;
4422 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4423 enum transcoder cpu_transcoder
= crtc
->config
->cpu_transcoder
;
4425 I915_WRITE(PCH_TRANS_HTOTAL(pch_transcoder
),
4426 I915_READ(HTOTAL(cpu_transcoder
)));
4427 I915_WRITE(PCH_TRANS_HBLANK(pch_transcoder
),
4428 I915_READ(HBLANK(cpu_transcoder
)));
4429 I915_WRITE(PCH_TRANS_HSYNC(pch_transcoder
),
4430 I915_READ(HSYNC(cpu_transcoder
)));
4432 I915_WRITE(PCH_TRANS_VTOTAL(pch_transcoder
),
4433 I915_READ(VTOTAL(cpu_transcoder
)));
4434 I915_WRITE(PCH_TRANS_VBLANK(pch_transcoder
),
4435 I915_READ(VBLANK(cpu_transcoder
)));
4436 I915_WRITE(PCH_TRANS_VSYNC(pch_transcoder
),
4437 I915_READ(VSYNC(cpu_transcoder
)));
4438 I915_WRITE(PCH_TRANS_VSYNCSHIFT(pch_transcoder
),
4439 I915_READ(VSYNCSHIFT(cpu_transcoder
)));
4442 static void cpt_set_fdi_bc_bifurcation(struct drm_device
*dev
, bool enable
)
4444 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4447 temp
= I915_READ(SOUTH_CHICKEN1
);
4448 if (!!(temp
& FDI_BC_BIFURCATION_SELECT
) == enable
)
4451 WARN_ON(I915_READ(FDI_RX_CTL(PIPE_B
)) & FDI_RX_ENABLE
);
4452 WARN_ON(I915_READ(FDI_RX_CTL(PIPE_C
)) & FDI_RX_ENABLE
);
4454 temp
&= ~FDI_BC_BIFURCATION_SELECT
;
4456 temp
|= FDI_BC_BIFURCATION_SELECT
;
4458 DRM_DEBUG_KMS("%sabling fdi C rx\n", enable
? "en" : "dis");
4459 I915_WRITE(SOUTH_CHICKEN1
, temp
);
4460 POSTING_READ(SOUTH_CHICKEN1
);
4463 static void ivybridge_update_fdi_bc_bifurcation(struct intel_crtc
*intel_crtc
)
4465 struct drm_device
*dev
= intel_crtc
->base
.dev
;
4467 switch (intel_crtc
->pipe
) {
4471 if (intel_crtc
->config
->fdi_lanes
> 2)
4472 cpt_set_fdi_bc_bifurcation(dev
, false);
4474 cpt_set_fdi_bc_bifurcation(dev
, true);
4478 cpt_set_fdi_bc_bifurcation(dev
, true);
4486 /* Return which DP Port should be selected for Transcoder DP control */
4488 intel_trans_dp_port_sel(struct drm_crtc
*crtc
)
4490 struct drm_device
*dev
= crtc
->dev
;
4491 struct intel_encoder
*encoder
;
4493 for_each_encoder_on_crtc(dev
, crtc
, encoder
) {
4494 if (encoder
->type
== INTEL_OUTPUT_DP
||
4495 encoder
->type
== INTEL_OUTPUT_EDP
)
4496 return enc_to_dig_port(&encoder
->base
)->port
;
4503 * Enable PCH resources required for PCH ports:
4505 * - FDI training & RX/TX
4506 * - update transcoder timings
4507 * - DP transcoding bits
4510 static void ironlake_pch_enable(struct drm_crtc
*crtc
)
4512 struct drm_device
*dev
= crtc
->dev
;
4513 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4514 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
4515 int pipe
= intel_crtc
->pipe
;
4518 assert_pch_transcoder_disabled(dev_priv
, pipe
);
4520 if (IS_IVYBRIDGE(dev
))
4521 ivybridge_update_fdi_bc_bifurcation(intel_crtc
);
4523 /* Write the TU size bits before fdi link training, so that error
4524 * detection works. */
4525 I915_WRITE(FDI_RX_TUSIZE1(pipe
),
4526 I915_READ(PIPE_DATA_M1(pipe
)) & TU_SIZE_MASK
);
4528 /* For PCH output, training FDI link */
4529 dev_priv
->display
.fdi_link_train(crtc
);
4531 /* We need to program the right clock selection before writing the pixel
4532 * mutliplier into the DPLL. */
4533 if (HAS_PCH_CPT(dev
)) {
4536 temp
= I915_READ(PCH_DPLL_SEL
);
4537 temp
|= TRANS_DPLL_ENABLE(pipe
);
4538 sel
= TRANS_DPLLB_SEL(pipe
);
4539 if (intel_crtc
->config
->shared_dpll
==
4540 intel_get_shared_dpll_by_id(dev_priv
, DPLL_ID_PCH_PLL_B
))
4544 I915_WRITE(PCH_DPLL_SEL
, temp
);
4547 /* XXX: pch pll's can be enabled any time before we enable the PCH
4548 * transcoder, and we actually should do this to not upset any PCH
4549 * transcoder that already use the clock when we share it.
4551 * Note that enable_shared_dpll tries to do the right thing, but
4552 * get_shared_dpll unconditionally resets the pll - we need that to have
4553 * the right LVDS enable sequence. */
4554 intel_enable_shared_dpll(intel_crtc
);
4556 /* set transcoder timing, panel must allow it */
4557 assert_panel_unlocked(dev_priv
, pipe
);
4558 ironlake_pch_transcoder_set_timings(intel_crtc
, pipe
);
4560 intel_fdi_normal_train(crtc
);
4562 /* For PCH DP, enable TRANS_DP_CTL */
4563 if (HAS_PCH_CPT(dev
) && intel_crtc_has_dp_encoder(intel_crtc
->config
)) {
4564 const struct drm_display_mode
*adjusted_mode
=
4565 &intel_crtc
->config
->base
.adjusted_mode
;
4566 u32 bpc
= (I915_READ(PIPECONF(pipe
)) & PIPECONF_BPC_MASK
) >> 5;
4567 i915_reg_t reg
= TRANS_DP_CTL(pipe
);
4568 temp
= I915_READ(reg
);
4569 temp
&= ~(TRANS_DP_PORT_SEL_MASK
|
4570 TRANS_DP_SYNC_MASK
|
4572 temp
|= TRANS_DP_OUTPUT_ENABLE
;
4573 temp
|= bpc
<< 9; /* same format but at 11:9 */
4575 if (adjusted_mode
->flags
& DRM_MODE_FLAG_PHSYNC
)
4576 temp
|= TRANS_DP_HSYNC_ACTIVE_HIGH
;
4577 if (adjusted_mode
->flags
& DRM_MODE_FLAG_PVSYNC
)
4578 temp
|= TRANS_DP_VSYNC_ACTIVE_HIGH
;
4580 switch (intel_trans_dp_port_sel(crtc
)) {
4582 temp
|= TRANS_DP_PORT_SEL_B
;
4585 temp
|= TRANS_DP_PORT_SEL_C
;
4588 temp
|= TRANS_DP_PORT_SEL_D
;
4594 I915_WRITE(reg
, temp
);
4597 ironlake_enable_pch_transcoder(dev_priv
, pipe
);
4600 static void lpt_pch_enable(struct drm_crtc
*crtc
)
4602 struct drm_device
*dev
= crtc
->dev
;
4603 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4604 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
4605 enum transcoder cpu_transcoder
= intel_crtc
->config
->cpu_transcoder
;
4607 assert_pch_transcoder_disabled(dev_priv
, TRANSCODER_A
);
4609 lpt_program_iclkip(crtc
);
4611 /* Set transcoder timing. */
4612 ironlake_pch_transcoder_set_timings(intel_crtc
, PIPE_A
);
4614 lpt_enable_pch_transcoder(dev_priv
, cpu_transcoder
);
4617 static void cpt_verify_modeset(struct drm_device
*dev
, int pipe
)
4619 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4620 i915_reg_t dslreg
= PIPEDSL(pipe
);
4623 temp
= I915_READ(dslreg
);
4625 if (wait_for(I915_READ(dslreg
) != temp
, 5)) {
4626 if (wait_for(I915_READ(dslreg
) != temp
, 5))
4627 DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe
));
4632 skl_update_scaler(struct intel_crtc_state
*crtc_state
, bool force_detach
,
4633 unsigned scaler_user
, int *scaler_id
, unsigned int rotation
,
4634 int src_w
, int src_h
, int dst_w
, int dst_h
)
4636 struct intel_crtc_scaler_state
*scaler_state
=
4637 &crtc_state
->scaler_state
;
4638 struct intel_crtc
*intel_crtc
=
4639 to_intel_crtc(crtc_state
->base
.crtc
);
4642 need_scaling
= intel_rotation_90_or_270(rotation
) ?
4643 (src_h
!= dst_w
|| src_w
!= dst_h
):
4644 (src_w
!= dst_w
|| src_h
!= dst_h
);
4647 * if plane is being disabled or scaler is no more required or force detach
4648 * - free scaler binded to this plane/crtc
4649 * - in order to do this, update crtc->scaler_usage
4651 * Here scaler state in crtc_state is set free so that
4652 * scaler can be assigned to other user. Actual register
4653 * update to free the scaler is done in plane/panel-fit programming.
4654 * For this purpose crtc/plane_state->scaler_id isn't reset here.
4656 if (force_detach
|| !need_scaling
) {
4657 if (*scaler_id
>= 0) {
4658 scaler_state
->scaler_users
&= ~(1 << scaler_user
);
4659 scaler_state
->scalers
[*scaler_id
].in_use
= 0;
4661 DRM_DEBUG_KMS("scaler_user index %u.%u: "
4662 "Staged freeing scaler id %d scaler_users = 0x%x\n",
4663 intel_crtc
->pipe
, scaler_user
, *scaler_id
,
4664 scaler_state
->scaler_users
);
4671 if (src_w
< SKL_MIN_SRC_W
|| src_h
< SKL_MIN_SRC_H
||
4672 dst_w
< SKL_MIN_DST_W
|| dst_h
< SKL_MIN_DST_H
||
4674 src_w
> SKL_MAX_SRC_W
|| src_h
> SKL_MAX_SRC_H
||
4675 dst_w
> SKL_MAX_DST_W
|| dst_h
> SKL_MAX_DST_H
) {
4676 DRM_DEBUG_KMS("scaler_user index %u.%u: src %ux%u dst %ux%u "
4677 "size is out of scaler range\n",
4678 intel_crtc
->pipe
, scaler_user
, src_w
, src_h
, dst_w
, dst_h
);
4682 /* mark this plane as a scaler user in crtc_state */
4683 scaler_state
->scaler_users
|= (1 << scaler_user
);
4684 DRM_DEBUG_KMS("scaler_user index %u.%u: "
4685 "staged scaling request for %ux%u->%ux%u scaler_users = 0x%x\n",
4686 intel_crtc
->pipe
, scaler_user
, src_w
, src_h
, dst_w
, dst_h
,
4687 scaler_state
->scaler_users
);
4693 * skl_update_scaler_crtc - Stages update to scaler state for a given crtc.
4695 * @state: crtc's scaler state
4698 * 0 - scaler_usage updated successfully
4699 * error - requested scaling cannot be supported or other error condition
4701 int skl_update_scaler_crtc(struct intel_crtc_state
*state
)
4703 struct intel_crtc
*intel_crtc
= to_intel_crtc(state
->base
.crtc
);
4704 const struct drm_display_mode
*adjusted_mode
= &state
->base
.adjusted_mode
;
4706 DRM_DEBUG_KMS("Updating scaler for [CRTC:%d:%s] scaler_user index %u.%u\n",
4707 intel_crtc
->base
.base
.id
, intel_crtc
->base
.name
,
4708 intel_crtc
->pipe
, SKL_CRTC_INDEX
);
4710 return skl_update_scaler(state
, !state
->base
.active
, SKL_CRTC_INDEX
,
4711 &state
->scaler_state
.scaler_id
, DRM_ROTATE_0
,
4712 state
->pipe_src_w
, state
->pipe_src_h
,
4713 adjusted_mode
->crtc_hdisplay
, adjusted_mode
->crtc_vdisplay
);
4717 * skl_update_scaler_plane - Stages update to scaler state for a given plane.
4719 * @state: crtc's scaler state
4720 * @plane_state: atomic plane state to update
4723 * 0 - scaler_usage updated successfully
4724 * error - requested scaling cannot be supported or other error condition
4726 static int skl_update_scaler_plane(struct intel_crtc_state
*crtc_state
,
4727 struct intel_plane_state
*plane_state
)
4730 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc_state
->base
.crtc
);
4731 struct intel_plane
*intel_plane
=
4732 to_intel_plane(plane_state
->base
.plane
);
4733 struct drm_framebuffer
*fb
= plane_state
->base
.fb
;
4736 bool force_detach
= !fb
|| !plane_state
->base
.visible
;
4738 DRM_DEBUG_KMS("Updating scaler for [PLANE:%d:%s] scaler_user index %u.%u\n",
4739 intel_plane
->base
.base
.id
, intel_plane
->base
.name
,
4740 intel_crtc
->pipe
, drm_plane_index(&intel_plane
->base
));
4742 ret
= skl_update_scaler(crtc_state
, force_detach
,
4743 drm_plane_index(&intel_plane
->base
),
4744 &plane_state
->scaler_id
,
4745 plane_state
->base
.rotation
,
4746 drm_rect_width(&plane_state
->base
.src
) >> 16,
4747 drm_rect_height(&plane_state
->base
.src
) >> 16,
4748 drm_rect_width(&plane_state
->base
.dst
),
4749 drm_rect_height(&plane_state
->base
.dst
));
4751 if (ret
|| plane_state
->scaler_id
< 0)
4754 /* check colorkey */
4755 if (plane_state
->ckey
.flags
!= I915_SET_COLORKEY_NONE
) {
4756 DRM_DEBUG_KMS("[PLANE:%d:%s] scaling with color key not allowed",
4757 intel_plane
->base
.base
.id
,
4758 intel_plane
->base
.name
);
4762 /* Check src format */
4763 switch (fb
->pixel_format
) {
4764 case DRM_FORMAT_RGB565
:
4765 case DRM_FORMAT_XBGR8888
:
4766 case DRM_FORMAT_XRGB8888
:
4767 case DRM_FORMAT_ABGR8888
:
4768 case DRM_FORMAT_ARGB8888
:
4769 case DRM_FORMAT_XRGB2101010
:
4770 case DRM_FORMAT_XBGR2101010
:
4771 case DRM_FORMAT_YUYV
:
4772 case DRM_FORMAT_YVYU
:
4773 case DRM_FORMAT_UYVY
:
4774 case DRM_FORMAT_VYUY
:
4777 DRM_DEBUG_KMS("[PLANE:%d:%s] FB:%d unsupported scaling format 0x%x\n",
4778 intel_plane
->base
.base
.id
, intel_plane
->base
.name
,
4779 fb
->base
.id
, fb
->pixel_format
);
4786 static void skylake_scaler_disable(struct intel_crtc
*crtc
)
4790 for (i
= 0; i
< crtc
->num_scalers
; i
++)
4791 skl_detach_scaler(crtc
, i
);
4794 static void skylake_pfit_enable(struct intel_crtc
*crtc
)
4796 struct drm_device
*dev
= crtc
->base
.dev
;
4797 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4798 int pipe
= crtc
->pipe
;
4799 struct intel_crtc_scaler_state
*scaler_state
=
4800 &crtc
->config
->scaler_state
;
4802 DRM_DEBUG_KMS("for crtc_state = %p\n", crtc
->config
);
4804 if (crtc
->config
->pch_pfit
.enabled
) {
4807 if (WARN_ON(crtc
->config
->scaler_state
.scaler_id
< 0)) {
4808 DRM_ERROR("Requesting pfit without getting a scaler first\n");
4812 id
= scaler_state
->scaler_id
;
4813 I915_WRITE(SKL_PS_CTRL(pipe
, id
), PS_SCALER_EN
|
4814 PS_FILTER_MEDIUM
| scaler_state
->scalers
[id
].mode
);
4815 I915_WRITE(SKL_PS_WIN_POS(pipe
, id
), crtc
->config
->pch_pfit
.pos
);
4816 I915_WRITE(SKL_PS_WIN_SZ(pipe
, id
), crtc
->config
->pch_pfit
.size
);
4818 DRM_DEBUG_KMS("for crtc_state = %p scaler_id = %d\n", crtc
->config
, id
);
4822 static void ironlake_pfit_enable(struct intel_crtc
*crtc
)
4824 struct drm_device
*dev
= crtc
->base
.dev
;
4825 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4826 int pipe
= crtc
->pipe
;
4828 if (crtc
->config
->pch_pfit
.enabled
) {
4829 /* Force use of hard-coded filter coefficients
4830 * as some pre-programmed values are broken,
4833 if (IS_IVYBRIDGE(dev
) || IS_HASWELL(dev
))
4834 I915_WRITE(PF_CTL(pipe
), PF_ENABLE
| PF_FILTER_MED_3x3
|
4835 PF_PIPE_SEL_IVB(pipe
));
4837 I915_WRITE(PF_CTL(pipe
), PF_ENABLE
| PF_FILTER_MED_3x3
);
4838 I915_WRITE(PF_WIN_POS(pipe
), crtc
->config
->pch_pfit
.pos
);
4839 I915_WRITE(PF_WIN_SZ(pipe
), crtc
->config
->pch_pfit
.size
);
4843 void hsw_enable_ips(struct intel_crtc
*crtc
)
4845 struct drm_device
*dev
= crtc
->base
.dev
;
4846 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4848 if (!crtc
->config
->ips_enabled
)
4852 * We can only enable IPS after we enable a plane and wait for a vblank
4853 * This function is called from post_plane_update, which is run after
4857 assert_plane_enabled(dev_priv
, crtc
->plane
);
4858 if (IS_BROADWELL(dev
)) {
4859 mutex_lock(&dev_priv
->rps
.hw_lock
);
4860 WARN_ON(sandybridge_pcode_write(dev_priv
, DISPLAY_IPS_CONTROL
, 0xc0000000));
4861 mutex_unlock(&dev_priv
->rps
.hw_lock
);
4862 /* Quoting Art Runyan: "its not safe to expect any particular
4863 * value in IPS_CTL bit 31 after enabling IPS through the
4864 * mailbox." Moreover, the mailbox may return a bogus state,
4865 * so we need to just enable it and continue on.
4868 I915_WRITE(IPS_CTL
, IPS_ENABLE
);
4869 /* The bit only becomes 1 in the next vblank, so this wait here
4870 * is essentially intel_wait_for_vblank. If we don't have this
4871 * and don't wait for vblanks until the end of crtc_enable, then
4872 * the HW state readout code will complain that the expected
4873 * IPS_CTL value is not the one we read. */
4874 if (intel_wait_for_register(dev_priv
,
4875 IPS_CTL
, IPS_ENABLE
, IPS_ENABLE
,
4877 DRM_ERROR("Timed out waiting for IPS enable\n");
4881 void hsw_disable_ips(struct intel_crtc
*crtc
)
4883 struct drm_device
*dev
= crtc
->base
.dev
;
4884 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4886 if (!crtc
->config
->ips_enabled
)
4889 assert_plane_enabled(dev_priv
, crtc
->plane
);
4890 if (IS_BROADWELL(dev
)) {
4891 mutex_lock(&dev_priv
->rps
.hw_lock
);
4892 WARN_ON(sandybridge_pcode_write(dev_priv
, DISPLAY_IPS_CONTROL
, 0));
4893 mutex_unlock(&dev_priv
->rps
.hw_lock
);
4894 /* wait for pcode to finish disabling IPS, which may take up to 42ms */
4895 if (intel_wait_for_register(dev_priv
,
4896 IPS_CTL
, IPS_ENABLE
, 0,
4898 DRM_ERROR("Timed out waiting for IPS disable\n");
4900 I915_WRITE(IPS_CTL
, 0);
4901 POSTING_READ(IPS_CTL
);
4904 /* We need to wait for a vblank before we can disable the plane. */
4905 intel_wait_for_vblank(dev
, crtc
->pipe
);
4908 static void intel_crtc_dpms_overlay_disable(struct intel_crtc
*intel_crtc
)
4910 if (intel_crtc
->overlay
) {
4911 struct drm_device
*dev
= intel_crtc
->base
.dev
;
4912 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4914 mutex_lock(&dev
->struct_mutex
);
4915 dev_priv
->mm
.interruptible
= false;
4916 (void) intel_overlay_switch_off(intel_crtc
->overlay
);
4917 dev_priv
->mm
.interruptible
= true;
4918 mutex_unlock(&dev
->struct_mutex
);
4921 /* Let userspace switch the overlay on again. In most cases userspace
4922 * has to recompute where to put it anyway.
4927 * intel_post_enable_primary - Perform operations after enabling primary plane
4928 * @crtc: the CRTC whose primary plane was just enabled
4930 * Performs potentially sleeping operations that must be done after the primary
4931 * plane is enabled, such as updating FBC and IPS. Note that this may be
4932 * called due to an explicit primary plane update, or due to an implicit
4933 * re-enable that is caused when a sprite plane is updated to no longer
4934 * completely hide the primary plane.
4937 intel_post_enable_primary(struct drm_crtc
*crtc
)
4939 struct drm_device
*dev
= crtc
->dev
;
4940 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4941 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
4942 int pipe
= intel_crtc
->pipe
;
4945 * FIXME IPS should be fine as long as one plane is
4946 * enabled, but in practice it seems to have problems
4947 * when going from primary only to sprite only and vice
4950 hsw_enable_ips(intel_crtc
);
4953 * Gen2 reports pipe underruns whenever all planes are disabled.
4954 * So don't enable underrun reporting before at least some planes
4956 * FIXME: Need to fix the logic to work when we turn off all planes
4957 * but leave the pipe running.
4960 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, true);
4962 /* Underruns don't always raise interrupts, so check manually. */
4963 intel_check_cpu_fifo_underruns(dev_priv
);
4964 intel_check_pch_fifo_underruns(dev_priv
);
4967 /* FIXME move all this to pre_plane_update() with proper state tracking */
4969 intel_pre_disable_primary(struct drm_crtc
*crtc
)
4971 struct drm_device
*dev
= crtc
->dev
;
4972 struct drm_i915_private
*dev_priv
= to_i915(dev
);
4973 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
4974 int pipe
= intel_crtc
->pipe
;
4977 * Gen2 reports pipe underruns whenever all planes are disabled.
4978 * So diasble underrun reporting before all the planes get disabled.
4979 * FIXME: Need to fix the logic to work when we turn off all planes
4980 * but leave the pipe running.
4983 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, false);
4986 * FIXME IPS should be fine as long as one plane is
4987 * enabled, but in practice it seems to have problems
4988 * when going from primary only to sprite only and vice
4991 hsw_disable_ips(intel_crtc
);
4994 /* FIXME get rid of this and use pre_plane_update */
4996 intel_pre_disable_primary_noatomic(struct drm_crtc
*crtc
)
4998 struct drm_device
*dev
= crtc
->dev
;
4999 struct drm_i915_private
*dev_priv
= to_i915(dev
);
5000 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
5001 int pipe
= intel_crtc
->pipe
;
5003 intel_pre_disable_primary(crtc
);
5006 * Vblank time updates from the shadow to live plane control register
5007 * are blocked if the memory self-refresh mode is active at that
5008 * moment. So to make sure the plane gets truly disabled, disable
5009 * first the self-refresh mode. The self-refresh enable bit in turn
5010 * will be checked/applied by the HW only at the next frame start
5011 * event which is after the vblank start event, so we need to have a
5012 * wait-for-vblank between disabling the plane and the pipe.
5014 if (HAS_GMCH_DISPLAY(dev
)) {
5015 intel_set_memory_cxsr(dev_priv
, false);
5016 dev_priv
->wm
.vlv
.cxsr
= false;
5017 intel_wait_for_vblank(dev
, pipe
);
5021 static void intel_post_plane_update(struct intel_crtc_state
*old_crtc_state
)
5023 struct intel_crtc
*crtc
= to_intel_crtc(old_crtc_state
->base
.crtc
);
5024 struct drm_atomic_state
*old_state
= old_crtc_state
->base
.state
;
5025 struct intel_crtc_state
*pipe_config
=
5026 to_intel_crtc_state(crtc
->base
.state
);
5027 struct drm_plane
*primary
= crtc
->base
.primary
;
5028 struct drm_plane_state
*old_pri_state
=
5029 drm_atomic_get_existing_plane_state(old_state
, primary
);
5031 intel_frontbuffer_flip(to_i915(crtc
->base
.dev
), pipe_config
->fb_bits
);
5033 crtc
->wm
.cxsr_allowed
= true;
5035 if (pipe_config
->update_wm_post
&& pipe_config
->base
.active
)
5036 intel_update_watermarks(&crtc
->base
);
5038 if (old_pri_state
) {
5039 struct intel_plane_state
*primary_state
=
5040 to_intel_plane_state(primary
->state
);
5041 struct intel_plane_state
*old_primary_state
=
5042 to_intel_plane_state(old_pri_state
);
5044 intel_fbc_post_update(crtc
);
5046 if (primary_state
->base
.visible
&&
5047 (needs_modeset(&pipe_config
->base
) ||
5048 !old_primary_state
->base
.visible
))
5049 intel_post_enable_primary(&crtc
->base
);
5053 static void intel_pre_plane_update(struct intel_crtc_state
*old_crtc_state
)
5055 struct intel_crtc
*crtc
= to_intel_crtc(old_crtc_state
->base
.crtc
);
5056 struct drm_device
*dev
= crtc
->base
.dev
;
5057 struct drm_i915_private
*dev_priv
= to_i915(dev
);
5058 struct intel_crtc_state
*pipe_config
=
5059 to_intel_crtc_state(crtc
->base
.state
);
5060 struct drm_atomic_state
*old_state
= old_crtc_state
->base
.state
;
5061 struct drm_plane
*primary
= crtc
->base
.primary
;
5062 struct drm_plane_state
*old_pri_state
=
5063 drm_atomic_get_existing_plane_state(old_state
, primary
);
5064 bool modeset
= needs_modeset(&pipe_config
->base
);
5066 if (old_pri_state
) {
5067 struct intel_plane_state
*primary_state
=
5068 to_intel_plane_state(primary
->state
);
5069 struct intel_plane_state
*old_primary_state
=
5070 to_intel_plane_state(old_pri_state
);
5072 intel_fbc_pre_update(crtc
, pipe_config
, primary_state
);
5074 if (old_primary_state
->base
.visible
&&
5075 (modeset
|| !primary_state
->base
.visible
))
5076 intel_pre_disable_primary(&crtc
->base
);
5079 if (pipe_config
->disable_cxsr
&& HAS_GMCH_DISPLAY(dev
)) {
5080 crtc
->wm
.cxsr_allowed
= false;
5083 * Vblank time updates from the shadow to live plane control register
5084 * are blocked if the memory self-refresh mode is active at that
5085 * moment. So to make sure the plane gets truly disabled, disable
5086 * first the self-refresh mode. The self-refresh enable bit in turn
5087 * will be checked/applied by the HW only at the next frame start
5088 * event which is after the vblank start event, so we need to have a
5089 * wait-for-vblank between disabling the plane and the pipe.
5091 if (old_crtc_state
->base
.active
) {
5092 intel_set_memory_cxsr(dev_priv
, false);
5093 dev_priv
->wm
.vlv
.cxsr
= false;
5094 intel_wait_for_vblank(dev
, crtc
->pipe
);
5099 * IVB workaround: must disable low power watermarks for at least
5100 * one frame before enabling scaling. LP watermarks can be re-enabled
5101 * when scaling is disabled.
5103 * WaCxSRDisabledForSpriteScaling:ivb
5105 if (pipe_config
->disable_lp_wm
) {
5106 ilk_disable_lp_wm(dev
);
5107 intel_wait_for_vblank(dev
, crtc
->pipe
);
5111 * If we're doing a modeset, we're done. No need to do any pre-vblank
5112 * watermark programming here.
5114 if (needs_modeset(&pipe_config
->base
))
5118 * For platforms that support atomic watermarks, program the
5119 * 'intermediate' watermarks immediately. On pre-gen9 platforms, these
5120 * will be the intermediate values that are safe for both pre- and
5121 * post- vblank; when vblank happens, the 'active' values will be set
5122 * to the final 'target' values and we'll do this again to get the
5123 * optimal watermarks. For gen9+ platforms, the values we program here
5124 * will be the final target values which will get automatically latched
5125 * at vblank time; no further programming will be necessary.
5127 * If a platform hasn't been transitioned to atomic watermarks yet,
5128 * we'll continue to update watermarks the old way, if flags tell
5131 if (dev_priv
->display
.initial_watermarks
!= NULL
)
5132 dev_priv
->display
.initial_watermarks(pipe_config
);
5133 else if (pipe_config
->update_wm_pre
)
5134 intel_update_watermarks(&crtc
->base
);
5137 static void intel_crtc_disable_planes(struct drm_crtc
*crtc
, unsigned plane_mask
)
5139 struct drm_device
*dev
= crtc
->dev
;
5140 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
5141 struct drm_plane
*p
;
5142 int pipe
= intel_crtc
->pipe
;
5144 intel_crtc_dpms_overlay_disable(intel_crtc
);
5146 drm_for_each_plane_mask(p
, dev
, plane_mask
)
5147 to_intel_plane(p
)->disable_plane(p
, crtc
);
5150 * FIXME: Once we grow proper nuclear flip support out of this we need
5151 * to compute the mask of flip planes precisely. For the time being
5152 * consider this a flip to a NULL plane.
5154 intel_frontbuffer_flip(to_i915(dev
), INTEL_FRONTBUFFER_ALL_MASK(pipe
));
5157 static void ironlake_crtc_enable(struct drm_crtc
*crtc
)
5159 struct drm_device
*dev
= crtc
->dev
;
5160 struct drm_i915_private
*dev_priv
= to_i915(dev
);
5161 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
5162 struct intel_encoder
*encoder
;
5163 int pipe
= intel_crtc
->pipe
;
5164 struct intel_crtc_state
*pipe_config
=
5165 to_intel_crtc_state(crtc
->state
);
5167 if (WARN_ON(intel_crtc
->active
))
5171 * Sometimes spurious CPU pipe underruns happen during FDI
5172 * training, at least with VGA+HDMI cloning. Suppress them.
5174 * On ILK we get an occasional spurious CPU pipe underruns
5175 * between eDP port A enable and vdd enable. Also PCH port
5176 * enable seems to result in the occasional CPU pipe underrun.
5178 * Spurious PCH underruns also occur during PCH enabling.
5180 if (intel_crtc
->config
->has_pch_encoder
|| IS_GEN5(dev_priv
))
5181 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, false);
5182 if (intel_crtc
->config
->has_pch_encoder
)
5183 intel_set_pch_fifo_underrun_reporting(dev_priv
, pipe
, false);
5185 if (intel_crtc
->config
->has_pch_encoder
)
5186 intel_prepare_shared_dpll(intel_crtc
);
5188 if (intel_crtc_has_dp_encoder(intel_crtc
->config
))
5189 intel_dp_set_m_n(intel_crtc
, M1_N1
);
5191 intel_set_pipe_timings(intel_crtc
);
5192 intel_set_pipe_src_size(intel_crtc
);
5194 if (intel_crtc
->config
->has_pch_encoder
) {
5195 intel_cpu_transcoder_set_m_n(intel_crtc
,
5196 &intel_crtc
->config
->fdi_m_n
, NULL
);
5199 ironlake_set_pipeconf(crtc
);
5201 intel_crtc
->active
= true;
5203 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
5204 if (encoder
->pre_enable
)
5205 encoder
->pre_enable(encoder
);
5207 if (intel_crtc
->config
->has_pch_encoder
) {
5208 /* Note: FDI PLL enabling _must_ be done before we enable the
5209 * cpu pipes, hence this is separate from all the other fdi/pch
5211 ironlake_fdi_pll_enable(intel_crtc
);
5213 assert_fdi_tx_disabled(dev_priv
, pipe
);
5214 assert_fdi_rx_disabled(dev_priv
, pipe
);
5217 ironlake_pfit_enable(intel_crtc
);
5220 * On ILK+ LUT must be loaded before the pipe is running but with
5223 intel_color_load_luts(&pipe_config
->base
);
5225 if (dev_priv
->display
.initial_watermarks
!= NULL
)
5226 dev_priv
->display
.initial_watermarks(intel_crtc
->config
);
5227 intel_enable_pipe(intel_crtc
);
5229 if (intel_crtc
->config
->has_pch_encoder
)
5230 ironlake_pch_enable(crtc
);
5232 assert_vblank_disabled(crtc
);
5233 drm_crtc_vblank_on(crtc
);
5235 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
5236 encoder
->enable(encoder
);
5238 if (HAS_PCH_CPT(dev
))
5239 cpt_verify_modeset(dev
, intel_crtc
->pipe
);
5241 /* Must wait for vblank to avoid spurious PCH FIFO underruns */
5242 if (intel_crtc
->config
->has_pch_encoder
)
5243 intel_wait_for_vblank(dev
, pipe
);
5244 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, true);
5245 intel_set_pch_fifo_underrun_reporting(dev_priv
, pipe
, true);
5248 /* IPS only exists on ULT machines and is tied to pipe A. */
5249 static bool hsw_crtc_supports_ips(struct intel_crtc
*crtc
)
5251 return HAS_IPS(crtc
->base
.dev
) && crtc
->pipe
== PIPE_A
;
5254 static void haswell_crtc_enable(struct drm_crtc
*crtc
)
5256 struct drm_device
*dev
= crtc
->dev
;
5257 struct drm_i915_private
*dev_priv
= to_i915(dev
);
5258 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
5259 struct intel_encoder
*encoder
;
5260 int pipe
= intel_crtc
->pipe
, hsw_workaround_pipe
;
5261 enum transcoder cpu_transcoder
= intel_crtc
->config
->cpu_transcoder
;
5262 struct intel_crtc_state
*pipe_config
=
5263 to_intel_crtc_state(crtc
->state
);
5265 if (WARN_ON(intel_crtc
->active
))
5268 if (intel_crtc
->config
->has_pch_encoder
)
5269 intel_set_pch_fifo_underrun_reporting(dev_priv
, TRANSCODER_A
,
5272 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
5273 if (encoder
->pre_pll_enable
)
5274 encoder
->pre_pll_enable(encoder
);
5276 if (intel_crtc
->config
->shared_dpll
)
5277 intel_enable_shared_dpll(intel_crtc
);
5279 if (intel_crtc_has_dp_encoder(intel_crtc
->config
))
5280 intel_dp_set_m_n(intel_crtc
, M1_N1
);
5282 if (!transcoder_is_dsi(cpu_transcoder
))
5283 intel_set_pipe_timings(intel_crtc
);
5285 intel_set_pipe_src_size(intel_crtc
);
5287 if (cpu_transcoder
!= TRANSCODER_EDP
&&
5288 !transcoder_is_dsi(cpu_transcoder
)) {
5289 I915_WRITE(PIPE_MULT(cpu_transcoder
),
5290 intel_crtc
->config
->pixel_multiplier
- 1);
5293 if (intel_crtc
->config
->has_pch_encoder
) {
5294 intel_cpu_transcoder_set_m_n(intel_crtc
,
5295 &intel_crtc
->config
->fdi_m_n
, NULL
);
5298 if (!transcoder_is_dsi(cpu_transcoder
))
5299 haswell_set_pipeconf(crtc
);
5301 haswell_set_pipemisc(crtc
);
5303 intel_color_set_csc(&pipe_config
->base
);
5305 intel_crtc
->active
= true;
5307 if (intel_crtc
->config
->has_pch_encoder
)
5308 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, false);
5310 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, true);
5312 for_each_encoder_on_crtc(dev
, crtc
, encoder
) {
5313 if (encoder
->pre_enable
)
5314 encoder
->pre_enable(encoder
);
5317 if (intel_crtc
->config
->has_pch_encoder
)
5318 dev_priv
->display
.fdi_link_train(crtc
);
5320 if (!transcoder_is_dsi(cpu_transcoder
))
5321 intel_ddi_enable_pipe_clock(intel_crtc
);
5323 if (INTEL_INFO(dev
)->gen
>= 9)
5324 skylake_pfit_enable(intel_crtc
);
5326 ironlake_pfit_enable(intel_crtc
);
5329 * On ILK+ LUT must be loaded before the pipe is running but with
5332 intel_color_load_luts(&pipe_config
->base
);
5334 intel_ddi_set_pipe_settings(crtc
);
5335 if (!transcoder_is_dsi(cpu_transcoder
))
5336 intel_ddi_enable_transcoder_func(crtc
);
5338 if (dev_priv
->display
.initial_watermarks
!= NULL
)
5339 dev_priv
->display
.initial_watermarks(pipe_config
);
5341 intel_update_watermarks(crtc
);
5343 /* XXX: Do the pipe assertions at the right place for BXT DSI. */
5344 if (!transcoder_is_dsi(cpu_transcoder
))
5345 intel_enable_pipe(intel_crtc
);
5347 if (intel_crtc
->config
->has_pch_encoder
)
5348 lpt_pch_enable(crtc
);
5350 if (intel_crtc
->config
->dp_encoder_is_mst
)
5351 intel_ddi_set_vc_payload_alloc(crtc
, true);
5353 assert_vblank_disabled(crtc
);
5354 drm_crtc_vblank_on(crtc
);
5356 for_each_encoder_on_crtc(dev
, crtc
, encoder
) {
5357 encoder
->enable(encoder
);
5358 intel_opregion_notify_encoder(encoder
, true);
5361 if (intel_crtc
->config
->has_pch_encoder
) {
5362 intel_wait_for_vblank(dev
, pipe
);
5363 intel_wait_for_vblank(dev
, pipe
);
5364 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, true);
5365 intel_set_pch_fifo_underrun_reporting(dev_priv
, TRANSCODER_A
,
5369 /* If we change the relative order between pipe/planes enabling, we need
5370 * to change the workaround. */
5371 hsw_workaround_pipe
= pipe_config
->hsw_workaround_pipe
;
5372 if (IS_HASWELL(dev
) && hsw_workaround_pipe
!= INVALID_PIPE
) {
5373 intel_wait_for_vblank(dev
, hsw_workaround_pipe
);
5374 intel_wait_for_vblank(dev
, hsw_workaround_pipe
);
5378 static void ironlake_pfit_disable(struct intel_crtc
*crtc
, bool force
)
5380 struct drm_device
*dev
= crtc
->base
.dev
;
5381 struct drm_i915_private
*dev_priv
= to_i915(dev
);
5382 int pipe
= crtc
->pipe
;
5384 /* To avoid upsetting the power well on haswell only disable the pfit if
5385 * it's in use. The hw state code will make sure we get this right. */
5386 if (force
|| crtc
->config
->pch_pfit
.enabled
) {
5387 I915_WRITE(PF_CTL(pipe
), 0);
5388 I915_WRITE(PF_WIN_POS(pipe
), 0);
5389 I915_WRITE(PF_WIN_SZ(pipe
), 0);
5393 static void ironlake_crtc_disable(struct drm_crtc
*crtc
)
5395 struct drm_device
*dev
= crtc
->dev
;
5396 struct drm_i915_private
*dev_priv
= to_i915(dev
);
5397 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
5398 struct intel_encoder
*encoder
;
5399 int pipe
= intel_crtc
->pipe
;
5402 * Sometimes spurious CPU pipe underruns happen when the
5403 * pipe is already disabled, but FDI RX/TX is still enabled.
5404 * Happens at least with VGA+HDMI cloning. Suppress them.
5406 if (intel_crtc
->config
->has_pch_encoder
) {
5407 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, false);
5408 intel_set_pch_fifo_underrun_reporting(dev_priv
, pipe
, false);
5411 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
5412 encoder
->disable(encoder
);
5414 drm_crtc_vblank_off(crtc
);
5415 assert_vblank_disabled(crtc
);
5417 intel_disable_pipe(intel_crtc
);
5419 ironlake_pfit_disable(intel_crtc
, false);
5421 if (intel_crtc
->config
->has_pch_encoder
)
5422 ironlake_fdi_disable(crtc
);
5424 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
5425 if (encoder
->post_disable
)
5426 encoder
->post_disable(encoder
);
5428 if (intel_crtc
->config
->has_pch_encoder
) {
5429 ironlake_disable_pch_transcoder(dev_priv
, pipe
);
5431 if (HAS_PCH_CPT(dev
)) {
5435 /* disable TRANS_DP_CTL */
5436 reg
= TRANS_DP_CTL(pipe
);
5437 temp
= I915_READ(reg
);
5438 temp
&= ~(TRANS_DP_OUTPUT_ENABLE
|
5439 TRANS_DP_PORT_SEL_MASK
);
5440 temp
|= TRANS_DP_PORT_SEL_NONE
;
5441 I915_WRITE(reg
, temp
);
5443 /* disable DPLL_SEL */
5444 temp
= I915_READ(PCH_DPLL_SEL
);
5445 temp
&= ~(TRANS_DPLL_ENABLE(pipe
) | TRANS_DPLLB_SEL(pipe
));
5446 I915_WRITE(PCH_DPLL_SEL
, temp
);
5449 ironlake_fdi_pll_disable(intel_crtc
);
5452 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, true);
5453 intel_set_pch_fifo_underrun_reporting(dev_priv
, pipe
, true);
5456 static void haswell_crtc_disable(struct drm_crtc
*crtc
)
5458 struct drm_device
*dev
= crtc
->dev
;
5459 struct drm_i915_private
*dev_priv
= to_i915(dev
);
5460 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
5461 struct intel_encoder
*encoder
;
5462 enum transcoder cpu_transcoder
= intel_crtc
->config
->cpu_transcoder
;
5464 if (intel_crtc
->config
->has_pch_encoder
)
5465 intel_set_pch_fifo_underrun_reporting(dev_priv
, TRANSCODER_A
,
5468 for_each_encoder_on_crtc(dev
, crtc
, encoder
) {
5469 intel_opregion_notify_encoder(encoder
, false);
5470 encoder
->disable(encoder
);
5473 drm_crtc_vblank_off(crtc
);
5474 assert_vblank_disabled(crtc
);
5476 /* XXX: Do the pipe assertions at the right place for BXT DSI. */
5477 if (!transcoder_is_dsi(cpu_transcoder
))
5478 intel_disable_pipe(intel_crtc
);
5480 if (intel_crtc
->config
->dp_encoder_is_mst
)
5481 intel_ddi_set_vc_payload_alloc(crtc
, false);
5483 if (!transcoder_is_dsi(cpu_transcoder
))
5484 intel_ddi_disable_transcoder_func(dev_priv
, cpu_transcoder
);
5486 if (INTEL_INFO(dev
)->gen
>= 9)
5487 skylake_scaler_disable(intel_crtc
);
5489 ironlake_pfit_disable(intel_crtc
, false);
5491 if (!transcoder_is_dsi(cpu_transcoder
))
5492 intel_ddi_disable_pipe_clock(intel_crtc
);
5494 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
5495 if (encoder
->post_disable
)
5496 encoder
->post_disable(encoder
);
5498 if (intel_crtc
->config
->has_pch_encoder
) {
5499 lpt_disable_pch_transcoder(dev_priv
);
5500 lpt_disable_iclkip(dev_priv
);
5501 intel_ddi_fdi_disable(crtc
);
5503 intel_set_pch_fifo_underrun_reporting(dev_priv
, TRANSCODER_A
,
5508 static void i9xx_pfit_enable(struct intel_crtc
*crtc
)
5510 struct drm_device
*dev
= crtc
->base
.dev
;
5511 struct drm_i915_private
*dev_priv
= to_i915(dev
);
5512 struct intel_crtc_state
*pipe_config
= crtc
->config
;
5514 if (!pipe_config
->gmch_pfit
.control
)
5518 * The panel fitter should only be adjusted whilst the pipe is disabled,
5519 * according to register description and PRM.
5521 WARN_ON(I915_READ(PFIT_CONTROL
) & PFIT_ENABLE
);
5522 assert_pipe_disabled(dev_priv
, crtc
->pipe
);
5524 I915_WRITE(PFIT_PGM_RATIOS
, pipe_config
->gmch_pfit
.pgm_ratios
);
5525 I915_WRITE(PFIT_CONTROL
, pipe_config
->gmch_pfit
.control
);
5527 /* Border color in case we don't scale up to the full screen. Black by
5528 * default, change to something else for debugging. */
5529 I915_WRITE(BCLRPAT(crtc
->pipe
), 0);
5532 static enum intel_display_power_domain
port_to_power_domain(enum port port
)
5536 return POWER_DOMAIN_PORT_DDI_A_LANES
;
5538 return POWER_DOMAIN_PORT_DDI_B_LANES
;
5540 return POWER_DOMAIN_PORT_DDI_C_LANES
;
5542 return POWER_DOMAIN_PORT_DDI_D_LANES
;
5544 return POWER_DOMAIN_PORT_DDI_E_LANES
;
5547 return POWER_DOMAIN_PORT_OTHER
;
5551 static enum intel_display_power_domain
port_to_aux_power_domain(enum port port
)
5555 return POWER_DOMAIN_AUX_A
;
5557 return POWER_DOMAIN_AUX_B
;
5559 return POWER_DOMAIN_AUX_C
;
5561 return POWER_DOMAIN_AUX_D
;
5563 /* FIXME: Check VBT for actual wiring of PORT E */
5564 return POWER_DOMAIN_AUX_D
;
5567 return POWER_DOMAIN_AUX_A
;
5571 enum intel_display_power_domain
5572 intel_display_port_power_domain(struct intel_encoder
*intel_encoder
)
5574 struct drm_device
*dev
= intel_encoder
->base
.dev
;
5575 struct intel_digital_port
*intel_dig_port
;
5577 switch (intel_encoder
->type
) {
5578 case INTEL_OUTPUT_UNKNOWN
:
5579 /* Only DDI platforms should ever use this output type */
5580 WARN_ON_ONCE(!HAS_DDI(dev
));
5581 case INTEL_OUTPUT_DP
:
5582 case INTEL_OUTPUT_HDMI
:
5583 case INTEL_OUTPUT_EDP
:
5584 intel_dig_port
= enc_to_dig_port(&intel_encoder
->base
);
5585 return port_to_power_domain(intel_dig_port
->port
);
5586 case INTEL_OUTPUT_DP_MST
:
5587 intel_dig_port
= enc_to_mst(&intel_encoder
->base
)->primary
;
5588 return port_to_power_domain(intel_dig_port
->port
);
5589 case INTEL_OUTPUT_ANALOG
:
5590 return POWER_DOMAIN_PORT_CRT
;
5591 case INTEL_OUTPUT_DSI
:
5592 return POWER_DOMAIN_PORT_DSI
;
5594 return POWER_DOMAIN_PORT_OTHER
;
5598 enum intel_display_power_domain
5599 intel_display_port_aux_power_domain(struct intel_encoder
*intel_encoder
)
5601 struct drm_device
*dev
= intel_encoder
->base
.dev
;
5602 struct intel_digital_port
*intel_dig_port
;
5604 switch (intel_encoder
->type
) {
5605 case INTEL_OUTPUT_UNKNOWN
:
5606 case INTEL_OUTPUT_HDMI
:
5608 * Only DDI platforms should ever use these output types.
5609 * We can get here after the HDMI detect code has already set
5610 * the type of the shared encoder. Since we can't be sure
5611 * what's the status of the given connectors, play safe and
5612 * run the DP detection too.
5614 WARN_ON_ONCE(!HAS_DDI(dev
));
5615 case INTEL_OUTPUT_DP
:
5616 case INTEL_OUTPUT_EDP
:
5617 intel_dig_port
= enc_to_dig_port(&intel_encoder
->base
);
5618 return port_to_aux_power_domain(intel_dig_port
->port
);
5619 case INTEL_OUTPUT_DP_MST
:
5620 intel_dig_port
= enc_to_mst(&intel_encoder
->base
)->primary
;
5621 return port_to_aux_power_domain(intel_dig_port
->port
);
5623 MISSING_CASE(intel_encoder
->type
);
5624 return POWER_DOMAIN_AUX_A
;
5628 static unsigned long get_crtc_power_domains(struct drm_crtc
*crtc
,
5629 struct intel_crtc_state
*crtc_state
)
5631 struct drm_device
*dev
= crtc
->dev
;
5632 struct drm_encoder
*encoder
;
5633 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
5634 enum pipe pipe
= intel_crtc
->pipe
;
5636 enum transcoder transcoder
= crtc_state
->cpu_transcoder
;
5638 if (!crtc_state
->base
.active
)
5641 mask
= BIT(POWER_DOMAIN_PIPE(pipe
));
5642 mask
|= BIT(POWER_DOMAIN_TRANSCODER(transcoder
));
5643 if (crtc_state
->pch_pfit
.enabled
||
5644 crtc_state
->pch_pfit
.force_thru
)
5645 mask
|= BIT(POWER_DOMAIN_PIPE_PANEL_FITTER(pipe
));
5647 drm_for_each_encoder_mask(encoder
, dev
, crtc_state
->base
.encoder_mask
) {
5648 struct intel_encoder
*intel_encoder
= to_intel_encoder(encoder
);
5650 mask
|= BIT(intel_display_port_power_domain(intel_encoder
));
5653 if (crtc_state
->shared_dpll
)
5654 mask
|= BIT(POWER_DOMAIN_PLLS
);
5659 static unsigned long
5660 modeset_get_crtc_power_domains(struct drm_crtc
*crtc
,
5661 struct intel_crtc_state
*crtc_state
)
5663 struct drm_i915_private
*dev_priv
= to_i915(crtc
->dev
);
5664 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
5665 enum intel_display_power_domain domain
;
5666 unsigned long domains
, new_domains
, old_domains
;
5668 old_domains
= intel_crtc
->enabled_power_domains
;
5669 intel_crtc
->enabled_power_domains
= new_domains
=
5670 get_crtc_power_domains(crtc
, crtc_state
);
5672 domains
= new_domains
& ~old_domains
;
5674 for_each_power_domain(domain
, domains
)
5675 intel_display_power_get(dev_priv
, domain
);
5677 return old_domains
& ~new_domains
;
5680 static void modeset_put_power_domains(struct drm_i915_private
*dev_priv
,
5681 unsigned long domains
)
5683 enum intel_display_power_domain domain
;
5685 for_each_power_domain(domain
, domains
)
5686 intel_display_power_put(dev_priv
, domain
);
5689 static int intel_compute_max_dotclk(struct drm_i915_private
*dev_priv
)
5691 int max_cdclk_freq
= dev_priv
->max_cdclk_freq
;
5693 if (INTEL_INFO(dev_priv
)->gen
>= 9 ||
5694 IS_HASWELL(dev_priv
) || IS_BROADWELL(dev_priv
))
5695 return max_cdclk_freq
;
5696 else if (IS_CHERRYVIEW(dev_priv
))
5697 return max_cdclk_freq
*95/100;
5698 else if (INTEL_INFO(dev_priv
)->gen
< 4)
5699 return 2*max_cdclk_freq
*90/100;
5701 return max_cdclk_freq
*90/100;
5704 static int skl_calc_cdclk(int max_pixclk
, int vco
);
5706 static void intel_update_max_cdclk(struct drm_device
*dev
)
5708 struct drm_i915_private
*dev_priv
= to_i915(dev
);
5710 if (IS_SKYLAKE(dev
) || IS_KABYLAKE(dev
)) {
5711 u32 limit
= I915_READ(SKL_DFSM
) & SKL_DFSM_CDCLK_LIMIT_MASK
;
5714 vco
= dev_priv
->skl_preferred_vco_freq
;
5715 WARN_ON(vco
!= 8100000 && vco
!= 8640000);
5718 * Use the lower (vco 8640) cdclk values as a
5719 * first guess. skl_calc_cdclk() will correct it
5720 * if the preferred vco is 8100 instead.
5722 if (limit
== SKL_DFSM_CDCLK_LIMIT_675
)
5724 else if (limit
== SKL_DFSM_CDCLK_LIMIT_540
)
5726 else if (limit
== SKL_DFSM_CDCLK_LIMIT_450
)
5731 dev_priv
->max_cdclk_freq
= skl_calc_cdclk(max_cdclk
, vco
);
5732 } else if (IS_BROXTON(dev
)) {
5733 dev_priv
->max_cdclk_freq
= 624000;
5734 } else if (IS_BROADWELL(dev
)) {
5736 * FIXME with extra cooling we can allow
5737 * 540 MHz for ULX and 675 Mhz for ULT.
5738 * How can we know if extra cooling is
5739 * available? PCI ID, VTB, something else?
5741 if (I915_READ(FUSE_STRAP
) & HSW_CDCLK_LIMIT
)
5742 dev_priv
->max_cdclk_freq
= 450000;
5743 else if (IS_BDW_ULX(dev
))
5744 dev_priv
->max_cdclk_freq
= 450000;
5745 else if (IS_BDW_ULT(dev
))
5746 dev_priv
->max_cdclk_freq
= 540000;
5748 dev_priv
->max_cdclk_freq
= 675000;
5749 } else if (IS_CHERRYVIEW(dev
)) {
5750 dev_priv
->max_cdclk_freq
= 320000;
5751 } else if (IS_VALLEYVIEW(dev
)) {
5752 dev_priv
->max_cdclk_freq
= 400000;
5754 /* otherwise assume cdclk is fixed */
5755 dev_priv
->max_cdclk_freq
= dev_priv
->cdclk_freq
;
5758 dev_priv
->max_dotclk_freq
= intel_compute_max_dotclk(dev_priv
);
5760 DRM_DEBUG_DRIVER("Max CD clock rate: %d kHz\n",
5761 dev_priv
->max_cdclk_freq
);
5763 DRM_DEBUG_DRIVER("Max dotclock rate: %d kHz\n",
5764 dev_priv
->max_dotclk_freq
);
5767 static void intel_update_cdclk(struct drm_device
*dev
)
5769 struct drm_i915_private
*dev_priv
= to_i915(dev
);
5771 dev_priv
->cdclk_freq
= dev_priv
->display
.get_display_clock_speed(dev
);
5773 if (INTEL_GEN(dev_priv
) >= 9)
5774 DRM_DEBUG_DRIVER("Current CD clock rate: %d kHz, VCO: %d kHz, ref: %d kHz\n",
5775 dev_priv
->cdclk_freq
, dev_priv
->cdclk_pll
.vco
,
5776 dev_priv
->cdclk_pll
.ref
);
5778 DRM_DEBUG_DRIVER("Current CD clock rate: %d kHz\n",
5779 dev_priv
->cdclk_freq
);
5782 * 9:0 CMBUS [sic] CDCLK frequency (cdfreq):
5783 * Programmng [sic] note: bit[9:2] should be programmed to the number
5784 * of cdclk that generates 4MHz reference clock freq which is used to
5785 * generate GMBus clock. This will vary with the cdclk freq.
5787 if (IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
))
5788 I915_WRITE(GMBUSFREQ_VLV
, DIV_ROUND_UP(dev_priv
->cdclk_freq
, 1000));
5791 /* convert from kHz to .1 fixpoint MHz with -1MHz offset */
5792 static int skl_cdclk_decimal(int cdclk
)
5794 return DIV_ROUND_CLOSEST(cdclk
- 1000, 500);
5797 static int bxt_de_pll_vco(struct drm_i915_private
*dev_priv
, int cdclk
)
5801 if (cdclk
== dev_priv
->cdclk_pll
.ref
)
5806 MISSING_CASE(cdclk
);
5818 return dev_priv
->cdclk_pll
.ref
* ratio
;
5821 static void bxt_de_pll_disable(struct drm_i915_private
*dev_priv
)
5823 I915_WRITE(BXT_DE_PLL_ENABLE
, 0);
5826 if (intel_wait_for_register(dev_priv
,
5827 BXT_DE_PLL_ENABLE
, BXT_DE_PLL_LOCK
, 0,
5829 DRM_ERROR("timeout waiting for DE PLL unlock\n");
5831 dev_priv
->cdclk_pll
.vco
= 0;
5834 static void bxt_de_pll_enable(struct drm_i915_private
*dev_priv
, int vco
)
5836 int ratio
= DIV_ROUND_CLOSEST(vco
, dev_priv
->cdclk_pll
.ref
);
5839 val
= I915_READ(BXT_DE_PLL_CTL
);
5840 val
&= ~BXT_DE_PLL_RATIO_MASK
;
5841 val
|= BXT_DE_PLL_RATIO(ratio
);
5842 I915_WRITE(BXT_DE_PLL_CTL
, val
);
5844 I915_WRITE(BXT_DE_PLL_ENABLE
, BXT_DE_PLL_PLL_ENABLE
);
5847 if (intel_wait_for_register(dev_priv
,
5852 DRM_ERROR("timeout waiting for DE PLL lock\n");
5854 dev_priv
->cdclk_pll
.vco
= vco
;
5857 static void bxt_set_cdclk(struct drm_i915_private
*dev_priv
, int cdclk
)
5862 vco
= bxt_de_pll_vco(dev_priv
, cdclk
);
5864 DRM_DEBUG_DRIVER("Changing CDCLK to %d kHz (VCO %d kHz)\n", cdclk
, vco
);
5866 /* cdclk = vco / 2 / div{1,1.5,2,4} */
5867 switch (DIV_ROUND_CLOSEST(vco
, cdclk
)) {
5869 divider
= BXT_CDCLK_CD2X_DIV_SEL_4
;
5872 divider
= BXT_CDCLK_CD2X_DIV_SEL_2
;
5875 divider
= BXT_CDCLK_CD2X_DIV_SEL_1_5
;
5878 divider
= BXT_CDCLK_CD2X_DIV_SEL_1
;
5881 WARN_ON(cdclk
!= dev_priv
->cdclk_pll
.ref
);
5884 divider
= BXT_CDCLK_CD2X_DIV_SEL_1
;
5888 /* Inform power controller of upcoming frequency change */
5889 mutex_lock(&dev_priv
->rps
.hw_lock
);
5890 ret
= sandybridge_pcode_write(dev_priv
, HSW_PCODE_DE_WRITE_FREQ_REQ
,
5892 mutex_unlock(&dev_priv
->rps
.hw_lock
);
5895 DRM_ERROR("PCode CDCLK freq change notify failed (err %d, freq %d)\n",
5900 if (dev_priv
->cdclk_pll
.vco
!= 0 &&
5901 dev_priv
->cdclk_pll
.vco
!= vco
)
5902 bxt_de_pll_disable(dev_priv
);
5904 if (dev_priv
->cdclk_pll
.vco
!= vco
)
5905 bxt_de_pll_enable(dev_priv
, vco
);
5907 val
= divider
| skl_cdclk_decimal(cdclk
);
5909 * FIXME if only the cd2x divider needs changing, it could be done
5910 * without shutting off the pipe (if only one pipe is active).
5912 val
|= BXT_CDCLK_CD2X_PIPE_NONE
;
5914 * Disable SSA Precharge when CD clock frequency < 500 MHz,
5917 if (cdclk
>= 500000)
5918 val
|= BXT_CDCLK_SSA_PRECHARGE_ENABLE
;
5919 I915_WRITE(CDCLK_CTL
, val
);
5921 mutex_lock(&dev_priv
->rps
.hw_lock
);
5922 ret
= sandybridge_pcode_write(dev_priv
, HSW_PCODE_DE_WRITE_FREQ_REQ
,
5923 DIV_ROUND_UP(cdclk
, 25000));
5924 mutex_unlock(&dev_priv
->rps
.hw_lock
);
5927 DRM_ERROR("PCode CDCLK freq set failed, (err %d, freq %d)\n",
5932 intel_update_cdclk(&dev_priv
->drm
);
5935 static void bxt_sanitize_cdclk(struct drm_i915_private
*dev_priv
)
5937 u32 cdctl
, expected
;
5939 intel_update_cdclk(&dev_priv
->drm
);
5941 if (dev_priv
->cdclk_pll
.vco
== 0 ||
5942 dev_priv
->cdclk_freq
== dev_priv
->cdclk_pll
.ref
)
5945 /* DPLL okay; verify the cdclock
5947 * Some BIOS versions leave an incorrect decimal frequency value and
5948 * set reserved MBZ bits in CDCLK_CTL at least during exiting from S4,
5949 * so sanitize this register.
5951 cdctl
= I915_READ(CDCLK_CTL
);
5953 * Let's ignore the pipe field, since BIOS could have configured the
5954 * dividers both synching to an active pipe, or asynchronously
5957 cdctl
&= ~BXT_CDCLK_CD2X_PIPE_NONE
;
5959 expected
= (cdctl
& BXT_CDCLK_CD2X_DIV_SEL_MASK
) |
5960 skl_cdclk_decimal(dev_priv
->cdclk_freq
);
5962 * Disable SSA Precharge when CD clock frequency < 500 MHz,
5965 if (dev_priv
->cdclk_freq
>= 500000)
5966 expected
|= BXT_CDCLK_SSA_PRECHARGE_ENABLE
;
5968 if (cdctl
== expected
)
5969 /* All well; nothing to sanitize */
5973 DRM_DEBUG_KMS("Sanitizing cdclk programmed by pre-os\n");
5975 /* force cdclk programming */
5976 dev_priv
->cdclk_freq
= 0;
5978 /* force full PLL disable + enable */
5979 dev_priv
->cdclk_pll
.vco
= -1;
5982 void bxt_init_cdclk(struct drm_i915_private
*dev_priv
)
5984 bxt_sanitize_cdclk(dev_priv
);
5986 if (dev_priv
->cdclk_freq
!= 0 && dev_priv
->cdclk_pll
.vco
!= 0)
5991 * - The initial CDCLK needs to be read from VBT.
5992 * Need to make this change after VBT has changes for BXT.
5994 bxt_set_cdclk(dev_priv
, bxt_calc_cdclk(0));
5997 void bxt_uninit_cdclk(struct drm_i915_private
*dev_priv
)
5999 bxt_set_cdclk(dev_priv
, dev_priv
->cdclk_pll
.ref
);
6002 static int skl_calc_cdclk(int max_pixclk
, int vco
)
6004 if (vco
== 8640000) {
6005 if (max_pixclk
> 540000)
6007 else if (max_pixclk
> 432000)
6009 else if (max_pixclk
> 308571)
6014 if (max_pixclk
> 540000)
6016 else if (max_pixclk
> 450000)
6018 else if (max_pixclk
> 337500)
6026 skl_dpll0_update(struct drm_i915_private
*dev_priv
)
6030 dev_priv
->cdclk_pll
.ref
= 24000;
6031 dev_priv
->cdclk_pll
.vco
= 0;
6033 val
= I915_READ(LCPLL1_CTL
);
6034 if ((val
& LCPLL_PLL_ENABLE
) == 0)
6037 if (WARN_ON((val
& LCPLL_PLL_LOCK
) == 0))
6040 val
= I915_READ(DPLL_CTRL1
);
6042 if (WARN_ON((val
& (DPLL_CTRL1_HDMI_MODE(SKL_DPLL0
) |
6043 DPLL_CTRL1_SSC(SKL_DPLL0
) |
6044 DPLL_CTRL1_OVERRIDE(SKL_DPLL0
))) !=
6045 DPLL_CTRL1_OVERRIDE(SKL_DPLL0
)))
6048 switch (val
& DPLL_CTRL1_LINK_RATE_MASK(SKL_DPLL0
)) {
6049 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_810
, SKL_DPLL0
):
6050 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1350
, SKL_DPLL0
):
6051 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1620
, SKL_DPLL0
):
6052 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_2700
, SKL_DPLL0
):
6053 dev_priv
->cdclk_pll
.vco
= 8100000;
6055 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1080
, SKL_DPLL0
):
6056 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_2160
, SKL_DPLL0
):
6057 dev_priv
->cdclk_pll
.vco
= 8640000;
6060 MISSING_CASE(val
& DPLL_CTRL1_LINK_RATE_MASK(SKL_DPLL0
));
6065 void skl_set_preferred_cdclk_vco(struct drm_i915_private
*dev_priv
, int vco
)
6067 bool changed
= dev_priv
->skl_preferred_vco_freq
!= vco
;
6069 dev_priv
->skl_preferred_vco_freq
= vco
;
6072 intel_update_max_cdclk(&dev_priv
->drm
);
6076 skl_dpll0_enable(struct drm_i915_private
*dev_priv
, int vco
)
6078 int min_cdclk
= skl_calc_cdclk(0, vco
);
6081 WARN_ON(vco
!= 8100000 && vco
!= 8640000);
6083 /* select the minimum CDCLK before enabling DPLL 0 */
6084 val
= CDCLK_FREQ_337_308
| skl_cdclk_decimal(min_cdclk
);
6085 I915_WRITE(CDCLK_CTL
, val
);
6086 POSTING_READ(CDCLK_CTL
);
6089 * We always enable DPLL0 with the lowest link rate possible, but still
6090 * taking into account the VCO required to operate the eDP panel at the
6091 * desired frequency. The usual DP link rates operate with a VCO of
6092 * 8100 while the eDP 1.4 alternate link rates need a VCO of 8640.
6093 * The modeset code is responsible for the selection of the exact link
6094 * rate later on, with the constraint of choosing a frequency that
6097 val
= I915_READ(DPLL_CTRL1
);
6099 val
&= ~(DPLL_CTRL1_HDMI_MODE(SKL_DPLL0
) | DPLL_CTRL1_SSC(SKL_DPLL0
) |
6100 DPLL_CTRL1_LINK_RATE_MASK(SKL_DPLL0
));
6101 val
|= DPLL_CTRL1_OVERRIDE(SKL_DPLL0
);
6103 val
|= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1080
,
6106 val
|= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_810
,
6109 I915_WRITE(DPLL_CTRL1
, val
);
6110 POSTING_READ(DPLL_CTRL1
);
6112 I915_WRITE(LCPLL1_CTL
, I915_READ(LCPLL1_CTL
) | LCPLL_PLL_ENABLE
);
6114 if (intel_wait_for_register(dev_priv
,
6115 LCPLL1_CTL
, LCPLL_PLL_LOCK
, LCPLL_PLL_LOCK
,
6117 DRM_ERROR("DPLL0 not locked\n");
6119 dev_priv
->cdclk_pll
.vco
= vco
;
6121 /* We'll want to keep using the current vco from now on. */
6122 skl_set_preferred_cdclk_vco(dev_priv
, vco
);
6126 skl_dpll0_disable(struct drm_i915_private
*dev_priv
)
6128 I915_WRITE(LCPLL1_CTL
, I915_READ(LCPLL1_CTL
) & ~LCPLL_PLL_ENABLE
);
6129 if (intel_wait_for_register(dev_priv
,
6130 LCPLL1_CTL
, LCPLL_PLL_LOCK
, 0,
6132 DRM_ERROR("Couldn't disable DPLL0\n");
6134 dev_priv
->cdclk_pll
.vco
= 0;
6137 static bool skl_cdclk_pcu_ready(struct drm_i915_private
*dev_priv
)
6142 /* inform PCU we want to change CDCLK */
6143 val
= SKL_CDCLK_PREPARE_FOR_CHANGE
;
6144 mutex_lock(&dev_priv
->rps
.hw_lock
);
6145 ret
= sandybridge_pcode_read(dev_priv
, SKL_PCODE_CDCLK_CONTROL
, &val
);
6146 mutex_unlock(&dev_priv
->rps
.hw_lock
);
6148 return ret
== 0 && (val
& SKL_CDCLK_READY_FOR_CHANGE
);
6151 static bool skl_cdclk_wait_for_pcu_ready(struct drm_i915_private
*dev_priv
)
6153 return _wait_for(skl_cdclk_pcu_ready(dev_priv
), 3000, 10) == 0;
6156 static void skl_set_cdclk(struct drm_i915_private
*dev_priv
, int cdclk
, int vco
)
6158 struct drm_device
*dev
= &dev_priv
->drm
;
6159 u32 freq_select
, pcu_ack
;
6161 WARN_ON((cdclk
== 24000) != (vco
== 0));
6163 DRM_DEBUG_DRIVER("Changing CDCLK to %d kHz (VCO %d kHz)\n", cdclk
, vco
);
6165 if (!skl_cdclk_wait_for_pcu_ready(dev_priv
)) {
6166 DRM_ERROR("failed to inform PCU about cdclk change\n");
6174 freq_select
= CDCLK_FREQ_450_432
;
6178 freq_select
= CDCLK_FREQ_540
;
6184 freq_select
= CDCLK_FREQ_337_308
;
6189 freq_select
= CDCLK_FREQ_675_617
;
6194 if (dev_priv
->cdclk_pll
.vco
!= 0 &&
6195 dev_priv
->cdclk_pll
.vco
!= vco
)
6196 skl_dpll0_disable(dev_priv
);
6198 if (dev_priv
->cdclk_pll
.vco
!= vco
)
6199 skl_dpll0_enable(dev_priv
, vco
);
6201 I915_WRITE(CDCLK_CTL
, freq_select
| skl_cdclk_decimal(cdclk
));
6202 POSTING_READ(CDCLK_CTL
);
6204 /* inform PCU of the change */
6205 mutex_lock(&dev_priv
->rps
.hw_lock
);
6206 sandybridge_pcode_write(dev_priv
, SKL_PCODE_CDCLK_CONTROL
, pcu_ack
);
6207 mutex_unlock(&dev_priv
->rps
.hw_lock
);
6209 intel_update_cdclk(dev
);
6212 static void skl_sanitize_cdclk(struct drm_i915_private
*dev_priv
);
6214 void skl_uninit_cdclk(struct drm_i915_private
*dev_priv
)
6216 skl_set_cdclk(dev_priv
, dev_priv
->cdclk_pll
.ref
, 0);
6219 void skl_init_cdclk(struct drm_i915_private
*dev_priv
)
6223 skl_sanitize_cdclk(dev_priv
);
6225 if (dev_priv
->cdclk_freq
!= 0 && dev_priv
->cdclk_pll
.vco
!= 0) {
6227 * Use the current vco as our initial
6228 * guess as to what the preferred vco is.
6230 if (dev_priv
->skl_preferred_vco_freq
== 0)
6231 skl_set_preferred_cdclk_vco(dev_priv
,
6232 dev_priv
->cdclk_pll
.vco
);
6236 vco
= dev_priv
->skl_preferred_vco_freq
;
6239 cdclk
= skl_calc_cdclk(0, vco
);
6241 skl_set_cdclk(dev_priv
, cdclk
, vco
);
6244 static void skl_sanitize_cdclk(struct drm_i915_private
*dev_priv
)
6246 uint32_t cdctl
, expected
;
6249 * check if the pre-os intialized the display
6250 * There is SWF18 scratchpad register defined which is set by the
6251 * pre-os which can be used by the OS drivers to check the status
6253 if ((I915_READ(SWF_ILK(0x18)) & 0x00FFFFFF) == 0)
6256 intel_update_cdclk(&dev_priv
->drm
);
6257 /* Is PLL enabled and locked ? */
6258 if (dev_priv
->cdclk_pll
.vco
== 0 ||
6259 dev_priv
->cdclk_freq
== dev_priv
->cdclk_pll
.ref
)
6262 /* DPLL okay; verify the cdclock
6264 * Noticed in some instances that the freq selection is correct but
6265 * decimal part is programmed wrong from BIOS where pre-os does not
6266 * enable display. Verify the same as well.
6268 cdctl
= I915_READ(CDCLK_CTL
);
6269 expected
= (cdctl
& CDCLK_FREQ_SEL_MASK
) |
6270 skl_cdclk_decimal(dev_priv
->cdclk_freq
);
6271 if (cdctl
== expected
)
6272 /* All well; nothing to sanitize */
6276 DRM_DEBUG_KMS("Sanitizing cdclk programmed by pre-os\n");
6278 /* force cdclk programming */
6279 dev_priv
->cdclk_freq
= 0;
6280 /* force full PLL disable + enable */
6281 dev_priv
->cdclk_pll
.vco
= -1;
6284 /* Adjust CDclk dividers to allow high res or save power if possible */
6285 static void valleyview_set_cdclk(struct drm_device
*dev
, int cdclk
)
6287 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6290 WARN_ON(dev_priv
->display
.get_display_clock_speed(dev
)
6291 != dev_priv
->cdclk_freq
);
6293 if (cdclk
>= 320000) /* jump to highest voltage for 400MHz too */
6295 else if (cdclk
== 266667)
6300 mutex_lock(&dev_priv
->rps
.hw_lock
);
6301 val
= vlv_punit_read(dev_priv
, PUNIT_REG_DSPFREQ
);
6302 val
&= ~DSPFREQGUAR_MASK
;
6303 val
|= (cmd
<< DSPFREQGUAR_SHIFT
);
6304 vlv_punit_write(dev_priv
, PUNIT_REG_DSPFREQ
, val
);
6305 if (wait_for((vlv_punit_read(dev_priv
, PUNIT_REG_DSPFREQ
) &
6306 DSPFREQSTAT_MASK
) == (cmd
<< DSPFREQSTAT_SHIFT
),
6308 DRM_ERROR("timed out waiting for CDclk change\n");
6310 mutex_unlock(&dev_priv
->rps
.hw_lock
);
6312 mutex_lock(&dev_priv
->sb_lock
);
6314 if (cdclk
== 400000) {
6317 divider
= DIV_ROUND_CLOSEST(dev_priv
->hpll_freq
<< 1, cdclk
) - 1;
6319 /* adjust cdclk divider */
6320 val
= vlv_cck_read(dev_priv
, CCK_DISPLAY_CLOCK_CONTROL
);
6321 val
&= ~CCK_FREQUENCY_VALUES
;
6323 vlv_cck_write(dev_priv
, CCK_DISPLAY_CLOCK_CONTROL
, val
);
6325 if (wait_for((vlv_cck_read(dev_priv
, CCK_DISPLAY_CLOCK_CONTROL
) &
6326 CCK_FREQUENCY_STATUS
) == (divider
<< CCK_FREQUENCY_STATUS_SHIFT
),
6328 DRM_ERROR("timed out waiting for CDclk change\n");
6331 /* adjust self-refresh exit latency value */
6332 val
= vlv_bunit_read(dev_priv
, BUNIT_REG_BISOC
);
6336 * For high bandwidth configs, we set a higher latency in the bunit
6337 * so that the core display fetch happens in time to avoid underruns.
6339 if (cdclk
== 400000)
6340 val
|= 4500 / 250; /* 4.5 usec */
6342 val
|= 3000 / 250; /* 3.0 usec */
6343 vlv_bunit_write(dev_priv
, BUNIT_REG_BISOC
, val
);
6345 mutex_unlock(&dev_priv
->sb_lock
);
6347 intel_update_cdclk(dev
);
6350 static void cherryview_set_cdclk(struct drm_device
*dev
, int cdclk
)
6352 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6355 WARN_ON(dev_priv
->display
.get_display_clock_speed(dev
)
6356 != dev_priv
->cdclk_freq
);
6365 MISSING_CASE(cdclk
);
6370 * Specs are full of misinformation, but testing on actual
6371 * hardware has shown that we just need to write the desired
6372 * CCK divider into the Punit register.
6374 cmd
= DIV_ROUND_CLOSEST(dev_priv
->hpll_freq
<< 1, cdclk
) - 1;
6376 mutex_lock(&dev_priv
->rps
.hw_lock
);
6377 val
= vlv_punit_read(dev_priv
, PUNIT_REG_DSPFREQ
);
6378 val
&= ~DSPFREQGUAR_MASK_CHV
;
6379 val
|= (cmd
<< DSPFREQGUAR_SHIFT_CHV
);
6380 vlv_punit_write(dev_priv
, PUNIT_REG_DSPFREQ
, val
);
6381 if (wait_for((vlv_punit_read(dev_priv
, PUNIT_REG_DSPFREQ
) &
6382 DSPFREQSTAT_MASK_CHV
) == (cmd
<< DSPFREQSTAT_SHIFT_CHV
),
6384 DRM_ERROR("timed out waiting for CDclk change\n");
6386 mutex_unlock(&dev_priv
->rps
.hw_lock
);
6388 intel_update_cdclk(dev
);
6391 static int valleyview_calc_cdclk(struct drm_i915_private
*dev_priv
,
6394 int freq_320
= (dev_priv
->hpll_freq
<< 1) % 320000 != 0 ? 333333 : 320000;
6395 int limit
= IS_CHERRYVIEW(dev_priv
) ? 95 : 90;
6398 * Really only a few cases to deal with, as only 4 CDclks are supported:
6401 * 320/333MHz (depends on HPLL freq)
6403 * So we check to see whether we're above 90% (VLV) or 95% (CHV)
6404 * of the lower bin and adjust if needed.
6406 * We seem to get an unstable or solid color picture at 200MHz.
6407 * Not sure what's wrong. For now use 200MHz only when all pipes
6410 if (!IS_CHERRYVIEW(dev_priv
) &&
6411 max_pixclk
> freq_320
*limit
/100)
6413 else if (max_pixclk
> 266667*limit
/100)
6415 else if (max_pixclk
> 0)
6421 static int bxt_calc_cdclk(int max_pixclk
)
6423 if (max_pixclk
> 576000)
6425 else if (max_pixclk
> 384000)
6427 else if (max_pixclk
> 288000)
6429 else if (max_pixclk
> 144000)
6435 /* Compute the max pixel clock for new configuration. */
6436 static int intel_mode_max_pixclk(struct drm_device
*dev
,
6437 struct drm_atomic_state
*state
)
6439 struct intel_atomic_state
*intel_state
= to_intel_atomic_state(state
);
6440 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6441 struct drm_crtc
*crtc
;
6442 struct drm_crtc_state
*crtc_state
;
6443 unsigned max_pixclk
= 0, i
;
6446 memcpy(intel_state
->min_pixclk
, dev_priv
->min_pixclk
,
6447 sizeof(intel_state
->min_pixclk
));
6449 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
6452 if (crtc_state
->enable
)
6453 pixclk
= crtc_state
->adjusted_mode
.crtc_clock
;
6455 intel_state
->min_pixclk
[i
] = pixclk
;
6458 for_each_pipe(dev_priv
, pipe
)
6459 max_pixclk
= max(intel_state
->min_pixclk
[pipe
], max_pixclk
);
6464 static int valleyview_modeset_calc_cdclk(struct drm_atomic_state
*state
)
6466 struct drm_device
*dev
= state
->dev
;
6467 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6468 int max_pixclk
= intel_mode_max_pixclk(dev
, state
);
6469 struct intel_atomic_state
*intel_state
=
6470 to_intel_atomic_state(state
);
6472 intel_state
->cdclk
= intel_state
->dev_cdclk
=
6473 valleyview_calc_cdclk(dev_priv
, max_pixclk
);
6475 if (!intel_state
->active_crtcs
)
6476 intel_state
->dev_cdclk
= valleyview_calc_cdclk(dev_priv
, 0);
6481 static int bxt_modeset_calc_cdclk(struct drm_atomic_state
*state
)
6483 int max_pixclk
= ilk_max_pixel_rate(state
);
6484 struct intel_atomic_state
*intel_state
=
6485 to_intel_atomic_state(state
);
6487 intel_state
->cdclk
= intel_state
->dev_cdclk
=
6488 bxt_calc_cdclk(max_pixclk
);
6490 if (!intel_state
->active_crtcs
)
6491 intel_state
->dev_cdclk
= bxt_calc_cdclk(0);
6496 static void vlv_program_pfi_credits(struct drm_i915_private
*dev_priv
)
6498 unsigned int credits
, default_credits
;
6500 if (IS_CHERRYVIEW(dev_priv
))
6501 default_credits
= PFI_CREDIT(12);
6503 default_credits
= PFI_CREDIT(8);
6505 if (dev_priv
->cdclk_freq
>= dev_priv
->czclk_freq
) {
6506 /* CHV suggested value is 31 or 63 */
6507 if (IS_CHERRYVIEW(dev_priv
))
6508 credits
= PFI_CREDIT_63
;
6510 credits
= PFI_CREDIT(15);
6512 credits
= default_credits
;
6516 * WA - write default credits before re-programming
6517 * FIXME: should we also set the resend bit here?
6519 I915_WRITE(GCI_CONTROL
, VGA_FAST_MODE_DISABLE
|
6522 I915_WRITE(GCI_CONTROL
, VGA_FAST_MODE_DISABLE
|
6523 credits
| PFI_CREDIT_RESEND
);
6526 * FIXME is this guaranteed to clear
6527 * immediately or should we poll for it?
6529 WARN_ON(I915_READ(GCI_CONTROL
) & PFI_CREDIT_RESEND
);
6532 static void valleyview_modeset_commit_cdclk(struct drm_atomic_state
*old_state
)
6534 struct drm_device
*dev
= old_state
->dev
;
6535 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6536 struct intel_atomic_state
*old_intel_state
=
6537 to_intel_atomic_state(old_state
);
6538 unsigned req_cdclk
= old_intel_state
->dev_cdclk
;
6541 * FIXME: We can end up here with all power domains off, yet
6542 * with a CDCLK frequency other than the minimum. To account
6543 * for this take the PIPE-A power domain, which covers the HW
6544 * blocks needed for the following programming. This can be
6545 * removed once it's guaranteed that we get here either with
6546 * the minimum CDCLK set, or the required power domains
6549 intel_display_power_get(dev_priv
, POWER_DOMAIN_PIPE_A
);
6551 if (IS_CHERRYVIEW(dev
))
6552 cherryview_set_cdclk(dev
, req_cdclk
);
6554 valleyview_set_cdclk(dev
, req_cdclk
);
6556 vlv_program_pfi_credits(dev_priv
);
6558 intel_display_power_put(dev_priv
, POWER_DOMAIN_PIPE_A
);
6561 static void valleyview_crtc_enable(struct drm_crtc
*crtc
)
6563 struct drm_device
*dev
= crtc
->dev
;
6564 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6565 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
6566 struct intel_encoder
*encoder
;
6567 struct intel_crtc_state
*pipe_config
=
6568 to_intel_crtc_state(crtc
->state
);
6569 int pipe
= intel_crtc
->pipe
;
6571 if (WARN_ON(intel_crtc
->active
))
6574 if (intel_crtc_has_dp_encoder(intel_crtc
->config
))
6575 intel_dp_set_m_n(intel_crtc
, M1_N1
);
6577 intel_set_pipe_timings(intel_crtc
);
6578 intel_set_pipe_src_size(intel_crtc
);
6580 if (IS_CHERRYVIEW(dev
) && pipe
== PIPE_B
) {
6581 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6583 I915_WRITE(CHV_BLEND(pipe
), CHV_BLEND_LEGACY
);
6584 I915_WRITE(CHV_CANVAS(pipe
), 0);
6587 i9xx_set_pipeconf(intel_crtc
);
6589 intel_crtc
->active
= true;
6591 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, true);
6593 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
6594 if (encoder
->pre_pll_enable
)
6595 encoder
->pre_pll_enable(encoder
);
6597 if (IS_CHERRYVIEW(dev
)) {
6598 chv_prepare_pll(intel_crtc
, intel_crtc
->config
);
6599 chv_enable_pll(intel_crtc
, intel_crtc
->config
);
6601 vlv_prepare_pll(intel_crtc
, intel_crtc
->config
);
6602 vlv_enable_pll(intel_crtc
, intel_crtc
->config
);
6605 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
6606 if (encoder
->pre_enable
)
6607 encoder
->pre_enable(encoder
);
6609 i9xx_pfit_enable(intel_crtc
);
6611 intel_color_load_luts(&pipe_config
->base
);
6613 intel_update_watermarks(crtc
);
6614 intel_enable_pipe(intel_crtc
);
6616 assert_vblank_disabled(crtc
);
6617 drm_crtc_vblank_on(crtc
);
6619 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
6620 encoder
->enable(encoder
);
6623 static void i9xx_set_pll_dividers(struct intel_crtc
*crtc
)
6625 struct drm_device
*dev
= crtc
->base
.dev
;
6626 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6628 I915_WRITE(FP0(crtc
->pipe
), crtc
->config
->dpll_hw_state
.fp0
);
6629 I915_WRITE(FP1(crtc
->pipe
), crtc
->config
->dpll_hw_state
.fp1
);
6632 static void i9xx_crtc_enable(struct drm_crtc
*crtc
)
6634 struct drm_device
*dev
= crtc
->dev
;
6635 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6636 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
6637 struct intel_encoder
*encoder
;
6638 struct intel_crtc_state
*pipe_config
=
6639 to_intel_crtc_state(crtc
->state
);
6640 enum pipe pipe
= intel_crtc
->pipe
;
6642 if (WARN_ON(intel_crtc
->active
))
6645 i9xx_set_pll_dividers(intel_crtc
);
6647 if (intel_crtc_has_dp_encoder(intel_crtc
->config
))
6648 intel_dp_set_m_n(intel_crtc
, M1_N1
);
6650 intel_set_pipe_timings(intel_crtc
);
6651 intel_set_pipe_src_size(intel_crtc
);
6653 i9xx_set_pipeconf(intel_crtc
);
6655 intel_crtc
->active
= true;
6658 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, true);
6660 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
6661 if (encoder
->pre_enable
)
6662 encoder
->pre_enable(encoder
);
6664 i9xx_enable_pll(intel_crtc
);
6666 i9xx_pfit_enable(intel_crtc
);
6668 intel_color_load_luts(&pipe_config
->base
);
6670 intel_update_watermarks(crtc
);
6671 intel_enable_pipe(intel_crtc
);
6673 assert_vblank_disabled(crtc
);
6674 drm_crtc_vblank_on(crtc
);
6676 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
6677 encoder
->enable(encoder
);
6680 static void i9xx_pfit_disable(struct intel_crtc
*crtc
)
6682 struct drm_device
*dev
= crtc
->base
.dev
;
6683 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6685 if (!crtc
->config
->gmch_pfit
.control
)
6688 assert_pipe_disabled(dev_priv
, crtc
->pipe
);
6690 DRM_DEBUG_DRIVER("disabling pfit, current: 0x%08x\n",
6691 I915_READ(PFIT_CONTROL
));
6692 I915_WRITE(PFIT_CONTROL
, 0);
6695 static void i9xx_crtc_disable(struct drm_crtc
*crtc
)
6697 struct drm_device
*dev
= crtc
->dev
;
6698 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6699 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
6700 struct intel_encoder
*encoder
;
6701 int pipe
= intel_crtc
->pipe
;
6704 * On gen2 planes are double buffered but the pipe isn't, so we must
6705 * wait for planes to fully turn off before disabling the pipe.
6708 intel_wait_for_vblank(dev
, pipe
);
6710 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
6711 encoder
->disable(encoder
);
6713 drm_crtc_vblank_off(crtc
);
6714 assert_vblank_disabled(crtc
);
6716 intel_disable_pipe(intel_crtc
);
6718 i9xx_pfit_disable(intel_crtc
);
6720 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
6721 if (encoder
->post_disable
)
6722 encoder
->post_disable(encoder
);
6724 if (!intel_crtc_has_type(intel_crtc
->config
, INTEL_OUTPUT_DSI
)) {
6725 if (IS_CHERRYVIEW(dev
))
6726 chv_disable_pll(dev_priv
, pipe
);
6727 else if (IS_VALLEYVIEW(dev
))
6728 vlv_disable_pll(dev_priv
, pipe
);
6730 i9xx_disable_pll(intel_crtc
);
6733 for_each_encoder_on_crtc(dev
, crtc
, encoder
)
6734 if (encoder
->post_pll_disable
)
6735 encoder
->post_pll_disable(encoder
);
6738 intel_set_cpu_fifo_underrun_reporting(dev_priv
, pipe
, false);
6741 static void intel_crtc_disable_noatomic(struct drm_crtc
*crtc
)
6743 struct intel_encoder
*encoder
;
6744 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
6745 struct drm_i915_private
*dev_priv
= to_i915(crtc
->dev
);
6746 enum intel_display_power_domain domain
;
6747 unsigned long domains
;
6749 if (!intel_crtc
->active
)
6752 if (to_intel_plane_state(crtc
->primary
->state
)->base
.visible
) {
6753 WARN_ON(intel_crtc
->flip_work
);
6755 intel_pre_disable_primary_noatomic(crtc
);
6757 intel_crtc_disable_planes(crtc
, 1 << drm_plane_index(crtc
->primary
));
6758 to_intel_plane_state(crtc
->primary
->state
)->base
.visible
= false;
6761 dev_priv
->display
.crtc_disable(crtc
);
6763 DRM_DEBUG_KMS("[CRTC:%d:%s] hw state adjusted, was enabled, now disabled\n",
6764 crtc
->base
.id
, crtc
->name
);
6766 WARN_ON(drm_atomic_set_mode_for_crtc(crtc
->state
, NULL
) < 0);
6767 crtc
->state
->active
= false;
6768 intel_crtc
->active
= false;
6769 crtc
->enabled
= false;
6770 crtc
->state
->connector_mask
= 0;
6771 crtc
->state
->encoder_mask
= 0;
6773 for_each_encoder_on_crtc(crtc
->dev
, crtc
, encoder
)
6774 encoder
->base
.crtc
= NULL
;
6776 intel_fbc_disable(intel_crtc
);
6777 intel_update_watermarks(crtc
);
6778 intel_disable_shared_dpll(intel_crtc
);
6780 domains
= intel_crtc
->enabled_power_domains
;
6781 for_each_power_domain(domain
, domains
)
6782 intel_display_power_put(dev_priv
, domain
);
6783 intel_crtc
->enabled_power_domains
= 0;
6785 dev_priv
->active_crtcs
&= ~(1 << intel_crtc
->pipe
);
6786 dev_priv
->min_pixclk
[intel_crtc
->pipe
] = 0;
6790 * turn all crtc's off, but do not adjust state
6791 * This has to be paired with a call to intel_modeset_setup_hw_state.
6793 int intel_display_suspend(struct drm_device
*dev
)
6795 struct drm_i915_private
*dev_priv
= to_i915(dev
);
6796 struct drm_atomic_state
*state
;
6799 state
= drm_atomic_helper_suspend(dev
);
6800 ret
= PTR_ERR_OR_ZERO(state
);
6802 DRM_ERROR("Suspending crtc's failed with %i\n", ret
);
6804 dev_priv
->modeset_restore_state
= state
;
6808 void intel_encoder_destroy(struct drm_encoder
*encoder
)
6810 struct intel_encoder
*intel_encoder
= to_intel_encoder(encoder
);
6812 drm_encoder_cleanup(encoder
);
6813 kfree(intel_encoder
);
6816 /* Cross check the actual hw state with our own modeset state tracking (and it's
6817 * internal consistency). */
6818 static void intel_connector_verify_state(struct intel_connector
*connector
)
6820 struct drm_crtc
*crtc
= connector
->base
.state
->crtc
;
6822 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
6823 connector
->base
.base
.id
,
6824 connector
->base
.name
);
6826 if (connector
->get_hw_state(connector
)) {
6827 struct intel_encoder
*encoder
= connector
->encoder
;
6828 struct drm_connector_state
*conn_state
= connector
->base
.state
;
6830 I915_STATE_WARN(!crtc
,
6831 "connector enabled without attached crtc\n");
6836 I915_STATE_WARN(!crtc
->state
->active
,
6837 "connector is active, but attached crtc isn't\n");
6839 if (!encoder
|| encoder
->type
== INTEL_OUTPUT_DP_MST
)
6842 I915_STATE_WARN(conn_state
->best_encoder
!= &encoder
->base
,
6843 "atomic encoder doesn't match attached encoder\n");
6845 I915_STATE_WARN(conn_state
->crtc
!= encoder
->base
.crtc
,
6846 "attached encoder crtc differs from connector crtc\n");
6848 I915_STATE_WARN(crtc
&& crtc
->state
->active
,
6849 "attached crtc is active, but connector isn't\n");
6850 I915_STATE_WARN(!crtc
&& connector
->base
.state
->best_encoder
,
6851 "best encoder set without crtc!\n");
6855 int intel_connector_init(struct intel_connector
*connector
)
6857 drm_atomic_helper_connector_reset(&connector
->base
);
6859 if (!connector
->base
.state
)
6865 struct intel_connector
*intel_connector_alloc(void)
6867 struct intel_connector
*connector
;
6869 connector
= kzalloc(sizeof *connector
, GFP_KERNEL
);
6873 if (intel_connector_init(connector
) < 0) {
6881 /* Simple connector->get_hw_state implementation for encoders that support only
6882 * one connector and no cloning and hence the encoder state determines the state
6883 * of the connector. */
6884 bool intel_connector_get_hw_state(struct intel_connector
*connector
)
6887 struct intel_encoder
*encoder
= connector
->encoder
;
6889 return encoder
->get_hw_state(encoder
, &pipe
);
6892 static int pipe_required_fdi_lanes(struct intel_crtc_state
*crtc_state
)
6894 if (crtc_state
->base
.enable
&& crtc_state
->has_pch_encoder
)
6895 return crtc_state
->fdi_lanes
;
6900 static int ironlake_check_fdi_lanes(struct drm_device
*dev
, enum pipe pipe
,
6901 struct intel_crtc_state
*pipe_config
)
6903 struct drm_atomic_state
*state
= pipe_config
->base
.state
;
6904 struct intel_crtc
*other_crtc
;
6905 struct intel_crtc_state
*other_crtc_state
;
6907 DRM_DEBUG_KMS("checking fdi config on pipe %c, lanes %i\n",
6908 pipe_name(pipe
), pipe_config
->fdi_lanes
);
6909 if (pipe_config
->fdi_lanes
> 4) {
6910 DRM_DEBUG_KMS("invalid fdi lane config on pipe %c: %i lanes\n",
6911 pipe_name(pipe
), pipe_config
->fdi_lanes
);
6915 if (IS_HASWELL(dev
) || IS_BROADWELL(dev
)) {
6916 if (pipe_config
->fdi_lanes
> 2) {
6917 DRM_DEBUG_KMS("only 2 lanes on haswell, required: %i lanes\n",
6918 pipe_config
->fdi_lanes
);
6925 if (INTEL_INFO(dev
)->num_pipes
== 2)
6928 /* Ivybridge 3 pipe is really complicated */
6933 if (pipe_config
->fdi_lanes
<= 2)
6936 other_crtc
= to_intel_crtc(intel_get_crtc_for_pipe(dev
, PIPE_C
));
6938 intel_atomic_get_crtc_state(state
, other_crtc
);
6939 if (IS_ERR(other_crtc_state
))
6940 return PTR_ERR(other_crtc_state
);
6942 if (pipe_required_fdi_lanes(other_crtc_state
) > 0) {
6943 DRM_DEBUG_KMS("invalid shared fdi lane config on pipe %c: %i lanes\n",
6944 pipe_name(pipe
), pipe_config
->fdi_lanes
);
6949 if (pipe_config
->fdi_lanes
> 2) {
6950 DRM_DEBUG_KMS("only 2 lanes on pipe %c: required %i lanes\n",
6951 pipe_name(pipe
), pipe_config
->fdi_lanes
);
6955 other_crtc
= to_intel_crtc(intel_get_crtc_for_pipe(dev
, PIPE_B
));
6957 intel_atomic_get_crtc_state(state
, other_crtc
);
6958 if (IS_ERR(other_crtc_state
))
6959 return PTR_ERR(other_crtc_state
);
6961 if (pipe_required_fdi_lanes(other_crtc_state
) > 2) {
6962 DRM_DEBUG_KMS("fdi link B uses too many lanes to enable link C\n");
6972 static int ironlake_fdi_compute_config(struct intel_crtc
*intel_crtc
,
6973 struct intel_crtc_state
*pipe_config
)
6975 struct drm_device
*dev
= intel_crtc
->base
.dev
;
6976 const struct drm_display_mode
*adjusted_mode
= &pipe_config
->base
.adjusted_mode
;
6977 int lane
, link_bw
, fdi_dotclock
, ret
;
6978 bool needs_recompute
= false;
6981 /* FDI is a binary signal running at ~2.7GHz, encoding
6982 * each output octet as 10 bits. The actual frequency
6983 * is stored as a divider into a 100MHz clock, and the
6984 * mode pixel clock is stored in units of 1KHz.
6985 * Hence the bw of each lane in terms of the mode signal
6988 link_bw
= intel_fdi_link_freq(to_i915(dev
), pipe_config
);
6990 fdi_dotclock
= adjusted_mode
->crtc_clock
;
6992 lane
= ironlake_get_lanes_required(fdi_dotclock
, link_bw
,
6993 pipe_config
->pipe_bpp
);
6995 pipe_config
->fdi_lanes
= lane
;
6997 intel_link_compute_m_n(pipe_config
->pipe_bpp
, lane
, fdi_dotclock
,
6998 link_bw
, &pipe_config
->fdi_m_n
);
7000 ret
= ironlake_check_fdi_lanes(dev
, intel_crtc
->pipe
, pipe_config
);
7001 if (ret
== -EINVAL
&& pipe_config
->pipe_bpp
> 6*3) {
7002 pipe_config
->pipe_bpp
-= 2*3;
7003 DRM_DEBUG_KMS("fdi link bw constraint, reducing pipe bpp to %i\n",
7004 pipe_config
->pipe_bpp
);
7005 needs_recompute
= true;
7006 pipe_config
->bw_constrained
= true;
7011 if (needs_recompute
)
7017 static bool pipe_config_supports_ips(struct drm_i915_private
*dev_priv
,
7018 struct intel_crtc_state
*pipe_config
)
7020 if (pipe_config
->pipe_bpp
> 24)
7023 /* HSW can handle pixel rate up to cdclk? */
7024 if (IS_HASWELL(dev_priv
))
7028 * We compare against max which means we must take
7029 * the increased cdclk requirement into account when
7030 * calculating the new cdclk.
7032 * Should measure whether using a lower cdclk w/o IPS
7034 return ilk_pipe_pixel_rate(pipe_config
) <=
7035 dev_priv
->max_cdclk_freq
* 95 / 100;
7038 static void hsw_compute_ips_config(struct intel_crtc
*crtc
,
7039 struct intel_crtc_state
*pipe_config
)
7041 struct drm_device
*dev
= crtc
->base
.dev
;
7042 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7044 pipe_config
->ips_enabled
= i915
.enable_ips
&&
7045 hsw_crtc_supports_ips(crtc
) &&
7046 pipe_config_supports_ips(dev_priv
, pipe_config
);
7049 static bool intel_crtc_supports_double_wide(const struct intel_crtc
*crtc
)
7051 const struct drm_i915_private
*dev_priv
= to_i915(crtc
->base
.dev
);
7053 /* GDG double wide on either pipe, otherwise pipe A only */
7054 return INTEL_INFO(dev_priv
)->gen
< 4 &&
7055 (crtc
->pipe
== PIPE_A
|| IS_I915G(dev_priv
));
7058 static int intel_crtc_compute_config(struct intel_crtc
*crtc
,
7059 struct intel_crtc_state
*pipe_config
)
7061 struct drm_device
*dev
= crtc
->base
.dev
;
7062 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7063 const struct drm_display_mode
*adjusted_mode
= &pipe_config
->base
.adjusted_mode
;
7064 int clock_limit
= dev_priv
->max_dotclk_freq
;
7066 if (INTEL_INFO(dev
)->gen
< 4) {
7067 clock_limit
= dev_priv
->max_cdclk_freq
* 9 / 10;
7070 * Enable double wide mode when the dot clock
7071 * is > 90% of the (display) core speed.
7073 if (intel_crtc_supports_double_wide(crtc
) &&
7074 adjusted_mode
->crtc_clock
> clock_limit
) {
7075 clock_limit
= dev_priv
->max_dotclk_freq
;
7076 pipe_config
->double_wide
= true;
7080 if (adjusted_mode
->crtc_clock
> clock_limit
) {
7081 DRM_DEBUG_KMS("requested pixel clock (%d kHz) too high (max: %d kHz, double wide: %s)\n",
7082 adjusted_mode
->crtc_clock
, clock_limit
,
7083 yesno(pipe_config
->double_wide
));
7088 * Pipe horizontal size must be even in:
7090 * - LVDS dual channel mode
7091 * - Double wide pipe
7093 if ((intel_crtc_has_type(pipe_config
, INTEL_OUTPUT_LVDS
) &&
7094 intel_is_dual_link_lvds(dev
)) || pipe_config
->double_wide
)
7095 pipe_config
->pipe_src_w
&= ~1;
7097 /* Cantiga+ cannot handle modes with a hsync front porch of 0.
7098 * WaPruneModeWithIncorrectHsyncOffset:ctg,elk,ilk,snb,ivb,vlv,hsw.
7100 if ((INTEL_INFO(dev
)->gen
> 4 || IS_G4X(dev
)) &&
7101 adjusted_mode
->crtc_hsync_start
== adjusted_mode
->crtc_hdisplay
)
7105 hsw_compute_ips_config(crtc
, pipe_config
);
7107 if (pipe_config
->has_pch_encoder
)
7108 return ironlake_fdi_compute_config(crtc
, pipe_config
);
7113 static int skylake_get_display_clock_speed(struct drm_device
*dev
)
7115 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7118 skl_dpll0_update(dev_priv
);
7120 if (dev_priv
->cdclk_pll
.vco
== 0)
7121 return dev_priv
->cdclk_pll
.ref
;
7123 cdctl
= I915_READ(CDCLK_CTL
);
7125 if (dev_priv
->cdclk_pll
.vco
== 8640000) {
7126 switch (cdctl
& CDCLK_FREQ_SEL_MASK
) {
7127 case CDCLK_FREQ_450_432
:
7129 case CDCLK_FREQ_337_308
:
7131 case CDCLK_FREQ_540
:
7133 case CDCLK_FREQ_675_617
:
7136 MISSING_CASE(cdctl
& CDCLK_FREQ_SEL_MASK
);
7139 switch (cdctl
& CDCLK_FREQ_SEL_MASK
) {
7140 case CDCLK_FREQ_450_432
:
7142 case CDCLK_FREQ_337_308
:
7144 case CDCLK_FREQ_540
:
7146 case CDCLK_FREQ_675_617
:
7149 MISSING_CASE(cdctl
& CDCLK_FREQ_SEL_MASK
);
7153 return dev_priv
->cdclk_pll
.ref
;
7156 static void bxt_de_pll_update(struct drm_i915_private
*dev_priv
)
7160 dev_priv
->cdclk_pll
.ref
= 19200;
7161 dev_priv
->cdclk_pll
.vco
= 0;
7163 val
= I915_READ(BXT_DE_PLL_ENABLE
);
7164 if ((val
& BXT_DE_PLL_PLL_ENABLE
) == 0)
7167 if (WARN_ON((val
& BXT_DE_PLL_LOCK
) == 0))
7170 val
= I915_READ(BXT_DE_PLL_CTL
);
7171 dev_priv
->cdclk_pll
.vco
= (val
& BXT_DE_PLL_RATIO_MASK
) *
7172 dev_priv
->cdclk_pll
.ref
;
7175 static int broxton_get_display_clock_speed(struct drm_device
*dev
)
7177 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7181 bxt_de_pll_update(dev_priv
);
7183 vco
= dev_priv
->cdclk_pll
.vco
;
7185 return dev_priv
->cdclk_pll
.ref
;
7187 divider
= I915_READ(CDCLK_CTL
) & BXT_CDCLK_CD2X_DIV_SEL_MASK
;
7190 case BXT_CDCLK_CD2X_DIV_SEL_1
:
7193 case BXT_CDCLK_CD2X_DIV_SEL_1_5
:
7196 case BXT_CDCLK_CD2X_DIV_SEL_2
:
7199 case BXT_CDCLK_CD2X_DIV_SEL_4
:
7203 MISSING_CASE(divider
);
7204 return dev_priv
->cdclk_pll
.ref
;
7207 return DIV_ROUND_CLOSEST(vco
, div
);
7210 static int broadwell_get_display_clock_speed(struct drm_device
*dev
)
7212 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7213 uint32_t lcpll
= I915_READ(LCPLL_CTL
);
7214 uint32_t freq
= lcpll
& LCPLL_CLK_FREQ_MASK
;
7216 if (lcpll
& LCPLL_CD_SOURCE_FCLK
)
7218 else if (I915_READ(FUSE_STRAP
) & HSW_CDCLK_LIMIT
)
7220 else if (freq
== LCPLL_CLK_FREQ_450
)
7222 else if (freq
== LCPLL_CLK_FREQ_54O_BDW
)
7224 else if (freq
== LCPLL_CLK_FREQ_337_5_BDW
)
7230 static int haswell_get_display_clock_speed(struct drm_device
*dev
)
7232 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7233 uint32_t lcpll
= I915_READ(LCPLL_CTL
);
7234 uint32_t freq
= lcpll
& LCPLL_CLK_FREQ_MASK
;
7236 if (lcpll
& LCPLL_CD_SOURCE_FCLK
)
7238 else if (I915_READ(FUSE_STRAP
) & HSW_CDCLK_LIMIT
)
7240 else if (freq
== LCPLL_CLK_FREQ_450
)
7242 else if (IS_HSW_ULT(dev
))
7248 static int valleyview_get_display_clock_speed(struct drm_device
*dev
)
7250 return vlv_get_cck_clock_hpll(to_i915(dev
), "cdclk",
7251 CCK_DISPLAY_CLOCK_CONTROL
);
7254 static int ilk_get_display_clock_speed(struct drm_device
*dev
)
7259 static int i945_get_display_clock_speed(struct drm_device
*dev
)
7264 static int i915_get_display_clock_speed(struct drm_device
*dev
)
7269 static int i9xx_misc_get_display_clock_speed(struct drm_device
*dev
)
7274 static int pnv_get_display_clock_speed(struct drm_device
*dev
)
7278 pci_read_config_word(dev
->pdev
, GCFGC
, &gcfgc
);
7280 switch (gcfgc
& GC_DISPLAY_CLOCK_MASK
) {
7281 case GC_DISPLAY_CLOCK_267_MHZ_PNV
:
7283 case GC_DISPLAY_CLOCK_333_MHZ_PNV
:
7285 case GC_DISPLAY_CLOCK_444_MHZ_PNV
:
7287 case GC_DISPLAY_CLOCK_200_MHZ_PNV
:
7290 DRM_ERROR("Unknown pnv display core clock 0x%04x\n", gcfgc
);
7291 case GC_DISPLAY_CLOCK_133_MHZ_PNV
:
7293 case GC_DISPLAY_CLOCK_167_MHZ_PNV
:
7298 static int i915gm_get_display_clock_speed(struct drm_device
*dev
)
7302 pci_read_config_word(dev
->pdev
, GCFGC
, &gcfgc
);
7304 if (gcfgc
& GC_LOW_FREQUENCY_ENABLE
)
7307 switch (gcfgc
& GC_DISPLAY_CLOCK_MASK
) {
7308 case GC_DISPLAY_CLOCK_333_MHZ
:
7311 case GC_DISPLAY_CLOCK_190_200_MHZ
:
7317 static int i865_get_display_clock_speed(struct drm_device
*dev
)
7322 static int i85x_get_display_clock_speed(struct drm_device
*dev
)
7327 * 852GM/852GMV only supports 133 MHz and the HPLLCC
7328 * encoding is different :(
7329 * FIXME is this the right way to detect 852GM/852GMV?
7331 if (dev
->pdev
->revision
== 0x1)
7334 pci_bus_read_config_word(dev
->pdev
->bus
,
7335 PCI_DEVFN(0, 3), HPLLCC
, &hpllcc
);
7337 /* Assume that the hardware is in the high speed state. This
7338 * should be the default.
7340 switch (hpllcc
& GC_CLOCK_CONTROL_MASK
) {
7341 case GC_CLOCK_133_200
:
7342 case GC_CLOCK_133_200_2
:
7343 case GC_CLOCK_100_200
:
7345 case GC_CLOCK_166_250
:
7347 case GC_CLOCK_100_133
:
7349 case GC_CLOCK_133_266
:
7350 case GC_CLOCK_133_266_2
:
7351 case GC_CLOCK_166_266
:
7355 /* Shouldn't happen */
7359 static int i830_get_display_clock_speed(struct drm_device
*dev
)
7364 static unsigned int intel_hpll_vco(struct drm_device
*dev
)
7366 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7367 static const unsigned int blb_vco
[8] = {
7374 static const unsigned int pnv_vco
[8] = {
7381 static const unsigned int cl_vco
[8] = {
7390 static const unsigned int elk_vco
[8] = {
7396 static const unsigned int ctg_vco
[8] = {
7404 const unsigned int *vco_table
;
7408 /* FIXME other chipsets? */
7410 vco_table
= ctg_vco
;
7411 else if (IS_G4X(dev
))
7412 vco_table
= elk_vco
;
7413 else if (IS_CRESTLINE(dev
))
7415 else if (IS_PINEVIEW(dev
))
7416 vco_table
= pnv_vco
;
7417 else if (IS_G33(dev
))
7418 vco_table
= blb_vco
;
7422 tmp
= I915_READ(IS_MOBILE(dev
) ? HPLLVCO_MOBILE
: HPLLVCO
);
7424 vco
= vco_table
[tmp
& 0x7];
7426 DRM_ERROR("Bad HPLL VCO (HPLLVCO=0x%02x)\n", tmp
);
7428 DRM_DEBUG_KMS("HPLL VCO %u kHz\n", vco
);
7433 static int gm45_get_display_clock_speed(struct drm_device
*dev
)
7435 unsigned int cdclk_sel
, vco
= intel_hpll_vco(dev
);
7438 pci_read_config_word(dev
->pdev
, GCFGC
, &tmp
);
7440 cdclk_sel
= (tmp
>> 12) & 0x1;
7446 return cdclk_sel
? 333333 : 222222;
7448 return cdclk_sel
? 320000 : 228571;
7450 DRM_ERROR("Unable to determine CDCLK. HPLL VCO=%u, CFGC=0x%04x\n", vco
, tmp
);
7455 static int i965gm_get_display_clock_speed(struct drm_device
*dev
)
7457 static const uint8_t div_3200
[] = { 16, 10, 8 };
7458 static const uint8_t div_4000
[] = { 20, 12, 10 };
7459 static const uint8_t div_5333
[] = { 24, 16, 14 };
7460 const uint8_t *div_table
;
7461 unsigned int cdclk_sel
, vco
= intel_hpll_vco(dev
);
7464 pci_read_config_word(dev
->pdev
, GCFGC
, &tmp
);
7466 cdclk_sel
= ((tmp
>> 8) & 0x1f) - 1;
7468 if (cdclk_sel
>= ARRAY_SIZE(div_3200
))
7473 div_table
= div_3200
;
7476 div_table
= div_4000
;
7479 div_table
= div_5333
;
7485 return DIV_ROUND_CLOSEST(vco
, div_table
[cdclk_sel
]);
7488 DRM_ERROR("Unable to determine CDCLK. HPLL VCO=%u kHz, CFGC=0x%04x\n", vco
, tmp
);
7492 static int g33_get_display_clock_speed(struct drm_device
*dev
)
7494 static const uint8_t div_3200
[] = { 12, 10, 8, 7, 5, 16 };
7495 static const uint8_t div_4000
[] = { 14, 12, 10, 8, 6, 20 };
7496 static const uint8_t div_4800
[] = { 20, 14, 12, 10, 8, 24 };
7497 static const uint8_t div_5333
[] = { 20, 16, 12, 12, 8, 28 };
7498 const uint8_t *div_table
;
7499 unsigned int cdclk_sel
, vco
= intel_hpll_vco(dev
);
7502 pci_read_config_word(dev
->pdev
, GCFGC
, &tmp
);
7504 cdclk_sel
= (tmp
>> 4) & 0x7;
7506 if (cdclk_sel
>= ARRAY_SIZE(div_3200
))
7511 div_table
= div_3200
;
7514 div_table
= div_4000
;
7517 div_table
= div_4800
;
7520 div_table
= div_5333
;
7526 return DIV_ROUND_CLOSEST(vco
, div_table
[cdclk_sel
]);
7529 DRM_ERROR("Unable to determine CDCLK. HPLL VCO=%u kHz, CFGC=0x%08x\n", vco
, tmp
);
7534 intel_reduce_m_n_ratio(uint32_t *num
, uint32_t *den
)
7536 while (*num
> DATA_LINK_M_N_MASK
||
7537 *den
> DATA_LINK_M_N_MASK
) {
7543 static void compute_m_n(unsigned int m
, unsigned int n
,
7544 uint32_t *ret_m
, uint32_t *ret_n
)
7546 *ret_n
= min_t(unsigned int, roundup_pow_of_two(n
), DATA_LINK_N_MAX
);
7547 *ret_m
= div_u64((uint64_t) m
* *ret_n
, n
);
7548 intel_reduce_m_n_ratio(ret_m
, ret_n
);
7552 intel_link_compute_m_n(int bits_per_pixel
, int nlanes
,
7553 int pixel_clock
, int link_clock
,
7554 struct intel_link_m_n
*m_n
)
7558 compute_m_n(bits_per_pixel
* pixel_clock
,
7559 link_clock
* nlanes
* 8,
7560 &m_n
->gmch_m
, &m_n
->gmch_n
);
7562 compute_m_n(pixel_clock
, link_clock
,
7563 &m_n
->link_m
, &m_n
->link_n
);
7566 static inline bool intel_panel_use_ssc(struct drm_i915_private
*dev_priv
)
7568 if (i915
.panel_use_ssc
>= 0)
7569 return i915
.panel_use_ssc
!= 0;
7570 return dev_priv
->vbt
.lvds_use_ssc
7571 && !(dev_priv
->quirks
& QUIRK_LVDS_SSC_DISABLE
);
7574 static uint32_t pnv_dpll_compute_fp(struct dpll
*dpll
)
7576 return (1 << dpll
->n
) << 16 | dpll
->m2
;
7579 static uint32_t i9xx_dpll_compute_fp(struct dpll
*dpll
)
7581 return dpll
->n
<< 16 | dpll
->m1
<< 8 | dpll
->m2
;
7584 static void i9xx_update_pll_dividers(struct intel_crtc
*crtc
,
7585 struct intel_crtc_state
*crtc_state
,
7586 struct dpll
*reduced_clock
)
7588 struct drm_device
*dev
= crtc
->base
.dev
;
7591 if (IS_PINEVIEW(dev
)) {
7592 fp
= pnv_dpll_compute_fp(&crtc_state
->dpll
);
7594 fp2
= pnv_dpll_compute_fp(reduced_clock
);
7596 fp
= i9xx_dpll_compute_fp(&crtc_state
->dpll
);
7598 fp2
= i9xx_dpll_compute_fp(reduced_clock
);
7601 crtc_state
->dpll_hw_state
.fp0
= fp
;
7603 crtc
->lowfreq_avail
= false;
7604 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
) &&
7606 crtc_state
->dpll_hw_state
.fp1
= fp2
;
7607 crtc
->lowfreq_avail
= true;
7609 crtc_state
->dpll_hw_state
.fp1
= fp
;
7613 static void vlv_pllb_recal_opamp(struct drm_i915_private
*dev_priv
, enum pipe
7619 * PLLB opamp always calibrates to max value of 0x3f, force enable it
7620 * and set it to a reasonable value instead.
7622 reg_val
= vlv_dpio_read(dev_priv
, pipe
, VLV_PLL_DW9(1));
7623 reg_val
&= 0xffffff00;
7624 reg_val
|= 0x00000030;
7625 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW9(1), reg_val
);
7627 reg_val
= vlv_dpio_read(dev_priv
, pipe
, VLV_REF_DW13
);
7628 reg_val
&= 0x8cffffff;
7629 reg_val
= 0x8c000000;
7630 vlv_dpio_write(dev_priv
, pipe
, VLV_REF_DW13
, reg_val
);
7632 reg_val
= vlv_dpio_read(dev_priv
, pipe
, VLV_PLL_DW9(1));
7633 reg_val
&= 0xffffff00;
7634 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW9(1), reg_val
);
7636 reg_val
= vlv_dpio_read(dev_priv
, pipe
, VLV_REF_DW13
);
7637 reg_val
&= 0x00ffffff;
7638 reg_val
|= 0xb0000000;
7639 vlv_dpio_write(dev_priv
, pipe
, VLV_REF_DW13
, reg_val
);
7642 static void intel_pch_transcoder_set_m_n(struct intel_crtc
*crtc
,
7643 struct intel_link_m_n
*m_n
)
7645 struct drm_device
*dev
= crtc
->base
.dev
;
7646 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7647 int pipe
= crtc
->pipe
;
7649 I915_WRITE(PCH_TRANS_DATA_M1(pipe
), TU_SIZE(m_n
->tu
) | m_n
->gmch_m
);
7650 I915_WRITE(PCH_TRANS_DATA_N1(pipe
), m_n
->gmch_n
);
7651 I915_WRITE(PCH_TRANS_LINK_M1(pipe
), m_n
->link_m
);
7652 I915_WRITE(PCH_TRANS_LINK_N1(pipe
), m_n
->link_n
);
7655 static void intel_cpu_transcoder_set_m_n(struct intel_crtc
*crtc
,
7656 struct intel_link_m_n
*m_n
,
7657 struct intel_link_m_n
*m2_n2
)
7659 struct drm_device
*dev
= crtc
->base
.dev
;
7660 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7661 int pipe
= crtc
->pipe
;
7662 enum transcoder transcoder
= crtc
->config
->cpu_transcoder
;
7664 if (INTEL_INFO(dev
)->gen
>= 5) {
7665 I915_WRITE(PIPE_DATA_M1(transcoder
), TU_SIZE(m_n
->tu
) | m_n
->gmch_m
);
7666 I915_WRITE(PIPE_DATA_N1(transcoder
), m_n
->gmch_n
);
7667 I915_WRITE(PIPE_LINK_M1(transcoder
), m_n
->link_m
);
7668 I915_WRITE(PIPE_LINK_N1(transcoder
), m_n
->link_n
);
7669 /* M2_N2 registers to be set only for gen < 8 (M2_N2 available
7670 * for gen < 8) and if DRRS is supported (to make sure the
7671 * registers are not unnecessarily accessed).
7673 if (m2_n2
&& (IS_CHERRYVIEW(dev
) || INTEL_INFO(dev
)->gen
< 8) &&
7674 crtc
->config
->has_drrs
) {
7675 I915_WRITE(PIPE_DATA_M2(transcoder
),
7676 TU_SIZE(m2_n2
->tu
) | m2_n2
->gmch_m
);
7677 I915_WRITE(PIPE_DATA_N2(transcoder
), m2_n2
->gmch_n
);
7678 I915_WRITE(PIPE_LINK_M2(transcoder
), m2_n2
->link_m
);
7679 I915_WRITE(PIPE_LINK_N2(transcoder
), m2_n2
->link_n
);
7682 I915_WRITE(PIPE_DATA_M_G4X(pipe
), TU_SIZE(m_n
->tu
) | m_n
->gmch_m
);
7683 I915_WRITE(PIPE_DATA_N_G4X(pipe
), m_n
->gmch_n
);
7684 I915_WRITE(PIPE_LINK_M_G4X(pipe
), m_n
->link_m
);
7685 I915_WRITE(PIPE_LINK_N_G4X(pipe
), m_n
->link_n
);
7689 void intel_dp_set_m_n(struct intel_crtc
*crtc
, enum link_m_n_set m_n
)
7691 struct intel_link_m_n
*dp_m_n
, *dp_m2_n2
= NULL
;
7694 dp_m_n
= &crtc
->config
->dp_m_n
;
7695 dp_m2_n2
= &crtc
->config
->dp_m2_n2
;
7696 } else if (m_n
== M2_N2
) {
7699 * M2_N2 registers are not supported. Hence m2_n2 divider value
7700 * needs to be programmed into M1_N1.
7702 dp_m_n
= &crtc
->config
->dp_m2_n2
;
7704 DRM_ERROR("Unsupported divider value\n");
7708 if (crtc
->config
->has_pch_encoder
)
7709 intel_pch_transcoder_set_m_n(crtc
, &crtc
->config
->dp_m_n
);
7711 intel_cpu_transcoder_set_m_n(crtc
, dp_m_n
, dp_m2_n2
);
7714 static void vlv_compute_dpll(struct intel_crtc
*crtc
,
7715 struct intel_crtc_state
*pipe_config
)
7717 pipe_config
->dpll_hw_state
.dpll
= DPLL_INTEGRATED_REF_CLK_VLV
|
7718 DPLL_REF_CLK_ENABLE_VLV
| DPLL_VGA_MODE_DIS
;
7719 if (crtc
->pipe
!= PIPE_A
)
7720 pipe_config
->dpll_hw_state
.dpll
|= DPLL_INTEGRATED_CRI_CLK_VLV
;
7722 /* DPLL not used with DSI, but still need the rest set up */
7723 if (!intel_crtc_has_type(pipe_config
, INTEL_OUTPUT_DSI
))
7724 pipe_config
->dpll_hw_state
.dpll
|= DPLL_VCO_ENABLE
|
7725 DPLL_EXT_BUFFER_ENABLE_VLV
;
7727 pipe_config
->dpll_hw_state
.dpll_md
=
7728 (pipe_config
->pixel_multiplier
- 1) << DPLL_MD_UDI_MULTIPLIER_SHIFT
;
7731 static void chv_compute_dpll(struct intel_crtc
*crtc
,
7732 struct intel_crtc_state
*pipe_config
)
7734 pipe_config
->dpll_hw_state
.dpll
= DPLL_SSC_REF_CLK_CHV
|
7735 DPLL_REF_CLK_ENABLE_VLV
| DPLL_VGA_MODE_DIS
;
7736 if (crtc
->pipe
!= PIPE_A
)
7737 pipe_config
->dpll_hw_state
.dpll
|= DPLL_INTEGRATED_CRI_CLK_VLV
;
7739 /* DPLL not used with DSI, but still need the rest set up */
7740 if (!intel_crtc_has_type(pipe_config
, INTEL_OUTPUT_DSI
))
7741 pipe_config
->dpll_hw_state
.dpll
|= DPLL_VCO_ENABLE
;
7743 pipe_config
->dpll_hw_state
.dpll_md
=
7744 (pipe_config
->pixel_multiplier
- 1) << DPLL_MD_UDI_MULTIPLIER_SHIFT
;
7747 static void vlv_prepare_pll(struct intel_crtc
*crtc
,
7748 const struct intel_crtc_state
*pipe_config
)
7750 struct drm_device
*dev
= crtc
->base
.dev
;
7751 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7752 enum pipe pipe
= crtc
->pipe
;
7754 u32 bestn
, bestm1
, bestm2
, bestp1
, bestp2
;
7755 u32 coreclk
, reg_val
;
7758 I915_WRITE(DPLL(pipe
),
7759 pipe_config
->dpll_hw_state
.dpll
&
7760 ~(DPLL_VCO_ENABLE
| DPLL_EXT_BUFFER_ENABLE_VLV
));
7762 /* No need to actually set up the DPLL with DSI */
7763 if ((pipe_config
->dpll_hw_state
.dpll
& DPLL_VCO_ENABLE
) == 0)
7766 mutex_lock(&dev_priv
->sb_lock
);
7768 bestn
= pipe_config
->dpll
.n
;
7769 bestm1
= pipe_config
->dpll
.m1
;
7770 bestm2
= pipe_config
->dpll
.m2
;
7771 bestp1
= pipe_config
->dpll
.p1
;
7772 bestp2
= pipe_config
->dpll
.p2
;
7774 /* See eDP HDMI DPIO driver vbios notes doc */
7776 /* PLL B needs special handling */
7778 vlv_pllb_recal_opamp(dev_priv
, pipe
);
7780 /* Set up Tx target for periodic Rcomp update */
7781 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW9_BCAST
, 0x0100000f);
7783 /* Disable target IRef on PLL */
7784 reg_val
= vlv_dpio_read(dev_priv
, pipe
, VLV_PLL_DW8(pipe
));
7785 reg_val
&= 0x00ffffff;
7786 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW8(pipe
), reg_val
);
7788 /* Disable fast lock */
7789 vlv_dpio_write(dev_priv
, pipe
, VLV_CMN_DW0
, 0x610);
7791 /* Set idtafcrecal before PLL is enabled */
7792 mdiv
= ((bestm1
<< DPIO_M1DIV_SHIFT
) | (bestm2
& DPIO_M2DIV_MASK
));
7793 mdiv
|= ((bestp1
<< DPIO_P1_SHIFT
) | (bestp2
<< DPIO_P2_SHIFT
));
7794 mdiv
|= ((bestn
<< DPIO_N_SHIFT
));
7795 mdiv
|= (1 << DPIO_K_SHIFT
);
7798 * Post divider depends on pixel clock rate, DAC vs digital (and LVDS,
7799 * but we don't support that).
7800 * Note: don't use the DAC post divider as it seems unstable.
7802 mdiv
|= (DPIO_POST_DIV_HDMIDP
<< DPIO_POST_DIV_SHIFT
);
7803 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW3(pipe
), mdiv
);
7805 mdiv
|= DPIO_ENABLE_CALIBRATION
;
7806 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW3(pipe
), mdiv
);
7808 /* Set HBR and RBR LPF coefficients */
7809 if (pipe_config
->port_clock
== 162000 ||
7810 intel_crtc_has_type(crtc
->config
, INTEL_OUTPUT_ANALOG
) ||
7811 intel_crtc_has_type(crtc
->config
, INTEL_OUTPUT_HDMI
))
7812 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW10(pipe
),
7815 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW10(pipe
),
7818 if (intel_crtc_has_dp_encoder(pipe_config
)) {
7819 /* Use SSC source */
7821 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW5(pipe
),
7824 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW5(pipe
),
7826 } else { /* HDMI or VGA */
7827 /* Use bend source */
7829 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW5(pipe
),
7832 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW5(pipe
),
7836 coreclk
= vlv_dpio_read(dev_priv
, pipe
, VLV_PLL_DW7(pipe
));
7837 coreclk
= (coreclk
& 0x0000ff00) | 0x01c00000;
7838 if (intel_crtc_has_dp_encoder(crtc
->config
))
7839 coreclk
|= 0x01000000;
7840 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW7(pipe
), coreclk
);
7842 vlv_dpio_write(dev_priv
, pipe
, VLV_PLL_DW11(pipe
), 0x87871000);
7843 mutex_unlock(&dev_priv
->sb_lock
);
7846 static void chv_prepare_pll(struct intel_crtc
*crtc
,
7847 const struct intel_crtc_state
*pipe_config
)
7849 struct drm_device
*dev
= crtc
->base
.dev
;
7850 struct drm_i915_private
*dev_priv
= to_i915(dev
);
7851 enum pipe pipe
= crtc
->pipe
;
7852 enum dpio_channel port
= vlv_pipe_to_channel(pipe
);
7853 u32 loopfilter
, tribuf_calcntr
;
7854 u32 bestn
, bestm1
, bestm2
, bestp1
, bestp2
, bestm2_frac
;
7858 /* Enable Refclk and SSC */
7859 I915_WRITE(DPLL(pipe
),
7860 pipe_config
->dpll_hw_state
.dpll
& ~DPLL_VCO_ENABLE
);
7862 /* No need to actually set up the DPLL with DSI */
7863 if ((pipe_config
->dpll_hw_state
.dpll
& DPLL_VCO_ENABLE
) == 0)
7866 bestn
= pipe_config
->dpll
.n
;
7867 bestm2_frac
= pipe_config
->dpll
.m2
& 0x3fffff;
7868 bestm1
= pipe_config
->dpll
.m1
;
7869 bestm2
= pipe_config
->dpll
.m2
>> 22;
7870 bestp1
= pipe_config
->dpll
.p1
;
7871 bestp2
= pipe_config
->dpll
.p2
;
7872 vco
= pipe_config
->dpll
.vco
;
7876 mutex_lock(&dev_priv
->sb_lock
);
7878 /* p1 and p2 divider */
7879 vlv_dpio_write(dev_priv
, pipe
, CHV_CMN_DW13(port
),
7880 5 << DPIO_CHV_S1_DIV_SHIFT
|
7881 bestp1
<< DPIO_CHV_P1_DIV_SHIFT
|
7882 bestp2
<< DPIO_CHV_P2_DIV_SHIFT
|
7883 1 << DPIO_CHV_K_DIV_SHIFT
);
7885 /* Feedback post-divider - m2 */
7886 vlv_dpio_write(dev_priv
, pipe
, CHV_PLL_DW0(port
), bestm2
);
7888 /* Feedback refclk divider - n and m1 */
7889 vlv_dpio_write(dev_priv
, pipe
, CHV_PLL_DW1(port
),
7890 DPIO_CHV_M1_DIV_BY_2
|
7891 1 << DPIO_CHV_N_DIV_SHIFT
);
7893 /* M2 fraction division */
7894 vlv_dpio_write(dev_priv
, pipe
, CHV_PLL_DW2(port
), bestm2_frac
);
7896 /* M2 fraction division enable */
7897 dpio_val
= vlv_dpio_read(dev_priv
, pipe
, CHV_PLL_DW3(port
));
7898 dpio_val
&= ~(DPIO_CHV_FEEDFWD_GAIN_MASK
| DPIO_CHV_FRAC_DIV_EN
);
7899 dpio_val
|= (2 << DPIO_CHV_FEEDFWD_GAIN_SHIFT
);
7901 dpio_val
|= DPIO_CHV_FRAC_DIV_EN
;
7902 vlv_dpio_write(dev_priv
, pipe
, CHV_PLL_DW3(port
), dpio_val
);
7904 /* Program digital lock detect threshold */
7905 dpio_val
= vlv_dpio_read(dev_priv
, pipe
, CHV_PLL_DW9(port
));
7906 dpio_val
&= ~(DPIO_CHV_INT_LOCK_THRESHOLD_MASK
|
7907 DPIO_CHV_INT_LOCK_THRESHOLD_SEL_COARSE
);
7908 dpio_val
|= (0x5 << DPIO_CHV_INT_LOCK_THRESHOLD_SHIFT
);
7910 dpio_val
|= DPIO_CHV_INT_LOCK_THRESHOLD_SEL_COARSE
;
7911 vlv_dpio_write(dev_priv
, pipe
, CHV_PLL_DW9(port
), dpio_val
);
7914 if (vco
== 5400000) {
7915 loopfilter
|= (0x3 << DPIO_CHV_PROP_COEFF_SHIFT
);
7916 loopfilter
|= (0x8 << DPIO_CHV_INT_COEFF_SHIFT
);
7917 loopfilter
|= (0x1 << DPIO_CHV_GAIN_CTRL_SHIFT
);
7918 tribuf_calcntr
= 0x9;
7919 } else if (vco
<= 6200000) {
7920 loopfilter
|= (0x5 << DPIO_CHV_PROP_COEFF_SHIFT
);
7921 loopfilter
|= (0xB << DPIO_CHV_INT_COEFF_SHIFT
);
7922 loopfilter
|= (0x3 << DPIO_CHV_GAIN_CTRL_SHIFT
);
7923 tribuf_calcntr
= 0x9;
7924 } else if (vco
<= 6480000) {
7925 loopfilter
|= (0x4 << DPIO_CHV_PROP_COEFF_SHIFT
);
7926 loopfilter
|= (0x9 << DPIO_CHV_INT_COEFF_SHIFT
);
7927 loopfilter
|= (0x3 << DPIO_CHV_GAIN_CTRL_SHIFT
);
7928 tribuf_calcntr
= 0x8;
7930 /* Not supported. Apply the same limits as in the max case */
7931 loopfilter
|= (0x4 << DPIO_CHV_PROP_COEFF_SHIFT
);
7932 loopfilter
|= (0x9 << DPIO_CHV_INT_COEFF_SHIFT
);
7933 loopfilter
|= (0x3 << DPIO_CHV_GAIN_CTRL_SHIFT
);
7936 vlv_dpio_write(dev_priv
, pipe
, CHV_PLL_DW6(port
), loopfilter
);
7938 dpio_val
= vlv_dpio_read(dev_priv
, pipe
, CHV_PLL_DW8(port
));
7939 dpio_val
&= ~DPIO_CHV_TDC_TARGET_CNT_MASK
;
7940 dpio_val
|= (tribuf_calcntr
<< DPIO_CHV_TDC_TARGET_CNT_SHIFT
);
7941 vlv_dpio_write(dev_priv
, pipe
, CHV_PLL_DW8(port
), dpio_val
);
7944 vlv_dpio_write(dev_priv
, pipe
, CHV_CMN_DW14(port
),
7945 vlv_dpio_read(dev_priv
, pipe
, CHV_CMN_DW14(port
)) |
7948 mutex_unlock(&dev_priv
->sb_lock
);
7952 * vlv_force_pll_on - forcibly enable just the PLL
7953 * @dev_priv: i915 private structure
7954 * @pipe: pipe PLL to enable
7955 * @dpll: PLL configuration
7957 * Enable the PLL for @pipe using the supplied @dpll config. To be used
7958 * in cases where we need the PLL enabled even when @pipe is not going to
7961 int vlv_force_pll_on(struct drm_device
*dev
, enum pipe pipe
,
7962 const struct dpll
*dpll
)
7964 struct intel_crtc
*crtc
=
7965 to_intel_crtc(intel_get_crtc_for_pipe(dev
, pipe
));
7966 struct intel_crtc_state
*pipe_config
;
7968 pipe_config
= kzalloc(sizeof(*pipe_config
), GFP_KERNEL
);
7972 pipe_config
->base
.crtc
= &crtc
->base
;
7973 pipe_config
->pixel_multiplier
= 1;
7974 pipe_config
->dpll
= *dpll
;
7976 if (IS_CHERRYVIEW(dev
)) {
7977 chv_compute_dpll(crtc
, pipe_config
);
7978 chv_prepare_pll(crtc
, pipe_config
);
7979 chv_enable_pll(crtc
, pipe_config
);
7981 vlv_compute_dpll(crtc
, pipe_config
);
7982 vlv_prepare_pll(crtc
, pipe_config
);
7983 vlv_enable_pll(crtc
, pipe_config
);
7992 * vlv_force_pll_off - forcibly disable just the PLL
7993 * @dev_priv: i915 private structure
7994 * @pipe: pipe PLL to disable
7996 * Disable the PLL for @pipe. To be used in cases where we need
7997 * the PLL enabled even when @pipe is not going to be enabled.
7999 void vlv_force_pll_off(struct drm_device
*dev
, enum pipe pipe
)
8001 if (IS_CHERRYVIEW(dev
))
8002 chv_disable_pll(to_i915(dev
), pipe
);
8004 vlv_disable_pll(to_i915(dev
), pipe
);
8007 static void i9xx_compute_dpll(struct intel_crtc
*crtc
,
8008 struct intel_crtc_state
*crtc_state
,
8009 struct dpll
*reduced_clock
)
8011 struct drm_device
*dev
= crtc
->base
.dev
;
8012 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8014 struct dpll
*clock
= &crtc_state
->dpll
;
8016 i9xx_update_pll_dividers(crtc
, crtc_state
, reduced_clock
);
8018 dpll
= DPLL_VGA_MODE_DIS
;
8020 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
))
8021 dpll
|= DPLLB_MODE_LVDS
;
8023 dpll
|= DPLLB_MODE_DAC_SERIAL
;
8025 if (IS_I945G(dev
) || IS_I945GM(dev
) || IS_G33(dev
)) {
8026 dpll
|= (crtc_state
->pixel_multiplier
- 1)
8027 << SDVO_MULTIPLIER_SHIFT_HIRES
;
8030 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_SDVO
) ||
8031 intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_HDMI
))
8032 dpll
|= DPLL_SDVO_HIGH_SPEED
;
8034 if (intel_crtc_has_dp_encoder(crtc_state
))
8035 dpll
|= DPLL_SDVO_HIGH_SPEED
;
8037 /* compute bitmask from p1 value */
8038 if (IS_PINEVIEW(dev
))
8039 dpll
|= (1 << (clock
->p1
- 1)) << DPLL_FPA01_P1_POST_DIV_SHIFT_PINEVIEW
;
8041 dpll
|= (1 << (clock
->p1
- 1)) << DPLL_FPA01_P1_POST_DIV_SHIFT
;
8042 if (IS_G4X(dev
) && reduced_clock
)
8043 dpll
|= (1 << (reduced_clock
->p1
- 1)) << DPLL_FPA1_P1_POST_DIV_SHIFT
;
8045 switch (clock
->p2
) {
8047 dpll
|= DPLL_DAC_SERIAL_P2_CLOCK_DIV_5
;
8050 dpll
|= DPLLB_LVDS_P2_CLOCK_DIV_7
;
8053 dpll
|= DPLL_DAC_SERIAL_P2_CLOCK_DIV_10
;
8056 dpll
|= DPLLB_LVDS_P2_CLOCK_DIV_14
;
8059 if (INTEL_INFO(dev
)->gen
>= 4)
8060 dpll
|= (6 << PLL_LOAD_PULSE_PHASE_SHIFT
);
8062 if (crtc_state
->sdvo_tv_clock
)
8063 dpll
|= PLL_REF_INPUT_TVCLKINBC
;
8064 else if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
) &&
8065 intel_panel_use_ssc(dev_priv
))
8066 dpll
|= PLLB_REF_INPUT_SPREADSPECTRUMIN
;
8068 dpll
|= PLL_REF_INPUT_DREFCLK
;
8070 dpll
|= DPLL_VCO_ENABLE
;
8071 crtc_state
->dpll_hw_state
.dpll
= dpll
;
8073 if (INTEL_INFO(dev
)->gen
>= 4) {
8074 u32 dpll_md
= (crtc_state
->pixel_multiplier
- 1)
8075 << DPLL_MD_UDI_MULTIPLIER_SHIFT
;
8076 crtc_state
->dpll_hw_state
.dpll_md
= dpll_md
;
8080 static void i8xx_compute_dpll(struct intel_crtc
*crtc
,
8081 struct intel_crtc_state
*crtc_state
,
8082 struct dpll
*reduced_clock
)
8084 struct drm_device
*dev
= crtc
->base
.dev
;
8085 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8087 struct dpll
*clock
= &crtc_state
->dpll
;
8089 i9xx_update_pll_dividers(crtc
, crtc_state
, reduced_clock
);
8091 dpll
= DPLL_VGA_MODE_DIS
;
8093 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
)) {
8094 dpll
|= (1 << (clock
->p1
- 1)) << DPLL_FPA01_P1_POST_DIV_SHIFT
;
8097 dpll
|= PLL_P1_DIVIDE_BY_TWO
;
8099 dpll
|= (clock
->p1
- 2) << DPLL_FPA01_P1_POST_DIV_SHIFT
;
8101 dpll
|= PLL_P2_DIVIDE_BY_4
;
8104 if (!IS_I830(dev
) && intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_DVO
))
8105 dpll
|= DPLL_DVO_2X_MODE
;
8107 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
) &&
8108 intel_panel_use_ssc(dev_priv
))
8109 dpll
|= PLLB_REF_INPUT_SPREADSPECTRUMIN
;
8111 dpll
|= PLL_REF_INPUT_DREFCLK
;
8113 dpll
|= DPLL_VCO_ENABLE
;
8114 crtc_state
->dpll_hw_state
.dpll
= dpll
;
8117 static void intel_set_pipe_timings(struct intel_crtc
*intel_crtc
)
8119 struct drm_device
*dev
= intel_crtc
->base
.dev
;
8120 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8121 enum pipe pipe
= intel_crtc
->pipe
;
8122 enum transcoder cpu_transcoder
= intel_crtc
->config
->cpu_transcoder
;
8123 const struct drm_display_mode
*adjusted_mode
= &intel_crtc
->config
->base
.adjusted_mode
;
8124 uint32_t crtc_vtotal
, crtc_vblank_end
;
8127 /* We need to be careful not to changed the adjusted mode, for otherwise
8128 * the hw state checker will get angry at the mismatch. */
8129 crtc_vtotal
= adjusted_mode
->crtc_vtotal
;
8130 crtc_vblank_end
= adjusted_mode
->crtc_vblank_end
;
8132 if (adjusted_mode
->flags
& DRM_MODE_FLAG_INTERLACE
) {
8133 /* the chip adds 2 halflines automatically */
8135 crtc_vblank_end
-= 1;
8137 if (intel_crtc_has_type(intel_crtc
->config
, INTEL_OUTPUT_SDVO
))
8138 vsyncshift
= (adjusted_mode
->crtc_htotal
- 1) / 2;
8140 vsyncshift
= adjusted_mode
->crtc_hsync_start
-
8141 adjusted_mode
->crtc_htotal
/ 2;
8143 vsyncshift
+= adjusted_mode
->crtc_htotal
;
8146 if (INTEL_INFO(dev
)->gen
> 3)
8147 I915_WRITE(VSYNCSHIFT(cpu_transcoder
), vsyncshift
);
8149 I915_WRITE(HTOTAL(cpu_transcoder
),
8150 (adjusted_mode
->crtc_hdisplay
- 1) |
8151 ((adjusted_mode
->crtc_htotal
- 1) << 16));
8152 I915_WRITE(HBLANK(cpu_transcoder
),
8153 (adjusted_mode
->crtc_hblank_start
- 1) |
8154 ((adjusted_mode
->crtc_hblank_end
- 1) << 16));
8155 I915_WRITE(HSYNC(cpu_transcoder
),
8156 (adjusted_mode
->crtc_hsync_start
- 1) |
8157 ((adjusted_mode
->crtc_hsync_end
- 1) << 16));
8159 I915_WRITE(VTOTAL(cpu_transcoder
),
8160 (adjusted_mode
->crtc_vdisplay
- 1) |
8161 ((crtc_vtotal
- 1) << 16));
8162 I915_WRITE(VBLANK(cpu_transcoder
),
8163 (adjusted_mode
->crtc_vblank_start
- 1) |
8164 ((crtc_vblank_end
- 1) << 16));
8165 I915_WRITE(VSYNC(cpu_transcoder
),
8166 (adjusted_mode
->crtc_vsync_start
- 1) |
8167 ((adjusted_mode
->crtc_vsync_end
- 1) << 16));
8169 /* Workaround: when the EDP input selection is B, the VTOTAL_B must be
8170 * programmed with the VTOTAL_EDP value. Same for VTOTAL_C. This is
8171 * documented on the DDI_FUNC_CTL register description, EDP Input Select
8173 if (IS_HASWELL(dev
) && cpu_transcoder
== TRANSCODER_EDP
&&
8174 (pipe
== PIPE_B
|| pipe
== PIPE_C
))
8175 I915_WRITE(VTOTAL(pipe
), I915_READ(VTOTAL(cpu_transcoder
)));
8179 static void intel_set_pipe_src_size(struct intel_crtc
*intel_crtc
)
8181 struct drm_device
*dev
= intel_crtc
->base
.dev
;
8182 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8183 enum pipe pipe
= intel_crtc
->pipe
;
8185 /* pipesrc controls the size that is scaled from, which should
8186 * always be the user's requested size.
8188 I915_WRITE(PIPESRC(pipe
),
8189 ((intel_crtc
->config
->pipe_src_w
- 1) << 16) |
8190 (intel_crtc
->config
->pipe_src_h
- 1));
8193 static void intel_get_pipe_timings(struct intel_crtc
*crtc
,
8194 struct intel_crtc_state
*pipe_config
)
8196 struct drm_device
*dev
= crtc
->base
.dev
;
8197 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8198 enum transcoder cpu_transcoder
= pipe_config
->cpu_transcoder
;
8201 tmp
= I915_READ(HTOTAL(cpu_transcoder
));
8202 pipe_config
->base
.adjusted_mode
.crtc_hdisplay
= (tmp
& 0xffff) + 1;
8203 pipe_config
->base
.adjusted_mode
.crtc_htotal
= ((tmp
>> 16) & 0xffff) + 1;
8204 tmp
= I915_READ(HBLANK(cpu_transcoder
));
8205 pipe_config
->base
.adjusted_mode
.crtc_hblank_start
= (tmp
& 0xffff) + 1;
8206 pipe_config
->base
.adjusted_mode
.crtc_hblank_end
= ((tmp
>> 16) & 0xffff) + 1;
8207 tmp
= I915_READ(HSYNC(cpu_transcoder
));
8208 pipe_config
->base
.adjusted_mode
.crtc_hsync_start
= (tmp
& 0xffff) + 1;
8209 pipe_config
->base
.adjusted_mode
.crtc_hsync_end
= ((tmp
>> 16) & 0xffff) + 1;
8211 tmp
= I915_READ(VTOTAL(cpu_transcoder
));
8212 pipe_config
->base
.adjusted_mode
.crtc_vdisplay
= (tmp
& 0xffff) + 1;
8213 pipe_config
->base
.adjusted_mode
.crtc_vtotal
= ((tmp
>> 16) & 0xffff) + 1;
8214 tmp
= I915_READ(VBLANK(cpu_transcoder
));
8215 pipe_config
->base
.adjusted_mode
.crtc_vblank_start
= (tmp
& 0xffff) + 1;
8216 pipe_config
->base
.adjusted_mode
.crtc_vblank_end
= ((tmp
>> 16) & 0xffff) + 1;
8217 tmp
= I915_READ(VSYNC(cpu_transcoder
));
8218 pipe_config
->base
.adjusted_mode
.crtc_vsync_start
= (tmp
& 0xffff) + 1;
8219 pipe_config
->base
.adjusted_mode
.crtc_vsync_end
= ((tmp
>> 16) & 0xffff) + 1;
8221 if (I915_READ(PIPECONF(cpu_transcoder
)) & PIPECONF_INTERLACE_MASK
) {
8222 pipe_config
->base
.adjusted_mode
.flags
|= DRM_MODE_FLAG_INTERLACE
;
8223 pipe_config
->base
.adjusted_mode
.crtc_vtotal
+= 1;
8224 pipe_config
->base
.adjusted_mode
.crtc_vblank_end
+= 1;
8228 static void intel_get_pipe_src_size(struct intel_crtc
*crtc
,
8229 struct intel_crtc_state
*pipe_config
)
8231 struct drm_device
*dev
= crtc
->base
.dev
;
8232 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8235 tmp
= I915_READ(PIPESRC(crtc
->pipe
));
8236 pipe_config
->pipe_src_h
= (tmp
& 0xffff) + 1;
8237 pipe_config
->pipe_src_w
= ((tmp
>> 16) & 0xffff) + 1;
8239 pipe_config
->base
.mode
.vdisplay
= pipe_config
->pipe_src_h
;
8240 pipe_config
->base
.mode
.hdisplay
= pipe_config
->pipe_src_w
;
8243 void intel_mode_from_pipe_config(struct drm_display_mode
*mode
,
8244 struct intel_crtc_state
*pipe_config
)
8246 mode
->hdisplay
= pipe_config
->base
.adjusted_mode
.crtc_hdisplay
;
8247 mode
->htotal
= pipe_config
->base
.adjusted_mode
.crtc_htotal
;
8248 mode
->hsync_start
= pipe_config
->base
.adjusted_mode
.crtc_hsync_start
;
8249 mode
->hsync_end
= pipe_config
->base
.adjusted_mode
.crtc_hsync_end
;
8251 mode
->vdisplay
= pipe_config
->base
.adjusted_mode
.crtc_vdisplay
;
8252 mode
->vtotal
= pipe_config
->base
.adjusted_mode
.crtc_vtotal
;
8253 mode
->vsync_start
= pipe_config
->base
.adjusted_mode
.crtc_vsync_start
;
8254 mode
->vsync_end
= pipe_config
->base
.adjusted_mode
.crtc_vsync_end
;
8256 mode
->flags
= pipe_config
->base
.adjusted_mode
.flags
;
8257 mode
->type
= DRM_MODE_TYPE_DRIVER
;
8259 mode
->clock
= pipe_config
->base
.adjusted_mode
.crtc_clock
;
8260 mode
->flags
|= pipe_config
->base
.adjusted_mode
.flags
;
8262 mode
->hsync
= drm_mode_hsync(mode
);
8263 mode
->vrefresh
= drm_mode_vrefresh(mode
);
8264 drm_mode_set_name(mode
);
8267 static void i9xx_set_pipeconf(struct intel_crtc
*intel_crtc
)
8269 struct drm_device
*dev
= intel_crtc
->base
.dev
;
8270 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8275 if ((intel_crtc
->pipe
== PIPE_A
&& dev_priv
->quirks
& QUIRK_PIPEA_FORCE
) ||
8276 (intel_crtc
->pipe
== PIPE_B
&& dev_priv
->quirks
& QUIRK_PIPEB_FORCE
))
8277 pipeconf
|= I915_READ(PIPECONF(intel_crtc
->pipe
)) & PIPECONF_ENABLE
;
8279 if (intel_crtc
->config
->double_wide
)
8280 pipeconf
|= PIPECONF_DOUBLE_WIDE
;
8282 /* only g4x and later have fancy bpc/dither controls */
8283 if (IS_G4X(dev
) || IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
)) {
8284 /* Bspec claims that we can't use dithering for 30bpp pipes. */
8285 if (intel_crtc
->config
->dither
&& intel_crtc
->config
->pipe_bpp
!= 30)
8286 pipeconf
|= PIPECONF_DITHER_EN
|
8287 PIPECONF_DITHER_TYPE_SP
;
8289 switch (intel_crtc
->config
->pipe_bpp
) {
8291 pipeconf
|= PIPECONF_6BPC
;
8294 pipeconf
|= PIPECONF_8BPC
;
8297 pipeconf
|= PIPECONF_10BPC
;
8300 /* Case prevented by intel_choose_pipe_bpp_dither. */
8305 if (HAS_PIPE_CXSR(dev
)) {
8306 if (intel_crtc
->lowfreq_avail
) {
8307 DRM_DEBUG_KMS("enabling CxSR downclocking\n");
8308 pipeconf
|= PIPECONF_CXSR_DOWNCLOCK
;
8310 DRM_DEBUG_KMS("disabling CxSR downclocking\n");
8314 if (intel_crtc
->config
->base
.adjusted_mode
.flags
& DRM_MODE_FLAG_INTERLACE
) {
8315 if (INTEL_INFO(dev
)->gen
< 4 ||
8316 intel_crtc_has_type(intel_crtc
->config
, INTEL_OUTPUT_SDVO
))
8317 pipeconf
|= PIPECONF_INTERLACE_W_FIELD_INDICATION
;
8319 pipeconf
|= PIPECONF_INTERLACE_W_SYNC_SHIFT
;
8321 pipeconf
|= PIPECONF_PROGRESSIVE
;
8323 if ((IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
)) &&
8324 intel_crtc
->config
->limited_color_range
)
8325 pipeconf
|= PIPECONF_COLOR_RANGE_SELECT
;
8327 I915_WRITE(PIPECONF(intel_crtc
->pipe
), pipeconf
);
8328 POSTING_READ(PIPECONF(intel_crtc
->pipe
));
8331 static int i8xx_crtc_compute_clock(struct intel_crtc
*crtc
,
8332 struct intel_crtc_state
*crtc_state
)
8334 struct drm_device
*dev
= crtc
->base
.dev
;
8335 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8336 const struct intel_limit
*limit
;
8339 memset(&crtc_state
->dpll_hw_state
, 0,
8340 sizeof(crtc_state
->dpll_hw_state
));
8342 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
)) {
8343 if (intel_panel_use_ssc(dev_priv
)) {
8344 refclk
= dev_priv
->vbt
.lvds_ssc_freq
;
8345 DRM_DEBUG_KMS("using SSC reference clock of %d kHz\n", refclk
);
8348 limit
= &intel_limits_i8xx_lvds
;
8349 } else if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_DVO
)) {
8350 limit
= &intel_limits_i8xx_dvo
;
8352 limit
= &intel_limits_i8xx_dac
;
8355 if (!crtc_state
->clock_set
&&
8356 !i9xx_find_best_dpll(limit
, crtc_state
, crtc_state
->port_clock
,
8357 refclk
, NULL
, &crtc_state
->dpll
)) {
8358 DRM_ERROR("Couldn't find PLL settings for mode!\n");
8362 i8xx_compute_dpll(crtc
, crtc_state
, NULL
);
8367 static int g4x_crtc_compute_clock(struct intel_crtc
*crtc
,
8368 struct intel_crtc_state
*crtc_state
)
8370 struct drm_device
*dev
= crtc
->base
.dev
;
8371 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8372 const struct intel_limit
*limit
;
8375 memset(&crtc_state
->dpll_hw_state
, 0,
8376 sizeof(crtc_state
->dpll_hw_state
));
8378 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
)) {
8379 if (intel_panel_use_ssc(dev_priv
)) {
8380 refclk
= dev_priv
->vbt
.lvds_ssc_freq
;
8381 DRM_DEBUG_KMS("using SSC reference clock of %d kHz\n", refclk
);
8384 if (intel_is_dual_link_lvds(dev
))
8385 limit
= &intel_limits_g4x_dual_channel_lvds
;
8387 limit
= &intel_limits_g4x_single_channel_lvds
;
8388 } else if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_HDMI
) ||
8389 intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_ANALOG
)) {
8390 limit
= &intel_limits_g4x_hdmi
;
8391 } else if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_SDVO
)) {
8392 limit
= &intel_limits_g4x_sdvo
;
8394 /* The option is for other outputs */
8395 limit
= &intel_limits_i9xx_sdvo
;
8398 if (!crtc_state
->clock_set
&&
8399 !g4x_find_best_dpll(limit
, crtc_state
, crtc_state
->port_clock
,
8400 refclk
, NULL
, &crtc_state
->dpll
)) {
8401 DRM_ERROR("Couldn't find PLL settings for mode!\n");
8405 i9xx_compute_dpll(crtc
, crtc_state
, NULL
);
8410 static int pnv_crtc_compute_clock(struct intel_crtc
*crtc
,
8411 struct intel_crtc_state
*crtc_state
)
8413 struct drm_device
*dev
= crtc
->base
.dev
;
8414 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8415 const struct intel_limit
*limit
;
8418 memset(&crtc_state
->dpll_hw_state
, 0,
8419 sizeof(crtc_state
->dpll_hw_state
));
8421 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
)) {
8422 if (intel_panel_use_ssc(dev_priv
)) {
8423 refclk
= dev_priv
->vbt
.lvds_ssc_freq
;
8424 DRM_DEBUG_KMS("using SSC reference clock of %d kHz\n", refclk
);
8427 limit
= &intel_limits_pineview_lvds
;
8429 limit
= &intel_limits_pineview_sdvo
;
8432 if (!crtc_state
->clock_set
&&
8433 !pnv_find_best_dpll(limit
, crtc_state
, crtc_state
->port_clock
,
8434 refclk
, NULL
, &crtc_state
->dpll
)) {
8435 DRM_ERROR("Couldn't find PLL settings for mode!\n");
8439 i9xx_compute_dpll(crtc
, crtc_state
, NULL
);
8444 static int i9xx_crtc_compute_clock(struct intel_crtc
*crtc
,
8445 struct intel_crtc_state
*crtc_state
)
8447 struct drm_device
*dev
= crtc
->base
.dev
;
8448 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8449 const struct intel_limit
*limit
;
8452 memset(&crtc_state
->dpll_hw_state
, 0,
8453 sizeof(crtc_state
->dpll_hw_state
));
8455 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
)) {
8456 if (intel_panel_use_ssc(dev_priv
)) {
8457 refclk
= dev_priv
->vbt
.lvds_ssc_freq
;
8458 DRM_DEBUG_KMS("using SSC reference clock of %d kHz\n", refclk
);
8461 limit
= &intel_limits_i9xx_lvds
;
8463 limit
= &intel_limits_i9xx_sdvo
;
8466 if (!crtc_state
->clock_set
&&
8467 !i9xx_find_best_dpll(limit
, crtc_state
, crtc_state
->port_clock
,
8468 refclk
, NULL
, &crtc_state
->dpll
)) {
8469 DRM_ERROR("Couldn't find PLL settings for mode!\n");
8473 i9xx_compute_dpll(crtc
, crtc_state
, NULL
);
8478 static int chv_crtc_compute_clock(struct intel_crtc
*crtc
,
8479 struct intel_crtc_state
*crtc_state
)
8481 int refclk
= 100000;
8482 const struct intel_limit
*limit
= &intel_limits_chv
;
8484 memset(&crtc_state
->dpll_hw_state
, 0,
8485 sizeof(crtc_state
->dpll_hw_state
));
8487 if (!crtc_state
->clock_set
&&
8488 !chv_find_best_dpll(limit
, crtc_state
, crtc_state
->port_clock
,
8489 refclk
, NULL
, &crtc_state
->dpll
)) {
8490 DRM_ERROR("Couldn't find PLL settings for mode!\n");
8494 chv_compute_dpll(crtc
, crtc_state
);
8499 static int vlv_crtc_compute_clock(struct intel_crtc
*crtc
,
8500 struct intel_crtc_state
*crtc_state
)
8502 int refclk
= 100000;
8503 const struct intel_limit
*limit
= &intel_limits_vlv
;
8505 memset(&crtc_state
->dpll_hw_state
, 0,
8506 sizeof(crtc_state
->dpll_hw_state
));
8508 if (!crtc_state
->clock_set
&&
8509 !vlv_find_best_dpll(limit
, crtc_state
, crtc_state
->port_clock
,
8510 refclk
, NULL
, &crtc_state
->dpll
)) {
8511 DRM_ERROR("Couldn't find PLL settings for mode!\n");
8515 vlv_compute_dpll(crtc
, crtc_state
);
8520 static void i9xx_get_pfit_config(struct intel_crtc
*crtc
,
8521 struct intel_crtc_state
*pipe_config
)
8523 struct drm_device
*dev
= crtc
->base
.dev
;
8524 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8527 if (INTEL_INFO(dev
)->gen
<= 3 && (IS_I830(dev
) || !IS_MOBILE(dev
)))
8530 tmp
= I915_READ(PFIT_CONTROL
);
8531 if (!(tmp
& PFIT_ENABLE
))
8534 /* Check whether the pfit is attached to our pipe. */
8535 if (INTEL_INFO(dev
)->gen
< 4) {
8536 if (crtc
->pipe
!= PIPE_B
)
8539 if ((tmp
& PFIT_PIPE_MASK
) != (crtc
->pipe
<< PFIT_PIPE_SHIFT
))
8543 pipe_config
->gmch_pfit
.control
= tmp
;
8544 pipe_config
->gmch_pfit
.pgm_ratios
= I915_READ(PFIT_PGM_RATIOS
);
8547 static void vlv_crtc_clock_get(struct intel_crtc
*crtc
,
8548 struct intel_crtc_state
*pipe_config
)
8550 struct drm_device
*dev
= crtc
->base
.dev
;
8551 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8552 int pipe
= pipe_config
->cpu_transcoder
;
8555 int refclk
= 100000;
8557 /* In case of DSI, DPLL will not be used */
8558 if ((pipe_config
->dpll_hw_state
.dpll
& DPLL_VCO_ENABLE
) == 0)
8561 mutex_lock(&dev_priv
->sb_lock
);
8562 mdiv
= vlv_dpio_read(dev_priv
, pipe
, VLV_PLL_DW3(pipe
));
8563 mutex_unlock(&dev_priv
->sb_lock
);
8565 clock
.m1
= (mdiv
>> DPIO_M1DIV_SHIFT
) & 7;
8566 clock
.m2
= mdiv
& DPIO_M2DIV_MASK
;
8567 clock
.n
= (mdiv
>> DPIO_N_SHIFT
) & 0xf;
8568 clock
.p1
= (mdiv
>> DPIO_P1_SHIFT
) & 7;
8569 clock
.p2
= (mdiv
>> DPIO_P2_SHIFT
) & 0x1f;
8571 pipe_config
->port_clock
= vlv_calc_dpll_params(refclk
, &clock
);
8575 i9xx_get_initial_plane_config(struct intel_crtc
*crtc
,
8576 struct intel_initial_plane_config
*plane_config
)
8578 struct drm_device
*dev
= crtc
->base
.dev
;
8579 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8580 u32 val
, base
, offset
;
8581 int pipe
= crtc
->pipe
, plane
= crtc
->plane
;
8582 int fourcc
, pixel_format
;
8583 unsigned int aligned_height
;
8584 struct drm_framebuffer
*fb
;
8585 struct intel_framebuffer
*intel_fb
;
8587 val
= I915_READ(DSPCNTR(plane
));
8588 if (!(val
& DISPLAY_PLANE_ENABLE
))
8591 intel_fb
= kzalloc(sizeof(*intel_fb
), GFP_KERNEL
);
8593 DRM_DEBUG_KMS("failed to alloc fb\n");
8597 fb
= &intel_fb
->base
;
8599 if (INTEL_INFO(dev
)->gen
>= 4) {
8600 if (val
& DISPPLANE_TILED
) {
8601 plane_config
->tiling
= I915_TILING_X
;
8602 fb
->modifier
[0] = I915_FORMAT_MOD_X_TILED
;
8606 pixel_format
= val
& DISPPLANE_PIXFORMAT_MASK
;
8607 fourcc
= i9xx_format_to_fourcc(pixel_format
);
8608 fb
->pixel_format
= fourcc
;
8609 fb
->bits_per_pixel
= drm_format_plane_cpp(fourcc
, 0) * 8;
8611 if (INTEL_INFO(dev
)->gen
>= 4) {
8612 if (plane_config
->tiling
)
8613 offset
= I915_READ(DSPTILEOFF(plane
));
8615 offset
= I915_READ(DSPLINOFF(plane
));
8616 base
= I915_READ(DSPSURF(plane
)) & 0xfffff000;
8618 base
= I915_READ(DSPADDR(plane
));
8620 plane_config
->base
= base
;
8622 val
= I915_READ(PIPESRC(pipe
));
8623 fb
->width
= ((val
>> 16) & 0xfff) + 1;
8624 fb
->height
= ((val
>> 0) & 0xfff) + 1;
8626 val
= I915_READ(DSPSTRIDE(pipe
));
8627 fb
->pitches
[0] = val
& 0xffffffc0;
8629 aligned_height
= intel_fb_align_height(dev
, fb
->height
,
8633 plane_config
->size
= fb
->pitches
[0] * aligned_height
;
8635 DRM_DEBUG_KMS("pipe/plane %c/%d with fb: size=%dx%d@%d, offset=%x, pitch %d, size 0x%x\n",
8636 pipe_name(pipe
), plane
, fb
->width
, fb
->height
,
8637 fb
->bits_per_pixel
, base
, fb
->pitches
[0],
8638 plane_config
->size
);
8640 plane_config
->fb
= intel_fb
;
8643 static void chv_crtc_clock_get(struct intel_crtc
*crtc
,
8644 struct intel_crtc_state
*pipe_config
)
8646 struct drm_device
*dev
= crtc
->base
.dev
;
8647 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8648 int pipe
= pipe_config
->cpu_transcoder
;
8649 enum dpio_channel port
= vlv_pipe_to_channel(pipe
);
8651 u32 cmn_dw13
, pll_dw0
, pll_dw1
, pll_dw2
, pll_dw3
;
8652 int refclk
= 100000;
8654 /* In case of DSI, DPLL will not be used */
8655 if ((pipe_config
->dpll_hw_state
.dpll
& DPLL_VCO_ENABLE
) == 0)
8658 mutex_lock(&dev_priv
->sb_lock
);
8659 cmn_dw13
= vlv_dpio_read(dev_priv
, pipe
, CHV_CMN_DW13(port
));
8660 pll_dw0
= vlv_dpio_read(dev_priv
, pipe
, CHV_PLL_DW0(port
));
8661 pll_dw1
= vlv_dpio_read(dev_priv
, pipe
, CHV_PLL_DW1(port
));
8662 pll_dw2
= vlv_dpio_read(dev_priv
, pipe
, CHV_PLL_DW2(port
));
8663 pll_dw3
= vlv_dpio_read(dev_priv
, pipe
, CHV_PLL_DW3(port
));
8664 mutex_unlock(&dev_priv
->sb_lock
);
8666 clock
.m1
= (pll_dw1
& 0x7) == DPIO_CHV_M1_DIV_BY_2
? 2 : 0;
8667 clock
.m2
= (pll_dw0
& 0xff) << 22;
8668 if (pll_dw3
& DPIO_CHV_FRAC_DIV_EN
)
8669 clock
.m2
|= pll_dw2
& 0x3fffff;
8670 clock
.n
= (pll_dw1
>> DPIO_CHV_N_DIV_SHIFT
) & 0xf;
8671 clock
.p1
= (cmn_dw13
>> DPIO_CHV_P1_DIV_SHIFT
) & 0x7;
8672 clock
.p2
= (cmn_dw13
>> DPIO_CHV_P2_DIV_SHIFT
) & 0x1f;
8674 pipe_config
->port_clock
= chv_calc_dpll_params(refclk
, &clock
);
8677 static bool i9xx_get_pipe_config(struct intel_crtc
*crtc
,
8678 struct intel_crtc_state
*pipe_config
)
8680 struct drm_device
*dev
= crtc
->base
.dev
;
8681 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8682 enum intel_display_power_domain power_domain
;
8686 power_domain
= POWER_DOMAIN_PIPE(crtc
->pipe
);
8687 if (!intel_display_power_get_if_enabled(dev_priv
, power_domain
))
8690 pipe_config
->cpu_transcoder
= (enum transcoder
) crtc
->pipe
;
8691 pipe_config
->shared_dpll
= NULL
;
8695 tmp
= I915_READ(PIPECONF(crtc
->pipe
));
8696 if (!(tmp
& PIPECONF_ENABLE
))
8699 if (IS_G4X(dev
) || IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
)) {
8700 switch (tmp
& PIPECONF_BPC_MASK
) {
8702 pipe_config
->pipe_bpp
= 18;
8705 pipe_config
->pipe_bpp
= 24;
8707 case PIPECONF_10BPC
:
8708 pipe_config
->pipe_bpp
= 30;
8715 if ((IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
)) &&
8716 (tmp
& PIPECONF_COLOR_RANGE_SELECT
))
8717 pipe_config
->limited_color_range
= true;
8719 if (INTEL_INFO(dev
)->gen
< 4)
8720 pipe_config
->double_wide
= tmp
& PIPECONF_DOUBLE_WIDE
;
8722 intel_get_pipe_timings(crtc
, pipe_config
);
8723 intel_get_pipe_src_size(crtc
, pipe_config
);
8725 i9xx_get_pfit_config(crtc
, pipe_config
);
8727 if (INTEL_INFO(dev
)->gen
>= 4) {
8728 /* No way to read it out on pipes B and C */
8729 if (IS_CHERRYVIEW(dev
) && crtc
->pipe
!= PIPE_A
)
8730 tmp
= dev_priv
->chv_dpll_md
[crtc
->pipe
];
8732 tmp
= I915_READ(DPLL_MD(crtc
->pipe
));
8733 pipe_config
->pixel_multiplier
=
8734 ((tmp
& DPLL_MD_UDI_MULTIPLIER_MASK
)
8735 >> DPLL_MD_UDI_MULTIPLIER_SHIFT
) + 1;
8736 pipe_config
->dpll_hw_state
.dpll_md
= tmp
;
8737 } else if (IS_I945G(dev
) || IS_I945GM(dev
) || IS_G33(dev
)) {
8738 tmp
= I915_READ(DPLL(crtc
->pipe
));
8739 pipe_config
->pixel_multiplier
=
8740 ((tmp
& SDVO_MULTIPLIER_MASK
)
8741 >> SDVO_MULTIPLIER_SHIFT_HIRES
) + 1;
8743 /* Note that on i915G/GM the pixel multiplier is in the sdvo
8744 * port and will be fixed up in the encoder->get_config
8746 pipe_config
->pixel_multiplier
= 1;
8748 pipe_config
->dpll_hw_state
.dpll
= I915_READ(DPLL(crtc
->pipe
));
8749 if (!IS_VALLEYVIEW(dev
) && !IS_CHERRYVIEW(dev
)) {
8751 * DPLL_DVO_2X_MODE must be enabled for both DPLLs
8752 * on 830. Filter it out here so that we don't
8753 * report errors due to that.
8756 pipe_config
->dpll_hw_state
.dpll
&= ~DPLL_DVO_2X_MODE
;
8758 pipe_config
->dpll_hw_state
.fp0
= I915_READ(FP0(crtc
->pipe
));
8759 pipe_config
->dpll_hw_state
.fp1
= I915_READ(FP1(crtc
->pipe
));
8761 /* Mask out read-only status bits. */
8762 pipe_config
->dpll_hw_state
.dpll
&= ~(DPLL_LOCK_VLV
|
8763 DPLL_PORTC_READY_MASK
|
8764 DPLL_PORTB_READY_MASK
);
8767 if (IS_CHERRYVIEW(dev
))
8768 chv_crtc_clock_get(crtc
, pipe_config
);
8769 else if (IS_VALLEYVIEW(dev
))
8770 vlv_crtc_clock_get(crtc
, pipe_config
);
8772 i9xx_crtc_clock_get(crtc
, pipe_config
);
8775 * Normally the dotclock is filled in by the encoder .get_config()
8776 * but in case the pipe is enabled w/o any ports we need a sane
8779 pipe_config
->base
.adjusted_mode
.crtc_clock
=
8780 pipe_config
->port_clock
/ pipe_config
->pixel_multiplier
;
8785 intel_display_power_put(dev_priv
, power_domain
);
8790 static void ironlake_init_pch_refclk(struct drm_device
*dev
)
8792 struct drm_i915_private
*dev_priv
= to_i915(dev
);
8793 struct intel_encoder
*encoder
;
8796 bool has_lvds
= false;
8797 bool has_cpu_edp
= false;
8798 bool has_panel
= false;
8799 bool has_ck505
= false;
8800 bool can_ssc
= false;
8801 bool using_ssc_source
= false;
8803 /* We need to take the global config into account */
8804 for_each_intel_encoder(dev
, encoder
) {
8805 switch (encoder
->type
) {
8806 case INTEL_OUTPUT_LVDS
:
8810 case INTEL_OUTPUT_EDP
:
8812 if (enc_to_dig_port(&encoder
->base
)->port
== PORT_A
)
8820 if (HAS_PCH_IBX(dev
)) {
8821 has_ck505
= dev_priv
->vbt
.display_clock_mode
;
8822 can_ssc
= has_ck505
;
8828 /* Check if any DPLLs are using the SSC source */
8829 for (i
= 0; i
< dev_priv
->num_shared_dpll
; i
++) {
8830 u32 temp
= I915_READ(PCH_DPLL(i
));
8832 if (!(temp
& DPLL_VCO_ENABLE
))
8835 if ((temp
& PLL_REF_INPUT_MASK
) ==
8836 PLLB_REF_INPUT_SPREADSPECTRUMIN
) {
8837 using_ssc_source
= true;
8842 DRM_DEBUG_KMS("has_panel %d has_lvds %d has_ck505 %d using_ssc_source %d\n",
8843 has_panel
, has_lvds
, has_ck505
, using_ssc_source
);
8845 /* Ironlake: try to setup display ref clock before DPLL
8846 * enabling. This is only under driver's control after
8847 * PCH B stepping, previous chipset stepping should be
8848 * ignoring this setting.
8850 val
= I915_READ(PCH_DREF_CONTROL
);
8852 /* As we must carefully and slowly disable/enable each source in turn,
8853 * compute the final state we want first and check if we need to
8854 * make any changes at all.
8857 final
&= ~DREF_NONSPREAD_SOURCE_MASK
;
8859 final
|= DREF_NONSPREAD_CK505_ENABLE
;
8861 final
|= DREF_NONSPREAD_SOURCE_ENABLE
;
8863 final
&= ~DREF_SSC_SOURCE_MASK
;
8864 final
&= ~DREF_CPU_SOURCE_OUTPUT_MASK
;
8865 final
&= ~DREF_SSC1_ENABLE
;
8868 final
|= DREF_SSC_SOURCE_ENABLE
;
8870 if (intel_panel_use_ssc(dev_priv
) && can_ssc
)
8871 final
|= DREF_SSC1_ENABLE
;
8874 if (intel_panel_use_ssc(dev_priv
) && can_ssc
)
8875 final
|= DREF_CPU_SOURCE_OUTPUT_DOWNSPREAD
;
8877 final
|= DREF_CPU_SOURCE_OUTPUT_NONSPREAD
;
8879 final
|= DREF_CPU_SOURCE_OUTPUT_DISABLE
;
8880 } else if (using_ssc_source
) {
8881 final
|= DREF_SSC_SOURCE_ENABLE
;
8882 final
|= DREF_SSC1_ENABLE
;
8888 /* Always enable nonspread source */
8889 val
&= ~DREF_NONSPREAD_SOURCE_MASK
;
8892 val
|= DREF_NONSPREAD_CK505_ENABLE
;
8894 val
|= DREF_NONSPREAD_SOURCE_ENABLE
;
8897 val
&= ~DREF_SSC_SOURCE_MASK
;
8898 val
|= DREF_SSC_SOURCE_ENABLE
;
8900 /* SSC must be turned on before enabling the CPU output */
8901 if (intel_panel_use_ssc(dev_priv
) && can_ssc
) {
8902 DRM_DEBUG_KMS("Using SSC on panel\n");
8903 val
|= DREF_SSC1_ENABLE
;
8905 val
&= ~DREF_SSC1_ENABLE
;
8907 /* Get SSC going before enabling the outputs */
8908 I915_WRITE(PCH_DREF_CONTROL
, val
);
8909 POSTING_READ(PCH_DREF_CONTROL
);
8912 val
&= ~DREF_CPU_SOURCE_OUTPUT_MASK
;
8914 /* Enable CPU source on CPU attached eDP */
8916 if (intel_panel_use_ssc(dev_priv
) && can_ssc
) {
8917 DRM_DEBUG_KMS("Using SSC on eDP\n");
8918 val
|= DREF_CPU_SOURCE_OUTPUT_DOWNSPREAD
;
8920 val
|= DREF_CPU_SOURCE_OUTPUT_NONSPREAD
;
8922 val
|= DREF_CPU_SOURCE_OUTPUT_DISABLE
;
8924 I915_WRITE(PCH_DREF_CONTROL
, val
);
8925 POSTING_READ(PCH_DREF_CONTROL
);
8928 DRM_DEBUG_KMS("Disabling CPU source output\n");
8930 val
&= ~DREF_CPU_SOURCE_OUTPUT_MASK
;
8932 /* Turn off CPU output */
8933 val
|= DREF_CPU_SOURCE_OUTPUT_DISABLE
;
8935 I915_WRITE(PCH_DREF_CONTROL
, val
);
8936 POSTING_READ(PCH_DREF_CONTROL
);
8939 if (!using_ssc_source
) {
8940 DRM_DEBUG_KMS("Disabling SSC source\n");
8942 /* Turn off the SSC source */
8943 val
&= ~DREF_SSC_SOURCE_MASK
;
8944 val
|= DREF_SSC_SOURCE_DISABLE
;
8947 val
&= ~DREF_SSC1_ENABLE
;
8949 I915_WRITE(PCH_DREF_CONTROL
, val
);
8950 POSTING_READ(PCH_DREF_CONTROL
);
8955 BUG_ON(val
!= final
);
8958 static void lpt_reset_fdi_mphy(struct drm_i915_private
*dev_priv
)
8962 tmp
= I915_READ(SOUTH_CHICKEN2
);
8963 tmp
|= FDI_MPHY_IOSFSB_RESET_CTL
;
8964 I915_WRITE(SOUTH_CHICKEN2
, tmp
);
8966 if (wait_for_us(I915_READ(SOUTH_CHICKEN2
) &
8967 FDI_MPHY_IOSFSB_RESET_STATUS
, 100))
8968 DRM_ERROR("FDI mPHY reset assert timeout\n");
8970 tmp
= I915_READ(SOUTH_CHICKEN2
);
8971 tmp
&= ~FDI_MPHY_IOSFSB_RESET_CTL
;
8972 I915_WRITE(SOUTH_CHICKEN2
, tmp
);
8974 if (wait_for_us((I915_READ(SOUTH_CHICKEN2
) &
8975 FDI_MPHY_IOSFSB_RESET_STATUS
) == 0, 100))
8976 DRM_ERROR("FDI mPHY reset de-assert timeout\n");
8979 /* WaMPhyProgramming:hsw */
8980 static void lpt_program_fdi_mphy(struct drm_i915_private
*dev_priv
)
8984 tmp
= intel_sbi_read(dev_priv
, 0x8008, SBI_MPHY
);
8985 tmp
&= ~(0xFF << 24);
8986 tmp
|= (0x12 << 24);
8987 intel_sbi_write(dev_priv
, 0x8008, tmp
, SBI_MPHY
);
8989 tmp
= intel_sbi_read(dev_priv
, 0x2008, SBI_MPHY
);
8991 intel_sbi_write(dev_priv
, 0x2008, tmp
, SBI_MPHY
);
8993 tmp
= intel_sbi_read(dev_priv
, 0x2108, SBI_MPHY
);
8995 intel_sbi_write(dev_priv
, 0x2108, tmp
, SBI_MPHY
);
8997 tmp
= intel_sbi_read(dev_priv
, 0x206C, SBI_MPHY
);
8998 tmp
|= (1 << 24) | (1 << 21) | (1 << 18);
8999 intel_sbi_write(dev_priv
, 0x206C, tmp
, SBI_MPHY
);
9001 tmp
= intel_sbi_read(dev_priv
, 0x216C, SBI_MPHY
);
9002 tmp
|= (1 << 24) | (1 << 21) | (1 << 18);
9003 intel_sbi_write(dev_priv
, 0x216C, tmp
, SBI_MPHY
);
9005 tmp
= intel_sbi_read(dev_priv
, 0x2080, SBI_MPHY
);
9008 intel_sbi_write(dev_priv
, 0x2080, tmp
, SBI_MPHY
);
9010 tmp
= intel_sbi_read(dev_priv
, 0x2180, SBI_MPHY
);
9013 intel_sbi_write(dev_priv
, 0x2180, tmp
, SBI_MPHY
);
9015 tmp
= intel_sbi_read(dev_priv
, 0x208C, SBI_MPHY
);
9018 intel_sbi_write(dev_priv
, 0x208C, tmp
, SBI_MPHY
);
9020 tmp
= intel_sbi_read(dev_priv
, 0x218C, SBI_MPHY
);
9023 intel_sbi_write(dev_priv
, 0x218C, tmp
, SBI_MPHY
);
9025 tmp
= intel_sbi_read(dev_priv
, 0x2098, SBI_MPHY
);
9026 tmp
&= ~(0xFF << 16);
9027 tmp
|= (0x1C << 16);
9028 intel_sbi_write(dev_priv
, 0x2098, tmp
, SBI_MPHY
);
9030 tmp
= intel_sbi_read(dev_priv
, 0x2198, SBI_MPHY
);
9031 tmp
&= ~(0xFF << 16);
9032 tmp
|= (0x1C << 16);
9033 intel_sbi_write(dev_priv
, 0x2198, tmp
, SBI_MPHY
);
9035 tmp
= intel_sbi_read(dev_priv
, 0x20C4, SBI_MPHY
);
9037 intel_sbi_write(dev_priv
, 0x20C4, tmp
, SBI_MPHY
);
9039 tmp
= intel_sbi_read(dev_priv
, 0x21C4, SBI_MPHY
);
9041 intel_sbi_write(dev_priv
, 0x21C4, tmp
, SBI_MPHY
);
9043 tmp
= intel_sbi_read(dev_priv
, 0x20EC, SBI_MPHY
);
9044 tmp
&= ~(0xF << 28);
9046 intel_sbi_write(dev_priv
, 0x20EC, tmp
, SBI_MPHY
);
9048 tmp
= intel_sbi_read(dev_priv
, 0x21EC, SBI_MPHY
);
9049 tmp
&= ~(0xF << 28);
9051 intel_sbi_write(dev_priv
, 0x21EC, tmp
, SBI_MPHY
);
9054 /* Implements 3 different sequences from BSpec chapter "Display iCLK
9055 * Programming" based on the parameters passed:
9056 * - Sequence to enable CLKOUT_DP
9057 * - Sequence to enable CLKOUT_DP without spread
9058 * - Sequence to enable CLKOUT_DP for FDI usage and configure PCH FDI I/O
9060 static void lpt_enable_clkout_dp(struct drm_device
*dev
, bool with_spread
,
9063 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9066 if (WARN(with_fdi
&& !with_spread
, "FDI requires downspread\n"))
9068 if (WARN(HAS_PCH_LPT_LP(dev
) && with_fdi
, "LP PCH doesn't have FDI\n"))
9071 mutex_lock(&dev_priv
->sb_lock
);
9073 tmp
= intel_sbi_read(dev_priv
, SBI_SSCCTL
, SBI_ICLK
);
9074 tmp
&= ~SBI_SSCCTL_DISABLE
;
9075 tmp
|= SBI_SSCCTL_PATHALT
;
9076 intel_sbi_write(dev_priv
, SBI_SSCCTL
, tmp
, SBI_ICLK
);
9081 tmp
= intel_sbi_read(dev_priv
, SBI_SSCCTL
, SBI_ICLK
);
9082 tmp
&= ~SBI_SSCCTL_PATHALT
;
9083 intel_sbi_write(dev_priv
, SBI_SSCCTL
, tmp
, SBI_ICLK
);
9086 lpt_reset_fdi_mphy(dev_priv
);
9087 lpt_program_fdi_mphy(dev_priv
);
9091 reg
= HAS_PCH_LPT_LP(dev
) ? SBI_GEN0
: SBI_DBUFF0
;
9092 tmp
= intel_sbi_read(dev_priv
, reg
, SBI_ICLK
);
9093 tmp
|= SBI_GEN0_CFG_BUFFENABLE_DISABLE
;
9094 intel_sbi_write(dev_priv
, reg
, tmp
, SBI_ICLK
);
9096 mutex_unlock(&dev_priv
->sb_lock
);
9099 /* Sequence to disable CLKOUT_DP */
9100 static void lpt_disable_clkout_dp(struct drm_device
*dev
)
9102 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9105 mutex_lock(&dev_priv
->sb_lock
);
9107 reg
= HAS_PCH_LPT_LP(dev
) ? SBI_GEN0
: SBI_DBUFF0
;
9108 tmp
= intel_sbi_read(dev_priv
, reg
, SBI_ICLK
);
9109 tmp
&= ~SBI_GEN0_CFG_BUFFENABLE_DISABLE
;
9110 intel_sbi_write(dev_priv
, reg
, tmp
, SBI_ICLK
);
9112 tmp
= intel_sbi_read(dev_priv
, SBI_SSCCTL
, SBI_ICLK
);
9113 if (!(tmp
& SBI_SSCCTL_DISABLE
)) {
9114 if (!(tmp
& SBI_SSCCTL_PATHALT
)) {
9115 tmp
|= SBI_SSCCTL_PATHALT
;
9116 intel_sbi_write(dev_priv
, SBI_SSCCTL
, tmp
, SBI_ICLK
);
9119 tmp
|= SBI_SSCCTL_DISABLE
;
9120 intel_sbi_write(dev_priv
, SBI_SSCCTL
, tmp
, SBI_ICLK
);
9123 mutex_unlock(&dev_priv
->sb_lock
);
9126 #define BEND_IDX(steps) ((50 + (steps)) / 5)
9128 static const uint16_t sscdivintphase
[] = {
9129 [BEND_IDX( 50)] = 0x3B23,
9130 [BEND_IDX( 45)] = 0x3B23,
9131 [BEND_IDX( 40)] = 0x3C23,
9132 [BEND_IDX( 35)] = 0x3C23,
9133 [BEND_IDX( 30)] = 0x3D23,
9134 [BEND_IDX( 25)] = 0x3D23,
9135 [BEND_IDX( 20)] = 0x3E23,
9136 [BEND_IDX( 15)] = 0x3E23,
9137 [BEND_IDX( 10)] = 0x3F23,
9138 [BEND_IDX( 5)] = 0x3F23,
9139 [BEND_IDX( 0)] = 0x0025,
9140 [BEND_IDX( -5)] = 0x0025,
9141 [BEND_IDX(-10)] = 0x0125,
9142 [BEND_IDX(-15)] = 0x0125,
9143 [BEND_IDX(-20)] = 0x0225,
9144 [BEND_IDX(-25)] = 0x0225,
9145 [BEND_IDX(-30)] = 0x0325,
9146 [BEND_IDX(-35)] = 0x0325,
9147 [BEND_IDX(-40)] = 0x0425,
9148 [BEND_IDX(-45)] = 0x0425,
9149 [BEND_IDX(-50)] = 0x0525,
9154 * steps -50 to 50 inclusive, in steps of 5
9155 * < 0 slow down the clock, > 0 speed up the clock, 0 == no bend (135MHz)
9156 * change in clock period = -(steps / 10) * 5.787 ps
9158 static void lpt_bend_clkout_dp(struct drm_i915_private
*dev_priv
, int steps
)
9161 int idx
= BEND_IDX(steps
);
9163 if (WARN_ON(steps
% 5 != 0))
9166 if (WARN_ON(idx
>= ARRAY_SIZE(sscdivintphase
)))
9169 mutex_lock(&dev_priv
->sb_lock
);
9171 if (steps
% 10 != 0)
9175 intel_sbi_write(dev_priv
, SBI_SSCDITHPHASE
, tmp
, SBI_ICLK
);
9177 tmp
= intel_sbi_read(dev_priv
, SBI_SSCDIVINTPHASE
, SBI_ICLK
);
9179 tmp
|= sscdivintphase
[idx
];
9180 intel_sbi_write(dev_priv
, SBI_SSCDIVINTPHASE
, tmp
, SBI_ICLK
);
9182 mutex_unlock(&dev_priv
->sb_lock
);
9187 static void lpt_init_pch_refclk(struct drm_device
*dev
)
9189 struct intel_encoder
*encoder
;
9190 bool has_vga
= false;
9192 for_each_intel_encoder(dev
, encoder
) {
9193 switch (encoder
->type
) {
9194 case INTEL_OUTPUT_ANALOG
:
9203 lpt_bend_clkout_dp(to_i915(dev
), 0);
9204 lpt_enable_clkout_dp(dev
, true, true);
9206 lpt_disable_clkout_dp(dev
);
9211 * Initialize reference clocks when the driver loads
9213 void intel_init_pch_refclk(struct drm_device
*dev
)
9215 if (HAS_PCH_IBX(dev
) || HAS_PCH_CPT(dev
))
9216 ironlake_init_pch_refclk(dev
);
9217 else if (HAS_PCH_LPT(dev
))
9218 lpt_init_pch_refclk(dev
);
9221 static void ironlake_set_pipeconf(struct drm_crtc
*crtc
)
9223 struct drm_i915_private
*dev_priv
= to_i915(crtc
->dev
);
9224 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
9225 int pipe
= intel_crtc
->pipe
;
9230 switch (intel_crtc
->config
->pipe_bpp
) {
9232 val
|= PIPECONF_6BPC
;
9235 val
|= PIPECONF_8BPC
;
9238 val
|= PIPECONF_10BPC
;
9241 val
|= PIPECONF_12BPC
;
9244 /* Case prevented by intel_choose_pipe_bpp_dither. */
9248 if (intel_crtc
->config
->dither
)
9249 val
|= (PIPECONF_DITHER_EN
| PIPECONF_DITHER_TYPE_SP
);
9251 if (intel_crtc
->config
->base
.adjusted_mode
.flags
& DRM_MODE_FLAG_INTERLACE
)
9252 val
|= PIPECONF_INTERLACED_ILK
;
9254 val
|= PIPECONF_PROGRESSIVE
;
9256 if (intel_crtc
->config
->limited_color_range
)
9257 val
|= PIPECONF_COLOR_RANGE_SELECT
;
9259 I915_WRITE(PIPECONF(pipe
), val
);
9260 POSTING_READ(PIPECONF(pipe
));
9263 static void haswell_set_pipeconf(struct drm_crtc
*crtc
)
9265 struct drm_i915_private
*dev_priv
= to_i915(crtc
->dev
);
9266 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
9267 enum transcoder cpu_transcoder
= intel_crtc
->config
->cpu_transcoder
;
9270 if (IS_HASWELL(dev_priv
) && intel_crtc
->config
->dither
)
9271 val
|= (PIPECONF_DITHER_EN
| PIPECONF_DITHER_TYPE_SP
);
9273 if (intel_crtc
->config
->base
.adjusted_mode
.flags
& DRM_MODE_FLAG_INTERLACE
)
9274 val
|= PIPECONF_INTERLACED_ILK
;
9276 val
|= PIPECONF_PROGRESSIVE
;
9278 I915_WRITE(PIPECONF(cpu_transcoder
), val
);
9279 POSTING_READ(PIPECONF(cpu_transcoder
));
9282 static void haswell_set_pipemisc(struct drm_crtc
*crtc
)
9284 struct drm_i915_private
*dev_priv
= to_i915(crtc
->dev
);
9285 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
9287 if (IS_BROADWELL(dev_priv
) || INTEL_INFO(dev_priv
)->gen
>= 9) {
9290 switch (intel_crtc
->config
->pipe_bpp
) {
9292 val
|= PIPEMISC_DITHER_6_BPC
;
9295 val
|= PIPEMISC_DITHER_8_BPC
;
9298 val
|= PIPEMISC_DITHER_10_BPC
;
9301 val
|= PIPEMISC_DITHER_12_BPC
;
9304 /* Case prevented by pipe_config_set_bpp. */
9308 if (intel_crtc
->config
->dither
)
9309 val
|= PIPEMISC_DITHER_ENABLE
| PIPEMISC_DITHER_TYPE_SP
;
9311 I915_WRITE(PIPEMISC(intel_crtc
->pipe
), val
);
9315 int ironlake_get_lanes_required(int target_clock
, int link_bw
, int bpp
)
9318 * Account for spread spectrum to avoid
9319 * oversubscribing the link. Max center spread
9320 * is 2.5%; use 5% for safety's sake.
9322 u32 bps
= target_clock
* bpp
* 21 / 20;
9323 return DIV_ROUND_UP(bps
, link_bw
* 8);
9326 static bool ironlake_needs_fb_cb_tune(struct dpll
*dpll
, int factor
)
9328 return i9xx_dpll_compute_m(dpll
) < factor
* dpll
->n
;
9331 static void ironlake_compute_dpll(struct intel_crtc
*intel_crtc
,
9332 struct intel_crtc_state
*crtc_state
,
9333 struct dpll
*reduced_clock
)
9335 struct drm_crtc
*crtc
= &intel_crtc
->base
;
9336 struct drm_device
*dev
= crtc
->dev
;
9337 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9341 /* Enable autotuning of the PLL clock (if permissible) */
9343 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
)) {
9344 if ((intel_panel_use_ssc(dev_priv
) &&
9345 dev_priv
->vbt
.lvds_ssc_freq
== 100000) ||
9346 (HAS_PCH_IBX(dev
) && intel_is_dual_link_lvds(dev
)))
9348 } else if (crtc_state
->sdvo_tv_clock
)
9351 fp
= i9xx_dpll_compute_fp(&crtc_state
->dpll
);
9353 if (ironlake_needs_fb_cb_tune(&crtc_state
->dpll
, factor
))
9356 if (reduced_clock
) {
9357 fp2
= i9xx_dpll_compute_fp(reduced_clock
);
9359 if (reduced_clock
->m
< factor
* reduced_clock
->n
)
9367 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
))
9368 dpll
|= DPLLB_MODE_LVDS
;
9370 dpll
|= DPLLB_MODE_DAC_SERIAL
;
9372 dpll
|= (crtc_state
->pixel_multiplier
- 1)
9373 << PLL_REF_SDVO_HDMI_MULTIPLIER_SHIFT
;
9375 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_SDVO
) ||
9376 intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_HDMI
))
9377 dpll
|= DPLL_SDVO_HIGH_SPEED
;
9379 if (intel_crtc_has_dp_encoder(crtc_state
))
9380 dpll
|= DPLL_SDVO_HIGH_SPEED
;
9382 /* compute bitmask from p1 value */
9383 dpll
|= (1 << (crtc_state
->dpll
.p1
- 1)) << DPLL_FPA01_P1_POST_DIV_SHIFT
;
9385 dpll
|= (1 << (crtc_state
->dpll
.p1
- 1)) << DPLL_FPA1_P1_POST_DIV_SHIFT
;
9387 switch (crtc_state
->dpll
.p2
) {
9389 dpll
|= DPLL_DAC_SERIAL_P2_CLOCK_DIV_5
;
9392 dpll
|= DPLLB_LVDS_P2_CLOCK_DIV_7
;
9395 dpll
|= DPLL_DAC_SERIAL_P2_CLOCK_DIV_10
;
9398 dpll
|= DPLLB_LVDS_P2_CLOCK_DIV_14
;
9402 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
) &&
9403 intel_panel_use_ssc(dev_priv
))
9404 dpll
|= PLLB_REF_INPUT_SPREADSPECTRUMIN
;
9406 dpll
|= PLL_REF_INPUT_DREFCLK
;
9408 dpll
|= DPLL_VCO_ENABLE
;
9410 crtc_state
->dpll_hw_state
.dpll
= dpll
;
9411 crtc_state
->dpll_hw_state
.fp0
= fp
;
9412 crtc_state
->dpll_hw_state
.fp1
= fp2
;
9415 static int ironlake_crtc_compute_clock(struct intel_crtc
*crtc
,
9416 struct intel_crtc_state
*crtc_state
)
9418 struct drm_device
*dev
= crtc
->base
.dev
;
9419 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9420 struct dpll reduced_clock
;
9421 bool has_reduced_clock
= false;
9422 struct intel_shared_dpll
*pll
;
9423 const struct intel_limit
*limit
;
9424 int refclk
= 120000;
9426 memset(&crtc_state
->dpll_hw_state
, 0,
9427 sizeof(crtc_state
->dpll_hw_state
));
9429 crtc
->lowfreq_avail
= false;
9431 /* CPU eDP is the only output that doesn't need a PCH PLL of its own. */
9432 if (!crtc_state
->has_pch_encoder
)
9435 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
)) {
9436 if (intel_panel_use_ssc(dev_priv
)) {
9437 DRM_DEBUG_KMS("using SSC reference clock of %d kHz\n",
9438 dev_priv
->vbt
.lvds_ssc_freq
);
9439 refclk
= dev_priv
->vbt
.lvds_ssc_freq
;
9442 if (intel_is_dual_link_lvds(dev
)) {
9443 if (refclk
== 100000)
9444 limit
= &intel_limits_ironlake_dual_lvds_100m
;
9446 limit
= &intel_limits_ironlake_dual_lvds
;
9448 if (refclk
== 100000)
9449 limit
= &intel_limits_ironlake_single_lvds_100m
;
9451 limit
= &intel_limits_ironlake_single_lvds
;
9454 limit
= &intel_limits_ironlake_dac
;
9457 if (!crtc_state
->clock_set
&&
9458 !g4x_find_best_dpll(limit
, crtc_state
, crtc_state
->port_clock
,
9459 refclk
, NULL
, &crtc_state
->dpll
)) {
9460 DRM_ERROR("Couldn't find PLL settings for mode!\n");
9464 ironlake_compute_dpll(crtc
, crtc_state
,
9465 has_reduced_clock
? &reduced_clock
: NULL
);
9467 pll
= intel_get_shared_dpll(crtc
, crtc_state
, NULL
);
9469 DRM_DEBUG_DRIVER("failed to find PLL for pipe %c\n",
9470 pipe_name(crtc
->pipe
));
9474 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_LVDS
) &&
9476 crtc
->lowfreq_avail
= true;
9481 static void intel_pch_transcoder_get_m_n(struct intel_crtc
*crtc
,
9482 struct intel_link_m_n
*m_n
)
9484 struct drm_device
*dev
= crtc
->base
.dev
;
9485 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9486 enum pipe pipe
= crtc
->pipe
;
9488 m_n
->link_m
= I915_READ(PCH_TRANS_LINK_M1(pipe
));
9489 m_n
->link_n
= I915_READ(PCH_TRANS_LINK_N1(pipe
));
9490 m_n
->gmch_m
= I915_READ(PCH_TRANS_DATA_M1(pipe
))
9492 m_n
->gmch_n
= I915_READ(PCH_TRANS_DATA_N1(pipe
));
9493 m_n
->tu
= ((I915_READ(PCH_TRANS_DATA_M1(pipe
))
9494 & TU_SIZE_MASK
) >> TU_SIZE_SHIFT
) + 1;
9497 static void intel_cpu_transcoder_get_m_n(struct intel_crtc
*crtc
,
9498 enum transcoder transcoder
,
9499 struct intel_link_m_n
*m_n
,
9500 struct intel_link_m_n
*m2_n2
)
9502 struct drm_device
*dev
= crtc
->base
.dev
;
9503 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9504 enum pipe pipe
= crtc
->pipe
;
9506 if (INTEL_INFO(dev
)->gen
>= 5) {
9507 m_n
->link_m
= I915_READ(PIPE_LINK_M1(transcoder
));
9508 m_n
->link_n
= I915_READ(PIPE_LINK_N1(transcoder
));
9509 m_n
->gmch_m
= I915_READ(PIPE_DATA_M1(transcoder
))
9511 m_n
->gmch_n
= I915_READ(PIPE_DATA_N1(transcoder
));
9512 m_n
->tu
= ((I915_READ(PIPE_DATA_M1(transcoder
))
9513 & TU_SIZE_MASK
) >> TU_SIZE_SHIFT
) + 1;
9514 /* Read M2_N2 registers only for gen < 8 (M2_N2 available for
9515 * gen < 8) and if DRRS is supported (to make sure the
9516 * registers are not unnecessarily read).
9518 if (m2_n2
&& INTEL_INFO(dev
)->gen
< 8 &&
9519 crtc
->config
->has_drrs
) {
9520 m2_n2
->link_m
= I915_READ(PIPE_LINK_M2(transcoder
));
9521 m2_n2
->link_n
= I915_READ(PIPE_LINK_N2(transcoder
));
9522 m2_n2
->gmch_m
= I915_READ(PIPE_DATA_M2(transcoder
))
9524 m2_n2
->gmch_n
= I915_READ(PIPE_DATA_N2(transcoder
));
9525 m2_n2
->tu
= ((I915_READ(PIPE_DATA_M2(transcoder
))
9526 & TU_SIZE_MASK
) >> TU_SIZE_SHIFT
) + 1;
9529 m_n
->link_m
= I915_READ(PIPE_LINK_M_G4X(pipe
));
9530 m_n
->link_n
= I915_READ(PIPE_LINK_N_G4X(pipe
));
9531 m_n
->gmch_m
= I915_READ(PIPE_DATA_M_G4X(pipe
))
9533 m_n
->gmch_n
= I915_READ(PIPE_DATA_N_G4X(pipe
));
9534 m_n
->tu
= ((I915_READ(PIPE_DATA_M_G4X(pipe
))
9535 & TU_SIZE_MASK
) >> TU_SIZE_SHIFT
) + 1;
9539 void intel_dp_get_m_n(struct intel_crtc
*crtc
,
9540 struct intel_crtc_state
*pipe_config
)
9542 if (pipe_config
->has_pch_encoder
)
9543 intel_pch_transcoder_get_m_n(crtc
, &pipe_config
->dp_m_n
);
9545 intel_cpu_transcoder_get_m_n(crtc
, pipe_config
->cpu_transcoder
,
9546 &pipe_config
->dp_m_n
,
9547 &pipe_config
->dp_m2_n2
);
9550 static void ironlake_get_fdi_m_n_config(struct intel_crtc
*crtc
,
9551 struct intel_crtc_state
*pipe_config
)
9553 intel_cpu_transcoder_get_m_n(crtc
, pipe_config
->cpu_transcoder
,
9554 &pipe_config
->fdi_m_n
, NULL
);
9557 static void skylake_get_pfit_config(struct intel_crtc
*crtc
,
9558 struct intel_crtc_state
*pipe_config
)
9560 struct drm_device
*dev
= crtc
->base
.dev
;
9561 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9562 struct intel_crtc_scaler_state
*scaler_state
= &pipe_config
->scaler_state
;
9563 uint32_t ps_ctrl
= 0;
9567 /* find scaler attached to this pipe */
9568 for (i
= 0; i
< crtc
->num_scalers
; i
++) {
9569 ps_ctrl
= I915_READ(SKL_PS_CTRL(crtc
->pipe
, i
));
9570 if (ps_ctrl
& PS_SCALER_EN
&& !(ps_ctrl
& PS_PLANE_SEL_MASK
)) {
9572 pipe_config
->pch_pfit
.enabled
= true;
9573 pipe_config
->pch_pfit
.pos
= I915_READ(SKL_PS_WIN_POS(crtc
->pipe
, i
));
9574 pipe_config
->pch_pfit
.size
= I915_READ(SKL_PS_WIN_SZ(crtc
->pipe
, i
));
9579 scaler_state
->scaler_id
= id
;
9581 scaler_state
->scaler_users
|= (1 << SKL_CRTC_INDEX
);
9583 scaler_state
->scaler_users
&= ~(1 << SKL_CRTC_INDEX
);
9588 skylake_get_initial_plane_config(struct intel_crtc
*crtc
,
9589 struct intel_initial_plane_config
*plane_config
)
9591 struct drm_device
*dev
= crtc
->base
.dev
;
9592 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9593 u32 val
, base
, offset
, stride_mult
, tiling
;
9594 int pipe
= crtc
->pipe
;
9595 int fourcc
, pixel_format
;
9596 unsigned int aligned_height
;
9597 struct drm_framebuffer
*fb
;
9598 struct intel_framebuffer
*intel_fb
;
9600 intel_fb
= kzalloc(sizeof(*intel_fb
), GFP_KERNEL
);
9602 DRM_DEBUG_KMS("failed to alloc fb\n");
9606 fb
= &intel_fb
->base
;
9608 val
= I915_READ(PLANE_CTL(pipe
, 0));
9609 if (!(val
& PLANE_CTL_ENABLE
))
9612 pixel_format
= val
& PLANE_CTL_FORMAT_MASK
;
9613 fourcc
= skl_format_to_fourcc(pixel_format
,
9614 val
& PLANE_CTL_ORDER_RGBX
,
9615 val
& PLANE_CTL_ALPHA_MASK
);
9616 fb
->pixel_format
= fourcc
;
9617 fb
->bits_per_pixel
= drm_format_plane_cpp(fourcc
, 0) * 8;
9619 tiling
= val
& PLANE_CTL_TILED_MASK
;
9621 case PLANE_CTL_TILED_LINEAR
:
9622 fb
->modifier
[0] = DRM_FORMAT_MOD_NONE
;
9624 case PLANE_CTL_TILED_X
:
9625 plane_config
->tiling
= I915_TILING_X
;
9626 fb
->modifier
[0] = I915_FORMAT_MOD_X_TILED
;
9628 case PLANE_CTL_TILED_Y
:
9629 fb
->modifier
[0] = I915_FORMAT_MOD_Y_TILED
;
9631 case PLANE_CTL_TILED_YF
:
9632 fb
->modifier
[0] = I915_FORMAT_MOD_Yf_TILED
;
9635 MISSING_CASE(tiling
);
9639 base
= I915_READ(PLANE_SURF(pipe
, 0)) & 0xfffff000;
9640 plane_config
->base
= base
;
9642 offset
= I915_READ(PLANE_OFFSET(pipe
, 0));
9644 val
= I915_READ(PLANE_SIZE(pipe
, 0));
9645 fb
->height
= ((val
>> 16) & 0xfff) + 1;
9646 fb
->width
= ((val
>> 0) & 0x1fff) + 1;
9648 val
= I915_READ(PLANE_STRIDE(pipe
, 0));
9649 stride_mult
= intel_fb_stride_alignment(dev_priv
, fb
->modifier
[0],
9651 fb
->pitches
[0] = (val
& 0x3ff) * stride_mult
;
9653 aligned_height
= intel_fb_align_height(dev
, fb
->height
,
9657 plane_config
->size
= fb
->pitches
[0] * aligned_height
;
9659 DRM_DEBUG_KMS("pipe %c with fb: size=%dx%d@%d, offset=%x, pitch %d, size 0x%x\n",
9660 pipe_name(pipe
), fb
->width
, fb
->height
,
9661 fb
->bits_per_pixel
, base
, fb
->pitches
[0],
9662 plane_config
->size
);
9664 plane_config
->fb
= intel_fb
;
9671 static void ironlake_get_pfit_config(struct intel_crtc
*crtc
,
9672 struct intel_crtc_state
*pipe_config
)
9674 struct drm_device
*dev
= crtc
->base
.dev
;
9675 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9678 tmp
= I915_READ(PF_CTL(crtc
->pipe
));
9680 if (tmp
& PF_ENABLE
) {
9681 pipe_config
->pch_pfit
.enabled
= true;
9682 pipe_config
->pch_pfit
.pos
= I915_READ(PF_WIN_POS(crtc
->pipe
));
9683 pipe_config
->pch_pfit
.size
= I915_READ(PF_WIN_SZ(crtc
->pipe
));
9685 /* We currently do not free assignements of panel fitters on
9686 * ivb/hsw (since we don't use the higher upscaling modes which
9687 * differentiates them) so just WARN about this case for now. */
9689 WARN_ON((tmp
& PF_PIPE_SEL_MASK_IVB
) !=
9690 PF_PIPE_SEL_IVB(crtc
->pipe
));
9696 ironlake_get_initial_plane_config(struct intel_crtc
*crtc
,
9697 struct intel_initial_plane_config
*plane_config
)
9699 struct drm_device
*dev
= crtc
->base
.dev
;
9700 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9701 u32 val
, base
, offset
;
9702 int pipe
= crtc
->pipe
;
9703 int fourcc
, pixel_format
;
9704 unsigned int aligned_height
;
9705 struct drm_framebuffer
*fb
;
9706 struct intel_framebuffer
*intel_fb
;
9708 val
= I915_READ(DSPCNTR(pipe
));
9709 if (!(val
& DISPLAY_PLANE_ENABLE
))
9712 intel_fb
= kzalloc(sizeof(*intel_fb
), GFP_KERNEL
);
9714 DRM_DEBUG_KMS("failed to alloc fb\n");
9718 fb
= &intel_fb
->base
;
9720 if (INTEL_INFO(dev
)->gen
>= 4) {
9721 if (val
& DISPPLANE_TILED
) {
9722 plane_config
->tiling
= I915_TILING_X
;
9723 fb
->modifier
[0] = I915_FORMAT_MOD_X_TILED
;
9727 pixel_format
= val
& DISPPLANE_PIXFORMAT_MASK
;
9728 fourcc
= i9xx_format_to_fourcc(pixel_format
);
9729 fb
->pixel_format
= fourcc
;
9730 fb
->bits_per_pixel
= drm_format_plane_cpp(fourcc
, 0) * 8;
9732 base
= I915_READ(DSPSURF(pipe
)) & 0xfffff000;
9733 if (IS_HASWELL(dev
) || IS_BROADWELL(dev
)) {
9734 offset
= I915_READ(DSPOFFSET(pipe
));
9736 if (plane_config
->tiling
)
9737 offset
= I915_READ(DSPTILEOFF(pipe
));
9739 offset
= I915_READ(DSPLINOFF(pipe
));
9741 plane_config
->base
= base
;
9743 val
= I915_READ(PIPESRC(pipe
));
9744 fb
->width
= ((val
>> 16) & 0xfff) + 1;
9745 fb
->height
= ((val
>> 0) & 0xfff) + 1;
9747 val
= I915_READ(DSPSTRIDE(pipe
));
9748 fb
->pitches
[0] = val
& 0xffffffc0;
9750 aligned_height
= intel_fb_align_height(dev
, fb
->height
,
9754 plane_config
->size
= fb
->pitches
[0] * aligned_height
;
9756 DRM_DEBUG_KMS("pipe %c with fb: size=%dx%d@%d, offset=%x, pitch %d, size 0x%x\n",
9757 pipe_name(pipe
), fb
->width
, fb
->height
,
9758 fb
->bits_per_pixel
, base
, fb
->pitches
[0],
9759 plane_config
->size
);
9761 plane_config
->fb
= intel_fb
;
9764 static bool ironlake_get_pipe_config(struct intel_crtc
*crtc
,
9765 struct intel_crtc_state
*pipe_config
)
9767 struct drm_device
*dev
= crtc
->base
.dev
;
9768 struct drm_i915_private
*dev_priv
= to_i915(dev
);
9769 enum intel_display_power_domain power_domain
;
9773 power_domain
= POWER_DOMAIN_PIPE(crtc
->pipe
);
9774 if (!intel_display_power_get_if_enabled(dev_priv
, power_domain
))
9777 pipe_config
->cpu_transcoder
= (enum transcoder
) crtc
->pipe
;
9778 pipe_config
->shared_dpll
= NULL
;
9781 tmp
= I915_READ(PIPECONF(crtc
->pipe
));
9782 if (!(tmp
& PIPECONF_ENABLE
))
9785 switch (tmp
& PIPECONF_BPC_MASK
) {
9787 pipe_config
->pipe_bpp
= 18;
9790 pipe_config
->pipe_bpp
= 24;
9792 case PIPECONF_10BPC
:
9793 pipe_config
->pipe_bpp
= 30;
9795 case PIPECONF_12BPC
:
9796 pipe_config
->pipe_bpp
= 36;
9802 if (tmp
& PIPECONF_COLOR_RANGE_SELECT
)
9803 pipe_config
->limited_color_range
= true;
9805 if (I915_READ(PCH_TRANSCONF(crtc
->pipe
)) & TRANS_ENABLE
) {
9806 struct intel_shared_dpll
*pll
;
9807 enum intel_dpll_id pll_id
;
9809 pipe_config
->has_pch_encoder
= true;
9811 tmp
= I915_READ(FDI_RX_CTL(crtc
->pipe
));
9812 pipe_config
->fdi_lanes
= ((FDI_DP_PORT_WIDTH_MASK
& tmp
) >>
9813 FDI_DP_PORT_WIDTH_SHIFT
) + 1;
9815 ironlake_get_fdi_m_n_config(crtc
, pipe_config
);
9817 if (HAS_PCH_IBX(dev_priv
)) {
9819 * The pipe->pch transcoder and pch transcoder->pll
9822 pll_id
= (enum intel_dpll_id
) crtc
->pipe
;
9824 tmp
= I915_READ(PCH_DPLL_SEL
);
9825 if (tmp
& TRANS_DPLLB_SEL(crtc
->pipe
))
9826 pll_id
= DPLL_ID_PCH_PLL_B
;
9828 pll_id
= DPLL_ID_PCH_PLL_A
;
9831 pipe_config
->shared_dpll
=
9832 intel_get_shared_dpll_by_id(dev_priv
, pll_id
);
9833 pll
= pipe_config
->shared_dpll
;
9835 WARN_ON(!pll
->funcs
.get_hw_state(dev_priv
, pll
,
9836 &pipe_config
->dpll_hw_state
));
9838 tmp
= pipe_config
->dpll_hw_state
.dpll
;
9839 pipe_config
->pixel_multiplier
=
9840 ((tmp
& PLL_REF_SDVO_HDMI_MULTIPLIER_MASK
)
9841 >> PLL_REF_SDVO_HDMI_MULTIPLIER_SHIFT
) + 1;
9843 ironlake_pch_clock_get(crtc
, pipe_config
);
9845 pipe_config
->pixel_multiplier
= 1;
9848 intel_get_pipe_timings(crtc
, pipe_config
);
9849 intel_get_pipe_src_size(crtc
, pipe_config
);
9851 ironlake_get_pfit_config(crtc
, pipe_config
);
9856 intel_display_power_put(dev_priv
, power_domain
);
9861 static void assert_can_disable_lcpll(struct drm_i915_private
*dev_priv
)
9863 struct drm_device
*dev
= &dev_priv
->drm
;
9864 struct intel_crtc
*crtc
;
9866 for_each_intel_crtc(dev
, crtc
)
9867 I915_STATE_WARN(crtc
->active
, "CRTC for pipe %c enabled\n",
9868 pipe_name(crtc
->pipe
));
9870 I915_STATE_WARN(I915_READ(HSW_PWR_WELL_DRIVER
), "Power well on\n");
9871 I915_STATE_WARN(I915_READ(SPLL_CTL
) & SPLL_PLL_ENABLE
, "SPLL enabled\n");
9872 I915_STATE_WARN(I915_READ(WRPLL_CTL(0)) & WRPLL_PLL_ENABLE
, "WRPLL1 enabled\n");
9873 I915_STATE_WARN(I915_READ(WRPLL_CTL(1)) & WRPLL_PLL_ENABLE
, "WRPLL2 enabled\n");
9874 I915_STATE_WARN(I915_READ(PP_STATUS(0)) & PP_ON
, "Panel power on\n");
9875 I915_STATE_WARN(I915_READ(BLC_PWM_CPU_CTL2
) & BLM_PWM_ENABLE
,
9876 "CPU PWM1 enabled\n");
9877 if (IS_HASWELL(dev
))
9878 I915_STATE_WARN(I915_READ(HSW_BLC_PWM2_CTL
) & BLM_PWM_ENABLE
,
9879 "CPU PWM2 enabled\n");
9880 I915_STATE_WARN(I915_READ(BLC_PWM_PCH_CTL1
) & BLM_PCH_PWM_ENABLE
,
9881 "PCH PWM1 enabled\n");
9882 I915_STATE_WARN(I915_READ(UTIL_PIN_CTL
) & UTIL_PIN_ENABLE
,
9883 "Utility pin enabled\n");
9884 I915_STATE_WARN(I915_READ(PCH_GTC_CTL
) & PCH_GTC_ENABLE
, "PCH GTC enabled\n");
9887 * In theory we can still leave IRQs enabled, as long as only the HPD
9888 * interrupts remain enabled. We used to check for that, but since it's
9889 * gen-specific and since we only disable LCPLL after we fully disable
9890 * the interrupts, the check below should be enough.
9892 I915_STATE_WARN(intel_irqs_enabled(dev_priv
), "IRQs enabled\n");
9895 static uint32_t hsw_read_dcomp(struct drm_i915_private
*dev_priv
)
9897 struct drm_device
*dev
= &dev_priv
->drm
;
9899 if (IS_HASWELL(dev
))
9900 return I915_READ(D_COMP_HSW
);
9902 return I915_READ(D_COMP_BDW
);
9905 static void hsw_write_dcomp(struct drm_i915_private
*dev_priv
, uint32_t val
)
9907 struct drm_device
*dev
= &dev_priv
->drm
;
9909 if (IS_HASWELL(dev
)) {
9910 mutex_lock(&dev_priv
->rps
.hw_lock
);
9911 if (sandybridge_pcode_write(dev_priv
, GEN6_PCODE_WRITE_D_COMP
,
9913 DRM_ERROR("Failed to write to D_COMP\n");
9914 mutex_unlock(&dev_priv
->rps
.hw_lock
);
9916 I915_WRITE(D_COMP_BDW
, val
);
9917 POSTING_READ(D_COMP_BDW
);
9922 * This function implements pieces of two sequences from BSpec:
9923 * - Sequence for display software to disable LCPLL
9924 * - Sequence for display software to allow package C8+
9925 * The steps implemented here are just the steps that actually touch the LCPLL
9926 * register. Callers should take care of disabling all the display engine
9927 * functions, doing the mode unset, fixing interrupts, etc.
9929 static void hsw_disable_lcpll(struct drm_i915_private
*dev_priv
,
9930 bool switch_to_fclk
, bool allow_power_down
)
9934 assert_can_disable_lcpll(dev_priv
);
9936 val
= I915_READ(LCPLL_CTL
);
9938 if (switch_to_fclk
) {
9939 val
|= LCPLL_CD_SOURCE_FCLK
;
9940 I915_WRITE(LCPLL_CTL
, val
);
9942 if (wait_for_us(I915_READ(LCPLL_CTL
) &
9943 LCPLL_CD_SOURCE_FCLK_DONE
, 1))
9944 DRM_ERROR("Switching to FCLK failed\n");
9946 val
= I915_READ(LCPLL_CTL
);
9949 val
|= LCPLL_PLL_DISABLE
;
9950 I915_WRITE(LCPLL_CTL
, val
);
9951 POSTING_READ(LCPLL_CTL
);
9953 if (intel_wait_for_register(dev_priv
, LCPLL_CTL
, LCPLL_PLL_LOCK
, 0, 1))
9954 DRM_ERROR("LCPLL still locked\n");
9956 val
= hsw_read_dcomp(dev_priv
);
9957 val
|= D_COMP_COMP_DISABLE
;
9958 hsw_write_dcomp(dev_priv
, val
);
9961 if (wait_for((hsw_read_dcomp(dev_priv
) & D_COMP_RCOMP_IN_PROGRESS
) == 0,
9963 DRM_ERROR("D_COMP RCOMP still in progress\n");
9965 if (allow_power_down
) {
9966 val
= I915_READ(LCPLL_CTL
);
9967 val
|= LCPLL_POWER_DOWN_ALLOW
;
9968 I915_WRITE(LCPLL_CTL
, val
);
9969 POSTING_READ(LCPLL_CTL
);
9974 * Fully restores LCPLL, disallowing power down and switching back to LCPLL
9977 static void hsw_restore_lcpll(struct drm_i915_private
*dev_priv
)
9981 val
= I915_READ(LCPLL_CTL
);
9983 if ((val
& (LCPLL_PLL_LOCK
| LCPLL_PLL_DISABLE
| LCPLL_CD_SOURCE_FCLK
|
9984 LCPLL_POWER_DOWN_ALLOW
)) == LCPLL_PLL_LOCK
)
9988 * Make sure we're not on PC8 state before disabling PC8, otherwise
9989 * we'll hang the machine. To prevent PC8 state, just enable force_wake.
9991 intel_uncore_forcewake_get(dev_priv
, FORCEWAKE_ALL
);
9993 if (val
& LCPLL_POWER_DOWN_ALLOW
) {
9994 val
&= ~LCPLL_POWER_DOWN_ALLOW
;
9995 I915_WRITE(LCPLL_CTL
, val
);
9996 POSTING_READ(LCPLL_CTL
);
9999 val
= hsw_read_dcomp(dev_priv
);
10000 val
|= D_COMP_COMP_FORCE
;
10001 val
&= ~D_COMP_COMP_DISABLE
;
10002 hsw_write_dcomp(dev_priv
, val
);
10004 val
= I915_READ(LCPLL_CTL
);
10005 val
&= ~LCPLL_PLL_DISABLE
;
10006 I915_WRITE(LCPLL_CTL
, val
);
10008 if (intel_wait_for_register(dev_priv
,
10009 LCPLL_CTL
, LCPLL_PLL_LOCK
, LCPLL_PLL_LOCK
,
10011 DRM_ERROR("LCPLL not locked yet\n");
10013 if (val
& LCPLL_CD_SOURCE_FCLK
) {
10014 val
= I915_READ(LCPLL_CTL
);
10015 val
&= ~LCPLL_CD_SOURCE_FCLK
;
10016 I915_WRITE(LCPLL_CTL
, val
);
10018 if (wait_for_us((I915_READ(LCPLL_CTL
) &
10019 LCPLL_CD_SOURCE_FCLK_DONE
) == 0, 1))
10020 DRM_ERROR("Switching back to LCPLL failed\n");
10023 intel_uncore_forcewake_put(dev_priv
, FORCEWAKE_ALL
);
10024 intel_update_cdclk(&dev_priv
->drm
);
10028 * Package states C8 and deeper are really deep PC states that can only be
10029 * reached when all the devices on the system allow it, so even if the graphics
10030 * device allows PC8+, it doesn't mean the system will actually get to these
10031 * states. Our driver only allows PC8+ when going into runtime PM.
10033 * The requirements for PC8+ are that all the outputs are disabled, the power
10034 * well is disabled and most interrupts are disabled, and these are also
10035 * requirements for runtime PM. When these conditions are met, we manually do
10036 * the other conditions: disable the interrupts, clocks and switch LCPLL refclk
10037 * to Fclk. If we're in PC8+ and we get an non-hotplug interrupt, we can hard
10038 * hang the machine.
10040 * When we really reach PC8 or deeper states (not just when we allow it) we lose
10041 * the state of some registers, so when we come back from PC8+ we need to
10042 * restore this state. We don't get into PC8+ if we're not in RC6, so we don't
10043 * need to take care of the registers kept by RC6. Notice that this happens even
10044 * if we don't put the device in PCI D3 state (which is what currently happens
10045 * because of the runtime PM support).
10047 * For more, read "Display Sequences for Package C8" on the hardware
10050 void hsw_enable_pc8(struct drm_i915_private
*dev_priv
)
10052 struct drm_device
*dev
= &dev_priv
->drm
;
10055 DRM_DEBUG_KMS("Enabling package C8+\n");
10057 if (HAS_PCH_LPT_LP(dev
)) {
10058 val
= I915_READ(SOUTH_DSPCLK_GATE_D
);
10059 val
&= ~PCH_LP_PARTITION_LEVEL_DISABLE
;
10060 I915_WRITE(SOUTH_DSPCLK_GATE_D
, val
);
10063 lpt_disable_clkout_dp(dev
);
10064 hsw_disable_lcpll(dev_priv
, true, true);
10067 void hsw_disable_pc8(struct drm_i915_private
*dev_priv
)
10069 struct drm_device
*dev
= &dev_priv
->drm
;
10072 DRM_DEBUG_KMS("Disabling package C8+\n");
10074 hsw_restore_lcpll(dev_priv
);
10075 lpt_init_pch_refclk(dev
);
10077 if (HAS_PCH_LPT_LP(dev
)) {
10078 val
= I915_READ(SOUTH_DSPCLK_GATE_D
);
10079 val
|= PCH_LP_PARTITION_LEVEL_DISABLE
;
10080 I915_WRITE(SOUTH_DSPCLK_GATE_D
, val
);
10084 static void bxt_modeset_commit_cdclk(struct drm_atomic_state
*old_state
)
10086 struct drm_device
*dev
= old_state
->dev
;
10087 struct intel_atomic_state
*old_intel_state
=
10088 to_intel_atomic_state(old_state
);
10089 unsigned int req_cdclk
= old_intel_state
->dev_cdclk
;
10091 bxt_set_cdclk(to_i915(dev
), req_cdclk
);
10094 /* compute the max rate for new configuration */
10095 static int ilk_max_pixel_rate(struct drm_atomic_state
*state
)
10097 struct intel_atomic_state
*intel_state
= to_intel_atomic_state(state
);
10098 struct drm_i915_private
*dev_priv
= to_i915(state
->dev
);
10099 struct drm_crtc
*crtc
;
10100 struct drm_crtc_state
*cstate
;
10101 struct intel_crtc_state
*crtc_state
;
10102 unsigned max_pixel_rate
= 0, i
;
10105 memcpy(intel_state
->min_pixclk
, dev_priv
->min_pixclk
,
10106 sizeof(intel_state
->min_pixclk
));
10108 for_each_crtc_in_state(state
, crtc
, cstate
, i
) {
10111 crtc_state
= to_intel_crtc_state(cstate
);
10112 if (!crtc_state
->base
.enable
) {
10113 intel_state
->min_pixclk
[i
] = 0;
10117 pixel_rate
= ilk_pipe_pixel_rate(crtc_state
);
10119 /* pixel rate mustn't exceed 95% of cdclk with IPS on BDW */
10120 if (IS_BROADWELL(dev_priv
) && crtc_state
->ips_enabled
)
10121 pixel_rate
= DIV_ROUND_UP(pixel_rate
* 100, 95);
10123 intel_state
->min_pixclk
[i
] = pixel_rate
;
10126 for_each_pipe(dev_priv
, pipe
)
10127 max_pixel_rate
= max(intel_state
->min_pixclk
[pipe
], max_pixel_rate
);
10129 return max_pixel_rate
;
10132 static void broadwell_set_cdclk(struct drm_device
*dev
, int cdclk
)
10134 struct drm_i915_private
*dev_priv
= to_i915(dev
);
10135 uint32_t val
, data
;
10138 if (WARN((I915_READ(LCPLL_CTL
) &
10139 (LCPLL_PLL_DISABLE
| LCPLL_PLL_LOCK
|
10140 LCPLL_CD_CLOCK_DISABLE
| LCPLL_ROOT_CD_CLOCK_DISABLE
|
10141 LCPLL_CD2X_CLOCK_DISABLE
| LCPLL_POWER_DOWN_ALLOW
|
10142 LCPLL_CD_SOURCE_FCLK
)) != LCPLL_PLL_LOCK
,
10143 "trying to change cdclk frequency with cdclk not enabled\n"))
10146 mutex_lock(&dev_priv
->rps
.hw_lock
);
10147 ret
= sandybridge_pcode_write(dev_priv
,
10148 BDW_PCODE_DISPLAY_FREQ_CHANGE_REQ
, 0x0);
10149 mutex_unlock(&dev_priv
->rps
.hw_lock
);
10151 DRM_ERROR("failed to inform pcode about cdclk change\n");
10155 val
= I915_READ(LCPLL_CTL
);
10156 val
|= LCPLL_CD_SOURCE_FCLK
;
10157 I915_WRITE(LCPLL_CTL
, val
);
10159 if (wait_for_us(I915_READ(LCPLL_CTL
) &
10160 LCPLL_CD_SOURCE_FCLK_DONE
, 1))
10161 DRM_ERROR("Switching to FCLK failed\n");
10163 val
= I915_READ(LCPLL_CTL
);
10164 val
&= ~LCPLL_CLK_FREQ_MASK
;
10168 val
|= LCPLL_CLK_FREQ_450
;
10172 val
|= LCPLL_CLK_FREQ_54O_BDW
;
10176 val
|= LCPLL_CLK_FREQ_337_5_BDW
;
10180 val
|= LCPLL_CLK_FREQ_675_BDW
;
10184 WARN(1, "invalid cdclk frequency\n");
10188 I915_WRITE(LCPLL_CTL
, val
);
10190 val
= I915_READ(LCPLL_CTL
);
10191 val
&= ~LCPLL_CD_SOURCE_FCLK
;
10192 I915_WRITE(LCPLL_CTL
, val
);
10194 if (wait_for_us((I915_READ(LCPLL_CTL
) &
10195 LCPLL_CD_SOURCE_FCLK_DONE
) == 0, 1))
10196 DRM_ERROR("Switching back to LCPLL failed\n");
10198 mutex_lock(&dev_priv
->rps
.hw_lock
);
10199 sandybridge_pcode_write(dev_priv
, HSW_PCODE_DE_WRITE_FREQ_REQ
, data
);
10200 mutex_unlock(&dev_priv
->rps
.hw_lock
);
10202 I915_WRITE(CDCLK_FREQ
, DIV_ROUND_CLOSEST(cdclk
, 1000) - 1);
10204 intel_update_cdclk(dev
);
10206 WARN(cdclk
!= dev_priv
->cdclk_freq
,
10207 "cdclk requested %d kHz but got %d kHz\n",
10208 cdclk
, dev_priv
->cdclk_freq
);
10211 static int broadwell_calc_cdclk(int max_pixclk
)
10213 if (max_pixclk
> 540000)
10215 else if (max_pixclk
> 450000)
10217 else if (max_pixclk
> 337500)
10223 static int broadwell_modeset_calc_cdclk(struct drm_atomic_state
*state
)
10225 struct drm_i915_private
*dev_priv
= to_i915(state
->dev
);
10226 struct intel_atomic_state
*intel_state
= to_intel_atomic_state(state
);
10227 int max_pixclk
= ilk_max_pixel_rate(state
);
10231 * FIXME should also account for plane ratio
10232 * once 64bpp pixel formats are supported.
10234 cdclk
= broadwell_calc_cdclk(max_pixclk
);
10236 if (cdclk
> dev_priv
->max_cdclk_freq
) {
10237 DRM_DEBUG_KMS("requested cdclk (%d kHz) exceeds max (%d kHz)\n",
10238 cdclk
, dev_priv
->max_cdclk_freq
);
10242 intel_state
->cdclk
= intel_state
->dev_cdclk
= cdclk
;
10243 if (!intel_state
->active_crtcs
)
10244 intel_state
->dev_cdclk
= broadwell_calc_cdclk(0);
10249 static void broadwell_modeset_commit_cdclk(struct drm_atomic_state
*old_state
)
10251 struct drm_device
*dev
= old_state
->dev
;
10252 struct intel_atomic_state
*old_intel_state
=
10253 to_intel_atomic_state(old_state
);
10254 unsigned req_cdclk
= old_intel_state
->dev_cdclk
;
10256 broadwell_set_cdclk(dev
, req_cdclk
);
10259 static int skl_modeset_calc_cdclk(struct drm_atomic_state
*state
)
10261 struct intel_atomic_state
*intel_state
= to_intel_atomic_state(state
);
10262 struct drm_i915_private
*dev_priv
= to_i915(state
->dev
);
10263 const int max_pixclk
= ilk_max_pixel_rate(state
);
10264 int vco
= intel_state
->cdclk_pll_vco
;
10268 * FIXME should also account for plane ratio
10269 * once 64bpp pixel formats are supported.
10271 cdclk
= skl_calc_cdclk(max_pixclk
, vco
);
10274 * FIXME move the cdclk caclulation to
10275 * compute_config() so we can fail gracegully.
10277 if (cdclk
> dev_priv
->max_cdclk_freq
) {
10278 DRM_ERROR("requested cdclk (%d kHz) exceeds max (%d kHz)\n",
10279 cdclk
, dev_priv
->max_cdclk_freq
);
10280 cdclk
= dev_priv
->max_cdclk_freq
;
10283 intel_state
->cdclk
= intel_state
->dev_cdclk
= cdclk
;
10284 if (!intel_state
->active_crtcs
)
10285 intel_state
->dev_cdclk
= skl_calc_cdclk(0, vco
);
10290 static void skl_modeset_commit_cdclk(struct drm_atomic_state
*old_state
)
10292 struct drm_i915_private
*dev_priv
= to_i915(old_state
->dev
);
10293 struct intel_atomic_state
*intel_state
= to_intel_atomic_state(old_state
);
10294 unsigned int req_cdclk
= intel_state
->dev_cdclk
;
10295 unsigned int req_vco
= intel_state
->cdclk_pll_vco
;
10297 skl_set_cdclk(dev_priv
, req_cdclk
, req_vco
);
10300 static int haswell_crtc_compute_clock(struct intel_crtc
*crtc
,
10301 struct intel_crtc_state
*crtc_state
)
10303 if (!intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_DSI
)) {
10304 if (!intel_ddi_pll_select(crtc
, crtc_state
))
10308 crtc
->lowfreq_avail
= false;
10313 static void bxt_get_ddi_pll(struct drm_i915_private
*dev_priv
,
10315 struct intel_crtc_state
*pipe_config
)
10317 enum intel_dpll_id id
;
10321 pipe_config
->ddi_pll_sel
= SKL_DPLL0
;
10322 id
= DPLL_ID_SKL_DPLL0
;
10325 pipe_config
->ddi_pll_sel
= SKL_DPLL1
;
10326 id
= DPLL_ID_SKL_DPLL1
;
10329 pipe_config
->ddi_pll_sel
= SKL_DPLL2
;
10330 id
= DPLL_ID_SKL_DPLL2
;
10333 DRM_ERROR("Incorrect port type\n");
10337 pipe_config
->shared_dpll
= intel_get_shared_dpll_by_id(dev_priv
, id
);
10340 static void skylake_get_ddi_pll(struct drm_i915_private
*dev_priv
,
10342 struct intel_crtc_state
*pipe_config
)
10344 enum intel_dpll_id id
;
10347 temp
= I915_READ(DPLL_CTRL2
) & DPLL_CTRL2_DDI_CLK_SEL_MASK(port
);
10348 pipe_config
->ddi_pll_sel
= temp
>> (port
* 3 + 1);
10350 switch (pipe_config
->ddi_pll_sel
) {
10352 id
= DPLL_ID_SKL_DPLL0
;
10355 id
= DPLL_ID_SKL_DPLL1
;
10358 id
= DPLL_ID_SKL_DPLL2
;
10361 id
= DPLL_ID_SKL_DPLL3
;
10364 MISSING_CASE(pipe_config
->ddi_pll_sel
);
10368 pipe_config
->shared_dpll
= intel_get_shared_dpll_by_id(dev_priv
, id
);
10371 static void haswell_get_ddi_pll(struct drm_i915_private
*dev_priv
,
10373 struct intel_crtc_state
*pipe_config
)
10375 enum intel_dpll_id id
;
10377 pipe_config
->ddi_pll_sel
= I915_READ(PORT_CLK_SEL(port
));
10379 switch (pipe_config
->ddi_pll_sel
) {
10380 case PORT_CLK_SEL_WRPLL1
:
10381 id
= DPLL_ID_WRPLL1
;
10383 case PORT_CLK_SEL_WRPLL2
:
10384 id
= DPLL_ID_WRPLL2
;
10386 case PORT_CLK_SEL_SPLL
:
10389 case PORT_CLK_SEL_LCPLL_810
:
10390 id
= DPLL_ID_LCPLL_810
;
10392 case PORT_CLK_SEL_LCPLL_1350
:
10393 id
= DPLL_ID_LCPLL_1350
;
10395 case PORT_CLK_SEL_LCPLL_2700
:
10396 id
= DPLL_ID_LCPLL_2700
;
10399 MISSING_CASE(pipe_config
->ddi_pll_sel
);
10401 case PORT_CLK_SEL_NONE
:
10405 pipe_config
->shared_dpll
= intel_get_shared_dpll_by_id(dev_priv
, id
);
10408 static bool hsw_get_transcoder_state(struct intel_crtc
*crtc
,
10409 struct intel_crtc_state
*pipe_config
,
10410 unsigned long *power_domain_mask
)
10412 struct drm_device
*dev
= crtc
->base
.dev
;
10413 struct drm_i915_private
*dev_priv
= to_i915(dev
);
10414 enum intel_display_power_domain power_domain
;
10418 * The pipe->transcoder mapping is fixed with the exception of the eDP
10419 * transcoder handled below.
10421 pipe_config
->cpu_transcoder
= (enum transcoder
) crtc
->pipe
;
10424 * XXX: Do intel_display_power_get_if_enabled before reading this (for
10425 * consistency and less surprising code; it's in always on power).
10427 tmp
= I915_READ(TRANS_DDI_FUNC_CTL(TRANSCODER_EDP
));
10428 if (tmp
& TRANS_DDI_FUNC_ENABLE
) {
10429 enum pipe trans_edp_pipe
;
10430 switch (tmp
& TRANS_DDI_EDP_INPUT_MASK
) {
10432 WARN(1, "unknown pipe linked to edp transcoder\n");
10433 case TRANS_DDI_EDP_INPUT_A_ONOFF
:
10434 case TRANS_DDI_EDP_INPUT_A_ON
:
10435 trans_edp_pipe
= PIPE_A
;
10437 case TRANS_DDI_EDP_INPUT_B_ONOFF
:
10438 trans_edp_pipe
= PIPE_B
;
10440 case TRANS_DDI_EDP_INPUT_C_ONOFF
:
10441 trans_edp_pipe
= PIPE_C
;
10445 if (trans_edp_pipe
== crtc
->pipe
)
10446 pipe_config
->cpu_transcoder
= TRANSCODER_EDP
;
10449 power_domain
= POWER_DOMAIN_TRANSCODER(pipe_config
->cpu_transcoder
);
10450 if (!intel_display_power_get_if_enabled(dev_priv
, power_domain
))
10452 *power_domain_mask
|= BIT(power_domain
);
10454 tmp
= I915_READ(PIPECONF(pipe_config
->cpu_transcoder
));
10456 return tmp
& PIPECONF_ENABLE
;
10459 static bool bxt_get_dsi_transcoder_state(struct intel_crtc
*crtc
,
10460 struct intel_crtc_state
*pipe_config
,
10461 unsigned long *power_domain_mask
)
10463 struct drm_device
*dev
= crtc
->base
.dev
;
10464 struct drm_i915_private
*dev_priv
= to_i915(dev
);
10465 enum intel_display_power_domain power_domain
;
10467 enum transcoder cpu_transcoder
;
10470 for_each_port_masked(port
, BIT(PORT_A
) | BIT(PORT_C
)) {
10471 if (port
== PORT_A
)
10472 cpu_transcoder
= TRANSCODER_DSI_A
;
10474 cpu_transcoder
= TRANSCODER_DSI_C
;
10476 power_domain
= POWER_DOMAIN_TRANSCODER(cpu_transcoder
);
10477 if (!intel_display_power_get_if_enabled(dev_priv
, power_domain
))
10479 *power_domain_mask
|= BIT(power_domain
);
10482 * The PLL needs to be enabled with a valid divider
10483 * configuration, otherwise accessing DSI registers will hang
10484 * the machine. See BSpec North Display Engine
10485 * registers/MIPI[BXT]. We can break out here early, since we
10486 * need the same DSI PLL to be enabled for both DSI ports.
10488 if (!intel_dsi_pll_is_enabled(dev_priv
))
10491 /* XXX: this works for video mode only */
10492 tmp
= I915_READ(BXT_MIPI_PORT_CTRL(port
));
10493 if (!(tmp
& DPI_ENABLE
))
10496 tmp
= I915_READ(MIPI_CTRL(port
));
10497 if ((tmp
& BXT_PIPE_SELECT_MASK
) != BXT_PIPE_SELECT(crtc
->pipe
))
10500 pipe_config
->cpu_transcoder
= cpu_transcoder
;
10504 return transcoder_is_dsi(pipe_config
->cpu_transcoder
);
10507 static void haswell_get_ddi_port_state(struct intel_crtc
*crtc
,
10508 struct intel_crtc_state
*pipe_config
)
10510 struct drm_device
*dev
= crtc
->base
.dev
;
10511 struct drm_i915_private
*dev_priv
= to_i915(dev
);
10512 struct intel_shared_dpll
*pll
;
10516 tmp
= I915_READ(TRANS_DDI_FUNC_CTL(pipe_config
->cpu_transcoder
));
10518 port
= (tmp
& TRANS_DDI_PORT_MASK
) >> TRANS_DDI_PORT_SHIFT
;
10520 if (IS_SKYLAKE(dev
) || IS_KABYLAKE(dev
))
10521 skylake_get_ddi_pll(dev_priv
, port
, pipe_config
);
10522 else if (IS_BROXTON(dev
))
10523 bxt_get_ddi_pll(dev_priv
, port
, pipe_config
);
10525 haswell_get_ddi_pll(dev_priv
, port
, pipe_config
);
10527 pll
= pipe_config
->shared_dpll
;
10529 WARN_ON(!pll
->funcs
.get_hw_state(dev_priv
, pll
,
10530 &pipe_config
->dpll_hw_state
));
10534 * Haswell has only FDI/PCH transcoder A. It is which is connected to
10535 * DDI E. So just check whether this pipe is wired to DDI E and whether
10536 * the PCH transcoder is on.
10538 if (INTEL_INFO(dev
)->gen
< 9 &&
10539 (port
== PORT_E
) && I915_READ(LPT_TRANSCONF
) & TRANS_ENABLE
) {
10540 pipe_config
->has_pch_encoder
= true;
10542 tmp
= I915_READ(FDI_RX_CTL(PIPE_A
));
10543 pipe_config
->fdi_lanes
= ((FDI_DP_PORT_WIDTH_MASK
& tmp
) >>
10544 FDI_DP_PORT_WIDTH_SHIFT
) + 1;
10546 ironlake_get_fdi_m_n_config(crtc
, pipe_config
);
10550 static bool haswell_get_pipe_config(struct intel_crtc
*crtc
,
10551 struct intel_crtc_state
*pipe_config
)
10553 struct drm_device
*dev
= crtc
->base
.dev
;
10554 struct drm_i915_private
*dev_priv
= to_i915(dev
);
10555 enum intel_display_power_domain power_domain
;
10556 unsigned long power_domain_mask
;
10559 power_domain
= POWER_DOMAIN_PIPE(crtc
->pipe
);
10560 if (!intel_display_power_get_if_enabled(dev_priv
, power_domain
))
10562 power_domain_mask
= BIT(power_domain
);
10564 pipe_config
->shared_dpll
= NULL
;
10566 active
= hsw_get_transcoder_state(crtc
, pipe_config
, &power_domain_mask
);
10568 if (IS_BROXTON(dev_priv
) &&
10569 bxt_get_dsi_transcoder_state(crtc
, pipe_config
, &power_domain_mask
)) {
10577 if (!transcoder_is_dsi(pipe_config
->cpu_transcoder
)) {
10578 haswell_get_ddi_port_state(crtc
, pipe_config
);
10579 intel_get_pipe_timings(crtc
, pipe_config
);
10582 intel_get_pipe_src_size(crtc
, pipe_config
);
10584 pipe_config
->gamma_mode
=
10585 I915_READ(GAMMA_MODE(crtc
->pipe
)) & GAMMA_MODE_MODE_MASK
;
10587 if (INTEL_INFO(dev
)->gen
>= 9) {
10588 skl_init_scalers(dev
, crtc
, pipe_config
);
10591 if (INTEL_INFO(dev
)->gen
>= 9) {
10592 pipe_config
->scaler_state
.scaler_id
= -1;
10593 pipe_config
->scaler_state
.scaler_users
&= ~(1 << SKL_CRTC_INDEX
);
10596 power_domain
= POWER_DOMAIN_PIPE_PANEL_FITTER(crtc
->pipe
);
10597 if (intel_display_power_get_if_enabled(dev_priv
, power_domain
)) {
10598 power_domain_mask
|= BIT(power_domain
);
10599 if (INTEL_INFO(dev
)->gen
>= 9)
10600 skylake_get_pfit_config(crtc
, pipe_config
);
10602 ironlake_get_pfit_config(crtc
, pipe_config
);
10605 if (IS_HASWELL(dev
))
10606 pipe_config
->ips_enabled
= hsw_crtc_supports_ips(crtc
) &&
10607 (I915_READ(IPS_CTL
) & IPS_ENABLE
);
10609 if (pipe_config
->cpu_transcoder
!= TRANSCODER_EDP
&&
10610 !transcoder_is_dsi(pipe_config
->cpu_transcoder
)) {
10611 pipe_config
->pixel_multiplier
=
10612 I915_READ(PIPE_MULT(pipe_config
->cpu_transcoder
)) + 1;
10614 pipe_config
->pixel_multiplier
= 1;
10618 for_each_power_domain(power_domain
, power_domain_mask
)
10619 intel_display_power_put(dev_priv
, power_domain
);
10624 static void i845_update_cursor(struct drm_crtc
*crtc
, u32 base
,
10625 const struct intel_plane_state
*plane_state
)
10627 struct drm_device
*dev
= crtc
->dev
;
10628 struct drm_i915_private
*dev_priv
= to_i915(dev
);
10629 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
10630 uint32_t cntl
= 0, size
= 0;
10632 if (plane_state
&& plane_state
->base
.visible
) {
10633 unsigned int width
= plane_state
->base
.crtc_w
;
10634 unsigned int height
= plane_state
->base
.crtc_h
;
10635 unsigned int stride
= roundup_pow_of_two(width
) * 4;
10639 WARN_ONCE(1, "Invalid cursor width/stride, width=%u, stride=%u\n",
10650 cntl
|= CURSOR_ENABLE
|
10651 CURSOR_GAMMA_ENABLE
|
10652 CURSOR_FORMAT_ARGB
|
10653 CURSOR_STRIDE(stride
);
10655 size
= (height
<< 12) | width
;
10658 if (intel_crtc
->cursor_cntl
!= 0 &&
10659 (intel_crtc
->cursor_base
!= base
||
10660 intel_crtc
->cursor_size
!= size
||
10661 intel_crtc
->cursor_cntl
!= cntl
)) {
10662 /* On these chipsets we can only modify the base/size/stride
10663 * whilst the cursor is disabled.
10665 I915_WRITE(CURCNTR(PIPE_A
), 0);
10666 POSTING_READ(CURCNTR(PIPE_A
));
10667 intel_crtc
->cursor_cntl
= 0;
10670 if (intel_crtc
->cursor_base
!= base
) {
10671 I915_WRITE(CURBASE(PIPE_A
), base
);
10672 intel_crtc
->cursor_base
= base
;
10675 if (intel_crtc
->cursor_size
!= size
) {
10676 I915_WRITE(CURSIZE
, size
);
10677 intel_crtc
->cursor_size
= size
;
10680 if (intel_crtc
->cursor_cntl
!= cntl
) {
10681 I915_WRITE(CURCNTR(PIPE_A
), cntl
);
10682 POSTING_READ(CURCNTR(PIPE_A
));
10683 intel_crtc
->cursor_cntl
= cntl
;
10687 static void i9xx_update_cursor(struct drm_crtc
*crtc
, u32 base
,
10688 const struct intel_plane_state
*plane_state
)
10690 struct drm_device
*dev
= crtc
->dev
;
10691 struct drm_i915_private
*dev_priv
= to_i915(dev
);
10692 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
10693 int pipe
= intel_crtc
->pipe
;
10696 if (plane_state
&& plane_state
->base
.visible
) {
10697 cntl
= MCURSOR_GAMMA_ENABLE
;
10698 switch (plane_state
->base
.crtc_w
) {
10700 cntl
|= CURSOR_MODE_64_ARGB_AX
;
10703 cntl
|= CURSOR_MODE_128_ARGB_AX
;
10706 cntl
|= CURSOR_MODE_256_ARGB_AX
;
10709 MISSING_CASE(plane_state
->base
.crtc_w
);
10712 cntl
|= pipe
<< 28; /* Connect to correct pipe */
10715 cntl
|= CURSOR_PIPE_CSC_ENABLE
;
10717 if (plane_state
->base
.rotation
== DRM_ROTATE_180
)
10718 cntl
|= CURSOR_ROTATE_180
;
10721 if (intel_crtc
->cursor_cntl
!= cntl
) {
10722 I915_WRITE(CURCNTR(pipe
), cntl
);
10723 POSTING_READ(CURCNTR(pipe
));
10724 intel_crtc
->cursor_cntl
= cntl
;
10727 /* and commit changes on next vblank */
10728 I915_WRITE(CURBASE(pipe
), base
);
10729 POSTING_READ(CURBASE(pipe
));
10731 intel_crtc
->cursor_base
= base
;
10734 /* If no-part of the cursor is visible on the framebuffer, then the GPU may hang... */
10735 static void intel_crtc_update_cursor(struct drm_crtc
*crtc
,
10736 const struct intel_plane_state
*plane_state
)
10738 struct drm_device
*dev
= crtc
->dev
;
10739 struct drm_i915_private
*dev_priv
= to_i915(dev
);
10740 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
10741 int pipe
= intel_crtc
->pipe
;
10742 u32 base
= intel_crtc
->cursor_addr
;
10746 int x
= plane_state
->base
.crtc_x
;
10747 int y
= plane_state
->base
.crtc_y
;
10750 pos
|= CURSOR_POS_SIGN
<< CURSOR_X_SHIFT
;
10753 pos
|= x
<< CURSOR_X_SHIFT
;
10756 pos
|= CURSOR_POS_SIGN
<< CURSOR_Y_SHIFT
;
10759 pos
|= y
<< CURSOR_Y_SHIFT
;
10761 /* ILK+ do this automagically */
10762 if (HAS_GMCH_DISPLAY(dev
) &&
10763 plane_state
->base
.rotation
== DRM_ROTATE_180
) {
10764 base
+= (plane_state
->base
.crtc_h
*
10765 plane_state
->base
.crtc_w
- 1) * 4;
10769 I915_WRITE(CURPOS(pipe
), pos
);
10771 if (IS_845G(dev
) || IS_I865G(dev
))
10772 i845_update_cursor(crtc
, base
, plane_state
);
10774 i9xx_update_cursor(crtc
, base
, plane_state
);
10777 static bool cursor_size_ok(struct drm_device
*dev
,
10778 uint32_t width
, uint32_t height
)
10780 if (width
== 0 || height
== 0)
10784 * 845g/865g are special in that they are only limited by
10785 * the width of their cursors, the height is arbitrary up to
10786 * the precision of the register. Everything else requires
10787 * square cursors, limited to a few power-of-two sizes.
10789 if (IS_845G(dev
) || IS_I865G(dev
)) {
10790 if ((width
& 63) != 0)
10793 if (width
> (IS_845G(dev
) ? 64 : 512))
10799 switch (width
| height
) {
10814 /* VESA 640x480x72Hz mode to set on the pipe */
10815 static struct drm_display_mode load_detect_mode
= {
10816 DRM_MODE("640x480", DRM_MODE_TYPE_DEFAULT
, 31500, 640, 664,
10817 704, 832, 0, 480, 489, 491, 520, 0, DRM_MODE_FLAG_NHSYNC
| DRM_MODE_FLAG_NVSYNC
),
10820 struct drm_framebuffer
*
10821 __intel_framebuffer_create(struct drm_device
*dev
,
10822 struct drm_mode_fb_cmd2
*mode_cmd
,
10823 struct drm_i915_gem_object
*obj
)
10825 struct intel_framebuffer
*intel_fb
;
10828 intel_fb
= kzalloc(sizeof(*intel_fb
), GFP_KERNEL
);
10830 return ERR_PTR(-ENOMEM
);
10832 ret
= intel_framebuffer_init(dev
, intel_fb
, mode_cmd
, obj
);
10836 return &intel_fb
->base
;
10840 return ERR_PTR(ret
);
10843 static struct drm_framebuffer
*
10844 intel_framebuffer_create(struct drm_device
*dev
,
10845 struct drm_mode_fb_cmd2
*mode_cmd
,
10846 struct drm_i915_gem_object
*obj
)
10848 struct drm_framebuffer
*fb
;
10851 ret
= i915_mutex_lock_interruptible(dev
);
10853 return ERR_PTR(ret
);
10854 fb
= __intel_framebuffer_create(dev
, mode_cmd
, obj
);
10855 mutex_unlock(&dev
->struct_mutex
);
10861 intel_framebuffer_pitch_for_width(int width
, int bpp
)
10863 u32 pitch
= DIV_ROUND_UP(width
* bpp
, 8);
10864 return ALIGN(pitch
, 64);
10868 intel_framebuffer_size_for_mode(struct drm_display_mode
*mode
, int bpp
)
10870 u32 pitch
= intel_framebuffer_pitch_for_width(mode
->hdisplay
, bpp
);
10871 return PAGE_ALIGN(pitch
* mode
->vdisplay
);
10874 static struct drm_framebuffer
*
10875 intel_framebuffer_create_for_mode(struct drm_device
*dev
,
10876 struct drm_display_mode
*mode
,
10877 int depth
, int bpp
)
10879 struct drm_framebuffer
*fb
;
10880 struct drm_i915_gem_object
*obj
;
10881 struct drm_mode_fb_cmd2 mode_cmd
= { 0 };
10883 obj
= i915_gem_object_create(dev
,
10884 intel_framebuffer_size_for_mode(mode
, bpp
));
10886 return ERR_CAST(obj
);
10888 mode_cmd
.width
= mode
->hdisplay
;
10889 mode_cmd
.height
= mode
->vdisplay
;
10890 mode_cmd
.pitches
[0] = intel_framebuffer_pitch_for_width(mode_cmd
.width
,
10892 mode_cmd
.pixel_format
= drm_mode_legacy_fb_format(bpp
, depth
);
10894 fb
= intel_framebuffer_create(dev
, &mode_cmd
, obj
);
10896 i915_gem_object_put_unlocked(obj
);
10901 static struct drm_framebuffer
*
10902 mode_fits_in_fbdev(struct drm_device
*dev
,
10903 struct drm_display_mode
*mode
)
10905 #ifdef CONFIG_DRM_FBDEV_EMULATION
10906 struct drm_i915_private
*dev_priv
= to_i915(dev
);
10907 struct drm_i915_gem_object
*obj
;
10908 struct drm_framebuffer
*fb
;
10910 if (!dev_priv
->fbdev
)
10913 if (!dev_priv
->fbdev
->fb
)
10916 obj
= dev_priv
->fbdev
->fb
->obj
;
10919 fb
= &dev_priv
->fbdev
->fb
->base
;
10920 if (fb
->pitches
[0] < intel_framebuffer_pitch_for_width(mode
->hdisplay
,
10921 fb
->bits_per_pixel
))
10924 if (obj
->base
.size
< mode
->vdisplay
* fb
->pitches
[0])
10927 drm_framebuffer_reference(fb
);
10934 static int intel_modeset_setup_plane_state(struct drm_atomic_state
*state
,
10935 struct drm_crtc
*crtc
,
10936 struct drm_display_mode
*mode
,
10937 struct drm_framebuffer
*fb
,
10940 struct drm_plane_state
*plane_state
;
10941 int hdisplay
, vdisplay
;
10944 plane_state
= drm_atomic_get_plane_state(state
, crtc
->primary
);
10945 if (IS_ERR(plane_state
))
10946 return PTR_ERR(plane_state
);
10949 drm_crtc_get_hv_timing(mode
, &hdisplay
, &vdisplay
);
10951 hdisplay
= vdisplay
= 0;
10953 ret
= drm_atomic_set_crtc_for_plane(plane_state
, fb
? crtc
: NULL
);
10956 drm_atomic_set_fb_for_plane(plane_state
, fb
);
10957 plane_state
->crtc_x
= 0;
10958 plane_state
->crtc_y
= 0;
10959 plane_state
->crtc_w
= hdisplay
;
10960 plane_state
->crtc_h
= vdisplay
;
10961 plane_state
->src_x
= x
<< 16;
10962 plane_state
->src_y
= y
<< 16;
10963 plane_state
->src_w
= hdisplay
<< 16;
10964 plane_state
->src_h
= vdisplay
<< 16;
10969 bool intel_get_load_detect_pipe(struct drm_connector
*connector
,
10970 struct drm_display_mode
*mode
,
10971 struct intel_load_detect_pipe
*old
,
10972 struct drm_modeset_acquire_ctx
*ctx
)
10974 struct intel_crtc
*intel_crtc
;
10975 struct intel_encoder
*intel_encoder
=
10976 intel_attached_encoder(connector
);
10977 struct drm_crtc
*possible_crtc
;
10978 struct drm_encoder
*encoder
= &intel_encoder
->base
;
10979 struct drm_crtc
*crtc
= NULL
;
10980 struct drm_device
*dev
= encoder
->dev
;
10981 struct drm_framebuffer
*fb
;
10982 struct drm_mode_config
*config
= &dev
->mode_config
;
10983 struct drm_atomic_state
*state
= NULL
, *restore_state
= NULL
;
10984 struct drm_connector_state
*connector_state
;
10985 struct intel_crtc_state
*crtc_state
;
10988 DRM_DEBUG_KMS("[CONNECTOR:%d:%s], [ENCODER:%d:%s]\n",
10989 connector
->base
.id
, connector
->name
,
10990 encoder
->base
.id
, encoder
->name
);
10992 old
->restore_state
= NULL
;
10995 ret
= drm_modeset_lock(&config
->connection_mutex
, ctx
);
11000 * Algorithm gets a little messy:
11002 * - if the connector already has an assigned crtc, use it (but make
11003 * sure it's on first)
11005 * - try to find the first unused crtc that can drive this connector,
11006 * and use that if we find one
11009 /* See if we already have a CRTC for this connector */
11010 if (connector
->state
->crtc
) {
11011 crtc
= connector
->state
->crtc
;
11013 ret
= drm_modeset_lock(&crtc
->mutex
, ctx
);
11017 /* Make sure the crtc and connector are running */
11021 /* Find an unused one (if possible) */
11022 for_each_crtc(dev
, possible_crtc
) {
11024 if (!(encoder
->possible_crtcs
& (1 << i
)))
11027 ret
= drm_modeset_lock(&possible_crtc
->mutex
, ctx
);
11031 if (possible_crtc
->state
->enable
) {
11032 drm_modeset_unlock(&possible_crtc
->mutex
);
11036 crtc
= possible_crtc
;
11041 * If we didn't find an unused CRTC, don't use any.
11044 DRM_DEBUG_KMS("no pipe available for load-detect\n");
11049 intel_crtc
= to_intel_crtc(crtc
);
11051 ret
= drm_modeset_lock(&crtc
->primary
->mutex
, ctx
);
11055 state
= drm_atomic_state_alloc(dev
);
11056 restore_state
= drm_atomic_state_alloc(dev
);
11057 if (!state
|| !restore_state
) {
11062 state
->acquire_ctx
= ctx
;
11063 restore_state
->acquire_ctx
= ctx
;
11065 connector_state
= drm_atomic_get_connector_state(state
, connector
);
11066 if (IS_ERR(connector_state
)) {
11067 ret
= PTR_ERR(connector_state
);
11071 ret
= drm_atomic_set_crtc_for_connector(connector_state
, crtc
);
11075 crtc_state
= intel_atomic_get_crtc_state(state
, intel_crtc
);
11076 if (IS_ERR(crtc_state
)) {
11077 ret
= PTR_ERR(crtc_state
);
11081 crtc_state
->base
.active
= crtc_state
->base
.enable
= true;
11084 mode
= &load_detect_mode
;
11086 /* We need a framebuffer large enough to accommodate all accesses
11087 * that the plane may generate whilst we perform load detection.
11088 * We can not rely on the fbcon either being present (we get called
11089 * during its initialisation to detect all boot displays, or it may
11090 * not even exist) or that it is large enough to satisfy the
11093 fb
= mode_fits_in_fbdev(dev
, mode
);
11095 DRM_DEBUG_KMS("creating tmp fb for load-detection\n");
11096 fb
= intel_framebuffer_create_for_mode(dev
, mode
, 24, 32);
11098 DRM_DEBUG_KMS("reusing fbdev for load-detection framebuffer\n");
11100 DRM_DEBUG_KMS("failed to allocate framebuffer for load-detection\n");
11104 ret
= intel_modeset_setup_plane_state(state
, crtc
, mode
, fb
, 0, 0);
11108 drm_framebuffer_unreference(fb
);
11110 ret
= drm_atomic_set_mode_for_crtc(&crtc_state
->base
, mode
);
11114 ret
= PTR_ERR_OR_ZERO(drm_atomic_get_connector_state(restore_state
, connector
));
11116 ret
= PTR_ERR_OR_ZERO(drm_atomic_get_crtc_state(restore_state
, crtc
));
11118 ret
= PTR_ERR_OR_ZERO(drm_atomic_get_plane_state(restore_state
, crtc
->primary
));
11120 DRM_DEBUG_KMS("Failed to create a copy of old state to restore: %i\n", ret
);
11124 ret
= drm_atomic_commit(state
);
11126 DRM_DEBUG_KMS("failed to set mode on load-detect pipe\n");
11130 old
->restore_state
= restore_state
;
11132 /* let the connector get through one full cycle before testing */
11133 intel_wait_for_vblank(dev
, intel_crtc
->pipe
);
11137 drm_atomic_state_free(state
);
11138 drm_atomic_state_free(restore_state
);
11139 restore_state
= state
= NULL
;
11141 if (ret
== -EDEADLK
) {
11142 drm_modeset_backoff(ctx
);
11149 void intel_release_load_detect_pipe(struct drm_connector
*connector
,
11150 struct intel_load_detect_pipe
*old
,
11151 struct drm_modeset_acquire_ctx
*ctx
)
11153 struct intel_encoder
*intel_encoder
=
11154 intel_attached_encoder(connector
);
11155 struct drm_encoder
*encoder
= &intel_encoder
->base
;
11156 struct drm_atomic_state
*state
= old
->restore_state
;
11159 DRM_DEBUG_KMS("[CONNECTOR:%d:%s], [ENCODER:%d:%s]\n",
11160 connector
->base
.id
, connector
->name
,
11161 encoder
->base
.id
, encoder
->name
);
11166 ret
= drm_atomic_commit(state
);
11168 DRM_DEBUG_KMS("Couldn't release load detect pipe: %i\n", ret
);
11169 drm_atomic_state_free(state
);
11173 static int i9xx_pll_refclk(struct drm_device
*dev
,
11174 const struct intel_crtc_state
*pipe_config
)
11176 struct drm_i915_private
*dev_priv
= to_i915(dev
);
11177 u32 dpll
= pipe_config
->dpll_hw_state
.dpll
;
11179 if ((dpll
& PLL_REF_INPUT_MASK
) == PLLB_REF_INPUT_SPREADSPECTRUMIN
)
11180 return dev_priv
->vbt
.lvds_ssc_freq
;
11181 else if (HAS_PCH_SPLIT(dev
))
11183 else if (!IS_GEN2(dev
))
11189 /* Returns the clock of the currently programmed mode of the given pipe. */
11190 static void i9xx_crtc_clock_get(struct intel_crtc
*crtc
,
11191 struct intel_crtc_state
*pipe_config
)
11193 struct drm_device
*dev
= crtc
->base
.dev
;
11194 struct drm_i915_private
*dev_priv
= to_i915(dev
);
11195 int pipe
= pipe_config
->cpu_transcoder
;
11196 u32 dpll
= pipe_config
->dpll_hw_state
.dpll
;
11200 int refclk
= i9xx_pll_refclk(dev
, pipe_config
);
11202 if ((dpll
& DISPLAY_RATE_SELECT_FPA1
) == 0)
11203 fp
= pipe_config
->dpll_hw_state
.fp0
;
11205 fp
= pipe_config
->dpll_hw_state
.fp1
;
11207 clock
.m1
= (fp
& FP_M1_DIV_MASK
) >> FP_M1_DIV_SHIFT
;
11208 if (IS_PINEVIEW(dev
)) {
11209 clock
.n
= ffs((fp
& FP_N_PINEVIEW_DIV_MASK
) >> FP_N_DIV_SHIFT
) - 1;
11210 clock
.m2
= (fp
& FP_M2_PINEVIEW_DIV_MASK
) >> FP_M2_DIV_SHIFT
;
11212 clock
.n
= (fp
& FP_N_DIV_MASK
) >> FP_N_DIV_SHIFT
;
11213 clock
.m2
= (fp
& FP_M2_DIV_MASK
) >> FP_M2_DIV_SHIFT
;
11216 if (!IS_GEN2(dev
)) {
11217 if (IS_PINEVIEW(dev
))
11218 clock
.p1
= ffs((dpll
& DPLL_FPA01_P1_POST_DIV_MASK_PINEVIEW
) >>
11219 DPLL_FPA01_P1_POST_DIV_SHIFT_PINEVIEW
);
11221 clock
.p1
= ffs((dpll
& DPLL_FPA01_P1_POST_DIV_MASK
) >>
11222 DPLL_FPA01_P1_POST_DIV_SHIFT
);
11224 switch (dpll
& DPLL_MODE_MASK
) {
11225 case DPLLB_MODE_DAC_SERIAL
:
11226 clock
.p2
= dpll
& DPLL_DAC_SERIAL_P2_CLOCK_DIV_5
?
11229 case DPLLB_MODE_LVDS
:
11230 clock
.p2
= dpll
& DPLLB_LVDS_P2_CLOCK_DIV_7
?
11234 DRM_DEBUG_KMS("Unknown DPLL mode %08x in programmed "
11235 "mode\n", (int)(dpll
& DPLL_MODE_MASK
));
11239 if (IS_PINEVIEW(dev
))
11240 port_clock
= pnv_calc_dpll_params(refclk
, &clock
);
11242 port_clock
= i9xx_calc_dpll_params(refclk
, &clock
);
11244 u32 lvds
= IS_I830(dev
) ? 0 : I915_READ(LVDS
);
11245 bool is_lvds
= (pipe
== 1) && (lvds
& LVDS_PORT_EN
);
11248 clock
.p1
= ffs((dpll
& DPLL_FPA01_P1_POST_DIV_MASK_I830_LVDS
) >>
11249 DPLL_FPA01_P1_POST_DIV_SHIFT
);
11251 if (lvds
& LVDS_CLKB_POWER_UP
)
11256 if (dpll
& PLL_P1_DIVIDE_BY_TWO
)
11259 clock
.p1
= ((dpll
& DPLL_FPA01_P1_POST_DIV_MASK_I830
) >>
11260 DPLL_FPA01_P1_POST_DIV_SHIFT
) + 2;
11262 if (dpll
& PLL_P2_DIVIDE_BY_4
)
11268 port_clock
= i9xx_calc_dpll_params(refclk
, &clock
);
11272 * This value includes pixel_multiplier. We will use
11273 * port_clock to compute adjusted_mode.crtc_clock in the
11274 * encoder's get_config() function.
11276 pipe_config
->port_clock
= port_clock
;
11279 int intel_dotclock_calculate(int link_freq
,
11280 const struct intel_link_m_n
*m_n
)
11283 * The calculation for the data clock is:
11284 * pixel_clock = ((m/n)*(link_clock * nr_lanes))/bpp
11285 * But we want to avoid losing precison if possible, so:
11286 * pixel_clock = ((m * link_clock * nr_lanes)/(n*bpp))
11288 * and the link clock is simpler:
11289 * link_clock = (m * link_clock) / n
11295 return div_u64((u64
)m_n
->link_m
* link_freq
, m_n
->link_n
);
11298 static void ironlake_pch_clock_get(struct intel_crtc
*crtc
,
11299 struct intel_crtc_state
*pipe_config
)
11301 struct drm_i915_private
*dev_priv
= to_i915(crtc
->base
.dev
);
11303 /* read out port_clock from the DPLL */
11304 i9xx_crtc_clock_get(crtc
, pipe_config
);
11307 * In case there is an active pipe without active ports,
11308 * we may need some idea for the dotclock anyway.
11309 * Calculate one based on the FDI configuration.
11311 pipe_config
->base
.adjusted_mode
.crtc_clock
=
11312 intel_dotclock_calculate(intel_fdi_link_freq(dev_priv
, pipe_config
),
11313 &pipe_config
->fdi_m_n
);
11316 /** Returns the currently programmed mode of the given pipe. */
11317 struct drm_display_mode
*intel_crtc_mode_get(struct drm_device
*dev
,
11318 struct drm_crtc
*crtc
)
11320 struct drm_i915_private
*dev_priv
= to_i915(dev
);
11321 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
11322 enum transcoder cpu_transcoder
= intel_crtc
->config
->cpu_transcoder
;
11323 struct drm_display_mode
*mode
;
11324 struct intel_crtc_state
*pipe_config
;
11325 int htot
= I915_READ(HTOTAL(cpu_transcoder
));
11326 int hsync
= I915_READ(HSYNC(cpu_transcoder
));
11327 int vtot
= I915_READ(VTOTAL(cpu_transcoder
));
11328 int vsync
= I915_READ(VSYNC(cpu_transcoder
));
11329 enum pipe pipe
= intel_crtc
->pipe
;
11331 mode
= kzalloc(sizeof(*mode
), GFP_KERNEL
);
11335 pipe_config
= kzalloc(sizeof(*pipe_config
), GFP_KERNEL
);
11336 if (!pipe_config
) {
11342 * Construct a pipe_config sufficient for getting the clock info
11343 * back out of crtc_clock_get.
11345 * Note, if LVDS ever uses a non-1 pixel multiplier, we'll need
11346 * to use a real value here instead.
11348 pipe_config
->cpu_transcoder
= (enum transcoder
) pipe
;
11349 pipe_config
->pixel_multiplier
= 1;
11350 pipe_config
->dpll_hw_state
.dpll
= I915_READ(DPLL(pipe
));
11351 pipe_config
->dpll_hw_state
.fp0
= I915_READ(FP0(pipe
));
11352 pipe_config
->dpll_hw_state
.fp1
= I915_READ(FP1(pipe
));
11353 i9xx_crtc_clock_get(intel_crtc
, pipe_config
);
11355 mode
->clock
= pipe_config
->port_clock
/ pipe_config
->pixel_multiplier
;
11356 mode
->hdisplay
= (htot
& 0xffff) + 1;
11357 mode
->htotal
= ((htot
& 0xffff0000) >> 16) + 1;
11358 mode
->hsync_start
= (hsync
& 0xffff) + 1;
11359 mode
->hsync_end
= ((hsync
& 0xffff0000) >> 16) + 1;
11360 mode
->vdisplay
= (vtot
& 0xffff) + 1;
11361 mode
->vtotal
= ((vtot
& 0xffff0000) >> 16) + 1;
11362 mode
->vsync_start
= (vsync
& 0xffff) + 1;
11363 mode
->vsync_end
= ((vsync
& 0xffff0000) >> 16) + 1;
11365 drm_mode_set_name(mode
);
11367 kfree(pipe_config
);
11372 static void intel_crtc_destroy(struct drm_crtc
*crtc
)
11374 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
11375 struct drm_device
*dev
= crtc
->dev
;
11376 struct intel_flip_work
*work
;
11378 spin_lock_irq(&dev
->event_lock
);
11379 work
= intel_crtc
->flip_work
;
11380 intel_crtc
->flip_work
= NULL
;
11381 spin_unlock_irq(&dev
->event_lock
);
11384 cancel_work_sync(&work
->mmio_work
);
11385 cancel_work_sync(&work
->unpin_work
);
11389 drm_crtc_cleanup(crtc
);
11394 static void intel_unpin_work_fn(struct work_struct
*__work
)
11396 struct intel_flip_work
*work
=
11397 container_of(__work
, struct intel_flip_work
, unpin_work
);
11398 struct intel_crtc
*crtc
= to_intel_crtc(work
->crtc
);
11399 struct drm_device
*dev
= crtc
->base
.dev
;
11400 struct drm_plane
*primary
= crtc
->base
.primary
;
11402 if (is_mmio_work(work
))
11403 flush_work(&work
->mmio_work
);
11405 mutex_lock(&dev
->struct_mutex
);
11406 intel_unpin_fb_obj(work
->old_fb
, primary
->state
->rotation
);
11407 i915_gem_object_put(work
->pending_flip_obj
);
11408 mutex_unlock(&dev
->struct_mutex
);
11410 i915_gem_request_put(work
->flip_queued_req
);
11412 intel_frontbuffer_flip_complete(to_i915(dev
),
11413 to_intel_plane(primary
)->frontbuffer_bit
);
11414 intel_fbc_post_update(crtc
);
11415 drm_framebuffer_unreference(work
->old_fb
);
11417 BUG_ON(atomic_read(&crtc
->unpin_work_count
) == 0);
11418 atomic_dec(&crtc
->unpin_work_count
);
11423 /* Is 'a' after or equal to 'b'? */
11424 static bool g4x_flip_count_after_eq(u32 a
, u32 b
)
11426 return !((a
- b
) & 0x80000000);
11429 static bool __pageflip_finished_cs(struct intel_crtc
*crtc
,
11430 struct intel_flip_work
*work
)
11432 struct drm_device
*dev
= crtc
->base
.dev
;
11433 struct drm_i915_private
*dev_priv
= to_i915(dev
);
11434 unsigned reset_counter
;
11436 reset_counter
= i915_reset_counter(&dev_priv
->gpu_error
);
11437 if (crtc
->reset_counter
!= reset_counter
)
11441 * The relevant registers doen't exist on pre-ctg.
11442 * As the flip done interrupt doesn't trigger for mmio
11443 * flips on gmch platforms, a flip count check isn't
11444 * really needed there. But since ctg has the registers,
11445 * include it in the check anyway.
11447 if (INTEL_INFO(dev
)->gen
< 5 && !IS_G4X(dev
))
11451 * BDW signals flip done immediately if the plane
11452 * is disabled, even if the plane enable is already
11453 * armed to occur at the next vblank :(
11457 * A DSPSURFLIVE check isn't enough in case the mmio and CS flips
11458 * used the same base address. In that case the mmio flip might
11459 * have completed, but the CS hasn't even executed the flip yet.
11461 * A flip count check isn't enough as the CS might have updated
11462 * the base address just after start of vblank, but before we
11463 * managed to process the interrupt. This means we'd complete the
11464 * CS flip too soon.
11466 * Combining both checks should get us a good enough result. It may
11467 * still happen that the CS flip has been executed, but has not
11468 * yet actually completed. But in case the base address is the same
11469 * anyway, we don't really care.
11471 return (I915_READ(DSPSURFLIVE(crtc
->plane
)) & ~0xfff) ==
11472 crtc
->flip_work
->gtt_offset
&&
11473 g4x_flip_count_after_eq(I915_READ(PIPE_FLIPCOUNT_G4X(crtc
->pipe
)),
11474 crtc
->flip_work
->flip_count
);
11478 __pageflip_finished_mmio(struct intel_crtc
*crtc
,
11479 struct intel_flip_work
*work
)
11482 * MMIO work completes when vblank is different from
11483 * flip_queued_vblank.
11485 * Reset counter value doesn't matter, this is handled by
11486 * i915_wait_request finishing early, so no need to handle
11489 return intel_crtc_get_vblank_counter(crtc
) != work
->flip_queued_vblank
;
11493 static bool pageflip_finished(struct intel_crtc
*crtc
,
11494 struct intel_flip_work
*work
)
11496 if (!atomic_read(&work
->pending
))
11501 if (is_mmio_work(work
))
11502 return __pageflip_finished_mmio(crtc
, work
);
11504 return __pageflip_finished_cs(crtc
, work
);
11507 void intel_finish_page_flip_cs(struct drm_i915_private
*dev_priv
, int pipe
)
11509 struct drm_device
*dev
= &dev_priv
->drm
;
11510 struct drm_crtc
*crtc
= dev_priv
->pipe_to_crtc_mapping
[pipe
];
11511 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
11512 struct intel_flip_work
*work
;
11513 unsigned long flags
;
11515 /* Ignore early vblank irqs */
11520 * This is called both by irq handlers and the reset code (to complete
11521 * lost pageflips) so needs the full irqsave spinlocks.
11523 spin_lock_irqsave(&dev
->event_lock
, flags
);
11524 work
= intel_crtc
->flip_work
;
11526 if (work
!= NULL
&&
11527 !is_mmio_work(work
) &&
11528 pageflip_finished(intel_crtc
, work
))
11529 page_flip_completed(intel_crtc
);
11531 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
11534 void intel_finish_page_flip_mmio(struct drm_i915_private
*dev_priv
, int pipe
)
11536 struct drm_device
*dev
= &dev_priv
->drm
;
11537 struct drm_crtc
*crtc
= dev_priv
->pipe_to_crtc_mapping
[pipe
];
11538 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
11539 struct intel_flip_work
*work
;
11540 unsigned long flags
;
11542 /* Ignore early vblank irqs */
11547 * This is called both by irq handlers and the reset code (to complete
11548 * lost pageflips) so needs the full irqsave spinlocks.
11550 spin_lock_irqsave(&dev
->event_lock
, flags
);
11551 work
= intel_crtc
->flip_work
;
11553 if (work
!= NULL
&&
11554 is_mmio_work(work
) &&
11555 pageflip_finished(intel_crtc
, work
))
11556 page_flip_completed(intel_crtc
);
11558 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
11561 static inline void intel_mark_page_flip_active(struct intel_crtc
*crtc
,
11562 struct intel_flip_work
*work
)
11564 work
->flip_queued_vblank
= intel_crtc_get_vblank_counter(crtc
);
11566 /* Ensure that the work item is consistent when activating it ... */
11567 smp_mb__before_atomic();
11568 atomic_set(&work
->pending
, 1);
11571 static int intel_gen2_queue_flip(struct drm_device
*dev
,
11572 struct drm_crtc
*crtc
,
11573 struct drm_framebuffer
*fb
,
11574 struct drm_i915_gem_object
*obj
,
11575 struct drm_i915_gem_request
*req
,
11578 struct intel_ring
*ring
= req
->ring
;
11579 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
11583 ret
= intel_ring_begin(req
, 6);
11587 /* Can't queue multiple flips, so wait for the previous
11588 * one to finish before executing the next.
11590 if (intel_crtc
->plane
)
11591 flip_mask
= MI_WAIT_FOR_PLANE_B_FLIP
;
11593 flip_mask
= MI_WAIT_FOR_PLANE_A_FLIP
;
11594 intel_ring_emit(ring
, MI_WAIT_FOR_EVENT
| flip_mask
);
11595 intel_ring_emit(ring
, MI_NOOP
);
11596 intel_ring_emit(ring
, MI_DISPLAY_FLIP
|
11597 MI_DISPLAY_FLIP_PLANE(intel_crtc
->plane
));
11598 intel_ring_emit(ring
, fb
->pitches
[0]);
11599 intel_ring_emit(ring
, intel_crtc
->flip_work
->gtt_offset
);
11600 intel_ring_emit(ring
, 0); /* aux display base address, unused */
11605 static int intel_gen3_queue_flip(struct drm_device
*dev
,
11606 struct drm_crtc
*crtc
,
11607 struct drm_framebuffer
*fb
,
11608 struct drm_i915_gem_object
*obj
,
11609 struct drm_i915_gem_request
*req
,
11612 struct intel_ring
*ring
= req
->ring
;
11613 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
11617 ret
= intel_ring_begin(req
, 6);
11621 if (intel_crtc
->plane
)
11622 flip_mask
= MI_WAIT_FOR_PLANE_B_FLIP
;
11624 flip_mask
= MI_WAIT_FOR_PLANE_A_FLIP
;
11625 intel_ring_emit(ring
, MI_WAIT_FOR_EVENT
| flip_mask
);
11626 intel_ring_emit(ring
, MI_NOOP
);
11627 intel_ring_emit(ring
, MI_DISPLAY_FLIP_I915
|
11628 MI_DISPLAY_FLIP_PLANE(intel_crtc
->plane
));
11629 intel_ring_emit(ring
, fb
->pitches
[0]);
11630 intel_ring_emit(ring
, intel_crtc
->flip_work
->gtt_offset
);
11631 intel_ring_emit(ring
, MI_NOOP
);
11636 static int intel_gen4_queue_flip(struct drm_device
*dev
,
11637 struct drm_crtc
*crtc
,
11638 struct drm_framebuffer
*fb
,
11639 struct drm_i915_gem_object
*obj
,
11640 struct drm_i915_gem_request
*req
,
11643 struct intel_ring
*ring
= req
->ring
;
11644 struct drm_i915_private
*dev_priv
= to_i915(dev
);
11645 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
11646 uint32_t pf
, pipesrc
;
11649 ret
= intel_ring_begin(req
, 4);
11653 /* i965+ uses the linear or tiled offsets from the
11654 * Display Registers (which do not change across a page-flip)
11655 * so we need only reprogram the base address.
11657 intel_ring_emit(ring
, MI_DISPLAY_FLIP
|
11658 MI_DISPLAY_FLIP_PLANE(intel_crtc
->plane
));
11659 intel_ring_emit(ring
, fb
->pitches
[0]);
11660 intel_ring_emit(ring
, intel_crtc
->flip_work
->gtt_offset
|
11661 intel_fb_modifier_to_tiling(fb
->modifier
[0]));
11663 /* XXX Enabling the panel-fitter across page-flip is so far
11664 * untested on non-native modes, so ignore it for now.
11665 * pf = I915_READ(pipe == 0 ? PFA_CTL_1 : PFB_CTL_1) & PF_ENABLE;
11668 pipesrc
= I915_READ(PIPESRC(intel_crtc
->pipe
)) & 0x0fff0fff;
11669 intel_ring_emit(ring
, pf
| pipesrc
);
11674 static int intel_gen6_queue_flip(struct drm_device
*dev
,
11675 struct drm_crtc
*crtc
,
11676 struct drm_framebuffer
*fb
,
11677 struct drm_i915_gem_object
*obj
,
11678 struct drm_i915_gem_request
*req
,
11681 struct intel_ring
*ring
= req
->ring
;
11682 struct drm_i915_private
*dev_priv
= to_i915(dev
);
11683 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
11684 uint32_t pf
, pipesrc
;
11687 ret
= intel_ring_begin(req
, 4);
11691 intel_ring_emit(ring
, MI_DISPLAY_FLIP
|
11692 MI_DISPLAY_FLIP_PLANE(intel_crtc
->plane
));
11693 intel_ring_emit(ring
, fb
->pitches
[0] |
11694 intel_fb_modifier_to_tiling(fb
->modifier
[0]));
11695 intel_ring_emit(ring
, intel_crtc
->flip_work
->gtt_offset
);
11697 /* Contrary to the suggestions in the documentation,
11698 * "Enable Panel Fitter" does not seem to be required when page
11699 * flipping with a non-native mode, and worse causes a normal
11701 * pf = I915_READ(PF_CTL(intel_crtc->pipe)) & PF_ENABLE;
11704 pipesrc
= I915_READ(PIPESRC(intel_crtc
->pipe
)) & 0x0fff0fff;
11705 intel_ring_emit(ring
, pf
| pipesrc
);
11710 static int intel_gen7_queue_flip(struct drm_device
*dev
,
11711 struct drm_crtc
*crtc
,
11712 struct drm_framebuffer
*fb
,
11713 struct drm_i915_gem_object
*obj
,
11714 struct drm_i915_gem_request
*req
,
11717 struct intel_ring
*ring
= req
->ring
;
11718 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
11719 uint32_t plane_bit
= 0;
11722 switch (intel_crtc
->plane
) {
11724 plane_bit
= MI_DISPLAY_FLIP_IVB_PLANE_A
;
11727 plane_bit
= MI_DISPLAY_FLIP_IVB_PLANE_B
;
11730 plane_bit
= MI_DISPLAY_FLIP_IVB_PLANE_C
;
11733 WARN_ONCE(1, "unknown plane in flip command\n");
11738 if (req
->engine
->id
== RCS
) {
11741 * On Gen 8, SRM is now taking an extra dword to accommodate
11742 * 48bits addresses, and we need a NOOP for the batch size to
11750 * BSpec MI_DISPLAY_FLIP for IVB:
11751 * "The full packet must be contained within the same cache line."
11753 * Currently the LRI+SRM+MI_DISPLAY_FLIP all fit within the same
11754 * cacheline, if we ever start emitting more commands before
11755 * the MI_DISPLAY_FLIP we may need to first emit everything else,
11756 * then do the cacheline alignment, and finally emit the
11759 ret
= intel_ring_cacheline_align(req
);
11763 ret
= intel_ring_begin(req
, len
);
11767 /* Unmask the flip-done completion message. Note that the bspec says that
11768 * we should do this for both the BCS and RCS, and that we must not unmask
11769 * more than one flip event at any time (or ensure that one flip message
11770 * can be sent by waiting for flip-done prior to queueing new flips).
11771 * Experimentation says that BCS works despite DERRMR masking all
11772 * flip-done completion events and that unmasking all planes at once
11773 * for the RCS also doesn't appear to drop events. Setting the DERRMR
11774 * to zero does lead to lockups within MI_DISPLAY_FLIP.
11776 if (req
->engine
->id
== RCS
) {
11777 intel_ring_emit(ring
, MI_LOAD_REGISTER_IMM(1));
11778 intel_ring_emit_reg(ring
, DERRMR
);
11779 intel_ring_emit(ring
, ~(DERRMR_PIPEA_PRI_FLIP_DONE
|
11780 DERRMR_PIPEB_PRI_FLIP_DONE
|
11781 DERRMR_PIPEC_PRI_FLIP_DONE
));
11783 intel_ring_emit(ring
, MI_STORE_REGISTER_MEM_GEN8
|
11784 MI_SRM_LRM_GLOBAL_GTT
);
11786 intel_ring_emit(ring
, MI_STORE_REGISTER_MEM
|
11787 MI_SRM_LRM_GLOBAL_GTT
);
11788 intel_ring_emit_reg(ring
, DERRMR
);
11789 intel_ring_emit(ring
,
11790 i915_ggtt_offset(req
->engine
->scratch
) + 256);
11791 if (IS_GEN8(dev
)) {
11792 intel_ring_emit(ring
, 0);
11793 intel_ring_emit(ring
, MI_NOOP
);
11797 intel_ring_emit(ring
, MI_DISPLAY_FLIP_I915
| plane_bit
);
11798 intel_ring_emit(ring
, fb
->pitches
[0] |
11799 intel_fb_modifier_to_tiling(fb
->modifier
[0]));
11800 intel_ring_emit(ring
, intel_crtc
->flip_work
->gtt_offset
);
11801 intel_ring_emit(ring
, (MI_NOOP
));
11806 static bool use_mmio_flip(struct intel_engine_cs
*engine
,
11807 struct drm_i915_gem_object
*obj
)
11809 struct reservation_object
*resv
;
11812 * This is not being used for older platforms, because
11813 * non-availability of flip done interrupt forces us to use
11814 * CS flips. Older platforms derive flip done using some clever
11815 * tricks involving the flip_pending status bits and vblank irqs.
11816 * So using MMIO flips there would disrupt this mechanism.
11819 if (engine
== NULL
)
11822 if (INTEL_GEN(engine
->i915
) < 5)
11825 if (i915
.use_mmio_flip
< 0)
11827 else if (i915
.use_mmio_flip
> 0)
11829 else if (i915
.enable_execlists
)
11832 resv
= i915_gem_object_get_dmabuf_resv(obj
);
11833 if (resv
&& !reservation_object_test_signaled_rcu(resv
, false))
11836 return engine
!= i915_gem_active_get_engine(&obj
->last_write
,
11837 &obj
->base
.dev
->struct_mutex
);
11840 static void skl_do_mmio_flip(struct intel_crtc
*intel_crtc
,
11841 unsigned int rotation
,
11842 struct intel_flip_work
*work
)
11844 struct drm_device
*dev
= intel_crtc
->base
.dev
;
11845 struct drm_i915_private
*dev_priv
= to_i915(dev
);
11846 struct drm_framebuffer
*fb
= intel_crtc
->base
.primary
->fb
;
11847 const enum pipe pipe
= intel_crtc
->pipe
;
11848 u32 ctl
, stride
= skl_plane_stride(fb
, 0, rotation
);
11850 ctl
= I915_READ(PLANE_CTL(pipe
, 0));
11851 ctl
&= ~PLANE_CTL_TILED_MASK
;
11852 switch (fb
->modifier
[0]) {
11853 case DRM_FORMAT_MOD_NONE
:
11855 case I915_FORMAT_MOD_X_TILED
:
11856 ctl
|= PLANE_CTL_TILED_X
;
11858 case I915_FORMAT_MOD_Y_TILED
:
11859 ctl
|= PLANE_CTL_TILED_Y
;
11861 case I915_FORMAT_MOD_Yf_TILED
:
11862 ctl
|= PLANE_CTL_TILED_YF
;
11865 MISSING_CASE(fb
->modifier
[0]);
11869 * Both PLANE_CTL and PLANE_STRIDE are not updated on vblank but on
11870 * PLANE_SURF updates, the update is then guaranteed to be atomic.
11872 I915_WRITE(PLANE_CTL(pipe
, 0), ctl
);
11873 I915_WRITE(PLANE_STRIDE(pipe
, 0), stride
);
11875 I915_WRITE(PLANE_SURF(pipe
, 0), work
->gtt_offset
);
11876 POSTING_READ(PLANE_SURF(pipe
, 0));
11879 static void ilk_do_mmio_flip(struct intel_crtc
*intel_crtc
,
11880 struct intel_flip_work
*work
)
11882 struct drm_device
*dev
= intel_crtc
->base
.dev
;
11883 struct drm_i915_private
*dev_priv
= to_i915(dev
);
11884 struct drm_framebuffer
*fb
= intel_crtc
->base
.primary
->fb
;
11885 i915_reg_t reg
= DSPCNTR(intel_crtc
->plane
);
11888 dspcntr
= I915_READ(reg
);
11890 if (fb
->modifier
[0] == I915_FORMAT_MOD_X_TILED
)
11891 dspcntr
|= DISPPLANE_TILED
;
11893 dspcntr
&= ~DISPPLANE_TILED
;
11895 I915_WRITE(reg
, dspcntr
);
11897 I915_WRITE(DSPSURF(intel_crtc
->plane
), work
->gtt_offset
);
11898 POSTING_READ(DSPSURF(intel_crtc
->plane
));
11901 static void intel_mmio_flip_work_func(struct work_struct
*w
)
11903 struct intel_flip_work
*work
=
11904 container_of(w
, struct intel_flip_work
, mmio_work
);
11905 struct intel_crtc
*crtc
= to_intel_crtc(work
->crtc
);
11906 struct drm_i915_private
*dev_priv
= to_i915(crtc
->base
.dev
);
11907 struct intel_framebuffer
*intel_fb
=
11908 to_intel_framebuffer(crtc
->base
.primary
->fb
);
11909 struct drm_i915_gem_object
*obj
= intel_fb
->obj
;
11910 struct reservation_object
*resv
;
11912 if (work
->flip_queued_req
)
11913 WARN_ON(i915_wait_request(work
->flip_queued_req
,
11917 /* For framebuffer backed by dmabuf, wait for fence */
11918 resv
= i915_gem_object_get_dmabuf_resv(obj
);
11920 WARN_ON(reservation_object_wait_timeout_rcu(resv
, false, false,
11921 MAX_SCHEDULE_TIMEOUT
) < 0);
11923 intel_pipe_update_start(crtc
);
11925 if (INTEL_GEN(dev_priv
) >= 9)
11926 skl_do_mmio_flip(crtc
, work
->rotation
, work
);
11928 /* use_mmio_flip() retricts MMIO flips to ilk+ */
11929 ilk_do_mmio_flip(crtc
, work
);
11931 intel_pipe_update_end(crtc
, work
);
11934 static int intel_default_queue_flip(struct drm_device
*dev
,
11935 struct drm_crtc
*crtc
,
11936 struct drm_framebuffer
*fb
,
11937 struct drm_i915_gem_object
*obj
,
11938 struct drm_i915_gem_request
*req
,
11944 static bool __pageflip_stall_check_cs(struct drm_i915_private
*dev_priv
,
11945 struct intel_crtc
*intel_crtc
,
11946 struct intel_flip_work
*work
)
11950 if (!atomic_read(&work
->pending
))
11955 vblank
= intel_crtc_get_vblank_counter(intel_crtc
);
11956 if (work
->flip_ready_vblank
== 0) {
11957 if (work
->flip_queued_req
&&
11958 !i915_gem_request_completed(work
->flip_queued_req
))
11961 work
->flip_ready_vblank
= vblank
;
11964 if (vblank
- work
->flip_ready_vblank
< 3)
11967 /* Potential stall - if we see that the flip has happened,
11968 * assume a missed interrupt. */
11969 if (INTEL_GEN(dev_priv
) >= 4)
11970 addr
= I915_HI_DISPBASE(I915_READ(DSPSURF(intel_crtc
->plane
)));
11972 addr
= I915_READ(DSPADDR(intel_crtc
->plane
));
11974 /* There is a potential issue here with a false positive after a flip
11975 * to the same address. We could address this by checking for a
11976 * non-incrementing frame counter.
11978 return addr
== work
->gtt_offset
;
11981 void intel_check_page_flip(struct drm_i915_private
*dev_priv
, int pipe
)
11983 struct drm_device
*dev
= &dev_priv
->drm
;
11984 struct drm_crtc
*crtc
= dev_priv
->pipe_to_crtc_mapping
[pipe
];
11985 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
11986 struct intel_flip_work
*work
;
11988 WARN_ON(!in_interrupt());
11993 spin_lock(&dev
->event_lock
);
11994 work
= intel_crtc
->flip_work
;
11996 if (work
!= NULL
&& !is_mmio_work(work
) &&
11997 __pageflip_stall_check_cs(dev_priv
, intel_crtc
, work
)) {
11999 "Kicking stuck page flip: queued at %d, now %d\n",
12000 work
->flip_queued_vblank
, intel_crtc_get_vblank_counter(intel_crtc
));
12001 page_flip_completed(intel_crtc
);
12005 if (work
!= NULL
&& !is_mmio_work(work
) &&
12006 intel_crtc_get_vblank_counter(intel_crtc
) - work
->flip_queued_vblank
> 1)
12007 intel_queue_rps_boost_for_request(work
->flip_queued_req
);
12008 spin_unlock(&dev
->event_lock
);
12011 static int intel_crtc_page_flip(struct drm_crtc
*crtc
,
12012 struct drm_framebuffer
*fb
,
12013 struct drm_pending_vblank_event
*event
,
12014 uint32_t page_flip_flags
)
12016 struct drm_device
*dev
= crtc
->dev
;
12017 struct drm_i915_private
*dev_priv
= to_i915(dev
);
12018 struct drm_framebuffer
*old_fb
= crtc
->primary
->fb
;
12019 struct drm_i915_gem_object
*obj
= intel_fb_obj(fb
);
12020 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
12021 struct drm_plane
*primary
= crtc
->primary
;
12022 enum pipe pipe
= intel_crtc
->pipe
;
12023 struct intel_flip_work
*work
;
12024 struct intel_engine_cs
*engine
;
12026 struct drm_i915_gem_request
*request
;
12027 struct i915_vma
*vma
;
12031 * drm_mode_page_flip_ioctl() should already catch this, but double
12032 * check to be safe. In the future we may enable pageflipping from
12033 * a disabled primary plane.
12035 if (WARN_ON(intel_fb_obj(old_fb
) == NULL
))
12038 /* Can't change pixel format via MI display flips. */
12039 if (fb
->pixel_format
!= crtc
->primary
->fb
->pixel_format
)
12043 * TILEOFF/LINOFF registers can't be changed via MI display flips.
12044 * Note that pitch changes could also affect these register.
12046 if (INTEL_INFO(dev
)->gen
> 3 &&
12047 (fb
->offsets
[0] != crtc
->primary
->fb
->offsets
[0] ||
12048 fb
->pitches
[0] != crtc
->primary
->fb
->pitches
[0]))
12051 if (i915_terminally_wedged(&dev_priv
->gpu_error
))
12054 work
= kzalloc(sizeof(*work
), GFP_KERNEL
);
12058 work
->event
= event
;
12060 work
->old_fb
= old_fb
;
12061 INIT_WORK(&work
->unpin_work
, intel_unpin_work_fn
);
12063 ret
= drm_crtc_vblank_get(crtc
);
12067 /* We borrow the event spin lock for protecting flip_work */
12068 spin_lock_irq(&dev
->event_lock
);
12069 if (intel_crtc
->flip_work
) {
12070 /* Before declaring the flip queue wedged, check if
12071 * the hardware completed the operation behind our backs.
12073 if (pageflip_finished(intel_crtc
, intel_crtc
->flip_work
)) {
12074 DRM_DEBUG_DRIVER("flip queue: previous flip completed, continuing\n");
12075 page_flip_completed(intel_crtc
);
12077 DRM_DEBUG_DRIVER("flip queue: crtc already busy\n");
12078 spin_unlock_irq(&dev
->event_lock
);
12080 drm_crtc_vblank_put(crtc
);
12085 intel_crtc
->flip_work
= work
;
12086 spin_unlock_irq(&dev
->event_lock
);
12088 if (atomic_read(&intel_crtc
->unpin_work_count
) >= 2)
12089 flush_workqueue(dev_priv
->wq
);
12091 /* Reference the objects for the scheduled work. */
12092 drm_framebuffer_reference(work
->old_fb
);
12094 crtc
->primary
->fb
= fb
;
12095 update_state_fb(crtc
->primary
);
12097 intel_fbc_pre_update(intel_crtc
, intel_crtc
->config
,
12098 to_intel_plane_state(primary
->state
));
12100 work
->pending_flip_obj
= i915_gem_object_get(obj
);
12102 ret
= i915_mutex_lock_interruptible(dev
);
12106 intel_crtc
->reset_counter
= i915_reset_counter(&dev_priv
->gpu_error
);
12107 if (__i915_reset_in_progress_or_wedged(intel_crtc
->reset_counter
)) {
12112 atomic_inc(&intel_crtc
->unpin_work_count
);
12114 if (INTEL_INFO(dev
)->gen
>= 5 || IS_G4X(dev
))
12115 work
->flip_count
= I915_READ(PIPE_FLIPCOUNT_G4X(pipe
)) + 1;
12117 if (IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
)) {
12118 engine
= &dev_priv
->engine
[BCS
];
12119 if (fb
->modifier
[0] != old_fb
->modifier
[0])
12120 /* vlv: DISPLAY_FLIP fails to change tiling */
12122 } else if (IS_IVYBRIDGE(dev
) || IS_HASWELL(dev
)) {
12123 engine
= &dev_priv
->engine
[BCS
];
12124 } else if (INTEL_INFO(dev
)->gen
>= 7) {
12125 engine
= i915_gem_active_get_engine(&obj
->last_write
,
12126 &obj
->base
.dev
->struct_mutex
);
12127 if (engine
== NULL
|| engine
->id
!= RCS
)
12128 engine
= &dev_priv
->engine
[BCS
];
12130 engine
= &dev_priv
->engine
[RCS
];
12133 mmio_flip
= use_mmio_flip(engine
, obj
);
12135 vma
= intel_pin_and_fence_fb_obj(fb
, primary
->state
->rotation
);
12137 ret
= PTR_ERR(vma
);
12138 goto cleanup_pending
;
12141 work
->gtt_offset
= intel_fb_gtt_offset(fb
, primary
->state
->rotation
);
12142 work
->gtt_offset
+= intel_crtc
->dspaddr_offset
;
12143 work
->rotation
= crtc
->primary
->state
->rotation
;
12146 INIT_WORK(&work
->mmio_work
, intel_mmio_flip_work_func
);
12148 work
->flip_queued_req
= i915_gem_active_get(&obj
->last_write
,
12149 &obj
->base
.dev
->struct_mutex
);
12150 schedule_work(&work
->mmio_work
);
12152 request
= i915_gem_request_alloc(engine
, engine
->last_context
);
12153 if (IS_ERR(request
)) {
12154 ret
= PTR_ERR(request
);
12155 goto cleanup_unpin
;
12158 ret
= i915_gem_object_sync(obj
, request
);
12160 goto cleanup_request
;
12162 ret
= dev_priv
->display
.queue_flip(dev
, crtc
, fb
, obj
, request
,
12165 goto cleanup_request
;
12167 intel_mark_page_flip_active(intel_crtc
, work
);
12169 work
->flip_queued_req
= i915_gem_request_get(request
);
12170 i915_add_request_no_flush(request
);
12173 i915_gem_track_fb(intel_fb_obj(old_fb
), obj
,
12174 to_intel_plane(primary
)->frontbuffer_bit
);
12175 mutex_unlock(&dev
->struct_mutex
);
12177 intel_frontbuffer_flip_prepare(to_i915(dev
),
12178 to_intel_plane(primary
)->frontbuffer_bit
);
12180 trace_i915_flip_request(intel_crtc
->plane
, obj
);
12185 i915_add_request_no_flush(request
);
12187 intel_unpin_fb_obj(fb
, crtc
->primary
->state
->rotation
);
12189 atomic_dec(&intel_crtc
->unpin_work_count
);
12190 mutex_unlock(&dev
->struct_mutex
);
12192 crtc
->primary
->fb
= old_fb
;
12193 update_state_fb(crtc
->primary
);
12195 i915_gem_object_put_unlocked(obj
);
12196 drm_framebuffer_unreference(work
->old_fb
);
12198 spin_lock_irq(&dev
->event_lock
);
12199 intel_crtc
->flip_work
= NULL
;
12200 spin_unlock_irq(&dev
->event_lock
);
12202 drm_crtc_vblank_put(crtc
);
12207 struct drm_atomic_state
*state
;
12208 struct drm_plane_state
*plane_state
;
12211 state
= drm_atomic_state_alloc(dev
);
12214 state
->acquire_ctx
= drm_modeset_legacy_acquire_ctx(crtc
);
12217 plane_state
= drm_atomic_get_plane_state(state
, primary
);
12218 ret
= PTR_ERR_OR_ZERO(plane_state
);
12220 drm_atomic_set_fb_for_plane(plane_state
, fb
);
12222 ret
= drm_atomic_set_crtc_for_plane(plane_state
, crtc
);
12224 ret
= drm_atomic_commit(state
);
12227 if (ret
== -EDEADLK
) {
12228 drm_modeset_backoff(state
->acquire_ctx
);
12229 drm_atomic_state_clear(state
);
12234 drm_atomic_state_free(state
);
12236 if (ret
== 0 && event
) {
12237 spin_lock_irq(&dev
->event_lock
);
12238 drm_crtc_send_vblank_event(crtc
, event
);
12239 spin_unlock_irq(&dev
->event_lock
);
12247 * intel_wm_need_update - Check whether watermarks need updating
12248 * @plane: drm plane
12249 * @state: new plane state
12251 * Check current plane state versus the new one to determine whether
12252 * watermarks need to be recalculated.
12254 * Returns true or false.
12256 static bool intel_wm_need_update(struct drm_plane
*plane
,
12257 struct drm_plane_state
*state
)
12259 struct intel_plane_state
*new = to_intel_plane_state(state
);
12260 struct intel_plane_state
*cur
= to_intel_plane_state(plane
->state
);
12262 /* Update watermarks on tiling or size changes. */
12263 if (new->base
.visible
!= cur
->base
.visible
)
12266 if (!cur
->base
.fb
|| !new->base
.fb
)
12269 if (cur
->base
.fb
->modifier
[0] != new->base
.fb
->modifier
[0] ||
12270 cur
->base
.rotation
!= new->base
.rotation
||
12271 drm_rect_width(&new->base
.src
) != drm_rect_width(&cur
->base
.src
) ||
12272 drm_rect_height(&new->base
.src
) != drm_rect_height(&cur
->base
.src
) ||
12273 drm_rect_width(&new->base
.dst
) != drm_rect_width(&cur
->base
.dst
) ||
12274 drm_rect_height(&new->base
.dst
) != drm_rect_height(&cur
->base
.dst
))
12280 static bool needs_scaling(struct intel_plane_state
*state
)
12282 int src_w
= drm_rect_width(&state
->base
.src
) >> 16;
12283 int src_h
= drm_rect_height(&state
->base
.src
) >> 16;
12284 int dst_w
= drm_rect_width(&state
->base
.dst
);
12285 int dst_h
= drm_rect_height(&state
->base
.dst
);
12287 return (src_w
!= dst_w
|| src_h
!= dst_h
);
12290 int intel_plane_atomic_calc_changes(struct drm_crtc_state
*crtc_state
,
12291 struct drm_plane_state
*plane_state
)
12293 struct intel_crtc_state
*pipe_config
= to_intel_crtc_state(crtc_state
);
12294 struct drm_crtc
*crtc
= crtc_state
->crtc
;
12295 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
12296 struct drm_plane
*plane
= plane_state
->plane
;
12297 struct drm_device
*dev
= crtc
->dev
;
12298 struct drm_i915_private
*dev_priv
= to_i915(dev
);
12299 struct intel_plane_state
*old_plane_state
=
12300 to_intel_plane_state(plane
->state
);
12301 bool mode_changed
= needs_modeset(crtc_state
);
12302 bool was_crtc_enabled
= crtc
->state
->active
;
12303 bool is_crtc_enabled
= crtc_state
->active
;
12304 bool turn_off
, turn_on
, visible
, was_visible
;
12305 struct drm_framebuffer
*fb
= plane_state
->fb
;
12308 if (INTEL_GEN(dev
) >= 9 && plane
->type
!= DRM_PLANE_TYPE_CURSOR
) {
12309 ret
= skl_update_scaler_plane(
12310 to_intel_crtc_state(crtc_state
),
12311 to_intel_plane_state(plane_state
));
12316 was_visible
= old_plane_state
->base
.visible
;
12317 visible
= to_intel_plane_state(plane_state
)->base
.visible
;
12319 if (!was_crtc_enabled
&& WARN_ON(was_visible
))
12320 was_visible
= false;
12323 * Visibility is calculated as if the crtc was on, but
12324 * after scaler setup everything depends on it being off
12325 * when the crtc isn't active.
12327 * FIXME this is wrong for watermarks. Watermarks should also
12328 * be computed as if the pipe would be active. Perhaps move
12329 * per-plane wm computation to the .check_plane() hook, and
12330 * only combine the results from all planes in the current place?
12332 if (!is_crtc_enabled
)
12333 to_intel_plane_state(plane_state
)->base
.visible
= visible
= false;
12335 if (!was_visible
&& !visible
)
12338 if (fb
!= old_plane_state
->base
.fb
)
12339 pipe_config
->fb_changed
= true;
12341 turn_off
= was_visible
&& (!visible
|| mode_changed
);
12342 turn_on
= visible
&& (!was_visible
|| mode_changed
);
12344 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] has [PLANE:%d:%s] with fb %i\n",
12345 intel_crtc
->base
.base
.id
,
12346 intel_crtc
->base
.name
,
12347 plane
->base
.id
, plane
->name
,
12348 fb
? fb
->base
.id
: -1);
12350 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] visible %i -> %i, off %i, on %i, ms %i\n",
12351 plane
->base
.id
, plane
->name
,
12352 was_visible
, visible
,
12353 turn_off
, turn_on
, mode_changed
);
12356 pipe_config
->update_wm_pre
= true;
12358 /* must disable cxsr around plane enable/disable */
12359 if (plane
->type
!= DRM_PLANE_TYPE_CURSOR
)
12360 pipe_config
->disable_cxsr
= true;
12361 } else if (turn_off
) {
12362 pipe_config
->update_wm_post
= true;
12364 /* must disable cxsr around plane enable/disable */
12365 if (plane
->type
!= DRM_PLANE_TYPE_CURSOR
)
12366 pipe_config
->disable_cxsr
= true;
12367 } else if (intel_wm_need_update(plane
, plane_state
)) {
12368 /* FIXME bollocks */
12369 pipe_config
->update_wm_pre
= true;
12370 pipe_config
->update_wm_post
= true;
12373 /* Pre-gen9 platforms need two-step watermark updates */
12374 if ((pipe_config
->update_wm_pre
|| pipe_config
->update_wm_post
) &&
12375 INTEL_INFO(dev
)->gen
< 9 && dev_priv
->display
.optimize_watermarks
)
12376 to_intel_crtc_state(crtc_state
)->wm
.need_postvbl_update
= true;
12378 if (visible
|| was_visible
)
12379 pipe_config
->fb_bits
|= to_intel_plane(plane
)->frontbuffer_bit
;
12382 * WaCxSRDisabledForSpriteScaling:ivb
12384 * cstate->update_wm was already set above, so this flag will
12385 * take effect when we commit and program watermarks.
12387 if (plane
->type
== DRM_PLANE_TYPE_OVERLAY
&& IS_IVYBRIDGE(dev
) &&
12388 needs_scaling(to_intel_plane_state(plane_state
)) &&
12389 !needs_scaling(old_plane_state
))
12390 pipe_config
->disable_lp_wm
= true;
12395 static bool encoders_cloneable(const struct intel_encoder
*a
,
12396 const struct intel_encoder
*b
)
12398 /* masks could be asymmetric, so check both ways */
12399 return a
== b
|| (a
->cloneable
& (1 << b
->type
) &&
12400 b
->cloneable
& (1 << a
->type
));
12403 static bool check_single_encoder_cloning(struct drm_atomic_state
*state
,
12404 struct intel_crtc
*crtc
,
12405 struct intel_encoder
*encoder
)
12407 struct intel_encoder
*source_encoder
;
12408 struct drm_connector
*connector
;
12409 struct drm_connector_state
*connector_state
;
12412 for_each_connector_in_state(state
, connector
, connector_state
, i
) {
12413 if (connector_state
->crtc
!= &crtc
->base
)
12417 to_intel_encoder(connector_state
->best_encoder
);
12418 if (!encoders_cloneable(encoder
, source_encoder
))
12425 static int intel_crtc_atomic_check(struct drm_crtc
*crtc
,
12426 struct drm_crtc_state
*crtc_state
)
12428 struct drm_device
*dev
= crtc
->dev
;
12429 struct drm_i915_private
*dev_priv
= to_i915(dev
);
12430 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
12431 struct intel_crtc_state
*pipe_config
=
12432 to_intel_crtc_state(crtc_state
);
12433 struct drm_atomic_state
*state
= crtc_state
->state
;
12435 bool mode_changed
= needs_modeset(crtc_state
);
12437 if (mode_changed
&& !crtc_state
->active
)
12438 pipe_config
->update_wm_post
= true;
12440 if (mode_changed
&& crtc_state
->enable
&&
12441 dev_priv
->display
.crtc_compute_clock
&&
12442 !WARN_ON(pipe_config
->shared_dpll
)) {
12443 ret
= dev_priv
->display
.crtc_compute_clock(intel_crtc
,
12449 if (crtc_state
->color_mgmt_changed
) {
12450 ret
= intel_color_check(crtc
, crtc_state
);
12455 * Changing color management on Intel hardware is
12456 * handled as part of planes update.
12458 crtc_state
->planes_changed
= true;
12462 if (dev_priv
->display
.compute_pipe_wm
) {
12463 ret
= dev_priv
->display
.compute_pipe_wm(pipe_config
);
12465 DRM_DEBUG_KMS("Target pipe watermarks are invalid\n");
12470 if (dev_priv
->display
.compute_intermediate_wm
&&
12471 !to_intel_atomic_state(state
)->skip_intermediate_wm
) {
12472 if (WARN_ON(!dev_priv
->display
.compute_pipe_wm
))
12476 * Calculate 'intermediate' watermarks that satisfy both the
12477 * old state and the new state. We can program these
12480 ret
= dev_priv
->display
.compute_intermediate_wm(crtc
->dev
,
12484 DRM_DEBUG_KMS("No valid intermediate pipe watermarks are possible\n");
12487 } else if (dev_priv
->display
.compute_intermediate_wm
) {
12488 if (HAS_PCH_SPLIT(dev_priv
) && INTEL_GEN(dev_priv
) < 9)
12489 pipe_config
->wm
.ilk
.intermediate
= pipe_config
->wm
.ilk
.optimal
;
12492 if (INTEL_INFO(dev
)->gen
>= 9) {
12494 ret
= skl_update_scaler_crtc(pipe_config
);
12497 ret
= intel_atomic_setup_scalers(dev
, intel_crtc
,
12504 static const struct drm_crtc_helper_funcs intel_helper_funcs
= {
12505 .mode_set_base_atomic
= intel_pipe_set_base_atomic
,
12506 .atomic_begin
= intel_begin_crtc_commit
,
12507 .atomic_flush
= intel_finish_crtc_commit
,
12508 .atomic_check
= intel_crtc_atomic_check
,
12511 static void intel_modeset_update_connector_atomic_state(struct drm_device
*dev
)
12513 struct intel_connector
*connector
;
12515 for_each_intel_connector(dev
, connector
) {
12516 if (connector
->base
.state
->crtc
)
12517 drm_connector_unreference(&connector
->base
);
12519 if (connector
->base
.encoder
) {
12520 connector
->base
.state
->best_encoder
=
12521 connector
->base
.encoder
;
12522 connector
->base
.state
->crtc
=
12523 connector
->base
.encoder
->crtc
;
12525 drm_connector_reference(&connector
->base
);
12527 connector
->base
.state
->best_encoder
= NULL
;
12528 connector
->base
.state
->crtc
= NULL
;
12534 connected_sink_compute_bpp(struct intel_connector
*connector
,
12535 struct intel_crtc_state
*pipe_config
)
12537 int bpp
= pipe_config
->pipe_bpp
;
12539 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] checking for sink bpp constrains\n",
12540 connector
->base
.base
.id
,
12541 connector
->base
.name
);
12543 /* Don't use an invalid EDID bpc value */
12544 if (connector
->base
.display_info
.bpc
&&
12545 connector
->base
.display_info
.bpc
* 3 < bpp
) {
12546 DRM_DEBUG_KMS("clamping display bpp (was %d) to EDID reported max of %d\n",
12547 bpp
, connector
->base
.display_info
.bpc
*3);
12548 pipe_config
->pipe_bpp
= connector
->base
.display_info
.bpc
*3;
12551 /* Clamp bpp to 8 on screens without EDID 1.4 */
12552 if (connector
->base
.display_info
.bpc
== 0 && bpp
> 24) {
12553 DRM_DEBUG_KMS("clamping display bpp (was %d) to default limit of 24\n",
12555 pipe_config
->pipe_bpp
= 24;
12560 compute_baseline_pipe_bpp(struct intel_crtc
*crtc
,
12561 struct intel_crtc_state
*pipe_config
)
12563 struct drm_device
*dev
= crtc
->base
.dev
;
12564 struct drm_atomic_state
*state
;
12565 struct drm_connector
*connector
;
12566 struct drm_connector_state
*connector_state
;
12569 if ((IS_G4X(dev
) || IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
)))
12571 else if (INTEL_INFO(dev
)->gen
>= 5)
12577 pipe_config
->pipe_bpp
= bpp
;
12579 state
= pipe_config
->base
.state
;
12581 /* Clamp display bpp to EDID value */
12582 for_each_connector_in_state(state
, connector
, connector_state
, i
) {
12583 if (connector_state
->crtc
!= &crtc
->base
)
12586 connected_sink_compute_bpp(to_intel_connector(connector
),
12593 static void intel_dump_crtc_timings(const struct drm_display_mode
*mode
)
12595 DRM_DEBUG_KMS("crtc timings: %d %d %d %d %d %d %d %d %d, "
12596 "type: 0x%x flags: 0x%x\n",
12598 mode
->crtc_hdisplay
, mode
->crtc_hsync_start
,
12599 mode
->crtc_hsync_end
, mode
->crtc_htotal
,
12600 mode
->crtc_vdisplay
, mode
->crtc_vsync_start
,
12601 mode
->crtc_vsync_end
, mode
->crtc_vtotal
, mode
->type
, mode
->flags
);
12604 static void intel_dump_pipe_config(struct intel_crtc
*crtc
,
12605 struct intel_crtc_state
*pipe_config
,
12606 const char *context
)
12608 struct drm_device
*dev
= crtc
->base
.dev
;
12609 struct drm_plane
*plane
;
12610 struct intel_plane
*intel_plane
;
12611 struct intel_plane_state
*state
;
12612 struct drm_framebuffer
*fb
;
12614 DRM_DEBUG_KMS("[CRTC:%d:%s]%s config %p for pipe %c\n",
12615 crtc
->base
.base
.id
, crtc
->base
.name
,
12616 context
, pipe_config
, pipe_name(crtc
->pipe
));
12618 DRM_DEBUG_KMS("cpu_transcoder: %s\n", transcoder_name(pipe_config
->cpu_transcoder
));
12619 DRM_DEBUG_KMS("pipe bpp: %i, dithering: %i\n",
12620 pipe_config
->pipe_bpp
, pipe_config
->dither
);
12621 DRM_DEBUG_KMS("fdi/pch: %i, lanes: %i, gmch_m: %u, gmch_n: %u, link_m: %u, link_n: %u, tu: %u\n",
12622 pipe_config
->has_pch_encoder
,
12623 pipe_config
->fdi_lanes
,
12624 pipe_config
->fdi_m_n
.gmch_m
, pipe_config
->fdi_m_n
.gmch_n
,
12625 pipe_config
->fdi_m_n
.link_m
, pipe_config
->fdi_m_n
.link_n
,
12626 pipe_config
->fdi_m_n
.tu
);
12627 DRM_DEBUG_KMS("dp: %i, lanes: %i, gmch_m: %u, gmch_n: %u, link_m: %u, link_n: %u, tu: %u\n",
12628 intel_crtc_has_dp_encoder(pipe_config
),
12629 pipe_config
->lane_count
,
12630 pipe_config
->dp_m_n
.gmch_m
, pipe_config
->dp_m_n
.gmch_n
,
12631 pipe_config
->dp_m_n
.link_m
, pipe_config
->dp_m_n
.link_n
,
12632 pipe_config
->dp_m_n
.tu
);
12634 DRM_DEBUG_KMS("dp: %i, lanes: %i, gmch_m2: %u, gmch_n2: %u, link_m2: %u, link_n2: %u, tu2: %u\n",
12635 intel_crtc_has_dp_encoder(pipe_config
),
12636 pipe_config
->lane_count
,
12637 pipe_config
->dp_m2_n2
.gmch_m
,
12638 pipe_config
->dp_m2_n2
.gmch_n
,
12639 pipe_config
->dp_m2_n2
.link_m
,
12640 pipe_config
->dp_m2_n2
.link_n
,
12641 pipe_config
->dp_m2_n2
.tu
);
12643 DRM_DEBUG_KMS("audio: %i, infoframes: %i\n",
12644 pipe_config
->has_audio
,
12645 pipe_config
->has_infoframe
);
12647 DRM_DEBUG_KMS("requested mode:\n");
12648 drm_mode_debug_printmodeline(&pipe_config
->base
.mode
);
12649 DRM_DEBUG_KMS("adjusted mode:\n");
12650 drm_mode_debug_printmodeline(&pipe_config
->base
.adjusted_mode
);
12651 intel_dump_crtc_timings(&pipe_config
->base
.adjusted_mode
);
12652 DRM_DEBUG_KMS("port clock: %d\n", pipe_config
->port_clock
);
12653 DRM_DEBUG_KMS("pipe src size: %dx%d\n",
12654 pipe_config
->pipe_src_w
, pipe_config
->pipe_src_h
);
12655 DRM_DEBUG_KMS("num_scalers: %d, scaler_users: 0x%x, scaler_id: %d\n",
12657 pipe_config
->scaler_state
.scaler_users
,
12658 pipe_config
->scaler_state
.scaler_id
);
12659 DRM_DEBUG_KMS("gmch pfit: control: 0x%08x, ratios: 0x%08x, lvds border: 0x%08x\n",
12660 pipe_config
->gmch_pfit
.control
,
12661 pipe_config
->gmch_pfit
.pgm_ratios
,
12662 pipe_config
->gmch_pfit
.lvds_border_bits
);
12663 DRM_DEBUG_KMS("pch pfit: pos: 0x%08x, size: 0x%08x, %s\n",
12664 pipe_config
->pch_pfit
.pos
,
12665 pipe_config
->pch_pfit
.size
,
12666 pipe_config
->pch_pfit
.enabled
? "enabled" : "disabled");
12667 DRM_DEBUG_KMS("ips: %i\n", pipe_config
->ips_enabled
);
12668 DRM_DEBUG_KMS("double wide: %i\n", pipe_config
->double_wide
);
12670 if (IS_BROXTON(dev
)) {
12671 DRM_DEBUG_KMS("ddi_pll_sel: %u; dpll_hw_state: ebb0: 0x%x, ebb4: 0x%x,"
12672 "pll0: 0x%x, pll1: 0x%x, pll2: 0x%x, pll3: 0x%x, "
12673 "pll6: 0x%x, pll8: 0x%x, pll9: 0x%x, pll10: 0x%x, pcsdw12: 0x%x\n",
12674 pipe_config
->ddi_pll_sel
,
12675 pipe_config
->dpll_hw_state
.ebb0
,
12676 pipe_config
->dpll_hw_state
.ebb4
,
12677 pipe_config
->dpll_hw_state
.pll0
,
12678 pipe_config
->dpll_hw_state
.pll1
,
12679 pipe_config
->dpll_hw_state
.pll2
,
12680 pipe_config
->dpll_hw_state
.pll3
,
12681 pipe_config
->dpll_hw_state
.pll6
,
12682 pipe_config
->dpll_hw_state
.pll8
,
12683 pipe_config
->dpll_hw_state
.pll9
,
12684 pipe_config
->dpll_hw_state
.pll10
,
12685 pipe_config
->dpll_hw_state
.pcsdw12
);
12686 } else if (IS_SKYLAKE(dev
) || IS_KABYLAKE(dev
)) {
12687 DRM_DEBUG_KMS("ddi_pll_sel: %u; dpll_hw_state: "
12688 "ctrl1: 0x%x, cfgcr1: 0x%x, cfgcr2: 0x%x\n",
12689 pipe_config
->ddi_pll_sel
,
12690 pipe_config
->dpll_hw_state
.ctrl1
,
12691 pipe_config
->dpll_hw_state
.cfgcr1
,
12692 pipe_config
->dpll_hw_state
.cfgcr2
);
12693 } else if (HAS_DDI(dev
)) {
12694 DRM_DEBUG_KMS("ddi_pll_sel: 0x%x; dpll_hw_state: wrpll: 0x%x spll: 0x%x\n",
12695 pipe_config
->ddi_pll_sel
,
12696 pipe_config
->dpll_hw_state
.wrpll
,
12697 pipe_config
->dpll_hw_state
.spll
);
12699 DRM_DEBUG_KMS("dpll_hw_state: dpll: 0x%x, dpll_md: 0x%x, "
12700 "fp0: 0x%x, fp1: 0x%x\n",
12701 pipe_config
->dpll_hw_state
.dpll
,
12702 pipe_config
->dpll_hw_state
.dpll_md
,
12703 pipe_config
->dpll_hw_state
.fp0
,
12704 pipe_config
->dpll_hw_state
.fp1
);
12707 DRM_DEBUG_KMS("planes on this crtc\n");
12708 list_for_each_entry(plane
, &dev
->mode_config
.plane_list
, head
) {
12709 intel_plane
= to_intel_plane(plane
);
12710 if (intel_plane
->pipe
!= crtc
->pipe
)
12713 state
= to_intel_plane_state(plane
->state
);
12714 fb
= state
->base
.fb
;
12716 DRM_DEBUG_KMS("[PLANE:%d:%s] disabled, scaler_id = %d\n",
12717 plane
->base
.id
, plane
->name
, state
->scaler_id
);
12721 DRM_DEBUG_KMS("[PLANE:%d:%s] enabled",
12722 plane
->base
.id
, plane
->name
);
12723 DRM_DEBUG_KMS("\tFB:%d, fb = %ux%u format = %s",
12724 fb
->base
.id
, fb
->width
, fb
->height
,
12725 drm_get_format_name(fb
->pixel_format
));
12726 DRM_DEBUG_KMS("\tscaler:%d src %dx%d+%d+%d dst %dx%d+%d+%d\n",
12728 state
->base
.src
.x1
>> 16,
12729 state
->base
.src
.y1
>> 16,
12730 drm_rect_width(&state
->base
.src
) >> 16,
12731 drm_rect_height(&state
->base
.src
) >> 16,
12732 state
->base
.dst
.x1
, state
->base
.dst
.y1
,
12733 drm_rect_width(&state
->base
.dst
),
12734 drm_rect_height(&state
->base
.dst
));
12738 static bool check_digital_port_conflicts(struct drm_atomic_state
*state
)
12740 struct drm_device
*dev
= state
->dev
;
12741 struct drm_connector
*connector
;
12742 unsigned int used_ports
= 0;
12743 unsigned int used_mst_ports
= 0;
12746 * Walk the connector list instead of the encoder
12747 * list to detect the problem on ddi platforms
12748 * where there's just one encoder per digital port.
12750 drm_for_each_connector(connector
, dev
) {
12751 struct drm_connector_state
*connector_state
;
12752 struct intel_encoder
*encoder
;
12754 connector_state
= drm_atomic_get_existing_connector_state(state
, connector
);
12755 if (!connector_state
)
12756 connector_state
= connector
->state
;
12758 if (!connector_state
->best_encoder
)
12761 encoder
= to_intel_encoder(connector_state
->best_encoder
);
12763 WARN_ON(!connector_state
->crtc
);
12765 switch (encoder
->type
) {
12766 unsigned int port_mask
;
12767 case INTEL_OUTPUT_UNKNOWN
:
12768 if (WARN_ON(!HAS_DDI(dev
)))
12770 case INTEL_OUTPUT_DP
:
12771 case INTEL_OUTPUT_HDMI
:
12772 case INTEL_OUTPUT_EDP
:
12773 port_mask
= 1 << enc_to_dig_port(&encoder
->base
)->port
;
12775 /* the same port mustn't appear more than once */
12776 if (used_ports
& port_mask
)
12779 used_ports
|= port_mask
;
12781 case INTEL_OUTPUT_DP_MST
:
12783 1 << enc_to_mst(&encoder
->base
)->primary
->port
;
12790 /* can't mix MST and SST/HDMI on the same port */
12791 if (used_ports
& used_mst_ports
)
12798 clear_intel_crtc_state(struct intel_crtc_state
*crtc_state
)
12800 struct drm_crtc_state tmp_state
;
12801 struct intel_crtc_scaler_state scaler_state
;
12802 struct intel_dpll_hw_state dpll_hw_state
;
12803 struct intel_shared_dpll
*shared_dpll
;
12804 uint32_t ddi_pll_sel
;
12807 /* FIXME: before the switch to atomic started, a new pipe_config was
12808 * kzalloc'd. Code that depends on any field being zero should be
12809 * fixed, so that the crtc_state can be safely duplicated. For now,
12810 * only fields that are know to not cause problems are preserved. */
12812 tmp_state
= crtc_state
->base
;
12813 scaler_state
= crtc_state
->scaler_state
;
12814 shared_dpll
= crtc_state
->shared_dpll
;
12815 dpll_hw_state
= crtc_state
->dpll_hw_state
;
12816 ddi_pll_sel
= crtc_state
->ddi_pll_sel
;
12817 force_thru
= crtc_state
->pch_pfit
.force_thru
;
12819 memset(crtc_state
, 0, sizeof *crtc_state
);
12821 crtc_state
->base
= tmp_state
;
12822 crtc_state
->scaler_state
= scaler_state
;
12823 crtc_state
->shared_dpll
= shared_dpll
;
12824 crtc_state
->dpll_hw_state
= dpll_hw_state
;
12825 crtc_state
->ddi_pll_sel
= ddi_pll_sel
;
12826 crtc_state
->pch_pfit
.force_thru
= force_thru
;
12830 intel_modeset_pipe_config(struct drm_crtc
*crtc
,
12831 struct intel_crtc_state
*pipe_config
)
12833 struct drm_atomic_state
*state
= pipe_config
->base
.state
;
12834 struct intel_encoder
*encoder
;
12835 struct drm_connector
*connector
;
12836 struct drm_connector_state
*connector_state
;
12837 int base_bpp
, ret
= -EINVAL
;
12841 clear_intel_crtc_state(pipe_config
);
12843 pipe_config
->cpu_transcoder
=
12844 (enum transcoder
) to_intel_crtc(crtc
)->pipe
;
12847 * Sanitize sync polarity flags based on requested ones. If neither
12848 * positive or negative polarity is requested, treat this as meaning
12849 * negative polarity.
12851 if (!(pipe_config
->base
.adjusted_mode
.flags
&
12852 (DRM_MODE_FLAG_PHSYNC
| DRM_MODE_FLAG_NHSYNC
)))
12853 pipe_config
->base
.adjusted_mode
.flags
|= DRM_MODE_FLAG_NHSYNC
;
12855 if (!(pipe_config
->base
.adjusted_mode
.flags
&
12856 (DRM_MODE_FLAG_PVSYNC
| DRM_MODE_FLAG_NVSYNC
)))
12857 pipe_config
->base
.adjusted_mode
.flags
|= DRM_MODE_FLAG_NVSYNC
;
12859 base_bpp
= compute_baseline_pipe_bpp(to_intel_crtc(crtc
),
12865 * Determine the real pipe dimensions. Note that stereo modes can
12866 * increase the actual pipe size due to the frame doubling and
12867 * insertion of additional space for blanks between the frame. This
12868 * is stored in the crtc timings. We use the requested mode to do this
12869 * computation to clearly distinguish it from the adjusted mode, which
12870 * can be changed by the connectors in the below retry loop.
12872 drm_crtc_get_hv_timing(&pipe_config
->base
.mode
,
12873 &pipe_config
->pipe_src_w
,
12874 &pipe_config
->pipe_src_h
);
12876 for_each_connector_in_state(state
, connector
, connector_state
, i
) {
12877 if (connector_state
->crtc
!= crtc
)
12880 encoder
= to_intel_encoder(connector_state
->best_encoder
);
12882 if (!check_single_encoder_cloning(state
, to_intel_crtc(crtc
), encoder
)) {
12883 DRM_DEBUG_KMS("rejecting invalid cloning configuration\n");
12888 * Determine output_types before calling the .compute_config()
12889 * hooks so that the hooks can use this information safely.
12891 pipe_config
->output_types
|= 1 << encoder
->type
;
12895 /* Ensure the port clock defaults are reset when retrying. */
12896 pipe_config
->port_clock
= 0;
12897 pipe_config
->pixel_multiplier
= 1;
12899 /* Fill in default crtc timings, allow encoders to overwrite them. */
12900 drm_mode_set_crtcinfo(&pipe_config
->base
.adjusted_mode
,
12901 CRTC_STEREO_DOUBLE
);
12903 /* Pass our mode to the connectors and the CRTC to give them a chance to
12904 * adjust it according to limitations or connector properties, and also
12905 * a chance to reject the mode entirely.
12907 for_each_connector_in_state(state
, connector
, connector_state
, i
) {
12908 if (connector_state
->crtc
!= crtc
)
12911 encoder
= to_intel_encoder(connector_state
->best_encoder
);
12913 if (!(encoder
->compute_config(encoder
, pipe_config
))) {
12914 DRM_DEBUG_KMS("Encoder config failure\n");
12919 /* Set default port clock if not overwritten by the encoder. Needs to be
12920 * done afterwards in case the encoder adjusts the mode. */
12921 if (!pipe_config
->port_clock
)
12922 pipe_config
->port_clock
= pipe_config
->base
.adjusted_mode
.crtc_clock
12923 * pipe_config
->pixel_multiplier
;
12925 ret
= intel_crtc_compute_config(to_intel_crtc(crtc
), pipe_config
);
12927 DRM_DEBUG_KMS("CRTC fixup failed\n");
12931 if (ret
== RETRY
) {
12932 if (WARN(!retry
, "loop in pipe configuration computation\n")) {
12937 DRM_DEBUG_KMS("CRTC bw constrained, retrying\n");
12939 goto encoder_retry
;
12942 /* Dithering seems to not pass-through bits correctly when it should, so
12943 * only enable it on 6bpc panels. */
12944 pipe_config
->dither
= pipe_config
->pipe_bpp
== 6*3;
12945 DRM_DEBUG_KMS("hw max bpp: %i, pipe bpp: %i, dithering: %i\n",
12946 base_bpp
, pipe_config
->pipe_bpp
, pipe_config
->dither
);
12953 intel_modeset_update_crtc_state(struct drm_atomic_state
*state
)
12955 struct drm_crtc
*crtc
;
12956 struct drm_crtc_state
*crtc_state
;
12959 /* Double check state. */
12960 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
12961 to_intel_crtc(crtc
)->config
= to_intel_crtc_state(crtc
->state
);
12963 /* Update hwmode for vblank functions */
12964 if (crtc
->state
->active
)
12965 crtc
->hwmode
= crtc
->state
->adjusted_mode
;
12967 crtc
->hwmode
.crtc_clock
= 0;
12970 * Update legacy state to satisfy fbc code. This can
12971 * be removed when fbc uses the atomic state.
12973 if (drm_atomic_get_existing_plane_state(state
, crtc
->primary
)) {
12974 struct drm_plane_state
*plane_state
= crtc
->primary
->state
;
12976 crtc
->primary
->fb
= plane_state
->fb
;
12977 crtc
->x
= plane_state
->src_x
>> 16;
12978 crtc
->y
= plane_state
->src_y
>> 16;
12983 static bool intel_fuzzy_clock_check(int clock1
, int clock2
)
12987 if (clock1
== clock2
)
12990 if (!clock1
|| !clock2
)
12993 diff
= abs(clock1
- clock2
);
12995 if (((((diff
+ clock1
+ clock2
) * 100)) / (clock1
+ clock2
)) < 105)
13001 #define for_each_intel_crtc_masked(dev, mask, intel_crtc) \
13002 list_for_each_entry((intel_crtc), \
13003 &(dev)->mode_config.crtc_list, \
13005 for_each_if (mask & (1 <<(intel_crtc)->pipe))
13008 intel_compare_m_n(unsigned int m
, unsigned int n
,
13009 unsigned int m2
, unsigned int n2
,
13012 if (m
== m2
&& n
== n2
)
13015 if (exact
|| !m
|| !n
|| !m2
|| !n2
)
13018 BUILD_BUG_ON(DATA_LINK_M_N_MASK
> INT_MAX
);
13025 } else if (n
< n2
) {
13035 return intel_fuzzy_clock_check(m
, m2
);
13039 intel_compare_link_m_n(const struct intel_link_m_n
*m_n
,
13040 struct intel_link_m_n
*m2_n2
,
13043 if (m_n
->tu
== m2_n2
->tu
&&
13044 intel_compare_m_n(m_n
->gmch_m
, m_n
->gmch_n
,
13045 m2_n2
->gmch_m
, m2_n2
->gmch_n
, !adjust
) &&
13046 intel_compare_m_n(m_n
->link_m
, m_n
->link_n
,
13047 m2_n2
->link_m
, m2_n2
->link_n
, !adjust
)) {
13058 intel_pipe_config_compare(struct drm_device
*dev
,
13059 struct intel_crtc_state
*current_config
,
13060 struct intel_crtc_state
*pipe_config
,
13065 #define INTEL_ERR_OR_DBG_KMS(fmt, ...) \
13068 DRM_ERROR(fmt, ##__VA_ARGS__); \
13070 DRM_DEBUG_KMS(fmt, ##__VA_ARGS__); \
13073 #define PIPE_CONF_CHECK_X(name) \
13074 if (current_config->name != pipe_config->name) { \
13075 INTEL_ERR_OR_DBG_KMS("mismatch in " #name " " \
13076 "(expected 0x%08x, found 0x%08x)\n", \
13077 current_config->name, \
13078 pipe_config->name); \
13082 #define PIPE_CONF_CHECK_I(name) \
13083 if (current_config->name != pipe_config->name) { \
13084 INTEL_ERR_OR_DBG_KMS("mismatch in " #name " " \
13085 "(expected %i, found %i)\n", \
13086 current_config->name, \
13087 pipe_config->name); \
13091 #define PIPE_CONF_CHECK_P(name) \
13092 if (current_config->name != pipe_config->name) { \
13093 INTEL_ERR_OR_DBG_KMS("mismatch in " #name " " \
13094 "(expected %p, found %p)\n", \
13095 current_config->name, \
13096 pipe_config->name); \
13100 #define PIPE_CONF_CHECK_M_N(name) \
13101 if (!intel_compare_link_m_n(¤t_config->name, \
13102 &pipe_config->name,\
13104 INTEL_ERR_OR_DBG_KMS("mismatch in " #name " " \
13105 "(expected tu %i gmch %i/%i link %i/%i, " \
13106 "found tu %i, gmch %i/%i link %i/%i)\n", \
13107 current_config->name.tu, \
13108 current_config->name.gmch_m, \
13109 current_config->name.gmch_n, \
13110 current_config->name.link_m, \
13111 current_config->name.link_n, \
13112 pipe_config->name.tu, \
13113 pipe_config->name.gmch_m, \
13114 pipe_config->name.gmch_n, \
13115 pipe_config->name.link_m, \
13116 pipe_config->name.link_n); \
13120 /* This is required for BDW+ where there is only one set of registers for
13121 * switching between high and low RR.
13122 * This macro can be used whenever a comparison has to be made between one
13123 * hw state and multiple sw state variables.
13125 #define PIPE_CONF_CHECK_M_N_ALT(name, alt_name) \
13126 if (!intel_compare_link_m_n(¤t_config->name, \
13127 &pipe_config->name, adjust) && \
13128 !intel_compare_link_m_n(¤t_config->alt_name, \
13129 &pipe_config->name, adjust)) { \
13130 INTEL_ERR_OR_DBG_KMS("mismatch in " #name " " \
13131 "(expected tu %i gmch %i/%i link %i/%i, " \
13132 "or tu %i gmch %i/%i link %i/%i, " \
13133 "found tu %i, gmch %i/%i link %i/%i)\n", \
13134 current_config->name.tu, \
13135 current_config->name.gmch_m, \
13136 current_config->name.gmch_n, \
13137 current_config->name.link_m, \
13138 current_config->name.link_n, \
13139 current_config->alt_name.tu, \
13140 current_config->alt_name.gmch_m, \
13141 current_config->alt_name.gmch_n, \
13142 current_config->alt_name.link_m, \
13143 current_config->alt_name.link_n, \
13144 pipe_config->name.tu, \
13145 pipe_config->name.gmch_m, \
13146 pipe_config->name.gmch_n, \
13147 pipe_config->name.link_m, \
13148 pipe_config->name.link_n); \
13152 #define PIPE_CONF_CHECK_FLAGS(name, mask) \
13153 if ((current_config->name ^ pipe_config->name) & (mask)) { \
13154 INTEL_ERR_OR_DBG_KMS("mismatch in " #name "(" #mask ") " \
13155 "(expected %i, found %i)\n", \
13156 current_config->name & (mask), \
13157 pipe_config->name & (mask)); \
13161 #define PIPE_CONF_CHECK_CLOCK_FUZZY(name) \
13162 if (!intel_fuzzy_clock_check(current_config->name, pipe_config->name)) { \
13163 INTEL_ERR_OR_DBG_KMS("mismatch in " #name " " \
13164 "(expected %i, found %i)\n", \
13165 current_config->name, \
13166 pipe_config->name); \
13170 #define PIPE_CONF_QUIRK(quirk) \
13171 ((current_config->quirks | pipe_config->quirks) & (quirk))
13173 PIPE_CONF_CHECK_I(cpu_transcoder
);
13175 PIPE_CONF_CHECK_I(has_pch_encoder
);
13176 PIPE_CONF_CHECK_I(fdi_lanes
);
13177 PIPE_CONF_CHECK_M_N(fdi_m_n
);
13179 PIPE_CONF_CHECK_I(lane_count
);
13180 PIPE_CONF_CHECK_X(lane_lat_optim_mask
);
13182 if (INTEL_INFO(dev
)->gen
< 8) {
13183 PIPE_CONF_CHECK_M_N(dp_m_n
);
13185 if (current_config
->has_drrs
)
13186 PIPE_CONF_CHECK_M_N(dp_m2_n2
);
13188 PIPE_CONF_CHECK_M_N_ALT(dp_m_n
, dp_m2_n2
);
13190 PIPE_CONF_CHECK_X(output_types
);
13192 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_hdisplay
);
13193 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_htotal
);
13194 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_hblank_start
);
13195 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_hblank_end
);
13196 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_hsync_start
);
13197 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_hsync_end
);
13199 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_vdisplay
);
13200 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_vtotal
);
13201 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_vblank_start
);
13202 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_vblank_end
);
13203 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_vsync_start
);
13204 PIPE_CONF_CHECK_I(base
.adjusted_mode
.crtc_vsync_end
);
13206 PIPE_CONF_CHECK_I(pixel_multiplier
);
13207 PIPE_CONF_CHECK_I(has_hdmi_sink
);
13208 if ((INTEL_INFO(dev
)->gen
< 8 && !IS_HASWELL(dev
)) ||
13209 IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
))
13210 PIPE_CONF_CHECK_I(limited_color_range
);
13211 PIPE_CONF_CHECK_I(has_infoframe
);
13213 PIPE_CONF_CHECK_I(has_audio
);
13215 PIPE_CONF_CHECK_FLAGS(base
.adjusted_mode
.flags
,
13216 DRM_MODE_FLAG_INTERLACE
);
13218 if (!PIPE_CONF_QUIRK(PIPE_CONFIG_QUIRK_MODE_SYNC_FLAGS
)) {
13219 PIPE_CONF_CHECK_FLAGS(base
.adjusted_mode
.flags
,
13220 DRM_MODE_FLAG_PHSYNC
);
13221 PIPE_CONF_CHECK_FLAGS(base
.adjusted_mode
.flags
,
13222 DRM_MODE_FLAG_NHSYNC
);
13223 PIPE_CONF_CHECK_FLAGS(base
.adjusted_mode
.flags
,
13224 DRM_MODE_FLAG_PVSYNC
);
13225 PIPE_CONF_CHECK_FLAGS(base
.adjusted_mode
.flags
,
13226 DRM_MODE_FLAG_NVSYNC
);
13229 PIPE_CONF_CHECK_X(gmch_pfit
.control
);
13230 /* pfit ratios are autocomputed by the hw on gen4+ */
13231 if (INTEL_INFO(dev
)->gen
< 4)
13232 PIPE_CONF_CHECK_X(gmch_pfit
.pgm_ratios
);
13233 PIPE_CONF_CHECK_X(gmch_pfit
.lvds_border_bits
);
13236 PIPE_CONF_CHECK_I(pipe_src_w
);
13237 PIPE_CONF_CHECK_I(pipe_src_h
);
13239 PIPE_CONF_CHECK_I(pch_pfit
.enabled
);
13240 if (current_config
->pch_pfit
.enabled
) {
13241 PIPE_CONF_CHECK_X(pch_pfit
.pos
);
13242 PIPE_CONF_CHECK_X(pch_pfit
.size
);
13245 PIPE_CONF_CHECK_I(scaler_state
.scaler_id
);
13248 /* BDW+ don't expose a synchronous way to read the state */
13249 if (IS_HASWELL(dev
))
13250 PIPE_CONF_CHECK_I(ips_enabled
);
13252 PIPE_CONF_CHECK_I(double_wide
);
13254 PIPE_CONF_CHECK_X(ddi_pll_sel
);
13256 PIPE_CONF_CHECK_P(shared_dpll
);
13257 PIPE_CONF_CHECK_X(dpll_hw_state
.dpll
);
13258 PIPE_CONF_CHECK_X(dpll_hw_state
.dpll_md
);
13259 PIPE_CONF_CHECK_X(dpll_hw_state
.fp0
);
13260 PIPE_CONF_CHECK_X(dpll_hw_state
.fp1
);
13261 PIPE_CONF_CHECK_X(dpll_hw_state
.wrpll
);
13262 PIPE_CONF_CHECK_X(dpll_hw_state
.spll
);
13263 PIPE_CONF_CHECK_X(dpll_hw_state
.ctrl1
);
13264 PIPE_CONF_CHECK_X(dpll_hw_state
.cfgcr1
);
13265 PIPE_CONF_CHECK_X(dpll_hw_state
.cfgcr2
);
13267 PIPE_CONF_CHECK_X(dsi_pll
.ctrl
);
13268 PIPE_CONF_CHECK_X(dsi_pll
.div
);
13270 if (IS_G4X(dev
) || INTEL_INFO(dev
)->gen
>= 5)
13271 PIPE_CONF_CHECK_I(pipe_bpp
);
13273 PIPE_CONF_CHECK_CLOCK_FUZZY(base
.adjusted_mode
.crtc_clock
);
13274 PIPE_CONF_CHECK_CLOCK_FUZZY(port_clock
);
13276 #undef PIPE_CONF_CHECK_X
13277 #undef PIPE_CONF_CHECK_I
13278 #undef PIPE_CONF_CHECK_P
13279 #undef PIPE_CONF_CHECK_FLAGS
13280 #undef PIPE_CONF_CHECK_CLOCK_FUZZY
13281 #undef PIPE_CONF_QUIRK
13282 #undef INTEL_ERR_OR_DBG_KMS
13287 static void intel_pipe_config_sanity_check(struct drm_i915_private
*dev_priv
,
13288 const struct intel_crtc_state
*pipe_config
)
13290 if (pipe_config
->has_pch_encoder
) {
13291 int fdi_dotclock
= intel_dotclock_calculate(intel_fdi_link_freq(dev_priv
, pipe_config
),
13292 &pipe_config
->fdi_m_n
);
13293 int dotclock
= pipe_config
->base
.adjusted_mode
.crtc_clock
;
13296 * FDI already provided one idea for the dotclock.
13297 * Yell if the encoder disagrees.
13299 WARN(!intel_fuzzy_clock_check(fdi_dotclock
, dotclock
),
13300 "FDI dotclock and encoder dotclock mismatch, fdi: %i, encoder: %i\n",
13301 fdi_dotclock
, dotclock
);
13305 static void verify_wm_state(struct drm_crtc
*crtc
,
13306 struct drm_crtc_state
*new_state
)
13308 struct drm_device
*dev
= crtc
->dev
;
13309 struct drm_i915_private
*dev_priv
= to_i915(dev
);
13310 struct skl_ddb_allocation hw_ddb
, *sw_ddb
;
13311 struct skl_ddb_entry
*hw_entry
, *sw_entry
;
13312 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
13313 const enum pipe pipe
= intel_crtc
->pipe
;
13316 if (INTEL_INFO(dev
)->gen
< 9 || !new_state
->active
)
13319 skl_ddb_get_hw_state(dev_priv
, &hw_ddb
);
13320 sw_ddb
= &dev_priv
->wm
.skl_hw
.ddb
;
13323 for_each_plane(dev_priv
, pipe
, plane
) {
13324 hw_entry
= &hw_ddb
.plane
[pipe
][plane
];
13325 sw_entry
= &sw_ddb
->plane
[pipe
][plane
];
13327 if (skl_ddb_entry_equal(hw_entry
, sw_entry
))
13330 DRM_ERROR("mismatch in DDB state pipe %c plane %d "
13331 "(expected (%u,%u), found (%u,%u))\n",
13332 pipe_name(pipe
), plane
+ 1,
13333 sw_entry
->start
, sw_entry
->end
,
13334 hw_entry
->start
, hw_entry
->end
);
13338 hw_entry
= &hw_ddb
.plane
[pipe
][PLANE_CURSOR
];
13339 sw_entry
= &sw_ddb
->plane
[pipe
][PLANE_CURSOR
];
13341 if (!skl_ddb_entry_equal(hw_entry
, sw_entry
)) {
13342 DRM_ERROR("mismatch in DDB state pipe %c cursor "
13343 "(expected (%u,%u), found (%u,%u))\n",
13345 sw_entry
->start
, sw_entry
->end
,
13346 hw_entry
->start
, hw_entry
->end
);
13351 verify_connector_state(struct drm_device
*dev
, struct drm_crtc
*crtc
)
13353 struct drm_connector
*connector
;
13355 drm_for_each_connector(connector
, dev
) {
13356 struct drm_encoder
*encoder
= connector
->encoder
;
13357 struct drm_connector_state
*state
= connector
->state
;
13359 if (state
->crtc
!= crtc
)
13362 intel_connector_verify_state(to_intel_connector(connector
));
13364 I915_STATE_WARN(state
->best_encoder
!= encoder
,
13365 "connector's atomic encoder doesn't match legacy encoder\n");
13370 verify_encoder_state(struct drm_device
*dev
)
13372 struct intel_encoder
*encoder
;
13373 struct intel_connector
*connector
;
13375 for_each_intel_encoder(dev
, encoder
) {
13376 bool enabled
= false;
13379 DRM_DEBUG_KMS("[ENCODER:%d:%s]\n",
13380 encoder
->base
.base
.id
,
13381 encoder
->base
.name
);
13383 for_each_intel_connector(dev
, connector
) {
13384 if (connector
->base
.state
->best_encoder
!= &encoder
->base
)
13388 I915_STATE_WARN(connector
->base
.state
->crtc
!=
13389 encoder
->base
.crtc
,
13390 "connector's crtc doesn't match encoder crtc\n");
13393 I915_STATE_WARN(!!encoder
->base
.crtc
!= enabled
,
13394 "encoder's enabled state mismatch "
13395 "(expected %i, found %i)\n",
13396 !!encoder
->base
.crtc
, enabled
);
13398 if (!encoder
->base
.crtc
) {
13401 active
= encoder
->get_hw_state(encoder
, &pipe
);
13402 I915_STATE_WARN(active
,
13403 "encoder detached but still enabled on pipe %c.\n",
13410 verify_crtc_state(struct drm_crtc
*crtc
,
13411 struct drm_crtc_state
*old_crtc_state
,
13412 struct drm_crtc_state
*new_crtc_state
)
13414 struct drm_device
*dev
= crtc
->dev
;
13415 struct drm_i915_private
*dev_priv
= to_i915(dev
);
13416 struct intel_encoder
*encoder
;
13417 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
13418 struct intel_crtc_state
*pipe_config
, *sw_config
;
13419 struct drm_atomic_state
*old_state
;
13422 old_state
= old_crtc_state
->state
;
13423 __drm_atomic_helper_crtc_destroy_state(old_crtc_state
);
13424 pipe_config
= to_intel_crtc_state(old_crtc_state
);
13425 memset(pipe_config
, 0, sizeof(*pipe_config
));
13426 pipe_config
->base
.crtc
= crtc
;
13427 pipe_config
->base
.state
= old_state
;
13429 DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc
->base
.id
, crtc
->name
);
13431 active
= dev_priv
->display
.get_pipe_config(intel_crtc
, pipe_config
);
13433 /* hw state is inconsistent with the pipe quirk */
13434 if ((intel_crtc
->pipe
== PIPE_A
&& dev_priv
->quirks
& QUIRK_PIPEA_FORCE
) ||
13435 (intel_crtc
->pipe
== PIPE_B
&& dev_priv
->quirks
& QUIRK_PIPEB_FORCE
))
13436 active
= new_crtc_state
->active
;
13438 I915_STATE_WARN(new_crtc_state
->active
!= active
,
13439 "crtc active state doesn't match with hw state "
13440 "(expected %i, found %i)\n", new_crtc_state
->active
, active
);
13442 I915_STATE_WARN(intel_crtc
->active
!= new_crtc_state
->active
,
13443 "transitional active state does not match atomic hw state "
13444 "(expected %i, found %i)\n", new_crtc_state
->active
, intel_crtc
->active
);
13446 for_each_encoder_on_crtc(dev
, crtc
, encoder
) {
13449 active
= encoder
->get_hw_state(encoder
, &pipe
);
13450 I915_STATE_WARN(active
!= new_crtc_state
->active
,
13451 "[ENCODER:%i] active %i with crtc active %i\n",
13452 encoder
->base
.base
.id
, active
, new_crtc_state
->active
);
13454 I915_STATE_WARN(active
&& intel_crtc
->pipe
!= pipe
,
13455 "Encoder connected to wrong pipe %c\n",
13459 pipe_config
->output_types
|= 1 << encoder
->type
;
13460 encoder
->get_config(encoder
, pipe_config
);
13464 if (!new_crtc_state
->active
)
13467 intel_pipe_config_sanity_check(dev_priv
, pipe_config
);
13469 sw_config
= to_intel_crtc_state(crtc
->state
);
13470 if (!intel_pipe_config_compare(dev
, sw_config
,
13471 pipe_config
, false)) {
13472 I915_STATE_WARN(1, "pipe state doesn't match!\n");
13473 intel_dump_pipe_config(intel_crtc
, pipe_config
,
13475 intel_dump_pipe_config(intel_crtc
, sw_config
,
13481 verify_single_dpll_state(struct drm_i915_private
*dev_priv
,
13482 struct intel_shared_dpll
*pll
,
13483 struct drm_crtc
*crtc
,
13484 struct drm_crtc_state
*new_state
)
13486 struct intel_dpll_hw_state dpll_hw_state
;
13487 unsigned crtc_mask
;
13490 memset(&dpll_hw_state
, 0, sizeof(dpll_hw_state
));
13492 DRM_DEBUG_KMS("%s\n", pll
->name
);
13494 active
= pll
->funcs
.get_hw_state(dev_priv
, pll
, &dpll_hw_state
);
13496 if (!(pll
->flags
& INTEL_DPLL_ALWAYS_ON
)) {
13497 I915_STATE_WARN(!pll
->on
&& pll
->active_mask
,
13498 "pll in active use but not on in sw tracking\n");
13499 I915_STATE_WARN(pll
->on
&& !pll
->active_mask
,
13500 "pll is on but not used by any active crtc\n");
13501 I915_STATE_WARN(pll
->on
!= active
,
13502 "pll on state mismatch (expected %i, found %i)\n",
13507 I915_STATE_WARN(pll
->active_mask
& ~pll
->config
.crtc_mask
,
13508 "more active pll users than references: %x vs %x\n",
13509 pll
->active_mask
, pll
->config
.crtc_mask
);
13514 crtc_mask
= 1 << drm_crtc_index(crtc
);
13516 if (new_state
->active
)
13517 I915_STATE_WARN(!(pll
->active_mask
& crtc_mask
),
13518 "pll active mismatch (expected pipe %c in active mask 0x%02x)\n",
13519 pipe_name(drm_crtc_index(crtc
)), pll
->active_mask
);
13521 I915_STATE_WARN(pll
->active_mask
& crtc_mask
,
13522 "pll active mismatch (didn't expect pipe %c in active mask 0x%02x)\n",
13523 pipe_name(drm_crtc_index(crtc
)), pll
->active_mask
);
13525 I915_STATE_WARN(!(pll
->config
.crtc_mask
& crtc_mask
),
13526 "pll enabled crtcs mismatch (expected 0x%x in 0x%02x)\n",
13527 crtc_mask
, pll
->config
.crtc_mask
);
13529 I915_STATE_WARN(pll
->on
&& memcmp(&pll
->config
.hw_state
,
13531 sizeof(dpll_hw_state
)),
13532 "pll hw state mismatch\n");
13536 verify_shared_dpll_state(struct drm_device
*dev
, struct drm_crtc
*crtc
,
13537 struct drm_crtc_state
*old_crtc_state
,
13538 struct drm_crtc_state
*new_crtc_state
)
13540 struct drm_i915_private
*dev_priv
= to_i915(dev
);
13541 struct intel_crtc_state
*old_state
= to_intel_crtc_state(old_crtc_state
);
13542 struct intel_crtc_state
*new_state
= to_intel_crtc_state(new_crtc_state
);
13544 if (new_state
->shared_dpll
)
13545 verify_single_dpll_state(dev_priv
, new_state
->shared_dpll
, crtc
, new_crtc_state
);
13547 if (old_state
->shared_dpll
&&
13548 old_state
->shared_dpll
!= new_state
->shared_dpll
) {
13549 unsigned crtc_mask
= 1 << drm_crtc_index(crtc
);
13550 struct intel_shared_dpll
*pll
= old_state
->shared_dpll
;
13552 I915_STATE_WARN(pll
->active_mask
& crtc_mask
,
13553 "pll active mismatch (didn't expect pipe %c in active mask)\n",
13554 pipe_name(drm_crtc_index(crtc
)));
13555 I915_STATE_WARN(pll
->config
.crtc_mask
& crtc_mask
,
13556 "pll enabled crtcs mismatch (found %x in enabled mask)\n",
13557 pipe_name(drm_crtc_index(crtc
)));
13562 intel_modeset_verify_crtc(struct drm_crtc
*crtc
,
13563 struct drm_crtc_state
*old_state
,
13564 struct drm_crtc_state
*new_state
)
13566 if (!needs_modeset(new_state
) &&
13567 !to_intel_crtc_state(new_state
)->update_pipe
)
13570 verify_wm_state(crtc
, new_state
);
13571 verify_connector_state(crtc
->dev
, crtc
);
13572 verify_crtc_state(crtc
, old_state
, new_state
);
13573 verify_shared_dpll_state(crtc
->dev
, crtc
, old_state
, new_state
);
13577 verify_disabled_dpll_state(struct drm_device
*dev
)
13579 struct drm_i915_private
*dev_priv
= to_i915(dev
);
13582 for (i
= 0; i
< dev_priv
->num_shared_dpll
; i
++)
13583 verify_single_dpll_state(dev_priv
, &dev_priv
->shared_dplls
[i
], NULL
, NULL
);
13587 intel_modeset_verify_disabled(struct drm_device
*dev
)
13589 verify_encoder_state(dev
);
13590 verify_connector_state(dev
, NULL
);
13591 verify_disabled_dpll_state(dev
);
13594 static void update_scanline_offset(struct intel_crtc
*crtc
)
13596 struct drm_device
*dev
= crtc
->base
.dev
;
13599 * The scanline counter increments at the leading edge of hsync.
13601 * On most platforms it starts counting from vtotal-1 on the
13602 * first active line. That means the scanline counter value is
13603 * always one less than what we would expect. Ie. just after
13604 * start of vblank, which also occurs at start of hsync (on the
13605 * last active line), the scanline counter will read vblank_start-1.
13607 * On gen2 the scanline counter starts counting from 1 instead
13608 * of vtotal-1, so we have to subtract one (or rather add vtotal-1
13609 * to keep the value positive), instead of adding one.
13611 * On HSW+ the behaviour of the scanline counter depends on the output
13612 * type. For DP ports it behaves like most other platforms, but on HDMI
13613 * there's an extra 1 line difference. So we need to add two instead of
13614 * one to the value.
13616 if (IS_GEN2(dev
)) {
13617 const struct drm_display_mode
*adjusted_mode
= &crtc
->config
->base
.adjusted_mode
;
13620 vtotal
= adjusted_mode
->crtc_vtotal
;
13621 if (adjusted_mode
->flags
& DRM_MODE_FLAG_INTERLACE
)
13624 crtc
->scanline_offset
= vtotal
- 1;
13625 } else if (HAS_DDI(dev
) &&
13626 intel_crtc_has_type(crtc
->config
, INTEL_OUTPUT_HDMI
)) {
13627 crtc
->scanline_offset
= 2;
13629 crtc
->scanline_offset
= 1;
13632 static void intel_modeset_clear_plls(struct drm_atomic_state
*state
)
13634 struct drm_device
*dev
= state
->dev
;
13635 struct drm_i915_private
*dev_priv
= to_i915(dev
);
13636 struct intel_shared_dpll_config
*shared_dpll
= NULL
;
13637 struct drm_crtc
*crtc
;
13638 struct drm_crtc_state
*crtc_state
;
13641 if (!dev_priv
->display
.crtc_compute_clock
)
13644 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
13645 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
13646 struct intel_shared_dpll
*old_dpll
=
13647 to_intel_crtc_state(crtc
->state
)->shared_dpll
;
13649 if (!needs_modeset(crtc_state
))
13652 to_intel_crtc_state(crtc_state
)->shared_dpll
= NULL
;
13658 shared_dpll
= intel_atomic_get_shared_dpll_state(state
);
13660 intel_shared_dpll_config_put(shared_dpll
, old_dpll
, intel_crtc
);
13665 * This implements the workaround described in the "notes" section of the mode
13666 * set sequence documentation. When going from no pipes or single pipe to
13667 * multiple pipes, and planes are enabled after the pipe, we need to wait at
13668 * least 2 vblanks on the first pipe before enabling planes on the second pipe.
13670 static int haswell_mode_set_planes_workaround(struct drm_atomic_state
*state
)
13672 struct drm_crtc_state
*crtc_state
;
13673 struct intel_crtc
*intel_crtc
;
13674 struct drm_crtc
*crtc
;
13675 struct intel_crtc_state
*first_crtc_state
= NULL
;
13676 struct intel_crtc_state
*other_crtc_state
= NULL
;
13677 enum pipe first_pipe
= INVALID_PIPE
, enabled_pipe
= INVALID_PIPE
;
13680 /* look at all crtc's that are going to be enabled in during modeset */
13681 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
13682 intel_crtc
= to_intel_crtc(crtc
);
13684 if (!crtc_state
->active
|| !needs_modeset(crtc_state
))
13687 if (first_crtc_state
) {
13688 other_crtc_state
= to_intel_crtc_state(crtc_state
);
13691 first_crtc_state
= to_intel_crtc_state(crtc_state
);
13692 first_pipe
= intel_crtc
->pipe
;
13696 /* No workaround needed? */
13697 if (!first_crtc_state
)
13700 /* w/a possibly needed, check how many crtc's are already enabled. */
13701 for_each_intel_crtc(state
->dev
, intel_crtc
) {
13702 struct intel_crtc_state
*pipe_config
;
13704 pipe_config
= intel_atomic_get_crtc_state(state
, intel_crtc
);
13705 if (IS_ERR(pipe_config
))
13706 return PTR_ERR(pipe_config
);
13708 pipe_config
->hsw_workaround_pipe
= INVALID_PIPE
;
13710 if (!pipe_config
->base
.active
||
13711 needs_modeset(&pipe_config
->base
))
13714 /* 2 or more enabled crtcs means no need for w/a */
13715 if (enabled_pipe
!= INVALID_PIPE
)
13718 enabled_pipe
= intel_crtc
->pipe
;
13721 if (enabled_pipe
!= INVALID_PIPE
)
13722 first_crtc_state
->hsw_workaround_pipe
= enabled_pipe
;
13723 else if (other_crtc_state
)
13724 other_crtc_state
->hsw_workaround_pipe
= first_pipe
;
13729 static int intel_modeset_all_pipes(struct drm_atomic_state
*state
)
13731 struct drm_crtc
*crtc
;
13732 struct drm_crtc_state
*crtc_state
;
13735 /* add all active pipes to the state */
13736 for_each_crtc(state
->dev
, crtc
) {
13737 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
13738 if (IS_ERR(crtc_state
))
13739 return PTR_ERR(crtc_state
);
13741 if (!crtc_state
->active
|| needs_modeset(crtc_state
))
13744 crtc_state
->mode_changed
= true;
13746 ret
= drm_atomic_add_affected_connectors(state
, crtc
);
13750 ret
= drm_atomic_add_affected_planes(state
, crtc
);
13758 static int intel_modeset_checks(struct drm_atomic_state
*state
)
13760 struct intel_atomic_state
*intel_state
= to_intel_atomic_state(state
);
13761 struct drm_i915_private
*dev_priv
= to_i915(state
->dev
);
13762 struct drm_crtc
*crtc
;
13763 struct drm_crtc_state
*crtc_state
;
13766 if (!check_digital_port_conflicts(state
)) {
13767 DRM_DEBUG_KMS("rejecting conflicting digital port configuration\n");
13771 intel_state
->modeset
= true;
13772 intel_state
->active_crtcs
= dev_priv
->active_crtcs
;
13774 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
13775 if (crtc_state
->active
)
13776 intel_state
->active_crtcs
|= 1 << i
;
13778 intel_state
->active_crtcs
&= ~(1 << i
);
13780 if (crtc_state
->active
!= crtc
->state
->active
)
13781 intel_state
->active_pipe_changes
|= drm_crtc_mask(crtc
);
13785 * See if the config requires any additional preparation, e.g.
13786 * to adjust global state with pipes off. We need to do this
13787 * here so we can get the modeset_pipe updated config for the new
13788 * mode set on this crtc. For other crtcs we need to use the
13789 * adjusted_mode bits in the crtc directly.
13791 if (dev_priv
->display
.modeset_calc_cdclk
) {
13792 if (!intel_state
->cdclk_pll_vco
)
13793 intel_state
->cdclk_pll_vco
= dev_priv
->cdclk_pll
.vco
;
13794 if (!intel_state
->cdclk_pll_vco
)
13795 intel_state
->cdclk_pll_vco
= dev_priv
->skl_preferred_vco_freq
;
13797 ret
= dev_priv
->display
.modeset_calc_cdclk(state
);
13801 if (intel_state
->dev_cdclk
!= dev_priv
->cdclk_freq
||
13802 intel_state
->cdclk_pll_vco
!= dev_priv
->cdclk_pll
.vco
)
13803 ret
= intel_modeset_all_pipes(state
);
13808 DRM_DEBUG_KMS("New cdclk calculated to be atomic %u, actual %u\n",
13809 intel_state
->cdclk
, intel_state
->dev_cdclk
);
13811 to_intel_atomic_state(state
)->cdclk
= dev_priv
->atomic_cdclk_freq
;
13813 intel_modeset_clear_plls(state
);
13815 if (IS_HASWELL(dev_priv
))
13816 return haswell_mode_set_planes_workaround(state
);
13822 * Handle calculation of various watermark data at the end of the atomic check
13823 * phase. The code here should be run after the per-crtc and per-plane 'check'
13824 * handlers to ensure that all derived state has been updated.
13826 static int calc_watermark_data(struct drm_atomic_state
*state
)
13828 struct drm_device
*dev
= state
->dev
;
13829 struct drm_i915_private
*dev_priv
= to_i915(dev
);
13831 /* Is there platform-specific watermark information to calculate? */
13832 if (dev_priv
->display
.compute_global_watermarks
)
13833 return dev_priv
->display
.compute_global_watermarks(state
);
13839 * intel_atomic_check - validate state object
13841 * @state: state to validate
13843 static int intel_atomic_check(struct drm_device
*dev
,
13844 struct drm_atomic_state
*state
)
13846 struct drm_i915_private
*dev_priv
= to_i915(dev
);
13847 struct intel_atomic_state
*intel_state
= to_intel_atomic_state(state
);
13848 struct drm_crtc
*crtc
;
13849 struct drm_crtc_state
*crtc_state
;
13851 bool any_ms
= false;
13853 ret
= drm_atomic_helper_check_modeset(dev
, state
);
13857 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
13858 struct intel_crtc_state
*pipe_config
=
13859 to_intel_crtc_state(crtc_state
);
13861 /* Catch I915_MODE_FLAG_INHERITED */
13862 if (crtc_state
->mode
.private_flags
!= crtc
->state
->mode
.private_flags
)
13863 crtc_state
->mode_changed
= true;
13865 if (!needs_modeset(crtc_state
))
13868 if (!crtc_state
->enable
) {
13873 /* FIXME: For only active_changed we shouldn't need to do any
13874 * state recomputation at all. */
13876 ret
= drm_atomic_add_affected_connectors(state
, crtc
);
13880 ret
= intel_modeset_pipe_config(crtc
, pipe_config
);
13882 intel_dump_pipe_config(to_intel_crtc(crtc
),
13883 pipe_config
, "[failed]");
13887 if (i915
.fastboot
&&
13888 intel_pipe_config_compare(dev
,
13889 to_intel_crtc_state(crtc
->state
),
13890 pipe_config
, true)) {
13891 crtc_state
->mode_changed
= false;
13892 to_intel_crtc_state(crtc_state
)->update_pipe
= true;
13895 if (needs_modeset(crtc_state
))
13898 ret
= drm_atomic_add_affected_planes(state
, crtc
);
13902 intel_dump_pipe_config(to_intel_crtc(crtc
), pipe_config
,
13903 needs_modeset(crtc_state
) ?
13904 "[modeset]" : "[fastset]");
13908 ret
= intel_modeset_checks(state
);
13913 intel_state
->cdclk
= dev_priv
->cdclk_freq
;
13915 ret
= drm_atomic_helper_check_planes(dev
, state
);
13919 intel_fbc_choose_crtc(dev_priv
, state
);
13920 return calc_watermark_data(state
);
13923 static int intel_atomic_prepare_commit(struct drm_device
*dev
,
13924 struct drm_atomic_state
*state
,
13927 struct drm_i915_private
*dev_priv
= to_i915(dev
);
13928 struct drm_plane_state
*plane_state
;
13929 struct drm_crtc_state
*crtc_state
;
13930 struct drm_plane
*plane
;
13931 struct drm_crtc
*crtc
;
13934 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
13935 if (state
->legacy_cursor_update
)
13938 ret
= intel_crtc_wait_for_pending_flips(crtc
);
13942 if (atomic_read(&to_intel_crtc(crtc
)->unpin_work_count
) >= 2)
13943 flush_workqueue(dev_priv
->wq
);
13946 ret
= mutex_lock_interruptible(&dev
->struct_mutex
);
13950 ret
= drm_atomic_helper_prepare_planes(dev
, state
);
13951 mutex_unlock(&dev
->struct_mutex
);
13953 if (!ret
&& !nonblock
) {
13954 for_each_plane_in_state(state
, plane
, plane_state
, i
) {
13955 struct intel_plane_state
*intel_plane_state
=
13956 to_intel_plane_state(plane_state
);
13958 if (!intel_plane_state
->wait_req
)
13961 ret
= i915_wait_request(intel_plane_state
->wait_req
,
13964 /* Any hang should be swallowed by the wait */
13965 WARN_ON(ret
== -EIO
);
13966 mutex_lock(&dev
->struct_mutex
);
13967 drm_atomic_helper_cleanup_planes(dev
, state
);
13968 mutex_unlock(&dev
->struct_mutex
);
13977 u32
intel_crtc_get_vblank_counter(struct intel_crtc
*crtc
)
13979 struct drm_device
*dev
= crtc
->base
.dev
;
13981 if (!dev
->max_vblank_count
)
13982 return drm_accurate_vblank_count(&crtc
->base
);
13984 return dev
->driver
->get_vblank_counter(dev
, crtc
->pipe
);
13987 static void intel_atomic_wait_for_vblanks(struct drm_device
*dev
,
13988 struct drm_i915_private
*dev_priv
,
13989 unsigned crtc_mask
)
13991 unsigned last_vblank_count
[I915_MAX_PIPES
];
13998 for_each_pipe(dev_priv
, pipe
) {
13999 struct drm_crtc
*crtc
= dev_priv
->pipe_to_crtc_mapping
[pipe
];
14001 if (!((1 << pipe
) & crtc_mask
))
14004 ret
= drm_crtc_vblank_get(crtc
);
14005 if (WARN_ON(ret
!= 0)) {
14006 crtc_mask
&= ~(1 << pipe
);
14010 last_vblank_count
[pipe
] = drm_crtc_vblank_count(crtc
);
14013 for_each_pipe(dev_priv
, pipe
) {
14014 struct drm_crtc
*crtc
= dev_priv
->pipe_to_crtc_mapping
[pipe
];
14017 if (!((1 << pipe
) & crtc_mask
))
14020 lret
= wait_event_timeout(dev
->vblank
[pipe
].queue
,
14021 last_vblank_count
[pipe
] !=
14022 drm_crtc_vblank_count(crtc
),
14023 msecs_to_jiffies(50));
14025 WARN(!lret
, "pipe %c vblank wait timed out\n", pipe_name(pipe
));
14027 drm_crtc_vblank_put(crtc
);
14031 static bool needs_vblank_wait(struct intel_crtc_state
*crtc_state
)
14033 /* fb updated, need to unpin old fb */
14034 if (crtc_state
->fb_changed
)
14037 /* wm changes, need vblank before final wm's */
14038 if (crtc_state
->update_wm_post
)
14042 * cxsr is re-enabled after vblank.
14043 * This is already handled by crtc_state->update_wm_post,
14044 * but added for clarity.
14046 if (crtc_state
->disable_cxsr
)
14052 static void intel_atomic_commit_tail(struct drm_atomic_state
*state
)
14054 struct drm_device
*dev
= state
->dev
;
14055 struct intel_atomic_state
*intel_state
= to_intel_atomic_state(state
);
14056 struct drm_i915_private
*dev_priv
= to_i915(dev
);
14057 struct drm_crtc_state
*old_crtc_state
;
14058 struct drm_crtc
*crtc
;
14059 struct intel_crtc_state
*intel_cstate
;
14060 struct drm_plane
*plane
;
14061 struct drm_plane_state
*plane_state
;
14062 bool hw_check
= intel_state
->modeset
;
14063 unsigned long put_domains
[I915_MAX_PIPES
] = {};
14064 unsigned crtc_vblank_mask
= 0;
14067 for_each_plane_in_state(state
, plane
, plane_state
, i
) {
14068 struct intel_plane_state
*intel_plane_state
=
14069 to_intel_plane_state(plane_state
);
14071 if (!intel_plane_state
->wait_req
)
14074 ret
= i915_wait_request(intel_plane_state
->wait_req
,
14076 /* EIO should be eaten, and we can't get interrupted in the
14077 * worker, and blocking commits have waited already. */
14081 drm_atomic_helper_wait_for_dependencies(state
);
14083 if (intel_state
->modeset
) {
14084 memcpy(dev_priv
->min_pixclk
, intel_state
->min_pixclk
,
14085 sizeof(intel_state
->min_pixclk
));
14086 dev_priv
->active_crtcs
= intel_state
->active_crtcs
;
14087 dev_priv
->atomic_cdclk_freq
= intel_state
->cdclk
;
14089 intel_display_power_get(dev_priv
, POWER_DOMAIN_MODESET
);
14092 for_each_crtc_in_state(state
, crtc
, old_crtc_state
, i
) {
14093 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
14095 if (needs_modeset(crtc
->state
) ||
14096 to_intel_crtc_state(crtc
->state
)->update_pipe
) {
14099 put_domains
[to_intel_crtc(crtc
)->pipe
] =
14100 modeset_get_crtc_power_domains(crtc
,
14101 to_intel_crtc_state(crtc
->state
));
14104 if (!needs_modeset(crtc
->state
))
14107 intel_pre_plane_update(to_intel_crtc_state(old_crtc_state
));
14109 if (old_crtc_state
->active
) {
14110 intel_crtc_disable_planes(crtc
, old_crtc_state
->plane_mask
);
14111 dev_priv
->display
.crtc_disable(crtc
);
14112 intel_crtc
->active
= false;
14113 intel_fbc_disable(intel_crtc
);
14114 intel_disable_shared_dpll(intel_crtc
);
14117 * Underruns don't always raise
14118 * interrupts, so check manually.
14120 intel_check_cpu_fifo_underruns(dev_priv
);
14121 intel_check_pch_fifo_underruns(dev_priv
);
14123 if (!crtc
->state
->active
)
14124 intel_update_watermarks(crtc
);
14128 /* Only after disabling all output pipelines that will be changed can we
14129 * update the the output configuration. */
14130 intel_modeset_update_crtc_state(state
);
14132 if (intel_state
->modeset
) {
14133 drm_atomic_helper_update_legacy_modeset_state(state
->dev
, state
);
14135 if (dev_priv
->display
.modeset_commit_cdclk
&&
14136 (intel_state
->dev_cdclk
!= dev_priv
->cdclk_freq
||
14137 intel_state
->cdclk_pll_vco
!= dev_priv
->cdclk_pll
.vco
))
14138 dev_priv
->display
.modeset_commit_cdclk(state
);
14140 intel_modeset_verify_disabled(dev
);
14143 /* Now enable the clocks, plane, pipe, and connectors that we set up. */
14144 for_each_crtc_in_state(state
, crtc
, old_crtc_state
, i
) {
14145 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
14146 bool modeset
= needs_modeset(crtc
->state
);
14147 struct intel_crtc_state
*pipe_config
=
14148 to_intel_crtc_state(crtc
->state
);
14150 if (modeset
&& crtc
->state
->active
) {
14151 update_scanline_offset(to_intel_crtc(crtc
));
14152 dev_priv
->display
.crtc_enable(crtc
);
14155 /* Complete events for now disable pipes here. */
14156 if (modeset
&& !crtc
->state
->active
&& crtc
->state
->event
) {
14157 spin_lock_irq(&dev
->event_lock
);
14158 drm_crtc_send_vblank_event(crtc
, crtc
->state
->event
);
14159 spin_unlock_irq(&dev
->event_lock
);
14161 crtc
->state
->event
= NULL
;
14165 intel_pre_plane_update(to_intel_crtc_state(old_crtc_state
));
14167 if (crtc
->state
->active
&&
14168 drm_atomic_get_existing_plane_state(state
, crtc
->primary
))
14169 intel_fbc_enable(intel_crtc
, pipe_config
, to_intel_plane_state(crtc
->primary
->state
));
14171 if (crtc
->state
->active
)
14172 drm_atomic_helper_commit_planes_on_crtc(old_crtc_state
);
14174 if (pipe_config
->base
.active
&& needs_vblank_wait(pipe_config
))
14175 crtc_vblank_mask
|= 1 << i
;
14178 /* FIXME: We should call drm_atomic_helper_commit_hw_done() here
14179 * already, but still need the state for the delayed optimization. To
14181 * - wrap the optimization/post_plane_update stuff into a per-crtc work.
14182 * - schedule that vblank worker _before_ calling hw_done
14183 * - at the start of commit_tail, cancel it _synchrously
14184 * - switch over to the vblank wait helper in the core after that since
14185 * we don't need out special handling any more.
14187 if (!state
->legacy_cursor_update
)
14188 intel_atomic_wait_for_vblanks(dev
, dev_priv
, crtc_vblank_mask
);
14191 * Now that the vblank has passed, we can go ahead and program the
14192 * optimal watermarks on platforms that need two-step watermark
14195 * TODO: Move this (and other cleanup) to an async worker eventually.
14197 for_each_crtc_in_state(state
, crtc
, old_crtc_state
, i
) {
14198 intel_cstate
= to_intel_crtc_state(crtc
->state
);
14200 if (dev_priv
->display
.optimize_watermarks
)
14201 dev_priv
->display
.optimize_watermarks(intel_cstate
);
14204 for_each_crtc_in_state(state
, crtc
, old_crtc_state
, i
) {
14205 intel_post_plane_update(to_intel_crtc_state(old_crtc_state
));
14207 if (put_domains
[i
])
14208 modeset_put_power_domains(dev_priv
, put_domains
[i
]);
14210 intel_modeset_verify_crtc(crtc
, old_crtc_state
, crtc
->state
);
14213 drm_atomic_helper_commit_hw_done(state
);
14215 if (intel_state
->modeset
)
14216 intel_display_power_put(dev_priv
, POWER_DOMAIN_MODESET
);
14218 mutex_lock(&dev
->struct_mutex
);
14219 drm_atomic_helper_cleanup_planes(dev
, state
);
14220 mutex_unlock(&dev
->struct_mutex
);
14222 drm_atomic_helper_commit_cleanup_done(state
);
14224 drm_atomic_state_free(state
);
14226 /* As one of the primary mmio accessors, KMS has a high likelihood
14227 * of triggering bugs in unclaimed access. After we finish
14228 * modesetting, see if an error has been flagged, and if so
14229 * enable debugging for the next modeset - and hope we catch
14232 * XXX note that we assume display power is on at this point.
14233 * This might hold true now but we need to add pm helper to check
14234 * unclaimed only when the hardware is on, as atomic commits
14235 * can happen also when the device is completely off.
14237 intel_uncore_arm_unclaimed_mmio_detection(dev_priv
);
14240 static void intel_atomic_commit_work(struct work_struct
*work
)
14242 struct drm_atomic_state
*state
= container_of(work
,
14243 struct drm_atomic_state
,
14245 intel_atomic_commit_tail(state
);
14248 static void intel_atomic_track_fbs(struct drm_atomic_state
*state
)
14250 struct drm_plane_state
*old_plane_state
;
14251 struct drm_plane
*plane
;
14254 for_each_plane_in_state(state
, plane
, old_plane_state
, i
)
14255 i915_gem_track_fb(intel_fb_obj(old_plane_state
->fb
),
14256 intel_fb_obj(plane
->state
->fb
),
14257 to_intel_plane(plane
)->frontbuffer_bit
);
14261 * intel_atomic_commit - commit validated state object
14263 * @state: the top-level driver state object
14264 * @nonblock: nonblocking commit
14266 * This function commits a top-level state object that has been validated
14267 * with drm_atomic_helper_check().
14269 * FIXME: Atomic modeset support for i915 is not yet complete. At the moment
14270 * nonblocking commits are only safe for pure plane updates. Everything else
14271 * should work though.
14274 * Zero for success or -errno.
14276 static int intel_atomic_commit(struct drm_device
*dev
,
14277 struct drm_atomic_state
*state
,
14280 struct intel_atomic_state
*intel_state
= to_intel_atomic_state(state
);
14281 struct drm_i915_private
*dev_priv
= to_i915(dev
);
14284 if (intel_state
->modeset
&& nonblock
) {
14285 DRM_DEBUG_KMS("nonblocking commit for modeset not yet implemented.\n");
14289 ret
= drm_atomic_helper_setup_commit(state
, nonblock
);
14293 INIT_WORK(&state
->commit_work
, intel_atomic_commit_work
);
14295 ret
= intel_atomic_prepare_commit(dev
, state
, nonblock
);
14297 DRM_DEBUG_ATOMIC("Preparing state failed with %i\n", ret
);
14301 drm_atomic_helper_swap_state(state
, true);
14302 dev_priv
->wm
.distrust_bios_wm
= false;
14303 dev_priv
->wm
.skl_results
= intel_state
->wm_results
;
14304 intel_shared_dpll_commit(state
);
14305 intel_atomic_track_fbs(state
);
14308 queue_work(system_unbound_wq
, &state
->commit_work
);
14310 intel_atomic_commit_tail(state
);
14315 void intel_crtc_restore_mode(struct drm_crtc
*crtc
)
14317 struct drm_device
*dev
= crtc
->dev
;
14318 struct drm_atomic_state
*state
;
14319 struct drm_crtc_state
*crtc_state
;
14322 state
= drm_atomic_state_alloc(dev
);
14324 DRM_DEBUG_KMS("[CRTC:%d:%s] crtc restore failed, out of memory",
14325 crtc
->base
.id
, crtc
->name
);
14329 state
->acquire_ctx
= drm_modeset_legacy_acquire_ctx(crtc
);
14332 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
14333 ret
= PTR_ERR_OR_ZERO(crtc_state
);
14335 if (!crtc_state
->active
)
14338 crtc_state
->mode_changed
= true;
14339 ret
= drm_atomic_commit(state
);
14342 if (ret
== -EDEADLK
) {
14343 drm_atomic_state_clear(state
);
14344 drm_modeset_backoff(state
->acquire_ctx
);
14350 drm_atomic_state_free(state
);
14353 #undef for_each_intel_crtc_masked
14356 * FIXME: Remove this once i915 is fully DRIVER_ATOMIC by calling
14357 * drm_atomic_helper_legacy_gamma_set() directly.
14359 static int intel_atomic_legacy_gamma_set(struct drm_crtc
*crtc
,
14360 u16
*red
, u16
*green
, u16
*blue
,
14363 struct drm_device
*dev
= crtc
->dev
;
14364 struct drm_mode_config
*config
= &dev
->mode_config
;
14365 struct drm_crtc_state
*state
;
14368 ret
= drm_atomic_helper_legacy_gamma_set(crtc
, red
, green
, blue
, size
);
14373 * Make sure we update the legacy properties so this works when
14374 * atomic is not enabled.
14377 state
= crtc
->state
;
14379 drm_object_property_set_value(&crtc
->base
,
14380 config
->degamma_lut_property
,
14381 (state
->degamma_lut
) ?
14382 state
->degamma_lut
->base
.id
: 0);
14384 drm_object_property_set_value(&crtc
->base
,
14385 config
->ctm_property
,
14387 state
->ctm
->base
.id
: 0);
14389 drm_object_property_set_value(&crtc
->base
,
14390 config
->gamma_lut_property
,
14391 (state
->gamma_lut
) ?
14392 state
->gamma_lut
->base
.id
: 0);
14397 static const struct drm_crtc_funcs intel_crtc_funcs
= {
14398 .gamma_set
= intel_atomic_legacy_gamma_set
,
14399 .set_config
= drm_atomic_helper_set_config
,
14400 .set_property
= drm_atomic_helper_crtc_set_property
,
14401 .destroy
= intel_crtc_destroy
,
14402 .page_flip
= intel_crtc_page_flip
,
14403 .atomic_duplicate_state
= intel_crtc_duplicate_state
,
14404 .atomic_destroy_state
= intel_crtc_destroy_state
,
14408 * intel_prepare_plane_fb - Prepare fb for usage on plane
14409 * @plane: drm plane to prepare for
14410 * @fb: framebuffer to prepare for presentation
14412 * Prepares a framebuffer for usage on a display plane. Generally this
14413 * involves pinning the underlying object and updating the frontbuffer tracking
14414 * bits. Some older platforms need special physical address handling for
14417 * Must be called with struct_mutex held.
14419 * Returns 0 on success, negative error code on failure.
14422 intel_prepare_plane_fb(struct drm_plane
*plane
,
14423 const struct drm_plane_state
*new_state
)
14425 struct drm_device
*dev
= plane
->dev
;
14426 struct drm_framebuffer
*fb
= new_state
->fb
;
14427 struct drm_i915_gem_object
*obj
= intel_fb_obj(fb
);
14428 struct drm_i915_gem_object
*old_obj
= intel_fb_obj(plane
->state
->fb
);
14429 struct reservation_object
*resv
;
14432 if (!obj
&& !old_obj
)
14436 struct drm_crtc_state
*crtc_state
=
14437 drm_atomic_get_existing_crtc_state(new_state
->state
, plane
->state
->crtc
);
14439 /* Big Hammer, we also need to ensure that any pending
14440 * MI_WAIT_FOR_EVENT inside a user batch buffer on the
14441 * current scanout is retired before unpinning the old
14442 * framebuffer. Note that we rely on userspace rendering
14443 * into the buffer attached to the pipe they are waiting
14444 * on. If not, userspace generates a GPU hang with IPEHR
14445 * point to the MI_WAIT_FOR_EVENT.
14447 * This should only fail upon a hung GPU, in which case we
14448 * can safely continue.
14450 if (needs_modeset(crtc_state
))
14451 ret
= i915_gem_object_wait_rendering(old_obj
, true);
14453 /* GPU hangs should have been swallowed by the wait */
14454 WARN_ON(ret
== -EIO
);
14462 /* For framebuffer backed by dmabuf, wait for fence */
14463 resv
= i915_gem_object_get_dmabuf_resv(obj
);
14467 lret
= reservation_object_wait_timeout_rcu(resv
, false, true,
14468 MAX_SCHEDULE_TIMEOUT
);
14469 if (lret
== -ERESTARTSYS
)
14472 WARN(lret
< 0, "waiting returns %li\n", lret
);
14475 if (plane
->type
== DRM_PLANE_TYPE_CURSOR
&&
14476 INTEL_INFO(dev
)->cursor_needs_physical
) {
14477 int align
= IS_I830(dev
) ? 16 * 1024 : 256;
14478 ret
= i915_gem_object_attach_phys(obj
, align
);
14480 DRM_DEBUG_KMS("failed to attach phys object\n");
14482 struct i915_vma
*vma
;
14484 vma
= intel_pin_and_fence_fb_obj(fb
, new_state
->rotation
);
14486 ret
= PTR_ERR(vma
);
14490 to_intel_plane_state(new_state
)->wait_req
=
14491 i915_gem_active_get(&obj
->last_write
,
14492 &obj
->base
.dev
->struct_mutex
);
14499 * intel_cleanup_plane_fb - Cleans up an fb after plane use
14500 * @plane: drm plane to clean up for
14501 * @fb: old framebuffer that was on plane
14503 * Cleans up a framebuffer that has just been removed from a plane.
14505 * Must be called with struct_mutex held.
14508 intel_cleanup_plane_fb(struct drm_plane
*plane
,
14509 const struct drm_plane_state
*old_state
)
14511 struct drm_device
*dev
= plane
->dev
;
14512 struct intel_plane_state
*old_intel_state
;
14513 struct intel_plane_state
*intel_state
= to_intel_plane_state(plane
->state
);
14514 struct drm_i915_gem_object
*old_obj
= intel_fb_obj(old_state
->fb
);
14515 struct drm_i915_gem_object
*obj
= intel_fb_obj(plane
->state
->fb
);
14517 old_intel_state
= to_intel_plane_state(old_state
);
14519 if (!obj
&& !old_obj
)
14522 if (old_obj
&& (plane
->type
!= DRM_PLANE_TYPE_CURSOR
||
14523 !INTEL_INFO(dev
)->cursor_needs_physical
))
14524 intel_unpin_fb_obj(old_state
->fb
, old_state
->rotation
);
14526 i915_gem_request_assign(&intel_state
->wait_req
, NULL
);
14527 i915_gem_request_assign(&old_intel_state
->wait_req
, NULL
);
14531 skl_max_scale(struct intel_crtc
*intel_crtc
, struct intel_crtc_state
*crtc_state
)
14534 int crtc_clock
, cdclk
;
14536 if (!intel_crtc
|| !crtc_state
->base
.enable
)
14537 return DRM_PLANE_HELPER_NO_SCALING
;
14539 crtc_clock
= crtc_state
->base
.adjusted_mode
.crtc_clock
;
14540 cdclk
= to_intel_atomic_state(crtc_state
->base
.state
)->cdclk
;
14542 if (WARN_ON_ONCE(!crtc_clock
|| cdclk
< crtc_clock
))
14543 return DRM_PLANE_HELPER_NO_SCALING
;
14546 * skl max scale is lower of:
14547 * close to 3 but not 3, -1 is for that purpose
14551 max_scale
= min((1 << 16) * 3 - 1, (1 << 8) * ((cdclk
<< 8) / crtc_clock
));
14557 intel_check_primary_plane(struct drm_plane
*plane
,
14558 struct intel_crtc_state
*crtc_state
,
14559 struct intel_plane_state
*state
)
14561 struct drm_i915_private
*dev_priv
= to_i915(plane
->dev
);
14562 struct drm_crtc
*crtc
= state
->base
.crtc
;
14563 int min_scale
= DRM_PLANE_HELPER_NO_SCALING
;
14564 int max_scale
= DRM_PLANE_HELPER_NO_SCALING
;
14565 bool can_position
= false;
14568 if (INTEL_GEN(dev_priv
) >= 9) {
14569 /* use scaler when colorkey is not required */
14570 if (state
->ckey
.flags
== I915_SET_COLORKEY_NONE
) {
14572 max_scale
= skl_max_scale(to_intel_crtc(crtc
), crtc_state
);
14574 can_position
= true;
14577 ret
= drm_plane_helper_check_state(&state
->base
,
14579 min_scale
, max_scale
,
14580 can_position
, true);
14584 if (!state
->base
.fb
)
14587 if (INTEL_GEN(dev_priv
) >= 9) {
14588 ret
= skl_check_plane_surface(state
);
14596 static void intel_begin_crtc_commit(struct drm_crtc
*crtc
,
14597 struct drm_crtc_state
*old_crtc_state
)
14599 struct drm_device
*dev
= crtc
->dev
;
14600 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
14601 struct intel_crtc_state
*old_intel_state
=
14602 to_intel_crtc_state(old_crtc_state
);
14603 bool modeset
= needs_modeset(crtc
->state
);
14605 /* Perform vblank evasion around commit operation */
14606 intel_pipe_update_start(intel_crtc
);
14611 if (crtc
->state
->color_mgmt_changed
|| to_intel_crtc_state(crtc
->state
)->update_pipe
) {
14612 intel_color_set_csc(crtc
->state
);
14613 intel_color_load_luts(crtc
->state
);
14616 if (to_intel_crtc_state(crtc
->state
)->update_pipe
)
14617 intel_update_pipe_config(intel_crtc
, old_intel_state
);
14618 else if (INTEL_INFO(dev
)->gen
>= 9)
14619 skl_detach_scalers(intel_crtc
);
14622 static void intel_finish_crtc_commit(struct drm_crtc
*crtc
,
14623 struct drm_crtc_state
*old_crtc_state
)
14625 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
14627 intel_pipe_update_end(intel_crtc
, NULL
);
14631 * intel_plane_destroy - destroy a plane
14632 * @plane: plane to destroy
14634 * Common destruction function for all types of planes (primary, cursor,
14637 void intel_plane_destroy(struct drm_plane
*plane
)
14642 drm_plane_cleanup(plane
);
14643 kfree(to_intel_plane(plane
));
14646 const struct drm_plane_funcs intel_plane_funcs
= {
14647 .update_plane
= drm_atomic_helper_update_plane
,
14648 .disable_plane
= drm_atomic_helper_disable_plane
,
14649 .destroy
= intel_plane_destroy
,
14650 .set_property
= drm_atomic_helper_plane_set_property
,
14651 .atomic_get_property
= intel_plane_atomic_get_property
,
14652 .atomic_set_property
= intel_plane_atomic_set_property
,
14653 .atomic_duplicate_state
= intel_plane_duplicate_state
,
14654 .atomic_destroy_state
= intel_plane_destroy_state
,
14658 static struct drm_plane
*intel_primary_plane_create(struct drm_device
*dev
,
14661 struct intel_plane
*primary
= NULL
;
14662 struct intel_plane_state
*state
= NULL
;
14663 const uint32_t *intel_primary_formats
;
14664 unsigned int num_formats
;
14667 primary
= kzalloc(sizeof(*primary
), GFP_KERNEL
);
14671 state
= intel_create_plane_state(&primary
->base
);
14674 primary
->base
.state
= &state
->base
;
14676 primary
->can_scale
= false;
14677 primary
->max_downscale
= 1;
14678 if (INTEL_INFO(dev
)->gen
>= 9) {
14679 primary
->can_scale
= true;
14680 state
->scaler_id
= -1;
14682 primary
->pipe
= pipe
;
14683 primary
->plane
= pipe
;
14684 primary
->frontbuffer_bit
= INTEL_FRONTBUFFER_PRIMARY(pipe
);
14685 primary
->check_plane
= intel_check_primary_plane
;
14686 if (HAS_FBC(dev
) && INTEL_INFO(dev
)->gen
< 4)
14687 primary
->plane
= !pipe
;
14689 if (INTEL_INFO(dev
)->gen
>= 9) {
14690 intel_primary_formats
= skl_primary_formats
;
14691 num_formats
= ARRAY_SIZE(skl_primary_formats
);
14693 primary
->update_plane
= skylake_update_primary_plane
;
14694 primary
->disable_plane
= skylake_disable_primary_plane
;
14695 } else if (HAS_PCH_SPLIT(dev
)) {
14696 intel_primary_formats
= i965_primary_formats
;
14697 num_formats
= ARRAY_SIZE(i965_primary_formats
);
14699 primary
->update_plane
= ironlake_update_primary_plane
;
14700 primary
->disable_plane
= i9xx_disable_primary_plane
;
14701 } else if (INTEL_INFO(dev
)->gen
>= 4) {
14702 intel_primary_formats
= i965_primary_formats
;
14703 num_formats
= ARRAY_SIZE(i965_primary_formats
);
14705 primary
->update_plane
= i9xx_update_primary_plane
;
14706 primary
->disable_plane
= i9xx_disable_primary_plane
;
14708 intel_primary_formats
= i8xx_primary_formats
;
14709 num_formats
= ARRAY_SIZE(i8xx_primary_formats
);
14711 primary
->update_plane
= i9xx_update_primary_plane
;
14712 primary
->disable_plane
= i9xx_disable_primary_plane
;
14715 if (INTEL_INFO(dev
)->gen
>= 9)
14716 ret
= drm_universal_plane_init(dev
, &primary
->base
, 0,
14717 &intel_plane_funcs
,
14718 intel_primary_formats
, num_formats
,
14719 DRM_PLANE_TYPE_PRIMARY
,
14720 "plane 1%c", pipe_name(pipe
));
14721 else if (INTEL_INFO(dev
)->gen
>= 5 || IS_G4X(dev
))
14722 ret
= drm_universal_plane_init(dev
, &primary
->base
, 0,
14723 &intel_plane_funcs
,
14724 intel_primary_formats
, num_formats
,
14725 DRM_PLANE_TYPE_PRIMARY
,
14726 "primary %c", pipe_name(pipe
));
14728 ret
= drm_universal_plane_init(dev
, &primary
->base
, 0,
14729 &intel_plane_funcs
,
14730 intel_primary_formats
, num_formats
,
14731 DRM_PLANE_TYPE_PRIMARY
,
14732 "plane %c", plane_name(primary
->plane
));
14736 if (INTEL_INFO(dev
)->gen
>= 4)
14737 intel_create_rotation_property(dev
, primary
);
14739 drm_plane_helper_add(&primary
->base
, &intel_plane_helper_funcs
);
14741 return &primary
->base
;
14750 void intel_create_rotation_property(struct drm_device
*dev
, struct intel_plane
*plane
)
14752 if (!dev
->mode_config
.rotation_property
) {
14753 unsigned long flags
= DRM_ROTATE_0
|
14756 if (INTEL_INFO(dev
)->gen
>= 9)
14757 flags
|= DRM_ROTATE_90
| DRM_ROTATE_270
;
14759 dev
->mode_config
.rotation_property
=
14760 drm_mode_create_rotation_property(dev
, flags
);
14762 if (dev
->mode_config
.rotation_property
)
14763 drm_object_attach_property(&plane
->base
.base
,
14764 dev
->mode_config
.rotation_property
,
14765 plane
->base
.state
->rotation
);
14769 intel_check_cursor_plane(struct drm_plane
*plane
,
14770 struct intel_crtc_state
*crtc_state
,
14771 struct intel_plane_state
*state
)
14773 struct drm_framebuffer
*fb
= state
->base
.fb
;
14774 struct drm_i915_gem_object
*obj
= intel_fb_obj(fb
);
14775 enum pipe pipe
= to_intel_plane(plane
)->pipe
;
14779 ret
= drm_plane_helper_check_state(&state
->base
,
14781 DRM_PLANE_HELPER_NO_SCALING
,
14782 DRM_PLANE_HELPER_NO_SCALING
,
14787 /* if we want to turn off the cursor ignore width and height */
14791 /* Check for which cursor types we support */
14792 if (!cursor_size_ok(plane
->dev
, state
->base
.crtc_w
, state
->base
.crtc_h
)) {
14793 DRM_DEBUG("Cursor dimension %dx%d not supported\n",
14794 state
->base
.crtc_w
, state
->base
.crtc_h
);
14798 stride
= roundup_pow_of_two(state
->base
.crtc_w
) * 4;
14799 if (obj
->base
.size
< stride
* state
->base
.crtc_h
) {
14800 DRM_DEBUG_KMS("buffer is too small\n");
14804 if (fb
->modifier
[0] != DRM_FORMAT_MOD_NONE
) {
14805 DRM_DEBUG_KMS("cursor cannot be tiled\n");
14810 * There's something wrong with the cursor on CHV pipe C.
14811 * If it straddles the left edge of the screen then
14812 * moving it away from the edge or disabling it often
14813 * results in a pipe underrun, and often that can lead to
14814 * dead pipe (constant underrun reported, and it scans
14815 * out just a solid color). To recover from that, the
14816 * display power well must be turned off and on again.
14817 * Refuse the put the cursor into that compromised position.
14819 if (IS_CHERRYVIEW(plane
->dev
) && pipe
== PIPE_C
&&
14820 state
->base
.visible
&& state
->base
.crtc_x
< 0) {
14821 DRM_DEBUG_KMS("CHV cursor C not allowed to straddle the left screen edge\n");
14829 intel_disable_cursor_plane(struct drm_plane
*plane
,
14830 struct drm_crtc
*crtc
)
14832 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
14834 intel_crtc
->cursor_addr
= 0;
14835 intel_crtc_update_cursor(crtc
, NULL
);
14839 intel_update_cursor_plane(struct drm_plane
*plane
,
14840 const struct intel_crtc_state
*crtc_state
,
14841 const struct intel_plane_state
*state
)
14843 struct drm_crtc
*crtc
= crtc_state
->base
.crtc
;
14844 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
14845 struct drm_device
*dev
= plane
->dev
;
14846 struct drm_i915_gem_object
*obj
= intel_fb_obj(state
->base
.fb
);
14851 else if (!INTEL_INFO(dev
)->cursor_needs_physical
)
14852 addr
= i915_gem_object_ggtt_offset(obj
, NULL
);
14854 addr
= obj
->phys_handle
->busaddr
;
14856 intel_crtc
->cursor_addr
= addr
;
14857 intel_crtc_update_cursor(crtc
, state
);
14860 static struct drm_plane
*intel_cursor_plane_create(struct drm_device
*dev
,
14863 struct intel_plane
*cursor
= NULL
;
14864 struct intel_plane_state
*state
= NULL
;
14867 cursor
= kzalloc(sizeof(*cursor
), GFP_KERNEL
);
14871 state
= intel_create_plane_state(&cursor
->base
);
14874 cursor
->base
.state
= &state
->base
;
14876 cursor
->can_scale
= false;
14877 cursor
->max_downscale
= 1;
14878 cursor
->pipe
= pipe
;
14879 cursor
->plane
= pipe
;
14880 cursor
->frontbuffer_bit
= INTEL_FRONTBUFFER_CURSOR(pipe
);
14881 cursor
->check_plane
= intel_check_cursor_plane
;
14882 cursor
->update_plane
= intel_update_cursor_plane
;
14883 cursor
->disable_plane
= intel_disable_cursor_plane
;
14885 ret
= drm_universal_plane_init(dev
, &cursor
->base
, 0,
14886 &intel_plane_funcs
,
14887 intel_cursor_formats
,
14888 ARRAY_SIZE(intel_cursor_formats
),
14889 DRM_PLANE_TYPE_CURSOR
,
14890 "cursor %c", pipe_name(pipe
));
14894 if (INTEL_INFO(dev
)->gen
>= 4) {
14895 if (!dev
->mode_config
.rotation_property
)
14896 dev
->mode_config
.rotation_property
=
14897 drm_mode_create_rotation_property(dev
,
14900 if (dev
->mode_config
.rotation_property
)
14901 drm_object_attach_property(&cursor
->base
.base
,
14902 dev
->mode_config
.rotation_property
,
14903 state
->base
.rotation
);
14906 if (INTEL_INFO(dev
)->gen
>=9)
14907 state
->scaler_id
= -1;
14909 drm_plane_helper_add(&cursor
->base
, &intel_plane_helper_funcs
);
14911 return &cursor
->base
;
14920 static void skl_init_scalers(struct drm_device
*dev
, struct intel_crtc
*intel_crtc
,
14921 struct intel_crtc_state
*crtc_state
)
14924 struct intel_scaler
*intel_scaler
;
14925 struct intel_crtc_scaler_state
*scaler_state
= &crtc_state
->scaler_state
;
14927 for (i
= 0; i
< intel_crtc
->num_scalers
; i
++) {
14928 intel_scaler
= &scaler_state
->scalers
[i
];
14929 intel_scaler
->in_use
= 0;
14930 intel_scaler
->mode
= PS_SCALER_MODE_DYN
;
14933 scaler_state
->scaler_id
= -1;
14936 static void intel_crtc_init(struct drm_device
*dev
, int pipe
)
14938 struct drm_i915_private
*dev_priv
= to_i915(dev
);
14939 struct intel_crtc
*intel_crtc
;
14940 struct intel_crtc_state
*crtc_state
= NULL
;
14941 struct drm_plane
*primary
= NULL
;
14942 struct drm_plane
*cursor
= NULL
;
14945 intel_crtc
= kzalloc(sizeof(*intel_crtc
), GFP_KERNEL
);
14946 if (intel_crtc
== NULL
)
14949 crtc_state
= kzalloc(sizeof(*crtc_state
), GFP_KERNEL
);
14952 intel_crtc
->config
= crtc_state
;
14953 intel_crtc
->base
.state
= &crtc_state
->base
;
14954 crtc_state
->base
.crtc
= &intel_crtc
->base
;
14956 /* initialize shared scalers */
14957 if (INTEL_INFO(dev
)->gen
>= 9) {
14958 if (pipe
== PIPE_C
)
14959 intel_crtc
->num_scalers
= 1;
14961 intel_crtc
->num_scalers
= SKL_NUM_SCALERS
;
14963 skl_init_scalers(dev
, intel_crtc
, crtc_state
);
14966 primary
= intel_primary_plane_create(dev
, pipe
);
14970 cursor
= intel_cursor_plane_create(dev
, pipe
);
14974 ret
= drm_crtc_init_with_planes(dev
, &intel_crtc
->base
, primary
,
14975 cursor
, &intel_crtc_funcs
,
14976 "pipe %c", pipe_name(pipe
));
14981 * On gen2/3 only plane A can do fbc, but the panel fitter and lvds port
14982 * is hooked to pipe B. Hence we want plane A feeding pipe B.
14984 intel_crtc
->pipe
= pipe
;
14985 intel_crtc
->plane
= pipe
;
14986 if (HAS_FBC(dev
) && INTEL_INFO(dev
)->gen
< 4) {
14987 DRM_DEBUG_KMS("swapping pipes & planes for FBC\n");
14988 intel_crtc
->plane
= !pipe
;
14991 intel_crtc
->cursor_base
= ~0;
14992 intel_crtc
->cursor_cntl
= ~0;
14993 intel_crtc
->cursor_size
= ~0;
14995 intel_crtc
->wm
.cxsr_allowed
= true;
14997 BUG_ON(pipe
>= ARRAY_SIZE(dev_priv
->plane_to_crtc_mapping
) ||
14998 dev_priv
->plane_to_crtc_mapping
[intel_crtc
->plane
] != NULL
);
14999 dev_priv
->plane_to_crtc_mapping
[intel_crtc
->plane
] = &intel_crtc
->base
;
15000 dev_priv
->pipe_to_crtc_mapping
[intel_crtc
->pipe
] = &intel_crtc
->base
;
15002 drm_crtc_helper_add(&intel_crtc
->base
, &intel_helper_funcs
);
15004 intel_color_init(&intel_crtc
->base
);
15006 WARN_ON(drm_crtc_index(&intel_crtc
->base
) != intel_crtc
->pipe
);
15010 intel_plane_destroy(primary
);
15011 intel_plane_destroy(cursor
);
15016 enum pipe
intel_get_pipe_from_connector(struct intel_connector
*connector
)
15018 struct drm_encoder
*encoder
= connector
->base
.encoder
;
15019 struct drm_device
*dev
= connector
->base
.dev
;
15021 WARN_ON(!drm_modeset_is_locked(&dev
->mode_config
.connection_mutex
));
15023 if (!encoder
|| WARN_ON(!encoder
->crtc
))
15024 return INVALID_PIPE
;
15026 return to_intel_crtc(encoder
->crtc
)->pipe
;
15029 int intel_get_pipe_from_crtc_id(struct drm_device
*dev
, void *data
,
15030 struct drm_file
*file
)
15032 struct drm_i915_get_pipe_from_crtc_id
*pipe_from_crtc_id
= data
;
15033 struct drm_crtc
*drmmode_crtc
;
15034 struct intel_crtc
*crtc
;
15036 drmmode_crtc
= drm_crtc_find(dev
, pipe_from_crtc_id
->crtc_id
);
15040 crtc
= to_intel_crtc(drmmode_crtc
);
15041 pipe_from_crtc_id
->pipe
= crtc
->pipe
;
15046 static int intel_encoder_clones(struct intel_encoder
*encoder
)
15048 struct drm_device
*dev
= encoder
->base
.dev
;
15049 struct intel_encoder
*source_encoder
;
15050 int index_mask
= 0;
15053 for_each_intel_encoder(dev
, source_encoder
) {
15054 if (encoders_cloneable(encoder
, source_encoder
))
15055 index_mask
|= (1 << entry
);
15063 static bool has_edp_a(struct drm_device
*dev
)
15065 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15067 if (!IS_MOBILE(dev
))
15070 if ((I915_READ(DP_A
) & DP_DETECTED
) == 0)
15073 if (IS_GEN5(dev
) && (I915_READ(FUSE_STRAP
) & ILK_eDP_A_DISABLE
))
15079 static bool intel_crt_present(struct drm_device
*dev
)
15081 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15083 if (INTEL_INFO(dev
)->gen
>= 9)
15086 if (IS_HSW_ULT(dev
) || IS_BDW_ULT(dev
))
15089 if (IS_CHERRYVIEW(dev
))
15092 if (HAS_PCH_LPT_H(dev
) && I915_READ(SFUSE_STRAP
) & SFUSE_STRAP_CRT_DISABLED
)
15095 /* DDI E can't be used if DDI A requires 4 lanes */
15096 if (HAS_DDI(dev
) && I915_READ(DDI_BUF_CTL(PORT_A
)) & DDI_A_4_LANES
)
15099 if (!dev_priv
->vbt
.int_crt_support
)
15105 void intel_pps_unlock_regs_wa(struct drm_i915_private
*dev_priv
)
15110 if (HAS_DDI(dev_priv
))
15113 * This w/a is needed at least on CPT/PPT, but to be sure apply it
15114 * everywhere where registers can be write protected.
15116 if (IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
))
15121 for (pps_idx
= 0; pps_idx
< pps_num
; pps_idx
++) {
15122 u32 val
= I915_READ(PP_CONTROL(pps_idx
));
15124 val
= (val
& ~PANEL_UNLOCK_MASK
) | PANEL_UNLOCK_REGS
;
15125 I915_WRITE(PP_CONTROL(pps_idx
), val
);
15129 static void intel_pps_init(struct drm_i915_private
*dev_priv
)
15131 if (HAS_PCH_SPLIT(dev_priv
) || IS_BROXTON(dev_priv
))
15132 dev_priv
->pps_mmio_base
= PCH_PPS_BASE
;
15133 else if (IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
))
15134 dev_priv
->pps_mmio_base
= VLV_PPS_BASE
;
15136 dev_priv
->pps_mmio_base
= PPS_BASE
;
15138 intel_pps_unlock_regs_wa(dev_priv
);
15141 static void intel_setup_outputs(struct drm_device
*dev
)
15143 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15144 struct intel_encoder
*encoder
;
15145 bool dpd_is_edp
= false;
15147 intel_pps_init(dev_priv
);
15150 * intel_edp_init_connector() depends on this completing first, to
15151 * prevent the registeration of both eDP and LVDS and the incorrect
15152 * sharing of the PPS.
15154 intel_lvds_init(dev
);
15156 if (intel_crt_present(dev
))
15157 intel_crt_init(dev
);
15159 if (IS_BROXTON(dev
)) {
15161 * FIXME: Broxton doesn't support port detection via the
15162 * DDI_BUF_CTL_A or SFUSE_STRAP registers, find another way to
15163 * detect the ports.
15165 intel_ddi_init(dev
, PORT_A
);
15166 intel_ddi_init(dev
, PORT_B
);
15167 intel_ddi_init(dev
, PORT_C
);
15169 intel_dsi_init(dev
);
15170 } else if (HAS_DDI(dev
)) {
15174 * Haswell uses DDI functions to detect digital outputs.
15175 * On SKL pre-D0 the strap isn't connected, so we assume
15178 found
= I915_READ(DDI_BUF_CTL(PORT_A
)) & DDI_INIT_DISPLAY_DETECTED
;
15179 /* WaIgnoreDDIAStrap: skl */
15180 if (found
|| IS_SKYLAKE(dev
) || IS_KABYLAKE(dev
))
15181 intel_ddi_init(dev
, PORT_A
);
15183 /* DDI B, C and D detection is indicated by the SFUSE_STRAP
15185 found
= I915_READ(SFUSE_STRAP
);
15187 if (found
& SFUSE_STRAP_DDIB_DETECTED
)
15188 intel_ddi_init(dev
, PORT_B
);
15189 if (found
& SFUSE_STRAP_DDIC_DETECTED
)
15190 intel_ddi_init(dev
, PORT_C
);
15191 if (found
& SFUSE_STRAP_DDID_DETECTED
)
15192 intel_ddi_init(dev
, PORT_D
);
15194 * On SKL we don't have a way to detect DDI-E so we rely on VBT.
15196 if ((IS_SKYLAKE(dev
) || IS_KABYLAKE(dev
)) &&
15197 (dev_priv
->vbt
.ddi_port_info
[PORT_E
].supports_dp
||
15198 dev_priv
->vbt
.ddi_port_info
[PORT_E
].supports_dvi
||
15199 dev_priv
->vbt
.ddi_port_info
[PORT_E
].supports_hdmi
))
15200 intel_ddi_init(dev
, PORT_E
);
15202 } else if (HAS_PCH_SPLIT(dev
)) {
15204 dpd_is_edp
= intel_dp_is_edp(dev
, PORT_D
);
15206 if (has_edp_a(dev
))
15207 intel_dp_init(dev
, DP_A
, PORT_A
);
15209 if (I915_READ(PCH_HDMIB
) & SDVO_DETECTED
) {
15210 /* PCH SDVOB multiplex with HDMIB */
15211 found
= intel_sdvo_init(dev
, PCH_SDVOB
, PORT_B
);
15213 intel_hdmi_init(dev
, PCH_HDMIB
, PORT_B
);
15214 if (!found
&& (I915_READ(PCH_DP_B
) & DP_DETECTED
))
15215 intel_dp_init(dev
, PCH_DP_B
, PORT_B
);
15218 if (I915_READ(PCH_HDMIC
) & SDVO_DETECTED
)
15219 intel_hdmi_init(dev
, PCH_HDMIC
, PORT_C
);
15221 if (!dpd_is_edp
&& I915_READ(PCH_HDMID
) & SDVO_DETECTED
)
15222 intel_hdmi_init(dev
, PCH_HDMID
, PORT_D
);
15224 if (I915_READ(PCH_DP_C
) & DP_DETECTED
)
15225 intel_dp_init(dev
, PCH_DP_C
, PORT_C
);
15227 if (I915_READ(PCH_DP_D
) & DP_DETECTED
)
15228 intel_dp_init(dev
, PCH_DP_D
, PORT_D
);
15229 } else if (IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
)) {
15230 bool has_edp
, has_port
;
15233 * The DP_DETECTED bit is the latched state of the DDC
15234 * SDA pin at boot. However since eDP doesn't require DDC
15235 * (no way to plug in a DP->HDMI dongle) the DDC pins for
15236 * eDP ports may have been muxed to an alternate function.
15237 * Thus we can't rely on the DP_DETECTED bit alone to detect
15238 * eDP ports. Consult the VBT as well as DP_DETECTED to
15239 * detect eDP ports.
15241 * Sadly the straps seem to be missing sometimes even for HDMI
15242 * ports (eg. on Voyo V3 - CHT x7-Z8700), so check both strap
15243 * and VBT for the presence of the port. Additionally we can't
15244 * trust the port type the VBT declares as we've seen at least
15245 * HDMI ports that the VBT claim are DP or eDP.
15247 has_edp
= intel_dp_is_edp(dev
, PORT_B
);
15248 has_port
= intel_bios_is_port_present(dev_priv
, PORT_B
);
15249 if (I915_READ(VLV_DP_B
) & DP_DETECTED
|| has_port
)
15250 has_edp
&= intel_dp_init(dev
, VLV_DP_B
, PORT_B
);
15251 if ((I915_READ(VLV_HDMIB
) & SDVO_DETECTED
|| has_port
) && !has_edp
)
15252 intel_hdmi_init(dev
, VLV_HDMIB
, PORT_B
);
15254 has_edp
= intel_dp_is_edp(dev
, PORT_C
);
15255 has_port
= intel_bios_is_port_present(dev_priv
, PORT_C
);
15256 if (I915_READ(VLV_DP_C
) & DP_DETECTED
|| has_port
)
15257 has_edp
&= intel_dp_init(dev
, VLV_DP_C
, PORT_C
);
15258 if ((I915_READ(VLV_HDMIC
) & SDVO_DETECTED
|| has_port
) && !has_edp
)
15259 intel_hdmi_init(dev
, VLV_HDMIC
, PORT_C
);
15261 if (IS_CHERRYVIEW(dev
)) {
15263 * eDP not supported on port D,
15264 * so no need to worry about it
15266 has_port
= intel_bios_is_port_present(dev_priv
, PORT_D
);
15267 if (I915_READ(CHV_DP_D
) & DP_DETECTED
|| has_port
)
15268 intel_dp_init(dev
, CHV_DP_D
, PORT_D
);
15269 if (I915_READ(CHV_HDMID
) & SDVO_DETECTED
|| has_port
)
15270 intel_hdmi_init(dev
, CHV_HDMID
, PORT_D
);
15273 intel_dsi_init(dev
);
15274 } else if (!IS_GEN2(dev
) && !IS_PINEVIEW(dev
)) {
15275 bool found
= false;
15277 if (I915_READ(GEN3_SDVOB
) & SDVO_DETECTED
) {
15278 DRM_DEBUG_KMS("probing SDVOB\n");
15279 found
= intel_sdvo_init(dev
, GEN3_SDVOB
, PORT_B
);
15280 if (!found
&& IS_G4X(dev
)) {
15281 DRM_DEBUG_KMS("probing HDMI on SDVOB\n");
15282 intel_hdmi_init(dev
, GEN4_HDMIB
, PORT_B
);
15285 if (!found
&& IS_G4X(dev
))
15286 intel_dp_init(dev
, DP_B
, PORT_B
);
15289 /* Before G4X SDVOC doesn't have its own detect register */
15291 if (I915_READ(GEN3_SDVOB
) & SDVO_DETECTED
) {
15292 DRM_DEBUG_KMS("probing SDVOC\n");
15293 found
= intel_sdvo_init(dev
, GEN3_SDVOC
, PORT_C
);
15296 if (!found
&& (I915_READ(GEN3_SDVOC
) & SDVO_DETECTED
)) {
15299 DRM_DEBUG_KMS("probing HDMI on SDVOC\n");
15300 intel_hdmi_init(dev
, GEN4_HDMIC
, PORT_C
);
15303 intel_dp_init(dev
, DP_C
, PORT_C
);
15307 (I915_READ(DP_D
) & DP_DETECTED
))
15308 intel_dp_init(dev
, DP_D
, PORT_D
);
15309 } else if (IS_GEN2(dev
))
15310 intel_dvo_init(dev
);
15312 if (SUPPORTS_TV(dev
))
15313 intel_tv_init(dev
);
15315 intel_psr_init(dev
);
15317 for_each_intel_encoder(dev
, encoder
) {
15318 encoder
->base
.possible_crtcs
= encoder
->crtc_mask
;
15319 encoder
->base
.possible_clones
=
15320 intel_encoder_clones(encoder
);
15323 intel_init_pch_refclk(dev
);
15325 drm_helper_move_panel_connectors_to_head(dev
);
15328 static void intel_user_framebuffer_destroy(struct drm_framebuffer
*fb
)
15330 struct drm_device
*dev
= fb
->dev
;
15331 struct intel_framebuffer
*intel_fb
= to_intel_framebuffer(fb
);
15333 drm_framebuffer_cleanup(fb
);
15334 mutex_lock(&dev
->struct_mutex
);
15335 WARN_ON(!intel_fb
->obj
->framebuffer_references
--);
15336 i915_gem_object_put(intel_fb
->obj
);
15337 mutex_unlock(&dev
->struct_mutex
);
15341 static int intel_user_framebuffer_create_handle(struct drm_framebuffer
*fb
,
15342 struct drm_file
*file
,
15343 unsigned int *handle
)
15345 struct intel_framebuffer
*intel_fb
= to_intel_framebuffer(fb
);
15346 struct drm_i915_gem_object
*obj
= intel_fb
->obj
;
15348 if (obj
->userptr
.mm
) {
15349 DRM_DEBUG("attempting to use a userptr for a framebuffer, denied\n");
15353 return drm_gem_handle_create(file
, &obj
->base
, handle
);
15356 static int intel_user_framebuffer_dirty(struct drm_framebuffer
*fb
,
15357 struct drm_file
*file
,
15358 unsigned flags
, unsigned color
,
15359 struct drm_clip_rect
*clips
,
15360 unsigned num_clips
)
15362 struct drm_device
*dev
= fb
->dev
;
15363 struct intel_framebuffer
*intel_fb
= to_intel_framebuffer(fb
);
15364 struct drm_i915_gem_object
*obj
= intel_fb
->obj
;
15366 mutex_lock(&dev
->struct_mutex
);
15367 intel_fb_obj_flush(obj
, false, ORIGIN_DIRTYFB
);
15368 mutex_unlock(&dev
->struct_mutex
);
15373 static const struct drm_framebuffer_funcs intel_fb_funcs
= {
15374 .destroy
= intel_user_framebuffer_destroy
,
15375 .create_handle
= intel_user_framebuffer_create_handle
,
15376 .dirty
= intel_user_framebuffer_dirty
,
15380 u32
intel_fb_pitch_limit(struct drm_device
*dev
, uint64_t fb_modifier
,
15381 uint32_t pixel_format
)
15383 u32 gen
= INTEL_INFO(dev
)->gen
;
15386 int cpp
= drm_format_plane_cpp(pixel_format
, 0);
15388 /* "The stride in bytes must not exceed the of the size of 8K
15389 * pixels and 32K bytes."
15391 return min(8192 * cpp
, 32768);
15392 } else if (gen
>= 5 && !IS_VALLEYVIEW(dev
) && !IS_CHERRYVIEW(dev
)) {
15394 } else if (gen
>= 4) {
15395 if (fb_modifier
== I915_FORMAT_MOD_X_TILED
)
15399 } else if (gen
>= 3) {
15400 if (fb_modifier
== I915_FORMAT_MOD_X_TILED
)
15405 /* XXX DSPC is limited to 4k tiled */
15410 static int intel_framebuffer_init(struct drm_device
*dev
,
15411 struct intel_framebuffer
*intel_fb
,
15412 struct drm_mode_fb_cmd2
*mode_cmd
,
15413 struct drm_i915_gem_object
*obj
)
15415 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15416 unsigned int tiling
= i915_gem_object_get_tiling(obj
);
15418 u32 pitch_limit
, stride_alignment
;
15420 WARN_ON(!mutex_is_locked(&dev
->struct_mutex
));
15422 if (mode_cmd
->flags
& DRM_MODE_FB_MODIFIERS
) {
15424 * If there's a fence, enforce that
15425 * the fb modifier and tiling mode match.
15427 if (tiling
!= I915_TILING_NONE
&&
15428 tiling
!= intel_fb_modifier_to_tiling(mode_cmd
->modifier
[0])) {
15429 DRM_DEBUG("tiling_mode doesn't match fb modifier\n");
15433 if (tiling
== I915_TILING_X
) {
15434 mode_cmd
->modifier
[0] = I915_FORMAT_MOD_X_TILED
;
15435 } else if (tiling
== I915_TILING_Y
) {
15436 DRM_DEBUG("No Y tiling for legacy addfb\n");
15441 /* Passed in modifier sanity checking. */
15442 switch (mode_cmd
->modifier
[0]) {
15443 case I915_FORMAT_MOD_Y_TILED
:
15444 case I915_FORMAT_MOD_Yf_TILED
:
15445 if (INTEL_INFO(dev
)->gen
< 9) {
15446 DRM_DEBUG("Unsupported tiling 0x%llx!\n",
15447 mode_cmd
->modifier
[0]);
15450 case DRM_FORMAT_MOD_NONE
:
15451 case I915_FORMAT_MOD_X_TILED
:
15454 DRM_DEBUG("Unsupported fb modifier 0x%llx!\n",
15455 mode_cmd
->modifier
[0]);
15460 * gen2/3 display engine uses the fence if present,
15461 * so the tiling mode must match the fb modifier exactly.
15463 if (INTEL_INFO(dev_priv
)->gen
< 4 &&
15464 tiling
!= intel_fb_modifier_to_tiling(mode_cmd
->modifier
[0])) {
15465 DRM_DEBUG("tiling_mode must match fb modifier exactly on gen2/3\n");
15469 stride_alignment
= intel_fb_stride_alignment(dev_priv
,
15470 mode_cmd
->modifier
[0],
15471 mode_cmd
->pixel_format
);
15472 if (mode_cmd
->pitches
[0] & (stride_alignment
- 1)) {
15473 DRM_DEBUG("pitch (%d) must be at least %u byte aligned\n",
15474 mode_cmd
->pitches
[0], stride_alignment
);
15478 pitch_limit
= intel_fb_pitch_limit(dev
, mode_cmd
->modifier
[0],
15479 mode_cmd
->pixel_format
);
15480 if (mode_cmd
->pitches
[0] > pitch_limit
) {
15481 DRM_DEBUG("%s pitch (%u) must be at less than %d\n",
15482 mode_cmd
->modifier
[0] != DRM_FORMAT_MOD_NONE
?
15483 "tiled" : "linear",
15484 mode_cmd
->pitches
[0], pitch_limit
);
15489 * If there's a fence, enforce that
15490 * the fb pitch and fence stride match.
15492 if (tiling
!= I915_TILING_NONE
&&
15493 mode_cmd
->pitches
[0] != i915_gem_object_get_stride(obj
)) {
15494 DRM_DEBUG("pitch (%d) must match tiling stride (%d)\n",
15495 mode_cmd
->pitches
[0],
15496 i915_gem_object_get_stride(obj
));
15500 /* Reject formats not supported by any plane early. */
15501 switch (mode_cmd
->pixel_format
) {
15502 case DRM_FORMAT_C8
:
15503 case DRM_FORMAT_RGB565
:
15504 case DRM_FORMAT_XRGB8888
:
15505 case DRM_FORMAT_ARGB8888
:
15507 case DRM_FORMAT_XRGB1555
:
15508 if (INTEL_INFO(dev
)->gen
> 3) {
15509 DRM_DEBUG("unsupported pixel format: %s\n",
15510 drm_get_format_name(mode_cmd
->pixel_format
));
15514 case DRM_FORMAT_ABGR8888
:
15515 if (!IS_VALLEYVIEW(dev
) && !IS_CHERRYVIEW(dev
) &&
15516 INTEL_INFO(dev
)->gen
< 9) {
15517 DRM_DEBUG("unsupported pixel format: %s\n",
15518 drm_get_format_name(mode_cmd
->pixel_format
));
15522 case DRM_FORMAT_XBGR8888
:
15523 case DRM_FORMAT_XRGB2101010
:
15524 case DRM_FORMAT_XBGR2101010
:
15525 if (INTEL_INFO(dev
)->gen
< 4) {
15526 DRM_DEBUG("unsupported pixel format: %s\n",
15527 drm_get_format_name(mode_cmd
->pixel_format
));
15531 case DRM_FORMAT_ABGR2101010
:
15532 if (!IS_VALLEYVIEW(dev
) && !IS_CHERRYVIEW(dev
)) {
15533 DRM_DEBUG("unsupported pixel format: %s\n",
15534 drm_get_format_name(mode_cmd
->pixel_format
));
15538 case DRM_FORMAT_YUYV
:
15539 case DRM_FORMAT_UYVY
:
15540 case DRM_FORMAT_YVYU
:
15541 case DRM_FORMAT_VYUY
:
15542 if (INTEL_INFO(dev
)->gen
< 5) {
15543 DRM_DEBUG("unsupported pixel format: %s\n",
15544 drm_get_format_name(mode_cmd
->pixel_format
));
15549 DRM_DEBUG("unsupported pixel format: %s\n",
15550 drm_get_format_name(mode_cmd
->pixel_format
));
15554 /* FIXME need to adjust LINOFF/TILEOFF accordingly. */
15555 if (mode_cmd
->offsets
[0] != 0)
15558 drm_helper_mode_fill_fb_struct(&intel_fb
->base
, mode_cmd
);
15559 intel_fb
->obj
= obj
;
15561 ret
= intel_fill_fb_info(dev_priv
, &intel_fb
->base
);
15565 ret
= drm_framebuffer_init(dev
, &intel_fb
->base
, &intel_fb_funcs
);
15567 DRM_ERROR("framebuffer init failed %d\n", ret
);
15571 intel_fb
->obj
->framebuffer_references
++;
15576 static struct drm_framebuffer
*
15577 intel_user_framebuffer_create(struct drm_device
*dev
,
15578 struct drm_file
*filp
,
15579 const struct drm_mode_fb_cmd2
*user_mode_cmd
)
15581 struct drm_framebuffer
*fb
;
15582 struct drm_i915_gem_object
*obj
;
15583 struct drm_mode_fb_cmd2 mode_cmd
= *user_mode_cmd
;
15585 obj
= i915_gem_object_lookup(filp
, mode_cmd
.handles
[0]);
15587 return ERR_PTR(-ENOENT
);
15589 fb
= intel_framebuffer_create(dev
, &mode_cmd
, obj
);
15591 i915_gem_object_put_unlocked(obj
);
15596 #ifndef CONFIG_DRM_FBDEV_EMULATION
15597 static inline void intel_fbdev_output_poll_changed(struct drm_device
*dev
)
15602 static const struct drm_mode_config_funcs intel_mode_funcs
= {
15603 .fb_create
= intel_user_framebuffer_create
,
15604 .output_poll_changed
= intel_fbdev_output_poll_changed
,
15605 .atomic_check
= intel_atomic_check
,
15606 .atomic_commit
= intel_atomic_commit
,
15607 .atomic_state_alloc
= intel_atomic_state_alloc
,
15608 .atomic_state_clear
= intel_atomic_state_clear
,
15612 * intel_init_display_hooks - initialize the display modesetting hooks
15613 * @dev_priv: device private
15615 void intel_init_display_hooks(struct drm_i915_private
*dev_priv
)
15617 if (INTEL_INFO(dev_priv
)->gen
>= 9) {
15618 dev_priv
->display
.get_pipe_config
= haswell_get_pipe_config
;
15619 dev_priv
->display
.get_initial_plane_config
=
15620 skylake_get_initial_plane_config
;
15621 dev_priv
->display
.crtc_compute_clock
=
15622 haswell_crtc_compute_clock
;
15623 dev_priv
->display
.crtc_enable
= haswell_crtc_enable
;
15624 dev_priv
->display
.crtc_disable
= haswell_crtc_disable
;
15625 } else if (HAS_DDI(dev_priv
)) {
15626 dev_priv
->display
.get_pipe_config
= haswell_get_pipe_config
;
15627 dev_priv
->display
.get_initial_plane_config
=
15628 ironlake_get_initial_plane_config
;
15629 dev_priv
->display
.crtc_compute_clock
=
15630 haswell_crtc_compute_clock
;
15631 dev_priv
->display
.crtc_enable
= haswell_crtc_enable
;
15632 dev_priv
->display
.crtc_disable
= haswell_crtc_disable
;
15633 } else if (HAS_PCH_SPLIT(dev_priv
)) {
15634 dev_priv
->display
.get_pipe_config
= ironlake_get_pipe_config
;
15635 dev_priv
->display
.get_initial_plane_config
=
15636 ironlake_get_initial_plane_config
;
15637 dev_priv
->display
.crtc_compute_clock
=
15638 ironlake_crtc_compute_clock
;
15639 dev_priv
->display
.crtc_enable
= ironlake_crtc_enable
;
15640 dev_priv
->display
.crtc_disable
= ironlake_crtc_disable
;
15641 } else if (IS_CHERRYVIEW(dev_priv
)) {
15642 dev_priv
->display
.get_pipe_config
= i9xx_get_pipe_config
;
15643 dev_priv
->display
.get_initial_plane_config
=
15644 i9xx_get_initial_plane_config
;
15645 dev_priv
->display
.crtc_compute_clock
= chv_crtc_compute_clock
;
15646 dev_priv
->display
.crtc_enable
= valleyview_crtc_enable
;
15647 dev_priv
->display
.crtc_disable
= i9xx_crtc_disable
;
15648 } else if (IS_VALLEYVIEW(dev_priv
)) {
15649 dev_priv
->display
.get_pipe_config
= i9xx_get_pipe_config
;
15650 dev_priv
->display
.get_initial_plane_config
=
15651 i9xx_get_initial_plane_config
;
15652 dev_priv
->display
.crtc_compute_clock
= vlv_crtc_compute_clock
;
15653 dev_priv
->display
.crtc_enable
= valleyview_crtc_enable
;
15654 dev_priv
->display
.crtc_disable
= i9xx_crtc_disable
;
15655 } else if (IS_G4X(dev_priv
)) {
15656 dev_priv
->display
.get_pipe_config
= i9xx_get_pipe_config
;
15657 dev_priv
->display
.get_initial_plane_config
=
15658 i9xx_get_initial_plane_config
;
15659 dev_priv
->display
.crtc_compute_clock
= g4x_crtc_compute_clock
;
15660 dev_priv
->display
.crtc_enable
= i9xx_crtc_enable
;
15661 dev_priv
->display
.crtc_disable
= i9xx_crtc_disable
;
15662 } else if (IS_PINEVIEW(dev_priv
)) {
15663 dev_priv
->display
.get_pipe_config
= i9xx_get_pipe_config
;
15664 dev_priv
->display
.get_initial_plane_config
=
15665 i9xx_get_initial_plane_config
;
15666 dev_priv
->display
.crtc_compute_clock
= pnv_crtc_compute_clock
;
15667 dev_priv
->display
.crtc_enable
= i9xx_crtc_enable
;
15668 dev_priv
->display
.crtc_disable
= i9xx_crtc_disable
;
15669 } else if (!IS_GEN2(dev_priv
)) {
15670 dev_priv
->display
.get_pipe_config
= i9xx_get_pipe_config
;
15671 dev_priv
->display
.get_initial_plane_config
=
15672 i9xx_get_initial_plane_config
;
15673 dev_priv
->display
.crtc_compute_clock
= i9xx_crtc_compute_clock
;
15674 dev_priv
->display
.crtc_enable
= i9xx_crtc_enable
;
15675 dev_priv
->display
.crtc_disable
= i9xx_crtc_disable
;
15677 dev_priv
->display
.get_pipe_config
= i9xx_get_pipe_config
;
15678 dev_priv
->display
.get_initial_plane_config
=
15679 i9xx_get_initial_plane_config
;
15680 dev_priv
->display
.crtc_compute_clock
= i8xx_crtc_compute_clock
;
15681 dev_priv
->display
.crtc_enable
= i9xx_crtc_enable
;
15682 dev_priv
->display
.crtc_disable
= i9xx_crtc_disable
;
15685 /* Returns the core display clock speed */
15686 if (IS_SKYLAKE(dev_priv
) || IS_KABYLAKE(dev_priv
))
15687 dev_priv
->display
.get_display_clock_speed
=
15688 skylake_get_display_clock_speed
;
15689 else if (IS_BROXTON(dev_priv
))
15690 dev_priv
->display
.get_display_clock_speed
=
15691 broxton_get_display_clock_speed
;
15692 else if (IS_BROADWELL(dev_priv
))
15693 dev_priv
->display
.get_display_clock_speed
=
15694 broadwell_get_display_clock_speed
;
15695 else if (IS_HASWELL(dev_priv
))
15696 dev_priv
->display
.get_display_clock_speed
=
15697 haswell_get_display_clock_speed
;
15698 else if (IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
))
15699 dev_priv
->display
.get_display_clock_speed
=
15700 valleyview_get_display_clock_speed
;
15701 else if (IS_GEN5(dev_priv
))
15702 dev_priv
->display
.get_display_clock_speed
=
15703 ilk_get_display_clock_speed
;
15704 else if (IS_I945G(dev_priv
) || IS_BROADWATER(dev_priv
) ||
15705 IS_GEN6(dev_priv
) || IS_IVYBRIDGE(dev_priv
))
15706 dev_priv
->display
.get_display_clock_speed
=
15707 i945_get_display_clock_speed
;
15708 else if (IS_GM45(dev_priv
))
15709 dev_priv
->display
.get_display_clock_speed
=
15710 gm45_get_display_clock_speed
;
15711 else if (IS_CRESTLINE(dev_priv
))
15712 dev_priv
->display
.get_display_clock_speed
=
15713 i965gm_get_display_clock_speed
;
15714 else if (IS_PINEVIEW(dev_priv
))
15715 dev_priv
->display
.get_display_clock_speed
=
15716 pnv_get_display_clock_speed
;
15717 else if (IS_G33(dev_priv
) || IS_G4X(dev_priv
))
15718 dev_priv
->display
.get_display_clock_speed
=
15719 g33_get_display_clock_speed
;
15720 else if (IS_I915G(dev_priv
))
15721 dev_priv
->display
.get_display_clock_speed
=
15722 i915_get_display_clock_speed
;
15723 else if (IS_I945GM(dev_priv
) || IS_845G(dev_priv
))
15724 dev_priv
->display
.get_display_clock_speed
=
15725 i9xx_misc_get_display_clock_speed
;
15726 else if (IS_I915GM(dev_priv
))
15727 dev_priv
->display
.get_display_clock_speed
=
15728 i915gm_get_display_clock_speed
;
15729 else if (IS_I865G(dev_priv
))
15730 dev_priv
->display
.get_display_clock_speed
=
15731 i865_get_display_clock_speed
;
15732 else if (IS_I85X(dev_priv
))
15733 dev_priv
->display
.get_display_clock_speed
=
15734 i85x_get_display_clock_speed
;
15736 WARN(!IS_I830(dev_priv
), "Unknown platform. Assuming 133 MHz CDCLK\n");
15737 dev_priv
->display
.get_display_clock_speed
=
15738 i830_get_display_clock_speed
;
15741 if (IS_GEN5(dev_priv
)) {
15742 dev_priv
->display
.fdi_link_train
= ironlake_fdi_link_train
;
15743 } else if (IS_GEN6(dev_priv
)) {
15744 dev_priv
->display
.fdi_link_train
= gen6_fdi_link_train
;
15745 } else if (IS_IVYBRIDGE(dev_priv
)) {
15746 /* FIXME: detect B0+ stepping and use auto training */
15747 dev_priv
->display
.fdi_link_train
= ivb_manual_fdi_link_train
;
15748 } else if (IS_HASWELL(dev_priv
) || IS_BROADWELL(dev_priv
)) {
15749 dev_priv
->display
.fdi_link_train
= hsw_fdi_link_train
;
15752 if (IS_BROADWELL(dev_priv
)) {
15753 dev_priv
->display
.modeset_commit_cdclk
=
15754 broadwell_modeset_commit_cdclk
;
15755 dev_priv
->display
.modeset_calc_cdclk
=
15756 broadwell_modeset_calc_cdclk
;
15757 } else if (IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
)) {
15758 dev_priv
->display
.modeset_commit_cdclk
=
15759 valleyview_modeset_commit_cdclk
;
15760 dev_priv
->display
.modeset_calc_cdclk
=
15761 valleyview_modeset_calc_cdclk
;
15762 } else if (IS_BROXTON(dev_priv
)) {
15763 dev_priv
->display
.modeset_commit_cdclk
=
15764 bxt_modeset_commit_cdclk
;
15765 dev_priv
->display
.modeset_calc_cdclk
=
15766 bxt_modeset_calc_cdclk
;
15767 } else if (IS_SKYLAKE(dev_priv
) || IS_KABYLAKE(dev_priv
)) {
15768 dev_priv
->display
.modeset_commit_cdclk
=
15769 skl_modeset_commit_cdclk
;
15770 dev_priv
->display
.modeset_calc_cdclk
=
15771 skl_modeset_calc_cdclk
;
15774 switch (INTEL_INFO(dev_priv
)->gen
) {
15776 dev_priv
->display
.queue_flip
= intel_gen2_queue_flip
;
15780 dev_priv
->display
.queue_flip
= intel_gen3_queue_flip
;
15785 dev_priv
->display
.queue_flip
= intel_gen4_queue_flip
;
15789 dev_priv
->display
.queue_flip
= intel_gen6_queue_flip
;
15792 case 8: /* FIXME(BDW): Check that the gen8 RCS flip works. */
15793 dev_priv
->display
.queue_flip
= intel_gen7_queue_flip
;
15796 /* Drop through - unsupported since execlist only. */
15798 /* Default just returns -ENODEV to indicate unsupported */
15799 dev_priv
->display
.queue_flip
= intel_default_queue_flip
;
15804 * Some BIOSes insist on assuming the GPU's pipe A is enabled at suspend,
15805 * resume, or other times. This quirk makes sure that's the case for
15806 * affected systems.
15808 static void quirk_pipea_force(struct drm_device
*dev
)
15810 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15812 dev_priv
->quirks
|= QUIRK_PIPEA_FORCE
;
15813 DRM_INFO("applying pipe a force quirk\n");
15816 static void quirk_pipeb_force(struct drm_device
*dev
)
15818 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15820 dev_priv
->quirks
|= QUIRK_PIPEB_FORCE
;
15821 DRM_INFO("applying pipe b force quirk\n");
15825 * Some machines (Lenovo U160) do not work with SSC on LVDS for some reason
15827 static void quirk_ssc_force_disable(struct drm_device
*dev
)
15829 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15830 dev_priv
->quirks
|= QUIRK_LVDS_SSC_DISABLE
;
15831 DRM_INFO("applying lvds SSC disable quirk\n");
15835 * A machine (e.g. Acer Aspire 5734Z) may need to invert the panel backlight
15838 static void quirk_invert_brightness(struct drm_device
*dev
)
15840 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15841 dev_priv
->quirks
|= QUIRK_INVERT_BRIGHTNESS
;
15842 DRM_INFO("applying inverted panel brightness quirk\n");
15845 /* Some VBT's incorrectly indicate no backlight is present */
15846 static void quirk_backlight_present(struct drm_device
*dev
)
15848 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15849 dev_priv
->quirks
|= QUIRK_BACKLIGHT_PRESENT
;
15850 DRM_INFO("applying backlight present quirk\n");
15853 struct intel_quirk
{
15855 int subsystem_vendor
;
15856 int subsystem_device
;
15857 void (*hook
)(struct drm_device
*dev
);
15860 /* For systems that don't have a meaningful PCI subdevice/subvendor ID */
15861 struct intel_dmi_quirk
{
15862 void (*hook
)(struct drm_device
*dev
);
15863 const struct dmi_system_id (*dmi_id_list
)[];
15866 static int intel_dmi_reverse_brightness(const struct dmi_system_id
*id
)
15868 DRM_INFO("Backlight polarity reversed on %s\n", id
->ident
);
15872 static const struct intel_dmi_quirk intel_dmi_quirks
[] = {
15874 .dmi_id_list
= &(const struct dmi_system_id
[]) {
15876 .callback
= intel_dmi_reverse_brightness
,
15877 .ident
= "NCR Corporation",
15878 .matches
= {DMI_MATCH(DMI_SYS_VENDOR
, "NCR Corporation"),
15879 DMI_MATCH(DMI_PRODUCT_NAME
, ""),
15882 { } /* terminating entry */
15884 .hook
= quirk_invert_brightness
,
15888 static struct intel_quirk intel_quirks
[] = {
15889 /* Toshiba Protege R-205, S-209 needs pipe A force quirk */
15890 { 0x2592, 0x1179, 0x0001, quirk_pipea_force
},
15892 /* ThinkPad T60 needs pipe A force quirk (bug #16494) */
15893 { 0x2782, 0x17aa, 0x201a, quirk_pipea_force
},
15895 /* 830 needs to leave pipe A & dpll A up */
15896 { 0x3577, PCI_ANY_ID
, PCI_ANY_ID
, quirk_pipea_force
},
15898 /* 830 needs to leave pipe B & dpll B up */
15899 { 0x3577, PCI_ANY_ID
, PCI_ANY_ID
, quirk_pipeb_force
},
15901 /* Lenovo U160 cannot use SSC on LVDS */
15902 { 0x0046, 0x17aa, 0x3920, quirk_ssc_force_disable
},
15904 /* Sony Vaio Y cannot use SSC on LVDS */
15905 { 0x0046, 0x104d, 0x9076, quirk_ssc_force_disable
},
15907 /* Acer Aspire 5734Z must invert backlight brightness */
15908 { 0x2a42, 0x1025, 0x0459, quirk_invert_brightness
},
15910 /* Acer/eMachines G725 */
15911 { 0x2a42, 0x1025, 0x0210, quirk_invert_brightness
},
15913 /* Acer/eMachines e725 */
15914 { 0x2a42, 0x1025, 0x0212, quirk_invert_brightness
},
15916 /* Acer/Packard Bell NCL20 */
15917 { 0x2a42, 0x1025, 0x034b, quirk_invert_brightness
},
15919 /* Acer Aspire 4736Z */
15920 { 0x2a42, 0x1025, 0x0260, quirk_invert_brightness
},
15922 /* Acer Aspire 5336 */
15923 { 0x2a42, 0x1025, 0x048a, quirk_invert_brightness
},
15925 /* Acer C720 and C720P Chromebooks (Celeron 2955U) have backlights */
15926 { 0x0a06, 0x1025, 0x0a11, quirk_backlight_present
},
15928 /* Acer C720 Chromebook (Core i3 4005U) */
15929 { 0x0a16, 0x1025, 0x0a11, quirk_backlight_present
},
15931 /* Apple Macbook 2,1 (Core 2 T7400) */
15932 { 0x27a2, 0x8086, 0x7270, quirk_backlight_present
},
15934 /* Apple Macbook 4,1 */
15935 { 0x2a02, 0x106b, 0x00a1, quirk_backlight_present
},
15937 /* Toshiba CB35 Chromebook (Celeron 2955U) */
15938 { 0x0a06, 0x1179, 0x0a88, quirk_backlight_present
},
15940 /* HP Chromebook 14 (Celeron 2955U) */
15941 { 0x0a06, 0x103c, 0x21ed, quirk_backlight_present
},
15943 /* Dell Chromebook 11 */
15944 { 0x0a06, 0x1028, 0x0a35, quirk_backlight_present
},
15946 /* Dell Chromebook 11 (2015 version) */
15947 { 0x0a16, 0x1028, 0x0a35, quirk_backlight_present
},
15950 static void intel_init_quirks(struct drm_device
*dev
)
15952 struct pci_dev
*d
= dev
->pdev
;
15955 for (i
= 0; i
< ARRAY_SIZE(intel_quirks
); i
++) {
15956 struct intel_quirk
*q
= &intel_quirks
[i
];
15958 if (d
->device
== q
->device
&&
15959 (d
->subsystem_vendor
== q
->subsystem_vendor
||
15960 q
->subsystem_vendor
== PCI_ANY_ID
) &&
15961 (d
->subsystem_device
== q
->subsystem_device
||
15962 q
->subsystem_device
== PCI_ANY_ID
))
15965 for (i
= 0; i
< ARRAY_SIZE(intel_dmi_quirks
); i
++) {
15966 if (dmi_check_system(*intel_dmi_quirks
[i
].dmi_id_list
) != 0)
15967 intel_dmi_quirks
[i
].hook(dev
);
15971 /* Disable the VGA plane that we never use */
15972 static void i915_disable_vga(struct drm_device
*dev
)
15974 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15976 i915_reg_t vga_reg
= i915_vgacntrl_reg(dev
);
15978 /* WaEnableVGAAccessThroughIOPort:ctg,elk,ilk,snb,ivb,vlv,hsw */
15979 vga_get_uninterruptible(dev
->pdev
, VGA_RSRC_LEGACY_IO
);
15980 outb(SR01
, VGA_SR_INDEX
);
15981 sr1
= inb(VGA_SR_DATA
);
15982 outb(sr1
| 1<<5, VGA_SR_DATA
);
15983 vga_put(dev
->pdev
, VGA_RSRC_LEGACY_IO
);
15986 I915_WRITE(vga_reg
, VGA_DISP_DISABLE
);
15987 POSTING_READ(vga_reg
);
15990 void intel_modeset_init_hw(struct drm_device
*dev
)
15992 struct drm_i915_private
*dev_priv
= to_i915(dev
);
15994 intel_update_cdclk(dev
);
15996 dev_priv
->atomic_cdclk_freq
= dev_priv
->cdclk_freq
;
15998 intel_init_clock_gating(dev
);
16002 * Calculate what we think the watermarks should be for the state we've read
16003 * out of the hardware and then immediately program those watermarks so that
16004 * we ensure the hardware settings match our internal state.
16006 * We can calculate what we think WM's should be by creating a duplicate of the
16007 * current state (which was constructed during hardware readout) and running it
16008 * through the atomic check code to calculate new watermark values in the
16011 static void sanitize_watermarks(struct drm_device
*dev
)
16013 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16014 struct drm_atomic_state
*state
;
16015 struct drm_crtc
*crtc
;
16016 struct drm_crtc_state
*cstate
;
16017 struct drm_modeset_acquire_ctx ctx
;
16021 /* Only supported on platforms that use atomic watermark design */
16022 if (!dev_priv
->display
.optimize_watermarks
)
16026 * We need to hold connection_mutex before calling duplicate_state so
16027 * that the connector loop is protected.
16029 drm_modeset_acquire_init(&ctx
, 0);
16031 ret
= drm_modeset_lock_all_ctx(dev
, &ctx
);
16032 if (ret
== -EDEADLK
) {
16033 drm_modeset_backoff(&ctx
);
16035 } else if (WARN_ON(ret
)) {
16039 state
= drm_atomic_helper_duplicate_state(dev
, &ctx
);
16040 if (WARN_ON(IS_ERR(state
)))
16044 * Hardware readout is the only time we don't want to calculate
16045 * intermediate watermarks (since we don't trust the current
16048 to_intel_atomic_state(state
)->skip_intermediate_wm
= true;
16050 ret
= intel_atomic_check(dev
, state
);
16053 * If we fail here, it means that the hardware appears to be
16054 * programmed in a way that shouldn't be possible, given our
16055 * understanding of watermark requirements. This might mean a
16056 * mistake in the hardware readout code or a mistake in the
16057 * watermark calculations for a given platform. Raise a WARN
16058 * so that this is noticeable.
16060 * If this actually happens, we'll have to just leave the
16061 * BIOS-programmed watermarks untouched and hope for the best.
16063 WARN(true, "Could not determine valid watermarks for inherited state\n");
16067 /* Write calculated watermark values back */
16068 for_each_crtc_in_state(state
, crtc
, cstate
, i
) {
16069 struct intel_crtc_state
*cs
= to_intel_crtc_state(cstate
);
16071 cs
->wm
.need_postvbl_update
= true;
16072 dev_priv
->display
.optimize_watermarks(cs
);
16075 drm_atomic_state_free(state
);
16077 drm_modeset_drop_locks(&ctx
);
16078 drm_modeset_acquire_fini(&ctx
);
16081 void intel_modeset_init(struct drm_device
*dev
)
16083 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16084 struct i915_ggtt
*ggtt
= &dev_priv
->ggtt
;
16087 struct intel_crtc
*crtc
;
16089 drm_mode_config_init(dev
);
16091 dev
->mode_config
.min_width
= 0;
16092 dev
->mode_config
.min_height
= 0;
16094 dev
->mode_config
.preferred_depth
= 24;
16095 dev
->mode_config
.prefer_shadow
= 1;
16097 dev
->mode_config
.allow_fb_modifiers
= true;
16099 dev
->mode_config
.funcs
= &intel_mode_funcs
;
16101 intel_init_quirks(dev
);
16103 intel_init_pm(dev
);
16105 if (INTEL_INFO(dev
)->num_pipes
== 0)
16109 * There may be no VBT; and if the BIOS enabled SSC we can
16110 * just keep using it to avoid unnecessary flicker. Whereas if the
16111 * BIOS isn't using it, don't assume it will work even if the VBT
16112 * indicates as much.
16114 if (HAS_PCH_IBX(dev
) || HAS_PCH_CPT(dev
)) {
16115 bool bios_lvds_use_ssc
= !!(I915_READ(PCH_DREF_CONTROL
) &
16118 if (dev_priv
->vbt
.lvds_use_ssc
!= bios_lvds_use_ssc
) {
16119 DRM_DEBUG_KMS("SSC %sabled by BIOS, overriding VBT which says %sabled\n",
16120 bios_lvds_use_ssc
? "en" : "dis",
16121 dev_priv
->vbt
.lvds_use_ssc
? "en" : "dis");
16122 dev_priv
->vbt
.lvds_use_ssc
= bios_lvds_use_ssc
;
16126 if (IS_GEN2(dev
)) {
16127 dev
->mode_config
.max_width
= 2048;
16128 dev
->mode_config
.max_height
= 2048;
16129 } else if (IS_GEN3(dev
)) {
16130 dev
->mode_config
.max_width
= 4096;
16131 dev
->mode_config
.max_height
= 4096;
16133 dev
->mode_config
.max_width
= 8192;
16134 dev
->mode_config
.max_height
= 8192;
16137 if (IS_845G(dev
) || IS_I865G(dev
)) {
16138 dev
->mode_config
.cursor_width
= IS_845G(dev
) ? 64 : 512;
16139 dev
->mode_config
.cursor_height
= 1023;
16140 } else if (IS_GEN2(dev
)) {
16141 dev
->mode_config
.cursor_width
= GEN2_CURSOR_WIDTH
;
16142 dev
->mode_config
.cursor_height
= GEN2_CURSOR_HEIGHT
;
16144 dev
->mode_config
.cursor_width
= MAX_CURSOR_WIDTH
;
16145 dev
->mode_config
.cursor_height
= MAX_CURSOR_HEIGHT
;
16148 dev
->mode_config
.fb_base
= ggtt
->mappable_base
;
16150 DRM_DEBUG_KMS("%d display pipe%s available.\n",
16151 INTEL_INFO(dev
)->num_pipes
,
16152 INTEL_INFO(dev
)->num_pipes
> 1 ? "s" : "");
16154 for_each_pipe(dev_priv
, pipe
) {
16155 intel_crtc_init(dev
, pipe
);
16156 for_each_sprite(dev_priv
, pipe
, sprite
) {
16157 ret
= intel_plane_init(dev
, pipe
, sprite
);
16159 DRM_DEBUG_KMS("pipe %c sprite %c init failed: %d\n",
16160 pipe_name(pipe
), sprite_name(pipe
, sprite
), ret
);
16164 intel_update_czclk(dev_priv
);
16165 intel_update_cdclk(dev
);
16167 intel_shared_dpll_init(dev
);
16169 if (dev_priv
->max_cdclk_freq
== 0)
16170 intel_update_max_cdclk(dev
);
16172 /* Just disable it once at startup */
16173 i915_disable_vga(dev
);
16174 intel_setup_outputs(dev
);
16176 drm_modeset_lock_all(dev
);
16177 intel_modeset_setup_hw_state(dev
);
16178 drm_modeset_unlock_all(dev
);
16180 for_each_intel_crtc(dev
, crtc
) {
16181 struct intel_initial_plane_config plane_config
= {};
16187 * Note that reserving the BIOS fb up front prevents us
16188 * from stuffing other stolen allocations like the ring
16189 * on top. This prevents some ugliness at boot time, and
16190 * can even allow for smooth boot transitions if the BIOS
16191 * fb is large enough for the active pipe configuration.
16193 dev_priv
->display
.get_initial_plane_config(crtc
,
16197 * If the fb is shared between multiple heads, we'll
16198 * just get the first one.
16200 intel_find_initial_plane_obj(crtc
, &plane_config
);
16204 * Make sure hardware watermarks really match the state we read out.
16205 * Note that we need to do this after reconstructing the BIOS fb's
16206 * since the watermark calculation done here will use pstate->fb.
16208 sanitize_watermarks(dev
);
16211 static void intel_enable_pipe_a(struct drm_device
*dev
)
16213 struct intel_connector
*connector
;
16214 struct drm_connector
*crt
= NULL
;
16215 struct intel_load_detect_pipe load_detect_temp
;
16216 struct drm_modeset_acquire_ctx
*ctx
= dev
->mode_config
.acquire_ctx
;
16218 /* We can't just switch on the pipe A, we need to set things up with a
16219 * proper mode and output configuration. As a gross hack, enable pipe A
16220 * by enabling the load detect pipe once. */
16221 for_each_intel_connector(dev
, connector
) {
16222 if (connector
->encoder
->type
== INTEL_OUTPUT_ANALOG
) {
16223 crt
= &connector
->base
;
16231 if (intel_get_load_detect_pipe(crt
, NULL
, &load_detect_temp
, ctx
))
16232 intel_release_load_detect_pipe(crt
, &load_detect_temp
, ctx
);
16236 intel_check_plane_mapping(struct intel_crtc
*crtc
)
16238 struct drm_device
*dev
= crtc
->base
.dev
;
16239 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16242 if (INTEL_INFO(dev
)->num_pipes
== 1)
16245 val
= I915_READ(DSPCNTR(!crtc
->plane
));
16247 if ((val
& DISPLAY_PLANE_ENABLE
) &&
16248 (!!(val
& DISPPLANE_SEL_PIPE_MASK
) == crtc
->pipe
))
16254 static bool intel_crtc_has_encoders(struct intel_crtc
*crtc
)
16256 struct drm_device
*dev
= crtc
->base
.dev
;
16257 struct intel_encoder
*encoder
;
16259 for_each_encoder_on_crtc(dev
, &crtc
->base
, encoder
)
16265 static bool intel_encoder_has_connectors(struct intel_encoder
*encoder
)
16267 struct drm_device
*dev
= encoder
->base
.dev
;
16268 struct intel_connector
*connector
;
16270 for_each_connector_on_encoder(dev
, &encoder
->base
, connector
)
16276 static bool has_pch_trancoder(struct drm_i915_private
*dev_priv
,
16277 enum transcoder pch_transcoder
)
16279 return HAS_PCH_IBX(dev_priv
) || HAS_PCH_CPT(dev_priv
) ||
16280 (HAS_PCH_LPT_H(dev_priv
) && pch_transcoder
== TRANSCODER_A
);
16283 static void intel_sanitize_crtc(struct intel_crtc
*crtc
)
16285 struct drm_device
*dev
= crtc
->base
.dev
;
16286 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16287 enum transcoder cpu_transcoder
= crtc
->config
->cpu_transcoder
;
16289 /* Clear any frame start delays used for debugging left by the BIOS */
16290 if (!transcoder_is_dsi(cpu_transcoder
)) {
16291 i915_reg_t reg
= PIPECONF(cpu_transcoder
);
16294 I915_READ(reg
) & ~PIPECONF_FRAME_START_DELAY_MASK
);
16297 /* restore vblank interrupts to correct state */
16298 drm_crtc_vblank_reset(&crtc
->base
);
16299 if (crtc
->active
) {
16300 struct intel_plane
*plane
;
16302 drm_crtc_vblank_on(&crtc
->base
);
16304 /* Disable everything but the primary plane */
16305 for_each_intel_plane_on_crtc(dev
, crtc
, plane
) {
16306 if (plane
->base
.type
== DRM_PLANE_TYPE_PRIMARY
)
16309 plane
->disable_plane(&plane
->base
, &crtc
->base
);
16313 /* We need to sanitize the plane -> pipe mapping first because this will
16314 * disable the crtc (and hence change the state) if it is wrong. Note
16315 * that gen4+ has a fixed plane -> pipe mapping. */
16316 if (INTEL_INFO(dev
)->gen
< 4 && !intel_check_plane_mapping(crtc
)) {
16319 DRM_DEBUG_KMS("[CRTC:%d:%s] wrong plane connection detected!\n",
16320 crtc
->base
.base
.id
, crtc
->base
.name
);
16322 /* Pipe has the wrong plane attached and the plane is active.
16323 * Temporarily change the plane mapping and disable everything
16325 plane
= crtc
->plane
;
16326 to_intel_plane_state(crtc
->base
.primary
->state
)->base
.visible
= true;
16327 crtc
->plane
= !plane
;
16328 intel_crtc_disable_noatomic(&crtc
->base
);
16329 crtc
->plane
= plane
;
16332 if (dev_priv
->quirks
& QUIRK_PIPEA_FORCE
&&
16333 crtc
->pipe
== PIPE_A
&& !crtc
->active
) {
16334 /* BIOS forgot to enable pipe A, this mostly happens after
16335 * resume. Force-enable the pipe to fix this, the update_dpms
16336 * call below we restore the pipe to the right state, but leave
16337 * the required bits on. */
16338 intel_enable_pipe_a(dev
);
16341 /* Adjust the state of the output pipe according to whether we
16342 * have active connectors/encoders. */
16343 if (crtc
->active
&& !intel_crtc_has_encoders(crtc
))
16344 intel_crtc_disable_noatomic(&crtc
->base
);
16346 if (crtc
->active
|| HAS_GMCH_DISPLAY(dev
)) {
16348 * We start out with underrun reporting disabled to avoid races.
16349 * For correct bookkeeping mark this on active crtcs.
16351 * Also on gmch platforms we dont have any hardware bits to
16352 * disable the underrun reporting. Which means we need to start
16353 * out with underrun reporting disabled also on inactive pipes,
16354 * since otherwise we'll complain about the garbage we read when
16355 * e.g. coming up after runtime pm.
16357 * No protection against concurrent access is required - at
16358 * worst a fifo underrun happens which also sets this to false.
16360 crtc
->cpu_fifo_underrun_disabled
= true;
16362 * We track the PCH trancoder underrun reporting state
16363 * within the crtc. With crtc for pipe A housing the underrun
16364 * reporting state for PCH transcoder A, crtc for pipe B housing
16365 * it for PCH transcoder B, etc. LPT-H has only PCH transcoder A,
16366 * and marking underrun reporting as disabled for the non-existing
16367 * PCH transcoders B and C would prevent enabling the south
16368 * error interrupt (see cpt_can_enable_serr_int()).
16370 if (has_pch_trancoder(dev_priv
, (enum transcoder
)crtc
->pipe
))
16371 crtc
->pch_fifo_underrun_disabled
= true;
16375 static void intel_sanitize_encoder(struct intel_encoder
*encoder
)
16377 struct intel_connector
*connector
;
16378 struct drm_device
*dev
= encoder
->base
.dev
;
16380 /* We need to check both for a crtc link (meaning that the
16381 * encoder is active and trying to read from a pipe) and the
16382 * pipe itself being active. */
16383 bool has_active_crtc
= encoder
->base
.crtc
&&
16384 to_intel_crtc(encoder
->base
.crtc
)->active
;
16386 if (intel_encoder_has_connectors(encoder
) && !has_active_crtc
) {
16387 DRM_DEBUG_KMS("[ENCODER:%d:%s] has active connectors but no active pipe!\n",
16388 encoder
->base
.base
.id
,
16389 encoder
->base
.name
);
16391 /* Connector is active, but has no active pipe. This is
16392 * fallout from our resume register restoring. Disable
16393 * the encoder manually again. */
16394 if (encoder
->base
.crtc
) {
16395 DRM_DEBUG_KMS("[ENCODER:%d:%s] manually disabled\n",
16396 encoder
->base
.base
.id
,
16397 encoder
->base
.name
);
16398 encoder
->disable(encoder
);
16399 if (encoder
->post_disable
)
16400 encoder
->post_disable(encoder
);
16402 encoder
->base
.crtc
= NULL
;
16404 /* Inconsistent output/port/pipe state happens presumably due to
16405 * a bug in one of the get_hw_state functions. Or someplace else
16406 * in our code, like the register restore mess on resume. Clamp
16407 * things to off as a safer default. */
16408 for_each_intel_connector(dev
, connector
) {
16409 if (connector
->encoder
!= encoder
)
16411 connector
->base
.dpms
= DRM_MODE_DPMS_OFF
;
16412 connector
->base
.encoder
= NULL
;
16415 /* Enabled encoders without active connectors will be fixed in
16416 * the crtc fixup. */
16419 void i915_redisable_vga_power_on(struct drm_device
*dev
)
16421 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16422 i915_reg_t vga_reg
= i915_vgacntrl_reg(dev
);
16424 if (!(I915_READ(vga_reg
) & VGA_DISP_DISABLE
)) {
16425 DRM_DEBUG_KMS("Something enabled VGA plane, disabling it\n");
16426 i915_disable_vga(dev
);
16430 void i915_redisable_vga(struct drm_device
*dev
)
16432 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16434 /* This function can be called both from intel_modeset_setup_hw_state or
16435 * at a very early point in our resume sequence, where the power well
16436 * structures are not yet restored. Since this function is at a very
16437 * paranoid "someone might have enabled VGA while we were not looking"
16438 * level, just check if the power well is enabled instead of trying to
16439 * follow the "don't touch the power well if we don't need it" policy
16440 * the rest of the driver uses. */
16441 if (!intel_display_power_get_if_enabled(dev_priv
, POWER_DOMAIN_VGA
))
16444 i915_redisable_vga_power_on(dev
);
16446 intel_display_power_put(dev_priv
, POWER_DOMAIN_VGA
);
16449 static bool primary_get_hw_state(struct intel_plane
*plane
)
16451 struct drm_i915_private
*dev_priv
= to_i915(plane
->base
.dev
);
16453 return I915_READ(DSPCNTR(plane
->plane
)) & DISPLAY_PLANE_ENABLE
;
16456 /* FIXME read out full plane state for all planes */
16457 static void readout_plane_state(struct intel_crtc
*crtc
)
16459 struct drm_plane
*primary
= crtc
->base
.primary
;
16460 struct intel_plane_state
*plane_state
=
16461 to_intel_plane_state(primary
->state
);
16463 plane_state
->base
.visible
= crtc
->active
&&
16464 primary_get_hw_state(to_intel_plane(primary
));
16466 if (plane_state
->base
.visible
)
16467 crtc
->base
.state
->plane_mask
|= 1 << drm_plane_index(primary
);
16470 static void intel_modeset_readout_hw_state(struct drm_device
*dev
)
16472 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16474 struct intel_crtc
*crtc
;
16475 struct intel_encoder
*encoder
;
16476 struct intel_connector
*connector
;
16479 dev_priv
->active_crtcs
= 0;
16481 for_each_intel_crtc(dev
, crtc
) {
16482 struct intel_crtc_state
*crtc_state
= crtc
->config
;
16485 __drm_atomic_helper_crtc_destroy_state(&crtc_state
->base
);
16486 memset(crtc_state
, 0, sizeof(*crtc_state
));
16487 crtc_state
->base
.crtc
= &crtc
->base
;
16489 crtc_state
->base
.active
= crtc_state
->base
.enable
=
16490 dev_priv
->display
.get_pipe_config(crtc
, crtc_state
);
16492 crtc
->base
.enabled
= crtc_state
->base
.enable
;
16493 crtc
->active
= crtc_state
->base
.active
;
16495 if (crtc_state
->base
.active
) {
16496 dev_priv
->active_crtcs
|= 1 << crtc
->pipe
;
16498 if (INTEL_GEN(dev_priv
) >= 9 || IS_BROADWELL(dev_priv
))
16499 pixclk
= ilk_pipe_pixel_rate(crtc_state
);
16500 else if (IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
))
16501 pixclk
= crtc_state
->base
.adjusted_mode
.crtc_clock
;
16503 WARN_ON(dev_priv
->display
.modeset_calc_cdclk
);
16505 /* pixel rate mustn't exceed 95% of cdclk with IPS on BDW */
16506 if (IS_BROADWELL(dev_priv
) && crtc_state
->ips_enabled
)
16507 pixclk
= DIV_ROUND_UP(pixclk
* 100, 95);
16510 dev_priv
->min_pixclk
[crtc
->pipe
] = pixclk
;
16512 readout_plane_state(crtc
);
16514 DRM_DEBUG_KMS("[CRTC:%d:%s] hw state readout: %s\n",
16515 crtc
->base
.base
.id
, crtc
->base
.name
,
16516 crtc
->active
? "enabled" : "disabled");
16519 for (i
= 0; i
< dev_priv
->num_shared_dpll
; i
++) {
16520 struct intel_shared_dpll
*pll
= &dev_priv
->shared_dplls
[i
];
16522 pll
->on
= pll
->funcs
.get_hw_state(dev_priv
, pll
,
16523 &pll
->config
.hw_state
);
16524 pll
->config
.crtc_mask
= 0;
16525 for_each_intel_crtc(dev
, crtc
) {
16526 if (crtc
->active
&& crtc
->config
->shared_dpll
== pll
)
16527 pll
->config
.crtc_mask
|= 1 << crtc
->pipe
;
16529 pll
->active_mask
= pll
->config
.crtc_mask
;
16531 DRM_DEBUG_KMS("%s hw state readout: crtc_mask 0x%08x, on %i\n",
16532 pll
->name
, pll
->config
.crtc_mask
, pll
->on
);
16535 for_each_intel_encoder(dev
, encoder
) {
16538 if (encoder
->get_hw_state(encoder
, &pipe
)) {
16539 crtc
= to_intel_crtc(dev_priv
->pipe_to_crtc_mapping
[pipe
]);
16540 encoder
->base
.crtc
= &crtc
->base
;
16541 crtc
->config
->output_types
|= 1 << encoder
->type
;
16542 encoder
->get_config(encoder
, crtc
->config
);
16544 encoder
->base
.crtc
= NULL
;
16547 DRM_DEBUG_KMS("[ENCODER:%d:%s] hw state readout: %s, pipe %c\n",
16548 encoder
->base
.base
.id
,
16549 encoder
->base
.name
,
16550 encoder
->base
.crtc
? "enabled" : "disabled",
16554 for_each_intel_connector(dev
, connector
) {
16555 if (connector
->get_hw_state(connector
)) {
16556 connector
->base
.dpms
= DRM_MODE_DPMS_ON
;
16558 encoder
= connector
->encoder
;
16559 connector
->base
.encoder
= &encoder
->base
;
16561 if (encoder
->base
.crtc
&&
16562 encoder
->base
.crtc
->state
->active
) {
16564 * This has to be done during hardware readout
16565 * because anything calling .crtc_disable may
16566 * rely on the connector_mask being accurate.
16568 encoder
->base
.crtc
->state
->connector_mask
|=
16569 1 << drm_connector_index(&connector
->base
);
16570 encoder
->base
.crtc
->state
->encoder_mask
|=
16571 1 << drm_encoder_index(&encoder
->base
);
16575 connector
->base
.dpms
= DRM_MODE_DPMS_OFF
;
16576 connector
->base
.encoder
= NULL
;
16578 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] hw state readout: %s\n",
16579 connector
->base
.base
.id
,
16580 connector
->base
.name
,
16581 connector
->base
.encoder
? "enabled" : "disabled");
16584 for_each_intel_crtc(dev
, crtc
) {
16585 crtc
->base
.hwmode
= crtc
->config
->base
.adjusted_mode
;
16587 memset(&crtc
->base
.mode
, 0, sizeof(crtc
->base
.mode
));
16588 if (crtc
->base
.state
->active
) {
16589 intel_mode_from_pipe_config(&crtc
->base
.mode
, crtc
->config
);
16590 intel_mode_from_pipe_config(&crtc
->base
.state
->adjusted_mode
, crtc
->config
);
16591 WARN_ON(drm_atomic_set_mode_for_crtc(crtc
->base
.state
, &crtc
->base
.mode
));
16594 * The initial mode needs to be set in order to keep
16595 * the atomic core happy. It wants a valid mode if the
16596 * crtc's enabled, so we do the above call.
16598 * At this point some state updated by the connectors
16599 * in their ->detect() callback has not run yet, so
16600 * no recalculation can be done yet.
16602 * Even if we could do a recalculation and modeset
16603 * right now it would cause a double modeset if
16604 * fbdev or userspace chooses a different initial mode.
16606 * If that happens, someone indicated they wanted a
16607 * mode change, which means it's safe to do a full
16610 crtc
->base
.state
->mode
.private_flags
= I915_MODE_FLAG_INHERITED
;
16612 drm_calc_timestamping_constants(&crtc
->base
, &crtc
->base
.hwmode
);
16613 update_scanline_offset(crtc
);
16616 intel_pipe_config_sanity_check(dev_priv
, crtc
->config
);
16620 /* Scan out the current hw modeset state,
16621 * and sanitizes it to the current state
16624 intel_modeset_setup_hw_state(struct drm_device
*dev
)
16626 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16628 struct intel_crtc
*crtc
;
16629 struct intel_encoder
*encoder
;
16632 intel_modeset_readout_hw_state(dev
);
16634 /* HW state is read out, now we need to sanitize this mess. */
16635 for_each_intel_encoder(dev
, encoder
) {
16636 intel_sanitize_encoder(encoder
);
16639 for_each_pipe(dev_priv
, pipe
) {
16640 crtc
= to_intel_crtc(dev_priv
->pipe_to_crtc_mapping
[pipe
]);
16641 intel_sanitize_crtc(crtc
);
16642 intel_dump_pipe_config(crtc
, crtc
->config
,
16643 "[setup_hw_state]");
16646 intel_modeset_update_connector_atomic_state(dev
);
16648 for (i
= 0; i
< dev_priv
->num_shared_dpll
; i
++) {
16649 struct intel_shared_dpll
*pll
= &dev_priv
->shared_dplls
[i
];
16651 if (!pll
->on
|| pll
->active_mask
)
16654 DRM_DEBUG_KMS("%s enabled but not in use, disabling\n", pll
->name
);
16656 pll
->funcs
.disable(dev_priv
, pll
);
16660 if (IS_VALLEYVIEW(dev
) || IS_CHERRYVIEW(dev
))
16661 vlv_wm_get_hw_state(dev
);
16662 else if (IS_GEN9(dev
))
16663 skl_wm_get_hw_state(dev
);
16664 else if (HAS_PCH_SPLIT(dev
))
16665 ilk_wm_get_hw_state(dev
);
16667 for_each_intel_crtc(dev
, crtc
) {
16668 unsigned long put_domains
;
16670 put_domains
= modeset_get_crtc_power_domains(&crtc
->base
, crtc
->config
);
16671 if (WARN_ON(put_domains
))
16672 modeset_put_power_domains(dev_priv
, put_domains
);
16674 intel_display_set_init_power(dev_priv
, false);
16676 intel_fbc_init_pipe_state(dev_priv
);
16679 void intel_display_resume(struct drm_device
*dev
)
16681 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16682 struct drm_atomic_state
*state
= dev_priv
->modeset_restore_state
;
16683 struct drm_modeset_acquire_ctx ctx
;
16686 dev_priv
->modeset_restore_state
= NULL
;
16688 state
->acquire_ctx
= &ctx
;
16691 * This is a cludge because with real atomic modeset mode_config.mutex
16692 * won't be taken. Unfortunately some probed state like
16693 * audio_codec_enable is still protected by mode_config.mutex, so lock
16696 mutex_lock(&dev
->mode_config
.mutex
);
16697 drm_modeset_acquire_init(&ctx
, 0);
16700 ret
= drm_modeset_lock_all_ctx(dev
, &ctx
);
16701 if (ret
!= -EDEADLK
)
16704 drm_modeset_backoff(&ctx
);
16708 ret
= __intel_display_resume(dev
, state
);
16710 drm_modeset_drop_locks(&ctx
);
16711 drm_modeset_acquire_fini(&ctx
);
16712 mutex_unlock(&dev
->mode_config
.mutex
);
16715 DRM_ERROR("Restoring old state failed with %i\n", ret
);
16716 drm_atomic_state_free(state
);
16720 void intel_modeset_gem_init(struct drm_device
*dev
)
16722 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16723 struct drm_crtc
*c
;
16724 struct drm_i915_gem_object
*obj
;
16726 intel_init_gt_powersave(dev_priv
);
16728 intel_modeset_init_hw(dev
);
16730 intel_setup_overlay(dev_priv
);
16733 * Make sure any fbs we allocated at startup are properly
16734 * pinned & fenced. When we do the allocation it's too early
16737 for_each_crtc(dev
, c
) {
16738 struct i915_vma
*vma
;
16740 obj
= intel_fb_obj(c
->primary
->fb
);
16744 mutex_lock(&dev
->struct_mutex
);
16745 vma
= intel_pin_and_fence_fb_obj(c
->primary
->fb
,
16746 c
->primary
->state
->rotation
);
16747 mutex_unlock(&dev
->struct_mutex
);
16749 DRM_ERROR("failed to pin boot fb on pipe %d\n",
16750 to_intel_crtc(c
)->pipe
);
16751 drm_framebuffer_unreference(c
->primary
->fb
);
16752 c
->primary
->fb
= NULL
;
16753 c
->primary
->crtc
= c
->primary
->state
->crtc
= NULL
;
16754 update_state_fb(c
->primary
);
16755 c
->state
->plane_mask
&= ~(1 << drm_plane_index(c
->primary
));
16760 int intel_connector_register(struct drm_connector
*connector
)
16762 struct intel_connector
*intel_connector
= to_intel_connector(connector
);
16765 ret
= intel_backlight_device_register(intel_connector
);
16775 void intel_connector_unregister(struct drm_connector
*connector
)
16777 struct intel_connector
*intel_connector
= to_intel_connector(connector
);
16779 intel_backlight_device_unregister(intel_connector
);
16780 intel_panel_destroy_backlight(connector
);
16783 void intel_modeset_cleanup(struct drm_device
*dev
)
16785 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16787 intel_disable_gt_powersave(dev_priv
);
16790 * Interrupts and polling as the first thing to avoid creating havoc.
16791 * Too much stuff here (turning of connectors, ...) would
16792 * experience fancy races otherwise.
16794 intel_irq_uninstall(dev_priv
);
16797 * Due to the hpd irq storm handling the hotplug work can re-arm the
16798 * poll handlers. Hence disable polling after hpd handling is shut down.
16800 drm_kms_helper_poll_fini(dev
);
16802 intel_unregister_dsm_handler();
16804 intel_fbc_global_disable(dev_priv
);
16806 /* flush any delayed tasks or pending work */
16807 flush_scheduled_work();
16809 drm_mode_config_cleanup(dev
);
16811 intel_cleanup_overlay(dev_priv
);
16813 intel_cleanup_gt_powersave(dev_priv
);
16815 intel_teardown_gmbus(dev
);
16818 void intel_connector_attach_encoder(struct intel_connector
*connector
,
16819 struct intel_encoder
*encoder
)
16821 connector
->encoder
= encoder
;
16822 drm_mode_connector_attach_encoder(&connector
->base
,
16827 * set vga decode state - true == enable VGA decode
16829 int intel_modeset_vga_set_state(struct drm_device
*dev
, bool state
)
16831 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16832 unsigned reg
= INTEL_INFO(dev
)->gen
>= 6 ? SNB_GMCH_CTRL
: INTEL_GMCH_CTRL
;
16835 if (pci_read_config_word(dev_priv
->bridge_dev
, reg
, &gmch_ctrl
)) {
16836 DRM_ERROR("failed to read control word\n");
16840 if (!!(gmch_ctrl
& INTEL_GMCH_VGA_DISABLE
) == !state
)
16844 gmch_ctrl
&= ~INTEL_GMCH_VGA_DISABLE
;
16846 gmch_ctrl
|= INTEL_GMCH_VGA_DISABLE
;
16848 if (pci_write_config_word(dev_priv
->bridge_dev
, reg
, gmch_ctrl
)) {
16849 DRM_ERROR("failed to write control word\n");
16856 struct intel_display_error_state
{
16858 u32 power_well_driver
;
16860 int num_transcoders
;
16862 struct intel_cursor_error_state
{
16867 } cursor
[I915_MAX_PIPES
];
16869 struct intel_pipe_error_state
{
16870 bool power_domain_on
;
16873 } pipe
[I915_MAX_PIPES
];
16875 struct intel_plane_error_state
{
16883 } plane
[I915_MAX_PIPES
];
16885 struct intel_transcoder_error_state
{
16886 bool power_domain_on
;
16887 enum transcoder cpu_transcoder
;
16900 struct intel_display_error_state
*
16901 intel_display_capture_error_state(struct drm_i915_private
*dev_priv
)
16903 struct intel_display_error_state
*error
;
16904 int transcoders
[] = {
16912 if (INTEL_INFO(dev_priv
)->num_pipes
== 0)
16915 error
= kzalloc(sizeof(*error
), GFP_ATOMIC
);
16919 if (IS_HASWELL(dev_priv
) || IS_BROADWELL(dev_priv
))
16920 error
->power_well_driver
= I915_READ(HSW_PWR_WELL_DRIVER
);
16922 for_each_pipe(dev_priv
, i
) {
16923 error
->pipe
[i
].power_domain_on
=
16924 __intel_display_power_is_enabled(dev_priv
,
16925 POWER_DOMAIN_PIPE(i
));
16926 if (!error
->pipe
[i
].power_domain_on
)
16929 error
->cursor
[i
].control
= I915_READ(CURCNTR(i
));
16930 error
->cursor
[i
].position
= I915_READ(CURPOS(i
));
16931 error
->cursor
[i
].base
= I915_READ(CURBASE(i
));
16933 error
->plane
[i
].control
= I915_READ(DSPCNTR(i
));
16934 error
->plane
[i
].stride
= I915_READ(DSPSTRIDE(i
));
16935 if (INTEL_GEN(dev_priv
) <= 3) {
16936 error
->plane
[i
].size
= I915_READ(DSPSIZE(i
));
16937 error
->plane
[i
].pos
= I915_READ(DSPPOS(i
));
16939 if (INTEL_GEN(dev_priv
) <= 7 && !IS_HASWELL(dev_priv
))
16940 error
->plane
[i
].addr
= I915_READ(DSPADDR(i
));
16941 if (INTEL_GEN(dev_priv
) >= 4) {
16942 error
->plane
[i
].surface
= I915_READ(DSPSURF(i
));
16943 error
->plane
[i
].tile_offset
= I915_READ(DSPTILEOFF(i
));
16946 error
->pipe
[i
].source
= I915_READ(PIPESRC(i
));
16948 if (HAS_GMCH_DISPLAY(dev_priv
))
16949 error
->pipe
[i
].stat
= I915_READ(PIPESTAT(i
));
16952 /* Note: this does not include DSI transcoders. */
16953 error
->num_transcoders
= INTEL_INFO(dev_priv
)->num_pipes
;
16954 if (HAS_DDI(dev_priv
))
16955 error
->num_transcoders
++; /* Account for eDP. */
16957 for (i
= 0; i
< error
->num_transcoders
; i
++) {
16958 enum transcoder cpu_transcoder
= transcoders
[i
];
16960 error
->transcoder
[i
].power_domain_on
=
16961 __intel_display_power_is_enabled(dev_priv
,
16962 POWER_DOMAIN_TRANSCODER(cpu_transcoder
));
16963 if (!error
->transcoder
[i
].power_domain_on
)
16966 error
->transcoder
[i
].cpu_transcoder
= cpu_transcoder
;
16968 error
->transcoder
[i
].conf
= I915_READ(PIPECONF(cpu_transcoder
));
16969 error
->transcoder
[i
].htotal
= I915_READ(HTOTAL(cpu_transcoder
));
16970 error
->transcoder
[i
].hblank
= I915_READ(HBLANK(cpu_transcoder
));
16971 error
->transcoder
[i
].hsync
= I915_READ(HSYNC(cpu_transcoder
));
16972 error
->transcoder
[i
].vtotal
= I915_READ(VTOTAL(cpu_transcoder
));
16973 error
->transcoder
[i
].vblank
= I915_READ(VBLANK(cpu_transcoder
));
16974 error
->transcoder
[i
].vsync
= I915_READ(VSYNC(cpu_transcoder
));
16980 #define err_printf(e, ...) i915_error_printf(e, __VA_ARGS__)
16983 intel_display_print_error_state(struct drm_i915_error_state_buf
*m
,
16984 struct drm_device
*dev
,
16985 struct intel_display_error_state
*error
)
16987 struct drm_i915_private
*dev_priv
= to_i915(dev
);
16993 err_printf(m
, "Num Pipes: %d\n", INTEL_INFO(dev
)->num_pipes
);
16994 if (IS_HASWELL(dev
) || IS_BROADWELL(dev
))
16995 err_printf(m
, "PWR_WELL_CTL2: %08x\n",
16996 error
->power_well_driver
);
16997 for_each_pipe(dev_priv
, i
) {
16998 err_printf(m
, "Pipe [%d]:\n", i
);
16999 err_printf(m
, " Power: %s\n",
17000 onoff(error
->pipe
[i
].power_domain_on
));
17001 err_printf(m
, " SRC: %08x\n", error
->pipe
[i
].source
);
17002 err_printf(m
, " STAT: %08x\n", error
->pipe
[i
].stat
);
17004 err_printf(m
, "Plane [%d]:\n", i
);
17005 err_printf(m
, " CNTR: %08x\n", error
->plane
[i
].control
);
17006 err_printf(m
, " STRIDE: %08x\n", error
->plane
[i
].stride
);
17007 if (INTEL_INFO(dev
)->gen
<= 3) {
17008 err_printf(m
, " SIZE: %08x\n", error
->plane
[i
].size
);
17009 err_printf(m
, " POS: %08x\n", error
->plane
[i
].pos
);
17011 if (INTEL_INFO(dev
)->gen
<= 7 && !IS_HASWELL(dev
))
17012 err_printf(m
, " ADDR: %08x\n", error
->plane
[i
].addr
);
17013 if (INTEL_INFO(dev
)->gen
>= 4) {
17014 err_printf(m
, " SURF: %08x\n", error
->plane
[i
].surface
);
17015 err_printf(m
, " TILEOFF: %08x\n", error
->plane
[i
].tile_offset
);
17018 err_printf(m
, "Cursor [%d]:\n", i
);
17019 err_printf(m
, " CNTR: %08x\n", error
->cursor
[i
].control
);
17020 err_printf(m
, " POS: %08x\n", error
->cursor
[i
].position
);
17021 err_printf(m
, " BASE: %08x\n", error
->cursor
[i
].base
);
17024 for (i
= 0; i
< error
->num_transcoders
; i
++) {
17025 err_printf(m
, "CPU transcoder: %s\n",
17026 transcoder_name(error
->transcoder
[i
].cpu_transcoder
));
17027 err_printf(m
, " Power: %s\n",
17028 onoff(error
->transcoder
[i
].power_domain_on
));
17029 err_printf(m
, " CONF: %08x\n", error
->transcoder
[i
].conf
);
17030 err_printf(m
, " HTOTAL: %08x\n", error
->transcoder
[i
].htotal
);
17031 err_printf(m
, " HBLANK: %08x\n", error
->transcoder
[i
].hblank
);
17032 err_printf(m
, " HSYNC: %08x\n", error
->transcoder
[i
].hsync
);
17033 err_printf(m
, " VTOTAL: %08x\n", error
->transcoder
[i
].vtotal
);
17034 err_printf(m
, " VBLANK: %08x\n", error
->transcoder
[i
].vblank
);
17035 err_printf(m
, " VSYNC: %08x\n", error
->transcoder
[i
].vsync
);