1 // SPDX-License-Identifier: MIT
3 * Copyright © 2021 Intel Corporation
6 #include <linux/kernel.h>
8 #include <linux/string_helpers.h>
10 #include "intel_backlight.h"
11 #include "intel_connector.h"
13 #include "intel_display_types.h"
14 #include "intel_dp_aux_backlight.h"
15 #include "intel_dsi_dcs_backlight.h"
16 #include "intel_panel.h"
17 #include "intel_pci_config.h"
20 * scale - scale values from one range to another
21 * @source_val: value in range [@source_min..@source_max]
22 * @source_min: minimum legal value for @source_val
23 * @source_max: maximum legal value for @source_val
24 * @target_min: corresponding target value for @source_min
25 * @target_max: corresponding target value for @source_max
27 * Return @source_val in range [@source_min..@source_max] scaled to range
28 * [@target_min..@target_max].
30 static u32 scale(u32 source_val,
31 u32 source_min, u32 source_max,
32 u32 target_min, u32 target_max)
36 WARN_ON(source_min > source_max);
37 WARN_ON(target_min > target_max);
40 source_val = clamp(source_val, source_min, source_max);
43 target_val = mul_u32_u32(source_val - source_min,
44 target_max - target_min);
45 target_val = DIV_ROUND_CLOSEST_ULL(target_val, source_max - source_min);
46 target_val += target_min;
52 * Scale user_level in range [0..user_max] to [0..hw_max], clamping the result
53 * to [hw_min..hw_max].
55 static u32 clamp_user_to_hw(struct intel_connector *connector,
56 u32 user_level, u32 user_max)
58 struct intel_panel *panel = &connector->panel;
61 hw_level = scale(user_level, 0, user_max, 0, panel->backlight.max);
62 hw_level = clamp(hw_level, panel->backlight.min, panel->backlight.max);
67 /* Scale hw_level in range [hw_min..hw_max] to [0..user_max]. */
68 static u32 scale_hw_to_user(struct intel_connector *connector,
69 u32 hw_level, u32 user_max)
71 struct intel_panel *panel = &connector->panel;
73 return scale(hw_level, panel->backlight.min, panel->backlight.max,
77 u32 intel_backlight_invert_pwm_level(struct intel_connector *connector, u32 val)
79 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
80 struct intel_panel *panel = &connector->panel;
82 drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0);
84 if (dev_priv->params.invert_brightness < 0)
87 if (dev_priv->params.invert_brightness > 0 ||
88 dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS) {
89 return panel->backlight.pwm_level_max - val + panel->backlight.pwm_level_min;
95 void intel_backlight_set_pwm_level(const struct drm_connector_state *conn_state, u32 val)
97 struct intel_connector *connector = to_intel_connector(conn_state->connector);
98 struct drm_i915_private *i915 = to_i915(connector->base.dev);
99 struct intel_panel *panel = &connector->panel;
101 drm_dbg_kms(&i915->drm, "set backlight PWM = %d\n", val);
102 panel->backlight.pwm_funcs->set(conn_state, val);
105 u32 intel_backlight_level_to_pwm(struct intel_connector *connector, u32 val)
107 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
108 struct intel_panel *panel = &connector->panel;
110 drm_WARN_ON_ONCE(&dev_priv->drm,
111 panel->backlight.max == 0 || panel->backlight.pwm_level_max == 0);
113 val = scale(val, panel->backlight.min, panel->backlight.max,
114 panel->backlight.pwm_level_min, panel->backlight.pwm_level_max);
116 return intel_backlight_invert_pwm_level(connector, val);
119 u32 intel_backlight_level_from_pwm(struct intel_connector *connector, u32 val)
121 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
122 struct intel_panel *panel = &connector->panel;
124 drm_WARN_ON_ONCE(&dev_priv->drm,
125 panel->backlight.max == 0 || panel->backlight.pwm_level_max == 0);
127 if (dev_priv->params.invert_brightness > 0 ||
128 (dev_priv->params.invert_brightness == 0 && dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS))
129 val = panel->backlight.pwm_level_max - (val - panel->backlight.pwm_level_min);
131 return scale(val, panel->backlight.pwm_level_min, panel->backlight.pwm_level_max,
132 panel->backlight.min, panel->backlight.max);
135 static u32 lpt_get_backlight(struct intel_connector *connector, enum pipe unused)
137 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
139 return intel_de_read(dev_priv, BLC_PWM_PCH_CTL2) & BACKLIGHT_DUTY_CYCLE_MASK;
142 static u32 pch_get_backlight(struct intel_connector *connector, enum pipe unused)
144 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
146 return intel_de_read(dev_priv, BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
149 static u32 i9xx_get_backlight(struct intel_connector *connector, enum pipe unused)
151 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
152 struct intel_panel *panel = &connector->panel;
155 val = intel_de_read(dev_priv, BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
156 if (DISPLAY_VER(dev_priv) < 4)
159 if (panel->backlight.combination_mode) {
162 pci_read_config_byte(to_pci_dev(dev_priv->drm.dev), LBPC, &lbpc);
169 static u32 vlv_get_backlight(struct intel_connector *connector, enum pipe pipe)
171 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
173 if (drm_WARN_ON(&dev_priv->drm, pipe != PIPE_A && pipe != PIPE_B))
176 return intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)) & BACKLIGHT_DUTY_CYCLE_MASK;
179 static u32 bxt_get_backlight(struct intel_connector *connector, enum pipe unused)
181 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
182 struct intel_panel *panel = &connector->panel;
184 return intel_de_read(dev_priv,
185 BXT_BLC_PWM_DUTY(panel->backlight.controller));
188 static u32 ext_pwm_get_backlight(struct intel_connector *connector, enum pipe unused)
190 struct intel_panel *panel = &connector->panel;
191 struct pwm_state state;
193 pwm_get_state(panel->backlight.pwm, &state);
194 return pwm_get_relative_duty_cycle(&state, 100);
197 static void lpt_set_backlight(const struct drm_connector_state *conn_state, u32 level)
199 struct intel_connector *connector = to_intel_connector(conn_state->connector);
200 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
202 u32 val = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2) & ~BACKLIGHT_DUTY_CYCLE_MASK;
203 intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, val | level);
206 static void pch_set_backlight(const struct drm_connector_state *conn_state, u32 level)
208 struct intel_connector *connector = to_intel_connector(conn_state->connector);
209 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
212 tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK;
213 intel_de_write(dev_priv, BLC_PWM_CPU_CTL, tmp | level);
216 static void i9xx_set_backlight(const struct drm_connector_state *conn_state, u32 level)
218 struct intel_connector *connector = to_intel_connector(conn_state->connector);
219 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
220 struct intel_panel *panel = &connector->panel;
223 drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0);
225 if (panel->backlight.combination_mode) {
228 lbpc = level * 0xfe / panel->backlight.pwm_level_max + 1;
230 pci_write_config_byte(to_pci_dev(dev_priv->drm.dev), LBPC, lbpc);
233 if (DISPLAY_VER(dev_priv) == 4) {
234 mask = BACKLIGHT_DUTY_CYCLE_MASK;
237 mask = BACKLIGHT_DUTY_CYCLE_MASK_PNV;
240 tmp = intel_de_read(dev_priv, BLC_PWM_CTL) & ~mask;
241 intel_de_write(dev_priv, BLC_PWM_CTL, tmp | level);
244 static void vlv_set_backlight(const struct drm_connector_state *conn_state, u32 level)
246 struct intel_connector *connector = to_intel_connector(conn_state->connector);
247 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
248 enum pipe pipe = to_intel_crtc(conn_state->crtc)->pipe;
251 tmp = intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)) & ~BACKLIGHT_DUTY_CYCLE_MASK;
252 intel_de_write(dev_priv, VLV_BLC_PWM_CTL(pipe), tmp | level);
255 static void bxt_set_backlight(const struct drm_connector_state *conn_state, u32 level)
257 struct intel_connector *connector = to_intel_connector(conn_state->connector);
258 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
259 struct intel_panel *panel = &connector->panel;
261 intel_de_write(dev_priv,
262 BXT_BLC_PWM_DUTY(panel->backlight.controller), level);
265 static void ext_pwm_set_backlight(const struct drm_connector_state *conn_state, u32 level)
267 struct intel_panel *panel = &to_intel_connector(conn_state->connector)->panel;
269 pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
270 pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
274 intel_panel_actually_set_backlight(const struct drm_connector_state *conn_state, u32 level)
276 struct intel_connector *connector = to_intel_connector(conn_state->connector);
277 struct drm_i915_private *i915 = to_i915(connector->base.dev);
278 struct intel_panel *panel = &connector->panel;
280 drm_dbg_kms(&i915->drm, "set backlight level = %d\n", level);
282 panel->backlight.funcs->set(conn_state, level);
285 /* set backlight brightness to level in range [0..max], assuming hw min is
288 void intel_backlight_set_acpi(const struct drm_connector_state *conn_state,
289 u32 user_level, u32 user_max)
291 struct intel_connector *connector = to_intel_connector(conn_state->connector);
292 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
293 struct intel_panel *panel = &connector->panel;
297 * Lack of crtc may occur during driver init because
298 * connection_mutex isn't held across the entire backlight
299 * setup + modeset readout, and the BIOS can issue the
300 * requests at any time.
302 if (!panel->backlight.present || !conn_state->crtc)
305 mutex_lock(&dev_priv->backlight_lock);
307 drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0);
309 hw_level = clamp_user_to_hw(connector, user_level, user_max);
310 panel->backlight.level = hw_level;
312 if (panel->backlight.device)
313 panel->backlight.device->props.brightness =
314 scale_hw_to_user(connector,
315 panel->backlight.level,
316 panel->backlight.device->props.max_brightness);
318 if (panel->backlight.enabled)
319 intel_panel_actually_set_backlight(conn_state, hw_level);
321 mutex_unlock(&dev_priv->backlight_lock);
324 static void lpt_disable_backlight(const struct drm_connector_state *old_conn_state, u32 level)
326 struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
327 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
330 intel_backlight_set_pwm_level(old_conn_state, level);
333 * Although we don't support or enable CPU PWM with LPT/SPT based
334 * systems, it may have been enabled prior to loading the
335 * driver. Disable to avoid warnings on LCPLL disable.
337 * This needs rework if we need to add support for CPU PWM on PCH split
340 tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
341 if (tmp & BLM_PWM_ENABLE) {
342 drm_dbg_kms(&dev_priv->drm,
343 "cpu backlight was enabled, disabling\n");
344 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2,
345 tmp & ~BLM_PWM_ENABLE);
348 tmp = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
349 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE);
352 static void pch_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
354 struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
355 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
358 intel_backlight_set_pwm_level(old_conn_state, val);
360 tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
361 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, tmp & ~BLM_PWM_ENABLE);
363 tmp = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
364 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE);
367 static void i9xx_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
369 intel_backlight_set_pwm_level(old_conn_state, val);
372 static void i965_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
374 struct drm_i915_private *dev_priv = to_i915(old_conn_state->connector->dev);
377 intel_backlight_set_pwm_level(old_conn_state, val);
379 tmp = intel_de_read(dev_priv, BLC_PWM_CTL2);
380 intel_de_write(dev_priv, BLC_PWM_CTL2, tmp & ~BLM_PWM_ENABLE);
383 static void vlv_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
385 struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
386 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
387 enum pipe pipe = to_intel_crtc(old_conn_state->crtc)->pipe;
390 intel_backlight_set_pwm_level(old_conn_state, val);
392 tmp = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
393 intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe),
394 tmp & ~BLM_PWM_ENABLE);
397 static void bxt_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
399 struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
400 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
401 struct intel_panel *panel = &connector->panel;
404 intel_backlight_set_pwm_level(old_conn_state, val);
406 tmp = intel_de_read(dev_priv,
407 BXT_BLC_PWM_CTL(panel->backlight.controller));
408 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
409 tmp & ~BXT_BLC_PWM_ENABLE);
411 if (panel->backlight.controller == 1) {
412 val = intel_de_read(dev_priv, UTIL_PIN_CTL);
413 val &= ~UTIL_PIN_ENABLE;
414 intel_de_write(dev_priv, UTIL_PIN_CTL, val);
418 static void cnp_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
420 struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
421 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
422 struct intel_panel *panel = &connector->panel;
425 intel_backlight_set_pwm_level(old_conn_state, val);
427 tmp = intel_de_read(dev_priv,
428 BXT_BLC_PWM_CTL(panel->backlight.controller));
429 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
430 tmp & ~BXT_BLC_PWM_ENABLE);
433 static void ext_pwm_disable_backlight(const struct drm_connector_state *old_conn_state, u32 level)
435 struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
436 struct intel_panel *panel = &connector->panel;
438 intel_backlight_set_pwm_level(old_conn_state, level);
440 panel->backlight.pwm_state.enabled = false;
441 pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
444 void intel_backlight_disable(const struct drm_connector_state *old_conn_state)
446 struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
447 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
448 struct intel_panel *panel = &connector->panel;
450 if (!panel->backlight.present)
454 * Do not disable backlight on the vga_switcheroo path. When switching
455 * away from i915, the other client may depend on i915 to handle the
456 * backlight. This will leave the backlight on unnecessarily when
457 * another client is not activated.
459 if (dev_priv->drm.switch_power_state == DRM_SWITCH_POWER_CHANGING) {
460 drm_dbg_kms(&dev_priv->drm,
461 "Skipping backlight disable on vga switch\n");
465 mutex_lock(&dev_priv->backlight_lock);
467 if (panel->backlight.device)
468 panel->backlight.device->props.power = FB_BLANK_POWERDOWN;
469 panel->backlight.enabled = false;
470 panel->backlight.funcs->disable(old_conn_state, 0);
472 mutex_unlock(&dev_priv->backlight_lock);
475 static void lpt_enable_backlight(const struct intel_crtc_state *crtc_state,
476 const struct drm_connector_state *conn_state, u32 level)
478 struct intel_connector *connector = to_intel_connector(conn_state->connector);
479 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
480 struct intel_panel *panel = &connector->panel;
481 u32 pch_ctl1, pch_ctl2, schicken;
483 pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
484 if (pch_ctl1 & BLM_PCH_PWM_ENABLE) {
485 drm_dbg_kms(&dev_priv->drm, "pch backlight already enabled\n");
486 pch_ctl1 &= ~BLM_PCH_PWM_ENABLE;
487 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
490 if (HAS_PCH_LPT(dev_priv)) {
491 schicken = intel_de_read(dev_priv, SOUTH_CHICKEN2);
492 if (panel->backlight.alternate_pwm_increment)
493 schicken |= LPT_PWM_GRANULARITY;
495 schicken &= ~LPT_PWM_GRANULARITY;
496 intel_de_write(dev_priv, SOUTH_CHICKEN2, schicken);
498 schicken = intel_de_read(dev_priv, SOUTH_CHICKEN1);
499 if (panel->backlight.alternate_pwm_increment)
500 schicken |= SPT_PWM_GRANULARITY;
502 schicken &= ~SPT_PWM_GRANULARITY;
503 intel_de_write(dev_priv, SOUTH_CHICKEN1, schicken);
506 pch_ctl2 = panel->backlight.pwm_level_max << 16;
507 intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, pch_ctl2);
510 if (panel->backlight.active_low_pwm)
511 pch_ctl1 |= BLM_PCH_POLARITY;
513 /* After LPT, override is the default. */
514 if (HAS_PCH_LPT(dev_priv))
515 pch_ctl1 |= BLM_PCH_OVERRIDE_ENABLE;
517 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
518 intel_de_posting_read(dev_priv, BLC_PWM_PCH_CTL1);
519 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1,
520 pch_ctl1 | BLM_PCH_PWM_ENABLE);
522 /* This won't stick until the above enable. */
523 intel_backlight_set_pwm_level(conn_state, level);
526 static void pch_enable_backlight(const struct intel_crtc_state *crtc_state,
527 const struct drm_connector_state *conn_state, u32 level)
529 struct intel_connector *connector = to_intel_connector(conn_state->connector);
530 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
531 struct intel_panel *panel = &connector->panel;
532 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
533 u32 cpu_ctl2, pch_ctl1, pch_ctl2;
535 cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
536 if (cpu_ctl2 & BLM_PWM_ENABLE) {
537 drm_dbg_kms(&dev_priv->drm, "cpu backlight already enabled\n");
538 cpu_ctl2 &= ~BLM_PWM_ENABLE;
539 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2);
542 pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
543 if (pch_ctl1 & BLM_PCH_PWM_ENABLE) {
544 drm_dbg_kms(&dev_priv->drm, "pch backlight already enabled\n");
545 pch_ctl1 &= ~BLM_PCH_PWM_ENABLE;
546 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
549 if (cpu_transcoder == TRANSCODER_EDP)
550 cpu_ctl2 = BLM_TRANSCODER_EDP;
552 cpu_ctl2 = BLM_PIPE(cpu_transcoder);
553 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2);
554 intel_de_posting_read(dev_priv, BLC_PWM_CPU_CTL2);
555 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2 | BLM_PWM_ENABLE);
557 /* This won't stick until the above enable. */
558 intel_backlight_set_pwm_level(conn_state, level);
560 pch_ctl2 = panel->backlight.pwm_level_max << 16;
561 intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, pch_ctl2);
564 if (panel->backlight.active_low_pwm)
565 pch_ctl1 |= BLM_PCH_POLARITY;
567 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
568 intel_de_posting_read(dev_priv, BLC_PWM_PCH_CTL1);
569 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1,
570 pch_ctl1 | BLM_PCH_PWM_ENABLE);
573 static void i9xx_enable_backlight(const struct intel_crtc_state *crtc_state,
574 const struct drm_connector_state *conn_state, u32 level)
576 struct intel_connector *connector = to_intel_connector(conn_state->connector);
577 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
578 struct intel_panel *panel = &connector->panel;
581 ctl = intel_de_read(dev_priv, BLC_PWM_CTL);
582 if (ctl & BACKLIGHT_DUTY_CYCLE_MASK_PNV) {
583 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
584 intel_de_write(dev_priv, BLC_PWM_CTL, 0);
587 freq = panel->backlight.pwm_level_max;
588 if (panel->backlight.combination_mode)
592 if (panel->backlight.combination_mode)
593 ctl |= BLM_LEGACY_MODE;
594 if (IS_PINEVIEW(dev_priv) && panel->backlight.active_low_pwm)
595 ctl |= BLM_POLARITY_PNV;
597 intel_de_write(dev_priv, BLC_PWM_CTL, ctl);
598 intel_de_posting_read(dev_priv, BLC_PWM_CTL);
600 /* XXX: combine this into above write? */
601 intel_backlight_set_pwm_level(conn_state, level);
604 * Needed to enable backlight on some 855gm models. BLC_HIST_CTL is
605 * 855gm only, but checking for gen2 is safe, as 855gm is the only gen2
606 * that has backlight.
608 if (DISPLAY_VER(dev_priv) == 2)
609 intel_de_write(dev_priv, BLC_HIST_CTL, BLM_HISTOGRAM_ENABLE);
612 static void i965_enable_backlight(const struct intel_crtc_state *crtc_state,
613 const struct drm_connector_state *conn_state, u32 level)
615 struct intel_connector *connector = to_intel_connector(conn_state->connector);
616 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
617 struct intel_panel *panel = &connector->panel;
618 enum pipe pipe = to_intel_crtc(conn_state->crtc)->pipe;
621 ctl2 = intel_de_read(dev_priv, BLC_PWM_CTL2);
622 if (ctl2 & BLM_PWM_ENABLE) {
623 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
624 ctl2 &= ~BLM_PWM_ENABLE;
625 intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2);
628 freq = panel->backlight.pwm_level_max;
629 if (panel->backlight.combination_mode)
633 intel_de_write(dev_priv, BLC_PWM_CTL, ctl);
635 ctl2 = BLM_PIPE(pipe);
636 if (panel->backlight.combination_mode)
637 ctl2 |= BLM_COMBINATION_MODE;
638 if (panel->backlight.active_low_pwm)
639 ctl2 |= BLM_POLARITY_I965;
640 intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2);
641 intel_de_posting_read(dev_priv, BLC_PWM_CTL2);
642 intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2 | BLM_PWM_ENABLE);
644 intel_backlight_set_pwm_level(conn_state, level);
647 static void vlv_enable_backlight(const struct intel_crtc_state *crtc_state,
648 const struct drm_connector_state *conn_state, u32 level)
650 struct intel_connector *connector = to_intel_connector(conn_state->connector);
651 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
652 struct intel_panel *panel = &connector->panel;
653 enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
656 ctl2 = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
657 if (ctl2 & BLM_PWM_ENABLE) {
658 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
659 ctl2 &= ~BLM_PWM_ENABLE;
660 intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe), ctl2);
663 ctl = panel->backlight.pwm_level_max << 16;
664 intel_de_write(dev_priv, VLV_BLC_PWM_CTL(pipe), ctl);
666 /* XXX: combine this into above write? */
667 intel_backlight_set_pwm_level(conn_state, level);
670 if (panel->backlight.active_low_pwm)
671 ctl2 |= BLM_POLARITY_I965;
672 intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe), ctl2);
673 intel_de_posting_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
674 intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe),
675 ctl2 | BLM_PWM_ENABLE);
678 static void bxt_enable_backlight(const struct intel_crtc_state *crtc_state,
679 const struct drm_connector_state *conn_state, u32 level)
681 struct intel_connector *connector = to_intel_connector(conn_state->connector);
682 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
683 struct intel_panel *panel = &connector->panel;
684 enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
687 /* Controller 1 uses the utility pin. */
688 if (panel->backlight.controller == 1) {
689 val = intel_de_read(dev_priv, UTIL_PIN_CTL);
690 if (val & UTIL_PIN_ENABLE) {
691 drm_dbg_kms(&dev_priv->drm,
692 "util pin already enabled\n");
693 val &= ~UTIL_PIN_ENABLE;
694 intel_de_write(dev_priv, UTIL_PIN_CTL, val);
698 if (panel->backlight.util_pin_active_low)
699 val |= UTIL_PIN_POLARITY;
700 intel_de_write(dev_priv, UTIL_PIN_CTL,
701 val | UTIL_PIN_PIPE(pipe) | UTIL_PIN_MODE_PWM | UTIL_PIN_ENABLE);
704 pwm_ctl = intel_de_read(dev_priv,
705 BXT_BLC_PWM_CTL(panel->backlight.controller));
706 if (pwm_ctl & BXT_BLC_PWM_ENABLE) {
707 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
708 pwm_ctl &= ~BXT_BLC_PWM_ENABLE;
709 intel_de_write(dev_priv,
710 BXT_BLC_PWM_CTL(panel->backlight.controller),
714 intel_de_write(dev_priv,
715 BXT_BLC_PWM_FREQ(panel->backlight.controller),
716 panel->backlight.pwm_level_max);
718 intel_backlight_set_pwm_level(conn_state, level);
721 if (panel->backlight.active_low_pwm)
722 pwm_ctl |= BXT_BLC_PWM_POLARITY;
724 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
726 intel_de_posting_read(dev_priv,
727 BXT_BLC_PWM_CTL(panel->backlight.controller));
728 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
729 pwm_ctl | BXT_BLC_PWM_ENABLE);
732 static void cnp_enable_backlight(const struct intel_crtc_state *crtc_state,
733 const struct drm_connector_state *conn_state, u32 level)
735 struct intel_connector *connector = to_intel_connector(conn_state->connector);
736 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
737 struct intel_panel *panel = &connector->panel;
740 pwm_ctl = intel_de_read(dev_priv,
741 BXT_BLC_PWM_CTL(panel->backlight.controller));
742 if (pwm_ctl & BXT_BLC_PWM_ENABLE) {
743 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
744 pwm_ctl &= ~BXT_BLC_PWM_ENABLE;
745 intel_de_write(dev_priv,
746 BXT_BLC_PWM_CTL(panel->backlight.controller),
750 intel_de_write(dev_priv,
751 BXT_BLC_PWM_FREQ(panel->backlight.controller),
752 panel->backlight.pwm_level_max);
754 intel_backlight_set_pwm_level(conn_state, level);
757 if (panel->backlight.active_low_pwm)
758 pwm_ctl |= BXT_BLC_PWM_POLARITY;
760 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
762 intel_de_posting_read(dev_priv,
763 BXT_BLC_PWM_CTL(panel->backlight.controller));
764 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
765 pwm_ctl | BXT_BLC_PWM_ENABLE);
768 static void ext_pwm_enable_backlight(const struct intel_crtc_state *crtc_state,
769 const struct drm_connector_state *conn_state, u32 level)
771 struct intel_connector *connector = to_intel_connector(conn_state->connector);
772 struct intel_panel *panel = &connector->panel;
774 pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
775 panel->backlight.pwm_state.enabled = true;
776 pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
779 static void __intel_backlight_enable(const struct intel_crtc_state *crtc_state,
780 const struct drm_connector_state *conn_state)
782 struct intel_connector *connector = to_intel_connector(conn_state->connector);
783 struct intel_panel *panel = &connector->panel;
785 WARN_ON(panel->backlight.max == 0);
787 if (panel->backlight.level <= panel->backlight.min) {
788 panel->backlight.level = panel->backlight.max;
789 if (panel->backlight.device)
790 panel->backlight.device->props.brightness =
791 scale_hw_to_user(connector,
792 panel->backlight.level,
793 panel->backlight.device->props.max_brightness);
796 panel->backlight.funcs->enable(crtc_state, conn_state, panel->backlight.level);
797 panel->backlight.enabled = true;
798 if (panel->backlight.device)
799 panel->backlight.device->props.power = FB_BLANK_UNBLANK;
802 void intel_backlight_enable(const struct intel_crtc_state *crtc_state,
803 const struct drm_connector_state *conn_state)
805 struct intel_connector *connector = to_intel_connector(conn_state->connector);
806 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
807 struct intel_panel *panel = &connector->panel;
808 enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
810 if (!panel->backlight.present)
813 drm_dbg_kms(&dev_priv->drm, "pipe %c\n", pipe_name(pipe));
815 mutex_lock(&dev_priv->backlight_lock);
817 __intel_backlight_enable(crtc_state, conn_state);
819 mutex_unlock(&dev_priv->backlight_lock);
822 #if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)
823 static u32 intel_panel_get_backlight(struct intel_connector *connector)
825 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
826 struct intel_panel *panel = &connector->panel;
829 mutex_lock(&dev_priv->backlight_lock);
831 if (panel->backlight.enabled)
832 val = panel->backlight.funcs->get(connector, intel_connector_get_pipe(connector));
834 mutex_unlock(&dev_priv->backlight_lock);
836 drm_dbg_kms(&dev_priv->drm, "get backlight PWM = %d\n", val);
840 /* Scale user_level in range [0..user_max] to [hw_min..hw_max]. */
841 static u32 scale_user_to_hw(struct intel_connector *connector,
842 u32 user_level, u32 user_max)
844 struct intel_panel *panel = &connector->panel;
846 return scale(user_level, 0, user_max,
847 panel->backlight.min, panel->backlight.max);
850 /* set backlight brightness to level in range [0..max], scaling wrt hw min */
851 static void intel_panel_set_backlight(const struct drm_connector_state *conn_state,
852 u32 user_level, u32 user_max)
854 struct intel_connector *connector = to_intel_connector(conn_state->connector);
855 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
856 struct intel_panel *panel = &connector->panel;
859 if (!panel->backlight.present)
862 mutex_lock(&dev_priv->backlight_lock);
864 drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0);
866 hw_level = scale_user_to_hw(connector, user_level, user_max);
867 panel->backlight.level = hw_level;
869 if (panel->backlight.enabled)
870 intel_panel_actually_set_backlight(conn_state, hw_level);
872 mutex_unlock(&dev_priv->backlight_lock);
875 static int intel_backlight_device_update_status(struct backlight_device *bd)
877 struct intel_connector *connector = bl_get_data(bd);
878 struct intel_panel *panel = &connector->panel;
879 struct drm_device *dev = connector->base.dev;
881 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
882 DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n",
883 bd->props.brightness, bd->props.max_brightness);
884 intel_panel_set_backlight(connector->base.state, bd->props.brightness,
885 bd->props.max_brightness);
888 * Allow flipping bl_power as a sub-state of enabled. Sadly the
889 * backlight class device does not make it easy to differentiate
890 * between callbacks for brightness and bl_power, so our backlight_power
891 * callback needs to take this into account.
893 if (panel->backlight.enabled) {
894 if (panel->backlight.power) {
895 bool enable = bd->props.power == FB_BLANK_UNBLANK &&
896 bd->props.brightness != 0;
897 panel->backlight.power(connector, enable);
900 bd->props.power = FB_BLANK_POWERDOWN;
903 drm_modeset_unlock(&dev->mode_config.connection_mutex);
907 static int intel_backlight_device_get_brightness(struct backlight_device *bd)
909 struct intel_connector *connector = bl_get_data(bd);
910 struct drm_device *dev = connector->base.dev;
911 struct drm_i915_private *dev_priv = to_i915(dev);
912 intel_wakeref_t wakeref;
915 with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref) {
918 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
920 hw_level = intel_panel_get_backlight(connector);
921 ret = scale_hw_to_user(connector,
922 hw_level, bd->props.max_brightness);
924 drm_modeset_unlock(&dev->mode_config.connection_mutex);
930 static const struct backlight_ops intel_backlight_device_ops = {
931 .update_status = intel_backlight_device_update_status,
932 .get_brightness = intel_backlight_device_get_brightness,
935 int intel_backlight_device_register(struct intel_connector *connector)
937 struct drm_i915_private *i915 = to_i915(connector->base.dev);
938 struct intel_panel *panel = &connector->panel;
939 struct backlight_properties props;
940 struct backlight_device *bd;
944 if (WARN_ON(panel->backlight.device))
947 if (!panel->backlight.present)
950 WARN_ON(panel->backlight.max == 0);
952 memset(&props, 0, sizeof(props));
953 props.type = BACKLIGHT_RAW;
956 * Note: Everything should work even if the backlight device max
957 * presented to the userspace is arbitrarily chosen.
959 props.max_brightness = panel->backlight.max;
960 props.brightness = scale_hw_to_user(connector,
961 panel->backlight.level,
962 props.max_brightness);
964 if (panel->backlight.enabled)
965 props.power = FB_BLANK_UNBLANK;
967 props.power = FB_BLANK_POWERDOWN;
969 name = kstrdup("intel_backlight", GFP_KERNEL);
973 bd = backlight_device_register(name, connector->base.kdev, connector,
974 &intel_backlight_device_ops, &props);
977 * Using the same name independent of the drm device or connector
978 * prevents registration of multiple backlight devices in the
979 * driver. However, we need to use the default name for backward
980 * compatibility. Use unique names for subsequent backlight devices as a
981 * fallback when the default name already exists.
983 if (IS_ERR(bd) && PTR_ERR(bd) == -EEXIST) {
985 name = kasprintf(GFP_KERNEL, "card%d-%s-backlight",
986 i915->drm.primary->index, connector->base.name);
990 bd = backlight_device_register(name, connector->base.kdev, connector,
991 &intel_backlight_device_ops, &props);
996 "[CONNECTOR:%d:%s] backlight device %s register failed: %ld\n",
997 connector->base.base.id, connector->base.name, name, PTR_ERR(bd));
1002 panel->backlight.device = bd;
1004 drm_dbg_kms(&i915->drm,
1005 "[CONNECTOR:%d:%s] backlight device %s registered\n",
1006 connector->base.base.id, connector->base.name, name);
1014 void intel_backlight_device_unregister(struct intel_connector *connector)
1016 struct intel_panel *panel = &connector->panel;
1018 if (panel->backlight.device) {
1019 backlight_device_unregister(panel->backlight.device);
1020 panel->backlight.device = NULL;
1023 #endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
1026 * CNP: PWM clock frequency is 19.2 MHz or 24 MHz.
1029 static u32 cnp_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1031 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1033 return DIV_ROUND_CLOSEST(KHz(RUNTIME_INFO(dev_priv)->rawclk_freq),
1038 * BXT: PWM clock frequency = 19.2 MHz.
1040 static u32 bxt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1042 return DIV_ROUND_CLOSEST(KHz(19200), pwm_freq_hz);
1046 * SPT: This value represents the period of the PWM stream in clock periods
1047 * multiplied by 16 (default increment) or 128 (alternate increment selected in
1048 * SCHICKEN_1 bit 0). PWM clock is 24 MHz.
1050 static u32 spt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1052 struct intel_panel *panel = &connector->panel;
1055 if (panel->backlight.alternate_pwm_increment)
1060 return DIV_ROUND_CLOSEST(MHz(24), pwm_freq_hz * mul);
1064 * LPT: This value represents the period of the PWM stream in clock periods
1065 * multiplied by 128 (default increment) or 16 (alternate increment, selected in
1066 * LPT SOUTH_CHICKEN2 register bit 5).
1068 static u32 lpt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1070 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1071 struct intel_panel *panel = &connector->panel;
1074 if (panel->backlight.alternate_pwm_increment)
1079 if (HAS_PCH_LPT_H(dev_priv))
1080 clock = MHz(135); /* LPT:H */
1082 clock = MHz(24); /* LPT:LP */
1084 return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * mul);
1088 * ILK/SNB/IVB: This value represents the period of the PWM stream in PCH
1089 * display raw clocks multiplied by 128.
1091 static u32 pch_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1093 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1095 return DIV_ROUND_CLOSEST(KHz(RUNTIME_INFO(dev_priv)->rawclk_freq),
1100 * Gen2: This field determines the number of time base events (display core
1101 * clock frequency/32) in total for a complete cycle of modulated backlight
1104 * Gen3: A time base event equals the display core clock ([DevPNV] HRAW clock)
1107 static u32 i9xx_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1109 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1112 if (IS_PINEVIEW(dev_priv))
1113 clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq);
1115 clock = KHz(dev_priv->cdclk.hw.cdclk);
1117 return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * 32);
1121 * Gen4: This value represents the period of the PWM stream in display core
1122 * clocks ([DevCTG] HRAW clocks) multiplied by 128.
1125 static u32 i965_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1127 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1130 if (IS_G4X(dev_priv))
1131 clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq);
1133 clock = KHz(dev_priv->cdclk.hw.cdclk);
1135 return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * 128);
1139 * VLV: This value represents the period of the PWM stream in display core
1140 * clocks ([DevCTG] 200MHz HRAW clocks) multiplied by 128 or 25MHz S0IX clocks
1141 * multiplied by 16. CHV uses a 19.2MHz S0IX clock.
1143 static u32 vlv_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1145 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1148 if ((intel_de_read(dev_priv, CBR1_VLV) & CBR_PWM_CLOCK_MUX_SELECT) == 0) {
1149 if (IS_CHERRYVIEW(dev_priv))
1155 clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq);
1159 return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * mul);
1162 static u16 get_vbt_pwm_freq(struct drm_i915_private *dev_priv)
1164 u16 pwm_freq_hz = dev_priv->vbt.backlight.pwm_freq_hz;
1167 drm_dbg_kms(&dev_priv->drm,
1168 "VBT defined backlight frequency %u Hz\n",
1172 drm_dbg_kms(&dev_priv->drm,
1173 "default backlight frequency %u Hz\n",
1180 static u32 get_backlight_max_vbt(struct intel_connector *connector)
1182 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1183 struct intel_panel *panel = &connector->panel;
1184 u16 pwm_freq_hz = get_vbt_pwm_freq(dev_priv);
1187 if (!panel->backlight.pwm_funcs->hz_to_pwm) {
1188 drm_dbg_kms(&dev_priv->drm,
1189 "backlight frequency conversion not supported\n");
1193 pwm = panel->backlight.pwm_funcs->hz_to_pwm(connector, pwm_freq_hz);
1195 drm_dbg_kms(&dev_priv->drm,
1196 "backlight frequency conversion failed\n");
1204 * Note: The setup hooks can't assume pipe is set!
1206 static u32 get_backlight_min_vbt(struct intel_connector *connector)
1208 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1209 struct intel_panel *panel = &connector->panel;
1212 drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0);
1215 * XXX: If the vbt value is 255, it makes min equal to max, which leads
1216 * to problems. There are such machines out there. Either our
1217 * interpretation is wrong or the vbt has bogus data. Or both. Safeguard
1218 * against this by letting the minimum be at most (arbitrarily chosen)
1221 min = clamp_t(int, dev_priv->vbt.backlight.min_brightness, 0, 64);
1222 if (min != dev_priv->vbt.backlight.min_brightness) {
1223 drm_dbg_kms(&dev_priv->drm,
1224 "clamping VBT min backlight %d/255 to %d/255\n",
1225 dev_priv->vbt.backlight.min_brightness, min);
1228 /* vbt value is a coefficient in range [0..255] */
1229 return scale(min, 0, 255, 0, panel->backlight.pwm_level_max);
1232 static int lpt_setup_backlight(struct intel_connector *connector, enum pipe unused)
1234 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1235 struct intel_panel *panel = &connector->panel;
1236 u32 cpu_ctl2, pch_ctl1, pch_ctl2, val;
1239 if (HAS_PCH_LPT(dev_priv))
1240 alt = intel_de_read(dev_priv, SOUTH_CHICKEN2) & LPT_PWM_GRANULARITY;
1242 alt = intel_de_read(dev_priv, SOUTH_CHICKEN1) & SPT_PWM_GRANULARITY;
1243 panel->backlight.alternate_pwm_increment = alt;
1245 pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
1246 panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY;
1248 pch_ctl2 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2);
1249 panel->backlight.pwm_level_max = pch_ctl2 >> 16;
1251 cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
1253 if (!panel->backlight.pwm_level_max)
1254 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1256 if (!panel->backlight.pwm_level_max)
1259 panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1261 panel->backlight.pwm_enabled = pch_ctl1 & BLM_PCH_PWM_ENABLE;
1263 cpu_mode = panel->backlight.pwm_enabled && HAS_PCH_LPT(dev_priv) &&
1264 !(pch_ctl1 & BLM_PCH_OVERRIDE_ENABLE) &&
1265 (cpu_ctl2 & BLM_PWM_ENABLE);
1268 val = pch_get_backlight(connector, unused);
1270 drm_dbg_kms(&dev_priv->drm,
1271 "CPU backlight register was enabled, switching to PCH override\n");
1273 /* Write converted CPU PWM value to PCH override register */
1274 lpt_set_backlight(connector->base.state, val);
1275 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1,
1276 pch_ctl1 | BLM_PCH_OVERRIDE_ENABLE);
1278 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2,
1279 cpu_ctl2 & ~BLM_PWM_ENABLE);
1285 static int pch_setup_backlight(struct intel_connector *connector, enum pipe unused)
1287 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1288 struct intel_panel *panel = &connector->panel;
1289 u32 cpu_ctl2, pch_ctl1, pch_ctl2;
1291 pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
1292 panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY;
1294 pch_ctl2 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2);
1295 panel->backlight.pwm_level_max = pch_ctl2 >> 16;
1297 if (!panel->backlight.pwm_level_max)
1298 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1300 if (!panel->backlight.pwm_level_max)
1303 panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1305 cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
1306 panel->backlight.pwm_enabled = (cpu_ctl2 & BLM_PWM_ENABLE) &&
1307 (pch_ctl1 & BLM_PCH_PWM_ENABLE);
1312 static int i9xx_setup_backlight(struct intel_connector *connector, enum pipe unused)
1314 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1315 struct intel_panel *panel = &connector->panel;
1318 ctl = intel_de_read(dev_priv, BLC_PWM_CTL);
1320 if (DISPLAY_VER(dev_priv) == 2 || IS_I915GM(dev_priv) || IS_I945GM(dev_priv))
1321 panel->backlight.combination_mode = ctl & BLM_LEGACY_MODE;
1323 if (IS_PINEVIEW(dev_priv))
1324 panel->backlight.active_low_pwm = ctl & BLM_POLARITY_PNV;
1326 panel->backlight.pwm_level_max = ctl >> 17;
1328 if (!panel->backlight.pwm_level_max) {
1329 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1330 panel->backlight.pwm_level_max >>= 1;
1333 if (!panel->backlight.pwm_level_max)
1336 if (panel->backlight.combination_mode)
1337 panel->backlight.pwm_level_max *= 0xff;
1339 panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1341 val = i9xx_get_backlight(connector, unused);
1342 val = intel_backlight_invert_pwm_level(connector, val);
1343 val = clamp(val, panel->backlight.pwm_level_min, panel->backlight.pwm_level_max);
1345 panel->backlight.pwm_enabled = val != 0;
1350 static int i965_setup_backlight(struct intel_connector *connector, enum pipe unused)
1352 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1353 struct intel_panel *panel = &connector->panel;
1356 ctl2 = intel_de_read(dev_priv, BLC_PWM_CTL2);
1357 panel->backlight.combination_mode = ctl2 & BLM_COMBINATION_MODE;
1358 panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
1360 ctl = intel_de_read(dev_priv, BLC_PWM_CTL);
1361 panel->backlight.pwm_level_max = ctl >> 16;
1363 if (!panel->backlight.pwm_level_max)
1364 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1366 if (!panel->backlight.pwm_level_max)
1369 if (panel->backlight.combination_mode)
1370 panel->backlight.pwm_level_max *= 0xff;
1372 panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1374 panel->backlight.pwm_enabled = ctl2 & BLM_PWM_ENABLE;
1379 static int vlv_setup_backlight(struct intel_connector *connector, enum pipe pipe)
1381 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1382 struct intel_panel *panel = &connector->panel;
1385 if (drm_WARN_ON(&dev_priv->drm, pipe != PIPE_A && pipe != PIPE_B))
1388 ctl2 = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
1389 panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
1391 ctl = intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe));
1392 panel->backlight.pwm_level_max = ctl >> 16;
1394 if (!panel->backlight.pwm_level_max)
1395 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1397 if (!panel->backlight.pwm_level_max)
1400 panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1402 panel->backlight.pwm_enabled = ctl2 & BLM_PWM_ENABLE;
1408 bxt_setup_backlight(struct intel_connector *connector, enum pipe unused)
1410 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1411 struct intel_panel *panel = &connector->panel;
1414 panel->backlight.controller = dev_priv->vbt.backlight.controller;
1416 pwm_ctl = intel_de_read(dev_priv,
1417 BXT_BLC_PWM_CTL(panel->backlight.controller));
1419 /* Controller 1 uses the utility pin. */
1420 if (panel->backlight.controller == 1) {
1421 val = intel_de_read(dev_priv, UTIL_PIN_CTL);
1422 panel->backlight.util_pin_active_low =
1423 val & UTIL_PIN_POLARITY;
1426 panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY;
1427 panel->backlight.pwm_level_max =
1428 intel_de_read(dev_priv, BXT_BLC_PWM_FREQ(panel->backlight.controller));
1430 if (!panel->backlight.pwm_level_max)
1431 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1433 if (!panel->backlight.pwm_level_max)
1436 panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1438 panel->backlight.pwm_enabled = pwm_ctl & BXT_BLC_PWM_ENABLE;
1444 cnp_setup_backlight(struct intel_connector *connector, enum pipe unused)
1446 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1447 struct intel_panel *panel = &connector->panel;
1451 * CNP has the BXT implementation of backlight, but with only one
1452 * controller. TODO: ICP has multiple controllers but we only use
1453 * controller 0 for now.
1455 panel->backlight.controller = 0;
1457 pwm_ctl = intel_de_read(dev_priv,
1458 BXT_BLC_PWM_CTL(panel->backlight.controller));
1460 panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY;
1461 panel->backlight.pwm_level_max =
1462 intel_de_read(dev_priv, BXT_BLC_PWM_FREQ(panel->backlight.controller));
1464 if (!panel->backlight.pwm_level_max)
1465 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1467 if (!panel->backlight.pwm_level_max)
1470 panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1472 panel->backlight.pwm_enabled = pwm_ctl & BXT_BLC_PWM_ENABLE;
1477 static int ext_pwm_setup_backlight(struct intel_connector *connector,
1480 struct drm_device *dev = connector->base.dev;
1481 struct drm_i915_private *dev_priv = to_i915(dev);
1482 struct intel_panel *panel = &connector->panel;
1486 /* Get the right PWM chip for DSI backlight according to VBT */
1487 if (dev_priv->vbt.dsi.config->pwm_blc == PPS_BLC_PMIC) {
1488 panel->backlight.pwm = pwm_get(dev->dev, "pwm_pmic_backlight");
1491 panel->backlight.pwm = pwm_get(dev->dev, "pwm_soc_backlight");
1495 if (IS_ERR(panel->backlight.pwm)) {
1496 drm_err(&dev_priv->drm, "Failed to get the %s PWM chip\n",
1498 panel->backlight.pwm = NULL;
1502 panel->backlight.pwm_level_max = 100; /* 100% */
1503 panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1505 if (pwm_is_enabled(panel->backlight.pwm)) {
1506 /* PWM is already enabled, use existing settings */
1507 pwm_get_state(panel->backlight.pwm, &panel->backlight.pwm_state);
1509 level = pwm_get_relative_duty_cycle(&panel->backlight.pwm_state,
1511 level = intel_backlight_invert_pwm_level(connector, level);
1512 panel->backlight.pwm_enabled = true;
1514 drm_dbg_kms(&dev_priv->drm, "PWM already enabled at freq %ld, VBT freq %d, level %d\n",
1515 NSEC_PER_SEC / (unsigned long)panel->backlight.pwm_state.period,
1516 get_vbt_pwm_freq(dev_priv), level);
1518 /* Set period from VBT frequency, leave other settings at 0. */
1519 panel->backlight.pwm_state.period =
1520 NSEC_PER_SEC / get_vbt_pwm_freq(dev_priv);
1523 drm_info(&dev_priv->drm, "Using %s PWM for LCD backlight control\n",
1528 static void intel_pwm_set_backlight(const struct drm_connector_state *conn_state, u32 level)
1530 struct intel_connector *connector = to_intel_connector(conn_state->connector);
1531 struct intel_panel *panel = &connector->panel;
1533 panel->backlight.pwm_funcs->set(conn_state,
1534 intel_backlight_invert_pwm_level(connector, level));
1537 static u32 intel_pwm_get_backlight(struct intel_connector *connector, enum pipe pipe)
1539 struct intel_panel *panel = &connector->panel;
1541 return intel_backlight_invert_pwm_level(connector,
1542 panel->backlight.pwm_funcs->get(connector, pipe));
1545 static void intel_pwm_enable_backlight(const struct intel_crtc_state *crtc_state,
1546 const struct drm_connector_state *conn_state, u32 level)
1548 struct intel_connector *connector = to_intel_connector(conn_state->connector);
1549 struct intel_panel *panel = &connector->panel;
1551 panel->backlight.pwm_funcs->enable(crtc_state, conn_state,
1552 intel_backlight_invert_pwm_level(connector, level));
1555 static void intel_pwm_disable_backlight(const struct drm_connector_state *conn_state, u32 level)
1557 struct intel_connector *connector = to_intel_connector(conn_state->connector);
1558 struct intel_panel *panel = &connector->panel;
1560 panel->backlight.pwm_funcs->disable(conn_state,
1561 intel_backlight_invert_pwm_level(connector, level));
1564 static int intel_pwm_setup_backlight(struct intel_connector *connector, enum pipe pipe)
1566 struct intel_panel *panel = &connector->panel;
1567 int ret = panel->backlight.pwm_funcs->setup(connector, pipe);
1572 panel->backlight.min = panel->backlight.pwm_level_min;
1573 panel->backlight.max = panel->backlight.pwm_level_max;
1574 panel->backlight.level = intel_pwm_get_backlight(connector, pipe);
1575 panel->backlight.enabled = panel->backlight.pwm_enabled;
1580 void intel_backlight_update(struct intel_atomic_state *state,
1581 struct intel_encoder *encoder,
1582 const struct intel_crtc_state *crtc_state,
1583 const struct drm_connector_state *conn_state)
1585 struct intel_connector *connector = to_intel_connector(conn_state->connector);
1586 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1587 struct intel_panel *panel = &connector->panel;
1589 if (!panel->backlight.present)
1592 mutex_lock(&dev_priv->backlight_lock);
1593 if (!panel->backlight.enabled)
1594 __intel_backlight_enable(crtc_state, conn_state);
1596 mutex_unlock(&dev_priv->backlight_lock);
1599 int intel_backlight_setup(struct intel_connector *connector, enum pipe pipe)
1601 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1602 struct intel_panel *panel = &connector->panel;
1605 if (!dev_priv->vbt.backlight.present) {
1606 if (dev_priv->quirks & QUIRK_BACKLIGHT_PRESENT) {
1607 drm_dbg_kms(&dev_priv->drm,
1608 "no backlight present per VBT, but present per quirk\n");
1610 drm_dbg_kms(&dev_priv->drm,
1611 "no backlight present per VBT\n");
1616 /* ensure intel_panel has been initialized first */
1617 if (drm_WARN_ON(&dev_priv->drm, !panel->backlight.funcs))
1620 /* set level and max in panel struct */
1621 mutex_lock(&dev_priv->backlight_lock);
1622 ret = panel->backlight.funcs->setup(connector, pipe);
1623 mutex_unlock(&dev_priv->backlight_lock);
1626 drm_dbg_kms(&dev_priv->drm,
1627 "failed to setup backlight for connector %s\n",
1628 connector->base.name);
1632 panel->backlight.present = true;
1634 drm_dbg_kms(&dev_priv->drm,
1635 "Connector %s backlight initialized, %s, brightness %u/%u\n",
1636 connector->base.name,
1637 str_enabled_disabled(panel->backlight.enabled),
1638 panel->backlight.level, panel->backlight.max);
1643 void intel_backlight_destroy(struct intel_panel *panel)
1645 /* dispose of the pwm */
1646 if (panel->backlight.pwm)
1647 pwm_put(panel->backlight.pwm);
1649 panel->backlight.present = false;
1652 static const struct intel_panel_bl_funcs bxt_pwm_funcs = {
1653 .setup = bxt_setup_backlight,
1654 .enable = bxt_enable_backlight,
1655 .disable = bxt_disable_backlight,
1656 .set = bxt_set_backlight,
1657 .get = bxt_get_backlight,
1658 .hz_to_pwm = bxt_hz_to_pwm,
1661 static const struct intel_panel_bl_funcs cnp_pwm_funcs = {
1662 .setup = cnp_setup_backlight,
1663 .enable = cnp_enable_backlight,
1664 .disable = cnp_disable_backlight,
1665 .set = bxt_set_backlight,
1666 .get = bxt_get_backlight,
1667 .hz_to_pwm = cnp_hz_to_pwm,
1670 static const struct intel_panel_bl_funcs lpt_pwm_funcs = {
1671 .setup = lpt_setup_backlight,
1672 .enable = lpt_enable_backlight,
1673 .disable = lpt_disable_backlight,
1674 .set = lpt_set_backlight,
1675 .get = lpt_get_backlight,
1676 .hz_to_pwm = lpt_hz_to_pwm,
1679 static const struct intel_panel_bl_funcs spt_pwm_funcs = {
1680 .setup = lpt_setup_backlight,
1681 .enable = lpt_enable_backlight,
1682 .disable = lpt_disable_backlight,
1683 .set = lpt_set_backlight,
1684 .get = lpt_get_backlight,
1685 .hz_to_pwm = spt_hz_to_pwm,
1688 static const struct intel_panel_bl_funcs pch_pwm_funcs = {
1689 .setup = pch_setup_backlight,
1690 .enable = pch_enable_backlight,
1691 .disable = pch_disable_backlight,
1692 .set = pch_set_backlight,
1693 .get = pch_get_backlight,
1694 .hz_to_pwm = pch_hz_to_pwm,
1697 static const struct intel_panel_bl_funcs ext_pwm_funcs = {
1698 .setup = ext_pwm_setup_backlight,
1699 .enable = ext_pwm_enable_backlight,
1700 .disable = ext_pwm_disable_backlight,
1701 .set = ext_pwm_set_backlight,
1702 .get = ext_pwm_get_backlight,
1705 static const struct intel_panel_bl_funcs vlv_pwm_funcs = {
1706 .setup = vlv_setup_backlight,
1707 .enable = vlv_enable_backlight,
1708 .disable = vlv_disable_backlight,
1709 .set = vlv_set_backlight,
1710 .get = vlv_get_backlight,
1711 .hz_to_pwm = vlv_hz_to_pwm,
1714 static const struct intel_panel_bl_funcs i965_pwm_funcs = {
1715 .setup = i965_setup_backlight,
1716 .enable = i965_enable_backlight,
1717 .disable = i965_disable_backlight,
1718 .set = i9xx_set_backlight,
1719 .get = i9xx_get_backlight,
1720 .hz_to_pwm = i965_hz_to_pwm,
1723 static const struct intel_panel_bl_funcs i9xx_pwm_funcs = {
1724 .setup = i9xx_setup_backlight,
1725 .enable = i9xx_enable_backlight,
1726 .disable = i9xx_disable_backlight,
1727 .set = i9xx_set_backlight,
1728 .get = i9xx_get_backlight,
1729 .hz_to_pwm = i9xx_hz_to_pwm,
1732 static const struct intel_panel_bl_funcs pwm_bl_funcs = {
1733 .setup = intel_pwm_setup_backlight,
1734 .enable = intel_pwm_enable_backlight,
1735 .disable = intel_pwm_disable_backlight,
1736 .set = intel_pwm_set_backlight,
1737 .get = intel_pwm_get_backlight,
1740 /* Set up chip specific backlight functions */
1741 void intel_backlight_init_funcs(struct intel_panel *panel)
1743 struct intel_connector *connector =
1744 container_of(panel, struct intel_connector, panel);
1745 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1747 if (connector->base.connector_type == DRM_MODE_CONNECTOR_DSI &&
1748 intel_dsi_dcs_init_backlight_funcs(connector) == 0)
1751 if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
1752 panel->backlight.pwm_funcs = &bxt_pwm_funcs;
1753 } else if (INTEL_PCH_TYPE(dev_priv) >= PCH_CNP) {
1754 panel->backlight.pwm_funcs = &cnp_pwm_funcs;
1755 } else if (INTEL_PCH_TYPE(dev_priv) >= PCH_LPT) {
1756 if (HAS_PCH_LPT(dev_priv))
1757 panel->backlight.pwm_funcs = &lpt_pwm_funcs;
1759 panel->backlight.pwm_funcs = &spt_pwm_funcs;
1760 } else if (HAS_PCH_SPLIT(dev_priv)) {
1761 panel->backlight.pwm_funcs = &pch_pwm_funcs;
1762 } else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
1763 if (connector->base.connector_type == DRM_MODE_CONNECTOR_DSI) {
1764 panel->backlight.pwm_funcs = &ext_pwm_funcs;
1766 panel->backlight.pwm_funcs = &vlv_pwm_funcs;
1768 } else if (DISPLAY_VER(dev_priv) == 4) {
1769 panel->backlight.pwm_funcs = &i965_pwm_funcs;
1771 panel->backlight.pwm_funcs = &i9xx_pwm_funcs;
1774 if (connector->base.connector_type == DRM_MODE_CONNECTOR_eDP &&
1775 intel_dp_aux_init_backlight_funcs(connector) == 0)
1778 /* We're using a standard PWM backlight interface */
1779 panel->backlight.funcs = &pwm_bl_funcs;