1/*
   2 * Copyright © 2006-2010 Intel Corporation
   3 * Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
   4 *
   5 * Permission is hereby granted, free of charge, to any person obtaining a
   6 * copy of this software and associated documentation files (the "Software"),
   7 * to deal in the Software without restriction, including without limitation
   8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9 * and/or sell copies of the Software, and to permit persons to whom the
  10 * Software is furnished to do so, subject to the following conditions:
  11 *
  12 * The above copyright notice and this permission notice (including the next
  13 * paragraph) shall be included in all copies or substantial portions of the
  14 * Software.
  15 *
  16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22 * DEALINGS IN THE SOFTWARE.
  23 *
  24 * Authors:
  25 *	Eric Anholt <eric@anholt.net>
  26 *      Dave Airlie <airlied@linux.ie>
  27 *      Jesse Barnes <jesse.barnes@intel.com>
  28 *      Chris Wilson <chris@chris-wilson.co.uk>
  29 */
  30
  31#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  32
  33#include <linux/kernel.h>
  34#include <linux/moduleparam.h>
  35#include <linux/pwm.h>
  36
 
 
 
 
  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"
 
 
  42
  43#define CRC_PMIC_PWM_PERIOD_NS	21333
 
 
 
 
 
 
  44
  45void
  46intel_fixed_panel_mode(const struct drm_display_mode *fixed_mode,
  47		       struct drm_display_mode *adjusted_mode)
  48{
  49	drm_mode_copy(adjusted_mode, fixed_mode);
 
 
  50
  51	drm_mode_set_crtcinfo(adjusted_mode, 0);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  52}
  53
  54static bool is_downclock_mode(const struct drm_display_mode *downclock_mode,
  55			      const struct drm_display_mode *fixed_mode)
 
  56{
  57	return drm_mode_match(downclock_mode, fixed_mode,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  58			      DRM_MODE_MATCH_TIMINGS |
  59			      DRM_MODE_MATCH_FLAGS |
  60			      DRM_MODE_MATCH_3D_FLAGS) &&
  61		downclock_mode->clock < fixed_mode->clock;
  62}
  63
  64struct drm_display_mode *
  65intel_panel_edid_downclock_mode(struct intel_connector *connector,
  66				const struct drm_display_mode *fixed_mode)
  67{
  68	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
  69	const struct drm_display_mode *scan, *best_mode = NULL;
  70	struct drm_display_mode *downclock_mode;
  71	int best_clock = fixed_mode->clock;
  72
  73	list_for_each_entry(scan, &connector->base.probed_modes, head) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  74		/*
  75		 * If one mode has the same resolution with the fixed_panel
  76		 * mode while they have the different refresh rate, it means
  77		 * that the reduced downclock is found. In such
  78		 * case we can set the different FPx0/1 to dynamically select
  79		 * between low and high frequency.
  80		 */
  81		if (is_downclock_mode(scan, fixed_mode) &&
  82		    scan->clock < best_clock) {
  83			/*
  84			 * The downclock is already found. But we
  85			 * expect to find the lower downclock.
  86			 */
  87			best_clock = scan->clock;
  88			best_mode = scan;
  89		}
  90	}
  91
  92	if (!best_mode)
  93		return NULL;
  94
  95	downclock_mode = drm_mode_duplicate(&dev_priv->drm, best_mode);
  96	if (!downclock_mode)
  97		return NULL;
 
  98
  99	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] using downclock mode from EDID: ",
 100		      connector->base.base.id, connector->base.name);
 101	drm_mode_debug_printmodeline(downclock_mode);
 102
 103	return downclock_mode;
 104}
 105
 106struct drm_display_mode *
 107intel_panel_edid_fixed_mode(struct intel_connector *connector)
 108{
 109	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 110	const struct drm_display_mode *scan;
 111	struct drm_display_mode *fixed_mode;
 112
 113	if (list_empty(&connector->base.probed_modes))
 114		return NULL;
 115
 116	/* prefer fixed mode from EDID if available */
 117	list_for_each_entry(scan, &connector->base.probed_modes, head) {
 118		if ((scan->type & DRM_MODE_TYPE_PREFERRED) == 0)
 119			continue;
 120
 121		fixed_mode = drm_mode_duplicate(&dev_priv->drm, scan);
 122		if (!fixed_mode)
 123			return NULL;
 124
 125		DRM_DEBUG_KMS("[CONNECTOR:%d:%s] using preferred mode from EDID: ",
 126			      connector->base.base.id, connector->base.name);
 127		drm_mode_debug_printmodeline(fixed_mode);
 128
 129		return fixed_mode;
 130	}
 
 
 
 
 
 
 131
 132	scan = list_first_entry(&connector->base.probed_modes,
 133				typeof(*scan), head);
 
 
 
 
 
 
 
 
 134
 135	fixed_mode = drm_mode_duplicate(&dev_priv->drm, scan);
 136	if (!fixed_mode)
 137		return NULL;
 
 
 
 
 
 
 
 138
 139	fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
 140
 141	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] using first mode from EDID: ",
 142		      connector->base.base.id, connector->base.name);
 143	drm_mode_debug_printmodeline(fixed_mode);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 144
 145	return fixed_mode;
 
 
 
 
 
 
 146}
 147
 148struct drm_display_mode *
 149intel_panel_vbt_fixed_mode(struct intel_connector *connector)
 
 150{
 151	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 152	struct drm_display_info *info = &connector->base.display_info;
 153	struct drm_display_mode *fixed_mode;
 154
 155	if (!dev_priv->vbt.lfp_lvds_vbt_mode)
 156		return NULL;
 157
 158	fixed_mode = drm_mode_duplicate(&dev_priv->drm,
 159					dev_priv->vbt.lfp_lvds_vbt_mode);
 160	if (!fixed_mode)
 161		return NULL;
 162
 163	fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
 164
 165	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] using mode from VBT: ",
 166		      connector->base.base.id, connector->base.name);
 167	drm_mode_debug_printmodeline(fixed_mode);
 168
 169	info->width_mm = fixed_mode->width_mm;
 170	info->height_mm = fixed_mode->height_mm;
 171
 172	return fixed_mode;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 173}
 174
 175/* adjusted_mode has been preset to be the panel's fixed mode */
 176void
 177intel_pch_panel_fitting(struct intel_crtc *intel_crtc,
 178			struct intel_crtc_state *pipe_config,
 179			int fitting_mode)
 180{
 181	const struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
 182	int x = 0, y = 0, width = 0, height = 0;
 
 
 
 183
 184	/* Native modes don't need fitting */
 185	if (adjusted_mode->crtc_hdisplay == pipe_config->pipe_src_w &&
 186	    adjusted_mode->crtc_vdisplay == pipe_config->pipe_src_h &&
 187	    pipe_config->output_format != INTEL_OUTPUT_FORMAT_YCBCR420)
 188		goto done;
 189
 190	switch (fitting_mode) {
 191	case DRM_MODE_SCALE_CENTER:
 192		width = pipe_config->pipe_src_w;
 193		height = pipe_config->pipe_src_h;
 194		x = (adjusted_mode->crtc_hdisplay - width + 1)/2;
 195		y = (adjusted_mode->crtc_vdisplay - height + 1)/2;
 196		break;
 197
 198	case DRM_MODE_SCALE_ASPECT:
 199		/* Scale but preserve the aspect ratio */
 200		{
 201			u32 scaled_width = adjusted_mode->crtc_hdisplay
 202				* pipe_config->pipe_src_h;
 203			u32 scaled_height = pipe_config->pipe_src_w
 204				* adjusted_mode->crtc_vdisplay;
 205			if (scaled_width > scaled_height) { /* pillar */
 206				width = scaled_height / pipe_config->pipe_src_h;
 207				if (width & 1)
 208					width++;
 209				x = (adjusted_mode->crtc_hdisplay - width + 1) / 2;
 210				y = 0;
 211				height = adjusted_mode->crtc_vdisplay;
 212			} else if (scaled_width < scaled_height) { /* letter */
 213				height = scaled_width / pipe_config->pipe_src_w;
 214				if (height & 1)
 215				    height++;
 216				y = (adjusted_mode->crtc_vdisplay - height + 1) / 2;
 217				x = 0;
 218				width = adjusted_mode->crtc_hdisplay;
 219			} else {
 220				x = y = 0;
 221				width = adjusted_mode->crtc_hdisplay;
 222				height = adjusted_mode->crtc_vdisplay;
 223			}
 224		}
 225		break;
 226
 
 
 
 
 227	case DRM_MODE_SCALE_FULLSCREEN:
 228		x = y = 0;
 229		width = adjusted_mode->crtc_hdisplay;
 230		height = adjusted_mode->crtc_vdisplay;
 231		break;
 232
 233	default:
 234		WARN(1, "bad panel fit mode: %d\n", fitting_mode);
 235		return;
 236	}
 237
 238done:
 239	pipe_config->pch_pfit.pos = (x << 16) | y;
 240	pipe_config->pch_pfit.size = (width << 16) | height;
 241	pipe_config->pch_pfit.enabled = pipe_config->pch_pfit.size != 0;
 
 242}
 243
 244static void
 245centre_horizontally(struct drm_display_mode *adjusted_mode,
 246		    int width)
 247{
 248	u32 border, sync_pos, blank_width, sync_width;
 249
 250	/* keep the hsync and hblank widths constant */
 251	sync_width = adjusted_mode->crtc_hsync_end - adjusted_mode->crtc_hsync_start;
 252	blank_width = adjusted_mode->crtc_hblank_end - adjusted_mode->crtc_hblank_start;
 253	sync_pos = (blank_width - sync_width + 1) / 2;
 254
 255	border = (adjusted_mode->crtc_hdisplay - width + 1) / 2;
 256	border += border & 1; /* make the border even */
 257
 258	adjusted_mode->crtc_hdisplay = width;
 259	adjusted_mode->crtc_hblank_start = width + border;
 260	adjusted_mode->crtc_hblank_end = adjusted_mode->crtc_hblank_start + blank_width;
 261
 262	adjusted_mode->crtc_hsync_start = adjusted_mode->crtc_hblank_start + sync_pos;
 263	adjusted_mode->crtc_hsync_end = adjusted_mode->crtc_hsync_start + sync_width;
 264}
 265
 266static void
 267centre_vertically(struct drm_display_mode *adjusted_mode,
 268		  int height)
 269{
 270	u32 border, sync_pos, blank_width, sync_width;
 271
 272	/* keep the vsync and vblank widths constant */
 273	sync_width = adjusted_mode->crtc_vsync_end - adjusted_mode->crtc_vsync_start;
 274	blank_width = adjusted_mode->crtc_vblank_end - adjusted_mode->crtc_vblank_start;
 275	sync_pos = (blank_width - sync_width + 1) / 2;
 276
 277	border = (adjusted_mode->crtc_vdisplay - height + 1) / 2;
 278
 279	adjusted_mode->crtc_vdisplay = height;
 280	adjusted_mode->crtc_vblank_start = height + border;
 281	adjusted_mode->crtc_vblank_end = adjusted_mode->crtc_vblank_start + blank_width;
 282
 283	adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vblank_start + sync_pos;
 284	adjusted_mode->crtc_vsync_end = adjusted_mode->crtc_vsync_start + sync_width;
 285}
 286
 287static inline u32 panel_fitter_scaling(u32 source, u32 target)
 288{
 289	/*
 290	 * Floating point operation is not supported. So the FACTOR
 291	 * is defined, which can avoid the floating point computation
 292	 * when calculating the panel ratio.
 293	 */
 294#define ACCURACY 12
 295#define FACTOR (1 << ACCURACY)
 296	u32 ratio = source * FACTOR / target;
 297	return (FACTOR * ratio + FACTOR/2) / FACTOR;
 298}
 299
 300static void i965_scale_aspect(struct intel_crtc_state *pipe_config,
 301			      u32 *pfit_control)
 302{
 303	const struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
 304	u32 scaled_width = adjusted_mode->crtc_hdisplay *
 305		pipe_config->pipe_src_h;
 306	u32 scaled_height = pipe_config->pipe_src_w *
 307		adjusted_mode->crtc_vdisplay;
 
 308
 309	/* 965+ is easy, it does everything in hw */
 310	if (scaled_width > scaled_height)
 311		*pfit_control |= PFIT_ENABLE |
 312			PFIT_SCALING_PILLAR;
 313	else if (scaled_width < scaled_height)
 314		*pfit_control |= PFIT_ENABLE |
 315			PFIT_SCALING_LETTER;
 316	else if (adjusted_mode->crtc_hdisplay != pipe_config->pipe_src_w)
 317		*pfit_control |= PFIT_ENABLE | PFIT_SCALING_AUTO;
 318}
 319
 320static void i9xx_scale_aspect(struct intel_crtc_state *pipe_config,
 321			      u32 *pfit_control, u32 *pfit_pgm_ratios,
 322			      u32 *border)
 323{
 324	struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
 325	u32 scaled_width = adjusted_mode->crtc_hdisplay *
 326		pipe_config->pipe_src_h;
 327	u32 scaled_height = pipe_config->pipe_src_w *
 328		adjusted_mode->crtc_vdisplay;
 329	u32 bits;
 330
 331	/*
 332	 * For earlier chips we have to calculate the scaling
 333	 * ratio by hand and program it into the
 334	 * PFIT_PGM_RATIO register
 335	 */
 336	if (scaled_width > scaled_height) { /* pillar */
 337		centre_horizontally(adjusted_mode,
 338				    scaled_height /
 339				    pipe_config->pipe_src_h);
 340
 341		*border = LVDS_BORDER_ENABLE;
 342		if (pipe_config->pipe_src_h != adjusted_mode->crtc_vdisplay) {
 343			bits = panel_fitter_scaling(pipe_config->pipe_src_h,
 344						    adjusted_mode->crtc_vdisplay);
 345
 346			*pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT |
 347					     bits << PFIT_VERT_SCALE_SHIFT);
 348			*pfit_control |= (PFIT_ENABLE |
 349					  VERT_INTERP_BILINEAR |
 350					  HORIZ_INTERP_BILINEAR);
 351		}
 352	} else if (scaled_width < scaled_height) { /* letter */
 353		centre_vertically(adjusted_mode,
 354				  scaled_width /
 355				  pipe_config->pipe_src_w);
 356
 357		*border = LVDS_BORDER_ENABLE;
 358		if (pipe_config->pipe_src_w != adjusted_mode->crtc_hdisplay) {
 359			bits = panel_fitter_scaling(pipe_config->pipe_src_w,
 360						    adjusted_mode->crtc_hdisplay);
 361
 362			*pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT |
 363					     bits << PFIT_VERT_SCALE_SHIFT);
 364			*pfit_control |= (PFIT_ENABLE |
 365					  VERT_INTERP_BILINEAR |
 366					  HORIZ_INTERP_BILINEAR);
 367		}
 368	} else {
 369		/* Aspects match, Let hw scale both directions */
 370		*pfit_control |= (PFIT_ENABLE |
 371				  VERT_AUTO_SCALE | HORIZ_AUTO_SCALE |
 372				  VERT_INTERP_BILINEAR |
 373				  HORIZ_INTERP_BILINEAR);
 
 374	}
 375}
 376
 377void intel_gmch_panel_fitting(struct intel_crtc *intel_crtc,
 378			      struct intel_crtc_state *pipe_config,
 379			      int fitting_mode)
 380{
 381	struct drm_i915_private *dev_priv = to_i915(intel_crtc->base.dev);
 
 382	u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0;
 383	struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
 
 
 384
 385	/* Native modes don't need fitting */
 386	if (adjusted_mode->crtc_hdisplay == pipe_config->pipe_src_w &&
 387	    adjusted_mode->crtc_vdisplay == pipe_config->pipe_src_h)
 388		goto out;
 389
 390	switch (fitting_mode) {
 391	case DRM_MODE_SCALE_CENTER:
 392		/*
 393		 * For centered modes, we have to calculate border widths &
 394		 * heights and modify the values programmed into the CRTC.
 395		 */
 396		centre_horizontally(adjusted_mode, pipe_config->pipe_src_w);
 397		centre_vertically(adjusted_mode, pipe_config->pipe_src_h);
 398		border = LVDS_BORDER_ENABLE;
 399		break;
 400	case DRM_MODE_SCALE_ASPECT:
 401		/* Scale but preserve the aspect ratio */
 402		if (INTEL_GEN(dev_priv) >= 4)
 403			i965_scale_aspect(pipe_config, &pfit_control);
 404		else
 405			i9xx_scale_aspect(pipe_config, &pfit_control,
 406					  &pfit_pgm_ratios, &border);
 407		break;
 408	case DRM_MODE_SCALE_FULLSCREEN:
 409		/*
 410		 * Full scaling, even if it changes the aspect ratio.
 411		 * Fortunately this is all done for us in hw.
 412		 */
 413		if (pipe_config->pipe_src_h != adjusted_mode->crtc_vdisplay ||
 414		    pipe_config->pipe_src_w != adjusted_mode->crtc_hdisplay) {
 415			pfit_control |= PFIT_ENABLE;
 416			if (INTEL_GEN(dev_priv) >= 4)
 417				pfit_control |= PFIT_SCALING_AUTO;
 418			else
 419				pfit_control |= (VERT_AUTO_SCALE |
 420						 VERT_INTERP_BILINEAR |
 421						 HORIZ_AUTO_SCALE |
 422						 HORIZ_INTERP_BILINEAR);
 423		}
 424		break;
 425	default:
 426		WARN(1, "bad panel fit mode: %d\n", fitting_mode);
 427		return;
 428	}
 429
 430	/* 965+ wants fuzzy fitting */
 431	/* FIXME: handle multiple panels by failing gracefully */
 432	if (INTEL_GEN(dev_priv) >= 4)
 433		pfit_control |= ((intel_crtc->pipe << PFIT_PIPE_SHIFT) |
 434				 PFIT_FILTER_FUZZY);
 435
 436out:
 437	if ((pfit_control & PFIT_ENABLE) == 0) {
 438		pfit_control = 0;
 439		pfit_pgm_ratios = 0;
 440	}
 441
 442	/* Make sure pre-965 set dither correctly for 18bpp panels. */
 443	if (INTEL_GEN(dev_priv) < 4 && pipe_config->pipe_bpp == 18)
 444		pfit_control |= PANEL_8TO6_DITHER_ENABLE;
 445
 446	pipe_config->gmch_pfit.control = pfit_control;
 447	pipe_config->gmch_pfit.pgm_ratios = pfit_pgm_ratios;
 448	pipe_config->gmch_pfit.lvds_border_bits = border;
 449}
 450
 451/**
 452 * scale - scale values from one range to another
 453 * @source_val: value in range [@source_min..@source_max]
 454 * @source_min: minimum legal value for @source_val
 455 * @source_max: maximum legal value for @source_val
 456 * @target_min: corresponding target value for @source_min
 457 * @target_max: corresponding target value for @source_max
 458 *
 459 * Return @source_val in range [@source_min..@source_max] scaled to range
 460 * [@target_min..@target_max].
 461 */
 462static u32 scale(u32 source_val,
 463		 u32 source_min, u32 source_max,
 464		 u32 target_min, u32 target_max)
 465{
 466	u64 target_val;
 467
 468	WARN_ON(source_min > source_max);
 469	WARN_ON(target_min > target_max);
 470
 471	/* defensive */
 472	source_val = clamp(source_val, source_min, source_max);
 473
 474	/* avoid overflows */
 475	target_val = mul_u32_u32(source_val - source_min,
 476				 target_max - target_min);
 477	target_val = DIV_ROUND_CLOSEST_ULL(target_val, source_max - source_min);
 478	target_val += target_min;
 479
 480	return target_val;
 481}
 482
 483/* Scale user_level in range [0..user_max] to [hw_min..hw_max]. */
 484static inline u32 scale_user_to_hw(struct intel_connector *connector,
 485				   u32 user_level, u32 user_max)
 486{
 487	struct intel_panel *panel = &connector->panel;
 488
 489	return scale(user_level, 0, user_max,
 490		     panel->backlight.min, panel->backlight.max);
 491}
 492
 493/* Scale user_level in range [0..user_max] to [0..hw_max], clamping the result
 494 * to [hw_min..hw_max]. */
 495static inline u32 clamp_user_to_hw(struct intel_connector *connector,
 496				   u32 user_level, u32 user_max)
 497{
 498	struct intel_panel *panel = &connector->panel;
 499	u32 hw_level;
 500
 501	hw_level = scale(user_level, 0, user_max, 0, panel->backlight.max);
 502	hw_level = clamp(hw_level, panel->backlight.min, panel->backlight.max);
 503
 504	return hw_level;
 505}
 506
 507/* Scale hw_level in range [hw_min..hw_max] to [0..user_max]. */
 508static inline u32 scale_hw_to_user(struct intel_connector *connector,
 509				   u32 hw_level, u32 user_max)
 510{
 511	struct intel_panel *panel = &connector->panel;
 512
 513	return scale(hw_level, panel->backlight.min, panel->backlight.max,
 514		     0, user_max);
 515}
 516
 517static u32 intel_panel_compute_brightness(struct intel_connector *connector,
 518					  u32 val)
 519{
 520	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 521	struct intel_panel *panel = &connector->panel;
 522
 523	WARN_ON(panel->backlight.max == 0);
 524
 525	if (i915_modparams.invert_brightness < 0)
 526		return val;
 527
 528	if (i915_modparams.invert_brightness > 0 ||
 529	    dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS) {
 530		return panel->backlight.max - val + panel->backlight.min;
 531	}
 532
 533	return val;
 534}
 535
 536static u32 lpt_get_backlight(struct intel_connector *connector)
 537{
 538	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 539
 540	return I915_READ(BLC_PWM_PCH_CTL2) & BACKLIGHT_DUTY_CYCLE_MASK;
 541}
 542
 543static u32 pch_get_backlight(struct intel_connector *connector)
 544{
 545	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 546
 547	return I915_READ(BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
 548}
 549
 550static u32 i9xx_get_backlight(struct intel_connector *connector)
 551{
 552	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 553	struct intel_panel *panel = &connector->panel;
 554	u32 val;
 555
 556	val = I915_READ(BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
 557	if (INTEL_GEN(dev_priv) < 4)
 558		val >>= 1;
 559
 560	if (panel->backlight.combination_mode) {
 561		u8 lbpc;
 562
 563		pci_read_config_byte(dev_priv->drm.pdev, LBPC, &lbpc);
 564		val *= lbpc;
 565	}
 566
 567	return val;
 568}
 569
 570static u32 _vlv_get_backlight(struct drm_i915_private *dev_priv, enum pipe pipe)
 571{
 572	if (WARN_ON(pipe != PIPE_A && pipe != PIPE_B))
 573		return 0;
 574
 575	return I915_READ(VLV_BLC_PWM_CTL(pipe)) & BACKLIGHT_DUTY_CYCLE_MASK;
 576}
 577
 578static u32 vlv_get_backlight(struct intel_connector *connector)
 579{
 580	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 581	enum pipe pipe = intel_connector_get_pipe(connector);
 582
 583	return _vlv_get_backlight(dev_priv, pipe);
 584}
 585
 586static u32 bxt_get_backlight(struct intel_connector *connector)
 587{
 588	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 589	struct intel_panel *panel = &connector->panel;
 590
 591	return I915_READ(BXT_BLC_PWM_DUTY(panel->backlight.controller));
 592}
 593
 594static u32 pwm_get_backlight(struct intel_connector *connector)
 595{
 596	struct intel_panel *panel = &connector->panel;
 597	int duty_ns;
 598
 599	duty_ns = pwm_get_duty_cycle(panel->backlight.pwm);
 600	return DIV_ROUND_UP(duty_ns * 100, CRC_PMIC_PWM_PERIOD_NS);
 601}
 602
 603static void lpt_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 604{
 605	struct intel_connector *connector = to_intel_connector(conn_state->connector);
 606	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 607
 608	u32 val = I915_READ(BLC_PWM_PCH_CTL2) & ~BACKLIGHT_DUTY_CYCLE_MASK;
 609	I915_WRITE(BLC_PWM_PCH_CTL2, val | level);
 610}
 611
 612static void pch_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 613{
 614	struct intel_connector *connector = to_intel_connector(conn_state->connector);
 615	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 616	u32 tmp;
 617
 618	tmp = I915_READ(BLC_PWM_CPU_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK;
 619	I915_WRITE(BLC_PWM_CPU_CTL, tmp | level);
 620}
 621
 622static void i9xx_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 623{
 624	struct intel_connector *connector = to_intel_connector(conn_state->connector);
 625	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 626	struct intel_panel *panel = &connector->panel;
 627	u32 tmp, mask;
 628
 629	WARN_ON(panel->backlight.max == 0);
 630
 631	if (panel->backlight.combination_mode) {
 632		u8 lbpc;
 633
 634		lbpc = level * 0xfe / panel->backlight.max + 1;
 635		level /= lbpc;
 636		pci_write_config_byte(dev_priv->drm.pdev, LBPC, lbpc);
 637	}
 638
 639	if (IS_GEN(dev_priv, 4)) {
 640		mask = BACKLIGHT_DUTY_CYCLE_MASK;
 641	} else {
 642		level <<= 1;
 643		mask = BACKLIGHT_DUTY_CYCLE_MASK_PNV;
 644	}
 645
 646	tmp = I915_READ(BLC_PWM_CTL) & ~mask;
 647	I915_WRITE(BLC_PWM_CTL, tmp | level);
 648}
 649
 650static void vlv_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 651{
 652	struct intel_connector *connector = to_intel_connector(conn_state->connector);
 653	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 654	enum pipe pipe = to_intel_crtc(conn_state->crtc)->pipe;
 655	u32 tmp;
 656
 657	tmp = I915_READ(VLV_BLC_PWM_CTL(pipe)) & ~BACKLIGHT_DUTY_CYCLE_MASK;
 658	I915_WRITE(VLV_BLC_PWM_CTL(pipe), tmp | level);
 659}
 660
 661static void bxt_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 662{
 663	struct intel_connector *connector = to_intel_connector(conn_state->connector);
 664	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 665	struct intel_panel *panel = &connector->panel;
 666
 667	I915_WRITE(BXT_BLC_PWM_DUTY(panel->backlight.controller), level);
 668}
 669
 670static void pwm_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 671{
 672	struct intel_panel *panel = &to_intel_connector(conn_state->connector)->panel;
 673	int duty_ns = DIV_ROUND_UP(level * CRC_PMIC_PWM_PERIOD_NS, 100);
 674
 675	pwm_config(panel->backlight.pwm, duty_ns, CRC_PMIC_PWM_PERIOD_NS);
 676}
 677
 678static void
 679intel_panel_actually_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 680{
 681	struct intel_connector *connector = to_intel_connector(conn_state->connector);
 682	struct intel_panel *panel = &connector->panel;
 683
 684	DRM_DEBUG_DRIVER("set backlight PWM = %d\n", level);
 685
 686	level = intel_panel_compute_brightness(connector, level);
 687	panel->backlight.set(conn_state, level);
 688}
 689
 690/* set backlight brightness to level in range [0..max], assuming hw min is
 691 * respected.
 692 */
 693void intel_panel_set_backlight_acpi(const struct drm_connector_state *conn_state,
 694				    u32 user_level, u32 user_max)
 695{
 696	struct intel_connector *connector = to_intel_connector(conn_state->connector);
 697	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 698	struct intel_panel *panel = &connector->panel;
 699	u32 hw_level;
 700
 701	/*
 702	 * Lack of crtc may occur during driver init because
 703	 * connection_mutex isn't held across the entire backlight
 704	 * setup + modeset readout, and the BIOS can issue the
 705	 * requests at any time.
 706	 */
 707	if (!panel->backlight.present || !conn_state->crtc)
 708		return;
 709
 710	mutex_lock(&dev_priv->backlight_lock);
 711
 712	WARN_ON(panel->backlight.max == 0);
 713
 714	hw_level = clamp_user_to_hw(connector, user_level, user_max);
 715	panel->backlight.level = hw_level;
 716
 717	if (panel->backlight.device)
 718		panel->backlight.device->props.brightness =
 719			scale_hw_to_user(connector,
 720					 panel->backlight.level,
 721					 panel->backlight.device->props.max_brightness);
 722
 723	if (panel->backlight.enabled)
 724		intel_panel_actually_set_backlight(conn_state, hw_level);
 725
 726	mutex_unlock(&dev_priv->backlight_lock);
 727}
 728
 729static void lpt_disable_backlight(const struct drm_connector_state *old_conn_state)
 730{
 731	struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 732	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 733	u32 tmp;
 734
 735	intel_panel_actually_set_backlight(old_conn_state, 0);
 736
 737	/*
 738	 * Although we don't support or enable CPU PWM with LPT/SPT based
 739	 * systems, it may have been enabled prior to loading the
 740	 * driver. Disable to avoid warnings on LCPLL disable.
 741	 *
 742	 * This needs rework if we need to add support for CPU PWM on PCH split
 743	 * platforms.
 744	 */
 745	tmp = I915_READ(BLC_PWM_CPU_CTL2);
 746	if (tmp & BLM_PWM_ENABLE) {
 747		DRM_DEBUG_KMS("cpu backlight was enabled, disabling\n");
 748		I915_WRITE(BLC_PWM_CPU_CTL2, tmp & ~BLM_PWM_ENABLE);
 749	}
 750
 751	tmp = I915_READ(BLC_PWM_PCH_CTL1);
 752	I915_WRITE(BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE);
 753}
 754
 755static void pch_disable_backlight(const struct drm_connector_state *old_conn_state)
 756{
 757	struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 758	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 759	u32 tmp;
 760
 761	intel_panel_actually_set_backlight(old_conn_state, 0);
 762
 763	tmp = I915_READ(BLC_PWM_CPU_CTL2);
 764	I915_WRITE(BLC_PWM_CPU_CTL2, tmp & ~BLM_PWM_ENABLE);
 765
 766	tmp = I915_READ(BLC_PWM_PCH_CTL1);
 767	I915_WRITE(BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE);
 768}
 769
 770static void i9xx_disable_backlight(const struct drm_connector_state *old_conn_state)
 771{
 772	intel_panel_actually_set_backlight(old_conn_state, 0);
 773}
 774
 775static void i965_disable_backlight(const struct drm_connector_state *old_conn_state)
 776{
 777	struct drm_i915_private *dev_priv = to_i915(old_conn_state->connector->dev);
 778	u32 tmp;
 779
 780	intel_panel_actually_set_backlight(old_conn_state, 0);
 781
 782	tmp = I915_READ(BLC_PWM_CTL2);
 783	I915_WRITE(BLC_PWM_CTL2, tmp & ~BLM_PWM_ENABLE);
 784}
 785
 786static void vlv_disable_backlight(const struct drm_connector_state *old_conn_state)
 787{
 788	struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 789	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 790	enum pipe pipe = to_intel_crtc(old_conn_state->crtc)->pipe;
 791	u32 tmp;
 792
 793	intel_panel_actually_set_backlight(old_conn_state, 0);
 794
 795	tmp = I915_READ(VLV_BLC_PWM_CTL2(pipe));
 796	I915_WRITE(VLV_BLC_PWM_CTL2(pipe), tmp & ~BLM_PWM_ENABLE);
 797}
 798
 799static void bxt_disable_backlight(const struct drm_connector_state *old_conn_state)
 800{
 801	struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 802	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 803	struct intel_panel *panel = &connector->panel;
 804	u32 tmp, val;
 805
 806	intel_panel_actually_set_backlight(old_conn_state, 0);
 807
 808	tmp = I915_READ(BXT_BLC_PWM_CTL(panel->backlight.controller));
 809	I915_WRITE(BXT_BLC_PWM_CTL(panel->backlight.controller),
 810			tmp & ~BXT_BLC_PWM_ENABLE);
 811
 812	if (panel->backlight.controller == 1) {
 813		val = I915_READ(UTIL_PIN_CTL);
 814		val &= ~UTIL_PIN_ENABLE;
 815		I915_WRITE(UTIL_PIN_CTL, val);
 816	}
 817}
 818
 819static void cnp_disable_backlight(const struct drm_connector_state *old_conn_state)
 820{
 821	struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 822	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 823	struct intel_panel *panel = &connector->panel;
 824	u32 tmp;
 825
 826	intel_panel_actually_set_backlight(old_conn_state, 0);
 827
 828	tmp = I915_READ(BXT_BLC_PWM_CTL(panel->backlight.controller));
 829	I915_WRITE(BXT_BLC_PWM_CTL(panel->backlight.controller),
 830		   tmp & ~BXT_BLC_PWM_ENABLE);
 831}
 832
 833static void pwm_disable_backlight(const struct drm_connector_state *old_conn_state)
 834{
 835	struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 836	struct intel_panel *panel = &connector->panel;
 837
 838	/* Disable the backlight */
 839	intel_panel_actually_set_backlight(old_conn_state, 0);
 840	usleep_range(2000, 3000);
 841	pwm_disable(panel->backlight.pwm);
 842}
 843
 844void intel_panel_disable_backlight(const struct drm_connector_state *old_conn_state)
 845{
 846	struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 847	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 848	struct intel_panel *panel = &connector->panel;
 849
 850	if (!panel->backlight.present)
 851		return;
 852
 853	/*
 854	 * Do not disable backlight on the vga_switcheroo path. When switching
 855	 * away from i915, the other client may depend on i915 to handle the
 856	 * backlight. This will leave the backlight on unnecessarily when
 857	 * another client is not activated.
 858	 */
 859	if (dev_priv->drm.switch_power_state == DRM_SWITCH_POWER_CHANGING) {
 860		DRM_DEBUG_DRIVER("Skipping backlight disable on vga switch\n");
 861		return;
 862	}
 863
 864	mutex_lock(&dev_priv->backlight_lock);
 865
 866	if (panel->backlight.device)
 867		panel->backlight.device->props.power = FB_BLANK_POWERDOWN;
 868	panel->backlight.enabled = false;
 869	panel->backlight.disable(old_conn_state);
 870
 871	mutex_unlock(&dev_priv->backlight_lock);
 872}
 873
 874static void lpt_enable_backlight(const struct intel_crtc_state *crtc_state,
 875				 const struct drm_connector_state *conn_state)
 876{
 877	struct intel_connector *connector = to_intel_connector(conn_state->connector);
 878	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 879	struct intel_panel *panel = &connector->panel;
 880	u32 pch_ctl1, pch_ctl2, schicken;
 881
 882	pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1);
 883	if (pch_ctl1 & BLM_PCH_PWM_ENABLE) {
 884		DRM_DEBUG_KMS("pch backlight already enabled\n");
 885		pch_ctl1 &= ~BLM_PCH_PWM_ENABLE;
 886		I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1);
 887	}
 888
 889	if (HAS_PCH_LPT(dev_priv)) {
 890		schicken = I915_READ(SOUTH_CHICKEN2);
 891		if (panel->backlight.alternate_pwm_increment)
 892			schicken |= LPT_PWM_GRANULARITY;
 893		else
 894			schicken &= ~LPT_PWM_GRANULARITY;
 895		I915_WRITE(SOUTH_CHICKEN2, schicken);
 896	} else {
 897		schicken = I915_READ(SOUTH_CHICKEN1);
 898		if (panel->backlight.alternate_pwm_increment)
 899			schicken |= SPT_PWM_GRANULARITY;
 900		else
 901			schicken &= ~SPT_PWM_GRANULARITY;
 902		I915_WRITE(SOUTH_CHICKEN1, schicken);
 903	}
 904
 905	pch_ctl2 = panel->backlight.max << 16;
 906	I915_WRITE(BLC_PWM_PCH_CTL2, pch_ctl2);
 907
 908	pch_ctl1 = 0;
 909	if (panel->backlight.active_low_pwm)
 910		pch_ctl1 |= BLM_PCH_POLARITY;
 911
 912	/* After LPT, override is the default. */
 913	if (HAS_PCH_LPT(dev_priv))
 914		pch_ctl1 |= BLM_PCH_OVERRIDE_ENABLE;
 915
 916	I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1);
 917	POSTING_READ(BLC_PWM_PCH_CTL1);
 918	I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1 | BLM_PCH_PWM_ENABLE);
 919
 920	/* This won't stick until the above enable. */
 921	intel_panel_actually_set_backlight(conn_state, panel->backlight.level);
 922}
 923
 924static void pch_enable_backlight(const struct intel_crtc_state *crtc_state,
 925				 const struct drm_connector_state *conn_state)
 926{
 927	struct intel_connector *connector = to_intel_connector(conn_state->connector);
 928	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 929	struct intel_panel *panel = &connector->panel;
 930	enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
 931	u32 cpu_ctl2, pch_ctl1, pch_ctl2;
 932
 933	cpu_ctl2 = I915_READ(BLC_PWM_CPU_CTL2);
 934	if (cpu_ctl2 & BLM_PWM_ENABLE) {
 935		DRM_DEBUG_KMS("cpu backlight already enabled\n");
 936		cpu_ctl2 &= ~BLM_PWM_ENABLE;
 937		I915_WRITE(BLC_PWM_CPU_CTL2, cpu_ctl2);
 938	}
 939
 940	pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1);
 941	if (pch_ctl1 & BLM_PCH_PWM_ENABLE) {
 942		DRM_DEBUG_KMS("pch backlight already enabled\n");
 943		pch_ctl1 &= ~BLM_PCH_PWM_ENABLE;
 944		I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1);
 945	}
 946
 947	if (cpu_transcoder == TRANSCODER_EDP)
 948		cpu_ctl2 = BLM_TRANSCODER_EDP;
 949	else
 950		cpu_ctl2 = BLM_PIPE(cpu_transcoder);
 951	I915_WRITE(BLC_PWM_CPU_CTL2, cpu_ctl2);
 952	POSTING_READ(BLC_PWM_CPU_CTL2);
 953	I915_WRITE(BLC_PWM_CPU_CTL2, cpu_ctl2 | BLM_PWM_ENABLE);
 954
 955	/* This won't stick until the above enable. */
 956	intel_panel_actually_set_backlight(conn_state, panel->backlight.level);
 957
 958	pch_ctl2 = panel->backlight.max << 16;
 959	I915_WRITE(BLC_PWM_PCH_CTL2, pch_ctl2);
 960
 961	pch_ctl1 = 0;
 962	if (panel->backlight.active_low_pwm)
 963		pch_ctl1 |= BLM_PCH_POLARITY;
 964
 965	I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1);
 966	POSTING_READ(BLC_PWM_PCH_CTL1);
 967	I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1 | BLM_PCH_PWM_ENABLE);
 968}
 969
 970static void i9xx_enable_backlight(const struct intel_crtc_state *crtc_state,
 971				  const struct drm_connector_state *conn_state)
 972{
 973	struct intel_connector *connector = to_intel_connector(conn_state->connector);
 974	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 975	struct intel_panel *panel = &connector->panel;
 976	u32 ctl, freq;
 977
 978	ctl = I915_READ(BLC_PWM_CTL);
 979	if (ctl & BACKLIGHT_DUTY_CYCLE_MASK_PNV) {
 980		DRM_DEBUG_KMS("backlight already enabled\n");
 981		I915_WRITE(BLC_PWM_CTL, 0);
 982	}
 983
 984	freq = panel->backlight.max;
 985	if (panel->backlight.combination_mode)
 986		freq /= 0xff;
 987
 988	ctl = freq << 17;
 989	if (panel->backlight.combination_mode)
 990		ctl |= BLM_LEGACY_MODE;
 991	if (IS_PINEVIEW(dev_priv) && panel->backlight.active_low_pwm)
 992		ctl |= BLM_POLARITY_PNV;
 993
 994	I915_WRITE(BLC_PWM_CTL, ctl);
 995	POSTING_READ(BLC_PWM_CTL);
 996
 997	/* XXX: combine this into above write? */
 998	intel_panel_actually_set_backlight(conn_state, panel->backlight.level);
 999
1000	/*
1001	 * Needed to enable backlight on some 855gm models. BLC_HIST_CTL is
1002	 * 855gm only, but checking for gen2 is safe, as 855gm is the only gen2
1003	 * that has backlight.
1004	 */
1005	if (IS_GEN(dev_priv, 2))
1006		I915_WRITE(BLC_HIST_CTL, BLM_HISTOGRAM_ENABLE);
1007}
1008
1009static void i965_enable_backlight(const struct intel_crtc_state *crtc_state,
1010				  const struct drm_connector_state *conn_state)
1011{
1012	struct intel_connector *connector = to_intel_connector(conn_state->connector);
1013	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1014	struct intel_panel *panel = &connector->panel;
1015	enum pipe pipe = to_intel_crtc(conn_state->crtc)->pipe;
1016	u32 ctl, ctl2, freq;
1017
1018	ctl2 = I915_READ(BLC_PWM_CTL2);
1019	if (ctl2 & BLM_PWM_ENABLE) {
1020		DRM_DEBUG_KMS("backlight already enabled\n");
1021		ctl2 &= ~BLM_PWM_ENABLE;
1022		I915_WRITE(BLC_PWM_CTL2, ctl2);
1023	}
1024
1025	freq = panel->backlight.max;
1026	if (panel->backlight.combination_mode)
1027		freq /= 0xff;
1028
1029	ctl = freq << 16;
1030	I915_WRITE(BLC_PWM_CTL, ctl);
1031
1032	ctl2 = BLM_PIPE(pipe);
1033	if (panel->backlight.combination_mode)
1034		ctl2 |= BLM_COMBINATION_MODE;
1035	if (panel->backlight.active_low_pwm)
1036		ctl2 |= BLM_POLARITY_I965;
1037	I915_WRITE(BLC_PWM_CTL2, ctl2);
1038	POSTING_READ(BLC_PWM_CTL2);
1039	I915_WRITE(BLC_PWM_CTL2, ctl2 | BLM_PWM_ENABLE);
1040
1041	intel_panel_actually_set_backlight(conn_state, panel->backlight.level);
1042}
1043
1044static void vlv_enable_backlight(const struct intel_crtc_state *crtc_state,
1045				 const struct drm_connector_state *conn_state)
1046{
1047	struct intel_connector *connector = to_intel_connector(conn_state->connector);
1048	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1049	struct intel_panel *panel = &connector->panel;
1050	enum pipe pipe = to_intel_crtc(crtc_state->base.crtc)->pipe;
1051	u32 ctl, ctl2;
1052
1053	ctl2 = I915_READ(VLV_BLC_PWM_CTL2(pipe));
1054	if (ctl2 & BLM_PWM_ENABLE) {
1055		DRM_DEBUG_KMS("backlight already enabled\n");
1056		ctl2 &= ~BLM_PWM_ENABLE;
1057		I915_WRITE(VLV_BLC_PWM_CTL2(pipe), ctl2);
1058	}
1059
1060	ctl = panel->backlight.max << 16;
1061	I915_WRITE(VLV_BLC_PWM_CTL(pipe), ctl);
1062
1063	/* XXX: combine this into above write? */
1064	intel_panel_actually_set_backlight(conn_state, panel->backlight.level);
1065
1066	ctl2 = 0;
1067	if (panel->backlight.active_low_pwm)
1068		ctl2 |= BLM_POLARITY_I965;
1069	I915_WRITE(VLV_BLC_PWM_CTL2(pipe), ctl2);
1070	POSTING_READ(VLV_BLC_PWM_CTL2(pipe));
1071	I915_WRITE(VLV_BLC_PWM_CTL2(pipe), ctl2 | BLM_PWM_ENABLE);
1072}
1073
1074static void bxt_enable_backlight(const struct intel_crtc_state *crtc_state,
1075				 const struct drm_connector_state *conn_state)
1076{
1077	struct intel_connector *connector = to_intel_connector(conn_state->connector);
1078	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1079	struct intel_panel *panel = &connector->panel;
1080	enum pipe pipe = to_intel_crtc(crtc_state->base.crtc)->pipe;
1081	u32 pwm_ctl, val;
1082
1083	/* Controller 1 uses the utility pin. */
1084	if (panel->backlight.controller == 1) {
1085		val = I915_READ(UTIL_PIN_CTL);
1086		if (val & UTIL_PIN_ENABLE) {
1087			DRM_DEBUG_KMS("util pin already enabled\n");
1088			val &= ~UTIL_PIN_ENABLE;
1089			I915_WRITE(UTIL_PIN_CTL, val);
1090		}
1091
1092		val = 0;
1093		if (panel->backlight.util_pin_active_low)
1094			val |= UTIL_PIN_POLARITY;
1095		I915_WRITE(UTIL_PIN_CTL, val | UTIL_PIN_PIPE(pipe) |
1096				UTIL_PIN_MODE_PWM | UTIL_PIN_ENABLE);
1097	}
1098
1099	pwm_ctl = I915_READ(BXT_BLC_PWM_CTL(panel->backlight.controller));
1100	if (pwm_ctl & BXT_BLC_PWM_ENABLE) {
1101		DRM_DEBUG_KMS("backlight already enabled\n");
1102		pwm_ctl &= ~BXT_BLC_PWM_ENABLE;
1103		I915_WRITE(BXT_BLC_PWM_CTL(panel->backlight.controller),
1104				pwm_ctl);
1105	}
1106
1107	I915_WRITE(BXT_BLC_PWM_FREQ(panel->backlight.controller),
1108			panel->backlight.max);
1109
1110	intel_panel_actually_set_backlight(conn_state, panel->backlight.level);
1111
1112	pwm_ctl = 0;
1113	if (panel->backlight.active_low_pwm)
1114		pwm_ctl |= BXT_BLC_PWM_POLARITY;
1115
1116	I915_WRITE(BXT_BLC_PWM_CTL(panel->backlight.controller), pwm_ctl);
1117	POSTING_READ(BXT_BLC_PWM_CTL(panel->backlight.controller));
1118	I915_WRITE(BXT_BLC_PWM_CTL(panel->backlight.controller),
1119			pwm_ctl | BXT_BLC_PWM_ENABLE);
1120}
1121
1122static void cnp_enable_backlight(const struct intel_crtc_state *crtc_state,
1123				 const struct drm_connector_state *conn_state)
1124{
1125	struct intel_connector *connector = to_intel_connector(conn_state->connector);
1126	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1127	struct intel_panel *panel = &connector->panel;
1128	u32 pwm_ctl;
1129
1130	pwm_ctl = I915_READ(BXT_BLC_PWM_CTL(panel->backlight.controller));
1131	if (pwm_ctl & BXT_BLC_PWM_ENABLE) {
1132		DRM_DEBUG_KMS("backlight already enabled\n");
1133		pwm_ctl &= ~BXT_BLC_PWM_ENABLE;
1134		I915_WRITE(BXT_BLC_PWM_CTL(panel->backlight.controller),
1135			   pwm_ctl);
1136	}
1137
1138	I915_WRITE(BXT_BLC_PWM_FREQ(panel->backlight.controller),
1139		   panel->backlight.max);
1140
1141	intel_panel_actually_set_backlight(conn_state, panel->backlight.level);
1142
1143	pwm_ctl = 0;
1144	if (panel->backlight.active_low_pwm)
1145		pwm_ctl |= BXT_BLC_PWM_POLARITY;
1146
1147	I915_WRITE(BXT_BLC_PWM_CTL(panel->backlight.controller), pwm_ctl);
1148	POSTING_READ(BXT_BLC_PWM_CTL(panel->backlight.controller));
1149	I915_WRITE(BXT_BLC_PWM_CTL(panel->backlight.controller),
1150		   pwm_ctl | BXT_BLC_PWM_ENABLE);
1151}
1152
1153static void pwm_enable_backlight(const struct intel_crtc_state *crtc_state,
1154				 const struct drm_connector_state *conn_state)
1155{
1156	struct intel_connector *connector = to_intel_connector(conn_state->connector);
1157	struct intel_panel *panel = &connector->panel;
1158
1159	pwm_enable(panel->backlight.pwm);
1160	intel_panel_actually_set_backlight(conn_state, panel->backlight.level);
1161}
1162
1163static void __intel_panel_enable_backlight(const struct intel_crtc_state *crtc_state,
1164					   const struct drm_connector_state *conn_state)
1165{
1166	struct intel_connector *connector = to_intel_connector(conn_state->connector);
1167	struct intel_panel *panel = &connector->panel;
1168
1169	WARN_ON(panel->backlight.max == 0);
1170
1171	if (panel->backlight.level <= panel->backlight.min) {
1172		panel->backlight.level = panel->backlight.max;
1173		if (panel->backlight.device)
1174			panel->backlight.device->props.brightness =
1175				scale_hw_to_user(connector,
1176						 panel->backlight.level,
1177						 panel->backlight.device->props.max_brightness);
1178	}
1179
1180	panel->backlight.enable(crtc_state, conn_state);
1181	panel->backlight.enabled = true;
1182	if (panel->backlight.device)
1183		panel->backlight.device->props.power = FB_BLANK_UNBLANK;
1184}
1185
1186void intel_panel_enable_backlight(const struct intel_crtc_state *crtc_state,
1187				  const struct drm_connector_state *conn_state)
1188{
1189	struct intel_connector *connector = to_intel_connector(conn_state->connector);
1190	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1191	struct intel_panel *panel = &connector->panel;
1192	enum pipe pipe = to_intel_crtc(crtc_state->base.crtc)->pipe;
1193
1194	if (!panel->backlight.present)
1195		return;
1196
1197	DRM_DEBUG_KMS("pipe %c\n", pipe_name(pipe));
1198
1199	mutex_lock(&dev_priv->backlight_lock);
1200
1201	__intel_panel_enable_backlight(crtc_state, conn_state);
1202
1203	mutex_unlock(&dev_priv->backlight_lock);
1204}
1205
1206#if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)
1207static u32 intel_panel_get_backlight(struct intel_connector *connector)
1208{
1209	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1210	struct intel_panel *panel = &connector->panel;
1211	u32 val = 0;
1212
1213	mutex_lock(&dev_priv->backlight_lock);
1214
1215	if (panel->backlight.enabled) {
1216		val = panel->backlight.get(connector);
1217		val = intel_panel_compute_brightness(connector, val);
1218	}
1219
1220	mutex_unlock(&dev_priv->backlight_lock);
1221
1222	DRM_DEBUG_DRIVER("get backlight PWM = %d\n", val);
1223	return val;
1224}
1225
1226/* set backlight brightness to level in range [0..max], scaling wrt hw min */
1227static void intel_panel_set_backlight(const struct drm_connector_state *conn_state,
1228				      u32 user_level, u32 user_max)
1229{
1230	struct intel_connector *connector = to_intel_connector(conn_state->connector);
1231	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1232	struct intel_panel *panel = &connector->panel;
1233	u32 hw_level;
1234
1235	if (!panel->backlight.present)
1236		return;
1237
1238	mutex_lock(&dev_priv->backlight_lock);
1239
1240	WARN_ON(panel->backlight.max == 0);
1241
1242	hw_level = scale_user_to_hw(connector, user_level, user_max);
1243	panel->backlight.level = hw_level;
1244
1245	if (panel->backlight.enabled)
1246		intel_panel_actually_set_backlight(conn_state, hw_level);
1247
1248	mutex_unlock(&dev_priv->backlight_lock);
1249}
1250
1251static int intel_backlight_device_update_status(struct backlight_device *bd)
1252{
1253	struct intel_connector *connector = bl_get_data(bd);
1254	struct intel_panel *panel = &connector->panel;
1255	struct drm_device *dev = connector->base.dev;
1256
1257	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
1258	DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n",
1259		      bd->props.brightness, bd->props.max_brightness);
1260	intel_panel_set_backlight(connector->base.state, bd->props.brightness,
1261				  bd->props.max_brightness);
1262
1263	/*
1264	 * Allow flipping bl_power as a sub-state of enabled. Sadly the
1265	 * backlight class device does not make it easy to to differentiate
1266	 * between callbacks for brightness and bl_power, so our backlight_power
1267	 * callback needs to take this into account.
1268	 */
1269	if (panel->backlight.enabled) {
1270		if (panel->backlight.power) {
1271			bool enable = bd->props.power == FB_BLANK_UNBLANK &&
1272				bd->props.brightness != 0;
1273			panel->backlight.power(connector, enable);
1274		}
1275	} else {
1276		bd->props.power = FB_BLANK_POWERDOWN;
1277	}
1278
1279	drm_modeset_unlock(&dev->mode_config.connection_mutex);
1280	return 0;
1281}
1282
1283static int intel_backlight_device_get_brightness(struct backlight_device *bd)
1284{
1285	struct intel_connector *connector = bl_get_data(bd);
1286	struct drm_device *dev = connector->base.dev;
1287	struct drm_i915_private *dev_priv = to_i915(dev);
1288	intel_wakeref_t wakeref;
1289	int ret = 0;
1290
1291	with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref) {
1292		u32 hw_level;
1293
1294		drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
1295
1296		hw_level = intel_panel_get_backlight(connector);
1297		ret = scale_hw_to_user(connector,
1298				       hw_level, bd->props.max_brightness);
1299
1300		drm_modeset_unlock(&dev->mode_config.connection_mutex);
1301	}
1302
1303	return ret;
1304}
1305
1306static const struct backlight_ops intel_backlight_device_ops = {
1307	.update_status = intel_backlight_device_update_status,
1308	.get_brightness = intel_backlight_device_get_brightness,
1309};
1310
1311int intel_backlight_device_register(struct intel_connector *connector)
1312{
1313	struct intel_panel *panel = &connector->panel;
1314	struct backlight_properties props;
1315
1316	if (WARN_ON(panel->backlight.device))
1317		return -ENODEV;
1318
1319	if (!panel->backlight.present)
1320		return 0;
1321
1322	WARN_ON(panel->backlight.max == 0);
1323
1324	memset(&props, 0, sizeof(props));
1325	props.type = BACKLIGHT_RAW;
1326
1327	/*
1328	 * Note: Everything should work even if the backlight device max
1329	 * presented to the userspace is arbitrarily chosen.
1330	 */
1331	props.max_brightness = panel->backlight.max;
1332	props.brightness = scale_hw_to_user(connector,
1333					    panel->backlight.level,
1334					    props.max_brightness);
1335
1336	if (panel->backlight.enabled)
1337		props.power = FB_BLANK_UNBLANK;
1338	else
1339		props.power = FB_BLANK_POWERDOWN;
1340
1341	/*
1342	 * Note: using the same name independent of the connector prevents
1343	 * registration of multiple backlight devices in the driver.
1344	 */
1345	panel->backlight.device =
1346		backlight_device_register("intel_backlight",
1347					  connector->base.kdev,
1348					  connector,
1349					  &intel_backlight_device_ops, &props);
1350
1351	if (IS_ERR(panel->backlight.device)) {
1352		DRM_ERROR("Failed to register backlight: %ld\n",
1353			  PTR_ERR(panel->backlight.device));
1354		panel->backlight.device = NULL;
1355		return -ENODEV;
1356	}
1357
1358	DRM_DEBUG_KMS("Connector %s backlight sysfs interface registered\n",
1359		      connector->base.name);
1360
1361	return 0;
1362}
1363
1364void intel_backlight_device_unregister(struct intel_connector *connector)
1365{
1366	struct intel_panel *panel = &connector->panel;
1367
1368	if (panel->backlight.device) {
1369		backlight_device_unregister(panel->backlight.device);
1370		panel->backlight.device = NULL;
1371	}
1372}
1373#endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
1374
1375/*
1376 * CNP: PWM clock frequency is 19.2 MHz or 24 MHz.
1377 *      PWM increment = 1
1378 */
1379static u32 cnp_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1380{
1381	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1382
1383	return DIV_ROUND_CLOSEST(KHz(dev_priv->rawclk_freq), pwm_freq_hz);
1384}
1385
1386/*
1387 * BXT: PWM clock frequency = 19.2 MHz.
1388 */
1389static u32 bxt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1390{
1391	return DIV_ROUND_CLOSEST(KHz(19200), pwm_freq_hz);
1392}
1393
1394/*
1395 * SPT: This value represents the period of the PWM stream in clock periods
1396 * multiplied by 16 (default increment) or 128 (alternate increment selected in
1397 * SCHICKEN_1 bit 0). PWM clock is 24 MHz.
1398 */
1399static u32 spt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1400{
1401	struct intel_panel *panel = &connector->panel;
1402	u32 mul;
1403
1404	if (panel->backlight.alternate_pwm_increment)
1405		mul = 128;
1406	else
1407		mul = 16;
1408
1409	return DIV_ROUND_CLOSEST(MHz(24), pwm_freq_hz * mul);
1410}
1411
1412/*
1413 * LPT: This value represents the period of the PWM stream in clock periods
1414 * multiplied by 128 (default increment) or 16 (alternate increment, selected in
1415 * LPT SOUTH_CHICKEN2 register bit 5).
1416 */
1417static u32 lpt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1418{
1419	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1420	struct intel_panel *panel = &connector->panel;
1421	u32 mul, clock;
1422
1423	if (panel->backlight.alternate_pwm_increment)
1424		mul = 16;
1425	else
1426		mul = 128;
1427
1428	if (HAS_PCH_LPT_H(dev_priv))
1429		clock = MHz(135); /* LPT:H */
1430	else
1431		clock = MHz(24); /* LPT:LP */
1432
1433	return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * mul);
1434}
1435
1436/*
1437 * ILK/SNB/IVB: This value represents the period of the PWM stream in PCH
1438 * display raw clocks multiplied by 128.
1439 */
1440static u32 pch_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1441{
1442	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1443
1444	return DIV_ROUND_CLOSEST(KHz(dev_priv->rawclk_freq), pwm_freq_hz * 128);
1445}
1446
1447/*
1448 * Gen2: This field determines the number of time base events (display core
1449 * clock frequency/32) in total for a complete cycle of modulated backlight
1450 * control.
1451 *
1452 * Gen3: A time base event equals the display core clock ([DevPNV] HRAW clock)
1453 * divided by 32.
1454 */
1455static u32 i9xx_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1456{
1457	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1458	int clock;
1459
1460	if (IS_PINEVIEW(dev_priv))
1461		clock = KHz(dev_priv->rawclk_freq);
1462	else
1463		clock = KHz(dev_priv->cdclk.hw.cdclk);
1464
1465	return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * 32);
1466}
1467
1468/*
1469 * Gen4: This value represents the period of the PWM stream in display core
1470 * clocks ([DevCTG] HRAW clocks) multiplied by 128.
1471 *
1472 */
1473static u32 i965_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1474{
1475	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1476	int clock;
1477
1478	if (IS_G4X(dev_priv))
1479		clock = KHz(dev_priv->rawclk_freq);
1480	else
1481		clock = KHz(dev_priv->cdclk.hw.cdclk);
1482
1483	return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * 128);
1484}
1485
1486/*
1487 * VLV: This value represents the period of the PWM stream in display core
1488 * clocks ([DevCTG] 200MHz HRAW clocks) multiplied by 128 or 25MHz S0IX clocks
1489 * multiplied by 16. CHV uses a 19.2MHz S0IX clock.
1490 */
1491static u32 vlv_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1492{
1493	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1494	int mul, clock;
1495
1496	if ((I915_READ(CBR1_VLV) & CBR_PWM_CLOCK_MUX_SELECT) == 0) {
1497		if (IS_CHERRYVIEW(dev_priv))
1498			clock = KHz(19200);
1499		else
1500			clock = MHz(25);
1501		mul = 16;
1502	} else {
1503		clock = KHz(dev_priv->rawclk_freq);
1504		mul = 128;
1505	}
1506
1507	return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * mul);
1508}
1509
1510static u32 get_backlight_max_vbt(struct intel_connector *connector)
 
 
1511{
1512	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1513	struct intel_panel *panel = &connector->panel;
1514	u16 pwm_freq_hz = dev_priv->vbt.backlight.pwm_freq_hz;
1515	u32 pwm;
1516
1517	if (!panel->backlight.hz_to_pwm) {
1518		DRM_DEBUG_KMS("backlight frequency conversion not supported\n");
1519		return 0;
1520	}
1521
1522	if (pwm_freq_hz) {
1523		DRM_DEBUG_KMS("VBT defined backlight frequency %u Hz\n",
1524			      pwm_freq_hz);
1525	} else {
1526		pwm_freq_hz = 200;
1527		DRM_DEBUG_KMS("default backlight frequency %u Hz\n",
1528			      pwm_freq_hz);
1529	}
1530
1531	pwm = panel->backlight.hz_to_pwm(connector, pwm_freq_hz);
1532	if (!pwm) {
1533		DRM_DEBUG_KMS("backlight frequency conversion failed\n");
1534		return 0;
1535	}
1536
1537	return pwm;
1538}
1539
1540/*
1541 * Note: The setup hooks can't assume pipe is set!
1542 */
1543static u32 get_backlight_min_vbt(struct intel_connector *connector)
1544{
1545	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1546	struct intel_panel *panel = &connector->panel;
1547	int min;
1548
1549	WARN_ON(panel->backlight.max == 0);
1550
1551	/*
1552	 * XXX: If the vbt value is 255, it makes min equal to max, which leads
1553	 * to problems. There are such machines out there. Either our
1554	 * interpretation is wrong or the vbt has bogus data. Or both. Safeguard
1555	 * against this by letting the minimum be at most (arbitrarily chosen)
1556	 * 25% of the max.
1557	 */
1558	min = clamp_t(int, dev_priv->vbt.backlight.min_brightness, 0, 64);
1559	if (min != dev_priv->vbt.backlight.min_brightness) {
1560		DRM_DEBUG_KMS("clamping VBT min backlight %d/255 to %d/255\n",
1561			      dev_priv->vbt.backlight.min_brightness, min);
1562	}
1563
1564	/* vbt value is a coefficient in range [0..255] */
1565	return scale(min, 0, 255, 0, panel->backlight.max);
1566}
1567
1568static int lpt_setup_backlight(struct intel_connector *connector, enum pipe unused)
1569{
1570	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1571	struct intel_panel *panel = &connector->panel;
1572	u32 cpu_ctl2, pch_ctl1, pch_ctl2, val;
1573	bool alt, cpu_mode;
1574
1575	if (HAS_PCH_LPT(dev_priv))
1576		alt = I915_READ(SOUTH_CHICKEN2) & LPT_PWM_GRANULARITY;
1577	else
1578		alt = I915_READ(SOUTH_CHICKEN1) & SPT_PWM_GRANULARITY;
1579	panel->backlight.alternate_pwm_increment = alt;
1580
1581	pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1);
1582	panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY;
1583
1584	pch_ctl2 = I915_READ(BLC_PWM_PCH_CTL2);
1585	panel->backlight.max = pch_ctl2 >> 16;
1586
1587	cpu_ctl2 = I915_READ(BLC_PWM_CPU_CTL2);
1588
1589	if (!panel->backlight.max)
1590		panel->backlight.max = get_backlight_max_vbt(connector);
1591
1592	if (!panel->backlight.max)
1593		return -ENODEV;
1594
1595	panel->backlight.min = get_backlight_min_vbt(connector);
1596
1597	panel->backlight.enabled = pch_ctl1 & BLM_PCH_PWM_ENABLE;
1598
1599	cpu_mode = panel->backlight.enabled && HAS_PCH_LPT(dev_priv) &&
1600		   !(pch_ctl1 & BLM_PCH_OVERRIDE_ENABLE) &&
1601		   (cpu_ctl2 & BLM_PWM_ENABLE);
1602	if (cpu_mode)
1603		val = pch_get_backlight(connector);
1604	else
1605		val = lpt_get_backlight(connector);
1606	val = intel_panel_compute_brightness(connector, val);
1607	panel->backlight.level = clamp(val, panel->backlight.min,
1608				       panel->backlight.max);
1609
1610	if (cpu_mode) {
1611		DRM_DEBUG_KMS("CPU backlight register was enabled, switching to PCH override\n");
1612
1613		/* Write converted CPU PWM value to PCH override register */
1614		lpt_set_backlight(connector->base.state, panel->backlight.level);
1615		I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1 | BLM_PCH_OVERRIDE_ENABLE);
1616
1617		I915_WRITE(BLC_PWM_CPU_CTL2, cpu_ctl2 & ~BLM_PWM_ENABLE);
1618	}
1619
1620	return 0;
1621}
1622
1623static int pch_setup_backlight(struct intel_connector *connector, enum pipe unused)
1624{
1625	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1626	struct intel_panel *panel = &connector->panel;
1627	u32 cpu_ctl2, pch_ctl1, pch_ctl2, val;
1628
1629	pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1);
1630	panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY;
1631
1632	pch_ctl2 = I915_READ(BLC_PWM_PCH_CTL2);
1633	panel->backlight.max = pch_ctl2 >> 16;
1634
1635	if (!panel->backlight.max)
1636		panel->backlight.max = get_backlight_max_vbt(connector);
1637
1638	if (!panel->backlight.max)
1639		return -ENODEV;
1640
1641	panel->backlight.min = get_backlight_min_vbt(connector);
1642
1643	val = pch_get_backlight(connector);
1644	val = intel_panel_compute_brightness(connector, val);
1645	panel->backlight.level = clamp(val, panel->backlight.min,
1646				       panel->backlight.max);
1647
1648	cpu_ctl2 = I915_READ(BLC_PWM_CPU_CTL2);
1649	panel->backlight.enabled = (cpu_ctl2 & BLM_PWM_ENABLE) &&
1650		(pch_ctl1 & BLM_PCH_PWM_ENABLE);
1651
1652	return 0;
1653}
1654
1655static int i9xx_setup_backlight(struct intel_connector *connector, enum pipe unused)
1656{
1657	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1658	struct intel_panel *panel = &connector->panel;
1659	u32 ctl, val;
1660
1661	ctl = I915_READ(BLC_PWM_CTL);
1662
1663	if (IS_GEN(dev_priv, 2) || IS_I915GM(dev_priv) || IS_I945GM(dev_priv))
1664		panel->backlight.combination_mode = ctl & BLM_LEGACY_MODE;
1665
1666	if (IS_PINEVIEW(dev_priv))
1667		panel->backlight.active_low_pwm = ctl & BLM_POLARITY_PNV;
1668
1669	panel->backlight.max = ctl >> 17;
1670
1671	if (!panel->backlight.max) {
1672		panel->backlight.max = get_backlight_max_vbt(connector);
1673		panel->backlight.max >>= 1;
1674	}
1675
1676	if (!panel->backlight.max)
1677		return -ENODEV;
1678
1679	if (panel->backlight.combination_mode)
1680		panel->backlight.max *= 0xff;
1681
1682	panel->backlight.min = get_backlight_min_vbt(connector);
1683
1684	val = i9xx_get_backlight(connector);
1685	val = intel_panel_compute_brightness(connector, val);
1686	panel->backlight.level = clamp(val, panel->backlight.min,
1687				       panel->backlight.max);
1688
1689	panel->backlight.enabled = val != 0;
1690
1691	return 0;
1692}
1693
1694static int i965_setup_backlight(struct intel_connector *connector, enum pipe unused)
1695{
1696	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1697	struct intel_panel *panel = &connector->panel;
1698	u32 ctl, ctl2, val;
1699
1700	ctl2 = I915_READ(BLC_PWM_CTL2);
1701	panel->backlight.combination_mode = ctl2 & BLM_COMBINATION_MODE;
1702	panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
1703
1704	ctl = I915_READ(BLC_PWM_CTL);
1705	panel->backlight.max = ctl >> 16;
1706
1707	if (!panel->backlight.max)
1708		panel->backlight.max = get_backlight_max_vbt(connector);
1709
1710	if (!panel->backlight.max)
1711		return -ENODEV;
1712
1713	if (panel->backlight.combination_mode)
1714		panel->backlight.max *= 0xff;
1715
1716	panel->backlight.min = get_backlight_min_vbt(connector);
1717
1718	val = i9xx_get_backlight(connector);
1719	val = intel_panel_compute_brightness(connector, val);
1720	panel->backlight.level = clamp(val, panel->backlight.min,
1721				       panel->backlight.max);
1722
1723	panel->backlight.enabled = ctl2 & BLM_PWM_ENABLE;
1724
1725	return 0;
1726}
1727
1728static int vlv_setup_backlight(struct intel_connector *connector, enum pipe pipe)
1729{
1730	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1731	struct intel_panel *panel = &connector->panel;
1732	u32 ctl, ctl2, val;
1733
1734	if (WARN_ON(pipe != PIPE_A && pipe != PIPE_B))
1735		return -ENODEV;
1736
1737	ctl2 = I915_READ(VLV_BLC_PWM_CTL2(pipe));
1738	panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
1739
1740	ctl = I915_READ(VLV_BLC_PWM_CTL(pipe));
1741	panel->backlight.max = ctl >> 16;
1742
1743	if (!panel->backlight.max)
1744		panel->backlight.max = get_backlight_max_vbt(connector);
1745
1746	if (!panel->backlight.max)
1747		return -ENODEV;
1748
1749	panel->backlight.min = get_backlight_min_vbt(connector);
1750
1751	val = _vlv_get_backlight(dev_priv, pipe);
1752	val = intel_panel_compute_brightness(connector, val);
1753	panel->backlight.level = clamp(val, panel->backlight.min,
1754				       panel->backlight.max);
1755
1756	panel->backlight.enabled = ctl2 & BLM_PWM_ENABLE;
1757
1758	return 0;
1759}
1760
1761static int
1762bxt_setup_backlight(struct intel_connector *connector, enum pipe unused)
1763{
1764	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1765	struct intel_panel *panel = &connector->panel;
1766	u32 pwm_ctl, val;
1767
1768	panel->backlight.controller = dev_priv->vbt.backlight.controller;
1769
1770	pwm_ctl = I915_READ(BXT_BLC_PWM_CTL(panel->backlight.controller));
1771
1772	/* Controller 1 uses the utility pin. */
1773	if (panel->backlight.controller == 1) {
1774		val = I915_READ(UTIL_PIN_CTL);
1775		panel->backlight.util_pin_active_low =
1776					val & UTIL_PIN_POLARITY;
1777	}
1778
1779	panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY;
1780	panel->backlight.max =
1781		I915_READ(BXT_BLC_PWM_FREQ(panel->backlight.controller));
1782
1783	if (!panel->backlight.max)
1784		panel->backlight.max = get_backlight_max_vbt(connector);
1785
1786	if (!panel->backlight.max)
1787		return -ENODEV;
1788
1789	panel->backlight.min = get_backlight_min_vbt(connector);
 
1790
1791	val = bxt_get_backlight(connector);
1792	val = intel_panel_compute_brightness(connector, val);
1793	panel->backlight.level = clamp(val, panel->backlight.min,
1794				       panel->backlight.max);
1795
1796	panel->backlight.enabled = pwm_ctl & BXT_BLC_PWM_ENABLE;
 
1797
1798	return 0;
1799}
1800
1801static int
1802cnp_setup_backlight(struct intel_connector *connector, enum pipe unused)
1803{
1804	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1805	struct intel_panel *panel = &connector->panel;
1806	u32 pwm_ctl, val;
1807
1808	/*
1809	 * CNP has the BXT implementation of backlight, but with only one
1810	 * controller. TODO: ICP has multiple controllers but we only use
1811	 * controller 0 for now.
1812	 */
1813	panel->backlight.controller = 0;
1814
1815	pwm_ctl = I915_READ(BXT_BLC_PWM_CTL(panel->backlight.controller));
1816
1817	panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY;
1818	panel->backlight.max =
1819		I915_READ(BXT_BLC_PWM_FREQ(panel->backlight.controller));
1820
1821	if (!panel->backlight.max)
1822		panel->backlight.max = get_backlight_max_vbt(connector);
1823
1824	if (!panel->backlight.max)
1825		return -ENODEV;
1826
1827	panel->backlight.min = get_backlight_min_vbt(connector);
1828
1829	val = bxt_get_backlight(connector);
1830	val = intel_panel_compute_brightness(connector, val);
1831	panel->backlight.level = clamp(val, panel->backlight.min,
1832				       panel->backlight.max);
1833
1834	panel->backlight.enabled = pwm_ctl & BXT_BLC_PWM_ENABLE;
1835
1836	return 0;
1837}
1838
1839static int pwm_setup_backlight(struct intel_connector *connector,
1840			       enum pipe pipe)
1841{
1842	struct drm_device *dev = connector->base.dev;
1843	struct intel_panel *panel = &connector->panel;
1844	int retval;
1845
1846	/* Get the PWM chip for backlight control */
1847	panel->backlight.pwm = pwm_get(dev->dev, "pwm_backlight");
1848	if (IS_ERR(panel->backlight.pwm)) {
1849		DRM_ERROR("Failed to own the pwm chip\n");
1850		panel->backlight.pwm = NULL;
1851		return -ENODEV;
1852	}
1853
1854	/*
1855	 * FIXME: pwm_apply_args() should be removed when switching to
1856	 * the atomic PWM API.
1857	 */
1858	pwm_apply_args(panel->backlight.pwm);
1859
1860	retval = pwm_config(panel->backlight.pwm, CRC_PMIC_PWM_PERIOD_NS,
1861			    CRC_PMIC_PWM_PERIOD_NS);
1862	if (retval < 0) {
1863		DRM_ERROR("Failed to configure the pwm chip\n");
1864		pwm_put(panel->backlight.pwm);
1865		panel->backlight.pwm = NULL;
1866		return retval;
1867	}
1868
1869	panel->backlight.min = 0; /* 0% */
1870	panel->backlight.max = 100; /* 100% */
1871	panel->backlight.level = DIV_ROUND_UP(
1872				 pwm_get_duty_cycle(panel->backlight.pwm) * 100,
1873				 CRC_PMIC_PWM_PERIOD_NS);
1874	panel->backlight.enabled = panel->backlight.level != 0;
1875
1876	return 0;
1877}
1878
1879void intel_panel_update_backlight(struct intel_encoder *encoder,
1880				  const struct intel_crtc_state *crtc_state,
1881				  const struct drm_connector_state *conn_state)
1882{
1883	struct intel_connector *connector = to_intel_connector(conn_state->connector);
1884	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1885	struct intel_panel *panel = &connector->panel;
 
1886
1887	if (!panel->backlight.present)
1888		return;
1889
1890	mutex_lock(&dev_priv->backlight_lock);
1891	if (!panel->backlight.enabled)
1892		__intel_panel_enable_backlight(crtc_state, conn_state);
1893
1894	mutex_unlock(&dev_priv->backlight_lock);
1895}
1896
1897int intel_panel_setup_backlight(struct drm_connector *connector, enum pipe pipe)
1898{
1899	struct drm_i915_private *dev_priv = to_i915(connector->dev);
1900	struct intel_connector *intel_connector = to_intel_connector(connector);
1901	struct intel_panel *panel = &intel_connector->panel;
1902	int ret;
1903
1904	if (!dev_priv->vbt.backlight.present) {
1905		if (dev_priv->quirks & QUIRK_BACKLIGHT_PRESENT) {
1906			DRM_DEBUG_KMS("no backlight present per VBT, but present per quirk\n");
1907		} else {
1908			DRM_DEBUG_KMS("no backlight present per VBT\n");
1909			return 0;
1910		}
1911	}
1912
1913	/* ensure intel_panel has been initialized first */
1914	if (WARN_ON(!panel->backlight.setup))
1915		return -ENODEV;
1916
1917	/* set level and max in panel struct */
1918	mutex_lock(&dev_priv->backlight_lock);
1919	ret = panel->backlight.setup(intel_connector, pipe);
1920	mutex_unlock(&dev_priv->backlight_lock);
1921
1922	if (ret) {
1923		DRM_DEBUG_KMS("failed to setup backlight for connector %s\n",
1924			      connector->name);
1925		return ret;
1926	}
1927
1928	panel->backlight.present = true;
1929
1930	DRM_DEBUG_KMS("Connector %s backlight initialized, %s, brightness %u/%u\n",
1931		      connector->name,
1932		      enableddisabled(panel->backlight.enabled),
1933		      panel->backlight.level, panel->backlight.max);
1934
1935	return 0;
1936}
1937
1938static void intel_panel_destroy_backlight(struct intel_panel *panel)
1939{
1940	/* dispose of the pwm */
1941	if (panel->backlight.pwm)
1942		pwm_put(panel->backlight.pwm);
1943
1944	panel->backlight.present = false;
1945}
1946
1947/* Set up chip specific backlight functions */
1948static void
1949intel_panel_init_backlight_funcs(struct intel_panel *panel)
1950{
1951	struct intel_connector *connector =
1952		container_of(panel, struct intel_connector, panel);
1953	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1954
1955	if (connector->base.connector_type == DRM_MODE_CONNECTOR_eDP &&
1956	    intel_dp_aux_init_backlight_funcs(connector) == 0)
1957		return;
1958
1959	if (connector->base.connector_type == DRM_MODE_CONNECTOR_DSI &&
1960	    intel_dsi_dcs_init_backlight_funcs(connector) == 0)
1961		return;
1962
1963	if (IS_GEN9_LP(dev_priv)) {
1964		panel->backlight.setup = bxt_setup_backlight;
1965		panel->backlight.enable = bxt_enable_backlight;
1966		panel->backlight.disable = bxt_disable_backlight;
1967		panel->backlight.set = bxt_set_backlight;
1968		panel->backlight.get = bxt_get_backlight;
1969		panel->backlight.hz_to_pwm = bxt_hz_to_pwm;
1970	} else if (INTEL_PCH_TYPE(dev_priv) >= PCH_CNP) {
1971		panel->backlight.setup = cnp_setup_backlight;
1972		panel->backlight.enable = cnp_enable_backlight;
1973		panel->backlight.disable = cnp_disable_backlight;
1974		panel->backlight.set = bxt_set_backlight;
1975		panel->backlight.get = bxt_get_backlight;
1976		panel->backlight.hz_to_pwm = cnp_hz_to_pwm;
1977	} else if (INTEL_PCH_TYPE(dev_priv) >= PCH_LPT) {
1978		panel->backlight.setup = lpt_setup_backlight;
1979		panel->backlight.enable = lpt_enable_backlight;
1980		panel->backlight.disable = lpt_disable_backlight;
1981		panel->backlight.set = lpt_set_backlight;
1982		panel->backlight.get = lpt_get_backlight;
1983		if (HAS_PCH_LPT(dev_priv))
1984			panel->backlight.hz_to_pwm = lpt_hz_to_pwm;
1985		else
1986			panel->backlight.hz_to_pwm = spt_hz_to_pwm;
1987	} else if (HAS_PCH_SPLIT(dev_priv)) {
1988		panel->backlight.setup = pch_setup_backlight;
1989		panel->backlight.enable = pch_enable_backlight;
1990		panel->backlight.disable = pch_disable_backlight;
1991		panel->backlight.set = pch_set_backlight;
1992		panel->backlight.get = pch_get_backlight;
1993		panel->backlight.hz_to_pwm = pch_hz_to_pwm;
1994	} else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
1995		if (connector->base.connector_type == DRM_MODE_CONNECTOR_DSI) {
1996			panel->backlight.setup = pwm_setup_backlight;
1997			panel->backlight.enable = pwm_enable_backlight;
1998			panel->backlight.disable = pwm_disable_backlight;
1999			panel->backlight.set = pwm_set_backlight;
2000			panel->backlight.get = pwm_get_backlight;
2001		} else {
2002			panel->backlight.setup = vlv_setup_backlight;
2003			panel->backlight.enable = vlv_enable_backlight;
2004			panel->backlight.disable = vlv_disable_backlight;
2005			panel->backlight.set = vlv_set_backlight;
2006			panel->backlight.get = vlv_get_backlight;
2007			panel->backlight.hz_to_pwm = vlv_hz_to_pwm;
2008		}
2009	} else if (IS_GEN(dev_priv, 4)) {
2010		panel->backlight.setup = i965_setup_backlight;
2011		panel->backlight.enable = i965_enable_backlight;
2012		panel->backlight.disable = i965_disable_backlight;
2013		panel->backlight.set = i9xx_set_backlight;
2014		panel->backlight.get = i9xx_get_backlight;
2015		panel->backlight.hz_to_pwm = i965_hz_to_pwm;
2016	} else {
2017		panel->backlight.setup = i9xx_setup_backlight;
2018		panel->backlight.enable = i9xx_enable_backlight;
2019		panel->backlight.disable = i9xx_disable_backlight;
2020		panel->backlight.set = i9xx_set_backlight;
2021		panel->backlight.get = i9xx_get_backlight;
2022		panel->backlight.hz_to_pwm = i9xx_hz_to_pwm;
2023	}
2024}
2025
2026int intel_panel_init(struct intel_panel *panel,
2027		     struct drm_display_mode *fixed_mode,
2028		     struct drm_display_mode *downclock_mode)
2029{
2030	intel_panel_init_backlight_funcs(panel);
2031
2032	panel->fixed_mode = fixed_mode;
2033	panel->downclock_mode = downclock_mode;
2034
2035	return 0;
2036}
2037
2038void intel_panel_fini(struct intel_panel *panel)
2039{
2040	struct intel_connector *intel_connector =
2041		container_of(panel, struct intel_connector, panel);
2042
2043	intel_panel_destroy_backlight(panel);
2044
2045	if (panel->fixed_mode)
2046		drm_mode_destroy(intel_connector->base.dev, panel->fixed_mode);
2047
2048	if (panel->downclock_mode)
2049		drm_mode_destroy(intel_connector->base.dev,
2050				panel->downclock_mode);
2051}