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