/usr/src/sys/dev/pci/drm/i915/display/intel

Bug Summary

File:	dev/pci/drm/i915/display/intel_panel.c
Warning:	line 484, column 15 Division by zero
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name intel_panel.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -D CONFIG_DRM_AMD_DC_DCN3_0 -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /usr/obj/sys/arch/amd64/compile/GENERIC.MP/scan-build/2022-01-12-131800-47421-1 -x c /usr/src/sys/dev/pci/drm/i915/display/intel_panel.c
1/*
* Copyright © 2006-2010 Intel Corporation
* Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Authors:
*	Eric Anholt <eric@anholt.net>
*      Dave Airlie <airlied@linux.ie>
*      Jesse Barnes <jesse.barnes@intel.com>
*      Chris Wilson <chris@chris-wilson.co.uk>
*/

31#define pr_fmt(fmt)KBUILD_MODNAME ": " fmt KBUILD_MODNAME ": " fmt

33#include <linux/kernel.h>
34#include <linux/moduleparam.h>
35#include <linux/pwm.h>

37#include "intel_connector.h"
38#include "intel_display_types.h"
39#include "intel_dp_aux_backlight.h"
40#include "intel_dsi_dcs_backlight.h"
41#include "intel_panel.h"

43void
44intel_fixed_panel_mode(const struct drm_display_mode *fixed_mode,
       struct drm_display_mode *adjusted_mode)
46{
drm_mode_copy(adjusted_mode, fixed_mode);

drm_mode_set_crtcinfo(adjusted_mode, 0);
50}

52static bool_Bool is_downclock_mode(const struct drm_display_mode *downclock_mode,
	      const struct drm_display_mode *fixed_mode)
54{
return drm_mode_match(downclock_mode, fixed_mode,
	      DRM_MODE_MATCH_TIMINGS(1 << 0) |
	      DRM_MODE_MATCH_FLAGS(1 << 2) |
	      DRM_MODE_MATCH_3D_FLAGS(1 << 3)) &&
downclock_mode->clock < fixed_mode->clock;
60}

62struct drm_display_mode *
63intel_panel_edid_downclock_mode(struct intel_connector *connector,
		const struct drm_display_mode *fixed_mode)
65{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
const struct drm_display_mode *scan, *best_mode = NULL((void *)0);
struct drm_display_mode *downclock_mode;
int best_clock = fixed_mode->clock;

list_for_each_entry(scan, &connector->base.probed_modes, head)for (scan = ({ const __typeof( ((__typeof(*scan) *)0)->head
 ) *__mptr = ((&connector->base.probed_modes)->next
); (__typeof(*scan) *)( (char *)__mptr - __builtin_offsetof(__typeof
(*scan), head) );}); &scan->head != (&connector->
base.probed_modes); scan = ({ const __typeof( ((__typeof(*scan
) *)0)->head ) *__mptr = (scan->head.next); (__typeof(*
scan) *)( (char *)__mptr - __builtin_offsetof(__typeof(*scan)
, head) );})) {
/*
 * If one mode has the same resolution with the fixed_panel
 * mode while they have the different refresh rate, it means
 * that the reduced downclock is found. In such
 * case we can set the different FPx0/1 to dynamically select
 * between low and high frequency.
 */
if (is_downclock_mode(scan, fixed_mode) &&
    scan->clock < best_clock) {
	/*
	 * The downclock is already found. But we
	 * expect to find the lower downclock.
	 */
	best_clock = scan->clock;
	best_mode = scan;
}
}

if (!best_mode)
return NULL((void *)0);

downclock_mode = drm_mode_duplicate(&dev_priv->drm, best_mode);
if (!downclock_mode)
return NULL((void *)0);

drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using downclock mode from EDID: "
, connector->base.base.id, connector->base.name)
    "[CONNECTOR:%d:%s] using downclock mode from EDID: ",drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using downclock mode from EDID: "
, connector->base.base.id, connector->base.name)
    connector->base.base.id, connector->base.name)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using downclock mode from EDID: "
, connector->base.base.id, connector->base.name);
drm_mode_debug_printmodeline(downclock_mode);

return downclock_mode;
103}

105struct drm_display_mode *
106intel_panel_edid_fixed_mode(struct intel_connector *connector)
107{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
const struct drm_display_mode *scan;
struct drm_display_mode *fixed_mode;

if (list_empty(&connector->base.probed_modes))
return NULL((void *)0);

/* prefer fixed mode from EDID if available */
list_for_each_entry(scan, &connector->base.probed_modes, head)for (scan = ({ const __typeof( ((__typeof(*scan) *)0)->head
 ) *__mptr = ((&connector->base.probed_modes)->next
); (__typeof(*scan) *)( (char *)__mptr - __builtin_offsetof(__typeof
(*scan), head) );}); &scan->head != (&connector->
base.probed_modes); scan = ({ const __typeof( ((__typeof(*scan
) *)0)->head ) *__mptr = (scan->head.next); (__typeof(*
scan) *)( (char *)__mptr - __builtin_offsetof(__typeof(*scan)
, head) );})) {
if ((scan->type & DRM_MODE_TYPE_PREFERRED(1<<3)) == 0)
	continue;

fixed_mode = drm_mode_duplicate(&dev_priv->drm, scan);
if (!fixed_mode)
	return NULL((void *)0);

drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using preferred mode from EDID: "
, connector->base.base.id, connector->base.name)
	    "[CONNECTOR:%d:%s] using preferred mode from EDID: ",drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using preferred mode from EDID: "
, connector->base.base.id, connector->base.name)
	    connector->base.base.id, connector->base.name)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using preferred mode from EDID: "
, connector->base.base.id, connector->base.name);
drm_mode_debug_printmodeline(fixed_mode);

return fixed_mode;
}

scan = list_first_entry(&connector->base.probed_modes,({ const __typeof( ((typeof(*scan) *)0)->head ) *__mptr = (
(&connector->base.probed_modes)->next); (typeof(*scan
) *)( (char *)__mptr - __builtin_offsetof(typeof(*scan), head
) );})
		typeof(*scan), head)({ const __typeof( ((typeof(*scan) *)0)->head ) *__mptr = (
(&connector->base.probed_modes)->next); (typeof(*scan
) *)( (char *)__mptr - __builtin_offsetof(typeof(*scan), head
) );});

fixed_mode = drm_mode_duplicate(&dev_priv->drm, scan);
if (!fixed_mode)
return NULL((void *)0);

fixed_mode->type |= DRM_MODE_TYPE_PREFERRED(1<<3);

drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using first mode from EDID: "
, connector->base.base.id, connector->base.name)
    "[CONNECTOR:%d:%s] using first mode from EDID: ",drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using first mode from EDID: "
, connector->base.base.id, connector->base.name)
    connector->base.base.id, connector->base.name)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using first mode from EDID: "
, connector->base.base.id, connector->base.name);
drm_mode_debug_printmodeline(fixed_mode);

return fixed_mode;
147}

149struct drm_display_mode *
150intel_panel_vbt_fixed_mode(struct intel_connector *connector)
151{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct drm_display_info *info = &connector->base.display_info;
struct drm_display_mode *fixed_mode;

if (!dev_priv->vbt.lfp_lvds_vbt_mode)
return NULL((void *)0);

fixed_mode = drm_mode_duplicate(&dev_priv->drm,
			dev_priv->vbt.lfp_lvds_vbt_mode);
if (!fixed_mode)
return NULL((void *)0);

fixed_mode->type |= DRM_MODE_TYPE_PREFERRED(1<<3);

drm_dbg_kms(&dev_priv->drm, "[CONNECTOR:%d:%s] using mode from VBT: ",drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using mode from VBT: "
, connector->base.base.id, connector->base.name)
    connector->base.base.id, connector->base.name)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "[CONNECTOR:%d:%s] using mode from VBT: "
, connector->base.base.id, connector->base.name);
drm_mode_debug_printmodeline(fixed_mode);

info->width_mm = fixed_mode->width_mm;
info->height_mm = fixed_mode->height_mm;

return fixed_mode;
174}

176/* adjusted_mode has been preset to be the panel's fixed mode */
177int intel_pch_panel_fitting(struct intel_crtc_state *crtc_state,
	    const struct drm_connector_state *conn_state)
179{
const struct drm_display_mode *adjusted_mode =
&crtc_state->hw.adjusted_mode;
int x, y, width, height;

/* Native modes don't need fitting */
if (adjusted_mode->crtc_hdisplay == crtc_state->pipe_src_w &&
   adjusted_mode->crtc_vdisplay == crtc_state->pipe_src_h &&
   crtc_state->output_format != INTEL_OUTPUT_FORMAT_YCBCR420)
return 0;

switch (conn_state->scaling_mode) {
case DRM_MODE_SCALE_CENTER2:
width = crtc_state->pipe_src_w;
height = crtc_state->pipe_src_h;
x = (adjusted_mode->crtc_hdisplay - width + 1)/2;
y = (adjusted_mode->crtc_vdisplay - height + 1)/2;
break;

case DRM_MODE_SCALE_ASPECT3:
/* Scale but preserve the aspect ratio */
{
	u32 scaled_width = adjusted_mode->crtc_hdisplay
		* crtc_state->pipe_src_h;
	u32 scaled_height = crtc_state->pipe_src_w
		* adjusted_mode->crtc_vdisplay;
	if (scaled_width > scaled_height) { /* pillar */
		width = scaled_height / crtc_state->pipe_src_h;
		if (width & 1)
			width++;
		x = (adjusted_mode->crtc_hdisplay - width + 1) / 2;
		y = 0;
		height = adjusted_mode->crtc_vdisplay;
	} else if (scaled_width < scaled_height) { /* letter */
		height = scaled_width / crtc_state->pipe_src_w;
		if (height & 1)
		    height++;
		y = (adjusted_mode->crtc_vdisplay - height + 1) / 2;
		x = 0;
		width = adjusted_mode->crtc_hdisplay;
	} else {
		x = y = 0;
		width = adjusted_mode->crtc_hdisplay;
		height = adjusted_mode->crtc_vdisplay;
	}
}
break;

case DRM_MODE_SCALE_NONE0:
WARN_ON(adjusted_mode->crtc_hdisplay != crtc_state->pipe_src_w)({ int __ret = !!((adjusted_mode->crtc_hdisplay != crtc_state
->pipe_src_w)); if (__ret) printf("%s", "WARN_ON(" "adjusted_mode->crtc_hdisplay != crtc_state->pipe_src_w"
 ")"); __builtin_expect(!!(__ret), 0); });
WARN_ON(adjusted_mode->crtc_vdisplay != crtc_state->pipe_src_h)({ int __ret = !!((adjusted_mode->crtc_vdisplay != crtc_state
->pipe_src_h)); if (__ret) printf("%s", "WARN_ON(" "adjusted_mode->crtc_vdisplay != crtc_state->pipe_src_h"
 ")"); __builtin_expect(!!(__ret), 0); });
fallthroughdo {} while (0);
case DRM_MODE_SCALE_FULLSCREEN1:
x = y = 0;
width = adjusted_mode->crtc_hdisplay;
height = adjusted_mode->crtc_vdisplay;
break;

default:
MISSING_CASE(conn_state->scaling_mode)({ int __ret = !!(1); if (__ret) printf("Missing case (%s == %ld)\n"
, "conn_state->scaling_mode", (long)(conn_state->scaling_mode
)); __builtin_expect(!!(__ret), 0); });
return -EINVAL22;
}

drm_rect_init(&crtc_state->pch_pfit.dst,
      x, y, width, height);
crtc_state->pch_pfit.enabled = true1;

return 0;
247}

249static void
250centre_horizontally(struct drm_display_mode *adjusted_mode,
    int width)
