2 * Copyright © 2006-2010 Intel Corporation
3 * Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
25 * Eric Anholt <eric@anholt.net>
26 * Dave Airlie <airlied@linux.ie>
27 * Jesse Barnes <jesse.barnes@intel.com>
28 * Chris Wilson <chris@chris-wilson.co.uk>
31 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
33 #include <linux/moduleparam.h>
34 #include "intel_drv.h"
37 intel_fixed_panel_mode(const struct drm_display_mode
*fixed_mode
,
38 struct drm_display_mode
*adjusted_mode
)
40 drm_mode_copy(adjusted_mode
, fixed_mode
);
42 drm_mode_set_crtcinfo(adjusted_mode
, 0);
45 /* adjusted_mode has been preset to be the panel's fixed mode */
47 intel_pch_panel_fitting(struct intel_crtc
*intel_crtc
,
48 struct intel_crtc_config
*pipe_config
,
51 struct drm_display_mode
*adjusted_mode
;
52 int x
, y
, width
, height
;
54 adjusted_mode
= &pipe_config
->adjusted_mode
;
56 x
= y
= width
= height
= 0;
58 /* Native modes don't need fitting */
59 if (adjusted_mode
->hdisplay
== pipe_config
->pipe_src_w
&&
60 adjusted_mode
->vdisplay
== pipe_config
->pipe_src_h
)
63 switch (fitting_mode
) {
64 case DRM_MODE_SCALE_CENTER
:
65 width
= pipe_config
->pipe_src_w
;
66 height
= pipe_config
->pipe_src_h
;
67 x
= (adjusted_mode
->hdisplay
- width
+ 1)/2;
68 y
= (adjusted_mode
->vdisplay
- height
+ 1)/2;
71 case DRM_MODE_SCALE_ASPECT
:
72 /* Scale but preserve the aspect ratio */
74 u32 scaled_width
= adjusted_mode
->hdisplay
75 * pipe_config
->pipe_src_h
;
76 u32 scaled_height
= pipe_config
->pipe_src_w
77 * adjusted_mode
->vdisplay
;
78 if (scaled_width
> scaled_height
) { /* pillar */
79 width
= scaled_height
/ pipe_config
->pipe_src_h
;
82 x
= (adjusted_mode
->hdisplay
- width
+ 1) / 2;
84 height
= adjusted_mode
->vdisplay
;
85 } else if (scaled_width
< scaled_height
) { /* letter */
86 height
= scaled_width
/ pipe_config
->pipe_src_w
;
89 y
= (adjusted_mode
->vdisplay
- height
+ 1) / 2;
91 width
= adjusted_mode
->hdisplay
;
94 width
= adjusted_mode
->hdisplay
;
95 height
= adjusted_mode
->vdisplay
;
100 case DRM_MODE_SCALE_FULLSCREEN
:
102 width
= adjusted_mode
->hdisplay
;
103 height
= adjusted_mode
->vdisplay
;
107 WARN(1, "bad panel fit mode: %d\n", fitting_mode
);
112 pipe_config
->pch_pfit
.pos
= (x
<< 16) | y
;
113 pipe_config
->pch_pfit
.size
= (width
<< 16) | height
;
114 pipe_config
->pch_pfit
.enabled
= pipe_config
->pch_pfit
.size
!= 0;
118 centre_horizontally(struct drm_display_mode
*mode
,
121 u32 border
, sync_pos
, blank_width
, sync_width
;
123 /* keep the hsync and hblank widths constant */
124 sync_width
= mode
->crtc_hsync_end
- mode
->crtc_hsync_start
;
125 blank_width
= mode
->crtc_hblank_end
- mode
->crtc_hblank_start
;
126 sync_pos
= (blank_width
- sync_width
+ 1) / 2;
128 border
= (mode
->hdisplay
- width
+ 1) / 2;
129 border
+= border
& 1; /* make the border even */
131 mode
->crtc_hdisplay
= width
;
132 mode
->crtc_hblank_start
= width
+ border
;
133 mode
->crtc_hblank_end
= mode
->crtc_hblank_start
+ blank_width
;
135 mode
->crtc_hsync_start
= mode
->crtc_hblank_start
+ sync_pos
;
136 mode
->crtc_hsync_end
= mode
->crtc_hsync_start
+ sync_width
;
140 centre_vertically(struct drm_display_mode
*mode
,
143 u32 border
, sync_pos
, blank_width
, sync_width
;
145 /* keep the vsync and vblank widths constant */
146 sync_width
= mode
->crtc_vsync_end
- mode
->crtc_vsync_start
;
147 blank_width
= mode
->crtc_vblank_end
- mode
->crtc_vblank_start
;
148 sync_pos
= (blank_width
- sync_width
+ 1) / 2;
150 border
= (mode
->vdisplay
- height
+ 1) / 2;
152 mode
->crtc_vdisplay
= height
;
153 mode
->crtc_vblank_start
= height
+ border
;
154 mode
->crtc_vblank_end
= mode
->crtc_vblank_start
+ blank_width
;
156 mode
->crtc_vsync_start
= mode
->crtc_vblank_start
+ sync_pos
;
157 mode
->crtc_vsync_end
= mode
->crtc_vsync_start
+ sync_width
;
160 static inline u32
panel_fitter_scaling(u32 source
, u32 target
)
163 * Floating point operation is not supported. So the FACTOR
164 * is defined, which can avoid the floating point computation
165 * when calculating the panel ratio.
168 #define FACTOR (1 << ACCURACY)
169 u32 ratio
= source
* FACTOR
/ target
;
170 return (FACTOR
* ratio
+ FACTOR
/2) / FACTOR
;
173 static void i965_scale_aspect(struct intel_crtc_config
*pipe_config
,
176 struct drm_display_mode
*adjusted_mode
= &pipe_config
->adjusted_mode
;
177 u32 scaled_width
= adjusted_mode
->hdisplay
*
178 pipe_config
->pipe_src_h
;
179 u32 scaled_height
= pipe_config
->pipe_src_w
*
180 adjusted_mode
->vdisplay
;
182 /* 965+ is easy, it does everything in hw */
183 if (scaled_width
> scaled_height
)
184 *pfit_control
|= PFIT_ENABLE
|
186 else if (scaled_width
< scaled_height
)
187 *pfit_control
|= PFIT_ENABLE
|
189 else if (adjusted_mode
->hdisplay
!= pipe_config
->pipe_src_w
)
190 *pfit_control
|= PFIT_ENABLE
| PFIT_SCALING_AUTO
;
193 static void i9xx_scale_aspect(struct intel_crtc_config
*pipe_config
,
194 u32
*pfit_control
, u32
*pfit_pgm_ratios
,
197 struct drm_display_mode
*adjusted_mode
= &pipe_config
->adjusted_mode
;
198 u32 scaled_width
= adjusted_mode
->hdisplay
*
199 pipe_config
->pipe_src_h
;
200 u32 scaled_height
= pipe_config
->pipe_src_w
*
201 adjusted_mode
->vdisplay
;
205 * For earlier chips we have to calculate the scaling
206 * ratio by hand and program it into the
207 * PFIT_PGM_RATIO register
209 if (scaled_width
> scaled_height
) { /* pillar */
210 centre_horizontally(adjusted_mode
,
212 pipe_config
->pipe_src_h
);
214 *border
= LVDS_BORDER_ENABLE
;
215 if (pipe_config
->pipe_src_h
!= adjusted_mode
->vdisplay
) {
216 bits
= panel_fitter_scaling(pipe_config
->pipe_src_h
,
217 adjusted_mode
->vdisplay
);
219 *pfit_pgm_ratios
|= (bits
<< PFIT_HORIZ_SCALE_SHIFT
|
220 bits
<< PFIT_VERT_SCALE_SHIFT
);
221 *pfit_control
|= (PFIT_ENABLE
|
222 VERT_INTERP_BILINEAR
|
223 HORIZ_INTERP_BILINEAR
);
225 } else if (scaled_width
< scaled_height
) { /* letter */
226 centre_vertically(adjusted_mode
,
228 pipe_config
->pipe_src_w
);
230 *border
= LVDS_BORDER_ENABLE
;
231 if (pipe_config
->pipe_src_w
!= adjusted_mode
->hdisplay
) {
232 bits
= panel_fitter_scaling(pipe_config
->pipe_src_w
,
233 adjusted_mode
->hdisplay
);
235 *pfit_pgm_ratios
|= (bits
<< PFIT_HORIZ_SCALE_SHIFT
|
236 bits
<< PFIT_VERT_SCALE_SHIFT
);
237 *pfit_control
|= (PFIT_ENABLE
|
238 VERT_INTERP_BILINEAR
|
239 HORIZ_INTERP_BILINEAR
);
242 /* Aspects match, Let hw scale both directions */
243 *pfit_control
|= (PFIT_ENABLE
|
244 VERT_AUTO_SCALE
| HORIZ_AUTO_SCALE
|
245 VERT_INTERP_BILINEAR
|
246 HORIZ_INTERP_BILINEAR
);
250 void intel_gmch_panel_fitting(struct intel_crtc
*intel_crtc
,
251 struct intel_crtc_config
*pipe_config
,
254 struct drm_device
*dev
= intel_crtc
->base
.dev
;
255 u32 pfit_control
= 0, pfit_pgm_ratios
= 0, border
= 0;
256 struct drm_display_mode
*adjusted_mode
;
258 adjusted_mode
= &pipe_config
->adjusted_mode
;
260 /* Native modes don't need fitting */
261 if (adjusted_mode
->hdisplay
== pipe_config
->pipe_src_w
&&
262 adjusted_mode
->vdisplay
== pipe_config
->pipe_src_h
)
265 switch (fitting_mode
) {
266 case DRM_MODE_SCALE_CENTER
:
268 * For centered modes, we have to calculate border widths &
269 * heights and modify the values programmed into the CRTC.
271 centre_horizontally(adjusted_mode
, pipe_config
->pipe_src_w
);
272 centre_vertically(adjusted_mode
, pipe_config
->pipe_src_h
);
273 border
= LVDS_BORDER_ENABLE
;
275 case DRM_MODE_SCALE_ASPECT
:
276 /* Scale but preserve the aspect ratio */
277 if (INTEL_INFO(dev
)->gen
>= 4)
278 i965_scale_aspect(pipe_config
, &pfit_control
);
280 i9xx_scale_aspect(pipe_config
, &pfit_control
,
281 &pfit_pgm_ratios
, &border
);
283 case DRM_MODE_SCALE_FULLSCREEN
:
285 * Full scaling, even if it changes the aspect ratio.
286 * Fortunately this is all done for us in hw.
288 if (pipe_config
->pipe_src_h
!= adjusted_mode
->vdisplay
||
289 pipe_config
->pipe_src_w
!= adjusted_mode
->hdisplay
) {
290 pfit_control
|= PFIT_ENABLE
;
291 if (INTEL_INFO(dev
)->gen
>= 4)
292 pfit_control
|= PFIT_SCALING_AUTO
;
294 pfit_control
|= (VERT_AUTO_SCALE
|
295 VERT_INTERP_BILINEAR
|
297 HORIZ_INTERP_BILINEAR
);
301 WARN(1, "bad panel fit mode: %d\n", fitting_mode
);
305 /* 965+ wants fuzzy fitting */
306 /* FIXME: handle multiple panels by failing gracefully */
307 if (INTEL_INFO(dev
)->gen
>= 4)
308 pfit_control
|= ((intel_crtc
->pipe
<< PFIT_PIPE_SHIFT
) |
312 if ((pfit_control
& PFIT_ENABLE
) == 0) {
317 /* Make sure pre-965 set dither correctly for 18bpp panels. */
318 if (INTEL_INFO(dev
)->gen
< 4 && pipe_config
->pipe_bpp
== 18)
319 pfit_control
|= PANEL_8TO6_DITHER_ENABLE
;
321 pipe_config
->gmch_pfit
.control
= pfit_control
;
322 pipe_config
->gmch_pfit
.pgm_ratios
= pfit_pgm_ratios
;
323 pipe_config
->gmch_pfit
.lvds_border_bits
= border
;
326 static u32
intel_panel_compute_brightness(struct intel_connector
*connector
,
329 struct drm_device
*dev
= connector
->base
.dev
;
330 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
331 struct intel_panel
*panel
= &connector
->panel
;
333 WARN_ON(panel
->backlight
.max
== 0);
335 if (i915
.invert_brightness
< 0)
338 if (i915
.invert_brightness
> 0 ||
339 dev_priv
->quirks
& QUIRK_INVERT_BRIGHTNESS
) {
340 return panel
->backlight
.max
- val
;
346 static u32
bdw_get_backlight(struct intel_connector
*connector
)
348 struct drm_device
*dev
= connector
->base
.dev
;
349 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
351 return I915_READ(BLC_PWM_PCH_CTL2
) & BACKLIGHT_DUTY_CYCLE_MASK
;
354 static u32
pch_get_backlight(struct intel_connector
*connector
)
356 struct drm_device
*dev
= connector
->base
.dev
;
357 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
359 return I915_READ(BLC_PWM_CPU_CTL
) & BACKLIGHT_DUTY_CYCLE_MASK
;
362 static u32
i9xx_get_backlight(struct intel_connector
*connector
)
364 struct drm_device
*dev
= connector
->base
.dev
;
365 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
366 struct intel_panel
*panel
= &connector
->panel
;
369 val
= I915_READ(BLC_PWM_CTL
) & BACKLIGHT_DUTY_CYCLE_MASK
;
370 if (INTEL_INFO(dev
)->gen
< 4)
373 if (panel
->backlight
.combination_mode
) {
376 pci_read_config_byte(dev
->pdev
, PCI_LBPC
, &lbpc
);
383 static u32
_vlv_get_backlight(struct drm_device
*dev
, enum pipe pipe
)
385 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
387 return I915_READ(VLV_BLC_PWM_CTL(pipe
)) & BACKLIGHT_DUTY_CYCLE_MASK
;
390 static u32
vlv_get_backlight(struct intel_connector
*connector
)
392 struct drm_device
*dev
= connector
->base
.dev
;
393 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
395 return _vlv_get_backlight(dev
, pipe
);
398 static u32
intel_panel_get_backlight(struct intel_connector
*connector
)
400 struct drm_device
*dev
= connector
->base
.dev
;
401 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
405 spin_lock_irqsave(&dev_priv
->backlight_lock
, flags
);
407 val
= dev_priv
->display
.get_backlight(connector
);
408 val
= intel_panel_compute_brightness(connector
, val
);
410 spin_unlock_irqrestore(&dev_priv
->backlight_lock
, flags
);
412 DRM_DEBUG_DRIVER("get backlight PWM = %d\n", val
);
416 static void bdw_set_backlight(struct intel_connector
*connector
, u32 level
)
418 struct drm_device
*dev
= connector
->base
.dev
;
419 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
420 u32 val
= I915_READ(BLC_PWM_PCH_CTL2
) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
421 I915_WRITE(BLC_PWM_PCH_CTL2
, val
| level
);
424 static void pch_set_backlight(struct intel_connector
*connector
, u32 level
)
426 struct drm_device
*dev
= connector
->base
.dev
;
427 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
430 tmp
= I915_READ(BLC_PWM_CPU_CTL
) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
431 I915_WRITE(BLC_PWM_CPU_CTL
, tmp
| level
);
434 static void i9xx_set_backlight(struct intel_connector
*connector
, u32 level
)
436 struct drm_device
*dev
= connector
->base
.dev
;
437 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
438 struct intel_panel
*panel
= &connector
->panel
;
441 WARN_ON(panel
->backlight
.max
== 0);
443 if (panel
->backlight
.combination_mode
) {
446 lbpc
= level
* 0xfe / panel
->backlight
.max
+ 1;
448 pci_write_config_byte(dev
->pdev
, PCI_LBPC
, lbpc
);
452 mask
= BACKLIGHT_DUTY_CYCLE_MASK
;
455 mask
= BACKLIGHT_DUTY_CYCLE_MASK_PNV
;
458 tmp
= I915_READ(BLC_PWM_CTL
) & ~mask
;
459 I915_WRITE(BLC_PWM_CTL
, tmp
| level
);
462 static void vlv_set_backlight(struct intel_connector
*connector
, u32 level
)
464 struct drm_device
*dev
= connector
->base
.dev
;
465 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
466 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
469 tmp
= I915_READ(VLV_BLC_PWM_CTL(pipe
)) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
470 I915_WRITE(VLV_BLC_PWM_CTL(pipe
), tmp
| level
);
474 intel_panel_actually_set_backlight(struct intel_connector
*connector
, u32 level
)
476 struct drm_device
*dev
= connector
->base
.dev
;
477 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
479 DRM_DEBUG_DRIVER("set backlight PWM = %d\n", level
);
481 level
= intel_panel_compute_brightness(connector
, level
);
482 dev_priv
->display
.set_backlight(connector
, level
);
485 /* set backlight brightness to level in range [0..max] */
486 void intel_panel_set_backlight(struct intel_connector
*connector
, u32 level
,
489 struct drm_device
*dev
= connector
->base
.dev
;
490 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
491 struct intel_panel
*panel
= &connector
->panel
;
492 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
496 if (!panel
->backlight
.present
|| pipe
== INVALID_PIPE
)
499 spin_lock_irqsave(&dev_priv
->backlight_lock
, flags
);
501 WARN_ON(panel
->backlight
.max
== 0);
503 /* scale to hardware max, but be careful to not overflow */
504 freq
= panel
->backlight
.max
;
506 level
= level
* freq
/ max
;
508 level
= freq
/ max
* level
;
510 panel
->backlight
.level
= level
;
511 if (panel
->backlight
.device
)
512 panel
->backlight
.device
->props
.brightness
= level
;
514 if (panel
->backlight
.enabled
)
515 intel_panel_actually_set_backlight(connector
, level
);
517 spin_unlock_irqrestore(&dev_priv
->backlight_lock
, flags
);
520 static void pch_disable_backlight(struct intel_connector
*connector
)
522 struct drm_device
*dev
= connector
->base
.dev
;
523 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
526 intel_panel_actually_set_backlight(connector
, 0);
528 tmp
= I915_READ(BLC_PWM_CPU_CTL2
);
529 I915_WRITE(BLC_PWM_CPU_CTL2
, tmp
& ~BLM_PWM_ENABLE
);
531 tmp
= I915_READ(BLC_PWM_PCH_CTL1
);
532 I915_WRITE(BLC_PWM_PCH_CTL1
, tmp
& ~BLM_PCH_PWM_ENABLE
);
535 static void i9xx_disable_backlight(struct intel_connector
*connector
)
537 intel_panel_actually_set_backlight(connector
, 0);
540 static void i965_disable_backlight(struct intel_connector
*connector
)
542 struct drm_device
*dev
= connector
->base
.dev
;
543 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
546 intel_panel_actually_set_backlight(connector
, 0);
548 tmp
= I915_READ(BLC_PWM_CTL2
);
549 I915_WRITE(BLC_PWM_CTL2
, tmp
& ~BLM_PWM_ENABLE
);
552 static void vlv_disable_backlight(struct intel_connector
*connector
)
554 struct drm_device
*dev
= connector
->base
.dev
;
555 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
556 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
559 intel_panel_actually_set_backlight(connector
, 0);
561 tmp
= I915_READ(VLV_BLC_PWM_CTL2(pipe
));
562 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), tmp
& ~BLM_PWM_ENABLE
);
565 void intel_panel_disable_backlight(struct intel_connector
*connector
)
567 struct drm_device
*dev
= connector
->base
.dev
;
568 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
569 struct intel_panel
*panel
= &connector
->panel
;
570 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
573 if (!panel
->backlight
.present
|| pipe
== INVALID_PIPE
)
577 * Do not disable backlight on the vgaswitcheroo path. When switching
578 * away from i915, the other client may depend on i915 to handle the
579 * backlight. This will leave the backlight on unnecessarily when
580 * another client is not activated.
582 if (dev
->switch_power_state
== DRM_SWITCH_POWER_CHANGING
) {
583 DRM_DEBUG_DRIVER("Skipping backlight disable on vga switch\n");
587 spin_lock_irqsave(&dev_priv
->backlight_lock
, flags
);
589 panel
->backlight
.enabled
= false;
590 dev_priv
->display
.disable_backlight(connector
);
592 spin_unlock_irqrestore(&dev_priv
->backlight_lock
, flags
);
595 static void bdw_enable_backlight(struct intel_connector
*connector
)
597 struct drm_device
*dev
= connector
->base
.dev
;
598 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
599 struct intel_panel
*panel
= &connector
->panel
;
600 u32 pch_ctl1
, pch_ctl2
;
602 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
603 if (pch_ctl1
& BLM_PCH_PWM_ENABLE
) {
604 DRM_DEBUG_KMS("pch backlight already enabled\n");
605 pch_ctl1
&= ~BLM_PCH_PWM_ENABLE
;
606 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
609 pch_ctl2
= panel
->backlight
.max
<< 16;
610 I915_WRITE(BLC_PWM_PCH_CTL2
, pch_ctl2
);
613 if (panel
->backlight
.active_low_pwm
)
614 pch_ctl1
|= BLM_PCH_POLARITY
;
616 /* BDW always uses the pch pwm controls. */
617 pch_ctl1
|= BLM_PCH_OVERRIDE_ENABLE
;
619 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
620 POSTING_READ(BLC_PWM_PCH_CTL1
);
621 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
| BLM_PCH_PWM_ENABLE
);
623 /* This won't stick until the above enable. */
624 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
627 static void pch_enable_backlight(struct intel_connector
*connector
)
629 struct drm_device
*dev
= connector
->base
.dev
;
630 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
631 struct intel_panel
*panel
= &connector
->panel
;
632 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
633 enum transcoder cpu_transcoder
=
634 intel_pipe_to_cpu_transcoder(dev_priv
, pipe
);
635 u32 cpu_ctl2
, pch_ctl1
, pch_ctl2
;
637 cpu_ctl2
= I915_READ(BLC_PWM_CPU_CTL2
);
638 if (cpu_ctl2
& BLM_PWM_ENABLE
) {
639 WARN(1, "cpu backlight already enabled\n");
640 cpu_ctl2
&= ~BLM_PWM_ENABLE
;
641 I915_WRITE(BLC_PWM_CPU_CTL2
, cpu_ctl2
);
644 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
645 if (pch_ctl1
& BLM_PCH_PWM_ENABLE
) {
646 DRM_DEBUG_KMS("pch backlight already enabled\n");
647 pch_ctl1
&= ~BLM_PCH_PWM_ENABLE
;
648 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
651 if (cpu_transcoder
== TRANSCODER_EDP
)
652 cpu_ctl2
= BLM_TRANSCODER_EDP
;
654 cpu_ctl2
= BLM_PIPE(cpu_transcoder
);
655 I915_WRITE(BLC_PWM_CPU_CTL2
, cpu_ctl2
);
656 POSTING_READ(BLC_PWM_CPU_CTL2
);
657 I915_WRITE(BLC_PWM_CPU_CTL2
, cpu_ctl2
| BLM_PWM_ENABLE
);
659 /* This won't stick until the above enable. */
660 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
662 pch_ctl2
= panel
->backlight
.max
<< 16;
663 I915_WRITE(BLC_PWM_PCH_CTL2
, pch_ctl2
);
666 if (panel
->backlight
.active_low_pwm
)
667 pch_ctl1
|= BLM_PCH_POLARITY
;
669 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
670 POSTING_READ(BLC_PWM_PCH_CTL1
);
671 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
| BLM_PCH_PWM_ENABLE
);
674 static void i9xx_enable_backlight(struct intel_connector
*connector
)
676 struct drm_device
*dev
= connector
->base
.dev
;
677 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
678 struct intel_panel
*panel
= &connector
->panel
;
681 ctl
= I915_READ(BLC_PWM_CTL
);
682 if (ctl
& BACKLIGHT_DUTY_CYCLE_MASK_PNV
) {
683 WARN(1, "backlight already enabled\n");
684 I915_WRITE(BLC_PWM_CTL
, 0);
687 freq
= panel
->backlight
.max
;
688 if (panel
->backlight
.combination_mode
)
692 if (panel
->backlight
.combination_mode
)
693 ctl
|= BLM_LEGACY_MODE
;
694 if (IS_PINEVIEW(dev
) && panel
->backlight
.active_low_pwm
)
695 ctl
|= BLM_POLARITY_PNV
;
697 I915_WRITE(BLC_PWM_CTL
, ctl
);
698 POSTING_READ(BLC_PWM_CTL
);
700 /* XXX: combine this into above write? */
701 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
704 static void i965_enable_backlight(struct intel_connector
*connector
)
706 struct drm_device
*dev
= connector
->base
.dev
;
707 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
708 struct intel_panel
*panel
= &connector
->panel
;
709 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
712 ctl2
= I915_READ(BLC_PWM_CTL2
);
713 if (ctl2
& BLM_PWM_ENABLE
) {
714 WARN(1, "backlight already enabled\n");
715 ctl2
&= ~BLM_PWM_ENABLE
;
716 I915_WRITE(BLC_PWM_CTL2
, ctl2
);
719 freq
= panel
->backlight
.max
;
720 if (panel
->backlight
.combination_mode
)
724 I915_WRITE(BLC_PWM_CTL
, ctl
);
726 /* XXX: combine this into above write? */
727 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
729 ctl2
= BLM_PIPE(pipe
);
730 if (panel
->backlight
.combination_mode
)
731 ctl2
|= BLM_COMBINATION_MODE
;
732 if (panel
->backlight
.active_low_pwm
)
733 ctl2
|= BLM_POLARITY_I965
;
734 I915_WRITE(BLC_PWM_CTL2
, ctl2
);
735 POSTING_READ(BLC_PWM_CTL2
);
736 I915_WRITE(BLC_PWM_CTL2
, ctl2
| BLM_PWM_ENABLE
);
739 static void vlv_enable_backlight(struct intel_connector
*connector
)
741 struct drm_device
*dev
= connector
->base
.dev
;
742 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
743 struct intel_panel
*panel
= &connector
->panel
;
744 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
747 ctl2
= I915_READ(VLV_BLC_PWM_CTL2(pipe
));
748 if (ctl2
& BLM_PWM_ENABLE
) {
749 WARN(1, "backlight already enabled\n");
750 ctl2
&= ~BLM_PWM_ENABLE
;
751 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), ctl2
);
754 ctl
= panel
->backlight
.max
<< 16;
755 I915_WRITE(VLV_BLC_PWM_CTL(pipe
), ctl
);
757 /* XXX: combine this into above write? */
758 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
761 if (panel
->backlight
.active_low_pwm
)
762 ctl2
|= BLM_POLARITY_I965
;
763 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), ctl2
);
764 POSTING_READ(VLV_BLC_PWM_CTL2(pipe
));
765 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), ctl2
| BLM_PWM_ENABLE
);
768 void intel_panel_enable_backlight(struct intel_connector
*connector
)
770 struct drm_device
*dev
= connector
->base
.dev
;
771 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
772 struct intel_panel
*panel
= &connector
->panel
;
773 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
776 if (!panel
->backlight
.present
|| pipe
== INVALID_PIPE
)
779 DRM_DEBUG_KMS("pipe %c\n", pipe_name(pipe
));
781 spin_lock_irqsave(&dev_priv
->backlight_lock
, flags
);
783 WARN_ON(panel
->backlight
.max
== 0);
785 if (panel
->backlight
.level
== 0) {
786 panel
->backlight
.level
= panel
->backlight
.max
;
787 if (panel
->backlight
.device
)
788 panel
->backlight
.device
->props
.brightness
=
789 panel
->backlight
.level
;
792 dev_priv
->display
.enable_backlight(connector
);
793 panel
->backlight
.enabled
= true;
795 spin_unlock_irqrestore(&dev_priv
->backlight_lock
, flags
);
798 enum drm_connector_status
799 intel_panel_detect(struct drm_device
*dev
)
801 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
803 /* Assume that the BIOS does not lie through the OpRegion... */
804 if (!i915
.panel_ignore_lid
&& dev_priv
->opregion
.lid_state
) {
805 return ioread32(dev_priv
->opregion
.lid_state
) & 0x1 ?
806 connector_status_connected
:
807 connector_status_disconnected
;
810 switch (i915
.panel_ignore_lid
) {
812 return connector_status_connected
;
814 return connector_status_disconnected
;
816 return connector_status_unknown
;
820 #if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)
821 static int intel_backlight_device_update_status(struct backlight_device
*bd
)
823 struct intel_connector
*connector
= bl_get_data(bd
);
824 struct drm_device
*dev
= connector
->base
.dev
;
826 mutex_lock(&dev
->mode_config
.mutex
);
827 DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n",
828 bd
->props
.brightness
, bd
->props
.max_brightness
);
829 intel_panel_set_backlight(connector
, bd
->props
.brightness
,
830 bd
->props
.max_brightness
);
831 mutex_unlock(&dev
->mode_config
.mutex
);
835 static int intel_backlight_device_get_brightness(struct backlight_device
*bd
)
837 struct intel_connector
*connector
= bl_get_data(bd
);
838 struct drm_device
*dev
= connector
->base
.dev
;
839 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
842 intel_runtime_pm_get(dev_priv
);
843 mutex_lock(&dev
->mode_config
.mutex
);
844 ret
= intel_panel_get_backlight(connector
);
845 mutex_unlock(&dev
->mode_config
.mutex
);
846 intel_runtime_pm_put(dev_priv
);
851 static const struct backlight_ops intel_backlight_device_ops
= {
852 .update_status
= intel_backlight_device_update_status
,
853 .get_brightness
= intel_backlight_device_get_brightness
,
856 static int intel_backlight_device_register(struct intel_connector
*connector
)
858 struct intel_panel
*panel
= &connector
->panel
;
859 struct backlight_properties props
;
861 if (WARN_ON(panel
->backlight
.device
))
864 BUG_ON(panel
->backlight
.max
== 0);
866 memset(&props
, 0, sizeof(props
));
867 props
.type
= BACKLIGHT_RAW
;
868 props
.brightness
= panel
->backlight
.level
;
869 props
.max_brightness
= panel
->backlight
.max
;
872 * Note: using the same name independent of the connector prevents
873 * registration of multiple backlight devices in the driver.
875 panel
->backlight
.device
=
876 backlight_device_register("intel_backlight",
877 connector
->base
.kdev
,
879 &intel_backlight_device_ops
, &props
);
881 if (IS_ERR(panel
->backlight
.device
)) {
882 DRM_ERROR("Failed to register backlight: %ld\n",
883 PTR_ERR(panel
->backlight
.device
));
884 panel
->backlight
.device
= NULL
;
890 static void intel_backlight_device_unregister(struct intel_connector
*connector
)
892 struct intel_panel
*panel
= &connector
->panel
;
894 if (panel
->backlight
.device
) {
895 backlight_device_unregister(panel
->backlight
.device
);
896 panel
->backlight
.device
= NULL
;
899 #else /* CONFIG_BACKLIGHT_CLASS_DEVICE */
900 static int intel_backlight_device_register(struct intel_connector
*connector
)
904 static void intel_backlight_device_unregister(struct intel_connector
*connector
)
907 #endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
910 * Note: The setup hooks can't assume pipe is set!
912 * XXX: Query mode clock or hardware clock and program PWM modulation frequency
913 * appropriately when it's 0. Use VBT and/or sane defaults.
915 static int bdw_setup_backlight(struct intel_connector
*connector
)
917 struct drm_device
*dev
= connector
->base
.dev
;
918 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
919 struct intel_panel
*panel
= &connector
->panel
;
920 u32 pch_ctl1
, pch_ctl2
, val
;
922 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
923 panel
->backlight
.active_low_pwm
= pch_ctl1
& BLM_PCH_POLARITY
;
925 pch_ctl2
= I915_READ(BLC_PWM_PCH_CTL2
);
926 panel
->backlight
.max
= pch_ctl2
>> 16;
927 if (!panel
->backlight
.max
)
930 val
= bdw_get_backlight(connector
);
931 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
933 panel
->backlight
.enabled
= (pch_ctl1
& BLM_PCH_PWM_ENABLE
) &&
934 panel
->backlight
.level
!= 0;
939 static int pch_setup_backlight(struct intel_connector
*connector
)
941 struct drm_device
*dev
= connector
->base
.dev
;
942 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
943 struct intel_panel
*panel
= &connector
->panel
;
944 u32 cpu_ctl2
, pch_ctl1
, pch_ctl2
, val
;
946 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
947 panel
->backlight
.active_low_pwm
= pch_ctl1
& BLM_PCH_POLARITY
;
949 pch_ctl2
= I915_READ(BLC_PWM_PCH_CTL2
);
950 panel
->backlight
.max
= pch_ctl2
>> 16;
951 if (!panel
->backlight
.max
)
954 val
= pch_get_backlight(connector
);
955 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
957 cpu_ctl2
= I915_READ(BLC_PWM_CPU_CTL2
);
958 panel
->backlight
.enabled
= (cpu_ctl2
& BLM_PWM_ENABLE
) &&
959 (pch_ctl1
& BLM_PCH_PWM_ENABLE
) && panel
->backlight
.level
!= 0;
964 static int i9xx_setup_backlight(struct intel_connector
*connector
)
966 struct drm_device
*dev
= connector
->base
.dev
;
967 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
968 struct intel_panel
*panel
= &connector
->panel
;
971 ctl
= I915_READ(BLC_PWM_CTL
);
973 if (IS_GEN2(dev
) || IS_I915GM(dev
) || IS_I945GM(dev
))
974 panel
->backlight
.combination_mode
= ctl
& BLM_LEGACY_MODE
;
976 if (IS_PINEVIEW(dev
))
977 panel
->backlight
.active_low_pwm
= ctl
& BLM_POLARITY_PNV
;
979 panel
->backlight
.max
= ctl
>> 17;
980 if (panel
->backlight
.combination_mode
)
981 panel
->backlight
.max
*= 0xff;
983 if (!panel
->backlight
.max
)
986 val
= i9xx_get_backlight(connector
);
987 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
989 panel
->backlight
.enabled
= panel
->backlight
.level
!= 0;
994 static int i965_setup_backlight(struct intel_connector
*connector
)
996 struct drm_device
*dev
= connector
->base
.dev
;
997 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
998 struct intel_panel
*panel
= &connector
->panel
;
1001 ctl2
= I915_READ(BLC_PWM_CTL2
);
1002 panel
->backlight
.combination_mode
= ctl2
& BLM_COMBINATION_MODE
;
1003 panel
->backlight
.active_low_pwm
= ctl2
& BLM_POLARITY_I965
;
1005 ctl
= I915_READ(BLC_PWM_CTL
);
1006 panel
->backlight
.max
= ctl
>> 16;
1007 if (panel
->backlight
.combination_mode
)
1008 panel
->backlight
.max
*= 0xff;
1010 if (!panel
->backlight
.max
)
1013 val
= i9xx_get_backlight(connector
);
1014 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
1016 panel
->backlight
.enabled
= (ctl2
& BLM_PWM_ENABLE
) &&
1017 panel
->backlight
.level
!= 0;
1022 static int vlv_setup_backlight(struct intel_connector
*connector
)
1024 struct drm_device
*dev
= connector
->base
.dev
;
1025 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1026 struct intel_panel
*panel
= &connector
->panel
;
1030 for_each_pipe(pipe
) {
1031 u32 cur_val
= I915_READ(VLV_BLC_PWM_CTL(pipe
));
1033 /* Skip if the modulation freq is already set */
1034 if (cur_val
& ~BACKLIGHT_DUTY_CYCLE_MASK
)
1037 cur_val
&= BACKLIGHT_DUTY_CYCLE_MASK
;
1038 I915_WRITE(VLV_BLC_PWM_CTL(pipe
), (0xf42 << 16) |
1042 ctl2
= I915_READ(VLV_BLC_PWM_CTL2(PIPE_A
));
1043 panel
->backlight
.active_low_pwm
= ctl2
& BLM_POLARITY_I965
;
1045 ctl
= I915_READ(VLV_BLC_PWM_CTL(PIPE_A
));
1046 panel
->backlight
.max
= ctl
>> 16;
1047 if (!panel
->backlight
.max
)
1050 val
= _vlv_get_backlight(dev
, PIPE_A
);
1051 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
1053 panel
->backlight
.enabled
= (ctl2
& BLM_PWM_ENABLE
) &&
1054 panel
->backlight
.level
!= 0;
1059 int intel_panel_setup_backlight(struct drm_connector
*connector
)
1061 struct drm_device
*dev
= connector
->dev
;
1062 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1063 struct intel_connector
*intel_connector
= to_intel_connector(connector
);
1064 struct intel_panel
*panel
= &intel_connector
->panel
;
1065 unsigned long flags
;
1068 if (!dev_priv
->vbt
.backlight
.present
) {
1069 DRM_DEBUG_KMS("native backlight control not available per VBT\n");
1073 /* set level and max in panel struct */
1074 spin_lock_irqsave(&dev_priv
->backlight_lock
, flags
);
1075 ret
= dev_priv
->display
.setup_backlight(intel_connector
);
1076 spin_unlock_irqrestore(&dev_priv
->backlight_lock
, flags
);
1079 DRM_DEBUG_KMS("failed to setup backlight for connector %s\n",
1080 drm_get_connector_name(connector
));
1084 intel_backlight_device_register(intel_connector
);
1086 panel
->backlight
.present
= true;
1088 DRM_DEBUG_KMS("backlight initialized, %s, brightness %u/%u, "
1089 "sysfs interface %sregistered\n",
1090 panel
->backlight
.enabled
? "enabled" : "disabled",
1091 panel
->backlight
.level
, panel
->backlight
.max
,
1092 panel
->backlight
.device
? "" : "not ");
1097 void intel_panel_destroy_backlight(struct drm_connector
*connector
)
1099 struct intel_connector
*intel_connector
= to_intel_connector(connector
);
1100 struct intel_panel
*panel
= &intel_connector
->panel
;
1102 panel
->backlight
.present
= false;
1103 intel_backlight_device_unregister(intel_connector
);
1107 * intel_find_panel_downclock - find the reduced downclock for LVDS in EDID
1109 * @fixed_mode : panel native mode
1110 * @connector: LVDS/eDP connector
1112 * Return downclock_avail
1113 * Find the reduced downclock for LVDS/eDP in EDID.
1115 struct drm_display_mode
*
1116 intel_find_panel_downclock(struct drm_device
*dev
,
1117 struct drm_display_mode
*fixed_mode
,
1118 struct drm_connector
*connector
)
1120 struct drm_display_mode
*scan
, *tmp_mode
;
1123 temp_downclock
= fixed_mode
->clock
;
1126 list_for_each_entry(scan
, &connector
->probed_modes
, head
) {
1128 * If one mode has the same resolution with the fixed_panel
1129 * mode while they have the different refresh rate, it means
1130 * that the reduced downclock is found. In such
1131 * case we can set the different FPx0/1 to dynamically select
1132 * between low and high frequency.
1134 if (scan
->hdisplay
== fixed_mode
->hdisplay
&&
1135 scan
->hsync_start
== fixed_mode
->hsync_start
&&
1136 scan
->hsync_end
== fixed_mode
->hsync_end
&&
1137 scan
->htotal
== fixed_mode
->htotal
&&
1138 scan
->vdisplay
== fixed_mode
->vdisplay
&&
1139 scan
->vsync_start
== fixed_mode
->vsync_start
&&
1140 scan
->vsync_end
== fixed_mode
->vsync_end
&&
1141 scan
->vtotal
== fixed_mode
->vtotal
) {
1142 if (scan
->clock
< temp_downclock
) {
1144 * The downclock is already found. But we
1145 * expect to find the lower downclock.
1147 temp_downclock
= scan
->clock
;
1153 if (temp_downclock
< fixed_mode
->clock
)
1154 return drm_mode_duplicate(dev
, tmp_mode
);
1159 /* Set up chip specific backlight functions */
1160 void intel_panel_init_backlight_funcs(struct drm_device
*dev
)
1162 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1164 if (IS_BROADWELL(dev
)) {
1165 dev_priv
->display
.setup_backlight
= bdw_setup_backlight
;
1166 dev_priv
->display
.enable_backlight
= bdw_enable_backlight
;
1167 dev_priv
->display
.disable_backlight
= pch_disable_backlight
;
1168 dev_priv
->display
.set_backlight
= bdw_set_backlight
;
1169 dev_priv
->display
.get_backlight
= bdw_get_backlight
;
1170 } else if (HAS_PCH_SPLIT(dev
)) {
1171 dev_priv
->display
.setup_backlight
= pch_setup_backlight
;
1172 dev_priv
->display
.enable_backlight
= pch_enable_backlight
;
1173 dev_priv
->display
.disable_backlight
= pch_disable_backlight
;
1174 dev_priv
->display
.set_backlight
= pch_set_backlight
;
1175 dev_priv
->display
.get_backlight
= pch_get_backlight
;
1176 } else if (IS_VALLEYVIEW(dev
)) {
1177 dev_priv
->display
.setup_backlight
= vlv_setup_backlight
;
1178 dev_priv
->display
.enable_backlight
= vlv_enable_backlight
;
1179 dev_priv
->display
.disable_backlight
= vlv_disable_backlight
;
1180 dev_priv
->display
.set_backlight
= vlv_set_backlight
;
1181 dev_priv
->display
.get_backlight
= vlv_get_backlight
;
1182 } else if (IS_GEN4(dev
)) {
1183 dev_priv
->display
.setup_backlight
= i965_setup_backlight
;
1184 dev_priv
->display
.enable_backlight
= i965_enable_backlight
;
1185 dev_priv
->display
.disable_backlight
= i965_disable_backlight
;
1186 dev_priv
->display
.set_backlight
= i9xx_set_backlight
;
1187 dev_priv
->display
.get_backlight
= i9xx_get_backlight
;
1189 dev_priv
->display
.setup_backlight
= i9xx_setup_backlight
;
1190 dev_priv
->display
.enable_backlight
= i9xx_enable_backlight
;
1191 dev_priv
->display
.disable_backlight
= i9xx_disable_backlight
;
1192 dev_priv
->display
.set_backlight
= i9xx_set_backlight
;
1193 dev_priv
->display
.get_backlight
= i9xx_get_backlight
;
1197 int intel_panel_init(struct intel_panel
*panel
,
1198 struct drm_display_mode
*fixed_mode
,
1199 struct drm_display_mode
*downclock_mode
)
1201 panel
->fixed_mode
= fixed_mode
;
1202 panel
->downclock_mode
= downclock_mode
;
1207 void intel_panel_fini(struct intel_panel
*panel
)
1209 struct intel_connector
*intel_connector
=
1210 container_of(panel
, struct intel_connector
, panel
);
1212 if (panel
->fixed_mode
)
1213 drm_mode_destroy(intel_connector
->base
.dev
, panel
->fixed_mode
);
1215 if (panel
->downclock_mode
)
1216 drm_mode_destroy(intel_connector
->base
.dev
,
1217 panel
->downclock_mode
);