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/kernel.h>
34 #include <linux/moduleparam.h>
35 #include "intel_drv.h"
38 intel_fixed_panel_mode(const struct drm_display_mode
*fixed_mode
,
39 struct drm_display_mode
*adjusted_mode
)
41 drm_mode_copy(adjusted_mode
, fixed_mode
);
43 drm_mode_set_crtcinfo(adjusted_mode
, 0);
47 * intel_find_panel_downclock - find the reduced downclock for LVDS in EDID
49 * @fixed_mode : panel native mode
50 * @connector: LVDS/eDP connector
52 * Return downclock_avail
53 * Find the reduced downclock for LVDS/eDP in EDID.
55 struct drm_display_mode
*
56 intel_find_panel_downclock(struct drm_device
*dev
,
57 struct drm_display_mode
*fixed_mode
,
58 struct drm_connector
*connector
)
60 struct drm_display_mode
*scan
, *tmp_mode
;
63 temp_downclock
= fixed_mode
->clock
;
66 list_for_each_entry(scan
, &connector
->probed_modes
, head
) {
68 * If one mode has the same resolution with the fixed_panel
69 * mode while they have the different refresh rate, it means
70 * that the reduced downclock is found. In such
71 * case we can set the different FPx0/1 to dynamically select
72 * between low and high frequency.
74 if (scan
->hdisplay
== fixed_mode
->hdisplay
&&
75 scan
->hsync_start
== fixed_mode
->hsync_start
&&
76 scan
->hsync_end
== fixed_mode
->hsync_end
&&
77 scan
->htotal
== fixed_mode
->htotal
&&
78 scan
->vdisplay
== fixed_mode
->vdisplay
&&
79 scan
->vsync_start
== fixed_mode
->vsync_start
&&
80 scan
->vsync_end
== fixed_mode
->vsync_end
&&
81 scan
->vtotal
== fixed_mode
->vtotal
) {
82 if (scan
->clock
< temp_downclock
) {
84 * The downclock is already found. But we
85 * expect to find the lower downclock.
87 temp_downclock
= scan
->clock
;
93 if (temp_downclock
< fixed_mode
->clock
)
94 return drm_mode_duplicate(dev
, tmp_mode
);
99 /* adjusted_mode has been preset to be the panel's fixed mode */
101 intel_pch_panel_fitting(struct intel_crtc
*intel_crtc
,
102 struct intel_crtc_state
*pipe_config
,
105 struct drm_display_mode
*adjusted_mode
;
106 int x
, y
, width
, height
;
108 adjusted_mode
= &pipe_config
->base
.adjusted_mode
;
110 x
= y
= width
= height
= 0;
112 /* Native modes don't need fitting */
113 if (adjusted_mode
->hdisplay
== pipe_config
->pipe_src_w
&&
114 adjusted_mode
->vdisplay
== pipe_config
->pipe_src_h
)
117 switch (fitting_mode
) {
118 case DRM_MODE_SCALE_CENTER
:
119 width
= pipe_config
->pipe_src_w
;
120 height
= pipe_config
->pipe_src_h
;
121 x
= (adjusted_mode
->hdisplay
- width
+ 1)/2;
122 y
= (adjusted_mode
->vdisplay
- height
+ 1)/2;
125 case DRM_MODE_SCALE_ASPECT
:
126 /* Scale but preserve the aspect ratio */
128 u32 scaled_width
= adjusted_mode
->hdisplay
129 * pipe_config
->pipe_src_h
;
130 u32 scaled_height
= pipe_config
->pipe_src_w
131 * adjusted_mode
->vdisplay
;
132 if (scaled_width
> scaled_height
) { /* pillar */
133 width
= scaled_height
/ pipe_config
->pipe_src_h
;
136 x
= (adjusted_mode
->hdisplay
- width
+ 1) / 2;
138 height
= adjusted_mode
->vdisplay
;
139 } else if (scaled_width
< scaled_height
) { /* letter */
140 height
= scaled_width
/ pipe_config
->pipe_src_w
;
143 y
= (adjusted_mode
->vdisplay
- height
+ 1) / 2;
145 width
= adjusted_mode
->hdisplay
;
148 width
= adjusted_mode
->hdisplay
;
149 height
= adjusted_mode
->vdisplay
;
154 case DRM_MODE_SCALE_FULLSCREEN
:
156 width
= adjusted_mode
->hdisplay
;
157 height
= adjusted_mode
->vdisplay
;
161 WARN(1, "bad panel fit mode: %d\n", fitting_mode
);
166 pipe_config
->pch_pfit
.pos
= (x
<< 16) | y
;
167 pipe_config
->pch_pfit
.size
= (width
<< 16) | height
;
168 pipe_config
->pch_pfit
.enabled
= pipe_config
->pch_pfit
.size
!= 0;
172 centre_horizontally(struct drm_display_mode
*mode
,
175 u32 border
, sync_pos
, blank_width
, sync_width
;
177 /* keep the hsync and hblank widths constant */
178 sync_width
= mode
->crtc_hsync_end
- mode
->crtc_hsync_start
;
179 blank_width
= mode
->crtc_hblank_end
- mode
->crtc_hblank_start
;
180 sync_pos
= (blank_width
- sync_width
+ 1) / 2;
182 border
= (mode
->hdisplay
- width
+ 1) / 2;
183 border
+= border
& 1; /* make the border even */
185 mode
->crtc_hdisplay
= width
;
186 mode
->crtc_hblank_start
= width
+ border
;
187 mode
->crtc_hblank_end
= mode
->crtc_hblank_start
+ blank_width
;
189 mode
->crtc_hsync_start
= mode
->crtc_hblank_start
+ sync_pos
;
190 mode
->crtc_hsync_end
= mode
->crtc_hsync_start
+ sync_width
;
194 centre_vertically(struct drm_display_mode
*mode
,
197 u32 border
, sync_pos
, blank_width
, sync_width
;
199 /* keep the vsync and vblank widths constant */
200 sync_width
= mode
->crtc_vsync_end
- mode
->crtc_vsync_start
;
201 blank_width
= mode
->crtc_vblank_end
- mode
->crtc_vblank_start
;
202 sync_pos
= (blank_width
- sync_width
+ 1) / 2;
204 border
= (mode
->vdisplay
- height
+ 1) / 2;
206 mode
->crtc_vdisplay
= height
;
207 mode
->crtc_vblank_start
= height
+ border
;
208 mode
->crtc_vblank_end
= mode
->crtc_vblank_start
+ blank_width
;
210 mode
->crtc_vsync_start
= mode
->crtc_vblank_start
+ sync_pos
;
211 mode
->crtc_vsync_end
= mode
->crtc_vsync_start
+ sync_width
;
214 static inline u32
panel_fitter_scaling(u32 source
, u32 target
)
217 * Floating point operation is not supported. So the FACTOR
218 * is defined, which can avoid the floating point computation
219 * when calculating the panel ratio.
222 #define FACTOR (1 << ACCURACY)
223 u32 ratio
= source
* FACTOR
/ target
;
224 return (FACTOR
* ratio
+ FACTOR
/2) / FACTOR
;
227 static void i965_scale_aspect(struct intel_crtc_state
*pipe_config
,
230 struct drm_display_mode
*adjusted_mode
= &pipe_config
->base
.adjusted_mode
;
231 u32 scaled_width
= adjusted_mode
->hdisplay
*
232 pipe_config
->pipe_src_h
;
233 u32 scaled_height
= pipe_config
->pipe_src_w
*
234 adjusted_mode
->vdisplay
;
236 /* 965+ is easy, it does everything in hw */
237 if (scaled_width
> scaled_height
)
238 *pfit_control
|= PFIT_ENABLE
|
240 else if (scaled_width
< scaled_height
)
241 *pfit_control
|= PFIT_ENABLE
|
243 else if (adjusted_mode
->hdisplay
!= pipe_config
->pipe_src_w
)
244 *pfit_control
|= PFIT_ENABLE
| PFIT_SCALING_AUTO
;
247 static void i9xx_scale_aspect(struct intel_crtc_state
*pipe_config
,
248 u32
*pfit_control
, u32
*pfit_pgm_ratios
,
251 struct drm_display_mode
*adjusted_mode
= &pipe_config
->base
.adjusted_mode
;
252 u32 scaled_width
= adjusted_mode
->hdisplay
*
253 pipe_config
->pipe_src_h
;
254 u32 scaled_height
= pipe_config
->pipe_src_w
*
255 adjusted_mode
->vdisplay
;
259 * For earlier chips we have to calculate the scaling
260 * ratio by hand and program it into the
261 * PFIT_PGM_RATIO register
263 if (scaled_width
> scaled_height
) { /* pillar */
264 centre_horizontally(adjusted_mode
,
266 pipe_config
->pipe_src_h
);
268 *border
= LVDS_BORDER_ENABLE
;
269 if (pipe_config
->pipe_src_h
!= adjusted_mode
->vdisplay
) {
270 bits
= panel_fitter_scaling(pipe_config
->pipe_src_h
,
271 adjusted_mode
->vdisplay
);
273 *pfit_pgm_ratios
|= (bits
<< PFIT_HORIZ_SCALE_SHIFT
|
274 bits
<< PFIT_VERT_SCALE_SHIFT
);
275 *pfit_control
|= (PFIT_ENABLE
|
276 VERT_INTERP_BILINEAR
|
277 HORIZ_INTERP_BILINEAR
);
279 } else if (scaled_width
< scaled_height
) { /* letter */
280 centre_vertically(adjusted_mode
,
282 pipe_config
->pipe_src_w
);
284 *border
= LVDS_BORDER_ENABLE
;
285 if (pipe_config
->pipe_src_w
!= adjusted_mode
->hdisplay
) {
286 bits
= panel_fitter_scaling(pipe_config
->pipe_src_w
,
287 adjusted_mode
->hdisplay
);
289 *pfit_pgm_ratios
|= (bits
<< PFIT_HORIZ_SCALE_SHIFT
|
290 bits
<< PFIT_VERT_SCALE_SHIFT
);
291 *pfit_control
|= (PFIT_ENABLE
|
292 VERT_INTERP_BILINEAR
|
293 HORIZ_INTERP_BILINEAR
);
296 /* Aspects match, Let hw scale both directions */
297 *pfit_control
|= (PFIT_ENABLE
|
298 VERT_AUTO_SCALE
| HORIZ_AUTO_SCALE
|
299 VERT_INTERP_BILINEAR
|
300 HORIZ_INTERP_BILINEAR
);
304 void intel_gmch_panel_fitting(struct intel_crtc
*intel_crtc
,
305 struct intel_crtc_state
*pipe_config
,
308 struct drm_device
*dev
= intel_crtc
->base
.dev
;
309 u32 pfit_control
= 0, pfit_pgm_ratios
= 0, border
= 0;
310 struct drm_display_mode
*adjusted_mode
;
312 adjusted_mode
= &pipe_config
->base
.adjusted_mode
;
314 /* Native modes don't need fitting */
315 if (adjusted_mode
->hdisplay
== pipe_config
->pipe_src_w
&&
316 adjusted_mode
->vdisplay
== pipe_config
->pipe_src_h
)
319 switch (fitting_mode
) {
320 case DRM_MODE_SCALE_CENTER
:
322 * For centered modes, we have to calculate border widths &
323 * heights and modify the values programmed into the CRTC.
325 centre_horizontally(adjusted_mode
, pipe_config
->pipe_src_w
);
326 centre_vertically(adjusted_mode
, pipe_config
->pipe_src_h
);
327 border
= LVDS_BORDER_ENABLE
;
329 case DRM_MODE_SCALE_ASPECT
:
330 /* Scale but preserve the aspect ratio */
331 if (INTEL_INFO(dev
)->gen
>= 4)
332 i965_scale_aspect(pipe_config
, &pfit_control
);
334 i9xx_scale_aspect(pipe_config
, &pfit_control
,
335 &pfit_pgm_ratios
, &border
);
337 case DRM_MODE_SCALE_FULLSCREEN
:
339 * Full scaling, even if it changes the aspect ratio.
340 * Fortunately this is all done for us in hw.
342 if (pipe_config
->pipe_src_h
!= adjusted_mode
->vdisplay
||
343 pipe_config
->pipe_src_w
!= adjusted_mode
->hdisplay
) {
344 pfit_control
|= PFIT_ENABLE
;
345 if (INTEL_INFO(dev
)->gen
>= 4)
346 pfit_control
|= PFIT_SCALING_AUTO
;
348 pfit_control
|= (VERT_AUTO_SCALE
|
349 VERT_INTERP_BILINEAR
|
351 HORIZ_INTERP_BILINEAR
);
355 WARN(1, "bad panel fit mode: %d\n", fitting_mode
);
359 /* 965+ wants fuzzy fitting */
360 /* FIXME: handle multiple panels by failing gracefully */
361 if (INTEL_INFO(dev
)->gen
>= 4)
362 pfit_control
|= ((intel_crtc
->pipe
<< PFIT_PIPE_SHIFT
) |
366 if ((pfit_control
& PFIT_ENABLE
) == 0) {
371 /* Make sure pre-965 set dither correctly for 18bpp panels. */
372 if (INTEL_INFO(dev
)->gen
< 4 && pipe_config
->pipe_bpp
== 18)
373 pfit_control
|= PANEL_8TO6_DITHER_ENABLE
;
375 pipe_config
->gmch_pfit
.control
= pfit_control
;
376 pipe_config
->gmch_pfit
.pgm_ratios
= pfit_pgm_ratios
;
377 pipe_config
->gmch_pfit
.lvds_border_bits
= border
;
380 enum drm_connector_status
381 intel_panel_detect(struct drm_device
*dev
)
383 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
385 /* Assume that the BIOS does not lie through the OpRegion... */
386 if (!i915
.panel_ignore_lid
&& dev_priv
->opregion
.lid_state
) {
387 return ioread32(dev_priv
->opregion
.lid_state
) & 0x1 ?
388 connector_status_connected
:
389 connector_status_disconnected
;
392 switch (i915
.panel_ignore_lid
) {
394 return connector_status_connected
;
396 return connector_status_disconnected
;
398 return connector_status_unknown
;
403 * scale - scale values from one range to another
405 * @source_val: value in range [@source_min..@source_max]
407 * Return @source_val in range [@source_min..@source_max] scaled to range
408 * [@target_min..@target_max].
410 static uint32_t scale(uint32_t source_val
,
411 uint32_t source_min
, uint32_t source_max
,
412 uint32_t target_min
, uint32_t target_max
)
416 WARN_ON(source_min
> source_max
);
417 WARN_ON(target_min
> target_max
);
420 source_val
= clamp(source_val
, source_min
, source_max
);
422 /* avoid overflows */
423 target_val
= DIV_ROUND_CLOSEST_ULL((uint64_t)(source_val
- source_min
) *
424 (target_max
- target_min
), source_max
- source_min
);
425 target_val
+= target_min
;
430 /* Scale user_level in range [0..user_max] to [hw_min..hw_max]. */
431 static inline u32
scale_user_to_hw(struct intel_connector
*connector
,
432 u32 user_level
, u32 user_max
)
434 struct intel_panel
*panel
= &connector
->panel
;
436 return scale(user_level
, 0, user_max
,
437 panel
->backlight
.min
, panel
->backlight
.max
);
440 /* Scale user_level in range [0..user_max] to [0..hw_max], clamping the result
441 * to [hw_min..hw_max]. */
442 static inline u32
clamp_user_to_hw(struct intel_connector
*connector
,
443 u32 user_level
, u32 user_max
)
445 struct intel_panel
*panel
= &connector
->panel
;
448 hw_level
= scale(user_level
, 0, user_max
, 0, panel
->backlight
.max
);
449 hw_level
= clamp(hw_level
, panel
->backlight
.min
, panel
->backlight
.max
);
454 /* Scale hw_level in range [hw_min..hw_max] to [0..user_max]. */
455 static inline u32
scale_hw_to_user(struct intel_connector
*connector
,
456 u32 hw_level
, u32 user_max
)
458 struct intel_panel
*panel
= &connector
->panel
;
460 return scale(hw_level
, panel
->backlight
.min
, panel
->backlight
.max
,
464 static u32
intel_panel_compute_brightness(struct intel_connector
*connector
,
467 struct drm_device
*dev
= connector
->base
.dev
;
468 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
469 struct intel_panel
*panel
= &connector
->panel
;
471 WARN_ON(panel
->backlight
.max
== 0);
473 if (i915
.invert_brightness
< 0)
476 if (i915
.invert_brightness
> 0 ||
477 dev_priv
->quirks
& QUIRK_INVERT_BRIGHTNESS
) {
478 return panel
->backlight
.max
- val
;
484 static u32
bdw_get_backlight(struct intel_connector
*connector
)
486 struct drm_device
*dev
= connector
->base
.dev
;
487 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
489 return I915_READ(BLC_PWM_PCH_CTL2
) & BACKLIGHT_DUTY_CYCLE_MASK
;
492 static u32
pch_get_backlight(struct intel_connector
*connector
)
494 struct drm_device
*dev
= connector
->base
.dev
;
495 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
497 return I915_READ(BLC_PWM_CPU_CTL
) & BACKLIGHT_DUTY_CYCLE_MASK
;
500 static u32
i9xx_get_backlight(struct intel_connector
*connector
)
502 struct drm_device
*dev
= connector
->base
.dev
;
503 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
504 struct intel_panel
*panel
= &connector
->panel
;
507 val
= I915_READ(BLC_PWM_CTL
) & BACKLIGHT_DUTY_CYCLE_MASK
;
508 if (INTEL_INFO(dev
)->gen
< 4)
511 if (panel
->backlight
.combination_mode
) {
514 pci_read_config_byte(dev
->pdev
, PCI_LBPC
, &lbpc
);
521 static u32
_vlv_get_backlight(struct drm_device
*dev
, enum pipe pipe
)
523 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
525 if (WARN_ON(pipe
!= PIPE_A
&& pipe
!= PIPE_B
))
528 return I915_READ(VLV_BLC_PWM_CTL(pipe
)) & BACKLIGHT_DUTY_CYCLE_MASK
;
531 static u32
vlv_get_backlight(struct intel_connector
*connector
)
533 struct drm_device
*dev
= connector
->base
.dev
;
534 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
536 return _vlv_get_backlight(dev
, pipe
);
539 static u32
bxt_get_backlight(struct intel_connector
*connector
)
541 struct drm_device
*dev
= connector
->base
.dev
;
542 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
544 return I915_READ(BXT_BLC_PWM_DUTY1
);
547 static u32
intel_panel_get_backlight(struct intel_connector
*connector
)
549 struct drm_device
*dev
= connector
->base
.dev
;
550 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
551 struct intel_panel
*panel
= &connector
->panel
;
554 mutex_lock(&dev_priv
->backlight_lock
);
556 if (panel
->backlight
.enabled
) {
557 val
= dev_priv
->display
.get_backlight(connector
);
558 val
= intel_panel_compute_brightness(connector
, val
);
561 mutex_unlock(&dev_priv
->backlight_lock
);
563 DRM_DEBUG_DRIVER("get backlight PWM = %d\n", val
);
567 static void bdw_set_backlight(struct intel_connector
*connector
, u32 level
)
569 struct drm_device
*dev
= connector
->base
.dev
;
570 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
571 u32 val
= I915_READ(BLC_PWM_PCH_CTL2
) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
572 I915_WRITE(BLC_PWM_PCH_CTL2
, val
| level
);
575 static void pch_set_backlight(struct intel_connector
*connector
, u32 level
)
577 struct drm_device
*dev
= connector
->base
.dev
;
578 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
581 tmp
= I915_READ(BLC_PWM_CPU_CTL
) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
582 I915_WRITE(BLC_PWM_CPU_CTL
, tmp
| level
);
585 static void i9xx_set_backlight(struct intel_connector
*connector
, u32 level
)
587 struct drm_device
*dev
= connector
->base
.dev
;
588 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
589 struct intel_panel
*panel
= &connector
->panel
;
592 WARN_ON(panel
->backlight
.max
== 0);
594 if (panel
->backlight
.combination_mode
) {
597 lbpc
= level
* 0xfe / panel
->backlight
.max
+ 1;
599 pci_write_config_byte(dev
->pdev
, PCI_LBPC
, lbpc
);
603 mask
= BACKLIGHT_DUTY_CYCLE_MASK
;
606 mask
= BACKLIGHT_DUTY_CYCLE_MASK_PNV
;
609 tmp
= I915_READ(BLC_PWM_CTL
) & ~mask
;
610 I915_WRITE(BLC_PWM_CTL
, tmp
| level
);
613 static void vlv_set_backlight(struct intel_connector
*connector
, u32 level
)
615 struct drm_device
*dev
= connector
->base
.dev
;
616 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
617 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
620 if (WARN_ON(pipe
!= PIPE_A
&& pipe
!= PIPE_B
))
623 tmp
= I915_READ(VLV_BLC_PWM_CTL(pipe
)) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
624 I915_WRITE(VLV_BLC_PWM_CTL(pipe
), tmp
| level
);
627 static void bxt_set_backlight(struct intel_connector
*connector
, u32 level
)
629 struct drm_device
*dev
= connector
->base
.dev
;
630 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
632 I915_WRITE(BXT_BLC_PWM_DUTY1
, level
);
636 intel_panel_actually_set_backlight(struct intel_connector
*connector
, u32 level
)
638 struct drm_device
*dev
= connector
->base
.dev
;
639 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
641 DRM_DEBUG_DRIVER("set backlight PWM = %d\n", level
);
643 level
= intel_panel_compute_brightness(connector
, level
);
644 dev_priv
->display
.set_backlight(connector
, level
);
647 /* set backlight brightness to level in range [0..max], scaling wrt hw min */
648 static void intel_panel_set_backlight(struct intel_connector
*connector
,
649 u32 user_level
, u32 user_max
)
651 struct drm_device
*dev
= connector
->base
.dev
;
652 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
653 struct intel_panel
*panel
= &connector
->panel
;
656 if (!panel
->backlight
.present
)
659 mutex_lock(&dev_priv
->backlight_lock
);
661 WARN_ON(panel
->backlight
.max
== 0);
663 hw_level
= scale_user_to_hw(connector
, user_level
, user_max
);
664 panel
->backlight
.level
= hw_level
;
666 if (panel
->backlight
.enabled
)
667 intel_panel_actually_set_backlight(connector
, hw_level
);
669 mutex_unlock(&dev_priv
->backlight_lock
);
672 /* set backlight brightness to level in range [0..max], assuming hw min is
675 void intel_panel_set_backlight_acpi(struct intel_connector
*connector
,
676 u32 user_level
, u32 user_max
)
678 struct drm_device
*dev
= connector
->base
.dev
;
679 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
680 struct intel_panel
*panel
= &connector
->panel
;
681 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
685 * INVALID_PIPE may occur during driver init because
686 * connection_mutex isn't held across the entire backlight
687 * setup + modeset readout, and the BIOS can issue the
688 * requests at any time.
690 if (!panel
->backlight
.present
|| pipe
== INVALID_PIPE
)
693 mutex_lock(&dev_priv
->backlight_lock
);
695 WARN_ON(panel
->backlight
.max
== 0);
697 hw_level
= clamp_user_to_hw(connector
, user_level
, user_max
);
698 panel
->backlight
.level
= hw_level
;
700 if (panel
->backlight
.device
)
701 panel
->backlight
.device
->props
.brightness
=
702 scale_hw_to_user(connector
,
703 panel
->backlight
.level
,
704 panel
->backlight
.device
->props
.max_brightness
);
706 if (panel
->backlight
.enabled
)
707 intel_panel_actually_set_backlight(connector
, hw_level
);
709 mutex_unlock(&dev_priv
->backlight_lock
);
712 static void pch_disable_backlight(struct intel_connector
*connector
)
714 struct drm_device
*dev
= connector
->base
.dev
;
715 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
718 intel_panel_actually_set_backlight(connector
, 0);
720 tmp
= I915_READ(BLC_PWM_CPU_CTL2
);
721 I915_WRITE(BLC_PWM_CPU_CTL2
, tmp
& ~BLM_PWM_ENABLE
);
723 tmp
= I915_READ(BLC_PWM_PCH_CTL1
);
724 I915_WRITE(BLC_PWM_PCH_CTL1
, tmp
& ~BLM_PCH_PWM_ENABLE
);
727 static void i9xx_disable_backlight(struct intel_connector
*connector
)
729 intel_panel_actually_set_backlight(connector
, 0);
732 static void i965_disable_backlight(struct intel_connector
*connector
)
734 struct drm_device
*dev
= connector
->base
.dev
;
735 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
738 intel_panel_actually_set_backlight(connector
, 0);
740 tmp
= I915_READ(BLC_PWM_CTL2
);
741 I915_WRITE(BLC_PWM_CTL2
, tmp
& ~BLM_PWM_ENABLE
);
744 static void vlv_disable_backlight(struct intel_connector
*connector
)
746 struct drm_device
*dev
= connector
->base
.dev
;
747 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
748 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
751 if (WARN_ON(pipe
!= PIPE_A
&& pipe
!= PIPE_B
))
754 intel_panel_actually_set_backlight(connector
, 0);
756 tmp
= I915_READ(VLV_BLC_PWM_CTL2(pipe
));
757 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), tmp
& ~BLM_PWM_ENABLE
);
760 static void bxt_disable_backlight(struct intel_connector
*connector
)
762 struct drm_device
*dev
= connector
->base
.dev
;
763 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
766 intel_panel_actually_set_backlight(connector
, 0);
768 tmp
= I915_READ(BXT_BLC_PWM_CTL1
);
769 I915_WRITE(BXT_BLC_PWM_CTL1
, tmp
& ~BXT_BLC_PWM_ENABLE
);
772 void intel_panel_disable_backlight(struct intel_connector
*connector
)
774 struct drm_device
*dev
= connector
->base
.dev
;
775 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
776 struct intel_panel
*panel
= &connector
->panel
;
778 if (!panel
->backlight
.present
)
782 * Do not disable backlight on the vgaswitcheroo path. When switching
783 * away from i915, the other client may depend on i915 to handle the
784 * backlight. This will leave the backlight on unnecessarily when
785 * another client is not activated.
787 if (dev
->switch_power_state
== DRM_SWITCH_POWER_CHANGING
) {
788 DRM_DEBUG_DRIVER("Skipping backlight disable on vga switch\n");
792 mutex_lock(&dev_priv
->backlight_lock
);
794 if (panel
->backlight
.device
)
795 panel
->backlight
.device
->props
.power
= FB_BLANK_POWERDOWN
;
796 panel
->backlight
.enabled
= false;
797 dev_priv
->display
.disable_backlight(connector
);
799 mutex_unlock(&dev_priv
->backlight_lock
);
802 static void bdw_enable_backlight(struct intel_connector
*connector
)
804 struct drm_device
*dev
= connector
->base
.dev
;
805 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
806 struct intel_panel
*panel
= &connector
->panel
;
807 u32 pch_ctl1
, pch_ctl2
;
809 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
810 if (pch_ctl1
& BLM_PCH_PWM_ENABLE
) {
811 DRM_DEBUG_KMS("pch backlight already enabled\n");
812 pch_ctl1
&= ~BLM_PCH_PWM_ENABLE
;
813 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
816 pch_ctl2
= panel
->backlight
.max
<< 16;
817 I915_WRITE(BLC_PWM_PCH_CTL2
, pch_ctl2
);
820 if (panel
->backlight
.active_low_pwm
)
821 pch_ctl1
|= BLM_PCH_POLARITY
;
823 /* After LPT, override is the default. */
824 if (HAS_PCH_LPT(dev_priv
))
825 pch_ctl1
|= BLM_PCH_OVERRIDE_ENABLE
;
827 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
828 POSTING_READ(BLC_PWM_PCH_CTL1
);
829 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
| BLM_PCH_PWM_ENABLE
);
831 /* This won't stick until the above enable. */
832 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
835 static void pch_enable_backlight(struct intel_connector
*connector
)
837 struct drm_device
*dev
= connector
->base
.dev
;
838 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
839 struct intel_panel
*panel
= &connector
->panel
;
840 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
841 enum transcoder cpu_transcoder
=
842 intel_pipe_to_cpu_transcoder(dev_priv
, pipe
);
843 u32 cpu_ctl2
, pch_ctl1
, pch_ctl2
;
845 cpu_ctl2
= I915_READ(BLC_PWM_CPU_CTL2
);
846 if (cpu_ctl2
& BLM_PWM_ENABLE
) {
847 DRM_DEBUG_KMS("cpu backlight already enabled\n");
848 cpu_ctl2
&= ~BLM_PWM_ENABLE
;
849 I915_WRITE(BLC_PWM_CPU_CTL2
, cpu_ctl2
);
852 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
853 if (pch_ctl1
& BLM_PCH_PWM_ENABLE
) {
854 DRM_DEBUG_KMS("pch backlight already enabled\n");
855 pch_ctl1
&= ~BLM_PCH_PWM_ENABLE
;
856 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
859 if (cpu_transcoder
== TRANSCODER_EDP
)
860 cpu_ctl2
= BLM_TRANSCODER_EDP
;
862 cpu_ctl2
= BLM_PIPE(cpu_transcoder
);
863 I915_WRITE(BLC_PWM_CPU_CTL2
, cpu_ctl2
);
864 POSTING_READ(BLC_PWM_CPU_CTL2
);
865 I915_WRITE(BLC_PWM_CPU_CTL2
, cpu_ctl2
| BLM_PWM_ENABLE
);
867 /* This won't stick until the above enable. */
868 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
870 pch_ctl2
= panel
->backlight
.max
<< 16;
871 I915_WRITE(BLC_PWM_PCH_CTL2
, pch_ctl2
);
874 if (panel
->backlight
.active_low_pwm
)
875 pch_ctl1
|= BLM_PCH_POLARITY
;
877 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
878 POSTING_READ(BLC_PWM_PCH_CTL1
);
879 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
| BLM_PCH_PWM_ENABLE
);
882 static void i9xx_enable_backlight(struct intel_connector
*connector
)
884 struct drm_device
*dev
= connector
->base
.dev
;
885 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
886 struct intel_panel
*panel
= &connector
->panel
;
889 ctl
= I915_READ(BLC_PWM_CTL
);
890 if (ctl
& BACKLIGHT_DUTY_CYCLE_MASK_PNV
) {
891 DRM_DEBUG_KMS("backlight already enabled\n");
892 I915_WRITE(BLC_PWM_CTL
, 0);
895 freq
= panel
->backlight
.max
;
896 if (panel
->backlight
.combination_mode
)
900 if (panel
->backlight
.combination_mode
)
901 ctl
|= BLM_LEGACY_MODE
;
902 if (IS_PINEVIEW(dev
) && panel
->backlight
.active_low_pwm
)
903 ctl
|= BLM_POLARITY_PNV
;
905 I915_WRITE(BLC_PWM_CTL
, ctl
);
906 POSTING_READ(BLC_PWM_CTL
);
908 /* XXX: combine this into above write? */
909 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
912 static void i965_enable_backlight(struct intel_connector
*connector
)
914 struct drm_device
*dev
= connector
->base
.dev
;
915 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
916 struct intel_panel
*panel
= &connector
->panel
;
917 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
920 ctl2
= I915_READ(BLC_PWM_CTL2
);
921 if (ctl2
& BLM_PWM_ENABLE
) {
922 DRM_DEBUG_KMS("backlight already enabled\n");
923 ctl2
&= ~BLM_PWM_ENABLE
;
924 I915_WRITE(BLC_PWM_CTL2
, ctl2
);
927 freq
= panel
->backlight
.max
;
928 if (panel
->backlight
.combination_mode
)
932 I915_WRITE(BLC_PWM_CTL
, ctl
);
934 ctl2
= BLM_PIPE(pipe
);
935 if (panel
->backlight
.combination_mode
)
936 ctl2
|= BLM_COMBINATION_MODE
;
937 if (panel
->backlight
.active_low_pwm
)
938 ctl2
|= BLM_POLARITY_I965
;
939 I915_WRITE(BLC_PWM_CTL2
, ctl2
);
940 POSTING_READ(BLC_PWM_CTL2
);
941 I915_WRITE(BLC_PWM_CTL2
, ctl2
| BLM_PWM_ENABLE
);
943 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
946 static void vlv_enable_backlight(struct intel_connector
*connector
)
948 struct drm_device
*dev
= connector
->base
.dev
;
949 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
950 struct intel_panel
*panel
= &connector
->panel
;
951 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
954 if (WARN_ON(pipe
!= PIPE_A
&& pipe
!= PIPE_B
))
957 ctl2
= I915_READ(VLV_BLC_PWM_CTL2(pipe
));
958 if (ctl2
& BLM_PWM_ENABLE
) {
959 DRM_DEBUG_KMS("backlight already enabled\n");
960 ctl2
&= ~BLM_PWM_ENABLE
;
961 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), ctl2
);
964 ctl
= panel
->backlight
.max
<< 16;
965 I915_WRITE(VLV_BLC_PWM_CTL(pipe
), ctl
);
967 /* XXX: combine this into above write? */
968 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
971 if (panel
->backlight
.active_low_pwm
)
972 ctl2
|= BLM_POLARITY_I965
;
973 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), ctl2
);
974 POSTING_READ(VLV_BLC_PWM_CTL2(pipe
));
975 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), ctl2
| BLM_PWM_ENABLE
);
978 static void bxt_enable_backlight(struct intel_connector
*connector
)
980 struct drm_device
*dev
= connector
->base
.dev
;
981 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
982 struct intel_panel
*panel
= &connector
->panel
;
985 pwm_ctl
= I915_READ(BXT_BLC_PWM_CTL1
);
986 if (pwm_ctl
& BXT_BLC_PWM_ENABLE
) {
987 DRM_DEBUG_KMS("backlight already enabled\n");
988 pwm_ctl
&= ~BXT_BLC_PWM_ENABLE
;
989 I915_WRITE(BXT_BLC_PWM_CTL1
, pwm_ctl
);
992 I915_WRITE(BXT_BLC_PWM_FREQ1
, panel
->backlight
.max
);
994 intel_panel_actually_set_backlight(connector
, panel
->backlight
.level
);
997 if (panel
->backlight
.active_low_pwm
)
998 pwm_ctl
|= BXT_BLC_PWM_POLARITY
;
1000 I915_WRITE(BXT_BLC_PWM_CTL1
, pwm_ctl
);
1001 POSTING_READ(BXT_BLC_PWM_CTL1
);
1002 I915_WRITE(BXT_BLC_PWM_CTL1
, pwm_ctl
| BXT_BLC_PWM_ENABLE
);
1005 void intel_panel_enable_backlight(struct intel_connector
*connector
)
1007 struct drm_device
*dev
= connector
->base
.dev
;
1008 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1009 struct intel_panel
*panel
= &connector
->panel
;
1010 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
1012 if (!panel
->backlight
.present
)
1015 DRM_DEBUG_KMS("pipe %c\n", pipe_name(pipe
));
1017 mutex_lock(&dev_priv
->backlight_lock
);
1019 WARN_ON(panel
->backlight
.max
== 0);
1021 if (panel
->backlight
.level
<= panel
->backlight
.min
) {
1022 panel
->backlight
.level
= panel
->backlight
.max
;
1023 if (panel
->backlight
.device
)
1024 panel
->backlight
.device
->props
.brightness
=
1025 scale_hw_to_user(connector
,
1026 panel
->backlight
.level
,
1027 panel
->backlight
.device
->props
.max_brightness
);
1030 dev_priv
->display
.enable_backlight(connector
);
1031 panel
->backlight
.enabled
= true;
1032 if (panel
->backlight
.device
)
1033 panel
->backlight
.device
->props
.power
= FB_BLANK_UNBLANK
;
1035 mutex_unlock(&dev_priv
->backlight_lock
);
1038 #if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)
1039 static int intel_backlight_device_update_status(struct backlight_device
*bd
)
1041 struct intel_connector
*connector
= bl_get_data(bd
);
1042 struct intel_panel
*panel
= &connector
->panel
;
1043 struct drm_device
*dev
= connector
->base
.dev
;
1045 drm_modeset_lock(&dev
->mode_config
.connection_mutex
, NULL
);
1046 DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n",
1047 bd
->props
.brightness
, bd
->props
.max_brightness
);
1048 intel_panel_set_backlight(connector
, bd
->props
.brightness
,
1049 bd
->props
.max_brightness
);
1052 * Allow flipping bl_power as a sub-state of enabled. Sadly the
1053 * backlight class device does not make it easy to to differentiate
1054 * between callbacks for brightness and bl_power, so our backlight_power
1055 * callback needs to take this into account.
1057 if (panel
->backlight
.enabled
) {
1058 if (panel
->backlight_power
) {
1059 bool enable
= bd
->props
.power
== FB_BLANK_UNBLANK
&&
1060 bd
->props
.brightness
!= 0;
1061 panel
->backlight_power(connector
, enable
);
1064 bd
->props
.power
= FB_BLANK_POWERDOWN
;
1067 drm_modeset_unlock(&dev
->mode_config
.connection_mutex
);
1071 static int intel_backlight_device_get_brightness(struct backlight_device
*bd
)
1073 struct intel_connector
*connector
= bl_get_data(bd
);
1074 struct drm_device
*dev
= connector
->base
.dev
;
1075 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1079 intel_runtime_pm_get(dev_priv
);
1080 drm_modeset_lock(&dev
->mode_config
.connection_mutex
, NULL
);
1082 hw_level
= intel_panel_get_backlight(connector
);
1083 ret
= scale_hw_to_user(connector
, hw_level
, bd
->props
.max_brightness
);
1085 drm_modeset_unlock(&dev
->mode_config
.connection_mutex
);
1086 intel_runtime_pm_put(dev_priv
);
1091 static const struct backlight_ops intel_backlight_device_ops
= {
1092 .update_status
= intel_backlight_device_update_status
,
1093 .get_brightness
= intel_backlight_device_get_brightness
,
1096 static int intel_backlight_device_register(struct intel_connector
*connector
)
1098 struct intel_panel
*panel
= &connector
->panel
;
1099 struct backlight_properties props
;
1101 if (WARN_ON(panel
->backlight
.device
))
1104 if (!panel
->backlight
.present
)
1107 WARN_ON(panel
->backlight
.max
== 0);
1109 memset(&props
, 0, sizeof(props
));
1110 props
.type
= BACKLIGHT_RAW
;
1113 * Note: Everything should work even if the backlight device max
1114 * presented to the userspace is arbitrarily chosen.
1116 props
.max_brightness
= panel
->backlight
.max
;
1117 props
.brightness
= scale_hw_to_user(connector
,
1118 panel
->backlight
.level
,
1119 props
.max_brightness
);
1121 if (panel
->backlight
.enabled
)
1122 props
.power
= FB_BLANK_UNBLANK
;
1124 props
.power
= FB_BLANK_POWERDOWN
;
1127 * Note: using the same name independent of the connector prevents
1128 * registration of multiple backlight devices in the driver.
1130 panel
->backlight
.device
=
1131 backlight_device_register("intel_backlight",
1132 connector
->base
.kdev
,
1134 &intel_backlight_device_ops
, &props
);
1136 if (IS_ERR(panel
->backlight
.device
)) {
1137 DRM_ERROR("Failed to register backlight: %ld\n",
1138 PTR_ERR(panel
->backlight
.device
));
1139 panel
->backlight
.device
= NULL
;
1143 DRM_DEBUG_KMS("Connector %s backlight sysfs interface registered\n",
1144 connector
->base
.name
);
1149 static void intel_backlight_device_unregister(struct intel_connector
*connector
)
1151 struct intel_panel
*panel
= &connector
->panel
;
1153 if (panel
->backlight
.device
) {
1154 backlight_device_unregister(panel
->backlight
.device
);
1155 panel
->backlight
.device
= NULL
;
1158 #else /* CONFIG_BACKLIGHT_CLASS_DEVICE */
1159 static int intel_backlight_device_register(struct intel_connector
*connector
)
1163 static void intel_backlight_device_unregister(struct intel_connector
*connector
)
1166 #endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
1169 * Note: The setup hooks can't assume pipe is set!
1171 * XXX: Query mode clock or hardware clock and program PWM modulation frequency
1172 * appropriately when it's 0. Use VBT and/or sane defaults.
1174 static u32
get_backlight_min_vbt(struct intel_connector
*connector
)
1176 struct drm_device
*dev
= connector
->base
.dev
;
1177 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1178 struct intel_panel
*panel
= &connector
->panel
;
1181 WARN_ON(panel
->backlight
.max
== 0);
1184 * XXX: If the vbt value is 255, it makes min equal to max, which leads
1185 * to problems. There are such machines out there. Either our
1186 * interpretation is wrong or the vbt has bogus data. Or both. Safeguard
1187 * against this by letting the minimum be at most (arbitrarily chosen)
1190 min
= clamp_t(int, dev_priv
->vbt
.backlight
.min_brightness
, 0, 64);
1191 if (min
!= dev_priv
->vbt
.backlight
.min_brightness
) {
1192 DRM_DEBUG_KMS("clamping VBT min backlight %d/255 to %d/255\n",
1193 dev_priv
->vbt
.backlight
.min_brightness
, min
);
1196 /* vbt value is a coefficient in range [0..255] */
1197 return scale(min
, 0, 255, 0, panel
->backlight
.max
);
1200 static int bdw_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1202 struct drm_device
*dev
= connector
->base
.dev
;
1203 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1204 struct intel_panel
*panel
= &connector
->panel
;
1205 u32 pch_ctl1
, pch_ctl2
, val
;
1207 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
1208 panel
->backlight
.active_low_pwm
= pch_ctl1
& BLM_PCH_POLARITY
;
1210 pch_ctl2
= I915_READ(BLC_PWM_PCH_CTL2
);
1211 panel
->backlight
.max
= pch_ctl2
>> 16;
1212 if (!panel
->backlight
.max
)
1215 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1217 val
= bdw_get_backlight(connector
);
1218 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
1220 panel
->backlight
.enabled
= (pch_ctl1
& BLM_PCH_PWM_ENABLE
) &&
1221 panel
->backlight
.level
!= 0;
1226 static int pch_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1228 struct drm_device
*dev
= connector
->base
.dev
;
1229 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1230 struct intel_panel
*panel
= &connector
->panel
;
1231 u32 cpu_ctl2
, pch_ctl1
, pch_ctl2
, val
;
1233 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
1234 panel
->backlight
.active_low_pwm
= pch_ctl1
& BLM_PCH_POLARITY
;
1236 pch_ctl2
= I915_READ(BLC_PWM_PCH_CTL2
);
1237 panel
->backlight
.max
= pch_ctl2
>> 16;
1238 if (!panel
->backlight
.max
)
1241 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1243 val
= pch_get_backlight(connector
);
1244 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
1246 cpu_ctl2
= I915_READ(BLC_PWM_CPU_CTL2
);
1247 panel
->backlight
.enabled
= (cpu_ctl2
& BLM_PWM_ENABLE
) &&
1248 (pch_ctl1
& BLM_PCH_PWM_ENABLE
) && panel
->backlight
.level
!= 0;
1253 static int i9xx_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1255 struct drm_device
*dev
= connector
->base
.dev
;
1256 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1257 struct intel_panel
*panel
= &connector
->panel
;
1260 ctl
= I915_READ(BLC_PWM_CTL
);
1262 if (IS_GEN2(dev
) || IS_I915GM(dev
) || IS_I945GM(dev
))
1263 panel
->backlight
.combination_mode
= ctl
& BLM_LEGACY_MODE
;
1265 if (IS_PINEVIEW(dev
))
1266 panel
->backlight
.active_low_pwm
= ctl
& BLM_POLARITY_PNV
;
1268 panel
->backlight
.max
= ctl
>> 17;
1269 if (panel
->backlight
.combination_mode
)
1270 panel
->backlight
.max
*= 0xff;
1272 if (!panel
->backlight
.max
)
1275 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1277 val
= i9xx_get_backlight(connector
);
1278 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
1280 panel
->backlight
.enabled
= panel
->backlight
.level
!= 0;
1285 static int i965_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1287 struct drm_device
*dev
= connector
->base
.dev
;
1288 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1289 struct intel_panel
*panel
= &connector
->panel
;
1292 ctl2
= I915_READ(BLC_PWM_CTL2
);
1293 panel
->backlight
.combination_mode
= ctl2
& BLM_COMBINATION_MODE
;
1294 panel
->backlight
.active_low_pwm
= ctl2
& BLM_POLARITY_I965
;
1296 ctl
= I915_READ(BLC_PWM_CTL
);
1297 panel
->backlight
.max
= ctl
>> 16;
1298 if (panel
->backlight
.combination_mode
)
1299 panel
->backlight
.max
*= 0xff;
1301 if (!panel
->backlight
.max
)
1304 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1306 val
= i9xx_get_backlight(connector
);
1307 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
1309 panel
->backlight
.enabled
= (ctl2
& BLM_PWM_ENABLE
) &&
1310 panel
->backlight
.level
!= 0;
1315 static int vlv_setup_backlight(struct intel_connector
*connector
, enum pipe pipe
)
1317 struct drm_device
*dev
= connector
->base
.dev
;
1318 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1319 struct intel_panel
*panel
= &connector
->panel
;
1323 for_each_pipe(dev_priv
, p
) {
1324 u32 cur_val
= I915_READ(VLV_BLC_PWM_CTL(p
));
1326 /* Skip if the modulation freq is already set */
1327 if (cur_val
& ~BACKLIGHT_DUTY_CYCLE_MASK
)
1330 cur_val
&= BACKLIGHT_DUTY_CYCLE_MASK
;
1331 I915_WRITE(VLV_BLC_PWM_CTL(p
), (0xf42 << 16) |
1335 if (WARN_ON(pipe
!= PIPE_A
&& pipe
!= PIPE_B
))
1338 ctl2
= I915_READ(VLV_BLC_PWM_CTL2(pipe
));
1339 panel
->backlight
.active_low_pwm
= ctl2
& BLM_POLARITY_I965
;
1341 ctl
= I915_READ(VLV_BLC_PWM_CTL(pipe
));
1342 panel
->backlight
.max
= ctl
>> 16;
1343 if (!panel
->backlight
.max
)
1346 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1348 val
= _vlv_get_backlight(dev
, pipe
);
1349 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
1351 panel
->backlight
.enabled
= (ctl2
& BLM_PWM_ENABLE
) &&
1352 panel
->backlight
.level
!= 0;
1358 bxt_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1360 struct drm_device
*dev
= connector
->base
.dev
;
1361 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1362 struct intel_panel
*panel
= &connector
->panel
;
1365 pwm_ctl
= I915_READ(BXT_BLC_PWM_CTL1
);
1366 panel
->backlight
.active_low_pwm
= pwm_ctl
& BXT_BLC_PWM_POLARITY
;
1368 panel
->backlight
.max
= I915_READ(BXT_BLC_PWM_FREQ1
);
1369 if (!panel
->backlight
.max
)
1372 val
= bxt_get_backlight(connector
);
1373 panel
->backlight
.level
= intel_panel_compute_brightness(connector
, val
);
1375 panel
->backlight
.enabled
= (pwm_ctl
& BXT_BLC_PWM_ENABLE
) &&
1376 panel
->backlight
.level
!= 0;
1381 int intel_panel_setup_backlight(struct drm_connector
*connector
, enum pipe pipe
)
1383 struct drm_device
*dev
= connector
->dev
;
1384 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1385 struct intel_connector
*intel_connector
= to_intel_connector(connector
);
1386 struct intel_panel
*panel
= &intel_connector
->panel
;
1389 if (!dev_priv
->vbt
.backlight
.present
) {
1390 if (dev_priv
->quirks
& QUIRK_BACKLIGHT_PRESENT
) {
1391 DRM_DEBUG_KMS("no backlight present per VBT, but present per quirk\n");
1393 DRM_DEBUG_KMS("no backlight present per VBT\n");
1398 /* set level and max in panel struct */
1399 mutex_lock(&dev_priv
->backlight_lock
);
1400 ret
= dev_priv
->display
.setup_backlight(intel_connector
, pipe
);
1401 mutex_unlock(&dev_priv
->backlight_lock
);
1404 DRM_DEBUG_KMS("failed to setup backlight for connector %s\n",
1409 panel
->backlight
.present
= true;
1411 DRM_DEBUG_KMS("Connector %s backlight initialized, %s, brightness %u/%u\n",
1413 panel
->backlight
.enabled
? "enabled" : "disabled",
1414 panel
->backlight
.level
, panel
->backlight
.max
);
1419 void intel_panel_destroy_backlight(struct drm_connector
*connector
)
1421 struct intel_connector
*intel_connector
= to_intel_connector(connector
);
1422 struct intel_panel
*panel
= &intel_connector
->panel
;
1424 panel
->backlight
.present
= false;
1427 /* Set up chip specific backlight functions */
1428 void intel_panel_init_backlight_funcs(struct drm_device
*dev
)
1430 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1432 if (IS_BROXTON(dev
)) {
1433 dev_priv
->display
.setup_backlight
= bxt_setup_backlight
;
1434 dev_priv
->display
.enable_backlight
= bxt_enable_backlight
;
1435 dev_priv
->display
.disable_backlight
= bxt_disable_backlight
;
1436 dev_priv
->display
.set_backlight
= bxt_set_backlight
;
1437 dev_priv
->display
.get_backlight
= bxt_get_backlight
;
1438 } else if (IS_BROADWELL(dev
) || IS_SKYLAKE(dev
)) {
1439 dev_priv
->display
.setup_backlight
= bdw_setup_backlight
;
1440 dev_priv
->display
.enable_backlight
= bdw_enable_backlight
;
1441 dev_priv
->display
.disable_backlight
= pch_disable_backlight
;
1442 dev_priv
->display
.set_backlight
= bdw_set_backlight
;
1443 dev_priv
->display
.get_backlight
= bdw_get_backlight
;
1444 } else if (HAS_PCH_SPLIT(dev
)) {
1445 dev_priv
->display
.setup_backlight
= pch_setup_backlight
;
1446 dev_priv
->display
.enable_backlight
= pch_enable_backlight
;
1447 dev_priv
->display
.disable_backlight
= pch_disable_backlight
;
1448 dev_priv
->display
.set_backlight
= pch_set_backlight
;
1449 dev_priv
->display
.get_backlight
= pch_get_backlight
;
1450 } else if (IS_VALLEYVIEW(dev
)) {
1451 dev_priv
->display
.setup_backlight
= vlv_setup_backlight
;
1452 dev_priv
->display
.enable_backlight
= vlv_enable_backlight
;
1453 dev_priv
->display
.disable_backlight
= vlv_disable_backlight
;
1454 dev_priv
->display
.set_backlight
= vlv_set_backlight
;
1455 dev_priv
->display
.get_backlight
= vlv_get_backlight
;
1456 } else if (IS_GEN4(dev
)) {
1457 dev_priv
->display
.setup_backlight
= i965_setup_backlight
;
1458 dev_priv
->display
.enable_backlight
= i965_enable_backlight
;
1459 dev_priv
->display
.disable_backlight
= i965_disable_backlight
;
1460 dev_priv
->display
.set_backlight
= i9xx_set_backlight
;
1461 dev_priv
->display
.get_backlight
= i9xx_get_backlight
;
1463 dev_priv
->display
.setup_backlight
= i9xx_setup_backlight
;
1464 dev_priv
->display
.enable_backlight
= i9xx_enable_backlight
;
1465 dev_priv
->display
.disable_backlight
= i9xx_disable_backlight
;
1466 dev_priv
->display
.set_backlight
= i9xx_set_backlight
;
1467 dev_priv
->display
.get_backlight
= i9xx_get_backlight
;
1471 int intel_panel_init(struct intel_panel
*panel
,
1472 struct drm_display_mode
*fixed_mode
,
1473 struct drm_display_mode
*downclock_mode
)
1475 panel
->fixed_mode
= fixed_mode
;
1476 panel
->downclock_mode
= downclock_mode
;
1481 void intel_panel_fini(struct intel_panel
*panel
)
1483 struct intel_connector
*intel_connector
=
1484 container_of(panel
, struct intel_connector
, panel
);
1486 if (panel
->fixed_mode
)
1487 drm_mode_destroy(intel_connector
->base
.dev
, panel
->fixed_mode
);
1489 if (panel
->downclock_mode
)
1490 drm_mode_destroy(intel_connector
->base
.dev
,
1491 panel
->downclock_mode
);
1494 void intel_backlight_register(struct drm_device
*dev
)
1496 struct intel_connector
*connector
;
1498 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, base
.head
)
1499 intel_backlight_device_register(connector
);
1502 void intel_backlight_unregister(struct drm_device
*dev
)
1504 struct intel_connector
*connector
;
1506 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, base
.head
)
1507 intel_backlight_device_unregister(connector
);