252{
u32 border, sync_pos, blank_width, sync_width;

/* keep the hsync and hblank widths constant */
sync_width = adjusted_mode->crtc_hsync_end - adjusted_mode->crtc_hsync_start;
blank_width = adjusted_mode->crtc_hblank_end - adjusted_mode->crtc_hblank_start;
sync_pos = (blank_width - sync_width + 1) / 2;

border = (adjusted_mode->crtc_hdisplay - width + 1) / 2;
border += border & 1; /* make the border even */

adjusted_mode->crtc_hdisplay = width;
adjusted_mode->crtc_hblank_start = width + border;
adjusted_mode->crtc_hblank_end = adjusted_mode->crtc_hblank_start + blank_width;

adjusted_mode->crtc_hsync_start = adjusted_mode->crtc_hblank_start + sync_pos;
adjusted_mode->crtc_hsync_end = adjusted_mode->crtc_hsync_start + sync_width;
269}

271static void
272centre_vertically(struct drm_display_mode *adjusted_mode,
  int height)
274{
u32 border, sync_pos, blank_width, sync_width;

/* keep the vsync and vblank widths constant */
sync_width = adjusted_mode->crtc_vsync_end - adjusted_mode->crtc_vsync_start;
blank_width = adjusted_mode->crtc_vblank_end - adjusted_mode->crtc_vblank_start;
sync_pos = (blank_width - sync_width + 1) / 2;

border = (adjusted_mode->crtc_vdisplay - height + 1) / 2;

adjusted_mode->crtc_vdisplay = height;
adjusted_mode->crtc_vblank_start = height + border;
adjusted_mode->crtc_vblank_end = adjusted_mode->crtc_vblank_start + blank_width;

adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vblank_start + sync_pos;
adjusted_mode->crtc_vsync_end = adjusted_mode->crtc_vsync_start + sync_width;
290}

292static u32 panel_fitter_scaling(u32 source, u32 target)
293{
/*
* Floating point operation is not supported. So the FACTOR
* is defined, which can avoid the floating point computation
* when calculating the panel ratio.
*/
299#define ACCURACY12 12
300#define FACTOR(1 << 12) (1 << ACCURACY12)
u32 ratio = source * FACTOR(1 << 12) / target;
return (FACTOR(1 << 12) * ratio + FACTOR(1 << 12)/2) / FACTOR(1 << 12);
303}

305static void i965_scale_aspect(struct intel_crtc_state *crtc_state,
	      u32 *pfit_control)
307{
const struct drm_display_mode *adjusted_mode =
&crtc_state->hw.adjusted_mode;
u32 scaled_width = adjusted_mode->crtc_hdisplay *
crtc_state->pipe_src_h;
u32 scaled_height = crtc_state->pipe_src_w *
adjusted_mode->crtc_vdisplay;

/* 965+ is easy, it does everything in hw */
if (scaled_width > scaled_height)
*pfit_control |= PFIT_ENABLE(1 << 31) |
	PFIT_SCALING_PILLAR(2 << 26);
else if (scaled_width < scaled_height)
*pfit_control |= PFIT_ENABLE(1 << 31) |
	PFIT_SCALING_LETTER(3 << 26);
else if (adjusted_mode->crtc_hdisplay != crtc_state->pipe_src_w)
*pfit_control |= PFIT_ENABLE(1 << 31) | PFIT_SCALING_AUTO(0 << 26);
324}

326static void i9xx_scale_aspect(struct intel_crtc_state *crtc_state,
	      u32 *pfit_control, u32 *pfit_pgm_ratios,
	      u32 *border)
329{
struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;
u32 scaled_width = adjusted_mode->crtc_hdisplay *
crtc_state->pipe_src_h;
u32 scaled_height = crtc_state->pipe_src_w *
adjusted_mode->crtc_vdisplay;
u32 bits;

/*
* For earlier chips we have to calculate the scaling
* ratio by hand and program it into the
* PFIT_PGM_RATIO register
*/
if (scaled_width > scaled_height) { /* pillar */
centre_horizontally(adjusted_mode,
		    scaled_height /
		    crtc_state->pipe_src_h);

*border = LVDS_BORDER_ENABLE(1 << 15);
if (crtc_state->pipe_src_h != adjusted_mode->crtc_vdisplay) {
	bits = panel_fitter_scaling(crtc_state->pipe_src_h,
				    adjusted_mode->crtc_vdisplay);

	*pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT4 |
			     bits << PFIT_VERT_SCALE_SHIFT20);
	*pfit_control |= (PFIT_ENABLE(1 << 31) |
			  VERT_INTERP_BILINEAR(1 << 10) |
			  HORIZ_INTERP_BILINEAR(1 << 6));
}
} else if (scaled_width < scaled_height) { /* letter */
centre_vertically(adjusted_mode,
		  scaled_width /
		  crtc_state->pipe_src_w);

*border = LVDS_BORDER_ENABLE(1 << 15);
if (crtc_state->pipe_src_w != adjusted_mode->crtc_hdisplay) {
	bits = panel_fitter_scaling(crtc_state->pipe_src_w,
				    adjusted_mode->crtc_hdisplay);

	*pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT4 |
			     bits << PFIT_VERT_SCALE_SHIFT20);
	*pfit_control |= (PFIT_ENABLE(1 << 31) |
			  VERT_INTERP_BILINEAR(1 << 10) |
			  HORIZ_INTERP_BILINEAR(1 << 6));
}
} else {
/* Aspects match, Let hw scale both directions */
*pfit_control |= (PFIT_ENABLE(1 << 31) |
		  VERT_AUTO_SCALE(1 << 9) | HORIZ_AUTO_SCALE(1 << 5) |
		  VERT_INTERP_BILINEAR(1 << 10) |
		  HORIZ_INTERP_BILINEAR(1 << 6));
}
381}

383int intel_gmch_panel_fitting(struct intel_crtc_state *crtc_state,
	     const struct drm_connector_state *conn_state)
385{
struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc)({ const __typeof( ((struct intel_crtc *)0)->base ) *__mptr
 = (crtc_state->uapi.crtc); (struct intel_crtc *)( (char *
)__mptr - __builtin_offsetof(struct intel_crtc, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(crtc->base.dev);
u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0;
struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;

/* Native modes don't need fitting */
if (adjusted_mode->crtc_hdisplay == crtc_state->pipe_src_w &&
   adjusted_mode->crtc_vdisplay == crtc_state->pipe_src_h)
goto out;

switch (conn_state->scaling_mode) {
case DRM_MODE_SCALE_CENTER2:
/*
 * For centered modes, we have to calculate border widths &
 * heights and modify the values programmed into the CRTC.
 */
centre_horizontally(adjusted_mode, crtc_state->pipe_src_w);
centre_vertically(adjusted_mode, crtc_state->pipe_src_h);
border = LVDS_BORDER_ENABLE(1 << 15);
break;
case DRM_MODE_SCALE_ASPECT3:
/* Scale but preserve the aspect ratio */
if (INTEL_GEN(dev_priv)((&(dev_priv)->__info)->gen) >= 4)
	i965_scale_aspect(crtc_state, &pfit_control);
else
	i9xx_scale_aspect(crtc_state, &pfit_control,
			  &pfit_pgm_ratios, &border);
break;
case DRM_MODE_SCALE_FULLSCREEN1:
/*
 * Full scaling, even if it changes the aspect ratio.
 * Fortunately this is all done for us in hw.
 */
if (crtc_state->pipe_src_h != adjusted_mode->crtc_vdisplay ||
    crtc_state->pipe_src_w != adjusted_mode->crtc_hdisplay) {
	pfit_control |= PFIT_ENABLE(1 << 31);
	if (INTEL_GEN(dev_priv)((&(dev_priv)->__info)->gen) >= 4)
		pfit_control |= PFIT_SCALING_AUTO(0 << 26);
	else
		pfit_control |= (VERT_AUTO_SCALE(1 << 9) |
				 VERT_INTERP_BILINEAR(1 << 10) |
				 HORIZ_AUTO_SCALE(1 << 5) |
				 HORIZ_INTERP_BILINEAR(1 << 6));
}
break;
default:
MISSING_CASE(conn_state->scaling_mode)({ int __ret = !!(1); if (__ret) printf("Missing case (%s == %ld)\n"
, "conn_state->scaling_mode", (long)(conn_state->scaling_mode
)); __builtin_expect(!!(__ret), 0); });
return -EINVAL22;
}

/* 965+ wants fuzzy fitting */
/* FIXME: handle multiple panels by failing gracefully */
if (INTEL_GEN(dev_priv)((&(dev_priv)->__info)->gen) >= 4)
pfit_control |= PFIT_PIPE(crtc->pipe)((crtc->pipe) << 29) | PFIT_FILTER_FUZZY(0 << 24);

441out:
if ((pfit_control & PFIT_ENABLE(1 << 31)) == 0) {
pfit_control = 0;
pfit_pgm_ratios = 0;
}

/* Make sure pre-965 set dither correctly for 18bpp panels. */
if (INTEL_GEN(dev_priv)((&(dev_priv)->__info)->gen) < 4 && crtc_state->pipe_bpp == 18)
pfit_control |= PANEL_8TO6_DITHER_ENABLE(1 << 3);

crtc_state->gmch_pfit.control = pfit_control;
crtc_state->gmch_pfit.pgm_ratios = pfit_pgm_ratios;
crtc_state->gmch_pfit.lvds_border_bits = border;

return 0;
456}

458/**
* scale - scale values from one range to another
* @source_val: value in range [@source_min..@source_max]
* @source_min: minimum legal value for @source_val
* @source_max: maximum legal value for @source_val
* @target_min: corresponding target value for @source_min
* @target_max: corresponding target value for @source_max
*
* Return @source_val in range [@source_min..@source_max] scaled to range
* [@target_min..@target_max].
*/
469static u32 scale(u32 source_val,
 u32 source_min, u32 source_max,
 u32 target_min, u32 target_max)
472{
u64 target_val;

WARN_ON(source_min > source_max)({ int __ret = !!((source_min > source_max)); if (__ret) printf
("%s", "WARN_ON(" "source_min > source_max" ")"); __builtin_expect
(!!(__ret), 0); });
4
←
Assuming 'source_min' is <= 'source_max'→
5
←
Taking false branch→
WARN_ON(target_min > target_max)({ int __ret = !!((target_min > target_max)); if (__ret) printf
("%s", "WARN_ON(" "target_min > target_max" ")"); __builtin_expect
(!!(__ret), 0); });
6
←
Taking false branch→

/* defensive */
source_val = clamp(source_val, source_min, source_max)({ __typeof(source_val) __min_a = (({ __typeof(source_val) __max_a
 = (source_val); __typeof(source_val) __max_b = (source_min);
 __max_a > __max_b ? __max_a : __max_b; })); __typeof(source_val
) __min_b = (source_max); __min_a < __min_b ? __min_a : __min_b
; });
7
←
Assuming '__max_a' is <= '__max_b'→
8
←
'?' condition is false→
9
←
'?' condition is false→

/* avoid overflows */
target_val = mul_u32_u32(source_val - source_min,
		 target_max - target_min);
target_val = DIV_ROUND_CLOSEST_ULL(target_val, source_max - source_min)(((target_val) + ((source_max - source_min) / 2)) / (source_max
 - source_min));
10
←
Division by zero
target_val += target_min;

return target_val;
488}

490/* Scale user_level in range [0..user_max] to [0..hw_max], clamping the result
* to [hw_min..hw_max]. */
492static u32 clamp_user_to_hw(struct intel_connector *connector,
	    u32 user_level, u32 user_max)
494{
struct intel_panel *panel = &connector->panel;
u32 hw_level;

hw_level = scale(user_level, 0, user_max, 0, panel->backlight.max);
hw_level = clamp(hw_level, panel->backlight.min, panel->backlight.max)({ __typeof(hw_level) __min_a = (({ __typeof(hw_level) __max_a
 = (hw_level); __typeof(hw_level) __max_b = (panel->backlight
.min); __max_a > __max_b ? __max_a : __max_b; })); __typeof
(hw_level) __min_b = (panel->backlight.max); __min_a < __min_b
 ? __min_a : __min_b; });

return hw_level;
502}

504/* Scale hw_level in range [hw_min..hw_max] to [0..user_max]. */
505static u32 scale_hw_to_user(struct intel_connector *connector,
	    u32 hw_level, u32 user_max)
507{
struct intel_panel *panel = &connector->panel;

return scale(hw_level, panel->backlight.min, panel->backlight.max,
3
←
Calling 'scale'→
     0, user_max);
512}

514static u32 intel_panel_compute_brightness(struct intel_connector *connector,
			  u32 val)
516{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;

drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0)({ int __ret = !!((panel->backlight.max == 0)); if (__ret)
 printf("%s %s: " "%s", dev_driver_string(((&dev_priv->
drm))->dev), "", "drm_WARN_ON(" "panel->backlight.max == 0"
 ")"); __builtin_expect(!!(__ret), 0); });

if (dev_priv->params.invert_brightness < 0)
return val;

if (dev_priv->params.invert_brightness > 0 ||
   dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS(1<<2)) {
return panel->backlight.max - val + panel->backlight.min;
}

return val;
531}

533static u32 lpt_get_backlight(struct intel_connector *connector)
534{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);

return intel_de_read(dev_priv, BLC_PWM_PCH_CTL2((const i915_reg_t){ .reg = (0xc8254) })) & BACKLIGHT_DUTY_CYCLE_MASK(0xffff);
538}

540static u32 pch_get_backlight(struct intel_connector *connector)
541{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);

return intel_de_read(dev_priv, BLC_PWM_CPU_CTL((const i915_reg_t){ .reg = (0x48254) })) & BACKLIGHT_DUTY_CYCLE_MASK(0xffff);
545}

