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 <linux/pwm.h>
36 #include "intel_drv.h"
38 #define CRC_PMIC_PWM_PERIOD_NS 21333
41 intel_fixed_panel_mode(const struct drm_display_mode
*fixed_mode
,
42 struct drm_display_mode
*adjusted_mode
)
44 drm_mode_copy(adjusted_mode
, fixed_mode
);
46 drm_mode_set_crtcinfo(adjusted_mode
, 0);
50 * intel_find_panel_downclock - find the reduced downclock for LVDS in EDID
51 * @dev_priv: i915 device instance
52 * @fixed_mode : panel native mode
53 * @connector: LVDS/eDP connector
55 * Return downclock_avail
56 * Find the reduced downclock for LVDS/eDP in EDID.
58 struct drm_display_mode
*
59 intel_find_panel_downclock(struct drm_i915_private
*dev_priv
,
60 struct drm_display_mode
*fixed_mode
,
61 struct drm_connector
*connector
)
63 struct drm_display_mode
*scan
, *tmp_mode
;
66 temp_downclock
= fixed_mode
->clock
;
69 list_for_each_entry(scan
, &connector
->probed_modes
, head
) {
71 * If one mode has the same resolution with the fixed_panel
72 * mode while they have the different refresh rate, it means
73 * that the reduced downclock is found. In such
74 * case we can set the different FPx0/1 to dynamically select
75 * between low and high frequency.
77 if (scan
->hdisplay
== fixed_mode
->hdisplay
&&
78 scan
->hsync_start
== fixed_mode
->hsync_start
&&
79 scan
->hsync_end
== fixed_mode
->hsync_end
&&
80 scan
->htotal
== fixed_mode
->htotal
&&
81 scan
->vdisplay
== fixed_mode
->vdisplay
&&
82 scan
->vsync_start
== fixed_mode
->vsync_start
&&
83 scan
->vsync_end
== fixed_mode
->vsync_end
&&
84 scan
->vtotal
== fixed_mode
->vtotal
) {
85 if (scan
->clock
< temp_downclock
) {
87 * The downclock is already found. But we
88 * expect to find the lower downclock.
90 temp_downclock
= scan
->clock
;
96 if (temp_downclock
< fixed_mode
->clock
)
97 return drm_mode_duplicate(&dev_priv
->drm
, tmp_mode
);
102 /* adjusted_mode has been preset to be the panel's fixed mode */
104 intel_pch_panel_fitting(struct intel_crtc
*intel_crtc
,
105 struct intel_crtc_state
*pipe_config
,
108 const struct drm_display_mode
*adjusted_mode
= &pipe_config
->base
.adjusted_mode
;
109 int x
= 0, y
= 0, width
= 0, height
= 0;
111 /* Native modes don't need fitting */
112 if (adjusted_mode
->crtc_hdisplay
== pipe_config
->pipe_src_w
&&
113 adjusted_mode
->crtc_vdisplay
== pipe_config
->pipe_src_h
&&
114 !pipe_config
->ycbcr420
)
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
->crtc_hdisplay
- width
+ 1)/2;
122 y
= (adjusted_mode
->crtc_vdisplay
- height
+ 1)/2;
125 case DRM_MODE_SCALE_ASPECT
:
126 /* Scale but preserve the aspect ratio */
128 u32 scaled_width
= adjusted_mode
->crtc_hdisplay
129 * pipe_config
->pipe_src_h
;
130 u32 scaled_height
= pipe_config
->pipe_src_w
131 * adjusted_mode
->crtc_vdisplay
;
132 if (scaled_width
> scaled_height
) { /* pillar */
133 width
= scaled_height
/ pipe_config
->pipe_src_h
;
136 x
= (adjusted_mode
->crtc_hdisplay
- width
+ 1) / 2;
138 height
= adjusted_mode
->crtc_vdisplay
;
139 } else if (scaled_width
< scaled_height
) { /* letter */
140 height
= scaled_width
/ pipe_config
->pipe_src_w
;
143 y
= (adjusted_mode
->crtc_vdisplay
- height
+ 1) / 2;
145 width
= adjusted_mode
->crtc_hdisplay
;
148 width
= adjusted_mode
->crtc_hdisplay
;
149 height
= adjusted_mode
->crtc_vdisplay
;
154 case DRM_MODE_SCALE_FULLSCREEN
:
156 width
= adjusted_mode
->crtc_hdisplay
;
157 height
= adjusted_mode
->crtc_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
*adjusted_mode
,
175 u32 border
, sync_pos
, blank_width
, sync_width
;
177 /* keep the hsync and hblank widths constant */
178 sync_width
= adjusted_mode
->crtc_hsync_end
- adjusted_mode
->crtc_hsync_start
;
179 blank_width
= adjusted_mode
->crtc_hblank_end
- adjusted_mode
->crtc_hblank_start
;
180 sync_pos
= (blank_width
- sync_width
+ 1) / 2;
182 border
= (adjusted_mode
->crtc_hdisplay
- width
+ 1) / 2;
183 border
+= border
& 1; /* make the border even */
185 adjusted_mode
->crtc_hdisplay
= width
;
186 adjusted_mode
->crtc_hblank_start
= width
+ border
;
187 adjusted_mode
->crtc_hblank_end
= adjusted_mode
->crtc_hblank_start
+ blank_width
;
189 adjusted_mode
->crtc_hsync_start
= adjusted_mode
->crtc_hblank_start
+ sync_pos
;
190 adjusted_mode
->crtc_hsync_end
= adjusted_mode
->crtc_hsync_start
+ sync_width
;
194 centre_vertically(struct drm_display_mode
*adjusted_mode
,
197 u32 border
, sync_pos
, blank_width
, sync_width
;
199 /* keep the vsync and vblank widths constant */
200 sync_width
= adjusted_mode
->crtc_vsync_end
- adjusted_mode
->crtc_vsync_start
;
201 blank_width
= adjusted_mode
->crtc_vblank_end
- adjusted_mode
->crtc_vblank_start
;
202 sync_pos
= (blank_width
- sync_width
+ 1) / 2;
204 border
= (adjusted_mode
->crtc_vdisplay
- height
+ 1) / 2;
206 adjusted_mode
->crtc_vdisplay
= height
;
207 adjusted_mode
->crtc_vblank_start
= height
+ border
;
208 adjusted_mode
->crtc_vblank_end
= adjusted_mode
->crtc_vblank_start
+ blank_width
;
210 adjusted_mode
->crtc_vsync_start
= adjusted_mode
->crtc_vblank_start
+ sync_pos
;
211 adjusted_mode
->crtc_vsync_end
= adjusted_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 const struct drm_display_mode
*adjusted_mode
= &pipe_config
->base
.adjusted_mode
;
231 u32 scaled_width
= adjusted_mode
->crtc_hdisplay
*
232 pipe_config
->pipe_src_h
;
233 u32 scaled_height
= pipe_config
->pipe_src_w
*
234 adjusted_mode
->crtc_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
->crtc_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
->crtc_hdisplay
*
253 pipe_config
->pipe_src_h
;
254 u32 scaled_height
= pipe_config
->pipe_src_w
*
255 adjusted_mode
->crtc_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
->crtc_vdisplay
) {
270 bits
= panel_fitter_scaling(pipe_config
->pipe_src_h
,
271 adjusted_mode
->crtc_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
->crtc_hdisplay
) {
286 bits
= panel_fitter_scaling(pipe_config
->pipe_src_w
,
287 adjusted_mode
->crtc_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_i915_private
*dev_priv
= to_i915(intel_crtc
->base
.dev
);
309 u32 pfit_control
= 0, pfit_pgm_ratios
= 0, border
= 0;
310 struct drm_display_mode
*adjusted_mode
= &pipe_config
->base
.adjusted_mode
;
312 /* Native modes don't need fitting */
313 if (adjusted_mode
->crtc_hdisplay
== pipe_config
->pipe_src_w
&&
314 adjusted_mode
->crtc_vdisplay
== pipe_config
->pipe_src_h
)
317 switch (fitting_mode
) {
318 case DRM_MODE_SCALE_CENTER
:
320 * For centered modes, we have to calculate border widths &
321 * heights and modify the values programmed into the CRTC.
323 centre_horizontally(adjusted_mode
, pipe_config
->pipe_src_w
);
324 centre_vertically(adjusted_mode
, pipe_config
->pipe_src_h
);
325 border
= LVDS_BORDER_ENABLE
;
327 case DRM_MODE_SCALE_ASPECT
:
328 /* Scale but preserve the aspect ratio */
329 if (INTEL_GEN(dev_priv
) >= 4)
330 i965_scale_aspect(pipe_config
, &pfit_control
);
332 i9xx_scale_aspect(pipe_config
, &pfit_control
,
333 &pfit_pgm_ratios
, &border
);
335 case DRM_MODE_SCALE_FULLSCREEN
:
337 * Full scaling, even if it changes the aspect ratio.
338 * Fortunately this is all done for us in hw.
340 if (pipe_config
->pipe_src_h
!= adjusted_mode
->crtc_vdisplay
||
341 pipe_config
->pipe_src_w
!= adjusted_mode
->crtc_hdisplay
) {
342 pfit_control
|= PFIT_ENABLE
;
343 if (INTEL_GEN(dev_priv
) >= 4)
344 pfit_control
|= PFIT_SCALING_AUTO
;
346 pfit_control
|= (VERT_AUTO_SCALE
|
347 VERT_INTERP_BILINEAR
|
349 HORIZ_INTERP_BILINEAR
);
353 WARN(1, "bad panel fit mode: %d\n", fitting_mode
);
357 /* 965+ wants fuzzy fitting */
358 /* FIXME: handle multiple panels by failing gracefully */
359 if (INTEL_GEN(dev_priv
) >= 4)
360 pfit_control
|= ((intel_crtc
->pipe
<< PFIT_PIPE_SHIFT
) |
364 if ((pfit_control
& PFIT_ENABLE
) == 0) {
369 /* Make sure pre-965 set dither correctly for 18bpp panels. */
370 if (INTEL_GEN(dev_priv
) < 4 && pipe_config
->pipe_bpp
== 18)
371 pfit_control
|= PANEL_8TO6_DITHER_ENABLE
;
373 pipe_config
->gmch_pfit
.control
= pfit_control
;
374 pipe_config
->gmch_pfit
.pgm_ratios
= pfit_pgm_ratios
;
375 pipe_config
->gmch_pfit
.lvds_border_bits
= border
;
378 enum drm_connector_status
379 intel_panel_detect(struct drm_i915_private
*dev_priv
)
381 /* Assume that the BIOS does not lie through the OpRegion... */
382 if (!i915_modparams
.panel_ignore_lid
&& dev_priv
->opregion
.lid_state
) {
383 return *dev_priv
->opregion
.lid_state
& 0x1 ?
384 connector_status_connected
:
385 connector_status_disconnected
;
388 switch (i915_modparams
.panel_ignore_lid
) {
390 return connector_status_connected
;
392 return connector_status_disconnected
;
394 return connector_status_unknown
;
399 * scale - scale values from one range to another
401 * @source_val: value in range [@source_min..@source_max]
403 * Return @source_val in range [@source_min..@source_max] scaled to range
404 * [@target_min..@target_max].
406 static uint32_t scale(uint32_t source_val
,
407 uint32_t source_min
, uint32_t source_max
,
408 uint32_t target_min
, uint32_t target_max
)
412 WARN_ON(source_min
> source_max
);
413 WARN_ON(target_min
> target_max
);
416 source_val
= clamp(source_val
, source_min
, source_max
);
418 /* avoid overflows */
419 target_val
= DIV_ROUND_CLOSEST_ULL((uint64_t)(source_val
- source_min
) *
420 (target_max
- target_min
), source_max
- source_min
);
421 target_val
+= target_min
;
426 /* Scale user_level in range [0..user_max] to [hw_min..hw_max]. */
427 static inline u32
scale_user_to_hw(struct intel_connector
*connector
,
428 u32 user_level
, u32 user_max
)
430 struct intel_panel
*panel
= &connector
->panel
;
432 return scale(user_level
, 0, user_max
,
433 panel
->backlight
.min
, panel
->backlight
.max
);
436 /* Scale user_level in range [0..user_max] to [0..hw_max], clamping the result
437 * to [hw_min..hw_max]. */
438 static inline u32
clamp_user_to_hw(struct intel_connector
*connector
,
439 u32 user_level
, u32 user_max
)
441 struct intel_panel
*panel
= &connector
->panel
;
444 hw_level
= scale(user_level
, 0, user_max
, 0, panel
->backlight
.max
);
445 hw_level
= clamp(hw_level
, panel
->backlight
.min
, panel
->backlight
.max
);
450 /* Scale hw_level in range [hw_min..hw_max] to [0..user_max]. */
451 static inline u32
scale_hw_to_user(struct intel_connector
*connector
,
452 u32 hw_level
, u32 user_max
)
454 struct intel_panel
*panel
= &connector
->panel
;
456 return scale(hw_level
, panel
->backlight
.min
, panel
->backlight
.max
,
460 static u32
intel_panel_compute_brightness(struct intel_connector
*connector
,
463 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
464 struct intel_panel
*panel
= &connector
->panel
;
466 WARN_ON(panel
->backlight
.max
== 0);
468 if (i915_modparams
.invert_brightness
< 0)
471 if (i915_modparams
.invert_brightness
> 0 ||
472 dev_priv
->quirks
& QUIRK_INVERT_BRIGHTNESS
) {
473 return panel
->backlight
.max
- val
+ panel
->backlight
.min
;
479 static u32
lpt_get_backlight(struct intel_connector
*connector
)
481 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
483 return I915_READ(BLC_PWM_PCH_CTL2
) & BACKLIGHT_DUTY_CYCLE_MASK
;
486 static u32
pch_get_backlight(struct intel_connector
*connector
)
488 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
490 return I915_READ(BLC_PWM_CPU_CTL
) & BACKLIGHT_DUTY_CYCLE_MASK
;
493 static u32
i9xx_get_backlight(struct intel_connector
*connector
)
495 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
496 struct intel_panel
*panel
= &connector
->panel
;
499 val
= I915_READ(BLC_PWM_CTL
) & BACKLIGHT_DUTY_CYCLE_MASK
;
500 if (INTEL_INFO(dev_priv
)->gen
< 4)
503 if (panel
->backlight
.combination_mode
) {
506 pci_read_config_byte(dev_priv
->drm
.pdev
, LBPC
, &lbpc
);
513 static u32
_vlv_get_backlight(struct drm_i915_private
*dev_priv
, enum pipe pipe
)
515 if (WARN_ON(pipe
!= PIPE_A
&& pipe
!= PIPE_B
))
518 return I915_READ(VLV_BLC_PWM_CTL(pipe
)) & BACKLIGHT_DUTY_CYCLE_MASK
;
521 static u32
vlv_get_backlight(struct intel_connector
*connector
)
523 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
524 enum pipe pipe
= intel_get_pipe_from_connector(connector
);
526 return _vlv_get_backlight(dev_priv
, pipe
);
529 static u32
bxt_get_backlight(struct intel_connector
*connector
)
531 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
532 struct intel_panel
*panel
= &connector
->panel
;
534 return I915_READ(BXT_BLC_PWM_DUTY(panel
->backlight
.controller
));
537 static u32
pwm_get_backlight(struct intel_connector
*connector
)
539 struct intel_panel
*panel
= &connector
->panel
;
542 duty_ns
= pwm_get_duty_cycle(panel
->backlight
.pwm
);
543 return DIV_ROUND_UP(duty_ns
* 100, CRC_PMIC_PWM_PERIOD_NS
);
546 static u32
intel_panel_get_backlight(struct intel_connector
*connector
)
548 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
549 struct intel_panel
*panel
= &connector
->panel
;
552 mutex_lock(&dev_priv
->backlight_lock
);
554 if (panel
->backlight
.enabled
) {
555 val
= panel
->backlight
.get(connector
);
556 val
= intel_panel_compute_brightness(connector
, val
);
559 mutex_unlock(&dev_priv
->backlight_lock
);
561 DRM_DEBUG_DRIVER("get backlight PWM = %d\n", val
);
565 static void lpt_set_backlight(const struct drm_connector_state
*conn_state
, u32 level
)
567 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
568 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
570 u32 val
= I915_READ(BLC_PWM_PCH_CTL2
) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
571 I915_WRITE(BLC_PWM_PCH_CTL2
, val
| level
);
574 static void pch_set_backlight(const struct drm_connector_state
*conn_state
, u32 level
)
576 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
577 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
580 tmp
= I915_READ(BLC_PWM_CPU_CTL
) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
581 I915_WRITE(BLC_PWM_CPU_CTL
, tmp
| level
);
584 static void i9xx_set_backlight(const struct drm_connector_state
*conn_state
, u32 level
)
586 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
587 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
588 struct intel_panel
*panel
= &connector
->panel
;
591 WARN_ON(panel
->backlight
.max
== 0);
593 if (panel
->backlight
.combination_mode
) {
596 lbpc
= level
* 0xfe / panel
->backlight
.max
+ 1;
598 pci_write_config_byte(dev_priv
->drm
.pdev
, LBPC
, lbpc
);
601 if (IS_GEN4(dev_priv
)) {
602 mask
= BACKLIGHT_DUTY_CYCLE_MASK
;
605 mask
= BACKLIGHT_DUTY_CYCLE_MASK_PNV
;
608 tmp
= I915_READ(BLC_PWM_CTL
) & ~mask
;
609 I915_WRITE(BLC_PWM_CTL
, tmp
| level
);
612 static void vlv_set_backlight(const struct drm_connector_state
*conn_state
, u32 level
)
614 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
615 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
616 enum pipe pipe
= to_intel_crtc(conn_state
->crtc
)->pipe
;
619 tmp
= I915_READ(VLV_BLC_PWM_CTL(pipe
)) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
620 I915_WRITE(VLV_BLC_PWM_CTL(pipe
), tmp
| level
);
623 static void bxt_set_backlight(const struct drm_connector_state
*conn_state
, u32 level
)
625 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
626 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
627 struct intel_panel
*panel
= &connector
->panel
;
629 I915_WRITE(BXT_BLC_PWM_DUTY(panel
->backlight
.controller
), level
);
632 static void pwm_set_backlight(const struct drm_connector_state
*conn_state
, u32 level
)
634 struct intel_panel
*panel
= &to_intel_connector(conn_state
->connector
)->panel
;
635 int duty_ns
= DIV_ROUND_UP(level
* CRC_PMIC_PWM_PERIOD_NS
, 100);
637 pwm_config(panel
->backlight
.pwm
, duty_ns
, CRC_PMIC_PWM_PERIOD_NS
);
641 intel_panel_actually_set_backlight(const struct drm_connector_state
*conn_state
, u32 level
)
643 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
644 struct intel_panel
*panel
= &connector
->panel
;
646 DRM_DEBUG_DRIVER("set backlight PWM = %d\n", level
);
648 level
= intel_panel_compute_brightness(connector
, level
);
649 panel
->backlight
.set(conn_state
, level
);
652 /* set backlight brightness to level in range [0..max], scaling wrt hw min */
653 static void intel_panel_set_backlight(const struct drm_connector_state
*conn_state
,
654 u32 user_level
, u32 user_max
)
656 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
657 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
658 struct intel_panel
*panel
= &connector
->panel
;
661 if (!panel
->backlight
.present
)
664 mutex_lock(&dev_priv
->backlight_lock
);
666 WARN_ON(panel
->backlight
.max
== 0);
668 hw_level
= scale_user_to_hw(connector
, user_level
, user_max
);
669 panel
->backlight
.level
= hw_level
;
671 if (panel
->backlight
.enabled
)
672 intel_panel_actually_set_backlight(conn_state
, hw_level
);
674 mutex_unlock(&dev_priv
->backlight_lock
);
677 /* set backlight brightness to level in range [0..max], assuming hw min is
680 void intel_panel_set_backlight_acpi(const struct drm_connector_state
*conn_state
,
681 u32 user_level
, u32 user_max
)
683 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
684 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
685 struct intel_panel
*panel
= &connector
->panel
;
689 * Lack of crtc may occur during driver init because
690 * connection_mutex isn't held across the entire backlight
691 * setup + modeset readout, and the BIOS can issue the
692 * requests at any time.
694 if (!panel
->backlight
.present
|| !conn_state
->crtc
)
697 mutex_lock(&dev_priv
->backlight_lock
);
699 WARN_ON(panel
->backlight
.max
== 0);
701 hw_level
= clamp_user_to_hw(connector
, user_level
, user_max
);
702 panel
->backlight
.level
= hw_level
;
704 if (panel
->backlight
.device
)
705 panel
->backlight
.device
->props
.brightness
=
706 scale_hw_to_user(connector
,
707 panel
->backlight
.level
,
708 panel
->backlight
.device
->props
.max_brightness
);
710 if (panel
->backlight
.enabled
)
711 intel_panel_actually_set_backlight(conn_state
, hw_level
);
713 mutex_unlock(&dev_priv
->backlight_lock
);
716 static void lpt_disable_backlight(const struct drm_connector_state
*old_conn_state
)
718 struct intel_connector
*connector
= to_intel_connector(old_conn_state
->connector
);
719 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
722 intel_panel_actually_set_backlight(old_conn_state
, 0);
725 * Although we don't support or enable CPU PWM with LPT/SPT based
726 * systems, it may have been enabled prior to loading the
727 * driver. Disable to avoid warnings on LCPLL disable.
729 * This needs rework if we need to add support for CPU PWM on PCH split
732 tmp
= I915_READ(BLC_PWM_CPU_CTL2
);
733 if (tmp
& BLM_PWM_ENABLE
) {
734 DRM_DEBUG_KMS("cpu backlight was enabled, disabling\n");
735 I915_WRITE(BLC_PWM_CPU_CTL2
, tmp
& ~BLM_PWM_ENABLE
);
738 tmp
= I915_READ(BLC_PWM_PCH_CTL1
);
739 I915_WRITE(BLC_PWM_PCH_CTL1
, tmp
& ~BLM_PCH_PWM_ENABLE
);
742 static void pch_disable_backlight(const struct drm_connector_state
*old_conn_state
)
744 struct intel_connector
*connector
= to_intel_connector(old_conn_state
->connector
);
745 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
748 intel_panel_actually_set_backlight(old_conn_state
, 0);
750 tmp
= I915_READ(BLC_PWM_CPU_CTL2
);
751 I915_WRITE(BLC_PWM_CPU_CTL2
, tmp
& ~BLM_PWM_ENABLE
);
753 tmp
= I915_READ(BLC_PWM_PCH_CTL1
);
754 I915_WRITE(BLC_PWM_PCH_CTL1
, tmp
& ~BLM_PCH_PWM_ENABLE
);
757 static void i9xx_disable_backlight(const struct drm_connector_state
*old_conn_state
)
759 intel_panel_actually_set_backlight(old_conn_state
, 0);
762 static void i965_disable_backlight(const struct drm_connector_state
*old_conn_state
)
764 struct drm_i915_private
*dev_priv
= to_i915(old_conn_state
->connector
->dev
);
767 intel_panel_actually_set_backlight(old_conn_state
, 0);
769 tmp
= I915_READ(BLC_PWM_CTL2
);
770 I915_WRITE(BLC_PWM_CTL2
, tmp
& ~BLM_PWM_ENABLE
);
773 static void vlv_disable_backlight(const struct drm_connector_state
*old_conn_state
)
775 struct intel_connector
*connector
= to_intel_connector(old_conn_state
->connector
);
776 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
777 enum pipe pipe
= to_intel_crtc(old_conn_state
->crtc
)->pipe
;
780 intel_panel_actually_set_backlight(old_conn_state
, 0);
782 tmp
= I915_READ(VLV_BLC_PWM_CTL2(pipe
));
783 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), tmp
& ~BLM_PWM_ENABLE
);
786 static void bxt_disable_backlight(const struct drm_connector_state
*old_conn_state
)
788 struct intel_connector
*connector
= to_intel_connector(old_conn_state
->connector
);
789 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
790 struct intel_panel
*panel
= &connector
->panel
;
793 intel_panel_actually_set_backlight(old_conn_state
, 0);
795 tmp
= I915_READ(BXT_BLC_PWM_CTL(panel
->backlight
.controller
));
796 I915_WRITE(BXT_BLC_PWM_CTL(panel
->backlight
.controller
),
797 tmp
& ~BXT_BLC_PWM_ENABLE
);
799 if (panel
->backlight
.controller
== 1) {
800 val
= I915_READ(UTIL_PIN_CTL
);
801 val
&= ~UTIL_PIN_ENABLE
;
802 I915_WRITE(UTIL_PIN_CTL
, val
);
806 static void cnp_disable_backlight(const struct drm_connector_state
*old_conn_state
)
808 struct intel_connector
*connector
= to_intel_connector(old_conn_state
->connector
);
809 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
810 struct intel_panel
*panel
= &connector
->panel
;
813 intel_panel_actually_set_backlight(old_conn_state
, 0);
815 tmp
= I915_READ(BXT_BLC_PWM_CTL(panel
->backlight
.controller
));
816 I915_WRITE(BXT_BLC_PWM_CTL(panel
->backlight
.controller
),
817 tmp
& ~BXT_BLC_PWM_ENABLE
);
820 static void pwm_disable_backlight(const struct drm_connector_state
*old_conn_state
)
822 struct intel_connector
*connector
= to_intel_connector(old_conn_state
->connector
);
823 struct intel_panel
*panel
= &connector
->panel
;
825 /* Disable the backlight */
826 pwm_config(panel
->backlight
.pwm
, 0, CRC_PMIC_PWM_PERIOD_NS
);
827 usleep_range(2000, 3000);
828 pwm_disable(panel
->backlight
.pwm
);
831 void intel_panel_disable_backlight(const struct drm_connector_state
*old_conn_state
)
833 struct intel_connector
*connector
= to_intel_connector(old_conn_state
->connector
);
834 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
835 struct intel_panel
*panel
= &connector
->panel
;
837 if (!panel
->backlight
.present
)
841 * Do not disable backlight on the vga_switcheroo path. When switching
842 * away from i915, the other client may depend on i915 to handle the
843 * backlight. This will leave the backlight on unnecessarily when
844 * another client is not activated.
846 if (dev_priv
->drm
.switch_power_state
== DRM_SWITCH_POWER_CHANGING
) {
847 DRM_DEBUG_DRIVER("Skipping backlight disable on vga switch\n");
851 mutex_lock(&dev_priv
->backlight_lock
);
853 if (panel
->backlight
.device
)
854 panel
->backlight
.device
->props
.power
= FB_BLANK_POWERDOWN
;
855 panel
->backlight
.enabled
= false;
856 panel
->backlight
.disable(old_conn_state
);
858 mutex_unlock(&dev_priv
->backlight_lock
);
861 static void lpt_enable_backlight(const struct intel_crtc_state
*crtc_state
,
862 const struct drm_connector_state
*conn_state
)
864 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
865 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
866 struct intel_panel
*panel
= &connector
->panel
;
867 u32 pch_ctl1
, pch_ctl2
, schicken
;
869 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
870 if (pch_ctl1
& BLM_PCH_PWM_ENABLE
) {
871 DRM_DEBUG_KMS("pch backlight already enabled\n");
872 pch_ctl1
&= ~BLM_PCH_PWM_ENABLE
;
873 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
876 if (HAS_PCH_LPT(dev_priv
)) {
877 schicken
= I915_READ(SOUTH_CHICKEN2
);
878 if (panel
->backlight
.alternate_pwm_increment
)
879 schicken
|= LPT_PWM_GRANULARITY
;
881 schicken
&= ~LPT_PWM_GRANULARITY
;
882 I915_WRITE(SOUTH_CHICKEN2
, schicken
);
884 schicken
= I915_READ(SOUTH_CHICKEN1
);
885 if (panel
->backlight
.alternate_pwm_increment
)
886 schicken
|= SPT_PWM_GRANULARITY
;
888 schicken
&= ~SPT_PWM_GRANULARITY
;
889 I915_WRITE(SOUTH_CHICKEN1
, schicken
);
892 pch_ctl2
= panel
->backlight
.max
<< 16;
893 I915_WRITE(BLC_PWM_PCH_CTL2
, pch_ctl2
);
896 if (panel
->backlight
.active_low_pwm
)
897 pch_ctl1
|= BLM_PCH_POLARITY
;
899 /* After LPT, override is the default. */
900 if (HAS_PCH_LPT(dev_priv
))
901 pch_ctl1
|= BLM_PCH_OVERRIDE_ENABLE
;
903 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
904 POSTING_READ(BLC_PWM_PCH_CTL1
);
905 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
| BLM_PCH_PWM_ENABLE
);
907 /* This won't stick until the above enable. */
908 intel_panel_actually_set_backlight(conn_state
, panel
->backlight
.level
);
911 static void pch_enable_backlight(const struct intel_crtc_state
*crtc_state
,
912 const struct drm_connector_state
*conn_state
)
914 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
915 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
916 struct intel_panel
*panel
= &connector
->panel
;
917 enum transcoder cpu_transcoder
= crtc_state
->cpu_transcoder
;
918 u32 cpu_ctl2
, pch_ctl1
, pch_ctl2
;
920 cpu_ctl2
= I915_READ(BLC_PWM_CPU_CTL2
);
921 if (cpu_ctl2
& BLM_PWM_ENABLE
) {
922 DRM_DEBUG_KMS("cpu backlight already enabled\n");
923 cpu_ctl2
&= ~BLM_PWM_ENABLE
;
924 I915_WRITE(BLC_PWM_CPU_CTL2
, cpu_ctl2
);
927 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
928 if (pch_ctl1
& BLM_PCH_PWM_ENABLE
) {
929 DRM_DEBUG_KMS("pch backlight already enabled\n");
930 pch_ctl1
&= ~BLM_PCH_PWM_ENABLE
;
931 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
934 if (cpu_transcoder
== TRANSCODER_EDP
)
935 cpu_ctl2
= BLM_TRANSCODER_EDP
;
937 cpu_ctl2
= BLM_PIPE(cpu_transcoder
);
938 I915_WRITE(BLC_PWM_CPU_CTL2
, cpu_ctl2
);
939 POSTING_READ(BLC_PWM_CPU_CTL2
);
940 I915_WRITE(BLC_PWM_CPU_CTL2
, cpu_ctl2
| BLM_PWM_ENABLE
);
942 /* This won't stick until the above enable. */
943 intel_panel_actually_set_backlight(conn_state
, panel
->backlight
.level
);
945 pch_ctl2
= panel
->backlight
.max
<< 16;
946 I915_WRITE(BLC_PWM_PCH_CTL2
, pch_ctl2
);
949 if (panel
->backlight
.active_low_pwm
)
950 pch_ctl1
|= BLM_PCH_POLARITY
;
952 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
);
953 POSTING_READ(BLC_PWM_PCH_CTL1
);
954 I915_WRITE(BLC_PWM_PCH_CTL1
, pch_ctl1
| BLM_PCH_PWM_ENABLE
);
957 static void i9xx_enable_backlight(const struct intel_crtc_state
*crtc_state
,
958 const struct drm_connector_state
*conn_state
)
960 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
961 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
962 struct intel_panel
*panel
= &connector
->panel
;
965 ctl
= I915_READ(BLC_PWM_CTL
);
966 if (ctl
& BACKLIGHT_DUTY_CYCLE_MASK_PNV
) {
967 DRM_DEBUG_KMS("backlight already enabled\n");
968 I915_WRITE(BLC_PWM_CTL
, 0);
971 freq
= panel
->backlight
.max
;
972 if (panel
->backlight
.combination_mode
)
976 if (panel
->backlight
.combination_mode
)
977 ctl
|= BLM_LEGACY_MODE
;
978 if (IS_PINEVIEW(dev_priv
) && panel
->backlight
.active_low_pwm
)
979 ctl
|= BLM_POLARITY_PNV
;
981 I915_WRITE(BLC_PWM_CTL
, ctl
);
982 POSTING_READ(BLC_PWM_CTL
);
984 /* XXX: combine this into above write? */
985 intel_panel_actually_set_backlight(conn_state
, panel
->backlight
.level
);
988 * Needed to enable backlight on some 855gm models. BLC_HIST_CTL is
989 * 855gm only, but checking for gen2 is safe, as 855gm is the only gen2
990 * that has backlight.
992 if (IS_GEN2(dev_priv
))
993 I915_WRITE(BLC_HIST_CTL
, BLM_HISTOGRAM_ENABLE
);
996 static void i965_enable_backlight(const struct intel_crtc_state
*crtc_state
,
997 const struct drm_connector_state
*conn_state
)
999 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
1000 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1001 struct intel_panel
*panel
= &connector
->panel
;
1002 enum pipe pipe
= to_intel_crtc(conn_state
->crtc
)->pipe
;
1003 u32 ctl
, ctl2
, freq
;
1005 ctl2
= I915_READ(BLC_PWM_CTL2
);
1006 if (ctl2
& BLM_PWM_ENABLE
) {
1007 DRM_DEBUG_KMS("backlight already enabled\n");
1008 ctl2
&= ~BLM_PWM_ENABLE
;
1009 I915_WRITE(BLC_PWM_CTL2
, ctl2
);
1012 freq
= panel
->backlight
.max
;
1013 if (panel
->backlight
.combination_mode
)
1017 I915_WRITE(BLC_PWM_CTL
, ctl
);
1019 ctl2
= BLM_PIPE(pipe
);
1020 if (panel
->backlight
.combination_mode
)
1021 ctl2
|= BLM_COMBINATION_MODE
;
1022 if (panel
->backlight
.active_low_pwm
)
1023 ctl2
|= BLM_POLARITY_I965
;
1024 I915_WRITE(BLC_PWM_CTL2
, ctl2
);
1025 POSTING_READ(BLC_PWM_CTL2
);
1026 I915_WRITE(BLC_PWM_CTL2
, ctl2
| BLM_PWM_ENABLE
);
1028 intel_panel_actually_set_backlight(conn_state
, panel
->backlight
.level
);
1031 static void vlv_enable_backlight(const struct intel_crtc_state
*crtc_state
,
1032 const struct drm_connector_state
*conn_state
)
1034 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
1035 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1036 struct intel_panel
*panel
= &connector
->panel
;
1037 enum pipe pipe
= to_intel_crtc(crtc_state
->base
.crtc
)->pipe
;
1040 ctl2
= I915_READ(VLV_BLC_PWM_CTL2(pipe
));
1041 if (ctl2
& BLM_PWM_ENABLE
) {
1042 DRM_DEBUG_KMS("backlight already enabled\n");
1043 ctl2
&= ~BLM_PWM_ENABLE
;
1044 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), ctl2
);
1047 ctl
= panel
->backlight
.max
<< 16;
1048 I915_WRITE(VLV_BLC_PWM_CTL(pipe
), ctl
);
1050 /* XXX: combine this into above write? */
1051 intel_panel_actually_set_backlight(conn_state
, panel
->backlight
.level
);
1054 if (panel
->backlight
.active_low_pwm
)
1055 ctl2
|= BLM_POLARITY_I965
;
1056 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), ctl2
);
1057 POSTING_READ(VLV_BLC_PWM_CTL2(pipe
));
1058 I915_WRITE(VLV_BLC_PWM_CTL2(pipe
), ctl2
| BLM_PWM_ENABLE
);
1061 static void bxt_enable_backlight(const struct intel_crtc_state
*crtc_state
,
1062 const struct drm_connector_state
*conn_state
)
1064 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
1065 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1066 struct intel_panel
*panel
= &connector
->panel
;
1067 enum pipe pipe
= to_intel_crtc(crtc_state
->base
.crtc
)->pipe
;
1070 /* Controller 1 uses the utility pin. */
1071 if (panel
->backlight
.controller
== 1) {
1072 val
= I915_READ(UTIL_PIN_CTL
);
1073 if (val
& UTIL_PIN_ENABLE
) {
1074 DRM_DEBUG_KMS("util pin already enabled\n");
1075 val
&= ~UTIL_PIN_ENABLE
;
1076 I915_WRITE(UTIL_PIN_CTL
, val
);
1080 if (panel
->backlight
.util_pin_active_low
)
1081 val
|= UTIL_PIN_POLARITY
;
1082 I915_WRITE(UTIL_PIN_CTL
, val
| UTIL_PIN_PIPE(pipe
) |
1083 UTIL_PIN_MODE_PWM
| UTIL_PIN_ENABLE
);
1086 pwm_ctl
= I915_READ(BXT_BLC_PWM_CTL(panel
->backlight
.controller
));
1087 if (pwm_ctl
& BXT_BLC_PWM_ENABLE
) {
1088 DRM_DEBUG_KMS("backlight already enabled\n");
1089 pwm_ctl
&= ~BXT_BLC_PWM_ENABLE
;
1090 I915_WRITE(BXT_BLC_PWM_CTL(panel
->backlight
.controller
),
1094 I915_WRITE(BXT_BLC_PWM_FREQ(panel
->backlight
.controller
),
1095 panel
->backlight
.max
);
1097 intel_panel_actually_set_backlight(conn_state
, panel
->backlight
.level
);
1100 if (panel
->backlight
.active_low_pwm
)
1101 pwm_ctl
|= BXT_BLC_PWM_POLARITY
;
1103 I915_WRITE(BXT_BLC_PWM_CTL(panel
->backlight
.controller
), pwm_ctl
);
1104 POSTING_READ(BXT_BLC_PWM_CTL(panel
->backlight
.controller
));
1105 I915_WRITE(BXT_BLC_PWM_CTL(panel
->backlight
.controller
),
1106 pwm_ctl
| BXT_BLC_PWM_ENABLE
);
1109 static void cnp_enable_backlight(const struct intel_crtc_state
*crtc_state
,
1110 const struct drm_connector_state
*conn_state
)
1112 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
1113 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1114 struct intel_panel
*panel
= &connector
->panel
;
1117 pwm_ctl
= I915_READ(BXT_BLC_PWM_CTL(panel
->backlight
.controller
));
1118 if (pwm_ctl
& BXT_BLC_PWM_ENABLE
) {
1119 DRM_DEBUG_KMS("backlight already enabled\n");
1120 pwm_ctl
&= ~BXT_BLC_PWM_ENABLE
;
1121 I915_WRITE(BXT_BLC_PWM_CTL(panel
->backlight
.controller
),
1125 I915_WRITE(BXT_BLC_PWM_FREQ(panel
->backlight
.controller
),
1126 panel
->backlight
.max
);
1128 intel_panel_actually_set_backlight(conn_state
, panel
->backlight
.level
);
1131 if (panel
->backlight
.active_low_pwm
)
1132 pwm_ctl
|= BXT_BLC_PWM_POLARITY
;
1134 I915_WRITE(BXT_BLC_PWM_CTL(panel
->backlight
.controller
), pwm_ctl
);
1135 POSTING_READ(BXT_BLC_PWM_CTL(panel
->backlight
.controller
));
1136 I915_WRITE(BXT_BLC_PWM_CTL(panel
->backlight
.controller
),
1137 pwm_ctl
| BXT_BLC_PWM_ENABLE
);
1140 static void pwm_enable_backlight(const struct intel_crtc_state
*crtc_state
,
1141 const struct drm_connector_state
*conn_state
)
1143 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
1144 struct intel_panel
*panel
= &connector
->panel
;
1146 pwm_enable(panel
->backlight
.pwm
);
1147 intel_panel_actually_set_backlight(conn_state
, panel
->backlight
.level
);
1150 void intel_panel_enable_backlight(const struct intel_crtc_state
*crtc_state
,
1151 const struct drm_connector_state
*conn_state
)
1153 struct intel_connector
*connector
= to_intel_connector(conn_state
->connector
);
1154 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1155 struct intel_panel
*panel
= &connector
->panel
;
1156 enum pipe pipe
= to_intel_crtc(crtc_state
->base
.crtc
)->pipe
;
1158 if (!panel
->backlight
.present
)
1161 DRM_DEBUG_KMS("pipe %c\n", pipe_name(pipe
));
1163 mutex_lock(&dev_priv
->backlight_lock
);
1165 WARN_ON(panel
->backlight
.max
== 0);
1167 if (panel
->backlight
.level
<= panel
->backlight
.min
) {
1168 panel
->backlight
.level
= panel
->backlight
.max
;
1169 if (panel
->backlight
.device
)
1170 panel
->backlight
.device
->props
.brightness
=
1171 scale_hw_to_user(connector
,
1172 panel
->backlight
.level
,
1173 panel
->backlight
.device
->props
.max_brightness
);
1176 panel
->backlight
.enable(crtc_state
, conn_state
);
1177 panel
->backlight
.enabled
= true;
1178 if (panel
->backlight
.device
)
1179 panel
->backlight
.device
->props
.power
= FB_BLANK_UNBLANK
;
1181 mutex_unlock(&dev_priv
->backlight_lock
);
1184 #if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)
1185 static int intel_backlight_device_update_status(struct backlight_device
*bd
)
1187 struct intel_connector
*connector
= bl_get_data(bd
);
1188 struct intel_panel
*panel
= &connector
->panel
;
1189 struct drm_device
*dev
= connector
->base
.dev
;
1191 drm_modeset_lock(&dev
->mode_config
.connection_mutex
, NULL
);
1192 DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n",
1193 bd
->props
.brightness
, bd
->props
.max_brightness
);
1194 intel_panel_set_backlight(connector
->base
.state
, bd
->props
.brightness
,
1195 bd
->props
.max_brightness
);
1198 * Allow flipping bl_power as a sub-state of enabled. Sadly the
1199 * backlight class device does not make it easy to to differentiate
1200 * between callbacks for brightness and bl_power, so our backlight_power
1201 * callback needs to take this into account.
1203 if (panel
->backlight
.enabled
) {
1204 if (panel
->backlight
.power
) {
1205 bool enable
= bd
->props
.power
== FB_BLANK_UNBLANK
&&
1206 bd
->props
.brightness
!= 0;
1207 panel
->backlight
.power(connector
, enable
);
1210 bd
->props
.power
= FB_BLANK_POWERDOWN
;
1213 drm_modeset_unlock(&dev
->mode_config
.connection_mutex
);
1217 static int intel_backlight_device_get_brightness(struct backlight_device
*bd
)
1219 struct intel_connector
*connector
= bl_get_data(bd
);
1220 struct drm_device
*dev
= connector
->base
.dev
;
1221 struct drm_i915_private
*dev_priv
= to_i915(dev
);
1225 intel_runtime_pm_get(dev_priv
);
1226 drm_modeset_lock(&dev
->mode_config
.connection_mutex
, NULL
);
1228 hw_level
= intel_panel_get_backlight(connector
);
1229 ret
= scale_hw_to_user(connector
, hw_level
, bd
->props
.max_brightness
);
1231 drm_modeset_unlock(&dev
->mode_config
.connection_mutex
);
1232 intel_runtime_pm_put(dev_priv
);
1237 static const struct backlight_ops intel_backlight_device_ops
= {
1238 .update_status
= intel_backlight_device_update_status
,
1239 .get_brightness
= intel_backlight_device_get_brightness
,
1242 int intel_backlight_device_register(struct intel_connector
*connector
)
1244 struct intel_panel
*panel
= &connector
->panel
;
1245 struct backlight_properties props
;
1247 if (WARN_ON(panel
->backlight
.device
))
1250 if (!panel
->backlight
.present
)
1253 WARN_ON(panel
->backlight
.max
== 0);
1255 memset(&props
, 0, sizeof(props
));
1256 props
.type
= BACKLIGHT_RAW
;
1259 * Note: Everything should work even if the backlight device max
1260 * presented to the userspace is arbitrarily chosen.
1262 props
.max_brightness
= panel
->backlight
.max
;
1263 props
.brightness
= scale_hw_to_user(connector
,
1264 panel
->backlight
.level
,
1265 props
.max_brightness
);
1267 if (panel
->backlight
.enabled
)
1268 props
.power
= FB_BLANK_UNBLANK
;
1270 props
.power
= FB_BLANK_POWERDOWN
;
1273 * Note: using the same name independent of the connector prevents
1274 * registration of multiple backlight devices in the driver.
1276 panel
->backlight
.device
=
1277 backlight_device_register("intel_backlight",
1278 connector
->base
.kdev
,
1280 &intel_backlight_device_ops
, &props
);
1282 if (IS_ERR(panel
->backlight
.device
)) {
1283 DRM_ERROR("Failed to register backlight: %ld\n",
1284 PTR_ERR(panel
->backlight
.device
));
1285 panel
->backlight
.device
= NULL
;
1289 DRM_DEBUG_KMS("Connector %s backlight sysfs interface registered\n",
1290 connector
->base
.name
);
1295 void intel_backlight_device_unregister(struct intel_connector
*connector
)
1297 struct intel_panel
*panel
= &connector
->panel
;
1299 if (panel
->backlight
.device
) {
1300 backlight_device_unregister(panel
->backlight
.device
);
1301 panel
->backlight
.device
= NULL
;
1304 #endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
1307 * CNP: PWM clock frequency is 19.2 MHz or 24 MHz.
1310 static u32
cnp_hz_to_pwm(struct intel_connector
*connector
, u32 pwm_freq_hz
)
1312 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1314 return DIV_ROUND_CLOSEST(KHz(dev_priv
->rawclk_freq
), pwm_freq_hz
);
1318 * BXT: PWM clock frequency = 19.2 MHz.
1320 static u32
bxt_hz_to_pwm(struct intel_connector
*connector
, u32 pwm_freq_hz
)
1322 return DIV_ROUND_CLOSEST(KHz(19200), pwm_freq_hz
);
1326 * SPT: This value represents the period of the PWM stream in clock periods
1327 * multiplied by 16 (default increment) or 128 (alternate increment selected in
1328 * SCHICKEN_1 bit 0). PWM clock is 24 MHz.
1330 static u32
spt_hz_to_pwm(struct intel_connector
*connector
, u32 pwm_freq_hz
)
1332 struct intel_panel
*panel
= &connector
->panel
;
1335 if (panel
->backlight
.alternate_pwm_increment
)
1340 return DIV_ROUND_CLOSEST(MHz(24), pwm_freq_hz
* mul
);
1344 * LPT: This value represents the period of the PWM stream in clock periods
1345 * multiplied by 128 (default increment) or 16 (alternate increment, selected in
1346 * LPT SOUTH_CHICKEN2 register bit 5).
1348 static u32
lpt_hz_to_pwm(struct intel_connector
*connector
, u32 pwm_freq_hz
)
1350 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1351 struct intel_panel
*panel
= &connector
->panel
;
1354 if (panel
->backlight
.alternate_pwm_increment
)
1359 if (HAS_PCH_LPT_H(dev_priv
))
1360 clock
= MHz(135); /* LPT:H */
1362 clock
= MHz(24); /* LPT:LP */
1364 return DIV_ROUND_CLOSEST(clock
, pwm_freq_hz
* mul
);
1368 * ILK/SNB/IVB: This value represents the period of the PWM stream in PCH
1369 * display raw clocks multiplied by 128.
1371 static u32
pch_hz_to_pwm(struct intel_connector
*connector
, u32 pwm_freq_hz
)
1373 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1375 return DIV_ROUND_CLOSEST(KHz(dev_priv
->rawclk_freq
), pwm_freq_hz
* 128);
1379 * Gen2: This field determines the number of time base events (display core
1380 * clock frequency/32) in total for a complete cycle of modulated backlight
1383 * Gen3: A time base event equals the display core clock ([DevPNV] HRAW clock)
1386 static u32
i9xx_hz_to_pwm(struct intel_connector
*connector
, u32 pwm_freq_hz
)
1388 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1391 if (IS_PINEVIEW(dev_priv
))
1392 clock
= KHz(dev_priv
->rawclk_freq
);
1394 clock
= KHz(dev_priv
->cdclk
.hw
.cdclk
);
1396 return DIV_ROUND_CLOSEST(clock
, pwm_freq_hz
* 32);
1400 * Gen4: This value represents the period of the PWM stream in display core
1401 * clocks ([DevCTG] HRAW clocks) multiplied by 128.
1404 static u32
i965_hz_to_pwm(struct intel_connector
*connector
, u32 pwm_freq_hz
)
1406 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1409 if (IS_G4X(dev_priv
))
1410 clock
= KHz(dev_priv
->rawclk_freq
);
1412 clock
= KHz(dev_priv
->cdclk
.hw
.cdclk
);
1414 return DIV_ROUND_CLOSEST(clock
, pwm_freq_hz
* 128);
1418 * VLV: This value represents the period of the PWM stream in display core
1419 * clocks ([DevCTG] 200MHz HRAW clocks) multiplied by 128 or 25MHz S0IX clocks
1420 * multiplied by 16. CHV uses a 19.2MHz S0IX clock.
1422 static u32
vlv_hz_to_pwm(struct intel_connector
*connector
, u32 pwm_freq_hz
)
1424 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1427 if ((I915_READ(CBR1_VLV
) & CBR_PWM_CLOCK_MUX_SELECT
) == 0) {
1428 if (IS_CHERRYVIEW(dev_priv
))
1434 clock
= KHz(dev_priv
->rawclk_freq
);
1438 return DIV_ROUND_CLOSEST(clock
, pwm_freq_hz
* mul
);
1441 static u32
get_backlight_max_vbt(struct intel_connector
*connector
)
1443 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1444 struct intel_panel
*panel
= &connector
->panel
;
1445 u16 pwm_freq_hz
= dev_priv
->vbt
.backlight
.pwm_freq_hz
;
1448 if (!panel
->backlight
.hz_to_pwm
) {
1449 DRM_DEBUG_KMS("backlight frequency conversion not supported\n");
1454 DRM_DEBUG_KMS("VBT defined backlight frequency %u Hz\n",
1458 DRM_DEBUG_KMS("default backlight frequency %u Hz\n",
1462 pwm
= panel
->backlight
.hz_to_pwm(connector
, pwm_freq_hz
);
1464 DRM_DEBUG_KMS("backlight frequency conversion failed\n");
1472 * Note: The setup hooks can't assume pipe is set!
1474 static u32
get_backlight_min_vbt(struct intel_connector
*connector
)
1476 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1477 struct intel_panel
*panel
= &connector
->panel
;
1480 WARN_ON(panel
->backlight
.max
== 0);
1483 * XXX: If the vbt value is 255, it makes min equal to max, which leads
1484 * to problems. There are such machines out there. Either our
1485 * interpretation is wrong or the vbt has bogus data. Or both. Safeguard
1486 * against this by letting the minimum be at most (arbitrarily chosen)
1489 min
= clamp_t(int, dev_priv
->vbt
.backlight
.min_brightness
, 0, 64);
1490 if (min
!= dev_priv
->vbt
.backlight
.min_brightness
) {
1491 DRM_DEBUG_KMS("clamping VBT min backlight %d/255 to %d/255\n",
1492 dev_priv
->vbt
.backlight
.min_brightness
, min
);
1495 /* vbt value is a coefficient in range [0..255] */
1496 return scale(min
, 0, 255, 0, panel
->backlight
.max
);
1499 static int lpt_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1501 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1502 struct intel_panel
*panel
= &connector
->panel
;
1503 u32 pch_ctl1
, pch_ctl2
, val
;
1506 if (HAS_PCH_LPT(dev_priv
))
1507 alt
= I915_READ(SOUTH_CHICKEN2
) & LPT_PWM_GRANULARITY
;
1509 alt
= I915_READ(SOUTH_CHICKEN1
) & SPT_PWM_GRANULARITY
;
1510 panel
->backlight
.alternate_pwm_increment
= alt
;
1512 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
1513 panel
->backlight
.active_low_pwm
= pch_ctl1
& BLM_PCH_POLARITY
;
1515 pch_ctl2
= I915_READ(BLC_PWM_PCH_CTL2
);
1516 panel
->backlight
.max
= pch_ctl2
>> 16;
1518 if (!panel
->backlight
.max
)
1519 panel
->backlight
.max
= get_backlight_max_vbt(connector
);
1521 if (!panel
->backlight
.max
)
1524 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1526 val
= lpt_get_backlight(connector
);
1527 val
= intel_panel_compute_brightness(connector
, val
);
1528 panel
->backlight
.level
= clamp(val
, panel
->backlight
.min
,
1529 panel
->backlight
.max
);
1531 panel
->backlight
.enabled
= pch_ctl1
& BLM_PCH_PWM_ENABLE
;
1536 static int pch_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1538 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1539 struct intel_panel
*panel
= &connector
->panel
;
1540 u32 cpu_ctl2
, pch_ctl1
, pch_ctl2
, val
;
1542 pch_ctl1
= I915_READ(BLC_PWM_PCH_CTL1
);
1543 panel
->backlight
.active_low_pwm
= pch_ctl1
& BLM_PCH_POLARITY
;
1545 pch_ctl2
= I915_READ(BLC_PWM_PCH_CTL2
);
1546 panel
->backlight
.max
= pch_ctl2
>> 16;
1548 if (!panel
->backlight
.max
)
1549 panel
->backlight
.max
= get_backlight_max_vbt(connector
);
1551 if (!panel
->backlight
.max
)
1554 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1556 val
= pch_get_backlight(connector
);
1557 val
= intel_panel_compute_brightness(connector
, val
);
1558 panel
->backlight
.level
= clamp(val
, panel
->backlight
.min
,
1559 panel
->backlight
.max
);
1561 cpu_ctl2
= I915_READ(BLC_PWM_CPU_CTL2
);
1562 panel
->backlight
.enabled
= (cpu_ctl2
& BLM_PWM_ENABLE
) &&
1563 (pch_ctl1
& BLM_PCH_PWM_ENABLE
);
1568 static int i9xx_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1570 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1571 struct intel_panel
*panel
= &connector
->panel
;
1574 ctl
= I915_READ(BLC_PWM_CTL
);
1576 if (IS_GEN2(dev_priv
) || IS_I915GM(dev_priv
) || IS_I945GM(dev_priv
))
1577 panel
->backlight
.combination_mode
= ctl
& BLM_LEGACY_MODE
;
1579 if (IS_PINEVIEW(dev_priv
))
1580 panel
->backlight
.active_low_pwm
= ctl
& BLM_POLARITY_PNV
;
1582 panel
->backlight
.max
= ctl
>> 17;
1584 if (!panel
->backlight
.max
) {
1585 panel
->backlight
.max
= get_backlight_max_vbt(connector
);
1586 panel
->backlight
.max
>>= 1;
1589 if (!panel
->backlight
.max
)
1592 if (panel
->backlight
.combination_mode
)
1593 panel
->backlight
.max
*= 0xff;
1595 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1597 val
= i9xx_get_backlight(connector
);
1598 val
= intel_panel_compute_brightness(connector
, val
);
1599 panel
->backlight
.level
= clamp(val
, panel
->backlight
.min
,
1600 panel
->backlight
.max
);
1602 panel
->backlight
.enabled
= val
!= 0;
1607 static int i965_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1609 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1610 struct intel_panel
*panel
= &connector
->panel
;
1613 ctl2
= I915_READ(BLC_PWM_CTL2
);
1614 panel
->backlight
.combination_mode
= ctl2
& BLM_COMBINATION_MODE
;
1615 panel
->backlight
.active_low_pwm
= ctl2
& BLM_POLARITY_I965
;
1617 ctl
= I915_READ(BLC_PWM_CTL
);
1618 panel
->backlight
.max
= ctl
>> 16;
1620 if (!panel
->backlight
.max
)
1621 panel
->backlight
.max
= get_backlight_max_vbt(connector
);
1623 if (!panel
->backlight
.max
)
1626 if (panel
->backlight
.combination_mode
)
1627 panel
->backlight
.max
*= 0xff;
1629 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1631 val
= i9xx_get_backlight(connector
);
1632 val
= intel_panel_compute_brightness(connector
, val
);
1633 panel
->backlight
.level
= clamp(val
, panel
->backlight
.min
,
1634 panel
->backlight
.max
);
1636 panel
->backlight
.enabled
= ctl2
& BLM_PWM_ENABLE
;
1641 static int vlv_setup_backlight(struct intel_connector
*connector
, enum pipe pipe
)
1643 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1644 struct intel_panel
*panel
= &connector
->panel
;
1647 if (WARN_ON(pipe
!= PIPE_A
&& pipe
!= PIPE_B
))
1650 ctl2
= I915_READ(VLV_BLC_PWM_CTL2(pipe
));
1651 panel
->backlight
.active_low_pwm
= ctl2
& BLM_POLARITY_I965
;
1653 ctl
= I915_READ(VLV_BLC_PWM_CTL(pipe
));
1654 panel
->backlight
.max
= ctl
>> 16;
1656 if (!panel
->backlight
.max
)
1657 panel
->backlight
.max
= get_backlight_max_vbt(connector
);
1659 if (!panel
->backlight
.max
)
1662 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1664 val
= _vlv_get_backlight(dev_priv
, pipe
);
1665 val
= intel_panel_compute_brightness(connector
, val
);
1666 panel
->backlight
.level
= clamp(val
, panel
->backlight
.min
,
1667 panel
->backlight
.max
);
1669 panel
->backlight
.enabled
= ctl2
& BLM_PWM_ENABLE
;
1675 bxt_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1677 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1678 struct intel_panel
*panel
= &connector
->panel
;
1681 panel
->backlight
.controller
= dev_priv
->vbt
.backlight
.controller
;
1683 pwm_ctl
= I915_READ(BXT_BLC_PWM_CTL(panel
->backlight
.controller
));
1685 /* Controller 1 uses the utility pin. */
1686 if (panel
->backlight
.controller
== 1) {
1687 val
= I915_READ(UTIL_PIN_CTL
);
1688 panel
->backlight
.util_pin_active_low
=
1689 val
& UTIL_PIN_POLARITY
;
1692 panel
->backlight
.active_low_pwm
= pwm_ctl
& BXT_BLC_PWM_POLARITY
;
1693 panel
->backlight
.max
=
1694 I915_READ(BXT_BLC_PWM_FREQ(panel
->backlight
.controller
));
1696 if (!panel
->backlight
.max
)
1697 panel
->backlight
.max
= get_backlight_max_vbt(connector
);
1699 if (!panel
->backlight
.max
)
1702 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1704 val
= bxt_get_backlight(connector
);
1705 val
= intel_panel_compute_brightness(connector
, val
);
1706 panel
->backlight
.level
= clamp(val
, panel
->backlight
.min
,
1707 panel
->backlight
.max
);
1709 panel
->backlight
.enabled
= pwm_ctl
& BXT_BLC_PWM_ENABLE
;
1715 cnp_setup_backlight(struct intel_connector
*connector
, enum pipe unused
)
1717 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1718 struct intel_panel
*panel
= &connector
->panel
;
1722 * CNP has the BXT implementation of backlight, but with only
1723 * one controller. Future platforms could have multiple controllers
1724 * so let's make this extensible and prepared for the future.
1726 panel
->backlight
.controller
= 0;
1728 pwm_ctl
= I915_READ(BXT_BLC_PWM_CTL(panel
->backlight
.controller
));
1730 panel
->backlight
.active_low_pwm
= pwm_ctl
& BXT_BLC_PWM_POLARITY
;
1731 panel
->backlight
.max
=
1732 I915_READ(BXT_BLC_PWM_FREQ(panel
->backlight
.controller
));
1734 if (!panel
->backlight
.max
)
1735 panel
->backlight
.max
= get_backlight_max_vbt(connector
);
1737 if (!panel
->backlight
.max
)
1740 panel
->backlight
.min
= get_backlight_min_vbt(connector
);
1742 val
= bxt_get_backlight(connector
);
1743 val
= intel_panel_compute_brightness(connector
, val
);
1744 panel
->backlight
.level
= clamp(val
, panel
->backlight
.min
,
1745 panel
->backlight
.max
);
1747 panel
->backlight
.enabled
= pwm_ctl
& BXT_BLC_PWM_ENABLE
;
1752 static int pwm_setup_backlight(struct intel_connector
*connector
,
1755 struct drm_device
*dev
= connector
->base
.dev
;
1756 struct intel_panel
*panel
= &connector
->panel
;
1759 /* Get the PWM chip for backlight control */
1760 panel
->backlight
.pwm
= pwm_get(dev
->dev
, "pwm_backlight");
1761 if (IS_ERR(panel
->backlight
.pwm
)) {
1762 DRM_ERROR("Failed to own the pwm chip\n");
1763 panel
->backlight
.pwm
= NULL
;
1768 * FIXME: pwm_apply_args() should be removed when switching to
1769 * the atomic PWM API.
1771 pwm_apply_args(panel
->backlight
.pwm
);
1773 retval
= pwm_config(panel
->backlight
.pwm
, CRC_PMIC_PWM_PERIOD_NS
,
1774 CRC_PMIC_PWM_PERIOD_NS
);
1776 DRM_ERROR("Failed to configure the pwm chip\n");
1777 pwm_put(panel
->backlight
.pwm
);
1778 panel
->backlight
.pwm
= NULL
;
1782 panel
->backlight
.min
= 0; /* 0% */
1783 panel
->backlight
.max
= 100; /* 100% */
1784 panel
->backlight
.level
= DIV_ROUND_UP(
1785 pwm_get_duty_cycle(panel
->backlight
.pwm
) * 100,
1786 CRC_PMIC_PWM_PERIOD_NS
);
1787 panel
->backlight
.enabled
= panel
->backlight
.level
!= 0;
1792 int intel_panel_setup_backlight(struct drm_connector
*connector
, enum pipe pipe
)
1794 struct drm_i915_private
*dev_priv
= to_i915(connector
->dev
);
1795 struct intel_connector
*intel_connector
= to_intel_connector(connector
);
1796 struct intel_panel
*panel
= &intel_connector
->panel
;
1799 if (!dev_priv
->vbt
.backlight
.present
) {
1800 if (dev_priv
->quirks
& QUIRK_BACKLIGHT_PRESENT
) {
1801 DRM_DEBUG_KMS("no backlight present per VBT, but present per quirk\n");
1803 DRM_DEBUG_KMS("no backlight present per VBT\n");
1808 /* ensure intel_panel has been initialized first */
1809 if (WARN_ON(!panel
->backlight
.setup
))
1812 /* set level and max in panel struct */
1813 mutex_lock(&dev_priv
->backlight_lock
);
1814 ret
= panel
->backlight
.setup(intel_connector
, pipe
);
1815 mutex_unlock(&dev_priv
->backlight_lock
);
1818 DRM_DEBUG_KMS("failed to setup backlight for connector %s\n",
1823 panel
->backlight
.present
= true;
1825 DRM_DEBUG_KMS("Connector %s backlight initialized, %s, brightness %u/%u\n",
1827 enableddisabled(panel
->backlight
.enabled
),
1828 panel
->backlight
.level
, panel
->backlight
.max
);
1833 void intel_panel_destroy_backlight(struct drm_connector
*connector
)
1835 struct intel_connector
*intel_connector
= to_intel_connector(connector
);
1836 struct intel_panel
*panel
= &intel_connector
->panel
;
1838 /* dispose of the pwm */
1839 if (panel
->backlight
.pwm
)
1840 pwm_put(panel
->backlight
.pwm
);
1842 panel
->backlight
.present
= false;
1845 /* Set up chip specific backlight functions */
1847 intel_panel_init_backlight_funcs(struct intel_panel
*panel
)
1849 struct intel_connector
*connector
=
1850 container_of(panel
, struct intel_connector
, panel
);
1851 struct drm_i915_private
*dev_priv
= to_i915(connector
->base
.dev
);
1853 if (connector
->base
.connector_type
== DRM_MODE_CONNECTOR_eDP
&&
1854 intel_dp_aux_init_backlight_funcs(connector
) == 0)
1857 if (connector
->base
.connector_type
== DRM_MODE_CONNECTOR_DSI
&&
1858 intel_dsi_dcs_init_backlight_funcs(connector
) == 0)
1861 if (IS_GEN9_LP(dev_priv
)) {
1862 panel
->backlight
.setup
= bxt_setup_backlight
;
1863 panel
->backlight
.enable
= bxt_enable_backlight
;
1864 panel
->backlight
.disable
= bxt_disable_backlight
;
1865 panel
->backlight
.set
= bxt_set_backlight
;
1866 panel
->backlight
.get
= bxt_get_backlight
;
1867 panel
->backlight
.hz_to_pwm
= bxt_hz_to_pwm
;
1868 } else if (HAS_PCH_CNP(dev_priv
)) {
1869 panel
->backlight
.setup
= cnp_setup_backlight
;
1870 panel
->backlight
.enable
= cnp_enable_backlight
;
1871 panel
->backlight
.disable
= cnp_disable_backlight
;
1872 panel
->backlight
.set
= bxt_set_backlight
;
1873 panel
->backlight
.get
= bxt_get_backlight
;
1874 panel
->backlight
.hz_to_pwm
= cnp_hz_to_pwm
;
1875 } else if (HAS_PCH_LPT(dev_priv
) || HAS_PCH_SPT(dev_priv
) ||
1876 HAS_PCH_KBP(dev_priv
)) {
1877 panel
->backlight
.setup
= lpt_setup_backlight
;
1878 panel
->backlight
.enable
= lpt_enable_backlight
;
1879 panel
->backlight
.disable
= lpt_disable_backlight
;
1880 panel
->backlight
.set
= lpt_set_backlight
;
1881 panel
->backlight
.get
= lpt_get_backlight
;
1882 if (HAS_PCH_LPT(dev_priv
))
1883 panel
->backlight
.hz_to_pwm
= lpt_hz_to_pwm
;
1885 panel
->backlight
.hz_to_pwm
= spt_hz_to_pwm
;
1886 } else if (HAS_PCH_SPLIT(dev_priv
)) {
1887 panel
->backlight
.setup
= pch_setup_backlight
;
1888 panel
->backlight
.enable
= pch_enable_backlight
;
1889 panel
->backlight
.disable
= pch_disable_backlight
;
1890 panel
->backlight
.set
= pch_set_backlight
;
1891 panel
->backlight
.get
= pch_get_backlight
;
1892 panel
->backlight
.hz_to_pwm
= pch_hz_to_pwm
;
1893 } else if (IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
)) {
1894 if (connector
->base
.connector_type
== DRM_MODE_CONNECTOR_DSI
) {
1895 panel
->backlight
.setup
= pwm_setup_backlight
;
1896 panel
->backlight
.enable
= pwm_enable_backlight
;
1897 panel
->backlight
.disable
= pwm_disable_backlight
;
1898 panel
->backlight
.set
= pwm_set_backlight
;
1899 panel
->backlight
.get
= pwm_get_backlight
;
1901 panel
->backlight
.setup
= vlv_setup_backlight
;
1902 panel
->backlight
.enable
= vlv_enable_backlight
;
1903 panel
->backlight
.disable
= vlv_disable_backlight
;
1904 panel
->backlight
.set
= vlv_set_backlight
;
1905 panel
->backlight
.get
= vlv_get_backlight
;
1906 panel
->backlight
.hz_to_pwm
= vlv_hz_to_pwm
;
1908 } else if (IS_GEN4(dev_priv
)) {
1909 panel
->backlight
.setup
= i965_setup_backlight
;
1910 panel
->backlight
.enable
= i965_enable_backlight
;
1911 panel
->backlight
.disable
= i965_disable_backlight
;
1912 panel
->backlight
.set
= i9xx_set_backlight
;
1913 panel
->backlight
.get
= i9xx_get_backlight
;
1914 panel
->backlight
.hz_to_pwm
= i965_hz_to_pwm
;
1916 panel
->backlight
.setup
= i9xx_setup_backlight
;
1917 panel
->backlight
.enable
= i9xx_enable_backlight
;
1918 panel
->backlight
.disable
= i9xx_disable_backlight
;
1919 panel
->backlight
.set
= i9xx_set_backlight
;
1920 panel
->backlight
.get
= i9xx_get_backlight
;
1921 panel
->backlight
.hz_to_pwm
= i9xx_hz_to_pwm
;
1925 int intel_panel_init(struct intel_panel
*panel
,
1926 struct drm_display_mode
*fixed_mode
,
1927 struct drm_display_mode
*downclock_mode
)
1929 intel_panel_init_backlight_funcs(panel
);
1931 panel
->fixed_mode
= fixed_mode
;
1932 panel
->downclock_mode
= downclock_mode
;
1937 void intel_panel_fini(struct intel_panel
*panel
)
1939 struct intel_connector
*intel_connector
=
1940 container_of(panel
, struct intel_connector
, panel
);
1942 if (panel
->fixed_mode
)
1943 drm_mode_destroy(intel_connector
->base
.dev
, panel
->fixed_mode
);
1945 if (panel
->downclock_mode
)
1946 drm_mode_destroy(intel_connector
->base
.dev
,
1947 panel
->downclock_mode
);