Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: MIT
0002 /*
0003  * Copyright © 2021 Intel Corporation
0004  */
0005 
0006 #include <linux/backlight.h>
0007 #include <linux/kernel.h>
0008 #include <linux/pwm.h>
0009 #include <linux/string_helpers.h>
0010 
0011 #include "intel_backlight.h"
0012 #include "intel_connector.h"
0013 #include "intel_de.h"
0014 #include "intel_display_types.h"
0015 #include "intel_dp_aux_backlight.h"
0016 #include "intel_dsi_dcs_backlight.h"
0017 #include "intel_panel.h"
0018 #include "intel_pci_config.h"
0019 #include "intel_pps.h"
0020 
0021 /**
0022  * scale - scale values from one range to another
0023  * @source_val: value in range [@source_min..@source_max]
0024  * @source_min: minimum legal value for @source_val
0025  * @source_max: maximum legal value for @source_val
0026  * @target_min: corresponding target value for @source_min
0027  * @target_max: corresponding target value for @source_max
0028  *
0029  * Return @source_val in range [@source_min..@source_max] scaled to range
0030  * [@target_min..@target_max].
0031  */
0032 static u32 scale(u32 source_val,
0033          u32 source_min, u32 source_max,
0034          u32 target_min, u32 target_max)
0035 {
0036     u64 target_val;
0037 
0038     WARN_ON(source_min > source_max);
0039     WARN_ON(target_min > target_max);
0040 
0041     /* defensive */
0042     source_val = clamp(source_val, source_min, source_max);
0043 
0044     /* avoid overflows */
0045     target_val = mul_u32_u32(source_val - source_min,
0046                  target_max - target_min);
0047     target_val = DIV_ROUND_CLOSEST_ULL(target_val, source_max - source_min);
0048     target_val += target_min;
0049 
0050     return target_val;
0051 }
0052 
0053 /*
0054  * Scale user_level in range [0..user_max] to [0..hw_max], clamping the result
0055  * to [hw_min..hw_max].
0056  */
0057 static u32 clamp_user_to_hw(struct intel_connector *connector,
0058                 u32 user_level, u32 user_max)
0059 {
0060     struct intel_panel *panel = &connector->panel;
0061     u32 hw_level;
0062 
0063     hw_level = scale(user_level, 0, user_max, 0, panel->backlight.max);
0064     hw_level = clamp(hw_level, panel->backlight.min, panel->backlight.max);
0065 
0066     return hw_level;
0067 }
0068 
0069 /* Scale hw_level in range [hw_min..hw_max] to [0..user_max]. */
0070 static u32 scale_hw_to_user(struct intel_connector *connector,
0071                 u32 hw_level, u32 user_max)
0072 {
0073     struct intel_panel *panel = &connector->panel;
0074 
0075     return scale(hw_level, panel->backlight.min, panel->backlight.max,
0076              0, user_max);
0077 }
0078 
0079 u32 intel_backlight_invert_pwm_level(struct intel_connector *connector, u32 val)
0080 {
0081     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0082     struct intel_panel *panel = &connector->panel;
0083 
0084     drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0);
0085 
0086     if (dev_priv->params.invert_brightness < 0)
0087         return val;
0088 
0089     if (dev_priv->params.invert_brightness > 0 ||
0090         dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS) {
0091         return panel->backlight.pwm_level_max - val + panel->backlight.pwm_level_min;
0092     }
0093 
0094     return val;
0095 }
0096 
0097 void intel_backlight_set_pwm_level(const struct drm_connector_state *conn_state, u32 val)
0098 {
0099     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0100     struct drm_i915_private *i915 = to_i915(connector->base.dev);
0101     struct intel_panel *panel = &connector->panel;
0102 
0103     drm_dbg_kms(&i915->drm, "set backlight PWM = %d\n", val);
0104     panel->backlight.pwm_funcs->set(conn_state, val);
0105 }
0106 
0107 u32 intel_backlight_level_to_pwm(struct intel_connector *connector, u32 val)
0108 {
0109     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0110     struct intel_panel *panel = &connector->panel;
0111 
0112     drm_WARN_ON_ONCE(&dev_priv->drm,
0113              panel->backlight.max == 0 || panel->backlight.pwm_level_max == 0);
0114 
0115     val = scale(val, panel->backlight.min, panel->backlight.max,
0116             panel->backlight.pwm_level_min, panel->backlight.pwm_level_max);
0117 
0118     return intel_backlight_invert_pwm_level(connector, val);
0119 }
0120 
0121 u32 intel_backlight_level_from_pwm(struct intel_connector *connector, u32 val)
0122 {
0123     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0124     struct intel_panel *panel = &connector->panel;
0125 
0126     drm_WARN_ON_ONCE(&dev_priv->drm,
0127              panel->backlight.max == 0 || panel->backlight.pwm_level_max == 0);
0128 
0129     if (dev_priv->params.invert_brightness > 0 ||
0130         (dev_priv->params.invert_brightness == 0 && dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS))
0131         val = panel->backlight.pwm_level_max - (val - panel->backlight.pwm_level_min);
0132 
0133     return scale(val, panel->backlight.pwm_level_min, panel->backlight.pwm_level_max,
0134              panel->backlight.min, panel->backlight.max);
0135 }
0136 
0137 static u32 lpt_get_backlight(struct intel_connector *connector, enum pipe unused)
0138 {
0139     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0140 
0141     return intel_de_read(dev_priv, BLC_PWM_PCH_CTL2) & BACKLIGHT_DUTY_CYCLE_MASK;
0142 }
0143 
0144 static u32 pch_get_backlight(struct intel_connector *connector, enum pipe unused)
0145 {
0146     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0147 
0148     return intel_de_read(dev_priv, BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
0149 }
0150 
0151 static u32 i9xx_get_backlight(struct intel_connector *connector, enum pipe unused)
0152 {
0153     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0154     struct intel_panel *panel = &connector->panel;
0155     u32 val;
0156 
0157     val = intel_de_read(dev_priv, BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
0158     if (DISPLAY_VER(dev_priv) < 4)
0159         val >>= 1;
0160 
0161     if (panel->backlight.combination_mode) {
0162         u8 lbpc;
0163 
0164         pci_read_config_byte(to_pci_dev(dev_priv->drm.dev), LBPC, &lbpc);
0165         val *= lbpc;
0166     }
0167 
0168     return val;
0169 }
0170 
0171 static u32 vlv_get_backlight(struct intel_connector *connector, enum pipe pipe)
0172 {
0173     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0174 
0175     if (drm_WARN_ON(&dev_priv->drm, pipe != PIPE_A && pipe != PIPE_B))
0176         return 0;
0177 
0178     return intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)) & BACKLIGHT_DUTY_CYCLE_MASK;
0179 }
0180 
0181 static u32 bxt_get_backlight(struct intel_connector *connector, enum pipe unused)
0182 {
0183     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0184     struct intel_panel *panel = &connector->panel;
0185 
0186     return intel_de_read(dev_priv,
0187                  BXT_BLC_PWM_DUTY(panel->backlight.controller));
0188 }
0189 
0190 static u32 ext_pwm_get_backlight(struct intel_connector *connector, enum pipe unused)
0191 {
0192     struct intel_panel *panel = &connector->panel;
0193     struct pwm_state state;
0194 
0195     pwm_get_state(panel->backlight.pwm, &state);
0196     return pwm_get_relative_duty_cycle(&state, 100);
0197 }
0198 
0199 static void lpt_set_backlight(const struct drm_connector_state *conn_state, u32 level)
0200 {
0201     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0202     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0203 
0204     u32 val = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2) & ~BACKLIGHT_DUTY_CYCLE_MASK;
0205     intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, val | level);
0206 }
0207 
0208 static void pch_set_backlight(const struct drm_connector_state *conn_state, u32 level)
0209 {
0210     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0211     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0212     u32 tmp;
0213 
0214     tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK;
0215     intel_de_write(dev_priv, BLC_PWM_CPU_CTL, tmp | level);
0216 }
0217 
0218 static void i9xx_set_backlight(const struct drm_connector_state *conn_state, u32 level)
0219 {
0220     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0221     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0222     struct intel_panel *panel = &connector->panel;
0223     u32 tmp, mask;
0224 
0225     drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0);
0226 
0227     if (panel->backlight.combination_mode) {
0228         u8 lbpc;
0229 
0230         lbpc = level * 0xfe / panel->backlight.pwm_level_max + 1;
0231         level /= lbpc;
0232         pci_write_config_byte(to_pci_dev(dev_priv->drm.dev), LBPC, lbpc);
0233     }
0234 
0235     if (DISPLAY_VER(dev_priv) == 4) {
0236         mask = BACKLIGHT_DUTY_CYCLE_MASK;
0237     } else {
0238         level <<= 1;
0239         mask = BACKLIGHT_DUTY_CYCLE_MASK_PNV;
0240     }
0241 
0242     tmp = intel_de_read(dev_priv, BLC_PWM_CTL) & ~mask;
0243     intel_de_write(dev_priv, BLC_PWM_CTL, tmp | level);
0244 }
0245 
0246 static void vlv_set_backlight(const struct drm_connector_state *conn_state, u32 level)
0247 {
0248     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0249     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0250     enum pipe pipe = to_intel_crtc(conn_state->crtc)->pipe;
0251     u32 tmp;
0252 
0253     tmp = intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)) & ~BACKLIGHT_DUTY_CYCLE_MASK;
0254     intel_de_write(dev_priv, VLV_BLC_PWM_CTL(pipe), tmp | level);
0255 }
0256 
0257 static void bxt_set_backlight(const struct drm_connector_state *conn_state, u32 level)
0258 {
0259     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0260     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0261     struct intel_panel *panel = &connector->panel;
0262 
0263     intel_de_write(dev_priv,
0264                BXT_BLC_PWM_DUTY(panel->backlight.controller), level);
0265 }
0266 
0267 static void ext_pwm_set_backlight(const struct drm_connector_state *conn_state, u32 level)
0268 {
0269     struct intel_panel *panel = &to_intel_connector(conn_state->connector)->panel;
0270 
0271     pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
0272     pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
0273 }
0274 
0275 static void
0276 intel_panel_actually_set_backlight(const struct drm_connector_state *conn_state, u32 level)
0277 {
0278     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0279     struct drm_i915_private *i915 = to_i915(connector->base.dev);
0280     struct intel_panel *panel = &connector->panel;
0281 
0282     drm_dbg_kms(&i915->drm, "set backlight level = %d\n", level);
0283 
0284     panel->backlight.funcs->set(conn_state, level);
0285 }
0286 
0287 /* set backlight brightness to level in range [0..max], assuming hw min is
0288  * respected.
0289  */
0290 void intel_backlight_set_acpi(const struct drm_connector_state *conn_state,
0291                   u32 user_level, u32 user_max)
0292 {
0293     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0294     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0295     struct intel_panel *panel = &connector->panel;
0296     u32 hw_level;
0297 
0298     /*
0299      * Lack of crtc may occur during driver init because
0300      * connection_mutex isn't held across the entire backlight
0301      * setup + modeset readout, and the BIOS can issue the
0302      * requests at any time.
0303      */
0304     if (!panel->backlight.present || !conn_state->crtc)
0305         return;
0306 
0307     mutex_lock(&dev_priv->backlight_lock);
0308 
0309     drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0);
0310 
0311     hw_level = clamp_user_to_hw(connector, user_level, user_max);
0312     panel->backlight.level = hw_level;
0313 
0314     if (panel->backlight.device)
0315         panel->backlight.device->props.brightness =
0316             scale_hw_to_user(connector,
0317                      panel->backlight.level,
0318                      panel->backlight.device->props.max_brightness);
0319 
0320     if (panel->backlight.enabled)
0321         intel_panel_actually_set_backlight(conn_state, hw_level);
0322 
0323     mutex_unlock(&dev_priv->backlight_lock);
0324 }
0325 
0326 static void lpt_disable_backlight(const struct drm_connector_state *old_conn_state, u32 level)
0327 {
0328     struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
0329     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0330     u32 tmp;
0331 
0332     intel_backlight_set_pwm_level(old_conn_state, level);
0333 
0334     /*
0335      * Although we don't support or enable CPU PWM with LPT/SPT based
0336      * systems, it may have been enabled prior to loading the
0337      * driver. Disable to avoid warnings on LCPLL disable.
0338      *
0339      * This needs rework if we need to add support for CPU PWM on PCH split
0340      * platforms.
0341      */
0342     tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
0343     if (tmp & BLM_PWM_ENABLE) {
0344         drm_dbg_kms(&dev_priv->drm,
0345                 "cpu backlight was enabled, disabling\n");
0346         intel_de_write(dev_priv, BLC_PWM_CPU_CTL2,
0347                    tmp & ~BLM_PWM_ENABLE);
0348     }
0349 
0350     tmp = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
0351     intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE);
0352 }
0353 
0354 static void pch_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
0355 {
0356     struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
0357     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0358     u32 tmp;
0359 
0360     intel_backlight_set_pwm_level(old_conn_state, val);
0361 
0362     tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
0363     intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, tmp & ~BLM_PWM_ENABLE);
0364 
0365     tmp = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
0366     intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE);
0367 }
0368 
0369 static void i9xx_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
0370 {
0371     intel_backlight_set_pwm_level(old_conn_state, val);
0372 }
0373 
0374 static void i965_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
0375 {
0376     struct drm_i915_private *dev_priv = to_i915(old_conn_state->connector->dev);
0377     u32 tmp;
0378 
0379     intel_backlight_set_pwm_level(old_conn_state, val);
0380 
0381     tmp = intel_de_read(dev_priv, BLC_PWM_CTL2);
0382     intel_de_write(dev_priv, BLC_PWM_CTL2, tmp & ~BLM_PWM_ENABLE);
0383 }
0384 
0385 static void vlv_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
0386 {
0387     struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
0388     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0389     enum pipe pipe = to_intel_crtc(old_conn_state->crtc)->pipe;
0390     u32 tmp;
0391 
0392     intel_backlight_set_pwm_level(old_conn_state, val);
0393 
0394     tmp = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
0395     intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe),
0396                tmp & ~BLM_PWM_ENABLE);
0397 }
0398 
0399 static void bxt_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
0400 {
0401     struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
0402     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0403     struct intel_panel *panel = &connector->panel;
0404     u32 tmp;
0405 
0406     intel_backlight_set_pwm_level(old_conn_state, val);
0407 
0408     tmp = intel_de_read(dev_priv,
0409                 BXT_BLC_PWM_CTL(panel->backlight.controller));
0410     intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
0411                tmp & ~BXT_BLC_PWM_ENABLE);
0412 
0413     if (panel->backlight.controller == 1) {
0414         val = intel_de_read(dev_priv, UTIL_PIN_CTL);
0415         val &= ~UTIL_PIN_ENABLE;
0416         intel_de_write(dev_priv, UTIL_PIN_CTL, val);
0417     }
0418 }
0419 
0420 static void cnp_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
0421 {
0422     struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
0423     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0424     struct intel_panel *panel = &connector->panel;
0425     u32 tmp;
0426 
0427     intel_backlight_set_pwm_level(old_conn_state, val);
0428 
0429     tmp = intel_de_read(dev_priv,
0430                 BXT_BLC_PWM_CTL(panel->backlight.controller));
0431     intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
0432                tmp & ~BXT_BLC_PWM_ENABLE);
0433 }
0434 
0435 static void ext_pwm_disable_backlight(const struct drm_connector_state *old_conn_state, u32 level)
0436 {
0437     struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
0438     struct intel_panel *panel = &connector->panel;
0439 
0440     intel_backlight_set_pwm_level(old_conn_state, level);
0441 
0442     panel->backlight.pwm_state.enabled = false;
0443     pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
0444 }
0445 
0446 void intel_backlight_disable(const struct drm_connector_state *old_conn_state)
0447 {
0448     struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
0449     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0450     struct intel_panel *panel = &connector->panel;
0451 
0452     if (!panel->backlight.present)
0453         return;
0454 
0455     /*
0456      * Do not disable backlight on the vga_switcheroo path. When switching
0457      * away from i915, the other client may depend on i915 to handle the
0458      * backlight. This will leave the backlight on unnecessarily when
0459      * another client is not activated.
0460      */
0461     if (dev_priv->drm.switch_power_state == DRM_SWITCH_POWER_CHANGING) {
0462         drm_dbg_kms(&dev_priv->drm,
0463                 "Skipping backlight disable on vga switch\n");
0464         return;
0465     }
0466 
0467     mutex_lock(&dev_priv->backlight_lock);
0468 
0469     if (panel->backlight.device)
0470         panel->backlight.device->props.power = FB_BLANK_POWERDOWN;
0471     panel->backlight.enabled = false;
0472     panel->backlight.funcs->disable(old_conn_state, 0);
0473 
0474     mutex_unlock(&dev_priv->backlight_lock);
0475 }
0476 
0477 static void lpt_enable_backlight(const struct intel_crtc_state *crtc_state,
0478                  const struct drm_connector_state *conn_state, u32 level)
0479 {
0480     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0481     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0482     struct intel_panel *panel = &connector->panel;
0483     u32 pch_ctl1, pch_ctl2, schicken;
0484 
0485     pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
0486     if (pch_ctl1 & BLM_PCH_PWM_ENABLE) {
0487         drm_dbg_kms(&dev_priv->drm, "pch backlight already enabled\n");
0488         pch_ctl1 &= ~BLM_PCH_PWM_ENABLE;
0489         intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
0490     }
0491 
0492     if (HAS_PCH_LPT(dev_priv)) {
0493         schicken = intel_de_read(dev_priv, SOUTH_CHICKEN2);
0494         if (panel->backlight.alternate_pwm_increment)
0495             schicken |= LPT_PWM_GRANULARITY;
0496         else
0497             schicken &= ~LPT_PWM_GRANULARITY;
0498         intel_de_write(dev_priv, SOUTH_CHICKEN2, schicken);
0499     } else {
0500         schicken = intel_de_read(dev_priv, SOUTH_CHICKEN1);
0501         if (panel->backlight.alternate_pwm_increment)
0502             schicken |= SPT_PWM_GRANULARITY;
0503         else
0504             schicken &= ~SPT_PWM_GRANULARITY;
0505         intel_de_write(dev_priv, SOUTH_CHICKEN1, schicken);
0506     }
0507 
0508     pch_ctl2 = panel->backlight.pwm_level_max << 16;
0509     intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, pch_ctl2);
0510 
0511     pch_ctl1 = 0;
0512     if (panel->backlight.active_low_pwm)
0513         pch_ctl1 |= BLM_PCH_POLARITY;
0514 
0515     /* After LPT, override is the default. */
0516     if (HAS_PCH_LPT(dev_priv))
0517         pch_ctl1 |= BLM_PCH_OVERRIDE_ENABLE;
0518 
0519     intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
0520     intel_de_posting_read(dev_priv, BLC_PWM_PCH_CTL1);
0521     intel_de_write(dev_priv, BLC_PWM_PCH_CTL1,
0522                pch_ctl1 | BLM_PCH_PWM_ENABLE);
0523 
0524     /* This won't stick until the above enable. */
0525     intel_backlight_set_pwm_level(conn_state, level);
0526 }
0527 
0528 static void pch_enable_backlight(const struct intel_crtc_state *crtc_state,
0529                  const struct drm_connector_state *conn_state, u32 level)
0530 {
0531     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0532     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0533     struct intel_panel *panel = &connector->panel;
0534     enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
0535     u32 cpu_ctl2, pch_ctl1, pch_ctl2;
0536 
0537     cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
0538     if (cpu_ctl2 & BLM_PWM_ENABLE) {
0539         drm_dbg_kms(&dev_priv->drm, "cpu backlight already enabled\n");
0540         cpu_ctl2 &= ~BLM_PWM_ENABLE;
0541         intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2);
0542     }
0543 
0544     pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
0545     if (pch_ctl1 & BLM_PCH_PWM_ENABLE) {
0546         drm_dbg_kms(&dev_priv->drm, "pch backlight already enabled\n");
0547         pch_ctl1 &= ~BLM_PCH_PWM_ENABLE;
0548         intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
0549     }
0550 
0551     if (cpu_transcoder == TRANSCODER_EDP)
0552         cpu_ctl2 = BLM_TRANSCODER_EDP;
0553     else
0554         cpu_ctl2 = BLM_PIPE(cpu_transcoder);
0555     intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2);
0556     intel_de_posting_read(dev_priv, BLC_PWM_CPU_CTL2);
0557     intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2 | BLM_PWM_ENABLE);
0558 
0559     /* This won't stick until the above enable. */
0560     intel_backlight_set_pwm_level(conn_state, level);
0561 
0562     pch_ctl2 = panel->backlight.pwm_level_max << 16;
0563     intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, pch_ctl2);
0564 
0565     pch_ctl1 = 0;
0566     if (panel->backlight.active_low_pwm)
0567         pch_ctl1 |= BLM_PCH_POLARITY;
0568 
0569     intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
0570     intel_de_posting_read(dev_priv, BLC_PWM_PCH_CTL1);
0571     intel_de_write(dev_priv, BLC_PWM_PCH_CTL1,
0572                pch_ctl1 | BLM_PCH_PWM_ENABLE);
0573 }
0574 
0575 static void i9xx_enable_backlight(const struct intel_crtc_state *crtc_state,
0576                   const struct drm_connector_state *conn_state, u32 level)
0577 {
0578     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0579     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0580     struct intel_panel *panel = &connector->panel;
0581     u32 ctl, freq;
0582 
0583     ctl = intel_de_read(dev_priv, BLC_PWM_CTL);
0584     if (ctl & BACKLIGHT_DUTY_CYCLE_MASK_PNV) {
0585         drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
0586         intel_de_write(dev_priv, BLC_PWM_CTL, 0);
0587     }
0588 
0589     freq = panel->backlight.pwm_level_max;
0590     if (panel->backlight.combination_mode)
0591         freq /= 0xff;
0592 
0593     ctl = freq << 17;
0594     if (panel->backlight.combination_mode)
0595         ctl |= BLM_LEGACY_MODE;
0596     if (IS_PINEVIEW(dev_priv) && panel->backlight.active_low_pwm)
0597         ctl |= BLM_POLARITY_PNV;
0598 
0599     intel_de_write(dev_priv, BLC_PWM_CTL, ctl);
0600     intel_de_posting_read(dev_priv, BLC_PWM_CTL);
0601 
0602     /* XXX: combine this into above write? */
0603     intel_backlight_set_pwm_level(conn_state, level);
0604 
0605     /*
0606      * Needed to enable backlight on some 855gm models. BLC_HIST_CTL is
0607      * 855gm only, but checking for gen2 is safe, as 855gm is the only gen2
0608      * that has backlight.
0609      */
0610     if (DISPLAY_VER(dev_priv) == 2)
0611         intel_de_write(dev_priv, BLC_HIST_CTL, BLM_HISTOGRAM_ENABLE);
0612 }
0613 
0614 static void i965_enable_backlight(const struct intel_crtc_state *crtc_state,
0615                   const struct drm_connector_state *conn_state, u32 level)
0616 {
0617     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0618     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0619     struct intel_panel *panel = &connector->panel;
0620     enum pipe pipe = to_intel_crtc(conn_state->crtc)->pipe;
0621     u32 ctl, ctl2, freq;
0622 
0623     ctl2 = intel_de_read(dev_priv, BLC_PWM_CTL2);
0624     if (ctl2 & BLM_PWM_ENABLE) {
0625         drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
0626         ctl2 &= ~BLM_PWM_ENABLE;
0627         intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2);
0628     }
0629 
0630     freq = panel->backlight.pwm_level_max;
0631     if (panel->backlight.combination_mode)
0632         freq /= 0xff;
0633 
0634     ctl = freq << 16;
0635     intel_de_write(dev_priv, BLC_PWM_CTL, ctl);
0636 
0637     ctl2 = BLM_PIPE(pipe);
0638     if (panel->backlight.combination_mode)
0639         ctl2 |= BLM_COMBINATION_MODE;
0640     if (panel->backlight.active_low_pwm)
0641         ctl2 |= BLM_POLARITY_I965;
0642     intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2);
0643     intel_de_posting_read(dev_priv, BLC_PWM_CTL2);
0644     intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2 | BLM_PWM_ENABLE);
0645 
0646     intel_backlight_set_pwm_level(conn_state, level);
0647 }
0648 
0649 static void vlv_enable_backlight(const struct intel_crtc_state *crtc_state,
0650                  const struct drm_connector_state *conn_state, u32 level)
0651 {
0652     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0653     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0654     struct intel_panel *panel = &connector->panel;
0655     enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
0656     u32 ctl, ctl2;
0657 
0658     ctl2 = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
0659     if (ctl2 & BLM_PWM_ENABLE) {
0660         drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
0661         ctl2 &= ~BLM_PWM_ENABLE;
0662         intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe), ctl2);
0663     }
0664 
0665     ctl = panel->backlight.pwm_level_max << 16;
0666     intel_de_write(dev_priv, VLV_BLC_PWM_CTL(pipe), ctl);
0667 
0668     /* XXX: combine this into above write? */
0669     intel_backlight_set_pwm_level(conn_state, level);
0670 
0671     ctl2 = 0;
0672     if (panel->backlight.active_low_pwm)
0673         ctl2 |= BLM_POLARITY_I965;
0674     intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe), ctl2);
0675     intel_de_posting_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
0676     intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe),
0677                ctl2 | BLM_PWM_ENABLE);
0678 }
0679 
0680 static void bxt_enable_backlight(const struct intel_crtc_state *crtc_state,
0681                  const struct drm_connector_state *conn_state, u32 level)
0682 {
0683     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0684     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0685     struct intel_panel *panel = &connector->panel;
0686     enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
0687     u32 pwm_ctl, val;
0688 
0689     /* Controller 1 uses the utility pin. */
0690     if (panel->backlight.controller == 1) {
0691         val = intel_de_read(dev_priv, UTIL_PIN_CTL);
0692         if (val & UTIL_PIN_ENABLE) {
0693             drm_dbg_kms(&dev_priv->drm,
0694                     "util pin already enabled\n");
0695             val &= ~UTIL_PIN_ENABLE;
0696             intel_de_write(dev_priv, UTIL_PIN_CTL, val);
0697         }
0698 
0699         val = 0;
0700         if (panel->backlight.util_pin_active_low)
0701             val |= UTIL_PIN_POLARITY;
0702         intel_de_write(dev_priv, UTIL_PIN_CTL,
0703                    val | UTIL_PIN_PIPE(pipe) | UTIL_PIN_MODE_PWM | UTIL_PIN_ENABLE);
0704     }
0705 
0706     pwm_ctl = intel_de_read(dev_priv,
0707                 BXT_BLC_PWM_CTL(panel->backlight.controller));
0708     if (pwm_ctl & BXT_BLC_PWM_ENABLE) {
0709         drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
0710         pwm_ctl &= ~BXT_BLC_PWM_ENABLE;
0711         intel_de_write(dev_priv,
0712                    BXT_BLC_PWM_CTL(panel->backlight.controller),
0713                    pwm_ctl);
0714     }
0715 
0716     intel_de_write(dev_priv,
0717                BXT_BLC_PWM_FREQ(panel->backlight.controller),
0718                panel->backlight.pwm_level_max);
0719 
0720     intel_backlight_set_pwm_level(conn_state, level);
0721 
0722     pwm_ctl = 0;
0723     if (panel->backlight.active_low_pwm)
0724         pwm_ctl |= BXT_BLC_PWM_POLARITY;
0725 
0726     intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
0727                pwm_ctl);
0728     intel_de_posting_read(dev_priv,
0729                   BXT_BLC_PWM_CTL(panel->backlight.controller));
0730     intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
0731                pwm_ctl | BXT_BLC_PWM_ENABLE);
0732 }
0733 
0734 static void cnp_enable_backlight(const struct intel_crtc_state *crtc_state,
0735                  const struct drm_connector_state *conn_state, u32 level)
0736 {
0737     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0738     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0739     struct intel_panel *panel = &connector->panel;
0740     u32 pwm_ctl;
0741 
0742     pwm_ctl = intel_de_read(dev_priv,
0743                 BXT_BLC_PWM_CTL(panel->backlight.controller));
0744     if (pwm_ctl & BXT_BLC_PWM_ENABLE) {
0745         drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
0746         pwm_ctl &= ~BXT_BLC_PWM_ENABLE;
0747         intel_de_write(dev_priv,
0748                    BXT_BLC_PWM_CTL(panel->backlight.controller),
0749                    pwm_ctl);
0750     }
0751 
0752     intel_de_write(dev_priv,
0753                BXT_BLC_PWM_FREQ(panel->backlight.controller),
0754                panel->backlight.pwm_level_max);
0755 
0756     intel_backlight_set_pwm_level(conn_state, level);
0757 
0758     pwm_ctl = 0;
0759     if (panel->backlight.active_low_pwm)
0760         pwm_ctl |= BXT_BLC_PWM_POLARITY;
0761 
0762     intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
0763                pwm_ctl);
0764     intel_de_posting_read(dev_priv,
0765                   BXT_BLC_PWM_CTL(panel->backlight.controller));
0766     intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
0767                pwm_ctl | BXT_BLC_PWM_ENABLE);
0768 }
0769 
0770 static void ext_pwm_enable_backlight(const struct intel_crtc_state *crtc_state,
0771                      const struct drm_connector_state *conn_state, u32 level)
0772 {
0773     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0774     struct intel_panel *panel = &connector->panel;
0775 
0776     pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
0777     panel->backlight.pwm_state.enabled = true;
0778     pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
0779 }
0780 
0781 static void __intel_backlight_enable(const struct intel_crtc_state *crtc_state,
0782                      const struct drm_connector_state *conn_state)
0783 {
0784     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0785     struct intel_panel *panel = &connector->panel;
0786 
0787     WARN_ON(panel->backlight.max == 0);
0788 
0789     if (panel->backlight.level <= panel->backlight.min) {
0790         panel->backlight.level = panel->backlight.max;
0791         if (panel->backlight.device)
0792             panel->backlight.device->props.brightness =
0793                 scale_hw_to_user(connector,
0794                          panel->backlight.level,
0795                          panel->backlight.device->props.max_brightness);
0796     }
0797 
0798     panel->backlight.funcs->enable(crtc_state, conn_state, panel->backlight.level);
0799     panel->backlight.enabled = true;
0800     if (panel->backlight.device)
0801         panel->backlight.device->props.power = FB_BLANK_UNBLANK;
0802 }
0803 
0804 void intel_backlight_enable(const struct intel_crtc_state *crtc_state,
0805                 const struct drm_connector_state *conn_state)
0806 {
0807     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0808     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0809     struct intel_panel *panel = &connector->panel;
0810     enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
0811 
0812     if (!panel->backlight.present)
0813         return;
0814 
0815     drm_dbg_kms(&dev_priv->drm, "pipe %c\n", pipe_name(pipe));
0816 
0817     mutex_lock(&dev_priv->backlight_lock);
0818 
0819     __intel_backlight_enable(crtc_state, conn_state);
0820 
0821     mutex_unlock(&dev_priv->backlight_lock);
0822 }
0823 
0824 #if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)
0825 static u32 intel_panel_get_backlight(struct intel_connector *connector)
0826 {
0827     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0828     struct intel_panel *panel = &connector->panel;
0829     u32 val = 0;
0830 
0831     mutex_lock(&dev_priv->backlight_lock);
0832 
0833     if (panel->backlight.enabled)
0834         val = panel->backlight.funcs->get(connector, intel_connector_get_pipe(connector));
0835 
0836     mutex_unlock(&dev_priv->backlight_lock);
0837 
0838     drm_dbg_kms(&dev_priv->drm, "get backlight PWM = %d\n", val);
0839     return val;
0840 }
0841 
0842 /* Scale user_level in range [0..user_max] to [hw_min..hw_max]. */
0843 static u32 scale_user_to_hw(struct intel_connector *connector,
0844                 u32 user_level, u32 user_max)
0845 {
0846     struct intel_panel *panel = &connector->panel;
0847 
0848     return scale(user_level, 0, user_max,
0849              panel->backlight.min, panel->backlight.max);
0850 }
0851 
0852 /* set backlight brightness to level in range [0..max], scaling wrt hw min */
0853 static void intel_panel_set_backlight(const struct drm_connector_state *conn_state,
0854                       u32 user_level, u32 user_max)
0855 {
0856     struct intel_connector *connector = to_intel_connector(conn_state->connector);
0857     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
0858     struct intel_panel *panel = &connector->panel;
0859     u32 hw_level;
0860 
0861     if (!panel->backlight.present)
0862         return;
0863 
0864     mutex_lock(&dev_priv->backlight_lock);
0865 
0866     drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0);
0867 
0868     hw_level = scale_user_to_hw(connector, user_level, user_max);
0869     panel->backlight.level = hw_level;
0870 
0871     if (panel->backlight.enabled)
0872         intel_panel_actually_set_backlight(conn_state, hw_level);
0873 
0874     mutex_unlock(&dev_priv->backlight_lock);
0875 }
0876 
0877 static int intel_backlight_device_update_status(struct backlight_device *bd)
0878 {
0879     struct intel_connector *connector = bl_get_data(bd);
0880     struct intel_panel *panel = &connector->panel;
0881     struct drm_device *dev = connector->base.dev;
0882 
0883     drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
0884     DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n",
0885               bd->props.brightness, bd->props.max_brightness);
0886     intel_panel_set_backlight(connector->base.state, bd->props.brightness,
0887                   bd->props.max_brightness);
0888 
0889     /*
0890      * Allow flipping bl_power as a sub-state of enabled. Sadly the
0891      * backlight class device does not make it easy to differentiate
0892      * between callbacks for brightness and bl_power, so our backlight_power
0893      * callback needs to take this into account.
0894      */
0895     if (panel->backlight.enabled) {
0896         if (panel->backlight.power) {
0897             bool enable = bd->props.power == FB_BLANK_UNBLANK &&
0898                 bd->props.brightness != 0;
0899             panel->backlight.power(connector, enable);
0900         }
0901     } else {
0902         bd->props.power = FB_BLANK_POWERDOWN;
0903     }
0904 
0905     drm_modeset_unlock(&dev->mode_config.connection_mutex);
0906     return 0;
0907 }
0908 
0909 static int intel_backlight_device_get_brightness(struct backlight_device *bd)
0910 {
0911     struct intel_connector *connector = bl_get_data(bd);
0912     struct drm_device *dev = connector->base.dev;
0913     struct drm_i915_private *dev_priv = to_i915(dev);
0914     intel_wakeref_t wakeref;
0915     int ret = 0;
0916 
0917     with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref) {
0918         u32 hw_level;
0919 
0920         drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
0921 
0922         hw_level = intel_panel_get_backlight(connector);
0923         ret = scale_hw_to_user(connector,
0924                        hw_level, bd->props.max_brightness);
0925 
0926         drm_modeset_unlock(&dev->mode_config.connection_mutex);
0927     }
0928 
0929     return ret;
0930 }
0931 
0932 static const struct backlight_ops intel_backlight_device_ops = {
0933     .update_status = intel_backlight_device_update_status,
0934     .get_brightness = intel_backlight_device_get_brightness,
0935 };
0936 
0937 int intel_backlight_device_register(struct intel_connector *connector)
0938 {
0939     struct drm_i915_private *i915 = to_i915(connector->base.dev);
0940     struct intel_panel *panel = &connector->panel;
0941     struct backlight_properties props;
0942     struct backlight_device *bd;
0943     const char *name;
0944     int ret = 0;
0945 
0946     if (WARN_ON(panel->backlight.device))
0947         return -ENODEV;
0948 
0949     if (!panel->backlight.present)
0950         return 0;
0951 
0952     WARN_ON(panel->backlight.max == 0);
0953 
0954     memset(&props, 0, sizeof(props));
0955     props.type = BACKLIGHT_RAW;
0956 
0957     /*
0958      * Note: Everything should work even if the backlight device max
0959      * presented to the userspace is arbitrarily chosen.
0960      */
0961     props.max_brightness = panel->backlight.max;
0962     props.brightness = scale_hw_to_user(connector,
0963                         panel->backlight.level,
0964                         props.max_brightness);
0965 
0966     if (panel->backlight.enabled)
0967         props.power = FB_BLANK_UNBLANK;
0968     else
0969         props.power = FB_BLANK_POWERDOWN;
0970 
0971     name = kstrdup("intel_backlight", GFP_KERNEL);
0972     if (!name)
0973         return -ENOMEM;
0974 
0975     bd = backlight_device_get_by_name(name);
0976     if (bd) {
0977         put_device(&bd->dev);
0978         /*
0979          * Using the same name independent of the drm device or connector
0980          * prevents registration of multiple backlight devices in the
0981          * driver. However, we need to use the default name for backward
0982          * compatibility. Use unique names for subsequent backlight devices as a
0983          * fallback when the default name already exists.
0984          */
0985         kfree(name);
0986         name = kasprintf(GFP_KERNEL, "card%d-%s-backlight",
0987                  i915->drm.primary->index, connector->base.name);
0988         if (!name)
0989             return -ENOMEM;
0990     }
0991     bd = backlight_device_register(name, connector->base.kdev, connector,
0992                        &intel_backlight_device_ops, &props);
0993 
0994     if (IS_ERR(bd)) {
0995         drm_err(&i915->drm,
0996             "[CONNECTOR:%d:%s] backlight device %s register failed: %ld\n",
0997             connector->base.base.id, connector->base.name, name, PTR_ERR(bd));
0998         ret = PTR_ERR(bd);
0999         goto out;
1000     }
1001 
1002     panel->backlight.device = bd;
1003 
1004     drm_dbg_kms(&i915->drm,
1005             "[CONNECTOR:%d:%s] backlight device %s registered\n",
1006             connector->base.base.id, connector->base.name, name);
1007 
1008 out:
1009     kfree(name);
1010 
1011     return ret;
1012 }
1013 
1014 void intel_backlight_device_unregister(struct intel_connector *connector)
1015 {
1016     struct intel_panel *panel = &connector->panel;
1017 
1018     if (panel->backlight.device) {
1019         backlight_device_unregister(panel->backlight.device);
1020         panel->backlight.device = NULL;
1021     }
1022 }
1023 #endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
1024 
1025 /*
1026  * CNP: PWM clock frequency is 19.2 MHz or 24 MHz.
1027  *      PWM increment = 1
1028  */
1029 static u32 cnp_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1030 {
1031     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1032 
1033     return DIV_ROUND_CLOSEST(KHz(RUNTIME_INFO(dev_priv)->rawclk_freq),
1034                  pwm_freq_hz);
1035 }
1036 
1037 /*
1038  * BXT: PWM clock frequency = 19.2 MHz.
1039  */
1040 static u32 bxt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1041 {
1042     return DIV_ROUND_CLOSEST(KHz(19200), pwm_freq_hz);
1043 }
1044 
1045 /*
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.
1049  */
1050 static u32 spt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1051 {
1052     struct intel_panel *panel = &connector->panel;
1053     u32 mul;
1054 
1055     if (panel->backlight.alternate_pwm_increment)
1056         mul = 128;
1057     else
1058         mul = 16;
1059 
1060     return DIV_ROUND_CLOSEST(MHz(24), pwm_freq_hz * mul);
1061 }
1062 
1063 /*
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).
1067  */
1068 static u32 lpt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1069 {
1070     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1071     struct intel_panel *panel = &connector->panel;
1072     u32 mul, clock;
1073 
1074     if (panel->backlight.alternate_pwm_increment)
1075         mul = 16;
1076     else
1077         mul = 128;
1078 
1079     if (HAS_PCH_LPT_H(dev_priv))
1080         clock = MHz(135); /* LPT:H */
1081     else
1082         clock = MHz(24); /* LPT:LP */
1083 
1084     return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * mul);
1085 }
1086 
1087 /*
1088  * ILK/SNB/IVB: This value represents the period of the PWM stream in PCH
1089  * display raw clocks multiplied by 128.
1090  */
1091 static u32 pch_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1092 {
1093     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1094 
1095     return DIV_ROUND_CLOSEST(KHz(RUNTIME_INFO(dev_priv)->rawclk_freq),
1096                  pwm_freq_hz * 128);
1097 }
1098 
1099 /*
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
1102  * control.
1103  *
1104  * Gen3: A time base event equals the display core clock ([DevPNV] HRAW clock)
1105  * divided by 32.
1106  */
1107 static u32 i9xx_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1108 {
1109     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1110     int clock;
1111 
1112     if (IS_PINEVIEW(dev_priv))
1113         clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq);
1114     else
1115         clock = KHz(dev_priv->cdclk.hw.cdclk);
1116 
1117     return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * 32);
1118 }
1119 
1120 /*
1121  * Gen4: This value represents the period of the PWM stream in display core
1122  * clocks ([DevCTG] HRAW clocks) multiplied by 128.
1123  *
1124  */
1125 static u32 i965_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1126 {
1127     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1128     int clock;
1129 
1130     if (IS_G4X(dev_priv))
1131         clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq);
1132     else
1133         clock = KHz(dev_priv->cdclk.hw.cdclk);
1134 
1135     return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * 128);
1136 }
1137 
1138 /*
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.
1142  */
1143 static u32 vlv_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1144 {
1145     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1146     int mul, clock;
1147 
1148     if ((intel_de_read(dev_priv, CBR1_VLV) & CBR_PWM_CLOCK_MUX_SELECT) == 0) {
1149         if (IS_CHERRYVIEW(dev_priv))
1150             clock = KHz(19200);
1151         else
1152             clock = MHz(25);
1153         mul = 16;
1154     } else {
1155         clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq);
1156         mul = 128;
1157     }
1158 
1159     return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * mul);
1160 }
1161 
1162 static u16 get_vbt_pwm_freq(struct intel_connector *connector)
1163 {
1164     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1165     u16 pwm_freq_hz = connector->panel.vbt.backlight.pwm_freq_hz;
1166 
1167     if (pwm_freq_hz) {
1168         drm_dbg_kms(&dev_priv->drm,
1169                 "VBT defined backlight frequency %u Hz\n",
1170                 pwm_freq_hz);
1171     } else {
1172         pwm_freq_hz = 200;
1173         drm_dbg_kms(&dev_priv->drm,
1174                 "default backlight frequency %u Hz\n",
1175                 pwm_freq_hz);
1176     }
1177 
1178     return pwm_freq_hz;
1179 }
1180 
1181 static u32 get_backlight_max_vbt(struct intel_connector *connector)
1182 {
1183     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1184     struct intel_panel *panel = &connector->panel;
1185     u16 pwm_freq_hz = get_vbt_pwm_freq(connector);
1186     u32 pwm;
1187 
1188     if (!panel->backlight.pwm_funcs->hz_to_pwm) {
1189         drm_dbg_kms(&dev_priv->drm,
1190                 "backlight frequency conversion not supported\n");
1191         return 0;
1192     }
1193 
1194     pwm = panel->backlight.pwm_funcs->hz_to_pwm(connector, pwm_freq_hz);
1195     if (!pwm) {
1196         drm_dbg_kms(&dev_priv->drm,
1197                 "backlight frequency conversion failed\n");
1198         return 0;
1199     }
1200 
1201     return pwm;
1202 }
1203 
1204 /*
1205  * Note: The setup hooks can't assume pipe is set!
1206  */
1207 static u32 get_backlight_min_vbt(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     int min;
1212 
1213     drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0);
1214 
1215     /*
1216      * XXX: If the vbt value is 255, it makes min equal to max, which leads
1217      * to problems. There are such machines out there. Either our
1218      * interpretation is wrong or the vbt has bogus data. Or both. Safeguard
1219      * against this by letting the minimum be at most (arbitrarily chosen)
1220      * 25% of the max.
1221      */
1222     min = clamp_t(int, connector->panel.vbt.backlight.min_brightness, 0, 64);
1223     if (min != connector->panel.vbt.backlight.min_brightness) {
1224         drm_dbg_kms(&dev_priv->drm,
1225                 "clamping VBT min backlight %d/255 to %d/255\n",
1226                 connector->panel.vbt.backlight.min_brightness, min);
1227     }
1228 
1229     /* vbt value is a coefficient in range [0..255] */
1230     return scale(min, 0, 255, 0, panel->backlight.pwm_level_max);
1231 }
1232 
1233 static int lpt_setup_backlight(struct intel_connector *connector, enum pipe unused)
1234 {
1235     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1236     struct intel_panel *panel = &connector->panel;
1237     u32 cpu_ctl2, pch_ctl1, pch_ctl2, val;
1238     bool alt, cpu_mode;
1239 
1240     if (HAS_PCH_LPT(dev_priv))
1241         alt = intel_de_read(dev_priv, SOUTH_CHICKEN2) & LPT_PWM_GRANULARITY;
1242     else
1243         alt = intel_de_read(dev_priv, SOUTH_CHICKEN1) & SPT_PWM_GRANULARITY;
1244     panel->backlight.alternate_pwm_increment = alt;
1245 
1246     pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
1247     panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY;
1248 
1249     pch_ctl2 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2);
1250     panel->backlight.pwm_level_max = pch_ctl2 >> 16;
1251 
1252     cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
1253 
1254     if (!panel->backlight.pwm_level_max)
1255         panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1256 
1257     if (!panel->backlight.pwm_level_max)
1258         return -ENODEV;
1259 
1260     panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1261 
1262     panel->backlight.pwm_enabled = pch_ctl1 & BLM_PCH_PWM_ENABLE;
1263 
1264     cpu_mode = panel->backlight.pwm_enabled && HAS_PCH_LPT(dev_priv) &&
1265            !(pch_ctl1 & BLM_PCH_OVERRIDE_ENABLE) &&
1266            (cpu_ctl2 & BLM_PWM_ENABLE);
1267 
1268     if (cpu_mode) {
1269         val = pch_get_backlight(connector, unused);
1270 
1271         drm_dbg_kms(&dev_priv->drm,
1272                 "CPU backlight register was enabled, switching to PCH override\n");
1273 
1274         /* Write converted CPU PWM value to PCH override register */
1275         lpt_set_backlight(connector->base.state, val);
1276         intel_de_write(dev_priv, BLC_PWM_PCH_CTL1,
1277                    pch_ctl1 | BLM_PCH_OVERRIDE_ENABLE);
1278 
1279         intel_de_write(dev_priv, BLC_PWM_CPU_CTL2,
1280                    cpu_ctl2 & ~BLM_PWM_ENABLE);
1281     }
1282 
1283     return 0;
1284 }
1285 
1286 static int pch_setup_backlight(struct intel_connector *connector, enum pipe unused)
1287 {
1288     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1289     struct intel_panel *panel = &connector->panel;
1290     u32 cpu_ctl2, pch_ctl1, pch_ctl2;
1291 
1292     pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
1293     panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY;
1294 
1295     pch_ctl2 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2);
1296     panel->backlight.pwm_level_max = pch_ctl2 >> 16;
1297 
1298     if (!panel->backlight.pwm_level_max)
1299         panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1300 
1301     if (!panel->backlight.pwm_level_max)
1302         return -ENODEV;
1303 
1304     panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1305 
1306     cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
1307     panel->backlight.pwm_enabled = (cpu_ctl2 & BLM_PWM_ENABLE) &&
1308         (pch_ctl1 & BLM_PCH_PWM_ENABLE);
1309 
1310     return 0;
1311 }
1312 
1313 static int i9xx_setup_backlight(struct intel_connector *connector, enum pipe unused)
1314 {
1315     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1316     struct intel_panel *panel = &connector->panel;
1317     u32 ctl, val;
1318 
1319     ctl = intel_de_read(dev_priv, BLC_PWM_CTL);
1320 
1321     if (DISPLAY_VER(dev_priv) == 2 || IS_I915GM(dev_priv) || IS_I945GM(dev_priv))
1322         panel->backlight.combination_mode = ctl & BLM_LEGACY_MODE;
1323 
1324     if (IS_PINEVIEW(dev_priv))
1325         panel->backlight.active_low_pwm = ctl & BLM_POLARITY_PNV;
1326 
1327     panel->backlight.pwm_level_max = ctl >> 17;
1328 
1329     if (!panel->backlight.pwm_level_max) {
1330         panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1331         panel->backlight.pwm_level_max >>= 1;
1332     }
1333 
1334     if (!panel->backlight.pwm_level_max)
1335         return -ENODEV;
1336 
1337     if (panel->backlight.combination_mode)
1338         panel->backlight.pwm_level_max *= 0xff;
1339 
1340     panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1341 
1342     val = i9xx_get_backlight(connector, unused);
1343     val = intel_backlight_invert_pwm_level(connector, val);
1344     val = clamp(val, panel->backlight.pwm_level_min, panel->backlight.pwm_level_max);
1345 
1346     panel->backlight.pwm_enabled = val != 0;
1347 
1348     return 0;
1349 }
1350 
1351 static int i965_setup_backlight(struct intel_connector *connector, enum pipe unused)
1352 {
1353     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1354     struct intel_panel *panel = &connector->panel;
1355     u32 ctl, ctl2;
1356 
1357     ctl2 = intel_de_read(dev_priv, BLC_PWM_CTL2);
1358     panel->backlight.combination_mode = ctl2 & BLM_COMBINATION_MODE;
1359     panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
1360 
1361     ctl = intel_de_read(dev_priv, BLC_PWM_CTL);
1362     panel->backlight.pwm_level_max = ctl >> 16;
1363 
1364     if (!panel->backlight.pwm_level_max)
1365         panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1366 
1367     if (!panel->backlight.pwm_level_max)
1368         return -ENODEV;
1369 
1370     if (panel->backlight.combination_mode)
1371         panel->backlight.pwm_level_max *= 0xff;
1372 
1373     panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1374 
1375     panel->backlight.pwm_enabled = ctl2 & BLM_PWM_ENABLE;
1376 
1377     return 0;
1378 }
1379 
1380 static int vlv_setup_backlight(struct intel_connector *connector, enum pipe pipe)
1381 {
1382     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1383     struct intel_panel *panel = &connector->panel;
1384     u32 ctl, ctl2;
1385 
1386     if (drm_WARN_ON(&dev_priv->drm, pipe != PIPE_A && pipe != PIPE_B))
1387         return -ENODEV;
1388 
1389     ctl2 = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
1390     panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
1391 
1392     ctl = intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe));
1393     panel->backlight.pwm_level_max = ctl >> 16;
1394 
1395     if (!panel->backlight.pwm_level_max)
1396         panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1397 
1398     if (!panel->backlight.pwm_level_max)
1399         return -ENODEV;
1400 
1401     panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1402 
1403     panel->backlight.pwm_enabled = ctl2 & BLM_PWM_ENABLE;
1404 
1405     return 0;
1406 }
1407 
1408 static int
1409 bxt_setup_backlight(struct intel_connector *connector, enum pipe unused)
1410 {
1411     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1412     struct intel_panel *panel = &connector->panel;
1413     u32 pwm_ctl, val;
1414 
1415     panel->backlight.controller = connector->panel.vbt.backlight.controller;
1416 
1417     pwm_ctl = intel_de_read(dev_priv,
1418                 BXT_BLC_PWM_CTL(panel->backlight.controller));
1419 
1420     /* Controller 1 uses the utility pin. */
1421     if (panel->backlight.controller == 1) {
1422         val = intel_de_read(dev_priv, UTIL_PIN_CTL);
1423         panel->backlight.util_pin_active_low =
1424                     val & UTIL_PIN_POLARITY;
1425     }
1426 
1427     panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY;
1428     panel->backlight.pwm_level_max =
1429         intel_de_read(dev_priv, BXT_BLC_PWM_FREQ(panel->backlight.controller));
1430 
1431     if (!panel->backlight.pwm_level_max)
1432         panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1433 
1434     if (!panel->backlight.pwm_level_max)
1435         return -ENODEV;
1436 
1437     panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1438 
1439     panel->backlight.pwm_enabled = pwm_ctl & BXT_BLC_PWM_ENABLE;
1440 
1441     return 0;
1442 }
1443 
1444 static int
1445 cnp_setup_backlight(struct intel_connector *connector, enum pipe unused)
1446 {
1447     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1448     struct intel_panel *panel = &connector->panel;
1449     u32 pwm_ctl;
1450 
1451     /*
1452      * CNP has the BXT implementation of backlight, but with only one
1453      * controller. TODO: ICP has multiple controllers but we only use
1454      * controller 0 for now.
1455      */
1456     panel->backlight.controller = 0;
1457 
1458     pwm_ctl = intel_de_read(dev_priv,
1459                 BXT_BLC_PWM_CTL(panel->backlight.controller));
1460 
1461     panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY;
1462     panel->backlight.pwm_level_max =
1463         intel_de_read(dev_priv, BXT_BLC_PWM_FREQ(panel->backlight.controller));
1464 
1465     if (!panel->backlight.pwm_level_max)
1466         panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1467 
1468     if (!panel->backlight.pwm_level_max)
1469         return -ENODEV;
1470 
1471     panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1472 
1473     panel->backlight.pwm_enabled = pwm_ctl & BXT_BLC_PWM_ENABLE;
1474 
1475     return 0;
1476 }
1477 
1478 static int ext_pwm_setup_backlight(struct intel_connector *connector,
1479                    enum pipe pipe)
1480 {
1481     struct drm_device *dev = connector->base.dev;
1482     struct drm_i915_private *dev_priv = to_i915(dev);
1483     struct intel_panel *panel = &connector->panel;
1484     const char *desc;
1485     u32 level;
1486 
1487     /* Get the right PWM chip for DSI backlight according to VBT */
1488     if (connector->panel.vbt.dsi.config->pwm_blc == PPS_BLC_PMIC) {
1489         panel->backlight.pwm = pwm_get(dev->dev, "pwm_pmic_backlight");
1490         desc = "PMIC";
1491     } else {
1492         panel->backlight.pwm = pwm_get(dev->dev, "pwm_soc_backlight");
1493         desc = "SoC";
1494     }
1495 
1496     if (IS_ERR(panel->backlight.pwm)) {
1497         drm_err(&dev_priv->drm, "Failed to get the %s PWM chip\n",
1498             desc);
1499         panel->backlight.pwm = NULL;
1500         return -ENODEV;
1501     }
1502 
1503     panel->backlight.pwm_level_max = 100; /* 100% */
1504     panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1505 
1506     if (pwm_is_enabled(panel->backlight.pwm)) {
1507         /* PWM is already enabled, use existing settings */
1508         pwm_get_state(panel->backlight.pwm, &panel->backlight.pwm_state);
1509 
1510         level = pwm_get_relative_duty_cycle(&panel->backlight.pwm_state,
1511                             100);
1512         level = intel_backlight_invert_pwm_level(connector, level);
1513         panel->backlight.pwm_enabled = true;
1514 
1515         drm_dbg_kms(&dev_priv->drm, "PWM already enabled at freq %ld, VBT freq %d, level %d\n",
1516                 NSEC_PER_SEC / (unsigned long)panel->backlight.pwm_state.period,
1517                 get_vbt_pwm_freq(connector), level);
1518     } else {
1519         /* Set period from VBT frequency, leave other settings at 0. */
1520         panel->backlight.pwm_state.period =
1521             NSEC_PER_SEC / get_vbt_pwm_freq(connector);
1522     }
1523 
1524     drm_info(&dev_priv->drm, "Using %s PWM for LCD backlight control\n",
1525          desc);
1526     return 0;
1527 }
1528 
1529 static void intel_pwm_set_backlight(const struct drm_connector_state *conn_state, u32 level)
1530 {
1531     struct intel_connector *connector = to_intel_connector(conn_state->connector);
1532     struct intel_panel *panel = &connector->panel;
1533 
1534     panel->backlight.pwm_funcs->set(conn_state,
1535                     intel_backlight_invert_pwm_level(connector, level));
1536 }
1537 
1538 static u32 intel_pwm_get_backlight(struct intel_connector *connector, enum pipe pipe)
1539 {
1540     struct intel_panel *panel = &connector->panel;
1541 
1542     return intel_backlight_invert_pwm_level(connector,
1543                         panel->backlight.pwm_funcs->get(connector, pipe));
1544 }
1545 
1546 static void intel_pwm_enable_backlight(const struct intel_crtc_state *crtc_state,
1547                        const struct drm_connector_state *conn_state, u32 level)
1548 {
1549     struct intel_connector *connector = to_intel_connector(conn_state->connector);
1550     struct intel_panel *panel = &connector->panel;
1551 
1552     panel->backlight.pwm_funcs->enable(crtc_state, conn_state,
1553                        intel_backlight_invert_pwm_level(connector, level));
1554 }
1555 
1556 static void intel_pwm_disable_backlight(const struct drm_connector_state *conn_state, u32 level)
1557 {
1558     struct intel_connector *connector = to_intel_connector(conn_state->connector);
1559     struct intel_panel *panel = &connector->panel;
1560 
1561     panel->backlight.pwm_funcs->disable(conn_state,
1562                         intel_backlight_invert_pwm_level(connector, level));
1563 }
1564 
1565 static int intel_pwm_setup_backlight(struct intel_connector *connector, enum pipe pipe)
1566 {
1567     struct intel_panel *panel = &connector->panel;
1568     int ret = panel->backlight.pwm_funcs->setup(connector, pipe);
1569 
1570     if (ret < 0)
1571         return ret;
1572 
1573     panel->backlight.min = panel->backlight.pwm_level_min;
1574     panel->backlight.max = panel->backlight.pwm_level_max;
1575     panel->backlight.level = intel_pwm_get_backlight(connector, pipe);
1576     panel->backlight.enabled = panel->backlight.pwm_enabled;
1577 
1578     return 0;
1579 }
1580 
1581 void intel_backlight_update(struct intel_atomic_state *state,
1582                 struct intel_encoder *encoder,
1583                 const struct intel_crtc_state *crtc_state,
1584                 const struct drm_connector_state *conn_state)
1585 {
1586     struct intel_connector *connector = to_intel_connector(conn_state->connector);
1587     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1588     struct intel_panel *panel = &connector->panel;
1589 
1590     if (!panel->backlight.present)
1591         return;
1592 
1593     mutex_lock(&dev_priv->backlight_lock);
1594     if (!panel->backlight.enabled)
1595         __intel_backlight_enable(crtc_state, conn_state);
1596 
1597     mutex_unlock(&dev_priv->backlight_lock);
1598 }
1599 
1600 int intel_backlight_setup(struct intel_connector *connector, enum pipe pipe)
1601 {
1602     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1603     struct intel_panel *panel = &connector->panel;
1604     int ret;
1605 
1606     if (!connector->panel.vbt.backlight.present) {
1607         if (dev_priv->quirks & QUIRK_BACKLIGHT_PRESENT) {
1608             drm_dbg_kms(&dev_priv->drm,
1609                     "no backlight present per VBT, but present per quirk\n");
1610         } else {
1611             drm_dbg_kms(&dev_priv->drm,
1612                     "no backlight present per VBT\n");
1613             return 0;
1614         }
1615     }
1616 
1617     /* ensure intel_panel has been initialized first */
1618     if (drm_WARN_ON(&dev_priv->drm, !panel->backlight.funcs))
1619         return -ENODEV;
1620 
1621     /* set level and max in panel struct */
1622     mutex_lock(&dev_priv->backlight_lock);
1623     ret = panel->backlight.funcs->setup(connector, pipe);
1624     mutex_unlock(&dev_priv->backlight_lock);
1625 
1626     if (ret) {
1627         drm_dbg_kms(&dev_priv->drm,
1628                 "failed to setup backlight for connector %s\n",
1629                 connector->base.name);
1630         return ret;
1631     }
1632 
1633     panel->backlight.present = true;
1634 
1635     drm_dbg_kms(&dev_priv->drm,
1636             "Connector %s backlight initialized, %s, brightness %u/%u\n",
1637             connector->base.name,
1638             str_enabled_disabled(panel->backlight.enabled),
1639             panel->backlight.level, panel->backlight.max);
1640 
1641     return 0;
1642 }
1643 
1644 void intel_backlight_destroy(struct intel_panel *panel)
1645 {
1646     /* dispose of the pwm */
1647     if (panel->backlight.pwm)
1648         pwm_put(panel->backlight.pwm);
1649 
1650     panel->backlight.present = false;
1651 }
1652 
1653 static const struct intel_panel_bl_funcs bxt_pwm_funcs = {
1654     .setup = bxt_setup_backlight,
1655     .enable = bxt_enable_backlight,
1656     .disable = bxt_disable_backlight,
1657     .set = bxt_set_backlight,
1658     .get = bxt_get_backlight,
1659     .hz_to_pwm = bxt_hz_to_pwm,
1660 };
1661 
1662 static const struct intel_panel_bl_funcs cnp_pwm_funcs = {
1663     .setup = cnp_setup_backlight,
1664     .enable = cnp_enable_backlight,
1665     .disable = cnp_disable_backlight,
1666     .set = bxt_set_backlight,
1667     .get = bxt_get_backlight,
1668     .hz_to_pwm = cnp_hz_to_pwm,
1669 };
1670 
1671 static const struct intel_panel_bl_funcs lpt_pwm_funcs = {
1672     .setup = lpt_setup_backlight,
1673     .enable = lpt_enable_backlight,
1674     .disable = lpt_disable_backlight,
1675     .set = lpt_set_backlight,
1676     .get = lpt_get_backlight,
1677     .hz_to_pwm = lpt_hz_to_pwm,
1678 };
1679 
1680 static const struct intel_panel_bl_funcs spt_pwm_funcs = {
1681     .setup = lpt_setup_backlight,
1682     .enable = lpt_enable_backlight,
1683     .disable = lpt_disable_backlight,
1684     .set = lpt_set_backlight,
1685     .get = lpt_get_backlight,
1686     .hz_to_pwm = spt_hz_to_pwm,
1687 };
1688 
1689 static const struct intel_panel_bl_funcs pch_pwm_funcs = {
1690     .setup = pch_setup_backlight,
1691     .enable = pch_enable_backlight,
1692     .disable = pch_disable_backlight,
1693     .set = pch_set_backlight,
1694     .get = pch_get_backlight,
1695     .hz_to_pwm = pch_hz_to_pwm,
1696 };
1697 
1698 static const struct intel_panel_bl_funcs ext_pwm_funcs = {
1699     .setup = ext_pwm_setup_backlight,
1700     .enable = ext_pwm_enable_backlight,
1701     .disable = ext_pwm_disable_backlight,
1702     .set = ext_pwm_set_backlight,
1703     .get = ext_pwm_get_backlight,
1704 };
1705 
1706 static const struct intel_panel_bl_funcs vlv_pwm_funcs = {
1707     .setup = vlv_setup_backlight,
1708     .enable = vlv_enable_backlight,
1709     .disable = vlv_disable_backlight,
1710     .set = vlv_set_backlight,
1711     .get = vlv_get_backlight,
1712     .hz_to_pwm = vlv_hz_to_pwm,
1713 };
1714 
1715 static const struct intel_panel_bl_funcs i965_pwm_funcs = {
1716     .setup = i965_setup_backlight,
1717     .enable = i965_enable_backlight,
1718     .disable = i965_disable_backlight,
1719     .set = i9xx_set_backlight,
1720     .get = i9xx_get_backlight,
1721     .hz_to_pwm = i965_hz_to_pwm,
1722 };
1723 
1724 static const struct intel_panel_bl_funcs i9xx_pwm_funcs = {
1725     .setup = i9xx_setup_backlight,
1726     .enable = i9xx_enable_backlight,
1727     .disable = i9xx_disable_backlight,
1728     .set = i9xx_set_backlight,
1729     .get = i9xx_get_backlight,
1730     .hz_to_pwm = i9xx_hz_to_pwm,
1731 };
1732 
1733 static const struct intel_panel_bl_funcs pwm_bl_funcs = {
1734     .setup = intel_pwm_setup_backlight,
1735     .enable = intel_pwm_enable_backlight,
1736     .disable = intel_pwm_disable_backlight,
1737     .set = intel_pwm_set_backlight,
1738     .get = intel_pwm_get_backlight,
1739 };
1740 
1741 /* Set up chip specific backlight functions */
1742 void intel_backlight_init_funcs(struct intel_panel *panel)
1743 {
1744     struct intel_connector *connector =
1745         container_of(panel, struct intel_connector, panel);
1746     struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1747 
1748     if (connector->base.connector_type == DRM_MODE_CONNECTOR_DSI &&
1749         intel_dsi_dcs_init_backlight_funcs(connector) == 0)
1750         return;
1751 
1752     if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
1753         panel->backlight.pwm_funcs = &bxt_pwm_funcs;
1754     } else if (INTEL_PCH_TYPE(dev_priv) >= PCH_CNP) {
1755         panel->backlight.pwm_funcs = &cnp_pwm_funcs;
1756     } else if (INTEL_PCH_TYPE(dev_priv) >= PCH_LPT) {
1757         if (HAS_PCH_LPT(dev_priv))
1758             panel->backlight.pwm_funcs = &lpt_pwm_funcs;
1759         else
1760             panel->backlight.pwm_funcs = &spt_pwm_funcs;
1761     } else if (HAS_PCH_SPLIT(dev_priv)) {
1762         panel->backlight.pwm_funcs = &pch_pwm_funcs;
1763     } else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
1764         if (connector->base.connector_type == DRM_MODE_CONNECTOR_DSI) {
1765             panel->backlight.pwm_funcs = &ext_pwm_funcs;
1766         } else {
1767             panel->backlight.pwm_funcs = &vlv_pwm_funcs;
1768         }
1769     } else if (DISPLAY_VER(dev_priv) == 4) {
1770         panel->backlight.pwm_funcs = &i965_pwm_funcs;
1771     } else {
1772         panel->backlight.pwm_funcs = &i9xx_pwm_funcs;
1773     }
1774 
1775     if (connector->base.connector_type == DRM_MODE_CONNECTOR_eDP) {
1776         if (intel_dp_aux_init_backlight_funcs(connector) == 0)
1777             return;
1778 
1779         if (!(dev_priv->quirks & QUIRK_NO_PPS_BACKLIGHT_POWER_HOOK))
1780             connector->panel.backlight.power = intel_pps_backlight_power;
1781     }
1782 
1783     /* We're using a standard PWM backlight interface */
1784     panel->backlight.funcs = &pwm_bl_funcs;
1785 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!