547static u32 i9xx_get_backlight(struct intel_connector *connector)
548{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 val;

val = intel_de_read(dev_priv, BLC_PWM_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61254) })) & BACKLIGHT_DUTY_CYCLE_MASK(0xffff);
if (INTEL_GEN(dev_priv)((&(dev_priv)->__info)->gen) < 4)
val >>= 1;

if (panel->backlight.combination_mode) {
u8 lbpc;

pci_read_config_byte(dev_priv->drm.pdev, LBPC0xf4, &lbpc);
val *= lbpc;
}

return val;
565}

567static u32 _vlv_get_backlight(struct drm_i915_privateinteldrm_softc *dev_priv, enum pipe pipe)
568{
if (drm_WARN_ON(&dev_priv->drm, pipe != PIPE_A && pipe != PIPE_B)({ int __ret = !!((pipe != PIPE_A && pipe != PIPE_B))
; if (__ret) printf("%s %s: " "%s", dev_driver_string(((&
dev_priv->drm))->dev), "", "drm_WARN_ON(" "pipe != PIPE_A && pipe != PIPE_B"
 ")"); __builtin_expect(!!(__ret), 0); }))
return 0;

return intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61254)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61354)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61254))))
) })) & BACKLIGHT_DUTY_CYCLE_MASK(0xffff);
573}

575static u32 vlv_get_backlight(struct intel_connector *connector)
576{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
enum pipe pipe = intel_connector_get_pipe(connector);

return _vlv_get_backlight(dev_priv, pipe);
581}

583static u32 bxt_get_backlight(struct intel_connector *connector)
584{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;

return intel_de_read(dev_priv,
	     BXT_BLC_PWM_DUTY(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8258) + (panel->backlight
.controller) * ((0xC8358) - (0xC8258)))) }));
590}

592static u32 pwm_get_backlight(struct intel_connector *connector)
593{
STUB()do { printf("%s: stub\n", __func__); } while(0);
return 0;
596#ifdef notyet
struct intel_panel *panel = &connector->panel;
struct pwm_state state;

pwm_get_state(panel->backlight.pwm, &state);
return pwm_get_relative_duty_cycle(&state, 100);
602#endif
603}

605static void lpt_set_backlight(const struct drm_connector_state *conn_state, u32 level)
606{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);

u32 val = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2((const i915_reg_t){ .reg = (0xc8254) })) & ~BACKLIGHT_DUTY_CYCLE_MASK(0xffff);
intel_de_write(dev_priv, BLC_PWM_PCH_CTL2((const i915_reg_t){ .reg = (0xc8254) }), val | level);
612}

614static void pch_set_backlight(const struct drm_connector_state *conn_state, u32 level)
615{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
u32 tmp;

tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL((const i915_reg_t){ .reg = (0x48254) })) & ~BACKLIGHT_DUTY_CYCLE_MASK(0xffff);
intel_de_write(dev_priv, BLC_PWM_CPU_CTL((const i915_reg_t){ .reg = (0x48254) }), tmp | level);
622}

624static void i9xx_set_backlight(const struct drm_connector_state *conn_state, u32 level)
625{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 tmp, mask;

drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0)({ int __ret = !!((panel->backlight.max == 0)); if (__ret)
 printf("%s %s: " "%s", dev_driver_string(((&dev_priv->
drm))->dev), "", "drm_WARN_ON(" "panel->backlight.max == 0"
 ")"); __builtin_expect(!!(__ret), 0); });

if (panel->backlight.combination_mode) {
u8 lbpc;

lbpc = level * 0xfe / panel->backlight.max + 1;
level /= lbpc;
pci_write_config_byte(dev_priv->drm.pdev, LBPC0xf4, lbpc);
}

if (IS_GEN(dev_priv, 4)(0 + (&(dev_priv)->__info)->gen == (4))) {
mask = BACKLIGHT_DUTY_CYCLE_MASK(0xffff);
} else {
level <<= 1;
mask = BACKLIGHT_DUTY_CYCLE_MASK_PNV(0xfffe);
}

tmp = intel_de_read(dev_priv, BLC_PWM_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61254) })) & ~mask;
intel_de_write(dev_priv, BLC_PWM_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61254) }), tmp | level);
650}

652static void vlv_set_backlight(const struct drm_connector_state *conn_state, u32 level)
653{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
enum pipe pipe = to_intel_crtc(conn_state->crtc)({ const __typeof( ((struct intel_crtc *)0)->base ) *__mptr
 = (conn_state->crtc); (struct intel_crtc *)( (char *)__mptr
 - __builtin_offsetof(struct intel_crtc, base) );})->pipe;
u32 tmp;

tmp = intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61254)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61354)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61254))))
) })) & ~BACKLIGHT_DUTY_CYCLE_MASK(0xffff);
intel_de_write(dev_priv, VLV_BLC_PWM_CTL(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61254)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61354)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61254))))
) }), tmp | level);
661}

663static void bxt_set_backlight(const struct drm_connector_state *conn_state, u32 level)
664{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;

intel_de_write(dev_priv,
       BXT_BLC_PWM_DUTY(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8258) + (panel->backlight
.controller) * ((0xC8358) - (0xC8258)))) }), level);
671}

673static void pwm_set_backlight(const struct drm_connector_state *conn_state, u32 level)
674{
STUB()do { printf("%s: stub\n", __func__); } while(0);
676#ifdef notyet
struct intel_panel *panel = &to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );})->panel;

pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
681#endif
682}

684static void
685intel_panel_actually_set_backlight(const struct drm_connector_state *conn_state, u32 level)
686{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *i915 = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;

drm_dbg_kms(&i915->drm, "set backlight PWM = %d\n", level)drm_dev_dbg((&i915->drm)->dev, DRM_UT_KMS, "set backlight PWM = %d\n"
, level);

level = intel_panel_compute_brightness(connector, level);
panel->backlight.set(conn_state, level);
695}

697/* set backlight brightness to level in range [0..max], assuming hw min is
* respected.
*/
700void intel_panel_set_backlight_acpi(const struct drm_connector_state *conn_state,
		    u32 user_level, u32 user_max)
702{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 hw_level;

/*
* Lack of crtc may occur during driver init because
* connection_mutex isn't held across the entire backlight
* setup + modeset readout, and the BIOS can issue the
* requests at any time.
*/
if (!panel->backlight.present || !conn_state->crtc)
return;

mutex_lock(&dev_priv->backlight_lock)rw_enter_write(&dev_priv->backlight_lock);

drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0)({ int __ret = !!((panel->backlight.max == 0)); if (__ret)
 printf("%s %s: " "%s", dev_driver_string(((&dev_priv->
drm))->dev), "", "drm_WARN_ON(" "panel->backlight.max == 0"
 ")"); __builtin_expect(!!(__ret), 0); });

hw_level = clamp_user_to_hw(connector, user_level, user_max);
panel->backlight.level = hw_level;

if (panel->backlight.device)
panel->backlight.device->props.brightness =
	scale_hw_to_user(connector,
			 panel->backlight.level,
			 panel->backlight.device->props.max_brightness);

if (panel->backlight.enabled)
intel_panel_actually_set_backlight(conn_state, hw_level);

mutex_unlock(&dev_priv->backlight_lock)rw_exit_write(&dev_priv->backlight_lock);
734}

736static void lpt_disable_backlight(const struct drm_connector_state *old_conn_state)
737{
struct intel_connector *connector = to_intel_connector(old_conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (old_conn_state->connector); (struct intel_connector
 *)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
u32 tmp;

intel_panel_actually_set_backlight(old_conn_state, 0);

/*
* Although we don't support or enable CPU PWM with LPT/SPT based
* systems, it may have been enabled prior to loading the
* driver. Disable to avoid warnings on LCPLL disable.
*
* This needs rework if we need to add support for CPU PWM on PCH split
* platforms.
*/
tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }));
if (tmp & BLM_PWM_ENABLE(1 << 31)) {
drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "cpu backlight was enabled, disabling\n"
)
	    "cpu backlight was enabled, disabling\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "cpu backlight was enabled, disabling\n"
);
intel_de_write(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }),
	       tmp & ~BLM_PWM_ENABLE(1 << 31));
}

tmp = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }));
intel_de_write(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }), tmp & ~BLM_PCH_PWM_ENABLE(1 << 31));
762}

764static void pch_disable_backlight(const struct drm_connector_state *old_conn_state)
765{
struct intel_connector *connector = to_intel_connector(old_conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (old_conn_state->connector); (struct intel_connector
 *)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
u32 tmp;

intel_panel_actually_set_backlight(old_conn_state, 0);

tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }));
intel_de_write(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }), tmp & ~BLM_PWM_ENABLE(1 << 31));

tmp = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }));
intel_de_write(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }), tmp & ~BLM_PCH_PWM_ENABLE(1 << 31));
777}

779static void i9xx_disable_backlight(const struct drm_connector_state *old_conn_state)
780{
intel_panel_actually_set_backlight(old_conn_state, 0);
782}

784static void i965_disable_backlight(const struct drm_connector_state *old_conn_state)
785{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(old_conn_state->connector->dev);
u32 tmp;

intel_panel_actually_set_backlight(old_conn_state, 0);

tmp = intel_de_read(dev_priv, BLC_PWM_CTL2((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61250) }));
intel_de_write(dev_priv, BLC_PWM_CTL2((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61250) }), tmp & ~BLM_PWM_ENABLE(1 << 31));
793}

795static void vlv_disable_backlight(const struct drm_connector_state *old_conn_state)
796{
struct intel_connector *connector = to_intel_connector(old_conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (old_conn_state->connector); (struct intel_connector
 *)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
enum pipe pipe = to_intel_crtc(old_conn_state->crtc)({ const __typeof( ((struct intel_crtc *)0)->base ) *__mptr
 = (old_conn_state->crtc); (struct intel_crtc *)( (char *)
__mptr - __builtin_offsetof(struct intel_crtc, base) );})->pipe;
u32 tmp;

intel_panel_actually_set_backlight(old_conn_state, 0);

tmp = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61250)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61350)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61250))))
) }));
intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61250)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61350)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61250))))
) }),
       tmp & ~BLM_PWM_ENABLE(1 << 31));
807}

809static void bxt_disable_backlight(const struct drm_connector_state *old_conn_state)
810{
struct intel_connector *connector = to_intel_connector(old_conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (old_conn_state->connector); (struct intel_connector
 *)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 tmp, val;

intel_panel_actually_set_backlight(old_conn_state, 0);

tmp = intel_de_read(dev_priv,
	    BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }));
intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }),
       tmp & ~BXT_BLC_PWM_ENABLE(1 << 31));

if (panel->backlight.controller == 1) {
val = intel_de_read(dev_priv, UTIL_PIN_CTL((const i915_reg_t){ .reg = (0x48400) }));
val &= ~UTIL_PIN_ENABLE(1 << 31);
intel_de_write(dev_priv, UTIL_PIN_CTL((const i915_reg_t){ .reg = (0x48400) }), val);
}
828}

830static void cnp_disable_backlight(const struct drm_connector_state *old_conn_state)
831{
struct intel_connector *connector = to_intel_connector(old_conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (old_conn_state->connector); (struct intel_connector
 *)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 tmp;

intel_panel_actually_set_backlight(old_conn_state, 0);

tmp = intel_de_read(dev_priv,
	    BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }));
intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }),
       tmp & ~BXT_BLC_PWM_ENABLE(1 << 31));
843}

845static void pwm_disable_backlight(const struct drm_connector_state *old_conn_state)
846{
STUB()do { printf("%s: stub\n", __func__); } while(0);
848#ifdef notyet
struct intel_connector *connector = to_intel_connector(old_conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (old_conn_state->connector); (struct intel_connector
 *)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct intel_panel *panel = &connector->panel;

panel->backlight.pwm_state.enabled = false0;
pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
854#endif
855}

857void intel_panel_disable_backlight(const struct drm_connector_state *old_conn_state)
858{
struct intel_connector *connector = to_intel_connector(old_conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (old_conn_state->connector); (struct intel_connector
 *)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;

if (!panel->backlight.present)
return;

/*
* Do not disable backlight on the vga_switcheroo path. When switching
* away from i915, the other client may depend on i915 to handle the
* backlight. This will leave the backlight on unnecessarily when
* another client is not activated.
*/
if (dev_priv->drm.switch_power_state == DRM_SWITCH_POWER_CHANGING) {
drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "Skipping backlight disable on vga switch\n"
)
	    "Skipping backlight disable on vga switch\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "Skipping backlight disable on vga switch\n"
);
return;
}

mutex_lock(&dev_priv->backlight_lock)rw_enter_write(&dev_priv->backlight_lock);

if (panel->backlight.device)
panel->backlight.device->props.power = FB_BLANK_POWERDOWN4;
panel->backlight.enabled = false0;
panel->backlight.disable(old_conn_state);

mutex_unlock(&dev_priv->backlight_lock)rw_exit_write(&dev_priv->backlight_lock);
886}

888static void lpt_enable_backlight(const struct intel_crtc_state *crtc_state,
		 const struct drm_connector_state *conn_state)
890{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 pch_ctl1, pch_ctl2, schicken;

pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }));
if (pch_ctl1 & BLM_PCH_PWM_ENABLE(1 << 31)) {
drm_dbg_kms(&dev_priv->drm, "pch backlight already enabled\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "pch backlight already enabled\n"
);
pch_ctl1 &= ~BLM_PCH_PWM_ENABLE(1 << 31);
intel_de_write(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }), pch_ctl1);
}

if (HAS_PCH_LPT(dev_priv)(((dev_priv)->pch_type) == PCH_LPT)) {
schicken = intel_de_read(dev_priv, SOUTH_CHICKEN2((const i915_reg_t){ .reg = (0xc2004) }));
if (panel->backlight.alternate_pwm_increment)
	schicken |= LPT_PWM_GRANULARITY(1 << 5);
else
	schicken &= ~LPT_PWM_GRANULARITY(1 << 5);
intel_de_write(dev_priv, SOUTH_CHICKEN2((const i915_reg_t){ .reg = (0xc2004) }), schicken);
} else {
schicken = intel_de_read(dev_priv, SOUTH_CHICKEN1((const i915_reg_t){ .reg = (0xc2000) }));
if (panel->backlight.alternate_pwm_increment)
	schicken |= SPT_PWM_GRANULARITY(1 << 0);
else
	schicken &= ~SPT_PWM_GRANULARITY(1 << 0);
intel_de_write(dev_priv, SOUTH_CHICKEN1((const i915_reg_t){ .reg = (0xc2000) }), schicken);
}

pch_ctl2 = panel->backlight.max << 16;
intel_de_write(dev_priv, BLC_PWM_PCH_CTL2((const i915_reg_t){ .reg = (0xc8254) }), pch_ctl2);

pch_ctl1 = 0;
if (panel->backlight.active_low_pwm)
pch_ctl1 |= BLM_PCH_POLARITY(1 << 29);

/* After LPT, override is the default. */
if (HAS_PCH_LPT(dev_priv)(((dev_priv)->pch_type) == PCH_LPT))
pch_ctl1 |= BLM_PCH_OVERRIDE_ENABLE(1 << 30);

intel_de_write(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }), pch_ctl1);
intel_de_posting_read(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }));
intel_de_write(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }),
       pch_ctl1 | BLM_PCH_PWM_ENABLE(1 << 31));

/* This won't stick until the above enable. */
intel_panel_actually_set_backlight(conn_state, panel->backlight.level);
937}

939static void pch_enable_backlight(const struct intel_crtc_state *crtc_state,
		 const struct drm_connector_state *conn_state)
941{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
u32 cpu_ctl2, pch_ctl1, pch_ctl2;

cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }));
if (cpu_ctl2 & BLM_PWM_ENABLE(1 << 31)) {
drm_dbg_kms(&dev_priv->drm, "cpu backlight already enabled\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "cpu backlight already enabled\n"
);
cpu_ctl2 &= ~BLM_PWM_ENABLE(1 << 31);
intel_de_write(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }), cpu_ctl2);
}

pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }));
if (pch_ctl1 & BLM_PCH_PWM_ENABLE(1 << 31)) {
drm_dbg_kms(&dev_priv->drm, "pch backlight already enabled\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "pch backlight already enabled\n"
);
pch_ctl1 &= ~BLM_PCH_PWM_ENABLE(1 << 31);
intel_de_write(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }), pch_ctl1);
}

if (cpu_transcoder == TRANSCODER_EDP)
cpu_ctl2 = BLM_TRANSCODER_EDP(3 << 29);
else
cpu_ctl2 = BLM_PIPE(cpu_transcoder)((cpu_transcoder) << 29);
intel_de_write(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }), cpu_ctl2);
intel_de_posting_read(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }));
intel_de_write(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }), cpu_ctl2 | BLM_PWM_ENABLE(1 << 31));

/* This won't stick until the above enable. */
intel_panel_actually_set_backlight(conn_state, panel->backlight.level);

pch_ctl2 = panel->backlight.max << 16;
intel_de_write(dev_priv, BLC_PWM_PCH_CTL2((const i915_reg_t){ .reg = (0xc8254) }), pch_ctl2);

pch_ctl1 = 0;
if (panel->backlight.active_low_pwm)
pch_ctl1 |= BLM_PCH_POLARITY(1 << 29);

intel_de_write(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }), pch_ctl1);
intel_de_posting_read(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }));
intel_de_write(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }),
       pch_ctl1 | BLM_PCH_PWM_ENABLE(1 << 31));
984}

986static void i9xx_enable_backlight(const struct intel_crtc_state *crtc_state,
		  const struct drm_connector_state *conn_state)
988{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 ctl, freq;

ctl = intel_de_read(dev_priv, BLC_PWM_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61254) }));
if (ctl & BACKLIGHT_DUTY_CYCLE_MASK_PNV(0xfffe)) {
drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "backlight already enabled\n"
);
intel_de_write(dev_priv, BLC_PWM_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61254) }), 0);
}

freq = panel->backlight.max;
if (panel->backlight.combination_mode)
freq /= 0xff;

ctl = freq << 17;
if (panel->backlight.combination_mode)
ctl |= BLM_LEGACY_MODE(1 << 16);
if (IS_PINEVIEW(dev_priv)IS_PLATFORM(dev_priv, INTEL_PINEVIEW) && panel->backlight.active_low_pwm)
ctl |= BLM_POLARITY_PNV(1 << 0);

intel_de_write(dev_priv, BLC_PWM_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61254) }), ctl);
intel_de_posting_read(dev_priv, BLC_PWM_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61254) }));

/* XXX: combine this into above write? */
intel_panel_actually_set_backlight(conn_state, panel->backlight.level);

/*
* Needed to enable backlight on some 855gm models. BLC_HIST_CTL is
* 855gm only, but checking for gen2 is safe, as 855gm is the only gen2
* that has backlight.
*/
if (IS_GEN(dev_priv, 2)(0 + (&(dev_priv)->__info)->gen == (2)))
intel_de_write(dev_priv, BLC_HIST_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61260) }), BLM_HISTOGRAM_ENABLE(1 << 31));
1023}

1025static void i965_enable_backlight(const struct intel_crtc_state *crtc_state,
		  const struct drm_connector_state *conn_state)
1027{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
enum pipe pipe = to_intel_crtc(conn_state->crtc)({ const __typeof( ((struct intel_crtc *)0)->base ) *__mptr
 = (conn_state->crtc); (struct intel_crtc *)( (char *)__mptr
 - __builtin_offsetof(struct intel_crtc, base) );})->pipe;
u32 ctl, ctl2, freq;

ctl2 = intel_de_read(dev_priv, BLC_PWM_CTL2((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61250) }));
if (ctl2 & BLM_PWM_ENABLE(1 << 31)) {
drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "backlight already enabled\n"
);
ctl2 &= ~BLM_PWM_ENABLE(1 << 31);
intel_de_write(dev_priv, BLC_PWM_CTL2((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61250) }), ctl2);
}

freq = panel->backlight.max;
if (panel->backlight.combination_mode)
freq /= 0xff;

ctl = freq << 16;
intel_de_write(dev_priv, BLC_PWM_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61254) }), ctl);

ctl2 = BLM_PIPE(pipe)((pipe) << 29);
if (panel->backlight.combination_mode)
ctl2 |= BLM_COMBINATION_MODE(1 << 30);
if (panel->backlight.active_low_pwm)
ctl2 |= BLM_POLARITY_I965(1 << 28);
intel_de_write(dev_priv, BLC_PWM_CTL2((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61250) }), ctl2);
intel_de_posting_read(dev_priv, BLC_PWM_CTL2((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61250) }));
intel_de_write(dev_priv, BLC_PWM_CTL2((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61250) }), ctl2 | BLM_PWM_ENABLE(1 << 31));

intel_panel_actually_set_backlight(conn_state, panel->backlight.level);
1058}

1060static void vlv_enable_backlight(const struct intel_crtc_state *crtc_state,
		 const struct drm_connector_state *conn_state)
1062{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)({ const __typeof( ((struct intel_crtc *)0)->base ) *__mptr
 = (crtc_state->uapi.crtc); (struct intel_crtc *)( (char *
)__mptr - __builtin_offsetof(struct intel_crtc, base) );})->pipe;
u32 ctl, ctl2;

ctl2 = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61250)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61350)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61250))))
) }));
if (ctl2 & BLM_PWM_ENABLE(1 << 31)) {
drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "backlight already enabled\n"
);
ctl2 &= ~BLM_PWM_ENABLE(1 << 31);
intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61250)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61350)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61250))))
) }), ctl2);
}

ctl = panel->backlight.max << 16;
intel_de_write(dev_priv, VLV_BLC_PWM_CTL(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61254)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61354)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61254))))
) }), ctl);

/* XXX: combine this into above write? */
intel_panel_actually_set_backlight(conn_state, panel->backlight.level);

ctl2 = 0;
if (panel->backlight.active_low_pwm)
ctl2 |= BLM_POLARITY_I965(1 << 28);
intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61250)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61350)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61250))))
) }), ctl2);
intel_de_posting_read(dev_priv, VLV_BLC_PWM_CTL2(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61250)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61350)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61250))))
) }));
intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61250)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61350)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61250))))
) }),
       ctl2 | BLM_PWM_ENABLE(1 << 31));
1089}

1091static void bxt_enable_backlight(const struct intel_crtc_state *crtc_state,
		 const struct drm_connector_state *conn_state)
