drivers/gpu/drm/i915/display/intel_backlight.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright © 2021 Intel Corporation
   4  */
   5
   6 #include <linux/backlight.h>
   7 #include <linux/kernel.h>
   8 #include <linux/pwm.h>
   9 #include <linux/string_helpers.h>
  10
  11 #include <acpi/video.h>
  12
  13 #include "i915_reg.h"
  14 #include "intel_backlight.h"
  15 #include "intel_backlight_regs.h"
  16 #include "intel_connector.h"
  17 #include "intel_de.h"
  18 #include "intel_display_types.h"
  19 #include "intel_dp_aux_backlight.h"
  20 #include "intel_dsi_dcs_backlight.h"
  21 #include "intel_panel.h"
  22 #include "intel_pci_config.h"
  23 #include "intel_pps.h"
  24 #include "intel_quirks.h"
  25
  26 /**
  27  * scale - scale values from one range to another
  28  * @source_val: value in range [@source_min..@source_max]
  29  * @source_min: minimum legal value for @source_val
  30  * @source_max: maximum legal value for @source_val
  31  * @target_min: corresponding target value for @source_min
  32  * @target_max: corresponding target value for @source_max
  33  *
  34  * Return @source_val in range [@source_min..@source_max] scaled to range
  35  * [@target_min..@target_max].
  36  */
  37 static u32 scale(u32 source_val,
  38                  u32 source_min, u32 source_max,
  39                  u32 target_min, u32 target_max)
  40 {
  41         u64 target_val;
  42
  43         WARN_ON(source_min > source_max);
  44         WARN_ON(target_min > target_max);
  45
  46         /* defensive */
  47         source_val = clamp(source_val, source_min, source_max);
  48
  49         /* avoid overflows */
  50         target_val = mul_u32_u32(source_val - source_min,
  51                                  target_max - target_min);
  52         target_val = DIV_ROUND_CLOSEST_ULL(target_val, source_max - source_min);
  53         target_val += target_min;
  54
  55         return target_val;
  56 }
  57
  58 /*
  59  * Scale user_level in range [0..user_max] to [0..hw_max], clamping the result
  60  * to [hw_min..hw_max].
  61  */
  62 static u32 clamp_user_to_hw(struct intel_connector *connector,
  63                             u32 user_level, u32 user_max)
  64 {
  65         struct intel_panel *panel = &connector->panel;
  66         u32 hw_level;
  67
  68         hw_level = scale(user_level, 0, user_max, 0, panel->backlight.max);
  69         hw_level = clamp(hw_level, panel->backlight.min, panel->backlight.max);
  70
  71         return hw_level;
  72 }
  73
  74 /* Scale hw_level in range [hw_min..hw_max] to [0..user_max]. */
  75 static u32 scale_hw_to_user(struct intel_connector *connector,
  76                             u32 hw_level, u32 user_max)
  77 {
  78         struct intel_panel *panel = &connector->panel;
  79
  80         return scale(hw_level, panel->backlight.min, panel->backlight.max,
  81                      0, user_max);
  82 }
  83
  84 u32 intel_backlight_invert_pwm_level(struct intel_connector *connector, u32 val)
  85 {
  86         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
  87         struct intel_panel *panel = &connector->panel;
  88
  89         drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0);
  90
  91         if (dev_priv->params.invert_brightness < 0)
  92                 return val;
  93
  94         if (dev_priv->params.invert_brightness > 0 ||
  95             intel_has_quirk(dev_priv, QUIRK_INVERT_BRIGHTNESS)) {
  96                 return panel->backlight.pwm_level_max - val + panel->backlight.pwm_level_min;
  97         }
  98
  99         return val;
 100 }
 101
 102 void intel_backlight_set_pwm_level(const struct drm_connector_state *conn_state, u32 val)
 103 {
 104         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 105         struct drm_i915_private *i915 = to_i915(connector->base.dev);
 106         struct intel_panel *panel = &connector->panel;
 107
 108         drm_dbg_kms(&i915->drm, "set backlight PWM = %d\n", val);
 109         panel->backlight.pwm_funcs->set(conn_state, val);
 110 }
 111
 112 u32 intel_backlight_level_to_pwm(struct intel_connector *connector, u32 val)
 113 {
 114         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 115         struct intel_panel *panel = &connector->panel;
 116
 117         drm_WARN_ON_ONCE(&dev_priv->drm,
 118                          panel->backlight.max == 0 || panel->backlight.pwm_level_max == 0);
 119
 120         val = scale(val, panel->backlight.min, panel->backlight.max,
 121                     panel->backlight.pwm_level_min, panel->backlight.pwm_level_max);
 122
 123         return intel_backlight_invert_pwm_level(connector, val);
 124 }
 125
 126 u32 intel_backlight_level_from_pwm(struct intel_connector *connector, u32 val)
 127 {
 128         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 129         struct intel_panel *panel = &connector->panel;
 130
 131         drm_WARN_ON_ONCE(&dev_priv->drm,
 132                          panel->backlight.max == 0 || panel->backlight.pwm_level_max == 0);
 133
 134         if (dev_priv->params.invert_brightness > 0 ||
 135             (dev_priv->params.invert_brightness == 0 && intel_has_quirk(dev_priv, QUIRK_INVERT_BRIGHTNESS)))
 136                 val = panel->backlight.pwm_level_max - (val - panel->backlight.pwm_level_min);
 137
 138         return scale(val, panel->backlight.pwm_level_min, panel->backlight.pwm_level_max,
 139                      panel->backlight.min, panel->backlight.max);
 140 }
 141
 142 static u32 lpt_get_backlight(struct intel_connector *connector, enum pipe unused)
 143 {
 144         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 145
 146         return intel_de_read(dev_priv, BLC_PWM_PCH_CTL2) & BACKLIGHT_DUTY_CYCLE_MASK;
 147 }
 148
 149 static u32 pch_get_backlight(struct intel_connector *connector, enum pipe unused)
 150 {
 151         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 152
 153         return intel_de_read(dev_priv, BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
 154 }
 155
 156 static u32 i9xx_get_backlight(struct intel_connector *connector, enum pipe unused)
 157 {
 158         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 159         struct intel_panel *panel = &connector->panel;
 160         u32 val;
 161
 162         val = intel_de_read(dev_priv, BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
 163         if (DISPLAY_VER(dev_priv) < 4)
 164                 val >>= 1;
 165
 166         if (panel->backlight.combination_mode) {
 167                 u8 lbpc;
 168
 169                 pci_read_config_byte(to_pci_dev(dev_priv->drm.dev), LBPC, &lbpc);
 170                 val *= lbpc;
 171         }
 172
 173         return val;
 174 }
 175
 176 static u32 vlv_get_backlight(struct intel_connector *connector, enum pipe pipe)
 177 {
 178         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 179
 180         if (drm_WARN_ON(&dev_priv->drm, pipe != PIPE_A && pipe != PIPE_B))
 181                 return 0;
 182
 183         return intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)) & BACKLIGHT_DUTY_CYCLE_MASK;
 184 }
 185
 186 static u32 bxt_get_backlight(struct intel_connector *connector, enum pipe unused)
 187 {
 188         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 189         struct intel_panel *panel = &connector->panel;
 190
 191         return intel_de_read(dev_priv,
 192                              BXT_BLC_PWM_DUTY(panel->backlight.controller));
 193 }
 194
 195 static u32 ext_pwm_get_backlight(struct intel_connector *connector, enum pipe unused)
 196 {
 197         struct intel_panel *panel = &connector->panel;
 198         struct pwm_state state;
 199
 200         pwm_get_state(panel->backlight.pwm, &state);
 201         return pwm_get_relative_duty_cycle(&state, 100);
 202 }
 203
 204 static void lpt_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 205 {
 206         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 207         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 208
 209         u32 val = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2) & ~BACKLIGHT_DUTY_CYCLE_MASK;
 210         intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, val | level);
 211 }
 212
 213 static void pch_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 214 {
 215         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 216         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 217         u32 tmp;
 218
 219         tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK;
 220         intel_de_write(dev_priv, BLC_PWM_CPU_CTL, tmp | level);
 221 }
 222
 223 static void i9xx_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 224 {
 225         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 226         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 227         struct intel_panel *panel = &connector->panel;
 228         u32 tmp, mask;
 229
 230         drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0);
 231
 232         if (panel->backlight.combination_mode) {
 233                 u8 lbpc;
 234
 235                 lbpc = level * 0xfe / panel->backlight.pwm_level_max + 1;
 236                 level /= lbpc;
 237                 pci_write_config_byte(to_pci_dev(dev_priv->drm.dev), LBPC, lbpc);
 238         }
 239
 240         if (DISPLAY_VER(dev_priv) == 4) {
 241                 mask = BACKLIGHT_DUTY_CYCLE_MASK;
 242         } else {
 243                 level <<= 1;
 244                 mask = BACKLIGHT_DUTY_CYCLE_MASK_PNV;
 245         }
 246
 247         tmp = intel_de_read(dev_priv, BLC_PWM_CTL) & ~mask;
 248         intel_de_write(dev_priv, BLC_PWM_CTL, tmp | level);
 249 }
 250
 251 static void vlv_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 252 {
 253         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 254         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 255         enum pipe pipe = to_intel_crtc(conn_state->crtc)->pipe;
 256         u32 tmp;
 257
 258         tmp = intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)) & ~BACKLIGHT_DUTY_CYCLE_MASK;
 259         intel_de_write(dev_priv, VLV_BLC_PWM_CTL(pipe), tmp | level);
 260 }
 261
 262 static void bxt_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 263 {
 264         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 265         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 266         struct intel_panel *panel = &connector->panel;
 267
 268         intel_de_write(dev_priv,
 269                        BXT_BLC_PWM_DUTY(panel->backlight.controller), level);
 270 }
 271
 272 static void ext_pwm_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 273 {
 274         struct intel_panel *panel = &to_intel_connector(conn_state->connector)->panel;
 275
 276         pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
 277         pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
 278 }
 279
 280 static void
 281 intel_panel_actually_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 282 {
 283         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 284         struct drm_i915_private *i915 = to_i915(connector->base.dev);
 285         struct intel_panel *panel = &connector->panel;
 286
 287         drm_dbg_kms(&i915->drm, "set backlight level = %d\n", level);
 288
 289         panel->backlight.funcs->set(conn_state, level);
 290 }
 291
 292 /* set backlight brightness to level in range [0..max], assuming hw min is
 293  * respected.
 294  */
 295 void intel_backlight_set_acpi(const struct drm_connector_state *conn_state,
 296                               u32 user_level, u32 user_max)
 297 {
 298         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 299         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 300         struct intel_panel *panel = &connector->panel;
 301         u32 hw_level;
 302
 303         /*
 304          * Lack of crtc may occur during driver init because
 305          * connection_mutex isn't held across the entire backlight
 306          * setup + modeset readout, and the BIOS can issue the
 307          * requests at any time.
 308          */
 309         if (!panel->backlight.present || !conn_state->crtc)
 310                 return;
 311
 312         mutex_lock(&dev_priv->display.backlight.lock);
 313
 314         drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0);
 315
 316         hw_level = clamp_user_to_hw(connector, user_level, user_max);
 317         panel->backlight.level = hw_level;
 318
 319         if (panel->backlight.device)
 320                 panel->backlight.device->props.brightness =
 321                         scale_hw_to_user(connector,
 322                                          panel->backlight.level,
 323                                          panel->backlight.device->props.max_brightness);
 324
 325         if (panel->backlight.enabled)
 326                 intel_panel_actually_set_backlight(conn_state, hw_level);
 327
 328         mutex_unlock(&dev_priv->display.backlight.lock);
 329 }
 330
 331 static void lpt_disable_backlight(const struct drm_connector_state *old_conn_state, u32 level)
 332 {
 333         struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 334         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 335         u32 tmp;
 336
 337         intel_backlight_set_pwm_level(old_conn_state, level);
 338
 339         /*
 340          * Although we don't support or enable CPU PWM with LPT/SPT based
 341          * systems, it may have been enabled prior to loading the
 342          * driver. Disable to avoid warnings on LCPLL disable.
 343          *
 344          * This needs rework if we need to add support for CPU PWM on PCH split
 345          * platforms.
 346          */
 347         tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
 348         if (tmp & BLM_PWM_ENABLE) {
 349                 drm_dbg_kms(&dev_priv->drm,
 350                             "cpu backlight was enabled, disabling\n");
 351                 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2,
 352                                tmp & ~BLM_PWM_ENABLE);
 353         }
 354
 355         tmp = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
 356         intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE);
 357 }
 358
 359 static void pch_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
 360 {
 361         struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 362         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 363         u32 tmp;
 364
 365         intel_backlight_set_pwm_level(old_conn_state, val);
 366
 367         tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
 368         intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, tmp & ~BLM_PWM_ENABLE);
 369
 370         tmp = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
 371         intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE);
 372 }
 373
 374 static void i9xx_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
 375 {
 376         intel_backlight_set_pwm_level(old_conn_state, val);
 377 }
 378
 379 static void i965_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
 380 {
 381         struct drm_i915_private *dev_priv = to_i915(old_conn_state->connector->dev);
 382         u32 tmp;
 383
 384         intel_backlight_set_pwm_level(old_conn_state, val);
 385
 386         tmp = intel_de_read(dev_priv, BLC_PWM_CTL2);
 387         intel_de_write(dev_priv, BLC_PWM_CTL2, tmp & ~BLM_PWM_ENABLE);
 388 }
 389
 390 static void vlv_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
 391 {
 392         struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 393         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 394         enum pipe pipe = to_intel_crtc(old_conn_state->crtc)->pipe;
 395         u32 tmp;
 396
 397         intel_backlight_set_pwm_level(old_conn_state, val);
 398
 399         tmp = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
 400         intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe),
 401                        tmp & ~BLM_PWM_ENABLE);
 402 }
 403
 404 static void bxt_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
 405 {
 406         struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 407         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 408         struct intel_panel *panel = &connector->panel;
 409         u32 tmp;
 410
 411         intel_backlight_set_pwm_level(old_conn_state, val);
 412
 413         tmp = intel_de_read(dev_priv,
 414                             BXT_BLC_PWM_CTL(panel->backlight.controller));
 415         intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
 416                        tmp & ~BXT_BLC_PWM_ENABLE);
 417
 418         if (panel->backlight.controller == 1) {
 419                 val = intel_de_read(dev_priv, UTIL_PIN_CTL);
 420                 val &= ~UTIL_PIN_ENABLE;
 421                 intel_de_write(dev_priv, UTIL_PIN_CTL, val);
 422         }
 423 }
 424
 425 static void cnp_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val)
 426 {
 427         struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 428         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 429         struct intel_panel *panel = &connector->panel;
 430         u32 tmp;
 431
 432         intel_backlight_set_pwm_level(old_conn_state, val);
 433
 434         tmp = intel_de_read(dev_priv,
 435                             BXT_BLC_PWM_CTL(panel->backlight.controller));
 436         intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
 437                        tmp & ~BXT_BLC_PWM_ENABLE);
 438 }
 439
 440 static void ext_pwm_disable_backlight(const struct drm_connector_state *old_conn_state, u32 level)
 441 {
 442         struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 443         struct intel_panel *panel = &connector->panel;
 444
 445         intel_backlight_set_pwm_level(old_conn_state, level);
 446
 447         panel->backlight.pwm_state.enabled = false;
 448         pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
 449 }
 450
 451 void intel_backlight_disable(const struct drm_connector_state *old_conn_state)
 452 {
 453         struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
 454         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 455         struct intel_panel *panel = &connector->panel;
 456
 457         if (!panel->backlight.present)
 458                 return;
 459
 460         /*
 461          * Do not disable backlight on the vga_switcheroo path. When switching
 462          * away from i915, the other client may depend on i915 to handle the
 463          * backlight. This will leave the backlight on unnecessarily when
 464          * another client is not activated.
 465          */
 466         if (dev_priv->drm.switch_power_state == DRM_SWITCH_POWER_CHANGING) {
 467                 drm_dbg_kms(&dev_priv->drm,
 468                             "Skipping backlight disable on vga switch\n");
 469                 return;
 470         }
 471
 472         mutex_lock(&dev_priv->display.backlight.lock);
 473
 474         if (panel->backlight.device)
 475                 panel->backlight.device->props.power = FB_BLANK_POWERDOWN;
 476         panel->backlight.enabled = false;
 477         panel->backlight.funcs->disable(old_conn_state, 0);
 478
 479         mutex_unlock(&dev_priv->display.backlight.lock);
 480 }
 481
 482 static void lpt_enable_backlight(const struct intel_crtc_state *crtc_state,
 483                                  const struct drm_connector_state *conn_state, u32 level)
 484 {
 485         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 486         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 487         struct intel_panel *panel = &connector->panel;
 488         u32 pch_ctl1, pch_ctl2, schicken;
 489
 490         pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
 491         if (pch_ctl1 & BLM_PCH_PWM_ENABLE) {
 492                 drm_dbg_kms(&dev_priv->drm, "pch backlight already enabled\n");
 493                 pch_ctl1 &= ~BLM_PCH_PWM_ENABLE;
 494                 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
 495         }
 496
 497         if (HAS_PCH_LPT(dev_priv)) {
 498                 schicken = intel_de_read(dev_priv, SOUTH_CHICKEN2);
 499                 if (panel->backlight.alternate_pwm_increment)
 500                         schicken |= LPT_PWM_GRANULARITY;
 501                 else
 502                         schicken &= ~LPT_PWM_GRANULARITY;
 503                 intel_de_write(dev_priv, SOUTH_CHICKEN2, schicken);
 504         } else {
 505                 schicken = intel_de_read(dev_priv, SOUTH_CHICKEN1);
 506                 if (panel->backlight.alternate_pwm_increment)
 507                         schicken |= SPT_PWM_GRANULARITY;
 508                 else
 509                         schicken &= ~SPT_PWM_GRANULARITY;
 510                 intel_de_write(dev_priv, SOUTH_CHICKEN1, schicken);
 511         }
 512
 513         pch_ctl2 = panel->backlight.pwm_level_max << 16;
 514         intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, pch_ctl2);
 515
 516         pch_ctl1 = 0;
 517         if (panel->backlight.active_low_pwm)
 518                 pch_ctl1 |= BLM_PCH_POLARITY;
 519
 520         /* After LPT, override is the default. */
 521         if (HAS_PCH_LPT(dev_priv))
 522                 pch_ctl1 |= BLM_PCH_OVERRIDE_ENABLE;
 523
 524         intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
 525         intel_de_posting_read(dev_priv, BLC_PWM_PCH_CTL1);
 526         intel_de_write(dev_priv, BLC_PWM_PCH_CTL1,
 527                        pch_ctl1 | BLM_PCH_PWM_ENABLE);
 528
 529         /* This won't stick until the above enable. */
 530         intel_backlight_set_pwm_level(conn_state, level);
 531 }
 532
 533 static void pch_enable_backlight(const struct intel_crtc_state *crtc_state,
 534                                  const struct drm_connector_state *conn_state, u32 level)
 535 {
 536         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 537         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 538         struct intel_panel *panel = &connector->panel;
 539         enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
 540         u32 cpu_ctl2, pch_ctl1, pch_ctl2;
 541
 542         cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
 543         if (cpu_ctl2 & BLM_PWM_ENABLE) {
 544                 drm_dbg_kms(&dev_priv->drm, "cpu backlight already enabled\n");
 545                 cpu_ctl2 &= ~BLM_PWM_ENABLE;
 546                 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2);
 547         }
 548
 549         pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
 550         if (pch_ctl1 & BLM_PCH_PWM_ENABLE) {
 551                 drm_dbg_kms(&dev_priv->drm, "pch backlight already enabled\n");
 552                 pch_ctl1 &= ~BLM_PCH_PWM_ENABLE;
 553                 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
 554         }
 555
 556         if (cpu_transcoder == TRANSCODER_EDP)
 557                 cpu_ctl2 = BLM_TRANSCODER_EDP;
 558         else
 559                 cpu_ctl2 = BLM_PIPE(cpu_transcoder);
 560         intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2);
 561         intel_de_posting_read(dev_priv, BLC_PWM_CPU_CTL2);
 562         intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2 | BLM_PWM_ENABLE);
 563
 564         /* This won't stick until the above enable. */
 565         intel_backlight_set_pwm_level(conn_state, level);
 566
 567         pch_ctl2 = panel->backlight.pwm_level_max << 16;
 568         intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, pch_ctl2);
 569
 570         pch_ctl1 = 0;
 571         if (panel->backlight.active_low_pwm)
 572                 pch_ctl1 |= BLM_PCH_POLARITY;
 573
 574         intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1);
 575         intel_de_posting_read(dev_priv, BLC_PWM_PCH_CTL1);
 576         intel_de_write(dev_priv, BLC_PWM_PCH_CTL1,
 577                        pch_ctl1 | BLM_PCH_PWM_ENABLE);
 578 }
 579
 580 static void i9xx_enable_backlight(const struct intel_crtc_state *crtc_state,
 581                                   const struct drm_connector_state *conn_state, u32 level)
 582 {
 583         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 584         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 585         struct intel_panel *panel = &connector->panel;
 586         u32 ctl, freq;
 587
 588         ctl = intel_de_read(dev_priv, BLC_PWM_CTL);
 589         if (ctl & BACKLIGHT_DUTY_CYCLE_MASK_PNV) {
 590                 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
 591                 intel_de_write(dev_priv, BLC_PWM_CTL, 0);
 592         }
 593
 594         freq = panel->backlight.pwm_level_max;
 595         if (panel->backlight.combination_mode)
 596                 freq /= 0xff;
 597
 598         ctl = freq << 17;
 599         if (panel->backlight.combination_mode)
 600                 ctl |= BLM_LEGACY_MODE;
 601         if (IS_PINEVIEW(dev_priv) && panel->backlight.active_low_pwm)
 602                 ctl |= BLM_POLARITY_PNV;
 603
 604         intel_de_write(dev_priv, BLC_PWM_CTL, ctl);
 605         intel_de_posting_read(dev_priv, BLC_PWM_CTL);
 606
 607         /* XXX: combine this into above write? */
 608         intel_backlight_set_pwm_level(conn_state, level);
 609
 610         /*
 611          * Needed to enable backlight on some 855gm models. BLC_HIST_CTL is
 612          * 855gm only, but checking for gen2 is safe, as 855gm is the only gen2
 613          * that has backlight.
 614          */
 615         if (DISPLAY_VER(dev_priv) == 2)
 616                 intel_de_write(dev_priv, BLC_HIST_CTL, BLM_HISTOGRAM_ENABLE);
 617 }
 618
 619 static void i965_enable_backlight(const struct intel_crtc_state *crtc_state,
 620                                   const struct drm_connector_state *conn_state, u32 level)
 621 {
 622         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 623         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 624         struct intel_panel *panel = &connector->panel;
 625         enum pipe pipe = to_intel_crtc(conn_state->crtc)->pipe;
 626         u32 ctl, ctl2, freq;
 627
 628         ctl2 = intel_de_read(dev_priv, BLC_PWM_CTL2);
 629         if (ctl2 & BLM_PWM_ENABLE) {
 630                 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
 631                 ctl2 &= ~BLM_PWM_ENABLE;
 632                 intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2);
 633         }
 634
 635         freq = panel->backlight.pwm_level_max;
 636         if (panel->backlight.combination_mode)
 637                 freq /= 0xff;
 638
 639         ctl = freq << 16;
 640         intel_de_write(dev_priv, BLC_PWM_CTL, ctl);
 641
 642         ctl2 = BLM_PIPE(pipe);
 643         if (panel->backlight.combination_mode)
 644                 ctl2 |= BLM_COMBINATION_MODE;
 645         if (panel->backlight.active_low_pwm)
 646                 ctl2 |= BLM_POLARITY_I965;
 647         intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2);
 648         intel_de_posting_read(dev_priv, BLC_PWM_CTL2);
 649         intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2 | BLM_PWM_ENABLE);
 650
 651         intel_backlight_set_pwm_level(conn_state, level);
 652 }
 653
 654 static void vlv_enable_backlight(const struct intel_crtc_state *crtc_state,
 655                                  const struct drm_connector_state *conn_state, u32 level)
 656 {
 657         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 658         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 659         struct intel_panel *panel = &connector->panel;
 660         enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
 661         u32 ctl, ctl2;
 662
 663         ctl2 = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
 664         if (ctl2 & BLM_PWM_ENABLE) {
 665                 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
 666                 ctl2 &= ~BLM_PWM_ENABLE;
 667                 intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe), ctl2);
 668         }
 669
 670         ctl = panel->backlight.pwm_level_max << 16;
 671         intel_de_write(dev_priv, VLV_BLC_PWM_CTL(pipe), ctl);
 672
 673         /* XXX: combine this into above write? */
 674         intel_backlight_set_pwm_level(conn_state, level);
 675
 676         ctl2 = 0;
 677         if (panel->backlight.active_low_pwm)
 678                 ctl2 |= BLM_POLARITY_I965;
 679         intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe), ctl2);
 680         intel_de_posting_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
 681         intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe),
 682                        ctl2 | BLM_PWM_ENABLE);
 683 }
 684
 685 static void bxt_enable_backlight(const struct intel_crtc_state *crtc_state,
 686                                  const struct drm_connector_state *conn_state, u32 level)
 687 {
 688         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 689         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 690         struct intel_panel *panel = &connector->panel;
 691         enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
 692         u32 pwm_ctl, val;
 693
 694         /* Controller 1 uses the utility pin. */
 695         if (panel->backlight.controller == 1) {
 696                 val = intel_de_read(dev_priv, UTIL_PIN_CTL);
 697                 if (val & UTIL_PIN_ENABLE) {
 698                         drm_dbg_kms(&dev_priv->drm,
 699                                     "util pin already enabled\n");
 700                         val &= ~UTIL_PIN_ENABLE;
 701                         intel_de_write(dev_priv, UTIL_PIN_CTL, val);
 702                 }
 703
 704                 val = 0;
 705                 if (panel->backlight.util_pin_active_low)
 706                         val |= UTIL_PIN_POLARITY;
 707                 intel_de_write(dev_priv, UTIL_PIN_CTL,
 708                                val | UTIL_PIN_PIPE(pipe) | UTIL_PIN_MODE_PWM | UTIL_PIN_ENABLE);
 709         }
 710
 711         pwm_ctl = intel_de_read(dev_priv,
 712                                 BXT_BLC_PWM_CTL(panel->backlight.controller));
 713         if (pwm_ctl & BXT_BLC_PWM_ENABLE) {
 714                 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
 715                 pwm_ctl &= ~BXT_BLC_PWM_ENABLE;
 716                 intel_de_write(dev_priv,
 717                                BXT_BLC_PWM_CTL(panel->backlight.controller),
 718                                pwm_ctl);
 719         }
 720
 721         intel_de_write(dev_priv,
 722                        BXT_BLC_PWM_FREQ(panel->backlight.controller),
 723                        panel->backlight.pwm_level_max);
 724
 725         intel_backlight_set_pwm_level(conn_state, level);
 726
 727         pwm_ctl = 0;
 728         if (panel->backlight.active_low_pwm)
 729                 pwm_ctl |= BXT_BLC_PWM_POLARITY;
 730
 731         intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
 732                        pwm_ctl);
 733         intel_de_posting_read(dev_priv,
 734                               BXT_BLC_PWM_CTL(panel->backlight.controller));
 735         intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
 736                        pwm_ctl | BXT_BLC_PWM_ENABLE);
 737 }
 738
 739 static void cnp_enable_backlight(const struct intel_crtc_state *crtc_state,
 740                                  const struct drm_connector_state *conn_state, u32 level)
 741 {
 742         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 743         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 744         struct intel_panel *panel = &connector->panel;
 745         u32 pwm_ctl;
 746
 747         pwm_ctl = intel_de_read(dev_priv,
 748                                 BXT_BLC_PWM_CTL(panel->backlight.controller));
 749         if (pwm_ctl & BXT_BLC_PWM_ENABLE) {
 750                 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n");
 751                 pwm_ctl &= ~BXT_BLC_PWM_ENABLE;
 752                 intel_de_write(dev_priv,
 753                                BXT_BLC_PWM_CTL(panel->backlight.controller),
 754                                pwm_ctl);
 755         }
 756
 757         intel_de_write(dev_priv,
 758                        BXT_BLC_PWM_FREQ(panel->backlight.controller),
 759                        panel->backlight.pwm_level_max);
 760
 761         intel_backlight_set_pwm_level(conn_state, level);
 762
 763         pwm_ctl = 0;
 764         if (panel->backlight.active_low_pwm)
 765                 pwm_ctl |= BXT_BLC_PWM_POLARITY;
 766
 767         intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
 768                        pwm_ctl);
 769         intel_de_posting_read(dev_priv,
 770                               BXT_BLC_PWM_CTL(panel->backlight.controller));
 771         intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller),
 772                        pwm_ctl | BXT_BLC_PWM_ENABLE);
 773 }
 774
 775 static void ext_pwm_enable_backlight(const struct intel_crtc_state *crtc_state,
 776                                      const struct drm_connector_state *conn_state, u32 level)
 777 {
 778         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 779         struct intel_panel *panel = &connector->panel;
 780
 781         pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
 782         panel->backlight.pwm_state.enabled = true;
 783         pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
 784 }
 785
 786 static void __intel_backlight_enable(const struct intel_crtc_state *crtc_state,
 787                                      const struct drm_connector_state *conn_state)
 788 {
 789         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 790         struct intel_panel *panel = &connector->panel;
 791
 792         WARN_ON(panel->backlight.max == 0);
 793
 794         if (panel->backlight.level <= panel->backlight.min) {
 795                 panel->backlight.level = panel->backlight.max;
 796                 if (panel->backlight.device)
 797                         panel->backlight.device->props.brightness =
 798                                 scale_hw_to_user(connector,
 799                                                  panel->backlight.level,
 800                                                  panel->backlight.device->props.max_brightness);
 801         }
 802
 803         panel->backlight.funcs->enable(crtc_state, conn_state, panel->backlight.level);
 804         panel->backlight.enabled = true;
 805         if (panel->backlight.device)
 806                 panel->backlight.device->props.power = FB_BLANK_UNBLANK;
 807 }
 808
 809 void intel_backlight_enable(const struct intel_crtc_state *crtc_state,
 810                             const struct drm_connector_state *conn_state)
 811 {
 812         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 813         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 814         struct intel_panel *panel = &connector->panel;
 815         enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
 816
 817         if (!panel->backlight.present)
 818                 return;
 819
 820         drm_dbg_kms(&dev_priv->drm, "pipe %c\n", pipe_name(pipe));
 821
 822         mutex_lock(&dev_priv->display.backlight.lock);
 823
 824         __intel_backlight_enable(crtc_state, conn_state);
 825
 826         mutex_unlock(&dev_priv->display.backlight.lock);
 827 }
 828
 829 #if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)
 830 static u32 intel_panel_get_backlight(struct intel_connector *connector)
 831 {
 832         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 833         struct intel_panel *panel = &connector->panel;
 834         u32 val = 0;
 835
 836         mutex_lock(&dev_priv->display.backlight.lock);
 837
 838         if (panel->backlight.enabled)
 839                 val = panel->backlight.funcs->get(connector, intel_connector_get_pipe(connector));
 840
 841         mutex_unlock(&dev_priv->display.backlight.lock);
 842
 843         drm_dbg_kms(&dev_priv->drm, "get backlight PWM = %d\n", val);
 844         return val;
 845 }
 846
 847 /* Scale user_level in range [0..user_max] to [hw_min..hw_max]. */
 848 static u32 scale_user_to_hw(struct intel_connector *connector,
 849                             u32 user_level, u32 user_max)
 850 {
 851         struct intel_panel *panel = &connector->panel;
 852
 853         return scale(user_level, 0, user_max,
 854                      panel->backlight.min, panel->backlight.max);
 855 }
 856
 857 /* set backlight brightness to level in range [0..max], scaling wrt hw min */
 858 static void intel_panel_set_backlight(const struct drm_connector_state *conn_state,
 859                                       u32 user_level, u32 user_max)
 860 {
 861         struct intel_connector *connector = to_intel_connector(conn_state->connector);
 862         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 863         struct intel_panel *panel = &connector->panel;
 864         u32 hw_level;
 865
 866         if (!panel->backlight.present)
 867                 return;
 868
 869         mutex_lock(&dev_priv->display.backlight.lock);
 870
 871         drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0);
 872
 873         hw_level = scale_user_to_hw(connector, user_level, user_max);
 874         panel->backlight.level = hw_level;
 875
 876         if (panel->backlight.enabled)
 877                 intel_panel_actually_set_backlight(conn_state, hw_level);
 878
 879         mutex_unlock(&dev_priv->display.backlight.lock);
 880 }
 881
 882 static int intel_backlight_device_update_status(struct backlight_device *bd)
 883 {
 884         struct intel_connector *connector = bl_get_data(bd);
 885         struct intel_panel *panel = &connector->panel;
 886         struct drm_device *dev = connector->base.dev;
 887
 888         drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 889         DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n",
 890                       bd->props.brightness, bd->props.max_brightness);
 891         intel_panel_set_backlight(connector->base.state, bd->props.brightness,
 892                                   bd->props.max_brightness);
 893
 894         /*
 895          * Allow flipping bl_power as a sub-state of enabled. Sadly the
 896          * backlight class device does not make it easy to differentiate
 897          * between callbacks for brightness and bl_power, so our backlight_power
 898          * callback needs to take this into account.
 899          */
 900         if (panel->backlight.enabled) {
 901                 if (panel->backlight.power) {
 902                         bool enable = bd->props.power == FB_BLANK_UNBLANK &&
 903                                 bd->props.brightness != 0;
 904                         panel->backlight.power(connector, enable);
 905                 }
 906         } else {
 907                 bd->props.power = FB_BLANK_POWERDOWN;
 908         }
 909
 910         drm_modeset_unlock(&dev->mode_config.connection_mutex);
 911         return 0;
 912 }
 913
 914 static int intel_backlight_device_get_brightness(struct backlight_device *bd)
 915 {
 916         struct intel_connector *connector = bl_get_data(bd);
 917         struct drm_device *dev = connector->base.dev;
 918         struct drm_i915_private *dev_priv = to_i915(dev);
 919         intel_wakeref_t wakeref;
 920         int ret = 0;
 921
 922         with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref) {
 923                 u32 hw_level;
 924
 925                 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 926
 927                 hw_level = intel_panel_get_backlight(connector);
 928                 ret = scale_hw_to_user(connector,
 929                                        hw_level, bd->props.max_brightness);
 930
 931                 drm_modeset_unlock(&dev->mode_config.connection_mutex);
 932         }
 933
 934         return ret;
 935 }
 936
 937 static const struct backlight_ops intel_backlight_device_ops = {
 938         .update_status = intel_backlight_device_update_status,
 939         .get_brightness = intel_backlight_device_get_brightness,
 940 };
 941
 942 int intel_backlight_device_register(struct intel_connector *connector)
 943 {
 944         struct drm_i915_private *i915 = to_i915(connector->base.dev);
 945         struct intel_panel *panel = &connector->panel;
 946         struct backlight_properties props;
 947         struct backlight_device *bd;
 948         const char *name;
 949         int ret = 0;
 950
 951         if (WARN_ON(panel->backlight.device))
 952                 return -ENODEV;
 953
 954         if (!panel->backlight.present)
 955                 return 0;
 956
 957         WARN_ON(panel->backlight.max == 0);
 958
 959         if (!acpi_video_backlight_use_native()) {
 960                 drm_info(&i915->drm, "Skipping intel_backlight registration\n");
 961                 return 0;
 962         }
 963
 964         memset(&props, 0, sizeof(props));
 965         props.type = BACKLIGHT_RAW;
 966
 967         /*
 968          * Note: Everything should work even if the backlight device max
 969          * presented to the userspace is arbitrarily chosen.
 970          */
 971         props.max_brightness = panel->backlight.max;
 972         props.brightness = scale_hw_to_user(connector,
 973                                             panel->backlight.level,
 974                                             props.max_brightness);
 975
 976         if (panel->backlight.enabled)
 977                 props.power = FB_BLANK_UNBLANK;
 978         else
 979                 props.power = FB_BLANK_POWERDOWN;
 980
 981         name = kstrdup("intel_backlight", GFP_KERNEL);
 982         if (!name)
 983                 return -ENOMEM;
 984
 985         bd = backlight_device_get_by_name(name);
 986         if (bd) {
 987                 put_device(&bd->dev);
 988                 /*
 989                  * Using the same name independent of the drm device or connector
 990                  * prevents registration of multiple backlight devices in the
 991                  * driver. However, we need to use the default name for backward
 992                  * compatibility. Use unique names for subsequent backlight devices as a
 993                  * fallback when the default name already exists.
 994                  */
 995                 kfree(name);
 996                 name = kasprintf(GFP_KERNEL, "card%d-%s-backlight",
 997                                  i915->drm.primary->index, connector->base.name);
 998                 if (!name)
 999                         return -ENOMEM;
1000         }
1001         bd = backlight_device_register(name, connector->base.kdev, connector,
1002                                        &intel_backlight_device_ops, &props);
1003
1004         if (IS_ERR(bd)) {
1005                 drm_err(&i915->drm,
1006                         "[CONNECTOR:%d:%s] backlight device %s register failed: %ld\n",
1007                         connector->base.base.id, connector->base.name, name, PTR_ERR(bd));
1008                 ret = PTR_ERR(bd);
1009                 goto out;
1010         }
1011
1012         panel->backlight.device = bd;
1013
1014         drm_dbg_kms(&i915->drm,
1015                     "[CONNECTOR:%d:%s] backlight device %s registered\n",
1016                     connector->base.base.id, connector->base.name, name);
1017
1018 out:
1019         kfree(name);
1020
1021         return ret;
1022 }
1023
1024 void intel_backlight_device_unregister(struct intel_connector *connector)
1025 {
1026         struct intel_panel *panel = &connector->panel;
1027
1028         if (panel->backlight.device) {
1029                 backlight_device_unregister(panel->backlight.device);
1030                 panel->backlight.device = NULL;
1031         }
1032 }
1033 #endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
1034
1035 /*
1036  * CNP: PWM clock frequency is 19.2 MHz or 24 MHz.
1037  *      PWM increment = 1
1038  */
1039 static u32 cnp_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1040 {
1041         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1042
1043         return DIV_ROUND_CLOSEST(KHz(RUNTIME_INFO(dev_priv)->rawclk_freq),
1044                                  pwm_freq_hz);
1045 }
1046
1047 /*
1048  * BXT: PWM clock frequency = 19.2 MHz.
1049  */
1050 static u32 bxt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1051 {
1052         return DIV_ROUND_CLOSEST(KHz(19200), pwm_freq_hz);
1053 }
1054
1055 /*
1056  * SPT: This value represents the period of the PWM stream in clock periods
1057  * multiplied by 16 (default increment) or 128 (alternate increment selected in
1058  * SCHICKEN_1 bit 0). PWM clock is 24 MHz.
1059  */
1060 static u32 spt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1061 {
1062         struct intel_panel *panel = &connector->panel;
1063         u32 mul;
1064
1065         if (panel->backlight.alternate_pwm_increment)
1066                 mul = 128;
1067         else
1068                 mul = 16;
1069
1070         return DIV_ROUND_CLOSEST(MHz(24), pwm_freq_hz * mul);
1071 }
1072
1073 /*
1074  * LPT: This value represents the period of the PWM stream in clock periods
1075  * multiplied by 128 (default increment) or 16 (alternate increment, selected in
1076  * LPT SOUTH_CHICKEN2 register bit 5).
1077  */
1078 static u32 lpt_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1079 {
1080         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1081         struct intel_panel *panel = &connector->panel;
1082         u32 mul, clock;
1083
1084         if (panel->backlight.alternate_pwm_increment)
1085                 mul = 16;
1086         else
1087                 mul = 128;
1088
1089         if (HAS_PCH_LPT_H(dev_priv))
1090                 clock = MHz(135); /* LPT:H */
1091         else
1092                 clock = MHz(24); /* LPT:LP */
1093
1094         return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * mul);
1095 }
1096
1097 /*
1098  * ILK/SNB/IVB: This value represents the period of the PWM stream in PCH
1099  * display raw clocks multiplied by 128.
1100  */
1101 static u32 pch_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1102 {
1103         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1104
1105         return DIV_ROUND_CLOSEST(KHz(RUNTIME_INFO(dev_priv)->rawclk_freq),
1106                                  pwm_freq_hz * 128);
1107 }
1108
1109 /*
1110  * Gen2: This field determines the number of time base events (display core
1111  * clock frequency/32) in total for a complete cycle of modulated backlight
1112  * control.
1113  *
1114  * Gen3: A time base event equals the display core clock ([DevPNV] HRAW clock)
1115  * divided by 32.
1116  */
1117 static u32 i9xx_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1118 {
1119         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1120         int clock;
1121
1122         if (IS_PINEVIEW(dev_priv))
1123                 clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq);
1124         else
1125                 clock = KHz(dev_priv->display.cdclk.hw.cdclk);
1126
1127         return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * 32);
1128 }
1129
1130 /*
1131  * Gen4: This value represents the period of the PWM stream in display core
1132  * clocks ([DevCTG] HRAW clocks) multiplied by 128.
1133  *
1134  */
1135 static u32 i965_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1136 {
1137         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1138         int clock;
1139
1140         if (IS_G4X(dev_priv))
1141                 clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq);
1142         else
1143                 clock = KHz(dev_priv->display.cdclk.hw.cdclk);
1144
1145         return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * 128);
1146 }
1147
1148 /*
1149  * VLV: This value represents the period of the PWM stream in display core
1150  * clocks ([DevCTG] 200MHz HRAW clocks) multiplied by 128 or 25MHz S0IX clocks
1151  * multiplied by 16. CHV uses a 19.2MHz S0IX clock.
1152  */
1153 static u32 vlv_hz_to_pwm(struct intel_connector *connector, u32 pwm_freq_hz)
1154 {
1155         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1156         int mul, clock;
1157
1158         if ((intel_de_read(dev_priv, CBR1_VLV) & CBR_PWM_CLOCK_MUX_SELECT) == 0) {
1159                 if (IS_CHERRYVIEW(dev_priv))
1160                         clock = KHz(19200);
1161                 else
1162                         clock = MHz(25);
1163                 mul = 16;
1164         } else {
1165                 clock = KHz(RUNTIME_INFO(dev_priv)->rawclk_freq);
1166                 mul = 128;
1167         }
1168
1169         return DIV_ROUND_CLOSEST(clock, pwm_freq_hz * mul);
1170 }
1171
1172 static u16 get_vbt_pwm_freq(struct intel_connector *connector)
1173 {
1174         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1175         u16 pwm_freq_hz = connector->panel.vbt.backlight.pwm_freq_hz;
1176
1177         if (pwm_freq_hz) {
1178                 drm_dbg_kms(&dev_priv->drm,
1179                             "VBT defined backlight frequency %u Hz\n",
1180                             pwm_freq_hz);
1181         } else {
1182                 pwm_freq_hz = 200;
1183                 drm_dbg_kms(&dev_priv->drm,
1184                             "default backlight frequency %u Hz\n",
1185                             pwm_freq_hz);
1186         }
1187
1188         return pwm_freq_hz;
1189 }
1190
1191 static u32 get_backlight_max_vbt(struct intel_connector *connector)
1192 {
1193         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1194         struct intel_panel *panel = &connector->panel;
1195         u16 pwm_freq_hz = get_vbt_pwm_freq(connector);
1196         u32 pwm;
1197
1198         if (!panel->backlight.pwm_funcs->hz_to_pwm) {
1199                 drm_dbg_kms(&dev_priv->drm,
1200                             "backlight frequency conversion not supported\n");
1201                 return 0;
1202         }
1203
1204         pwm = panel->backlight.pwm_funcs->hz_to_pwm(connector, pwm_freq_hz);
1205         if (!pwm) {
1206                 drm_dbg_kms(&dev_priv->drm,
1207                             "backlight frequency conversion failed\n");
1208                 return 0;
1209         }
1210
1211         return pwm;
1212 }
1213
1214 /*
1215  * Note: The setup hooks can't assume pipe is set!
1216  */
1217 static u32 get_backlight_min_vbt(struct intel_connector *connector)
1218 {
1219         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1220         struct intel_panel *panel = &connector->panel;
1221         int min;
1222
1223         drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0);
1224
1225         /*
1226          * XXX: If the vbt value is 255, it makes min equal to max, which leads
1227          * to problems. There are such machines out there. Either our
1228          * interpretation is wrong or the vbt has bogus data. Or both. Safeguard
1229          * against this by letting the minimum be at most (arbitrarily chosen)
1230          * 25% of the max.
1231          */
1232         min = clamp_t(int, connector->panel.vbt.backlight.min_brightness, 0, 64);
1233         if (min != connector->panel.vbt.backlight.min_brightness) {
1234                 drm_dbg_kms(&dev_priv->drm,
1235                             "clamping VBT min backlight %d/255 to %d/255\n",
1236                             connector->panel.vbt.backlight.min_brightness, min);
1237         }
1238
1239         /* vbt value is a coefficient in range [0..255] */
1240         return scale(min, 0, 255, 0, panel->backlight.pwm_level_max);
1241 }
1242
1243 static int lpt_setup_backlight(struct intel_connector *connector, enum pipe unused)
1244 {
1245         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1246         struct intel_panel *panel = &connector->panel;
1247         u32 cpu_ctl2, pch_ctl1, pch_ctl2, val;
1248         bool alt, cpu_mode;
1249
1250         if (HAS_PCH_LPT(dev_priv))
1251                 alt = intel_de_read(dev_priv, SOUTH_CHICKEN2) & LPT_PWM_GRANULARITY;
1252         else
1253                 alt = intel_de_read(dev_priv, SOUTH_CHICKEN1) & SPT_PWM_GRANULARITY;
1254         panel->backlight.alternate_pwm_increment = alt;
1255
1256         pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
1257         panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY;
1258
1259         pch_ctl2 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2);
1260         panel->backlight.pwm_level_max = pch_ctl2 >> 16;
1261
1262         cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
1263
1264         if (!panel->backlight.pwm_level_max)
1265                 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1266
1267         if (!panel->backlight.pwm_level_max)
1268                 return -ENODEV;
1269
1270         panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1271
1272         panel->backlight.pwm_enabled = pch_ctl1 & BLM_PCH_PWM_ENABLE;
1273
1274         cpu_mode = panel->backlight.pwm_enabled && HAS_PCH_LPT(dev_priv) &&
1275                    !(pch_ctl1 & BLM_PCH_OVERRIDE_ENABLE) &&
1276                    (cpu_ctl2 & BLM_PWM_ENABLE);
1277
1278         if (cpu_mode) {
1279                 val = pch_get_backlight(connector, unused);
1280
1281                 drm_dbg_kms(&dev_priv->drm,
1282                             "CPU backlight register was enabled, switching to PCH override\n");
1283
1284                 /* Write converted CPU PWM value to PCH override register */
1285                 lpt_set_backlight(connector->base.state, val);
1286                 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1,
1287                                pch_ctl1 | BLM_PCH_OVERRIDE_ENABLE);
1288
1289                 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2,
1290                                cpu_ctl2 & ~BLM_PWM_ENABLE);
1291         }
1292
1293         return 0;
1294 }
1295
1296 static int pch_setup_backlight(struct intel_connector *connector, enum pipe unused)
1297 {
1298         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1299         struct intel_panel *panel = &connector->panel;
1300         u32 cpu_ctl2, pch_ctl1, pch_ctl2;
1301
1302         pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1);
1303         panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY;
1304
1305         pch_ctl2 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2);
1306         panel->backlight.pwm_level_max = pch_ctl2 >> 16;
1307
1308         if (!panel->backlight.pwm_level_max)
1309                 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1310
1311         if (!panel->backlight.pwm_level_max)
1312                 return -ENODEV;
1313
1314         panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1315
1316         cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2);
1317         panel->backlight.pwm_enabled = (cpu_ctl2 & BLM_PWM_ENABLE) &&
1318                 (pch_ctl1 & BLM_PCH_PWM_ENABLE);
1319
1320         return 0;
1321 }
1322
1323 static int i9xx_setup_backlight(struct intel_connector *connector, enum pipe unused)
1324 {
1325         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1326         struct intel_panel *panel = &connector->panel;
1327         u32 ctl, val;
1328
1329         ctl = intel_de_read(dev_priv, BLC_PWM_CTL);
1330
1331         if (DISPLAY_VER(dev_priv) == 2 || IS_I915GM(dev_priv) || IS_I945GM(dev_priv))
1332                 panel->backlight.combination_mode = ctl & BLM_LEGACY_MODE;
1333
1334         if (IS_PINEVIEW(dev_priv))
1335                 panel->backlight.active_low_pwm = ctl & BLM_POLARITY_PNV;
1336
1337         panel->backlight.pwm_level_max = ctl >> 17;
1338
1339         if (!panel->backlight.pwm_level_max) {
1340                 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1341                 panel->backlight.pwm_level_max >>= 1;
1342         }
1343
1344         if (!panel->backlight.pwm_level_max)
1345                 return -ENODEV;
1346
1347         if (panel->backlight.combination_mode)
1348                 panel->backlight.pwm_level_max *= 0xff;
1349
1350         panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1351
1352         val = i9xx_get_backlight(connector, unused);
1353         val = intel_backlight_invert_pwm_level(connector, val);
1354         val = clamp(val, panel->backlight.pwm_level_min, panel->backlight.pwm_level_max);
1355
1356         panel->backlight.pwm_enabled = val != 0;
1357
1358         return 0;
1359 }
1360
1361 static int i965_setup_backlight(struct intel_connector *connector, enum pipe unused)
1362 {
1363         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1364         struct intel_panel *panel = &connector->panel;
1365         u32 ctl, ctl2;
1366
1367         ctl2 = intel_de_read(dev_priv, BLC_PWM_CTL2);
1368         panel->backlight.combination_mode = ctl2 & BLM_COMBINATION_MODE;
1369         panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
1370
1371         ctl = intel_de_read(dev_priv, BLC_PWM_CTL);
1372         panel->backlight.pwm_level_max = ctl >> 16;
1373
1374         if (!panel->backlight.pwm_level_max)
1375                 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1376
1377         if (!panel->backlight.pwm_level_max)
1378                 return -ENODEV;
1379
1380         if (panel->backlight.combination_mode)
1381                 panel->backlight.pwm_level_max *= 0xff;
1382
1383         panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1384
1385         panel->backlight.pwm_enabled = ctl2 & BLM_PWM_ENABLE;
1386
1387         return 0;
1388 }
1389
1390 static int vlv_setup_backlight(struct intel_connector *connector, enum pipe pipe)
1391 {
1392         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1393         struct intel_panel *panel = &connector->panel;
1394         u32 ctl, ctl2;
1395
1396         if (drm_WARN_ON(&dev_priv->drm, pipe != PIPE_A && pipe != PIPE_B))
1397                 return -ENODEV;
1398
1399         ctl2 = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe));
1400         panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965;
1401
1402         ctl = intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe));
1403         panel->backlight.pwm_level_max = ctl >> 16;
1404
1405         if (!panel->backlight.pwm_level_max)
1406                 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1407
1408         if (!panel->backlight.pwm_level_max)
1409                 return -ENODEV;
1410
1411         panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1412
1413         panel->backlight.pwm_enabled = ctl2 & BLM_PWM_ENABLE;
1414
1415         return 0;
1416 }
1417
1418 static int
1419 bxt_setup_backlight(struct intel_connector *connector, enum pipe unused)
1420 {
1421         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1422         struct intel_panel *panel = &connector->panel;
1423         u32 pwm_ctl, val;
1424
1425         panel->backlight.controller = connector->panel.vbt.backlight.controller;
1426
1427         pwm_ctl = intel_de_read(dev_priv,
1428                                 BXT_BLC_PWM_CTL(panel->backlight.controller));
1429
1430         /* Controller 1 uses the utility pin. */
1431         if (panel->backlight.controller == 1) {
1432                 val = intel_de_read(dev_priv, UTIL_PIN_CTL);
1433                 panel->backlight.util_pin_active_low =
1434                                         val & UTIL_PIN_POLARITY;
1435         }
1436
1437         panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY;
1438         panel->backlight.pwm_level_max =
1439                 intel_de_read(dev_priv, BXT_BLC_PWM_FREQ(panel->backlight.controller));
1440
1441         if (!panel->backlight.pwm_level_max)
1442                 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1443
1444         if (!panel->backlight.pwm_level_max)
1445                 return -ENODEV;
1446
1447         panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1448
1449         panel->backlight.pwm_enabled = pwm_ctl & BXT_BLC_PWM_ENABLE;
1450
1451         return 0;
1452 }
1453
1454 static int
1455 cnp_setup_backlight(struct intel_connector *connector, enum pipe unused)
1456 {
1457         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1458         struct intel_panel *panel = &connector->panel;
1459         u32 pwm_ctl;
1460
1461         /*
1462          * CNP has the BXT implementation of backlight, but with only one
1463          * controller. TODO: ICP has multiple controllers but we only use
1464          * controller 0 for now.
1465          */
1466         panel->backlight.controller = 0;
1467
1468         pwm_ctl = intel_de_read(dev_priv,
1469                                 BXT_BLC_PWM_CTL(panel->backlight.controller));
1470
1471         panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY;
1472         panel->backlight.pwm_level_max =
1473                 intel_de_read(dev_priv, BXT_BLC_PWM_FREQ(panel->backlight.controller));
1474
1475         if (!panel->backlight.pwm_level_max)
1476                 panel->backlight.pwm_level_max = get_backlight_max_vbt(connector);
1477
1478         if (!panel->backlight.pwm_level_max)
1479                 return -ENODEV;
1480
1481         panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1482
1483         panel->backlight.pwm_enabled = pwm_ctl & BXT_BLC_PWM_ENABLE;
1484
1485         return 0;
1486 }
1487
1488 static int ext_pwm_setup_backlight(struct intel_connector *connector,
1489                                    enum pipe pipe)
1490 {
1491         struct drm_device *dev = connector->base.dev;
1492         struct drm_i915_private *dev_priv = to_i915(dev);
1493         struct intel_panel *panel = &connector->panel;
1494         const char *desc;
1495         u32 level;
1496
1497         /* Get the right PWM chip for DSI backlight according to VBT */
1498         if (connector->panel.vbt.dsi.config->pwm_blc == PPS_BLC_PMIC) {
1499                 panel->backlight.pwm = pwm_get(dev->dev, "pwm_pmic_backlight");
1500                 desc = "PMIC";
1501         } else {
1502                 panel->backlight.pwm = pwm_get(dev->dev, "pwm_soc_backlight");
1503                 desc = "SoC";
1504         }
1505
1506         if (IS_ERR(panel->backlight.pwm)) {
1507                 drm_err(&dev_priv->drm, "Failed to get the %s PWM chip\n",
1508                         desc);
1509                 panel->backlight.pwm = NULL;
1510                 return -ENODEV;
1511         }
1512
1513         panel->backlight.pwm_level_max = 100; /* 100% */
1514         panel->backlight.pwm_level_min = get_backlight_min_vbt(connector);
1515
1516         if (pwm_is_enabled(panel->backlight.pwm)) {
1517                 /* PWM is already enabled, use existing settings */
1518                 pwm_get_state(panel->backlight.pwm, &panel->backlight.pwm_state);
1519
1520                 level = pwm_get_relative_duty_cycle(&panel->backlight.pwm_state,
1521                                                     100);
1522                 level = intel_backlight_invert_pwm_level(connector, level);
1523                 panel->backlight.pwm_enabled = true;
1524
1525                 drm_dbg_kms(&dev_priv->drm, "PWM already enabled at freq %ld, VBT freq %d, level %d\n",
1526                             NSEC_PER_SEC / (unsigned long)panel->backlight.pwm_state.period,
1527                             get_vbt_pwm_freq(connector), level);
1528         } else {
1529                 /* Set period from VBT frequency, leave other settings at 0. */
1530                 panel->backlight.pwm_state.period =
1531                         NSEC_PER_SEC / get_vbt_pwm_freq(connector);
1532         }
1533
1534         drm_info(&dev_priv->drm, "Using %s PWM for LCD backlight control\n",
1535                  desc);
1536         return 0;
1537 }
1538
1539 static void intel_pwm_set_backlight(const struct drm_connector_state *conn_state, u32 level)
1540 {
1541         struct intel_connector *connector = to_intel_connector(conn_state->connector);
1542         struct intel_panel *panel = &connector->panel;
1543
1544         panel->backlight.pwm_funcs->set(conn_state,
1545                                         intel_backlight_invert_pwm_level(connector, level));
1546 }
1547
1548 static u32 intel_pwm_get_backlight(struct intel_connector *connector, enum pipe pipe)
1549 {
1550         struct intel_panel *panel = &connector->panel;
1551
1552         return intel_backlight_invert_pwm_level(connector,
1553                                             panel->backlight.pwm_funcs->get(connector, pipe));
1554 }
1555
1556 static void intel_pwm_enable_backlight(const struct intel_crtc_state *crtc_state,
1557                                        const struct drm_connector_state *conn_state, u32 level)
1558 {
1559         struct intel_connector *connector = to_intel_connector(conn_state->connector);
1560         struct intel_panel *panel = &connector->panel;
1561
1562         panel->backlight.pwm_funcs->enable(crtc_state, conn_state,
1563                                            intel_backlight_invert_pwm_level(connector, level));
1564 }
1565
1566 static void intel_pwm_disable_backlight(const struct drm_connector_state *conn_state, u32 level)
1567 {
1568         struct intel_connector *connector = to_intel_connector(conn_state->connector);
1569         struct intel_panel *panel = &connector->panel;
1570
1571         panel->backlight.pwm_funcs->disable(conn_state,
1572                                             intel_backlight_invert_pwm_level(connector, level));
1573 }
1574
1575 static int intel_pwm_setup_backlight(struct intel_connector *connector, enum pipe pipe)
1576 {
1577         struct intel_panel *panel = &connector->panel;
1578         int ret = panel->backlight.pwm_funcs->setup(connector, pipe);
1579
1580         if (ret < 0)
1581                 return ret;
1582
1583         panel->backlight.min = panel->backlight.pwm_level_min;
1584         panel->backlight.max = panel->backlight.pwm_level_max;
1585         panel->backlight.level = intel_pwm_get_backlight(connector, pipe);
1586         panel->backlight.enabled = panel->backlight.pwm_enabled;
1587
1588         return 0;
1589 }
1590
1591 void intel_backlight_update(struct intel_atomic_state *state,
1592                             struct intel_encoder *encoder,
1593                             const struct intel_crtc_state *crtc_state,
1594                             const struct drm_connector_state *conn_state)
1595 {
1596         struct intel_connector *connector = to_intel_connector(conn_state->connector);
1597         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1598         struct intel_panel *panel = &connector->panel;
1599
1600         if (!panel->backlight.present)
1601                 return;
1602
1603         mutex_lock(&dev_priv->display.backlight.lock);
1604         if (!panel->backlight.enabled)
1605                 __intel_backlight_enable(crtc_state, conn_state);
1606
1607         mutex_unlock(&dev_priv->display.backlight.lock);
1608 }
1609
1610 int intel_backlight_setup(struct intel_connector *connector, enum pipe pipe)
1611 {
1612         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1613         struct intel_panel *panel = &connector->panel;
1614         int ret;
1615
1616         if (!connector->panel.vbt.backlight.present) {
1617                 if (intel_has_quirk(dev_priv, QUIRK_BACKLIGHT_PRESENT)) {
1618                         drm_dbg_kms(&dev_priv->drm,
1619                                     "no backlight present per VBT, but present per quirk\n");
1620                 } else {
1621                         drm_dbg_kms(&dev_priv->drm,
1622                                     "no backlight present per VBT\n");
1623                         return 0;
1624                 }
1625         }
1626
1627         /* ensure intel_panel has been initialized first */
1628         if (drm_WARN_ON(&dev_priv->drm, !panel->backlight.funcs))
1629                 return -ENODEV;
1630
1631         /* set level and max in panel struct */
1632         mutex_lock(&dev_priv->display.backlight.lock);
1633         ret = panel->backlight.funcs->setup(connector, pipe);
1634         mutex_unlock(&dev_priv->display.backlight.lock);
1635
1636         if (ret) {
1637                 drm_dbg_kms(&dev_priv->drm,
1638                             "failed to setup backlight for connector %s\n",
1639                             connector->base.name);
1640                 return ret;
1641         }
1642
1643         panel->backlight.present = true;
1644
1645         drm_dbg_kms(&dev_priv->drm,
1646                     "Connector %s backlight initialized, %s, brightness %u/%u\n",
1647                     connector->base.name,
1648                     str_enabled_disabled(panel->backlight.enabled),
1649                     panel->backlight.level, panel->backlight.max);
1650
1651         return 0;
1652 }
1653
1654 void intel_backlight_destroy(struct intel_panel *panel)
1655 {
1656         /* dispose of the pwm */
1657         if (panel->backlight.pwm)
1658                 pwm_put(panel->backlight.pwm);
1659
1660         panel->backlight.present = false;
1661 }
1662
1663 static const struct intel_panel_bl_funcs bxt_pwm_funcs = {
1664         .setup = bxt_setup_backlight,
1665         .enable = bxt_enable_backlight,
1666         .disable = bxt_disable_backlight,
1667         .set = bxt_set_backlight,
1668         .get = bxt_get_backlight,
1669         .hz_to_pwm = bxt_hz_to_pwm,
1670 };
1671
1672 static const struct intel_panel_bl_funcs cnp_pwm_funcs = {
1673         .setup = cnp_setup_backlight,
1674         .enable = cnp_enable_backlight,
1675         .disable = cnp_disable_backlight,
1676         .set = bxt_set_backlight,
1677         .get = bxt_get_backlight,
1678         .hz_to_pwm = cnp_hz_to_pwm,
1679 };
1680
1681 static const struct intel_panel_bl_funcs lpt_pwm_funcs = {
1682         .setup = lpt_setup_backlight,
1683         .enable = lpt_enable_backlight,
1684         .disable = lpt_disable_backlight,
1685         .set = lpt_set_backlight,
1686         .get = lpt_get_backlight,
1687         .hz_to_pwm = lpt_hz_to_pwm,
1688 };
1689
1690 static const struct intel_panel_bl_funcs spt_pwm_funcs = {
1691         .setup = lpt_setup_backlight,
1692         .enable = lpt_enable_backlight,
1693         .disable = lpt_disable_backlight,
1694         .set = lpt_set_backlight,
1695         .get = lpt_get_backlight,
1696         .hz_to_pwm = spt_hz_to_pwm,
1697 };
1698
1699 static const struct intel_panel_bl_funcs pch_pwm_funcs = {
1700         .setup = pch_setup_backlight,
1701         .enable = pch_enable_backlight,
1702         .disable = pch_disable_backlight,
1703         .set = pch_set_backlight,
1704         .get = pch_get_backlight,
1705         .hz_to_pwm = pch_hz_to_pwm,
1706 };
1707
1708 static const struct intel_panel_bl_funcs ext_pwm_funcs = {
1709         .setup = ext_pwm_setup_backlight,
1710         .enable = ext_pwm_enable_backlight,
1711         .disable = ext_pwm_disable_backlight,
1712         .set = ext_pwm_set_backlight,
1713         .get = ext_pwm_get_backlight,
1714 };
1715
1716 static const struct intel_panel_bl_funcs vlv_pwm_funcs = {
1717         .setup = vlv_setup_backlight,
1718         .enable = vlv_enable_backlight,
1719         .disable = vlv_disable_backlight,
1720         .set = vlv_set_backlight,
1721         .get = vlv_get_backlight,
1722         .hz_to_pwm = vlv_hz_to_pwm,
1723 };
1724
1725 static const struct intel_panel_bl_funcs i965_pwm_funcs = {
1726         .setup = i965_setup_backlight,
1727         .enable = i965_enable_backlight,
1728         .disable = i965_disable_backlight,
1729         .set = i9xx_set_backlight,
1730         .get = i9xx_get_backlight,
1731         .hz_to_pwm = i965_hz_to_pwm,
1732 };
1733
1734 static const struct intel_panel_bl_funcs i9xx_pwm_funcs = {
1735         .setup = i9xx_setup_backlight,
1736         .enable = i9xx_enable_backlight,
1737         .disable = i9xx_disable_backlight,
1738         .set = i9xx_set_backlight,
1739         .get = i9xx_get_backlight,
1740         .hz_to_pwm = i9xx_hz_to_pwm,
1741 };
1742
1743 static const struct intel_panel_bl_funcs pwm_bl_funcs = {
1744         .setup = intel_pwm_setup_backlight,
1745         .enable = intel_pwm_enable_backlight,
1746         .disable = intel_pwm_disable_backlight,
1747         .set = intel_pwm_set_backlight,
1748         .get = intel_pwm_get_backlight,
1749 };
1750
1751 /* Set up chip specific backlight functions */
1752 void intel_backlight_init_funcs(struct intel_panel *panel)
1753 {
1754         struct intel_connector *connector =
1755                 container_of(panel, struct intel_connector, panel);
1756         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1757
1758         if (connector->base.connector_type == DRM_MODE_CONNECTOR_DSI &&
1759             intel_dsi_dcs_init_backlight_funcs(connector) == 0)
1760                 return;
1761
1762         if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
1763                 panel->backlight.pwm_funcs = &bxt_pwm_funcs;
1764         } else if (INTEL_PCH_TYPE(dev_priv) >= PCH_CNP) {
1765                 panel->backlight.pwm_funcs = &cnp_pwm_funcs;
1766         } else if (INTEL_PCH_TYPE(dev_priv) >= PCH_LPT) {
1767                 if (HAS_PCH_LPT(dev_priv))
1768                         panel->backlight.pwm_funcs = &lpt_pwm_funcs;
1769                 else
1770                         panel->backlight.pwm_funcs = &spt_pwm_funcs;
1771         } else if (HAS_PCH_SPLIT(dev_priv)) {
1772                 panel->backlight.pwm_funcs = &pch_pwm_funcs;
1773         } else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
1774                 if (connector->base.connector_type == DRM_MODE_CONNECTOR_DSI) {
1775                         panel->backlight.pwm_funcs = &ext_pwm_funcs;
1776                 } else {
1777                         panel->backlight.pwm_funcs = &vlv_pwm_funcs;
1778                 }
1779         } else if (DISPLAY_VER(dev_priv) == 4) {
1780                 panel->backlight.pwm_funcs = &i965_pwm_funcs;
1781         } else {
1782                 panel->backlight.pwm_funcs = &i9xx_pwm_funcs;
1783         }
1784
1785         if (connector->base.connector_type == DRM_MODE_CONNECTOR_eDP) {
1786                 if (intel_dp_aux_init_backlight_funcs(connector) == 0)
1787                         return;
1788
1789                 if (!intel_has_quirk(dev_priv, QUIRK_NO_PPS_BACKLIGHT_POWER_HOOK))
1790                         connector->panel.backlight.power = intel_pps_backlight_power;
1791         }
1792
1793         /* We're using a standard PWM backlight interface */
1794         panel->backlight.funcs = &pwm_bl_funcs;
1795 }