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