1093{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)({ const __typeof( ((struct intel_crtc *)0)->base ) *__mptr
 = (crtc_state->uapi.crtc); (struct intel_crtc *)( (char *
)__mptr - __builtin_offsetof(struct intel_crtc, base) );})->pipe;
u32 pwm_ctl, val;

/* Controller 1 uses the utility pin. */
if (panel->backlight.controller == 1) {
val = intel_de_read(dev_priv, UTIL_PIN_CTL((const i915_reg_t){ .reg = (0x48400) }));
if (val & UTIL_PIN_ENABLE(1 << 31)) {
	drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "util pin already enabled\n"
)
		    "util pin already enabled\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "util pin already enabled\n"
);
	val &= ~UTIL_PIN_ENABLE(1 << 31);
	intel_de_write(dev_priv, UTIL_PIN_CTL((const i915_reg_t){ .reg = (0x48400) }), val);
}

val = 0;
if (panel->backlight.util_pin_active_low)
	val |= UTIL_PIN_POLARITY(1 << 22);
intel_de_write(dev_priv, UTIL_PIN_CTL((const i915_reg_t){ .reg = (0x48400) }),
	       val | UTIL_PIN_PIPE(pipe)((pipe) << 29) | UTIL_PIN_MODE_PWM(1 << 24) | UTIL_PIN_ENABLE(1 << 31));
}

pwm_ctl = intel_de_read(dev_priv,
		BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }));
if (pwm_ctl & BXT_BLC_PWM_ENABLE(1 << 31)) {
drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "backlight already enabled\n"
);
pwm_ctl &= ~BXT_BLC_PWM_ENABLE(1 << 31);
intel_de_write(dev_priv,
	       BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }),
	       pwm_ctl);
}

intel_de_write(dev_priv,
       BXT_BLC_PWM_FREQ(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8254) + (panel->backlight
.controller) * ((0xC8354) - (0xC8254)))) }),
       panel->backlight.max);

intel_panel_actually_set_backlight(conn_state, panel->backlight.level);

pwm_ctl = 0;
if (panel->backlight.active_low_pwm)
pwm_ctl |= BXT_BLC_PWM_POLARITY(1 << 29);

intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }),
       pwm_ctl);
intel_de_posting_read(dev_priv,
	      BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }));
intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }),
       pwm_ctl | BXT_BLC_PWM_ENABLE(1 << 31));
1143}

1145static void cnp_enable_backlight(const struct intel_crtc_state *crtc_state,
		 const struct drm_connector_state *conn_state)
1147{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 pwm_ctl;

pwm_ctl = intel_de_read(dev_priv,
		BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }));
if (pwm_ctl & BXT_BLC_PWM_ENABLE(1 << 31)) {
drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "backlight already enabled\n"
);
pwm_ctl &= ~BXT_BLC_PWM_ENABLE(1 << 31);
intel_de_write(dev_priv,
	       BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }),
	       pwm_ctl);
}

intel_de_write(dev_priv,
       BXT_BLC_PWM_FREQ(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8254) + (panel->backlight
.controller) * ((0xC8354) - (0xC8254)))) }),
       panel->backlight.max);

intel_panel_actually_set_backlight(conn_state, panel->backlight.level);

pwm_ctl = 0;
if (panel->backlight.active_low_pwm)
pwm_ctl |= BXT_BLC_PWM_POLARITY(1 << 29);

intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }),
       pwm_ctl);
intel_de_posting_read(dev_priv,
	      BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }));
intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }),
       pwm_ctl | BXT_BLC_PWM_ENABLE(1 << 31));
1179}

1181static void pwm_enable_backlight(const struct intel_crtc_state *crtc_state,
		 const struct drm_connector_state *conn_state)
1183{
STUB()do { printf("%s: stub\n", __func__); } while(0);
1185#ifdef notyet
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct intel_panel *panel = &connector->panel;
int level = panel->backlight.level;

level = intel_panel_compute_brightness(connector, level);
pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
panel->backlight.pwm_state.enabled = true1;
pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
1194#endif
1195}

1197static void __intel_panel_enable_backlight(const struct intel_crtc_state *crtc_state,
			   const struct drm_connector_state *conn_state)
1199{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct intel_panel *panel = &connector->panel;

WARN_ON(panel->backlight.max == 0)({ int __ret = !!((panel->backlight.max == 0)); if (__ret)
 printf("%s", "WARN_ON(" "panel->backlight.max == 0" ")");
 __builtin_expect(!!(__ret), 0); });

if (panel->backlight.level <= panel->backlight.min) {
panel->backlight.level = panel->backlight.max;
if (panel->backlight.device)
	panel->backlight.device->props.brightness =
		scale_hw_to_user(connector,
				 panel->backlight.level,
				 panel->backlight.device->props.max_brightness);
}

panel->backlight.enable(crtc_state, conn_state);
panel->backlight.enabled = true1;
if (panel->backlight.device)
panel->backlight.device->props.power = FB_BLANK_UNBLANK0;
1218}

1220void intel_panel_enable_backlight(const struct intel_crtc_state *crtc_state,
		  const struct drm_connector_state *conn_state)
1222{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)({ const __typeof( ((struct intel_crtc *)0)->base ) *__mptr
 = (crtc_state->uapi.crtc); (struct intel_crtc *)( (char *
)__mptr - __builtin_offsetof(struct intel_crtc, base) );})->pipe;

if (!panel->backlight.present)
return;

drm_dbg_kms(&dev_priv->drm, "pipe %c\n", pipe_name(pipe))drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "pipe %c\n"
, ((pipe) + 'A'));

mutex_lock(&dev_priv->backlight_lock)rw_enter_write(&dev_priv->backlight_lock);

__intel_panel_enable_backlight(crtc_state, conn_state);

mutex_unlock(&dev_priv->backlight_lock)rw_exit_write(&dev_priv->backlight_lock);
1238}

1240#if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)1
1241static u32 intel_panel_get_backlight(struct intel_connector *connector)
1242{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 val = 0;

mutex_lock(&dev_priv->backlight_lock)rw_enter_write(&dev_priv->backlight_lock);

if (panel->backlight.enabled) {
val = panel->backlight.get(connector);
val = intel_panel_compute_brightness(connector, val);
}

mutex_unlock(&dev_priv->backlight_lock)rw_exit_write(&dev_priv->backlight_lock);

drm_dbg_kms(&dev_priv->drm, "get backlight PWM = %d\n", val)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "get backlight PWM = %d\n"
, val);
return val;
1258}

1260/* Scale user_level in range [0..user_max] to [hw_min..hw_max]. */
1261static u32 scale_user_to_hw(struct intel_connector *connector,
	    u32 user_level, u32 user_max)
1263{
struct intel_panel *panel = &connector->panel;

return scale(user_level, 0, user_max,
     panel->backlight.min, panel->backlight.max);
1268}

1270/* set backlight brightness to level in range [0..max], scaling wrt hw min */
1271static void intel_panel_set_backlight(const struct drm_connector_state *conn_state,
		      u32 user_level, u32 user_max)
1273{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 hw_level;

if (!panel->backlight.present)
return;

mutex_lock(&dev_priv->backlight_lock)rw_enter_write(&dev_priv->backlight_lock);

drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0)({ int __ret = !!((panel->backlight.max == 0)); if (__ret)
 printf("%s %s: " "%s", dev_driver_string(((&dev_priv->
drm))->dev), "", "drm_WARN_ON(" "panel->backlight.max == 0"
 ")"); __builtin_expect(!!(__ret), 0); });

hw_level = scale_user_to_hw(connector, user_level, user_max);
panel->backlight.level = hw_level;

if (panel->backlight.enabled)
intel_panel_actually_set_backlight(conn_state, hw_level);

mutex_unlock(&dev_priv->backlight_lock)rw_exit_write(&dev_priv->backlight_lock);
1293}

1295static int intel_backlight_device_update_status(struct backlight_device *bd)
1296{
struct intel_connector *connector = bl_get_data(bd)(bd)->data;
struct intel_panel *panel = &connector->panel;
struct drm_device *dev = connector->base.dev;

drm_modeset_lock(&dev->mode_config.connection_mutex, NULL((void *)0));
DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n",__drm_dbg(DRM_UT_KMS, "updating intel_backlight, brightness=%d/%d\n"
, bd->props.brightness, bd->props.max_brightness)
      bd->props.brightness, bd->props.max_brightness)__drm_dbg(DRM_UT_KMS, "updating intel_backlight, brightness=%d/%d\n"
, bd->props.brightness, bd->props.max_brightness);
intel_panel_set_backlight(connector->base.state, bd->props.brightness,
		  bd->props.max_brightness);

/*
* Allow flipping bl_power as a sub-state of enabled. Sadly the
* backlight class device does not make it easy to to differentiate
* between callbacks for brightness and bl_power, so our backlight_power
* callback needs to take this into account.
*/
if (panel->backlight.enabled) {
if (panel->backlight.power) {
	bool_Bool enable = bd->props.power == FB_BLANK_UNBLANK0 &&
		bd->props.brightness != 0;
	panel->backlight.power(connector, enable);
}
} else {
bd->props.power = FB_BLANK_POWERDOWN4;
}

drm_modeset_unlock(&dev->mode_config.connection_mutex);
return 0;
1325}

1327static int intel_backlight_device_get_brightness(struct backlight_device *bd)
1328{
struct intel_connector *connector = bl_get_data(bd)(bd)->data;
struct drm_device *dev = connector->base.dev;
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(dev);
intel_wakeref_t wakeref;
int ret = 0;

with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref)for ((wakeref) = intel_runtime_pm_get(&dev_priv->runtime_pm
); (wakeref); intel_runtime_pm_put((&dev_priv->runtime_pm
), (wakeref)), (wakeref) = 0) {
1
Loop condition is true.  Entering loop body→
u32 hw_level;

drm_modeset_lock(&dev->mode_config.connection_mutex, NULL((void *)0));

hw_level = intel_panel_get_backlight(connector);
ret = scale_hw_to_user(connector,
2
←
Calling 'scale_hw_to_user'→
		       hw_level, bd->props.max_brightness);

drm_modeset_unlock(&dev->mode_config.connection_mutex);
}

return ret;
1348}

1350static const struct backlight_ops intel_backlight_device_ops = {
.update_status = intel_backlight_device_update_status,
.get_brightness = intel_backlight_device_get_brightness,
1353};

1355int intel_backlight_device_register(struct intel_connector *connector)
1356{
struct drm_i915_privateinteldrm_softc *i915 = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
struct backlight_properties props;

if (WARN_ON(panel->backlight.device)({ int __ret = !!((panel->backlight.device)); if (__ret) printf
("%s", "WARN_ON(" "panel->backlight.device" ")"); __builtin_expect
(!!(__ret), 0); }))
return -ENODEV19;

if (!panel->backlight.present)
return 0;

WARN_ON(panel->backlight.max == 0)({ int __ret = !!((panel->backlight.max == 0)); if (__ret)
 printf("%s", "WARN_ON(" "panel->backlight.max == 0" ")");
 __builtin_expect(!!(__ret), 0); });

memset(&props, 0, sizeof(props))__builtin_memset((&props), (0), (sizeof(props)));
props.type = BACKLIGHT_RAW0;

/*
* Note: Everything should work even if the backlight device max
* presented to the userspace is arbitrarily chosen.
*/
props.max_brightness = panel->backlight.max;
props.brightness = scale_hw_to_user(connector,
			    panel->backlight.level,
			    props.max_brightness);

if (panel->backlight.enabled)
props.power = FB_BLANK_UNBLANK0;
else
props.power = FB_BLANK_POWERDOWN4;

/*
* Note: using the same name independent of the connector prevents
* registration of multiple backlight devices in the driver.
*/
panel->backlight.device =
backlight_device_register("intel_backlight",
			  connector->base.kdev,
			  connector,
			  &intel_backlight_device_ops, &props);

if (IS_ERR(panel->backlight.device)) {
drm_err(&i915->drm, "Failed to register backlight: %ld\n",printf("drm:pid%d:%s *ERROR* " "[drm] " "*ERROR* " "Failed to register backlight: %ld\n"
, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc->p_p->ps_pid, __func__ , PTR_ERR
(panel->backlight.device))
	PTR_ERR(panel->backlight.device))printf("drm:pid%d:%s *ERROR* " "[drm] " "*ERROR* " "Failed to register backlight: %ld\n"
, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc->p_p->ps_pid, __func__ , PTR_ERR
(panel->backlight.device));
panel->backlight.device = NULL((void *)0);
return -ENODEV19;
}

drm_dbg_kms(&i915->drm,drm_dev_dbg((&i915->drm)->dev, DRM_UT_KMS, "Connector %s backlight sysfs interface registered\n"
, connector->base.name)
    "Connector %s backlight sysfs interface registered\n",drm_dev_dbg((&i915->drm)->dev, DRM_UT_KMS, "Connector %s backlight sysfs interface registered\n"
, connector->base.name)
    connector->base.name)drm_dev_dbg((&i915->drm)->dev, DRM_UT_KMS, "Connector %s backlight sysfs interface registered\n"
, connector->base.name);

return 0;
1408}

