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 "intel_backlight.h" 12 #include "intel_connector.h" 13 #include "intel_de.h" 14 #include "intel_display_types.h" 15 #include "intel_dp_aux_backlight.h" 16 #include "intel_dsi_dcs_backlight.h" 17 #include "intel_panel.h" 18 #include "intel_pci_config.h" 19 #include "intel_pps.h" 20 21 /** 22 * scale - scale values from one range to another 23 * @source_val: value in range [@source_min..@source_max] 24 * @source_min: minimum legal value for @source_val 25 * @source_max: maximum legal value for @source_val 26 * @target_min: corresponding target value for @source_min 27 * @target_max: corresponding target value for @source_max 28 * 29 * Return @source_val in range [@source_min..@source_max] scaled to range 30 * [@target_min..@target_max]. 31 */ 32 static u32 scale(u32 source_val, 33 u32 source_min, u32 source_max, 34 u32 target_min, u32 target_max) 35 { 36 u64 target_val; 37 38 WARN_ON(source_min > source_max); 39 WARN_ON(target_min > target_max); 40 41 /* defensive */ 42 source_val = clamp(source_val, source_min, source_max); 43 44 /* avoid overflows */ 45 target_val = mul_u32_u32(source_val - source_min, 46 target_max - target_min); 47 target_val = DIV_ROUND_CLOSEST_ULL(target_val, source_max - source_min); 48 target_val += target_min; 49 50 return target_val; 51 } 52 53 /* 54 * Scale user_level in range [0..user_max] to [0..hw_max], clamping the result 55 * to [hw_min..hw_max]. 56 */ 57 static u32 clamp_user_to_hw(struct intel_connector *connector, 58 u32 user_level, u32 user_max) 59 { 60 struct intel_panel *panel = &connector->panel; 61 u32 hw_level; 62 63 hw_level = scale(user_level, 0, user_max, 0, panel->backlight.max); 64 hw_level = clamp(hw_level, panel->backlight.min, panel->backlight.max); 65 66 return hw_level; 67 } 68 69 /* Scale hw_level in range [hw_min..hw_max] to [0..user_max]. */ 70 static u32 scale_hw_to_user(struct intel_connector *connector, 71 u32 hw_level, u32 user_max) 72 { 73 struct intel_panel *panel = &connector->panel; 74 75 return scale(hw_level, panel->backlight.min, panel->backlight.max, 76 0, user_max); 77 } 78 79 u32 intel_backlight_invert_pwm_level(struct intel_connector *connector, u32 val) 80 { 81 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 82 struct intel_panel *panel = &connector->panel; 83 84 drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0); 85 86 if (dev_priv->params.invert_brightness < 0) 87 return val; 88 89 if (dev_priv->params.invert_brightness > 0 || 90 dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS) { 91 return panel->backlight.pwm_level_max - val + panel->backlight.pwm_level_min; 92 } 93 94 return val; 95 } 96 97 void intel_backlight_set_pwm_level(const struct drm_connector_state *conn_state, u32 val) 98 { 99 struct intel_connector *connector = to_intel_connector(conn_state->connector); 100 struct drm_i915_private *i915 = to_i915(connector->base.dev); 101 struct intel_panel *panel = &connector->panel; 102 103 drm_dbg_kms(&i915->drm, "set backlight PWM = %d\n", val); 104 panel->backlight.pwm_funcs->set(conn_state, val); 105 } 106 107 u32 intel_backlight_level_to_pwm(struct intel_connector *connector, u32 val) 108 { 109 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 110 struct intel_panel *panel = &connector->panel; 111 112 drm_WARN_ON_ONCE(&dev_priv->drm, 113 panel->backlight.max == 0 || panel->backlight.pwm_level_max == 0); 114 115 val = scale(val, panel->backlight.min, panel->backlight.max, 116 panel->backlight.pwm_level_min, panel->backlight.pwm_level_max); 117 118 return intel_backlight_invert_pwm_level(connector, val); 119 } 120 121 u32 intel_backlight_level_from_pwm(struct intel_connector *connector, u32 val) 122 { 123 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 124 struct intel_panel *panel = &connector->panel; 125 126 drm_WARN_ON_ONCE(&dev_priv->drm, 127 panel->backlight.max == 0 || panel->backlight.pwm_level_max == 0); 128 129 if (dev_priv->params.invert_brightness > 0 || 130 (dev_priv->params.invert_brightness == 0 && dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS)) 131 val = panel->backlight.pwm_level_max - (val - panel->backlight.pwm_level_min); 132 133 return scale(val, panel->backlight.pwm_level_min, panel->backlight.pwm_level_max, 134 panel->backlight.min, panel->backlight.max); 135 } 136 137 static u32 lpt_get_backlight(struct intel_connector *connector, enum pipe unused) 138 { 139 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 140 141 return intel_de_read(dev_priv, BLC_PWM_PCH_CTL2) & BACKLIGHT_DUTY_CYCLE_MASK; 142 } 143 144 static u32 pch_get_backlight(struct intel_connector *connector, enum pipe unused) 145 { 146 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 147 148 return intel_de_read(dev_priv, BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK; 149 } 150 151 static u32 i9xx_get_backlight(struct intel_connector *connector, enum pipe unused) 152 { 153 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 154 struct intel_panel *panel = &connector->panel; 155 u32 val; 156 157 val = intel_de_read(dev_priv, BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK; 158 if (DISPLAY_VER(dev_priv) < 4) 159 val >>= 1; 160 161 if (panel->backlight.combination_mode) { 162 u8 lbpc; 163 164 pci_read_config_byte(to_pci_dev(dev_priv->drm.dev), LBPC, &lbpc); 165 val *= lbpc; 166 } 167 168 return val; 169 } 170 171 static u32 vlv_get_backlight(struct intel_connector *connector, enum pipe pipe) 172 { 173 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 174 175 if (drm_WARN_ON(&dev_priv->drm, pipe != PIPE_A && pipe != PIPE_B)) 176 return 0; 177 178 return intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)) & BACKLIGHT_DUTY_CYCLE_MASK; 179 } 180 181 static u32 bxt_get_backlight(struct intel_connector *connector, enum pipe unused) 182 { 183 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 184 struct intel_panel *panel = &connector->panel; 185 186 return intel_de_read(dev_priv, 187 BXT_BLC_PWM_DUTY(panel->backlight.controller)); 188 } 189 190 static u32 ext_pwm_get_backlight(struct intel_connector *connector, enum pipe unused) 191 { 192 struct intel_panel *panel = &connector->panel; 193 struct pwm_state state; 194 195 pwm_get_state(panel->backlight.pwm, &state); 196 return pwm_get_relative_duty_cycle(&state, 100); 197 } 198 199 static void lpt_set_backlight(const struct drm_connector_state *conn_state, u32 level) 200 { 201 struct intel_connector *connector = to_intel_connector(conn_state->connector); 202 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 203 204 u32 val = intel_de_read(dev_priv, BLC_PWM_PCH_CTL2) & ~BACKLIGHT_DUTY_CYCLE_MASK; 205 intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, val | level); 206 } 207 208 static void pch_set_backlight(const struct drm_connector_state *conn_state, u32 level) 209 { 210 struct intel_connector *connector = to_intel_connector(conn_state->connector); 211 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 212 u32 tmp; 213 214 tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK; 215 intel_de_write(dev_priv, BLC_PWM_CPU_CTL, tmp | level); 216 } 217 218 static void i9xx_set_backlight(const struct drm_connector_state *conn_state, u32 level) 219 { 220 struct intel_connector *connector = to_intel_connector(conn_state->connector); 221 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 222 struct intel_panel *panel = &connector->panel; 223 u32 tmp, mask; 224 225 drm_WARN_ON(&dev_priv->drm, panel->backlight.pwm_level_max == 0); 226 227 if (panel->backlight.combination_mode) { 228 u8 lbpc; 229 230 lbpc = level * 0xfe / panel->backlight.pwm_level_max + 1; 231 level /= lbpc; 232 pci_write_config_byte(to_pci_dev(dev_priv->drm.dev), LBPC, lbpc); 233 } 234 235 if (DISPLAY_VER(dev_priv) == 4) { 236 mask = BACKLIGHT_DUTY_CYCLE_MASK; 237 } else { 238 level <<= 1; 239 mask = BACKLIGHT_DUTY_CYCLE_MASK_PNV; 240 } 241 242 tmp = intel_de_read(dev_priv, BLC_PWM_CTL) & ~mask; 243 intel_de_write(dev_priv, BLC_PWM_CTL, tmp | level); 244 } 245 246 static void vlv_set_backlight(const struct drm_connector_state *conn_state, u32 level) 247 { 248 struct intel_connector *connector = to_intel_connector(conn_state->connector); 249 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 250 enum pipe pipe = to_intel_crtc(conn_state->crtc)->pipe; 251 u32 tmp; 252 253 tmp = intel_de_read(dev_priv, VLV_BLC_PWM_CTL(pipe)) & ~BACKLIGHT_DUTY_CYCLE_MASK; 254 intel_de_write(dev_priv, VLV_BLC_PWM_CTL(pipe), tmp | level); 255 } 256 257 static void bxt_set_backlight(const struct drm_connector_state *conn_state, u32 level) 258 { 259 struct intel_connector *connector = to_intel_connector(conn_state->connector); 260 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 261 struct intel_panel *panel = &connector->panel; 262 263 intel_de_write(dev_priv, 264 BXT_BLC_PWM_DUTY(panel->backlight.controller), level); 265 } 266 267 static void ext_pwm_set_backlight(const struct drm_connector_state *conn_state, u32 level) 268 { 269 struct intel_panel *panel = &to_intel_connector(conn_state->connector)->panel; 270 271 pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100); 272 pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state); 273 } 274 275 static void 276 intel_panel_actually_set_backlight(const struct drm_connector_state *conn_state, u32 level) 277 { 278 struct intel_connector *connector = to_intel_connector(conn_state->connector); 279 struct drm_i915_private *i915 = to_i915(connector->base.dev); 280 struct intel_panel *panel = &connector->panel; 281 282 drm_dbg_kms(&i915->drm, "set backlight level = %d\n", level); 283 284 panel->backlight.funcs->set(conn_state, level); 285 } 286 287 /* set backlight brightness to level in range [0..max], assuming hw min is 288 * respected. 289 */ 290 void intel_backlight_set_acpi(const struct drm_connector_state *conn_state, 291 u32 user_level, u32 user_max) 292 { 293 struct intel_connector *connector = to_intel_connector(conn_state->connector); 294 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 295 struct intel_panel *panel = &connector->panel; 296 u32 hw_level; 297 298 /* 299 * Lack of crtc may occur during driver init because 300 * connection_mutex isn't held across the entire backlight 301 * setup + modeset readout, and the BIOS can issue the 302 * requests at any time. 303 */ 304 if (!panel->backlight.present || !conn_state->crtc) 305 return; 306 307 mutex_lock(&dev_priv->backlight_lock); 308 309 drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0); 310 311 hw_level = clamp_user_to_hw(connector, user_level, user_max); 312 panel->backlight.level = hw_level; 313 314 if (panel->backlight.device) 315 panel->backlight.device->props.brightness = 316 scale_hw_to_user(connector, 317 panel->backlight.level, 318 panel->backlight.device->props.max_brightness); 319 320 if (panel->backlight.enabled) 321 intel_panel_actually_set_backlight(conn_state, hw_level); 322 323 mutex_unlock(&dev_priv->backlight_lock); 324 } 325 326 static void lpt_disable_backlight(const struct drm_connector_state *old_conn_state, u32 level) 327 { 328 struct intel_connector *connector = to_intel_connector(old_conn_state->connector); 329 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 330 u32 tmp; 331 332 intel_backlight_set_pwm_level(old_conn_state, level); 333 334 /* 335 * Although we don't support or enable CPU PWM with LPT/SPT based 336 * systems, it may have been enabled prior to loading the 337 * driver. Disable to avoid warnings on LCPLL disable. 338 * 339 * This needs rework if we need to add support for CPU PWM on PCH split 340 * platforms. 341 */ 342 tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2); 343 if (tmp & BLM_PWM_ENABLE) { 344 drm_dbg_kms(&dev_priv->drm, 345 "cpu backlight was enabled, disabling\n"); 346 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, 347 tmp & ~BLM_PWM_ENABLE); 348 } 349 350 tmp = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1); 351 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE); 352 } 353 354 static void pch_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val) 355 { 356 struct intel_connector *connector = to_intel_connector(old_conn_state->connector); 357 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 358 u32 tmp; 359 360 intel_backlight_set_pwm_level(old_conn_state, val); 361 362 tmp = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2); 363 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, tmp & ~BLM_PWM_ENABLE); 364 365 tmp = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1); 366 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE); 367 } 368 369 static void i9xx_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val) 370 { 371 intel_backlight_set_pwm_level(old_conn_state, val); 372 } 373 374 static void i965_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val) 375 { 376 struct drm_i915_private *dev_priv = to_i915(old_conn_state->connector->dev); 377 u32 tmp; 378 379 intel_backlight_set_pwm_level(old_conn_state, val); 380 381 tmp = intel_de_read(dev_priv, BLC_PWM_CTL2); 382 intel_de_write(dev_priv, BLC_PWM_CTL2, tmp & ~BLM_PWM_ENABLE); 383 } 384 385 static void vlv_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val) 386 { 387 struct intel_connector *connector = to_intel_connector(old_conn_state->connector); 388 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 389 enum pipe pipe = to_intel_crtc(old_conn_state->crtc)->pipe; 390 u32 tmp; 391 392 intel_backlight_set_pwm_level(old_conn_state, val); 393 394 tmp = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe)); 395 intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe), 396 tmp & ~BLM_PWM_ENABLE); 397 } 398 399 static void bxt_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val) 400 { 401 struct intel_connector *connector = to_intel_connector(old_conn_state->connector); 402 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 403 struct intel_panel *panel = &connector->panel; 404 u32 tmp; 405 406 intel_backlight_set_pwm_level(old_conn_state, val); 407 408 tmp = intel_de_read(dev_priv, 409 BXT_BLC_PWM_CTL(panel->backlight.controller)); 410 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller), 411 tmp & ~BXT_BLC_PWM_ENABLE); 412 413 if (panel->backlight.controller == 1) { 414 val = intel_de_read(dev_priv, UTIL_PIN_CTL); 415 val &= ~UTIL_PIN_ENABLE; 416 intel_de_write(dev_priv, UTIL_PIN_CTL, val); 417 } 418 } 419 420 static void cnp_disable_backlight(const struct drm_connector_state *old_conn_state, u32 val) 421 { 422 struct intel_connector *connector = to_intel_connector(old_conn_state->connector); 423 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 424 struct intel_panel *panel = &connector->panel; 425 u32 tmp; 426 427 intel_backlight_set_pwm_level(old_conn_state, val); 428 429 tmp = intel_de_read(dev_priv, 430 BXT_BLC_PWM_CTL(panel->backlight.controller)); 431 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller), 432 tmp & ~BXT_BLC_PWM_ENABLE); 433 } 434 435 static void ext_pwm_disable_backlight(const struct drm_connector_state *old_conn_state, u32 level) 436 { 437 struct intel_connector *connector = to_intel_connector(old_conn_state->connector); 438 struct intel_panel *panel = &connector->panel; 439 440 intel_backlight_set_pwm_level(old_conn_state, level); 441 442 panel->backlight.pwm_state.enabled = false; 443 pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state); 444 } 445 446 void intel_backlight_disable(const struct drm_connector_state *old_conn_state) 447 { 448 struct intel_connector *connector = to_intel_connector(old_conn_state->connector); 449 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 450 struct intel_panel *panel = &connector->panel; 451 452 if (!panel->backlight.present) 453 return; 454 455 /* 456 * Do not disable backlight on the vga_switcheroo path. When switching 457 * away from i915, the other client may depend on i915 to handle the 458 * backlight. This will leave the backlight on unnecessarily when 459 * another client is not activated. 460 */ 461 if (dev_priv->drm.switch_power_state == DRM_SWITCH_POWER_CHANGING) { 462 drm_dbg_kms(&dev_priv->drm, 463 "Skipping backlight disable on vga switch\n"); 464 return; 465 } 466 467 mutex_lock(&dev_priv->backlight_lock); 468 469 if (panel->backlight.device) 470 panel->backlight.device->props.power = FB_BLANK_POWERDOWN; 471 panel->backlight.enabled = false; 472 panel->backlight.funcs->disable(old_conn_state, 0); 473 474 mutex_unlock(&dev_priv->backlight_lock); 475 } 476 477 static void lpt_enable_backlight(const struct intel_crtc_state *crtc_state, 478 const struct drm_connector_state *conn_state, u32 level) 479 { 480 struct intel_connector *connector = to_intel_connector(conn_state->connector); 481 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 482 struct intel_panel *panel = &connector->panel; 483 u32 pch_ctl1, pch_ctl2, schicken; 484 485 pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1); 486 if (pch_ctl1 & BLM_PCH_PWM_ENABLE) { 487 drm_dbg_kms(&dev_priv->drm, "pch backlight already enabled\n"); 488 pch_ctl1 &= ~BLM_PCH_PWM_ENABLE; 489 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1); 490 } 491 492 if (HAS_PCH_LPT(dev_priv)) { 493 schicken = intel_de_read(dev_priv, SOUTH_CHICKEN2); 494 if (panel->backlight.alternate_pwm_increment) 495 schicken |= LPT_PWM_GRANULARITY; 496 else 497 schicken &= ~LPT_PWM_GRANULARITY; 498 intel_de_write(dev_priv, SOUTH_CHICKEN2, schicken); 499 } else { 500 schicken = intel_de_read(dev_priv, SOUTH_CHICKEN1); 501 if (panel->backlight.alternate_pwm_increment) 502 schicken |= SPT_PWM_GRANULARITY; 503 else 504 schicken &= ~SPT_PWM_GRANULARITY; 505 intel_de_write(dev_priv, SOUTH_CHICKEN1, schicken); 506 } 507 508 pch_ctl2 = panel->backlight.pwm_level_max << 16; 509 intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, pch_ctl2); 510 511 pch_ctl1 = 0; 512 if (panel->backlight.active_low_pwm) 513 pch_ctl1 |= BLM_PCH_POLARITY; 514 515 /* After LPT, override is the default. */ 516 if (HAS_PCH_LPT(dev_priv)) 517 pch_ctl1 |= BLM_PCH_OVERRIDE_ENABLE; 518 519 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1); 520 intel_de_posting_read(dev_priv, BLC_PWM_PCH_CTL1); 521 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, 522 pch_ctl1 | BLM_PCH_PWM_ENABLE); 523 524 /* This won't stick until the above enable. */ 525 intel_backlight_set_pwm_level(conn_state, level); 526 } 527 528 static void pch_enable_backlight(const struct intel_crtc_state *crtc_state, 529 const struct drm_connector_state *conn_state, u32 level) 530 { 531 struct intel_connector *connector = to_intel_connector(conn_state->connector); 532 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 533 struct intel_panel *panel = &connector->panel; 534 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder; 535 u32 cpu_ctl2, pch_ctl1, pch_ctl2; 536 537 cpu_ctl2 = intel_de_read(dev_priv, BLC_PWM_CPU_CTL2); 538 if (cpu_ctl2 & BLM_PWM_ENABLE) { 539 drm_dbg_kms(&dev_priv->drm, "cpu backlight already enabled\n"); 540 cpu_ctl2 &= ~BLM_PWM_ENABLE; 541 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2); 542 } 543 544 pch_ctl1 = intel_de_read(dev_priv, BLC_PWM_PCH_CTL1); 545 if (pch_ctl1 & BLM_PCH_PWM_ENABLE) { 546 drm_dbg_kms(&dev_priv->drm, "pch backlight already enabled\n"); 547 pch_ctl1 &= ~BLM_PCH_PWM_ENABLE; 548 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1); 549 } 550 551 if (cpu_transcoder == TRANSCODER_EDP) 552 cpu_ctl2 = BLM_TRANSCODER_EDP; 553 else 554 cpu_ctl2 = BLM_PIPE(cpu_transcoder); 555 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2); 556 intel_de_posting_read(dev_priv, BLC_PWM_CPU_CTL2); 557 intel_de_write(dev_priv, BLC_PWM_CPU_CTL2, cpu_ctl2 | BLM_PWM_ENABLE); 558 559 /* This won't stick until the above enable. */ 560 intel_backlight_set_pwm_level(conn_state, level); 561 562 pch_ctl2 = panel->backlight.pwm_level_max << 16; 563 intel_de_write(dev_priv, BLC_PWM_PCH_CTL2, pch_ctl2); 564 565 pch_ctl1 = 0; 566 if (panel->backlight.active_low_pwm) 567 pch_ctl1 |= BLM_PCH_POLARITY; 568 569 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, pch_ctl1); 570 intel_de_posting_read(dev_priv, BLC_PWM_PCH_CTL1); 571 intel_de_write(dev_priv, BLC_PWM_PCH_CTL1, 572 pch_ctl1 | BLM_PCH_PWM_ENABLE); 573 } 574 575 static void i9xx_enable_backlight(const struct intel_crtc_state *crtc_state, 576 const struct drm_connector_state *conn_state, u32 level) 577 { 578 struct intel_connector *connector = to_intel_connector(conn_state->connector); 579 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 580 struct intel_panel *panel = &connector->panel; 581 u32 ctl, freq; 582 583 ctl = intel_de_read(dev_priv, BLC_PWM_CTL); 584 if (ctl & BACKLIGHT_DUTY_CYCLE_MASK_PNV) { 585 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n"); 586 intel_de_write(dev_priv, BLC_PWM_CTL, 0); 587 } 588 589 freq = panel->backlight.pwm_level_max; 590 if (panel->backlight.combination_mode) 591 freq /= 0xff; 592 593 ctl = freq << 17; 594 if (panel->backlight.combination_mode) 595 ctl |= BLM_LEGACY_MODE; 596 if (IS_PINEVIEW(dev_priv) && panel->backlight.active_low_pwm) 597 ctl |= BLM_POLARITY_PNV; 598 599 intel_de_write(dev_priv, BLC_PWM_CTL, ctl); 600 intel_de_posting_read(dev_priv, BLC_PWM_CTL); 601 602 /* XXX: combine this into above write? */ 603 intel_backlight_set_pwm_level(conn_state, level); 604 605 /* 606 * Needed to enable backlight on some 855gm models. BLC_HIST_CTL is 607 * 855gm only, but checking for gen2 is safe, as 855gm is the only gen2 608 * that has backlight. 609 */ 610 if (DISPLAY_VER(dev_priv) == 2) 611 intel_de_write(dev_priv, BLC_HIST_CTL, BLM_HISTOGRAM_ENABLE); 612 } 613 614 static void i965_enable_backlight(const struct intel_crtc_state *crtc_state, 615 const struct drm_connector_state *conn_state, u32 level) 616 { 617 struct intel_connector *connector = to_intel_connector(conn_state->connector); 618 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 619 struct intel_panel *panel = &connector->panel; 620 enum pipe pipe = to_intel_crtc(conn_state->crtc)->pipe; 621 u32 ctl, ctl2, freq; 622 623 ctl2 = intel_de_read(dev_priv, BLC_PWM_CTL2); 624 if (ctl2 & BLM_PWM_ENABLE) { 625 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n"); 626 ctl2 &= ~BLM_PWM_ENABLE; 627 intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2); 628 } 629 630 freq = panel->backlight.pwm_level_max; 631 if (panel->backlight.combination_mode) 632 freq /= 0xff; 633 634 ctl = freq << 16; 635 intel_de_write(dev_priv, BLC_PWM_CTL, ctl); 636 637 ctl2 = BLM_PIPE(pipe); 638 if (panel->backlight.combination_mode) 639 ctl2 |= BLM_COMBINATION_MODE; 640 if (panel->backlight.active_low_pwm) 641 ctl2 |= BLM_POLARITY_I965; 642 intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2); 643 intel_de_posting_read(dev_priv, BLC_PWM_CTL2); 644 intel_de_write(dev_priv, BLC_PWM_CTL2, ctl2 | BLM_PWM_ENABLE); 645 646 intel_backlight_set_pwm_level(conn_state, level); 647 } 648 649 static void vlv_enable_backlight(const struct intel_crtc_state *crtc_state, 650 const struct drm_connector_state *conn_state, u32 level) 651 { 652 struct intel_connector *connector = to_intel_connector(conn_state->connector); 653 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 654 struct intel_panel *panel = &connector->panel; 655 enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe; 656 u32 ctl, ctl2; 657 658 ctl2 = intel_de_read(dev_priv, VLV_BLC_PWM_CTL2(pipe)); 659 if (ctl2 & BLM_PWM_ENABLE) { 660 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n"); 661 ctl2 &= ~BLM_PWM_ENABLE; 662 intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe), ctl2); 663 } 664 665 ctl = panel->backlight.pwm_level_max << 16; 666 intel_de_write(dev_priv, VLV_BLC_PWM_CTL(pipe), ctl); 667 668 /* XXX: combine this into above write? */ 669 intel_backlight_set_pwm_level(conn_state, level); 670 671 ctl2 = 0; 672 if (panel->backlight.active_low_pwm) 673 ctl2 |= BLM_POLARITY_I965; 674 intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe), ctl2); 675 intel_de_posting_read(dev_priv, VLV_BLC_PWM_CTL2(pipe)); 676 intel_de_write(dev_priv, VLV_BLC_PWM_CTL2(pipe), 677 ctl2 | BLM_PWM_ENABLE); 678 } 679 680 static void bxt_enable_backlight(const struct intel_crtc_state *crtc_state, 681 const struct drm_connector_state *conn_state, u32 level) 682 { 683 struct intel_connector *connector = to_intel_connector(conn_state->connector); 684 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 685 struct intel_panel *panel = &connector->panel; 686 enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe; 687 u32 pwm_ctl, val; 688 689 /* Controller 1 uses the utility pin. */ 690 if (panel->backlight.controller == 1) { 691 val = intel_de_read(dev_priv, UTIL_PIN_CTL); 692 if (val & UTIL_PIN_ENABLE) { 693 drm_dbg_kms(&dev_priv->drm, 694 "util pin already enabled\n"); 695 val &= ~UTIL_PIN_ENABLE; 696 intel_de_write(dev_priv, UTIL_PIN_CTL, val); 697 } 698 699 val = 0; 700 if (panel->backlight.util_pin_active_low) 701 val |= UTIL_PIN_POLARITY; 702 intel_de_write(dev_priv, UTIL_PIN_CTL, 703 val | UTIL_PIN_PIPE(pipe) | UTIL_PIN_MODE_PWM | UTIL_PIN_ENABLE); 704 } 705 706 pwm_ctl = intel_de_read(dev_priv, 707 BXT_BLC_PWM_CTL(panel->backlight.controller)); 708 if (pwm_ctl & BXT_BLC_PWM_ENABLE) { 709 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n"); 710 pwm_ctl &= ~BXT_BLC_PWM_ENABLE; 711 intel_de_write(dev_priv, 712 BXT_BLC_PWM_CTL(panel->backlight.controller), 713 pwm_ctl); 714 } 715 716 intel_de_write(dev_priv, 717 BXT_BLC_PWM_FREQ(panel->backlight.controller), 718 panel->backlight.pwm_level_max); 719 720 intel_backlight_set_pwm_level(conn_state, level); 721 722 pwm_ctl = 0; 723 if (panel->backlight.active_low_pwm) 724 pwm_ctl |= BXT_BLC_PWM_POLARITY; 725 726 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller), 727 pwm_ctl); 728 intel_de_posting_read(dev_priv, 729 BXT_BLC_PWM_CTL(panel->backlight.controller)); 730 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller), 731 pwm_ctl | BXT_BLC_PWM_ENABLE); 732 } 733 734 static void cnp_enable_backlight(const struct intel_crtc_state *crtc_state, 735 const struct drm_connector_state *conn_state, u32 level) 736 { 737 struct intel_connector *connector = to_intel_connector(conn_state->connector); 738 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 739 struct intel_panel *panel = &connector->panel; 740 u32 pwm_ctl; 741 742 pwm_ctl = intel_de_read(dev_priv, 743 BXT_BLC_PWM_CTL(panel->backlight.controller)); 744 if (pwm_ctl & BXT_BLC_PWM_ENABLE) { 745 drm_dbg_kms(&dev_priv->drm, "backlight already enabled\n"); 746 pwm_ctl &= ~BXT_BLC_PWM_ENABLE; 747 intel_de_write(dev_priv, 748 BXT_BLC_PWM_CTL(panel->backlight.controller), 749 pwm_ctl); 750 } 751 752 intel_de_write(dev_priv, 753 BXT_BLC_PWM_FREQ(panel->backlight.controller), 754 panel->backlight.pwm_level_max); 755 756 intel_backlight_set_pwm_level(conn_state, level); 757 758 pwm_ctl = 0; 759 if (panel->backlight.active_low_pwm) 760 pwm_ctl |= BXT_BLC_PWM_POLARITY; 761 762 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller), 763 pwm_ctl); 764 intel_de_posting_read(dev_priv, 765 BXT_BLC_PWM_CTL(panel->backlight.controller)); 766 intel_de_write(dev_priv, BXT_BLC_PWM_CTL(panel->backlight.controller), 767 pwm_ctl | BXT_BLC_PWM_ENABLE); 768 } 769 770 static void ext_pwm_enable_backlight(const struct intel_crtc_state *crtc_state, 771 const struct drm_connector_state *conn_state, u32 level) 772 { 773 struct intel_connector *connector = to_intel_connector(conn_state->connector); 774 struct intel_panel *panel = &connector->panel; 775 776 pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100); 777 panel->backlight.pwm_state.enabled = true; 778 pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state); 779 } 780 781 static void __intel_backlight_enable(const struct intel_crtc_state *crtc_state, 782 const struct drm_connector_state *conn_state) 783 { 784 struct intel_connector *connector = to_intel_connector(conn_state->connector); 785 struct intel_panel *panel = &connector->panel; 786 787 WARN_ON(panel->backlight.max == 0); 788 789 if (panel->backlight.level <= panel->backlight.min) { 790 panel->backlight.level = panel->backlight.max; 791 if (panel->backlight.device) 792 panel->backlight.device->props.brightness = 793 scale_hw_to_user(connector, 794 panel->backlight.level, 795 panel->backlight.device->props.max_brightness); 796 } 797 798 panel->backlight.funcs->enable(crtc_state, conn_state, panel->backlight.level); 799 panel->backlight.enabled = true; 800 if (panel->backlight.device) 801 panel->backlight.device->props.power = FB_BLANK_UNBLANK; 802 } 803 804 void intel_backlight_enable(const struct intel_crtc_state *crtc_state, 805 const struct drm_connector_state *conn_state) 806 { 807 struct intel_connector *connector = to_intel_connector(conn_state->connector); 808 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 809 struct intel_panel *panel = &connector->panel; 810 enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe; 811 812 if (!panel->backlight.present) 813 return; 814 815 drm_dbg_kms(&dev_priv->drm, "pipe %c\n", pipe_name(pipe)); 816 817 mutex_lock(&dev_priv->backlight_lock); 818 819 __intel_backlight_enable(crtc_state, conn_state); 820 821 mutex_unlock(&dev_priv->backlight_lock); 822 } 823 824 #if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE) 825 static u32 intel_panel_get_backlight(struct intel_connector *connector) 826 { 827 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 828 struct intel_panel *panel = &connector->panel; 829 u32 val = 0; 830 831 mutex_lock(&dev_priv->backlight_lock); 832 833 if (panel->backlight.enabled) 834 val = panel->backlight.funcs->get(connector, intel_connector_get_pipe(connector)); 835 836 mutex_unlock(&dev_priv->backlight_lock); 837 838 drm_dbg_kms(&dev_priv->drm, "get backlight PWM = %d\n", val); 839 return val; 840 } 841 842 /* Scale user_level in range [0..user_max] to [hw_min..hw_max]. */ 843 static u32 scale_user_to_hw(struct intel_connector *connector, 844 u32 user_level, u32 user_max) 845 { 846 struct intel_panel *panel = &connector->panel; 847 848 return scale(user_level, 0, user_max, 849 panel->backlight.min, panel->backlight.max); 850 } 851 852 /* set backlight brightness to level in range [0..max], scaling wrt hw min */ 853 static void intel_panel_set_backlight(const struct drm_connector_state *conn_state, 854 u32 user_level, u32 user_max) 855 { 856 struct intel_connector *connector = to_intel_connector(conn_state->connector); 857 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 858 struct intel_panel *panel = &connector->panel; 859 u32 hw_level; 860 861 if (!panel->backlight.present) 862 return; 863 864 mutex_lock(&dev_priv->backlight_lock); 865 866 drm_WARN_ON(&dev_priv->drm, panel->backlight.max == 0); 867 868 hw_level = scale_user_to_hw(connector, user_level, user_max); 869 panel->backlight.level = hw_level; 870 871 if (panel->backlight.enabled) 872 intel_panel_actually_set_backlight(conn_state, hw_level); 873 874 mutex_unlock(&dev_priv->backlight_lock); 875 } 876 877 static int intel_backlight_device_update_status(struct backlight_device *bd) 878 { 879 struct intel_connector *connector = bl_get_data(bd); 880 struct intel_panel *panel = &connector->panel; 881 struct drm_device *dev = connector->base.dev; 882 883 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 884 DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n", 885 bd->props.brightness, bd->props.max_brightness); 886 intel_panel_set_backlight(connector->base.state, bd->props.brightness, 887 bd->props.max_brightness); 888 889 /* 890 * Allow flipping bl_power as a sub-state of enabled. Sadly the 891 * backlight class device does not make it easy to differentiate 892 * between callbacks for brightness and bl_power, so our backlight_power 893 * callback needs to take this into account. 894 */ 895 if (panel->backlight.enabled) { 896 if (panel->backlight.power) { 897 bool enable = bd->props.power == FB_BLANK_UNBLANK && 898 bd->props.brightness != 0; 899 panel->backlight.power(connector, enable); 900 } 901 } else { 902 bd->props.power = FB_BLANK_POWERDOWN; 903 } 904 905 drm_modeset_unlock(&dev->mode_config.connection_mutex); 906 return 0; 907 } 908 909 static int intel_backlight_device_get_brightness(struct backlight_device *bd) 910 { 911 struct intel_connector *connector = bl_get_data(bd); 912 struct drm_device *dev = connector->base.dev; 913 struct drm_i915_private *dev_priv = to_i915(dev); 914 intel_wakeref_t wakeref; 915 int ret = 0; 916 917 with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref) { 918 u32 hw_level; 919 920 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 921 922 hw_level = intel_panel_get_backlight(connector); 923 ret = scale_hw_to_user(connector, 924 hw_level, bd->props.max_brightness); 925 926 drm_modeset_unlock(&dev->mode_config.connection_mutex); 927 } 928 929 return ret; 930 } 931 932 static const struct backlight_ops intel_backlight_device_ops = { 933 .update_status = intel_backlight_device_update_status, 934 .get_brightness = intel_backlight_device_get_brightness, 935 }; 936 937 int intel_backlight_device_register(struct intel_connector *connector) 938 { 939 struct drm_i915_private *i915 = to_i915(connector->base.dev); 940 struct intel_panel *panel = &connector->panel; 941 struct backlight_properties props; 942 struct backlight_device *bd; 943 const char *name; 944 int ret = 0; 945 946 if (WARN_ON(panel->backlight.device)) 947 return -ENODEV; 948 949 if (!panel->backlight.present) 950 return 0; 951 952 WARN_ON(panel->backlight.max == 0); 953 954 memset(&props, 0, sizeof(props)); 955 props.type = BACKLIGHT_RAW; 956 957 /* 958 * Note: Everything should work even if the backlight device max 959 * presented to the userspace is arbitrarily chosen. 960 */ 961 props.max_brightness = panel->backlight.max; 962 props.brightness = scale_hw_to_user(connector, 963 panel->backlight.level, 964 props.max_brightness); 965 966 if (panel->backlight.enabled) 967 props.power = FB_BLANK_UNBLANK; 968 else 969 props.power = FB_BLANK_POWERDOWN; 970 971 name = kstrdup("intel_backlight", GFP_KERNEL); 972 if (!name) 973 return -ENOMEM; 974 975 bd = backlight_device_get_by_name(name); 976 if (bd) { 977 put_device(&bd->dev); 978 /* 979 * Using the same name independent of the drm device or connector 980 * prevents registration of multiple backlight devices in the 981 * driver. However, we need to use the default name for backward 982 * compatibility. Use unique names for subsequent backlight devices as a 983 * fallback when the default name already exists. 984 */ 985 kfree(name); 986 name = kasprintf(GFP_KERNEL, "card%d-%s-backlight", 987 i915->drm.primary->index, connector->base.name); 988 if (!name) 989 return -ENOMEM; 990 } 991 bd = backlight_device_register(name, connector->base.kdev, connector, 992 &intel_backlight_device_ops, &props); 993 994 if (IS_ERR(bd)) { 995 drm_err(&i915->drm, 996 "[CONNECTOR:%d:%s] backlight device %s register failed: %ld\n", 997 connector->base.base.id, connector->base.name, name, PTR_ERR(bd)); 998 ret = PTR_ERR(bd); 999 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 } 1786