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