1410void intel_backlight_device_unregister(struct intel_connector *connector)
1411{
struct intel_panel *panel = &connector->panel;

if (panel->backlight.device) {
backlight_device_unregister(panel->backlight.device);
panel->backlight.device = NULL((void *)0);
}
1418}
1419#endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */

1421/*
* CNP: PWM clock frequency is 19.2 MHz or 24 MHz.
*      PWM increment = 1
*/
1425static u32 cnp_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1426{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);

return DIV_ROUND_CLOSEST(KHz(RUNTIME_INFO(dev_priv)->rawclk_freq),((((1000 * ((&(dev_priv)->__runtime)->rawclk_freq))
) + ((pwm_freq_hz) / 2)) / (pwm_freq_hz))
		 pwm_freq_hz)((((1000 * ((&(dev_priv)->__runtime)->rawclk_freq))
) + ((pwm_freq_hz) / 2)) / (pwm_freq_hz));
1431}

1433/*
* BXT: PWM clock frequency = 19.2 MHz.
*/
1436static u32 bxt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1437{
return DIV_ROUND_CLOSEST(KHz(19200), pwm_freq_hz)((((1000 * (19200))) + ((pwm_freq_hz) / 2)) / (pwm_freq_hz));
1439}

1441/*
* SPT: This value represents the period of the PWM stream in clock periods
* multiplied by 16 (default increment) or 128 (alternate increment selected in
* SCHICKEN_1 bit 0). PWM clock is 24 MHz.
*/
1446static u32 spt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1447{
struct intel_panel *panel = &connector->panel;
u32 mul;

if (panel->backlight.alternate_pwm_increment)
mul = 128;
else
mul = 16;

return DIV_ROUND_CLOSEST(MHz(24), pwm_freq_hz * mul)((((1000 * (1000 * (24)))) + ((pwm_freq_hz * mul) / 2)) / (pwm_freq_hz
 * mul));
1457}

1459/*
* LPT: This value represents the period of the PWM stream in clock periods
* multiplied by 128 (default increment) or 16 (alternate increment, selected in
* LPT SOUTH_CHICKEN2 register bit 5).
*/
1464static u32 lpt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1465{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 mul, clock;

if (panel->backlight.alternate_pwm_increment)
mul = 16;
else
mul = 128;

if (HAS_PCH_LPT_H(dev_priv)(((dev_priv)->pch_id) == 0x8c00 || ((dev_priv)->pch_id)
 == 0x8c80))
clock = MHz(135)(1000 * (1000 * (135))); /* LPT:H */
else
clock = MHz(24)(1000 * (1000 * (24))); /* LPT:LP */

return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * mul)(((clock) + ((pwm_freq_hz * mul) / 2)) / (pwm_freq_hz * mul));
1481}

1483/*
* ILK/SNB/IVB: This value represents the period of the PWM stream in PCH
* display raw clocks multiplied by 128.
*/
1487static u32 pch_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1488{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);

return DIV_ROUND_CLOSEST(KHz(RUNTIME_INFO(dev_priv)->rawclk_freq),((((1000 * ((&(dev_priv)->__runtime)->rawclk_freq))
) + ((pwm_freq_hz * 128) / 2)) / (pwm_freq_hz * 128))
		 pwm_freq_hz * 128)((((1000 * ((&(dev_priv)->__runtime)->rawclk_freq))
) + ((pwm_freq_hz * 128) / 2)) / (pwm_freq_hz * 128));
1493}

1495/*
* Gen2: This field determines the number of time base events (display core
* clock frequency/32) in total for a complete cycle of modulated backlight
* control.
*
* Gen3: A time base event equals the display core clock ([DevPNV] HRAW clock)
* divided by 32.
*/
1503static u32 i9xx_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1504{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
int clock;

if (IS_PINEVIEW(dev_priv)IS_PLATFORM(dev_priv, INTEL_PINEVIEW))
clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq)(1000 * ((&(dev_priv)->__runtime)->rawclk_freq));
else
clock = KHz(dev_priv->cdclk.hw.cdclk)(1000 * (dev_priv->cdclk.hw.cdclk));

return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * 32)(((clock) + ((pwm_freq_hz * 32) / 2)) / (pwm_freq_hz * 32));
1514}

1516/*
* Gen4: This value represents the period of the PWM stream in display core
* clocks ([DevCTG] HRAW clocks) multiplied by 128.
*
*/
1521static u32 i965_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1522{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
int clock;

if (IS_G4X(dev_priv)(IS_PLATFORM(dev_priv, INTEL_G45) || IS_PLATFORM(dev_priv, INTEL_GM45
)))
clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq)(1000 * ((&(dev_priv)->__runtime)->rawclk_freq));
else
clock = KHz(dev_priv->cdclk.hw.cdclk)(1000 * (dev_priv->cdclk.hw.cdclk));

return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * 128)(((clock) + ((pwm_freq_hz * 128) / 2)) / (pwm_freq_hz * 128));
1532}

1534/*
* VLV: This value represents the period of the PWM stream in display core
* clocks ([DevCTG] 200MHz HRAW clocks) multiplied by 128 or 25MHz S0IX clocks
* multiplied by 16. CHV uses a 19.2MHz S0IX clock.
*/
1539static u32 vlv_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1540{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
int mul, clock;

if ((intel_de_read(dev_priv, CBR1_VLV((const i915_reg_t){ .reg = (0x180000 + 0x70400) })) & CBR_PWM_CLOCK_MUX_SELECT(1 << 30)) == 0) {
if (IS_CHERRYVIEW(dev_priv)IS_PLATFORM(dev_priv, INTEL_CHERRYVIEW))
	clock = KHz(19200)(1000 * (19200));
else
	clock = MHz(25)(1000 * (1000 * (25)));
mul = 16;
} else {
clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq)(1000 * ((&(dev_priv)->__runtime)->rawclk_freq));
mul = 128;
}

return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * mul)(((clock) + ((pwm_freq_hz * mul) / 2)) / (pwm_freq_hz * mul));
1556}

1558static u16 get_vbt_pwm_freq(struct drm_i915_privateinteldrm_softc *dev_priv)
1559{
u16 pwm_freq_hz = dev_priv->vbt.backlight.pwm_freq_hz;

if (pwm_freq_hz) {
drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "VBT defined backlight frequency %u Hz\n"
, pwm_freq_hz)
	    "VBT defined backlight frequency %u Hz\n",drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "VBT defined backlight frequency %u Hz\n"
, pwm_freq_hz)
	    pwm_freq_hz)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "VBT defined backlight frequency %u Hz\n"
, pwm_freq_hz);
} else {
pwm_freq_hz = 200;
drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "default backlight frequency %u Hz\n"
, pwm_freq_hz)
	    "default backlight frequency %u Hz\n",drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "default backlight frequency %u Hz\n"
, pwm_freq_hz)
	    pwm_freq_hz)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "default backlight frequency %u Hz\n"
, pwm_freq_hz);
}

return pwm_freq_hz;
1574}

1576static u32 get_backlight_max_vbt(struct intel_connector *connector)
1577{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u16 pwm_freq_hz = get_vbt_pwm_freq(dev_priv);
u32 pwm;

if (!panel->backlight.hz_to_pwm) {
drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "backlight frequency conversion not supported\n"
)
	    "backlight frequency conversion not supported\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "backlight frequency conversion not supported\n"
);
return 0;
}

pwm = panel->backlight.hz_to_pwm(connector, pwm_freq_hz);
if (!pwm) {
drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "backlight frequency conversion failed\n"
)
	    "backlight frequency conversion failed\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "backlight frequency conversion failed\n"
);
return 0;
}

return pwm;
1597}

1599/*
* Note: The setup hooks can't assume pipe is set!
*/
1602static u32 get_backlight_min_vbt(struct intel_connector *connector)
1603{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
int min;

drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0)({ int __ret = !!((panel->backlight.max == 0)); if (__ret)
 printf("%s %s: " "%s", dev_driver_string(((&dev_priv->
drm))->dev), "", "drm_WARN_ON(" "panel->backlight.max == 0"
 ")"); __builtin_expect(!!(__ret), 0); });

/*
* XXX: If the vbt value is 255, it makes min equal to max, which leads
* to problems. There are such machines out there. Either our
* interpretation is wrong or the vbt has bogus data. Or both. Safeguard
* against this by letting the minimum be at most (arbitrarily chosen)
* 25% of the max.
*/
min = clamp_t(int, dev_priv->vbt.backlight.min_brightness, 0, 64)({ int __min_a = (({ int __max_a = (dev_priv->vbt.backlight
.min_brightness); int __max_b = (0); __max_a > __max_b ? __max_a
 : __max_b; })); int __min_b = (64); __min_a < __min_b ? __min_a
 : __min_b; });
if (min != dev_priv->vbt.backlight.min_brightness) {
drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "clamping VBT min backlight %d/255 to %d/255\n"
, dev_priv->vbt.backlight.min_brightness, min)
	    "clamping VBT min backlight %d/255 to %d/255\n",drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "clamping VBT min backlight %d/255 to %d/255\n"
, dev_priv->vbt.backlight.min_brightness, min)
	    dev_priv->vbt.backlight.min_brightness, min)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "clamping VBT min backlight %d/255 to %d/255\n"
, dev_priv->vbt.backlight.min_brightness, min);
}

/* vbt value is a coefficient in range [0..255] */
return scale(min, 0, 255, 0, panel->backlight.max);
1626}

1628static int lpt_setup_backlight(struct intel_connector *connector, enum pipe unused)
1629{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 cpu_ctl2, pch_ctl1, pch_ctl2, val;
bool_Bool alt, cpu_mode;

if (HAS_PCH_LPT(dev_priv)(((dev_priv)->pch_type) == PCH_LPT))
alt = intel_de_read(dev_priv, SOUTH_CHICKEN2((const i915_reg_t){ .reg = (0xc2004) })) & LPT_PWM_GRANULARITY(1 << 5);
else
alt = intel_de_read(dev_priv, SOUTH_CHICKEN1((const i915_reg_t){ .reg = (0xc2000) })) & SPT_PWM_GRANULARITY(1 << 0);
panel->backlight.alternate_pwm_increment = alt;

pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }));
panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY(1 << 29);

pch_ctl2 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2((const i915_reg_t){ .reg = (0xc8254) }));
panel->backlight.max = pch_ctl2 >> 16;

cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }));

if (!panel->backlight.max)
panel->backlight.max = get_backlight_max_vbt(connector);

if (!panel->backlight.max)
return -ENODEV19;

panel->backlight.min = get_backlight_min_vbt(connector);

panel->backlight.enabled = pch_ctl1 & BLM_PCH_PWM_ENABLE(1 << 31);

