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