cpu_mode = panel->backlight.enabled && HAS_PCH_LPT(dev_priv)(((dev_priv)->pch_type) == PCH_LPT) &&
   !(pch_ctl1 & BLM_PCH_OVERRIDE_ENABLE(1 << 30)) &&
   (cpu_ctl2 & BLM_PWM_ENABLE(1 << 31));
if (cpu_mode)
val = pch_get_backlight(connector);
else
val = lpt_get_backlight(connector);

if (cpu_mode) {
drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "CPU backlight register was enabled, switching to PCH override\n"
)
	    "CPU backlight register was enabled, switching to PCH override\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "CPU backlight register was enabled, switching to PCH override\n"
);

/* Write converted CPU PWM value to PCH override register */
lpt_set_backlight(connector->base.state, val);
intel_de_write(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }),
	       pch_ctl1 | BLM_PCH_OVERRIDE_ENABLE(1 << 30));

intel_de_write(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }),
	       cpu_ctl2 & ~BLM_PWM_ENABLE(1 << 31));
}

val = intel_panel_compute_brightness(connector, val);
panel->backlight.level = clamp(val, panel->backlight.min,({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; })
		       panel->backlight.max)({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; });

return 0;
1685}

1687static int pch_setup_backlight(struct intel_connector *connector, enum pipe unused)
1688{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 cpu_ctl2, pch_ctl1, pch_ctl2, val;

pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1((const i915_reg_t){ .reg = (0xc8250) }));
panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY(1 << 29);

pch_ctl2 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2((const i915_reg_t){ .reg = (0xc8254) }));
panel->backlight.max = pch_ctl2 >> 16;

if (!panel->backlight.max)
panel->backlight.max = get_backlight_max_vbt(connector);

if (!panel->backlight.max)
return -ENODEV19;

panel->backlight.min = get_backlight_min_vbt(connector);

val = pch_get_backlight(connector);
val = intel_panel_compute_brightness(connector, val);
panel->backlight.level = clamp(val, panel->backlight.min,({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; })
		       panel->backlight.max)({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; });

cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2((const i915_reg_t){ .reg = (0x48250) }));
panel->backlight.enabled = (cpu_ctl2 & BLM_PWM_ENABLE(1 << 31)) &&
(pch_ctl1 & BLM_PCH_PWM_ENABLE(1 << 31));

return 0;
1717}

1719static int i9xx_setup_backlight(struct intel_connector *connector, enum pipe unused)
1720{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 ctl, val;

ctl = intel_de_read(dev_priv, BLC_PWM_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61254) }));

if (IS_GEN(dev_priv, 2)(0 + (&(dev_priv)->__info)->gen == (2)) || IS_I915GM(dev_priv)IS_PLATFORM(dev_priv, INTEL_I915GM) || IS_I945GM(dev_priv)IS_PLATFORM(dev_priv, INTEL_I945GM))
panel->backlight.combination_mode = ctl & BLM_LEGACY_MODE(1 << 16);

if (IS_PINEVIEW(dev_priv)IS_PLATFORM(dev_priv, INTEL_PINEVIEW))
panel->backlight.active_low_pwm = ctl & BLM_POLARITY_PNV(1 << 0);

panel->backlight.max = ctl >> 17;

if (!panel->backlight.max) {
panel->backlight.max = get_backlight_max_vbt(connector);
panel->backlight.max >>= 1;
}

if (!panel->backlight.max)
return -ENODEV19;

if (panel->backlight.combination_mode)
panel->backlight.max *= 0xff;

panel->backlight.min = get_backlight_min_vbt(connector);

val = i9xx_get_backlight(connector);
val = intel_panel_compute_brightness(connector, val);
panel->backlight.level = clamp(val, panel->backlight.min,({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; })
		       panel->backlight.max)({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; });

panel->backlight.enabled = val != 0;

return 0;
1756}

1758static int i965_setup_backlight(struct intel_connector *connector, enum pipe unused)
1759{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 ctl, ctl2, val;

ctl2 = intel_de_read(dev_priv, BLC_PWM_CTL2((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61250) }));
panel->backlight.combination_mode = ctl2 & BLM_COMBINATION_MODE(1 << 30);
panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965(1 << 28);

ctl = intel_de_read(dev_priv, BLC_PWM_CTL((const i915_reg_t){ .reg = (((&(dev_priv)->__info)->
display_mmio_offset) + 0x61254) }));
panel->backlight.max = ctl >> 16;

if (!panel->backlight.max)
panel->backlight.max = get_backlight_max_vbt(connector);

if (!panel->backlight.max)
return -ENODEV19;

if (panel->backlight.combination_mode)
panel->backlight.max *= 0xff;

panel->backlight.min = get_backlight_min_vbt(connector);

val = i9xx_get_backlight(connector);
val = intel_panel_compute_brightness(connector, val);
panel->backlight.level = clamp(val, panel->backlight.min,({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; })
		       panel->backlight.max)({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; });

panel->backlight.enabled = ctl2 & BLM_PWM_ENABLE(1 << 31);

return 0;
1790}

1792static int vlv_setup_backlight(struct intel_connector *connector, enum pipe pipe)
1793{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 ctl, ctl2, val;

if (drm_WARN_ON(&dev_priv->drm, pipe != PIPE_A && pipe != PIPE_B)({ int __ret = !!((pipe != PIPE_A && pipe != PIPE_B))
; if (__ret) printf("%s %s: " "%s", dev_driver_string(((&
dev_priv->drm))->dev), "", "drm_WARN_ON(" "pipe != PIPE_A && pipe != PIPE_B"
 ")"); __builtin_expect(!!(__ret), 0); }))
return -ENODEV19;

ctl2 = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61250)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61350)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61250))))
) }));
panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965(1 << 28);

ctl = intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)((const i915_reg_t){ .reg = ((((((&(dev_priv)->__info)
->display_mmio_offset) + 0x61254)) + (pipe) * (((((&(dev_priv
)->__info)->display_mmio_offset) + 0x61354)) - ((((&
(dev_priv)->__info)->display_mmio_offset) + 0x61254))))
) }));
panel->backlight.max = ctl >> 16;

if (!panel->backlight.max)
panel->backlight.max = get_backlight_max_vbt(connector);

if (!panel->backlight.max)
return -ENODEV19;

panel->backlight.min = get_backlight_min_vbt(connector);

val = _vlv_get_backlight(dev_priv, pipe);
val = intel_panel_compute_brightness(connector, val);
panel->backlight.level = clamp(val, panel->backlight.min,({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; })
		       panel->backlight.max)({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; });

panel->backlight.enabled = ctl2 & BLM_PWM_ENABLE(1 << 31);

return 0;
1823}

1825static int
1826bxt_setup_backlight(struct intel_connector *connector, enum pipe unused)
1827{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 pwm_ctl, val;

panel->backlight.controller = dev_priv->vbt.backlight.controller;

pwm_ctl = intel_de_read(dev_priv,
		BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }));

/* Controller 1 uses the utility pin. */
if (panel->backlight.controller == 1) {
val = intel_de_read(dev_priv, UTIL_PIN_CTL((const i915_reg_t){ .reg = (0x48400) }));
panel->backlight.util_pin_active_low =
			val & UTIL_PIN_POLARITY(1 << 22);
}

panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY(1 << 29);
panel->backlight.max =
intel_de_read(dev_priv,
	      BXT_BLC_PWM_FREQ(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8254) + (panel->backlight
.controller) * ((0xC8354) - (0xC8254)))) }));

if (!panel->backlight.max)
panel->backlight.max = get_backlight_max_vbt(connector);

if (!panel->backlight.max)
return -ENODEV19;

panel->backlight.min = get_backlight_min_vbt(connector);

val = bxt_get_backlight(connector);
val = intel_panel_compute_brightness(connector, val);
panel->backlight.level = clamp(val, panel->backlight.min,({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; })
		       panel->backlight.max)({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; });

panel->backlight.enabled = pwm_ctl & BXT_BLC_PWM_ENABLE(1 << 31);

return 0;
1865}

1867static int
1868cnp_setup_backlight(struct intel_connector *connector, enum pipe unused)
1869{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;
u32 pwm_ctl, val;

/*
* CNP has the BXT implementation of backlight, but with only one
* controller. TODO: ICP has multiple controllers but we only use
* controller 0 for now.
*/
panel->backlight.controller = 0;

pwm_ctl = intel_de_read(dev_priv,
		BXT_BLC_PWM_CTL(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8250) + (panel->backlight
.controller) * ((0xC8350) - (0xC8250)))) }));

panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY(1 << 29);
panel->backlight.max =
intel_de_read(dev_priv,
	      BXT_BLC_PWM_FREQ(panel->backlight.controller)((const i915_reg_t){ .reg = (((0xC8254) + (panel->backlight
.controller) * ((0xC8354) - (0xC8254)))) }));

if (!panel->backlight.max)
panel->backlight.max = get_backlight_max_vbt(connector);

if (!panel->backlight.max)
return -ENODEV19;

panel->backlight.min = get_backlight_min_vbt(connector);

val = bxt_get_backlight(connector);
val = intel_panel_compute_brightness(connector, val);
panel->backlight.level = clamp(val, panel->backlight.min,({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; })
		       panel->backlight.max)({ __typeof(val) __min_a = (({ __typeof(val) __max_a = (val);
 __typeof(val) __max_b = (panel->backlight.min); __max_a >
 __max_b ? __max_a : __max_b; })); __typeof(val) __min_b = (panel
->backlight.max); __min_a < __min_b ? __min_a : __min_b
; });

panel->backlight.enabled = pwm_ctl & BXT_BLC_PWM_ENABLE(1 << 31);

return 0;
1905}

1907static int pwm_setup_backlight(struct intel_connector *connector,
	       enum pipe pipe)
1909{
struct drm_device *dev = connector->base.dev;
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(dev);
struct intel_panel *panel = &connector->panel;
const char *desc;
u32 level;

/* Get the right PWM chip for DSI backlight according to VBT */
if (dev_priv->vbt.dsi.config->pwm_blc == PPS_BLC_PMIC0) {
panel->backlight.pwm = pwm_get(dev->dev, "pwm_pmic_backlight");
desc = "PMIC";
} else {
panel->backlight.pwm = pwm_get(dev->dev, "pwm_soc_backlight");
desc = "SoC";
}

if (IS_ERR(panel->backlight.pwm)) {
drm_err(&dev_priv->drm, "Failed to get the %s PWM chip\n",printf("drm:pid%d:%s *ERROR* " "[drm] " "*ERROR* " "Failed to get the %s PWM chip\n"
, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc->p_p->ps_pid, __func__ , desc)
	desc)printf("drm:pid%d:%s *ERROR* " "[drm] " "*ERROR* " "Failed to get the %s PWM chip\n"
, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc->p_p->ps_pid, __func__ , desc);
panel->backlight.pwm = NULL((void *)0);
return -ENODEV19;
}

panel->backlight.max = 100; /* 100% */
panel->backlight.min = get_backlight_min_vbt(connector);

1935#ifdef notyet
if (pwm_is_enabled(panel->backlight.pwm)) {
/* PWM is already enabled, use existing settings */
pwm_get_state(panel->backlight.pwm, &panel->backlight.pwm_state);

level = pwm_get_relative_duty_cycle(&panel->backlight.pwm_state,
				    100);
level = intel_panel_compute_brightness(connector, level);
panel->backlight.level = clamp(level, panel->backlight.min,({ __typeof(level) __min_a = (({ __typeof(level) __max_a = (level
); __typeof(level) __max_b = (panel->backlight.min); __max_a
 > __max_b ? __max_a : __max_b; })); __typeof(level) __min_b
 = (panel->backlight.max); __min_a < __min_b ? __min_a :
 __min_b; })
			       panel->backlight.max)({ __typeof(level) __min_a = (({ __typeof(level) __max_a = (level
); __typeof(level) __max_b = (panel->backlight.min); __max_a
 > __max_b ? __max_a : __max_b; })); __typeof(level) __min_b
 = (panel->backlight.max); __min_a < __min_b ? __min_a :
 __min_b; });
panel->backlight.enabled = true1;

drm_dbg_kms(&dev_priv->drm, "PWM already enabled at freq %ld, VBT freq %d, level %d\n",drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "PWM already enabled at freq %ld, VBT freq %d, level %d\n"
, 1000000000L / (unsigned long)panel->backlight.pwm_state.
period, get_vbt_pwm_freq(dev_priv), level)
	    NSEC_PER_SEC / (unsigned long)panel->backlight.pwm_state.period,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "PWM already enabled at freq %ld, VBT freq %d, level %d\n"
, 1000000000L / (unsigned long)panel->backlight.pwm_state.
period, get_vbt_pwm_freq(dev_priv), level)
	    get_vbt_pwm_freq(dev_priv), level)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "PWM already enabled at freq %ld, VBT freq %d, level %d\n"
, 1000000000L / (unsigned long)panel->backlight.pwm_state.
period, get_vbt_pwm_freq(dev_priv), level);
} else {
/* Set period from VBT frequency, leave other settings at 0. */
panel->backlight.pwm_state.period =
	NSEC_PER_SEC1000000000L / get_vbt_pwm_freq(dev_priv);
}
1955#else
STUB()do { printf("%s: stub\n", __func__); } while(0);
1957#endif

drm_info(&dev_priv->drm, "Using %s PWM for LCD backlight control\n",do { } while(0)
 desc)do { } while(0);
return 0;
1962}

1964void intel_panel_update_backlight(struct intel_atomic_state *state,
		  struct intel_encoder *encoder,
		  const struct intel_crtc_state *crtc_state,
		  const struct drm_connector_state *conn_state)
1968{
struct intel_connector *connector = to_intel_connector(conn_state->connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (conn_state->connector); (struct intel_connector *
)( (char *)__mptr - __builtin_offsetof(struct intel_connector
, base) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);
struct intel_panel *panel = &connector->panel;

if (!panel->backlight.present)
return;

mutex_lock(&dev_priv->backlight_lock)rw_enter_write(&dev_priv->backlight_lock);
if (!panel->backlight.enabled)
__intel_panel_enable_backlight(crtc_state, conn_state);

mutex_unlock(&dev_priv->backlight_lock)rw_exit_write(&dev_priv->backlight_lock);
1981}

1983int intel_panel_setup_backlight(struct drm_connector *connector, enum pipe pipe)
1984{
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->dev);
struct intel_connector *intel_connector = to_intel_connector(connector)({ const __typeof( ((struct intel_connector *)0)->base ) *
__mptr = (connector); (struct intel_connector *)( (char *)__mptr
 - __builtin_offsetof(struct intel_connector, base) );});
struct intel_panel *panel = &intel_connector->panel;
int ret;

if (!dev_priv->vbt.backlight.present) {
if (dev_priv->quirks & QUIRK_BACKLIGHT_PRESENT(1<<3)) {
	drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "no backlight present per VBT, but present per quirk\n"
)
		    "no backlight present per VBT, but present per quirk\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "no backlight present per VBT, but present per quirk\n"
);
} else {
	drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "no backlight present per VBT\n"
)
		    "no backlight present per VBT\n")drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "no backlight present per VBT\n"
);
	return 0;
}
}

/* ensure intel_panel has been initialized first */
if (drm_WARN_ON(&dev_priv->drm, !panel->backlight.setup)({ int __ret = !!((!panel->backlight.setup)); if (__ret) printf
("%s %s: " "%s", dev_driver_string(((&dev_priv->drm))->
dev), "", "drm_WARN_ON(" "!panel->backlight.setup" ")"); __builtin_expect
(!!(__ret), 0); }))
return -ENODEV19;

/* set level and max in panel struct */
mutex_lock(&dev_priv->backlight_lock)rw_enter_write(&dev_priv->backlight_lock);
ret = panel->backlight.setup(intel_connector, pipe);
mutex_unlock(&dev_priv->backlight_lock)rw_exit_write(&dev_priv->backlight_lock);

if (ret) {
drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "failed to setup backlight for connector %s\n"
, connector->name)
	    "failed to setup backlight for connector %s\n",drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "failed to setup backlight for connector %s\n"
, connector->name)
	    connector->name)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "failed to setup backlight for connector %s\n"
, connector->name);
return ret;
}

panel->backlight.present = true1;

drm_dbg_kms(&dev_priv->drm,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "Connector %s backlight initialized, %s, brightness %u/%u\n"
, connector->name, enableddisabled(panel->backlight.enabled
), panel->backlight.level, panel->backlight.max)
    "Connector %s backlight initialized, %s, brightness %u/%u\n",drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "Connector %s backlight initialized, %s, brightness %u/%u\n"
, connector->name, enableddisabled(panel->backlight.enabled
), panel->backlight.level, panel->backlight.max)
    connector->name,drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "Connector %s backlight initialized, %s, brightness %u/%u\n"
, connector->name, enableddisabled(panel->backlight.enabled
), panel->backlight.level, panel->backlight.max)
    enableddisabled(panel->backlight.enabled),drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "Connector %s backlight initialized, %s, brightness %u/%u\n"
, connector->name, enableddisabled(panel->backlight.enabled
), panel->backlight.level, panel->backlight.max)
    panel->backlight.level, panel->backlight.max)drm_dev_dbg((&dev_priv->drm)->dev, DRM_UT_KMS, "Connector %s backlight initialized, %s, brightness %u/%u\n"
, connector->name, enableddisabled(panel->backlight.enabled
), panel->backlight.level, panel->backlight.max);

return 0;
2026}

2028static void intel_panel_destroy_backlight(struct intel_panel *panel)
2029{
/* dispose of the pwm */
if (panel->backlight.pwm)
pwm_put(panel->backlight.pwm);

panel->backlight.present = false0;
2035}

2037/* Set up chip specific backlight functions */
2038static void
2039intel_panel_init_backlight_funcs(struct intel_panel *panel)
2040{
struct intel_connector *connector =
container_of(panel, struct intel_connector, panel)({ const __typeof( ((struct intel_connector *)0)->panel ) *
__mptr = (panel); (struct intel_connector *)( (char *)__mptr -
 __builtin_offsetof(struct intel_connector, panel) );});
struct drm_i915_privateinteldrm_softc *dev_priv = to_i915(connector->base.dev);

if (connector->base.connector_type == DRM_MODE_CONNECTOR_eDP14 &&
   intel_dp_aux_init_backlight_funcs(connector) == 0)
return;

if (connector->base.connector_type == DRM_MODE_CONNECTOR_DSI16 &&
   intel_dsi_dcs_init_backlight_funcs(connector) == 0)
return;

if (IS_GEN9_LP(dev_priv)((0 + (&(dev_priv)->__info)->gen == (9)) &&
 ((&(dev_priv)->__info)->is_lp))) {
panel->backlight.setup = bxt_setup_backlight;
panel->backlight.enable = bxt_enable_backlight;
panel->backlight.disable = bxt_disable_backlight;
panel->backlight.set = bxt_set_backlight;
panel->backlight.get = bxt_get_backlight;
panel->backlight.hz_to_pwm = bxt_hz_to_pwm;
} else if (INTEL_PCH_TYPE(dev_priv)((dev_priv)->pch_type) >= PCH_CNP) {
panel->backlight.setup = cnp_setup_backlight;
panel->backlight.enable = cnp_enable_backlight;
panel->backlight.disable = cnp_disable_backlight;
panel->backlight.set = bxt_set_backlight;
panel->backlight.get = bxt_get_backlight;
panel->backlight.hz_to_pwm = cnp_hz_to_pwm;
} else if (INTEL_PCH_TYPE(dev_priv)((dev_priv)->pch_type) >= PCH_LPT) {
panel->backlight.setup = lpt_setup_backlight;
panel->backlight.enable = lpt_enable_backlight;
panel->backlight.disable = lpt_disable_backlight;
panel->backlight.set = lpt_set_backlight;
panel->backlight.get = lpt_get_backlight;
if (HAS_PCH_LPT(dev_priv)(((dev_priv)->pch_type) == PCH_LPT))
	panel->backlight.hz_to_pwm = lpt_hz_to_pwm;
else
	panel->backlight.hz_to_pwm = spt_hz_to_pwm;
} else if (HAS_PCH_SPLIT(dev_priv)(((dev_priv)->pch_type) != PCH_NONE)) {
panel->backlight.setup = pch_setup_backlight;
panel->backlight.enable = pch_enable_backlight;
panel->backlight.disable = pch_disable_backlight;
panel->backlight.set = pch_set_backlight;
panel->backlight.get = pch_get_backlight;
panel->backlight.hz_to_pwm = pch_hz_to_pwm;
} else if (IS_VALLEYVIEW(dev_priv)IS_PLATFORM(dev_priv, INTEL_VALLEYVIEW) || IS_CHERRYVIEW(dev_priv)IS_PLATFORM(dev_priv, INTEL_CHERRYVIEW)) {
if (connector->base.connector_type == DRM_MODE_CONNECTOR_DSI16) {
	panel->backlight.setup = pwm_setup_backlight;
	panel->backlight.enable = pwm_enable_backlight;
	panel->backlight.disable = pwm_disable_backlight;
	panel->backlight.set = pwm_set_backlight;
	panel->backlight.get = pwm_get_backlight;
} else {
	panel->backlight.setup = vlv_setup_backlight;
	panel->backlight.enable = vlv_enable_backlight;
	panel->backlight.disable = vlv_disable_backlight;
	panel->backlight.set = vlv_set_backlight;
	panel->backlight.get = vlv_get_backlight;
	panel->backlight.hz_to_pwm = vlv_hz_to_pwm;
}
} else if (IS_GEN(dev_priv, 4)(0 + (&(dev_priv)->__info)->gen == (4))) {
panel->backlight.setup = i965_setup_backlight;
panel->backlight.enable = i965_enable_backlight;
panel->backlight.disable = i965_disable_backlight;
panel->backlight.set = i9xx_set_backlight;
panel->backlight.get = i9xx_get_backlight;
panel->backlight.hz_to_pwm = i965_hz_to_pwm;
} else {
panel->backlight.setup = i9xx_setup_backlight;
panel->backlight.enable = i9xx_enable_backlight;
panel->backlight.disable = i9xx_disable_backlight;
panel->backlight.set = i9xx_set_backlight;
panel->backlight.get = i9xx_get_backlight;
panel->backlight.hz_to_pwm = i9xx_hz_to_pwm;
}
2114}

2116enum drm_connector_status
2117intel_panel_detect(struct drm_connector *connector, bool_Bool force)
2118{
struct drm_i915_privateinteldrm_softc *i915 = to_i915(connector->dev);

if (!INTEL_DISPLAY_ENABLED(i915)(({ int __ret = !!((!((&(i915)->__info)->pipe_mask !=
 0))); if (__ret) printf("%s %s: " "%s", dev_driver_string(((
&(i915)->drm))->dev), "", "drm_WARN_ON(" "!((&(i915)->__info)->pipe_mask != 0)"
 ")"); __builtin_expect(!!(__ret), 0); }), !(i915)->params
.disable_display))
return connector_status_disconnected;

return connector_status_connected;
2125}

2127int intel_panel_init(struct intel_panel *panel,
     struct drm_display_mode *fixed_mode,
     struct drm_display_mode *downclock_mode)
2130{
intel_panel_init_backlight_funcs(panel);

panel->fixed_mode = fixed_mode;
panel->downclock_mode = downclock_mode;

return 0;
2137}

2139void intel_panel_fini(struct intel_panel *panel)
2140{
struct intel_connector *intel_connector =
container_of(panel, struct intel_connector, panel)({ const __typeof( ((struct intel_connector *)0)->panel ) *
__mptr = (panel); (struct intel_connector *)( (char *)__mptr -
 __builtin_offsetof(struct intel_connector, panel) );});

intel_panel_destroy_backlight(panel);

if (panel->fixed_mode)
drm_mode_destroy(intel_connector->base.dev, panel->fixed_mode);

if (panel->downclock_mode)
drm_mode_destroy(intel_connector->base.dev,
		panel->downclock_mode);
2152}