1 /* 2 * Copyright © 2006-2010 Intel Corporation 3 * Copyright (c) 2006 Dave Airlie <airlied@linux.ie> 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 * 24 * Authors: 25 * Eric Anholt <eric@anholt.net> 26 * Dave Airlie <airlied@linux.ie> 27 * Jesse Barnes <jesse.barnes@intel.com> 28 * Chris Wilson <chris@chris-wilson.co.uk> 29 */ 30 31 #include <linux/kernel.h> 32 #include <linux/moduleparam.h> 33 #include "intel_drv.h" 34 35 void 36 intel_fixed_panel_mode(const struct drm_display_mode *fixed_mode, 37 struct drm_display_mode *adjusted_mode) 38 { 39 drm_mode_copy(adjusted_mode, fixed_mode); 40 41 drm_mode_set_crtcinfo(adjusted_mode, 0); 42 } 43 44 /** 45 * intel_find_panel_downclock - find the reduced downclock for LVDS in EDID 46 * @dev: drm device 47 * @fixed_mode : panel native mode 48 * @connector: LVDS/eDP connector 49 * 50 * Return downclock_avail 51 * Find the reduced downclock for LVDS/eDP in EDID. 52 */ 53 struct drm_display_mode * 54 intel_find_panel_downclock(struct drm_device *dev, 55 struct drm_display_mode *fixed_mode, 56 struct drm_connector *connector) 57 { 58 struct drm_display_mode *scan, *tmp_mode; 59 int temp_downclock; 60 61 temp_downclock = fixed_mode->clock; 62 tmp_mode = NULL; 63 64 list_for_each_entry(scan, &connector->probed_modes, head) { 65 /* 66 * If one mode has the same resolution with the fixed_panel 67 * mode while they have the different refresh rate, it means 68 * that the reduced downclock is found. In such 69 * case we can set the different FPx0/1 to dynamically select 70 * between low and high frequency. 71 */ 72 if (scan->hdisplay == fixed_mode->hdisplay && 73 scan->hsync_start == fixed_mode->hsync_start && 74 scan->hsync_end == fixed_mode->hsync_end && 75 scan->htotal == fixed_mode->htotal && 76 scan->vdisplay == fixed_mode->vdisplay && 77 scan->vsync_start == fixed_mode->vsync_start && 78 scan->vsync_end == fixed_mode->vsync_end && 79 scan->vtotal == fixed_mode->vtotal) { 80 if (scan->clock < temp_downclock) { 81 /* 82 * The downclock is already found. But we 83 * expect to find the lower downclock. 84 */ 85 temp_downclock = scan->clock; 86 tmp_mode = scan; 87 } 88 } 89 } 90 91 if (temp_downclock < fixed_mode->clock) 92 return drm_mode_duplicate(dev, tmp_mode); 93 else 94 return NULL; 95 } 96 97 /* adjusted_mode has been preset to be the panel's fixed mode */ 98 void 99 intel_pch_panel_fitting(struct intel_crtc *intel_crtc, 100 struct intel_crtc_state *pipe_config, 101 int fitting_mode) 102 { 103 struct drm_display_mode *adjusted_mode; 104 int x, y, width, height; 105 106 adjusted_mode = &pipe_config->base.adjusted_mode; 107 108 x = y = width = height = 0; 109 110 /* Native modes don't need fitting */ 111 if (adjusted_mode->hdisplay == pipe_config->pipe_src_w && 112 adjusted_mode->vdisplay == pipe_config->pipe_src_h) 113 goto done; 114 115 switch (fitting_mode) { 116 case DRM_MODE_SCALE_CENTER: 117 width = pipe_config->pipe_src_w; 118 height = pipe_config->pipe_src_h; 119 x = (adjusted_mode->hdisplay - width + 1)/2; 120 y = (adjusted_mode->vdisplay - height + 1)/2; 121 break; 122 123 case DRM_MODE_SCALE_ASPECT: 124 /* Scale but preserve the aspect ratio */ 125 { 126 u32 scaled_width = adjusted_mode->hdisplay 127 * pipe_config->pipe_src_h; 128 u32 scaled_height = pipe_config->pipe_src_w 129 * adjusted_mode->vdisplay; 130 if (scaled_width > scaled_height) { /* pillar */ 131 width = scaled_height / pipe_config->pipe_src_h; 132 if (width & 1) 133 width++; 134 x = (adjusted_mode->hdisplay - width + 1) / 2; 135 y = 0; 136 height = adjusted_mode->vdisplay; 137 } else if (scaled_width < scaled_height) { /* letter */ 138 height = scaled_width / pipe_config->pipe_src_w; 139 if (height & 1) 140 height++; 141 y = (adjusted_mode->vdisplay - height + 1) / 2; 142 x = 0; 143 width = adjusted_mode->hdisplay; 144 } else { 145 x = y = 0; 146 width = adjusted_mode->hdisplay; 147 height = adjusted_mode->vdisplay; 148 } 149 } 150 break; 151 152 case DRM_MODE_SCALE_FULLSCREEN: 153 x = y = 0; 154 width = adjusted_mode->hdisplay; 155 height = adjusted_mode->vdisplay; 156 break; 157 158 default: 159 WARN(1, "bad panel fit mode: %d\n", fitting_mode); 160 return; 161 } 162 163 done: 164 pipe_config->pch_pfit.pos = (x << 16) | y; 165 pipe_config->pch_pfit.size = (width << 16) | height; 166 pipe_config->pch_pfit.enabled = pipe_config->pch_pfit.size != 0; 167 } 168 169 static void 170 centre_horizontally(struct drm_display_mode *mode, 171 int width) 172 { 173 u32 border, sync_pos, blank_width, sync_width; 174 175 /* keep the hsync and hblank widths constant */ 176 sync_width = mode->crtc_hsync_end - mode->crtc_hsync_start; 177 blank_width = mode->crtc_hblank_end - mode->crtc_hblank_start; 178 sync_pos = (blank_width - sync_width + 1) / 2; 179 180 border = (mode->hdisplay - width + 1) / 2; 181 border += border & 1; /* make the border even */ 182 183 mode->crtc_hdisplay = width; 184 mode->crtc_hblank_start = width + border; 185 mode->crtc_hblank_end = mode->crtc_hblank_start + blank_width; 186 187 mode->crtc_hsync_start = mode->crtc_hblank_start + sync_pos; 188 mode->crtc_hsync_end = mode->crtc_hsync_start + sync_width; 189 } 190 191 static void 192 centre_vertically(struct drm_display_mode *mode, 193 int height) 194 { 195 u32 border, sync_pos, blank_width, sync_width; 196 197 /* keep the vsync and vblank widths constant */ 198 sync_width = mode->crtc_vsync_end - mode->crtc_vsync_start; 199 blank_width = mode->crtc_vblank_end - mode->crtc_vblank_start; 200 sync_pos = (blank_width - sync_width + 1) / 2; 201 202 border = (mode->vdisplay - height + 1) / 2; 203 204 mode->crtc_vdisplay = height; 205 mode->crtc_vblank_start = height + border; 206 mode->crtc_vblank_end = mode->crtc_vblank_start + blank_width; 207 208 mode->crtc_vsync_start = mode->crtc_vblank_start + sync_pos; 209 mode->crtc_vsync_end = mode->crtc_vsync_start + sync_width; 210 } 211 212 static inline u32 panel_fitter_scaling(u32 source, u32 target) 213 { 214 /* 215 * Floating point operation is not supported. So the FACTOR 216 * is defined, which can avoid the floating point computation 217 * when calculating the panel ratio. 218 */ 219 #define ACCURACY 12 220 #define FACTOR (1 << ACCURACY) 221 u32 ratio = source * FACTOR / target; 222 return (FACTOR * ratio + FACTOR/2) / FACTOR; 223 } 224 225 static void i965_scale_aspect(struct intel_crtc_state *pipe_config, 226 u32 *pfit_control) 227 { 228 struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode; 229 u32 scaled_width = adjusted_mode->hdisplay * 230 pipe_config->pipe_src_h; 231 u32 scaled_height = pipe_config->pipe_src_w * 232 adjusted_mode->vdisplay; 233 234 /* 965+ is easy, it does everything in hw */ 235 if (scaled_width > scaled_height) 236 *pfit_control |= PFIT_ENABLE | 237 PFIT_SCALING_PILLAR; 238 else if (scaled_width < scaled_height) 239 *pfit_control |= PFIT_ENABLE | 240 PFIT_SCALING_LETTER; 241 else if (adjusted_mode->hdisplay != pipe_config->pipe_src_w) 242 *pfit_control |= PFIT_ENABLE | PFIT_SCALING_AUTO; 243 } 244 245 static void i9xx_scale_aspect(struct intel_crtc_state *pipe_config, 246 u32 *pfit_control, u32 *pfit_pgm_ratios, 247 u32 *border) 248 { 249 struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode; 250 u32 scaled_width = adjusted_mode->hdisplay * 251 pipe_config->pipe_src_h; 252 u32 scaled_height = pipe_config->pipe_src_w * 253 adjusted_mode->vdisplay; 254 u32 bits; 255 256 /* 257 * For earlier chips we have to calculate the scaling 258 * ratio by hand and program it into the 259 * PFIT_PGM_RATIO register 260 */ 261 if (scaled_width > scaled_height) { /* pillar */ 262 centre_horizontally(adjusted_mode, 263 scaled_height / 264 pipe_config->pipe_src_h); 265 266 *border = LVDS_BORDER_ENABLE; 267 if (pipe_config->pipe_src_h != adjusted_mode->vdisplay) { 268 bits = panel_fitter_scaling(pipe_config->pipe_src_h, 269 adjusted_mode->vdisplay); 270 271 *pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT | 272 bits << PFIT_VERT_SCALE_SHIFT); 273 *pfit_control |= (PFIT_ENABLE | 274 VERT_INTERP_BILINEAR | 275 HORIZ_INTERP_BILINEAR); 276 } 277 } else if (scaled_width < scaled_height) { /* letter */ 278 centre_vertically(adjusted_mode, 279 scaled_width / 280 pipe_config->pipe_src_w); 281 282 *border = LVDS_BORDER_ENABLE; 283 if (pipe_config->pipe_src_w != adjusted_mode->hdisplay) { 284 bits = panel_fitter_scaling(pipe_config->pipe_src_w, 285 adjusted_mode->hdisplay); 286 287 *pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT | 288 bits << PFIT_VERT_SCALE_SHIFT); 289 *pfit_control |= (PFIT_ENABLE | 290 VERT_INTERP_BILINEAR | 291 HORIZ_INTERP_BILINEAR); 292 } 293 } else { 294 /* Aspects match, Let hw scale both directions */ 295 *pfit_control |= (PFIT_ENABLE | 296 VERT_AUTO_SCALE | HORIZ_AUTO_SCALE | 297 VERT_INTERP_BILINEAR | 298 HORIZ_INTERP_BILINEAR); 299 } 300 } 301 302 void intel_gmch_panel_fitting(struct intel_crtc *intel_crtc, 303 struct intel_crtc_state *pipe_config, 304 int fitting_mode) 305 { 306 struct drm_device *dev = intel_crtc->base.dev; 307 u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0; 308 struct drm_display_mode *adjusted_mode; 309 310 adjusted_mode = &pipe_config->base.adjusted_mode; 311 312 /* Native modes don't need fitting */ 313 if (adjusted_mode->hdisplay == pipe_config->pipe_src_w && 314 adjusted_mode->vdisplay == pipe_config->pipe_src_h) 315 goto out; 316 317 switch (fitting_mode) { 318 case DRM_MODE_SCALE_CENTER: 319 /* 320 * For centered modes, we have to calculate border widths & 321 * heights and modify the values programmed into the CRTC. 322 */ 323 centre_horizontally(adjusted_mode, pipe_config->pipe_src_w); 324 centre_vertically(adjusted_mode, pipe_config->pipe_src_h); 325 border = LVDS_BORDER_ENABLE; 326 break; 327 case DRM_MODE_SCALE_ASPECT: 328 /* Scale but preserve the aspect ratio */ 329 if (INTEL_INFO(dev)->gen >= 4) 330 i965_scale_aspect(pipe_config, &pfit_control); 331 else 332 i9xx_scale_aspect(pipe_config, &pfit_control, 333 &pfit_pgm_ratios, &border); 334 break; 335 case DRM_MODE_SCALE_FULLSCREEN: 336 /* 337 * Full scaling, even if it changes the aspect ratio. 338 * Fortunately this is all done for us in hw. 339 */ 340 if (pipe_config->pipe_src_h != adjusted_mode->vdisplay || 341 pipe_config->pipe_src_w != adjusted_mode->hdisplay) { 342 pfit_control |= PFIT_ENABLE; 343 if (INTEL_INFO(dev)->gen >= 4) 344 pfit_control |= PFIT_SCALING_AUTO; 345 else 346 pfit_control |= (VERT_AUTO_SCALE | 347 VERT_INTERP_BILINEAR | 348 HORIZ_AUTO_SCALE | 349 HORIZ_INTERP_BILINEAR); 350 } 351 break; 352 default: 353 WARN(1, "bad panel fit mode: %d\n", fitting_mode); 354 return; 355 } 356 357 /* 965+ wants fuzzy fitting */ 358 /* FIXME: handle multiple panels by failing gracefully */ 359 if (INTEL_INFO(dev)->gen >= 4) 360 pfit_control |= ((intel_crtc->pipe << PFIT_PIPE_SHIFT) | 361 PFIT_FILTER_FUZZY); 362 363 out: 364 if ((pfit_control & PFIT_ENABLE) == 0) { 365 pfit_control = 0; 366 pfit_pgm_ratios = 0; 367 } 368 369 /* Make sure pre-965 set dither correctly for 18bpp panels. */ 370 if (INTEL_INFO(dev)->gen < 4 && pipe_config->pipe_bpp == 18) 371 pfit_control |= PANEL_8TO6_DITHER_ENABLE; 372 373 pipe_config->gmch_pfit.control = pfit_control; 374 pipe_config->gmch_pfit.pgm_ratios = pfit_pgm_ratios; 375 pipe_config->gmch_pfit.lvds_border_bits = border; 376 } 377 378 enum drm_connector_status 379 intel_panel_detect(struct drm_device *dev) 380 { 381 struct drm_i915_private *dev_priv = dev->dev_private; 382 383 /* Assume that the BIOS does not lie through the OpRegion... */ 384 if (!i915.panel_ignore_lid && dev_priv->opregion.lid_state) { 385 return ioread32(dev_priv->opregion.lid_state) & 0x1 ? 386 connector_status_connected : 387 connector_status_disconnected; 388 } 389 390 switch (i915.panel_ignore_lid) { 391 case -2: 392 return connector_status_connected; 393 case -1: 394 return connector_status_disconnected; 395 default: 396 return connector_status_unknown; 397 } 398 } 399 400 /** 401 * scale - scale values from one range to another 402 * 403 * @source_val: value in range [@source_min..@source_max] 404 * 405 * Return @source_val in range [@source_min..@source_max] scaled to range 406 * [@target_min..@target_max]. 407 */ 408 static uint32_t scale(uint32_t source_val, 409 uint32_t source_min, uint32_t source_max, 410 uint32_t target_min, uint32_t target_max) 411 { 412 uint64_t target_val; 413 414 WARN_ON(source_min > source_max); 415 WARN_ON(target_min > target_max); 416 417 /* defensive */ 418 source_val = clamp(source_val, source_min, source_max); 419 420 /* avoid overflows */ 421 target_val = DIV_ROUND_CLOSEST_ULL((uint64_t)(source_val - source_min) * 422 (target_max - target_min), source_max - source_min); 423 target_val += target_min; 424 425 return target_val; 426 } 427 428 /* Scale user_level in range [0..user_max] to [hw_min..hw_max]. */ 429 static inline u32 scale_user_to_hw(struct intel_connector *connector, 430 u32 user_level, u32 user_max) 431 { 432 struct intel_panel *panel = &connector->panel; 433 434 return scale(user_level, 0, user_max, 435 panel->backlight.min, panel->backlight.max); 436 } 437 438 /* Scale user_level in range [0..user_max] to [0..hw_max], clamping the result 439 * to [hw_min..hw_max]. */ 440 static inline u32 clamp_user_to_hw(struct intel_connector *connector, 441 u32 user_level, u32 user_max) 442 { 443 struct intel_panel *panel = &connector->panel; 444 u32 hw_level; 445 446 hw_level = scale(user_level, 0, user_max, 0, panel->backlight.max); 447 hw_level = clamp(hw_level, panel->backlight.min, panel->backlight.max); 448 449 return hw_level; 450 } 451 452 /* Scale hw_level in range [hw_min..hw_max] to [0..user_max]. */ 453 static inline u32 scale_hw_to_user(struct intel_connector *connector, 454 u32 hw_level, u32 user_max) 455 { 456 struct intel_panel *panel = &connector->panel; 457 458 return scale(hw_level, panel->backlight.min, panel->backlight.max, 459 0, user_max); 460 } 461 462 static u32 intel_panel_compute_brightness(struct intel_connector *connector, 463 u32 val) 464 { 465 struct drm_device *dev = connector->base.dev; 466 struct drm_i915_private *dev_priv = dev->dev_private; 467 struct intel_panel *panel = &connector->panel; 468 469 WARN_ON(panel->backlight.max == 0); 470 471 if (i915.invert_brightness < 0) 472 return val; 473 474 if (i915.invert_brightness > 0 || 475 dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS) { 476 return panel->backlight.max - val; 477 } 478 479 return val; 480 } 481 482 static u32 bdw_get_backlight(struct intel_connector *connector) 483 { 484 struct drm_device *dev = connector->base.dev; 485 struct drm_i915_private *dev_priv = dev->dev_private; 486 487 return I915_READ(BLC_PWM_PCH_CTL2) & BACKLIGHT_DUTY_CYCLE_MASK; 488 } 489 490 static u32 pch_get_backlight(struct intel_connector *connector) 491 { 492 struct drm_device *dev = connector->base.dev; 493 struct drm_i915_private *dev_priv = dev->dev_private; 494 495 return I915_READ(BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK; 496 } 497 498 static u32 i9xx_get_backlight(struct intel_connector *connector) 499 { 500 struct drm_device *dev = connector->base.dev; 501 struct drm_i915_private *dev_priv = dev->dev_private; 502 struct intel_panel *panel = &connector->panel; 503 u32 val; 504 505 val = I915_READ(BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK; 506 if (INTEL_INFO(dev)->gen < 4) 507 val >>= 1; 508 509 if (panel->backlight.combination_mode) { 510 u8 lbpc; 511 512 pci_read_config_byte(dev->pdev, PCI_LBPC, &lbpc); 513 val *= lbpc; 514 } 515 516 return val; 517 } 518 519 static u32 _vlv_get_backlight(struct drm_device *dev, enum i915_pipe pipe) 520 { 521 struct drm_i915_private *dev_priv = dev->dev_private; 522 523 if (WARN_ON(pipe != PIPE_A && pipe != PIPE_B)) 524 return 0; 525 526 return I915_READ(VLV_BLC_PWM_CTL(pipe)) & BACKLIGHT_DUTY_CYCLE_MASK; 527 } 528 529 static u32 vlv_get_backlight(struct intel_connector *connector) 530 { 531 struct drm_device *dev = connector->base.dev; 532 enum i915_pipe pipe = intel_get_pipe_from_connector(connector); 533 534 return _vlv_get_backlight(dev, pipe); 535 } 536 537 static u32 bxt_get_backlight(struct intel_connector *connector) 538 { 539 struct drm_device *dev = connector->base.dev; 540 struct drm_i915_private *dev_priv = dev->dev_private; 541 542 return I915_READ(BXT_BLC_PWM_DUTY1); 543 } 544 545 #if 0 546 static u32 intel_panel_get_backlight(struct intel_connector *connector) 547 { 548 struct drm_device *dev = connector->base.dev; 549 struct drm_i915_private *dev_priv = dev->dev_private; 550 struct intel_panel *panel = &connector->panel; 551 u32 val = 0; 552 553 mutex_lock(&dev_priv->backlight_lock); 554 555 if (panel->backlight.enabled) { 556 val = dev_priv->display.get_backlight(connector); 557 val = intel_panel_compute_brightness(connector, val); 558 } 559 560 mutex_unlock(&dev_priv->backlight_lock); 561 562 DRM_DEBUG_DRIVER("get backlight PWM = %d\n", val); 563 return val; 564 } 565 #endif 566 567 static void bdw_set_backlight(struct intel_connector *connector, u32 level) 568 { 569 struct drm_device *dev = connector->base.dev; 570 struct drm_i915_private *dev_priv = dev->dev_private; 571 u32 val = I915_READ(BLC_PWM_PCH_CTL2) & ~BACKLIGHT_DUTY_CYCLE_MASK; 572 I915_WRITE(BLC_PWM_PCH_CTL2, val | level); 573 } 574 575 static void pch_set_backlight(struct intel_connector *connector, u32 level) 576 { 577 struct drm_device *dev = connector->base.dev; 578 struct drm_i915_private *dev_priv = dev->dev_private; 579 u32 tmp; 580 581 tmp = I915_READ(BLC_PWM_CPU_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK; 582 I915_WRITE(BLC_PWM_CPU_CTL, tmp | level); 583 } 584 585 static void i9xx_set_backlight(struct intel_connector *connector, u32 level) 586 { 587 struct drm_device *dev = connector->base.dev; 588 struct drm_i915_private *dev_priv = dev->dev_private; 589 struct intel_panel *panel = &connector->panel; 590 u32 tmp, mask; 591 592 WARN_ON(panel->backlight.max == 0); 593 594 if (panel->backlight.combination_mode) { 595 u8 lbpc; 596 597 lbpc = level * 0xfe / panel->backlight.max + 1; 598 level /= lbpc; 599 pci_write_config_byte(dev->pdev, PCI_LBPC, lbpc); 600 } 601 602 if (IS_GEN4(dev)) { 603 mask = BACKLIGHT_DUTY_CYCLE_MASK; 604 } else { 605 level <<= 1; 606 mask = BACKLIGHT_DUTY_CYCLE_MASK_PNV; 607 } 608 609 tmp = I915_READ(BLC_PWM_CTL) & ~mask; 610 I915_WRITE(BLC_PWM_CTL, tmp | level); 611 } 612 613 static void vlv_set_backlight(struct intel_connector *connector, u32 level) 614 { 615 struct drm_device *dev = connector->base.dev; 616 struct drm_i915_private *dev_priv = dev->dev_private; 617 enum i915_pipe pipe = intel_get_pipe_from_connector(connector); 618 u32 tmp; 619 620 if (WARN_ON(pipe != PIPE_A && pipe != PIPE_B)) 621 return; 622 623 tmp = I915_READ(VLV_BLC_PWM_CTL(pipe)) & ~BACKLIGHT_DUTY_CYCLE_MASK; 624 I915_WRITE(VLV_BLC_PWM_CTL(pipe), tmp | level); 625 } 626 627 static void bxt_set_backlight(struct intel_connector *connector, u32 level) 628 { 629 struct drm_device *dev = connector->base.dev; 630 struct drm_i915_private *dev_priv = dev->dev_private; 631 632 I915_WRITE(BXT_BLC_PWM_DUTY1, level); 633 } 634 635 static void 636 intel_panel_actually_set_backlight(struct intel_connector *connector, u32 level) 637 { 638 struct drm_device *dev = connector->base.dev; 639 struct drm_i915_private *dev_priv = dev->dev_private; 640 641 DRM_DEBUG_DRIVER("set backlight PWM = %d\n", level); 642 643 level = intel_panel_compute_brightness(connector, level); 644 dev_priv->display.set_backlight(connector, level); 645 } 646 647 /* set backlight brightness to level in range [0..max], scaling wrt hw min */ 648 static void intel_panel_set_backlight(struct intel_connector *connector, 649 u32 user_level, u32 user_max) 650 { 651 struct drm_device *dev = connector->base.dev; 652 struct drm_i915_private *dev_priv = dev->dev_private; 653 struct intel_panel *panel = &connector->panel; 654 u32 hw_level; 655 656 if (!panel->backlight.present) 657 return; 658 659 mutex_lock(&dev_priv->backlight_lock); 660 661 WARN_ON(panel->backlight.max == 0); 662 663 hw_level = scale_user_to_hw(connector, user_level, user_max); 664 panel->backlight.level = hw_level; 665 666 if (panel->backlight.enabled) 667 intel_panel_actually_set_backlight(connector, hw_level); 668 669 mutex_unlock(&dev_priv->backlight_lock); 670 } 671 672 /* set backlight brightness to level in range [0..max], assuming hw min is 673 * respected. 674 */ 675 void intel_panel_set_backlight_acpi(struct intel_connector *connector, 676 u32 user_level, u32 user_max) 677 { 678 struct drm_device *dev = connector->base.dev; 679 struct drm_i915_private *dev_priv = dev->dev_private; 680 struct intel_panel *panel = &connector->panel; 681 enum i915_pipe pipe = intel_get_pipe_from_connector(connector); 682 u32 hw_level; 683 684 /* 685 * INVALID_PIPE may occur during driver init because 686 * connection_mutex isn't held across the entire backlight 687 * setup + modeset readout, and the BIOS can issue the 688 * requests at any time. 689 */ 690 if (!panel->backlight.present || pipe == INVALID_PIPE) 691 return; 692 693 mutex_lock(&dev_priv->backlight_lock); 694 695 WARN_ON(panel->backlight.max == 0); 696 697 hw_level = clamp_user_to_hw(connector, user_level, user_max); 698 panel->backlight.level = hw_level; 699 700 if (panel->backlight.device) 701 panel->backlight.device->props.brightness = 702 scale_hw_to_user(connector, 703 panel->backlight.level, 704 panel->backlight.device->props.max_brightness); 705 706 if (panel->backlight.enabled) 707 intel_panel_actually_set_backlight(connector, hw_level); 708 709 mutex_unlock(&dev_priv->backlight_lock); 710 } 711 712 static void pch_disable_backlight(struct intel_connector *connector) 713 { 714 struct drm_device *dev = connector->base.dev; 715 struct drm_i915_private *dev_priv = dev->dev_private; 716 u32 tmp; 717 718 intel_panel_actually_set_backlight(connector, 0); 719 720 tmp = I915_READ(BLC_PWM_CPU_CTL2); 721 I915_WRITE(BLC_PWM_CPU_CTL2, tmp & ~BLM_PWM_ENABLE); 722 723 tmp = I915_READ(BLC_PWM_PCH_CTL1); 724 I915_WRITE(BLC_PWM_PCH_CTL1, tmp & ~BLM_PCH_PWM_ENABLE); 725 } 726 727 static void i9xx_disable_backlight(struct intel_connector *connector) 728 { 729 intel_panel_actually_set_backlight(connector, 0); 730 } 731 732 static void i965_disable_backlight(struct intel_connector *connector) 733 { 734 struct drm_device *dev = connector->base.dev; 735 struct drm_i915_private *dev_priv = dev->dev_private; 736 u32 tmp; 737 738 intel_panel_actually_set_backlight(connector, 0); 739 740 tmp = I915_READ(BLC_PWM_CTL2); 741 I915_WRITE(BLC_PWM_CTL2, tmp & ~BLM_PWM_ENABLE); 742 } 743 744 static void vlv_disable_backlight(struct intel_connector *connector) 745 { 746 struct drm_device *dev = connector->base.dev; 747 struct drm_i915_private *dev_priv = dev->dev_private; 748 enum i915_pipe pipe = intel_get_pipe_from_connector(connector); 749 u32 tmp; 750 751 if (WARN_ON(pipe != PIPE_A && pipe != PIPE_B)) 752 return; 753 754 intel_panel_actually_set_backlight(connector, 0); 755 756 tmp = I915_READ(VLV_BLC_PWM_CTL2(pipe)); 757 I915_WRITE(VLV_BLC_PWM_CTL2(pipe), tmp & ~BLM_PWM_ENABLE); 758 } 759 760 static void bxt_disable_backlight(struct intel_connector *connector) 761 { 762 struct drm_device *dev = connector->base.dev; 763 struct drm_i915_private *dev_priv = dev->dev_private; 764 u32 tmp; 765 766 intel_panel_actually_set_backlight(connector, 0); 767 768 tmp = I915_READ(BXT_BLC_PWM_CTL1); 769 I915_WRITE(BXT_BLC_PWM_CTL1, tmp & ~BXT_BLC_PWM_ENABLE); 770 } 771 772 void intel_panel_disable_backlight(struct intel_connector *connector) 773 { 774 struct drm_device *dev = connector->base.dev; 775 struct drm_i915_private *dev_priv = dev->dev_private; 776 struct intel_panel *panel = &connector->panel; 777 778 if (!panel->backlight.present) 779 return; 780 781 /* 782 * Do not disable backlight on the vgaswitcheroo path. When switching 783 * away from i915, the other client may depend on i915 to handle the 784 * backlight. This will leave the backlight on unnecessarily when 785 * another client is not activated. 786 */ 787 if (dev->switch_power_state == DRM_SWITCH_POWER_CHANGING) { 788 DRM_DEBUG_DRIVER("Skipping backlight disable on vga switch\n"); 789 return; 790 } 791 792 mutex_lock(&dev_priv->backlight_lock); 793 794 if (panel->backlight.device) 795 panel->backlight.device->props.power = FB_BLANK_POWERDOWN; 796 panel->backlight.enabled = false; 797 dev_priv->display.disable_backlight(connector); 798 799 mutex_unlock(&dev_priv->backlight_lock); 800 } 801 802 static void bdw_enable_backlight(struct intel_connector *connector) 803 { 804 struct drm_device *dev = connector->base.dev; 805 struct drm_i915_private *dev_priv = dev->dev_private; 806 struct intel_panel *panel = &connector->panel; 807 u32 pch_ctl1, pch_ctl2; 808 809 pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1); 810 if (pch_ctl1 & BLM_PCH_PWM_ENABLE) { 811 DRM_DEBUG_KMS("pch backlight already enabled\n"); 812 pch_ctl1 &= ~BLM_PCH_PWM_ENABLE; 813 I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1); 814 } 815 816 pch_ctl2 = panel->backlight.max << 16; 817 I915_WRITE(BLC_PWM_PCH_CTL2, pch_ctl2); 818 819 pch_ctl1 = 0; 820 if (panel->backlight.active_low_pwm) 821 pch_ctl1 |= BLM_PCH_POLARITY; 822 823 /* After LPT, override is the default. */ 824 if (HAS_PCH_LPT(dev_priv)) 825 pch_ctl1 |= BLM_PCH_OVERRIDE_ENABLE; 826 827 I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1); 828 POSTING_READ(BLC_PWM_PCH_CTL1); 829 I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1 | BLM_PCH_PWM_ENABLE); 830 831 /* This won't stick until the above enable. */ 832 intel_panel_actually_set_backlight(connector, panel->backlight.level); 833 } 834 835 static void pch_enable_backlight(struct intel_connector *connector) 836 { 837 struct drm_device *dev = connector->base.dev; 838 struct drm_i915_private *dev_priv = dev->dev_private; 839 struct intel_panel *panel = &connector->panel; 840 enum i915_pipe pipe = intel_get_pipe_from_connector(connector); 841 enum transcoder cpu_transcoder = 842 intel_pipe_to_cpu_transcoder(dev_priv, pipe); 843 u32 cpu_ctl2, pch_ctl1, pch_ctl2; 844 845 cpu_ctl2 = I915_READ(BLC_PWM_CPU_CTL2); 846 if (cpu_ctl2 & BLM_PWM_ENABLE) { 847 DRM_DEBUG_KMS("cpu backlight already enabled\n"); 848 cpu_ctl2 &= ~BLM_PWM_ENABLE; 849 I915_WRITE(BLC_PWM_CPU_CTL2, cpu_ctl2); 850 } 851 852 pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1); 853 if (pch_ctl1 & BLM_PCH_PWM_ENABLE) { 854 DRM_DEBUG_KMS("pch backlight already enabled\n"); 855 pch_ctl1 &= ~BLM_PCH_PWM_ENABLE; 856 I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1); 857 } 858 859 if (cpu_transcoder == TRANSCODER_EDP) 860 cpu_ctl2 = BLM_TRANSCODER_EDP; 861 else 862 cpu_ctl2 = BLM_PIPE(cpu_transcoder); 863 I915_WRITE(BLC_PWM_CPU_CTL2, cpu_ctl2); 864 POSTING_READ(BLC_PWM_CPU_CTL2); 865 I915_WRITE(BLC_PWM_CPU_CTL2, cpu_ctl2 | BLM_PWM_ENABLE); 866 867 /* This won't stick until the above enable. */ 868 intel_panel_actually_set_backlight(connector, panel->backlight.level); 869 870 pch_ctl2 = panel->backlight.max << 16; 871 I915_WRITE(BLC_PWM_PCH_CTL2, pch_ctl2); 872 873 pch_ctl1 = 0; 874 if (panel->backlight.active_low_pwm) 875 pch_ctl1 |= BLM_PCH_POLARITY; 876 877 I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1); 878 POSTING_READ(BLC_PWM_PCH_CTL1); 879 I915_WRITE(BLC_PWM_PCH_CTL1, pch_ctl1 | BLM_PCH_PWM_ENABLE); 880 } 881 882 static void i9xx_enable_backlight(struct intel_connector *connector) 883 { 884 struct drm_device *dev = connector->base.dev; 885 struct drm_i915_private *dev_priv = dev->dev_private; 886 struct intel_panel *panel = &connector->panel; 887 u32 ctl, freq; 888 889 ctl = I915_READ(BLC_PWM_CTL); 890 if (ctl & BACKLIGHT_DUTY_CYCLE_MASK_PNV) { 891 DRM_DEBUG_KMS("backlight already enabled\n"); 892 I915_WRITE(BLC_PWM_CTL, 0); 893 } 894 895 freq = panel->backlight.max; 896 if (panel->backlight.combination_mode) 897 freq /= 0xff; 898 899 ctl = freq << 17; 900 if (panel->backlight.combination_mode) 901 ctl |= BLM_LEGACY_MODE; 902 if (IS_PINEVIEW(dev) && panel->backlight.active_low_pwm) 903 ctl |= BLM_POLARITY_PNV; 904 905 I915_WRITE(BLC_PWM_CTL, ctl); 906 POSTING_READ(BLC_PWM_CTL); 907 908 /* XXX: combine this into above write? */ 909 intel_panel_actually_set_backlight(connector, panel->backlight.level); 910 911 /* 912 * Needed to enable backlight on some 855gm models. BLC_HIST_CTL is 913 * 855gm only, but checking for gen2 is safe, as 855gm is the only gen2 914 * that has backlight. 915 */ 916 if (IS_GEN2(dev)) 917 I915_WRITE(BLC_HIST_CTL, BLM_HISTOGRAM_ENABLE); 918 } 919 920 static void i965_enable_backlight(struct intel_connector *connector) 921 { 922 struct drm_device *dev = connector->base.dev; 923 struct drm_i915_private *dev_priv = dev->dev_private; 924 struct intel_panel *panel = &connector->panel; 925 enum i915_pipe pipe = intel_get_pipe_from_connector(connector); 926 u32 ctl, ctl2, freq; 927 928 ctl2 = I915_READ(BLC_PWM_CTL2); 929 if (ctl2 & BLM_PWM_ENABLE) { 930 DRM_DEBUG_KMS("backlight already enabled\n"); 931 ctl2 &= ~BLM_PWM_ENABLE; 932 I915_WRITE(BLC_PWM_CTL2, ctl2); 933 } 934 935 freq = panel->backlight.max; 936 if (panel->backlight.combination_mode) 937 freq /= 0xff; 938 939 ctl = freq << 16; 940 I915_WRITE(BLC_PWM_CTL, ctl); 941 942 ctl2 = BLM_PIPE(pipe); 943 if (panel->backlight.combination_mode) 944 ctl2 |= BLM_COMBINATION_MODE; 945 if (panel->backlight.active_low_pwm) 946 ctl2 |= BLM_POLARITY_I965; 947 I915_WRITE(BLC_PWM_CTL2, ctl2); 948 POSTING_READ(BLC_PWM_CTL2); 949 I915_WRITE(BLC_PWM_CTL2, ctl2 | BLM_PWM_ENABLE); 950 951 intel_panel_actually_set_backlight(connector, panel->backlight.level); 952 } 953 954 static void vlv_enable_backlight(struct intel_connector *connector) 955 { 956 struct drm_device *dev = connector->base.dev; 957 struct drm_i915_private *dev_priv = dev->dev_private; 958 struct intel_panel *panel = &connector->panel; 959 enum i915_pipe pipe = intel_get_pipe_from_connector(connector); 960 u32 ctl, ctl2; 961 962 if (WARN_ON(pipe != PIPE_A && pipe != PIPE_B)) 963 return; 964 965 ctl2 = I915_READ(VLV_BLC_PWM_CTL2(pipe)); 966 if (ctl2 & BLM_PWM_ENABLE) { 967 DRM_DEBUG_KMS("backlight already enabled\n"); 968 ctl2 &= ~BLM_PWM_ENABLE; 969 I915_WRITE(VLV_BLC_PWM_CTL2(pipe), ctl2); 970 } 971 972 ctl = panel->backlight.max << 16; 973 I915_WRITE(VLV_BLC_PWM_CTL(pipe), ctl); 974 975 /* XXX: combine this into above write? */ 976 intel_panel_actually_set_backlight(connector, panel->backlight.level); 977 978 ctl2 = 0; 979 if (panel->backlight.active_low_pwm) 980 ctl2 |= BLM_POLARITY_I965; 981 I915_WRITE(VLV_BLC_PWM_CTL2(pipe), ctl2); 982 POSTING_READ(VLV_BLC_PWM_CTL2(pipe)); 983 I915_WRITE(VLV_BLC_PWM_CTL2(pipe), ctl2 | BLM_PWM_ENABLE); 984 } 985 986 static void bxt_enable_backlight(struct intel_connector *connector) 987 { 988 struct drm_device *dev = connector->base.dev; 989 struct drm_i915_private *dev_priv = dev->dev_private; 990 struct intel_panel *panel = &connector->panel; 991 u32 pwm_ctl; 992 993 pwm_ctl = I915_READ(BXT_BLC_PWM_CTL1); 994 if (pwm_ctl & BXT_BLC_PWM_ENABLE) { 995 DRM_DEBUG_KMS("backlight already enabled\n"); 996 pwm_ctl &= ~BXT_BLC_PWM_ENABLE; 997 I915_WRITE(BXT_BLC_PWM_CTL1, pwm_ctl); 998 } 999 1000 I915_WRITE(BXT_BLC_PWM_FREQ1, panel->backlight.max); 1001 1002 intel_panel_actually_set_backlight(connector, panel->backlight.level); 1003 1004 pwm_ctl = 0; 1005 if (panel->backlight.active_low_pwm) 1006 pwm_ctl |= BXT_BLC_PWM_POLARITY; 1007 1008 I915_WRITE(BXT_BLC_PWM_CTL1, pwm_ctl); 1009 POSTING_READ(BXT_BLC_PWM_CTL1); 1010 I915_WRITE(BXT_BLC_PWM_CTL1, pwm_ctl | BXT_BLC_PWM_ENABLE); 1011 } 1012 1013 void intel_panel_enable_backlight(struct intel_connector *connector) 1014 { 1015 struct drm_device *dev = connector->base.dev; 1016 struct drm_i915_private *dev_priv = dev->dev_private; 1017 struct intel_panel *panel = &connector->panel; 1018 enum i915_pipe pipe = intel_get_pipe_from_connector(connector); 1019 1020 if (!panel->backlight.present) 1021 return; 1022 1023 DRM_DEBUG_KMS("pipe %c\n", pipe_name(pipe)); 1024 1025 mutex_lock(&dev_priv->backlight_lock); 1026 1027 WARN_ON(panel->backlight.max == 0); 1028 1029 if (panel->backlight.level <= panel->backlight.min) { 1030 panel->backlight.level = panel->backlight.max; 1031 if (panel->backlight.device) 1032 panel->backlight.device->props.brightness = 1033 scale_hw_to_user(connector, 1034 panel->backlight.level, 1035 panel->backlight.device->props.max_brightness); 1036 } 1037 1038 dev_priv->display.enable_backlight(connector); 1039 panel->backlight.enabled = true; 1040 if (panel->backlight.device) 1041 panel->backlight.device->props.power = FB_BLANK_UNBLANK; 1042 1043 mutex_unlock(&dev_priv->backlight_lock); 1044 } 1045 1046 #if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE) 1047 static int intel_backlight_device_update_status(struct backlight_device *bd) 1048 { 1049 #if 0 1050 struct intel_connector *connector = bl_get_data(bd); 1051 struct intel_panel *panel = &connector->panel; 1052 struct drm_device *dev = connector->base.dev; 1053 1054 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 1055 DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n", 1056 bd->props.brightness, bd->props.max_brightness); 1057 intel_panel_set_backlight(connector, bd->props.brightness, 1058 bd->props.max_brightness); 1059 1060 /* 1061 * Allow flipping bl_power as a sub-state of enabled. Sadly the 1062 * backlight class device does not make it easy to to differentiate 1063 * between callbacks for brightness and bl_power, so our backlight_power 1064 * callback needs to take this into account. 1065 */ 1066 if (panel->backlight.enabled) { 1067 if (panel->backlight_power) { 1068 bool enable = bd->props.power == FB_BLANK_UNBLANK && 1069 bd->props.brightness != 0; 1070 panel->backlight_power(connector, enable); 1071 } 1072 } else { 1073 bd->props.power = FB_BLANK_POWERDOWN; 1074 } 1075 1076 drm_modeset_unlock(&dev->mode_config.connection_mutex); 1077 #endif 1078 return 0; 1079 } 1080 1081 static int intel_backlight_device_get_brightness(struct backlight_device *bd) 1082 { 1083 #if 0 1084 struct intel_connector *connector = bl_get_data(bd); 1085 struct drm_device *dev = connector->base.dev; 1086 struct drm_i915_private *dev_priv = dev->dev_private; 1087 u32 hw_level; 1088 int ret; 1089 1090 intel_runtime_pm_get(dev_priv); 1091 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 1092 1093 hw_level = intel_panel_get_backlight(connector); 1094 ret = scale_hw_to_user(connector, hw_level, bd->props.max_brightness); 1095 1096 drm_modeset_unlock(&dev->mode_config.connection_mutex); 1097 intel_runtime_pm_put(dev_priv); 1098 1099 return ret; 1100 #endif 1101 return 0; 1102 } 1103 1104 static const struct backlight_ops intel_backlight_device_ops = { 1105 .update_status = intel_backlight_device_update_status, 1106 .get_brightness = intel_backlight_device_get_brightness, 1107 }; 1108 1109 static int intel_backlight_device_register(struct intel_connector *connector) 1110 { 1111 struct intel_panel *panel = &connector->panel; 1112 struct backlight_properties props; 1113 1114 if (WARN_ON(panel->backlight.device)) 1115 return -ENODEV; 1116 1117 if (!panel->backlight.present) 1118 return 0; 1119 1120 WARN_ON(panel->backlight.max == 0); 1121 1122 memset(&props, 0, sizeof(props)); 1123 props.type = BACKLIGHT_RAW; 1124 1125 /* 1126 * Note: Everything should work even if the backlight device max 1127 * presented to the userspace is arbitrarily chosen. 1128 */ 1129 props.max_brightness = panel->backlight.max; 1130 props.brightness = scale_hw_to_user(connector, 1131 panel->backlight.level, 1132 props.max_brightness); 1133 1134 if (panel->backlight.enabled) 1135 props.power = FB_BLANK_UNBLANK; 1136 else 1137 props.power = FB_BLANK_POWERDOWN; 1138 1139 /* 1140 * Note: using the same name independent of the connector prevents 1141 * registration of multiple backlight devices in the driver. 1142 */ 1143 #if 0 1144 panel->backlight.device = 1145 backlight_device_register("intel_backlight", 1146 connector->base.kdev, 1147 connector, 1148 &intel_backlight_device_ops, &props); 1149 1150 if (IS_ERR(panel->backlight.device)) { 1151 DRM_ERROR("Failed to register backlight: %ld\n", 1152 PTR_ERR(panel->backlight.device)); 1153 panel->backlight.device = NULL; 1154 return -ENODEV; 1155 } 1156 #endif 1157 1158 DRM_DEBUG_KMS("Connector %s backlight sysfs interface registered\n", 1159 connector->base.name); 1160 1161 return 0; 1162 } 1163 1164 static void intel_backlight_device_unregister(struct intel_connector *connector) 1165 { 1166 #if 0 1167 struct intel_panel *panel = &connector->panel; 1168 1169 if (panel->backlight.device) { 1170 backlight_device_unregister(panel->backlight.device); 1171 panel->backlight.device = NULL; 1172 } 1173 #endif 1174 } 1175 #else /* CONFIG_BACKLIGHT_CLASS_DEVICE */ 1176 static int intel_backlight_device_register(struct intel_connector *connector) 1177 { 1178 return 0; 1179 } 1180 static void intel_backlight_device_unregister(struct intel_connector *connector) 1181 { 1182 } 1183 #endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */ 1184 1185 /* 1186 * Note: The setup hooks can't assume pipe is set! 1187 * 1188 * XXX: Query mode clock or hardware clock and program PWM modulation frequency 1189 * appropriately when it's 0. Use VBT and/or sane defaults. 1190 */ 1191 static u32 get_backlight_min_vbt(struct intel_connector *connector) 1192 { 1193 struct drm_device *dev = connector->base.dev; 1194 struct drm_i915_private *dev_priv = dev->dev_private; 1195 struct intel_panel *panel = &connector->panel; 1196 int min; 1197 1198 WARN_ON(panel->backlight.max == 0); 1199 1200 /* 1201 * XXX: If the vbt value is 255, it makes min equal to max, which leads 1202 * to problems. There are such machines out there. Either our 1203 * interpretation is wrong or the vbt has bogus data. Or both. Safeguard 1204 * against this by letting the minimum be at most (arbitrarily chosen) 1205 * 25% of the max. 1206 */ 1207 min = clamp_t(int, dev_priv->vbt.backlight.min_brightness, 0, 64); 1208 if (min != dev_priv->vbt.backlight.min_brightness) { 1209 DRM_DEBUG_KMS("clamping VBT min backlight %d/255 to %d/255\n", 1210 dev_priv->vbt.backlight.min_brightness, min); 1211 } 1212 1213 /* vbt value is a coefficient in range [0..255] */ 1214 return scale(min, 0, 255, 0, panel->backlight.max); 1215 } 1216 1217 static int bdw_setup_backlight(struct intel_connector *connector, enum i915_pipe unused) 1218 { 1219 struct drm_device *dev = connector->base.dev; 1220 struct drm_i915_private *dev_priv = dev->dev_private; 1221 struct intel_panel *panel = &connector->panel; 1222 u32 pch_ctl1, pch_ctl2, val; 1223 1224 pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1); 1225 panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY; 1226 1227 pch_ctl2 = I915_READ(BLC_PWM_PCH_CTL2); 1228 panel->backlight.max = pch_ctl2 >> 16; 1229 if (!panel->backlight.max) 1230 return -ENODEV; 1231 1232 panel->backlight.min = get_backlight_min_vbt(connector); 1233 1234 val = bdw_get_backlight(connector); 1235 panel->backlight.level = intel_panel_compute_brightness(connector, val); 1236 1237 panel->backlight.enabled = (pch_ctl1 & BLM_PCH_PWM_ENABLE) && 1238 panel->backlight.level != 0; 1239 1240 return 0; 1241 } 1242 1243 static int pch_setup_backlight(struct intel_connector *connector, enum i915_pipe unused) 1244 { 1245 struct drm_device *dev = connector->base.dev; 1246 struct drm_i915_private *dev_priv = dev->dev_private; 1247 struct intel_panel *panel = &connector->panel; 1248 u32 cpu_ctl2, pch_ctl1, pch_ctl2, val; 1249 1250 pch_ctl1 = I915_READ(BLC_PWM_PCH_CTL1); 1251 panel->backlight.active_low_pwm = pch_ctl1 & BLM_PCH_POLARITY; 1252 1253 pch_ctl2 = I915_READ(BLC_PWM_PCH_CTL2); 1254 panel->backlight.max = pch_ctl2 >> 16; 1255 if (!panel->backlight.max) 1256 return -ENODEV; 1257 1258 panel->backlight.min = get_backlight_min_vbt(connector); 1259 1260 val = pch_get_backlight(connector); 1261 panel->backlight.level = intel_panel_compute_brightness(connector, val); 1262 1263 cpu_ctl2 = I915_READ(BLC_PWM_CPU_CTL2); 1264 panel->backlight.enabled = (cpu_ctl2 & BLM_PWM_ENABLE) && 1265 (pch_ctl1 & BLM_PCH_PWM_ENABLE) && panel->backlight.level != 0; 1266 1267 return 0; 1268 } 1269 1270 static int i9xx_setup_backlight(struct intel_connector *connector, enum i915_pipe unused) 1271 { 1272 struct drm_device *dev = connector->base.dev; 1273 struct drm_i915_private *dev_priv = dev->dev_private; 1274 struct intel_panel *panel = &connector->panel; 1275 u32 ctl, val; 1276 1277 ctl = I915_READ(BLC_PWM_CTL); 1278 1279 if (IS_GEN2(dev) || IS_I915GM(dev) || IS_I945GM(dev)) 1280 panel->backlight.combination_mode = ctl & BLM_LEGACY_MODE; 1281 1282 if (IS_PINEVIEW(dev)) 1283 panel->backlight.active_low_pwm = ctl & BLM_POLARITY_PNV; 1284 1285 panel->backlight.max = ctl >> 17; 1286 if (panel->backlight.combination_mode) 1287 panel->backlight.max *= 0xff; 1288 1289 if (!panel->backlight.max) 1290 return -ENODEV; 1291 1292 panel->backlight.min = get_backlight_min_vbt(connector); 1293 1294 val = i9xx_get_backlight(connector); 1295 panel->backlight.level = intel_panel_compute_brightness(connector, val); 1296 1297 panel->backlight.enabled = panel->backlight.level != 0; 1298 1299 return 0; 1300 } 1301 1302 static int i965_setup_backlight(struct intel_connector *connector, enum i915_pipe unused) 1303 { 1304 struct drm_device *dev = connector->base.dev; 1305 struct drm_i915_private *dev_priv = dev->dev_private; 1306 struct intel_panel *panel = &connector->panel; 1307 u32 ctl, ctl2, val; 1308 1309 ctl2 = I915_READ(BLC_PWM_CTL2); 1310 panel->backlight.combination_mode = ctl2 & BLM_COMBINATION_MODE; 1311 panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965; 1312 1313 ctl = I915_READ(BLC_PWM_CTL); 1314 panel->backlight.max = ctl >> 16; 1315 if (panel->backlight.combination_mode) 1316 panel->backlight.max *= 0xff; 1317 1318 if (!panel->backlight.max) 1319 return -ENODEV; 1320 1321 panel->backlight.min = get_backlight_min_vbt(connector); 1322 1323 val = i9xx_get_backlight(connector); 1324 panel->backlight.level = intel_panel_compute_brightness(connector, val); 1325 1326 panel->backlight.enabled = (ctl2 & BLM_PWM_ENABLE) && 1327 panel->backlight.level != 0; 1328 1329 return 0; 1330 } 1331 1332 static int vlv_setup_backlight(struct intel_connector *connector, enum i915_pipe pipe) 1333 { 1334 struct drm_device *dev = connector->base.dev; 1335 struct drm_i915_private *dev_priv = dev->dev_private; 1336 struct intel_panel *panel = &connector->panel; 1337 enum i915_pipe p; 1338 u32 ctl, ctl2, val; 1339 1340 for_each_pipe(dev_priv, p) { 1341 u32 cur_val = I915_READ(VLV_BLC_PWM_CTL(p)); 1342 1343 /* Skip if the modulation freq is already set */ 1344 if (cur_val & ~BACKLIGHT_DUTY_CYCLE_MASK) 1345 continue; 1346 1347 cur_val &= BACKLIGHT_DUTY_CYCLE_MASK; 1348 I915_WRITE(VLV_BLC_PWM_CTL(p), (0xf42 << 16) | 1349 cur_val); 1350 } 1351 1352 if (WARN_ON(pipe != PIPE_A && pipe != PIPE_B)) 1353 return -ENODEV; 1354 1355 ctl2 = I915_READ(VLV_BLC_PWM_CTL2(pipe)); 1356 panel->backlight.active_low_pwm = ctl2 & BLM_POLARITY_I965; 1357 1358 ctl = I915_READ(VLV_BLC_PWM_CTL(pipe)); 1359 panel->backlight.max = ctl >> 16; 1360 if (!panel->backlight.max) 1361 return -ENODEV; 1362 1363 panel->backlight.min = get_backlight_min_vbt(connector); 1364 1365 val = _vlv_get_backlight(dev, pipe); 1366 panel->backlight.level = intel_panel_compute_brightness(connector, val); 1367 1368 panel->backlight.enabled = (ctl2 & BLM_PWM_ENABLE) && 1369 panel->backlight.level != 0; 1370 1371 return 0; 1372 } 1373 1374 #ifdef __DragonFly__ 1375 /* 1376 * Read max backlight level 1377 */ 1378 static int 1379 sysctl_backlight_max(SYSCTL_HANDLER_ARGS) 1380 { 1381 int err, val; 1382 struct intel_connector *connector = arg1; 1383 struct drm_device *dev = connector->base.dev; 1384 struct drm_i915_private *dev_priv = dev->dev_private; 1385 struct intel_panel *panel = &connector->panel; 1386 1387 mutex_lock(&dev_priv->backlight_lock); 1388 val = panel->backlight.max; 1389 mutex_unlock(&dev_priv->backlight_lock); 1390 1391 err = sysctl_handle_int(oidp, &val, 0, req); 1392 return(err); 1393 } 1394 1395 /* 1396 * Read/write backlight level 1397 */ 1398 static int 1399 sysctl_backlight_handler(SYSCTL_HANDLER_ARGS) 1400 { 1401 struct intel_connector *connector = arg1; 1402 struct drm_device *dev = connector->base.dev; 1403 struct drm_i915_private *dev_priv = dev->dev_private; 1404 struct intel_panel *panel = &connector->panel; 1405 int err, val; 1406 u32 user_level, max_brightness; 1407 1408 mutex_lock(&dev_priv->backlight_lock); 1409 max_brightness = panel->backlight.max; 1410 user_level = scale_hw_to_user(connector, panel->backlight.level, 1411 max_brightness); 1412 mutex_unlock(&dev_priv->backlight_lock); 1413 1414 val = user_level; 1415 err = sysctl_handle_int(oidp, &val, 0, req); 1416 if (err != 0 || req->newptr == NULL) { 1417 return(err); 1418 } 1419 1420 if (val != user_level && val >= 0 && val <= max_brightness) { 1421 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 1422 intel_panel_set_backlight(arg1, val, max_brightness); 1423 drm_modeset_unlock(&dev->mode_config.connection_mutex); 1424 } 1425 1426 return(err); 1427 } 1428 #endif /* __DragonFly__ */ 1429 1430 static int 1431 bxt_setup_backlight(struct intel_connector *connector, enum i915_pipe unused) 1432 { 1433 struct drm_device *dev = connector->base.dev; 1434 struct drm_i915_private *dev_priv = dev->dev_private; 1435 struct intel_panel *panel = &connector->panel; 1436 u32 pwm_ctl, val; 1437 1438 pwm_ctl = I915_READ(BXT_BLC_PWM_CTL1); 1439 panel->backlight.active_low_pwm = pwm_ctl & BXT_BLC_PWM_POLARITY; 1440 1441 panel->backlight.max = I915_READ(BXT_BLC_PWM_FREQ1); 1442 if (!panel->backlight.max) 1443 return -ENODEV; 1444 1445 val = bxt_get_backlight(connector); 1446 panel->backlight.level = intel_panel_compute_brightness(connector, val); 1447 1448 panel->backlight.enabled = (pwm_ctl & BXT_BLC_PWM_ENABLE) && 1449 panel->backlight.level != 0; 1450 1451 return 0; 1452 } 1453 1454 int intel_panel_setup_backlight(struct drm_connector *connector, enum i915_pipe pipe) 1455 { 1456 struct drm_device *dev = connector->dev; 1457 struct drm_i915_private *dev_priv = dev->dev_private; 1458 struct intel_connector *intel_connector = to_intel_connector(connector); 1459 struct intel_panel *panel = &intel_connector->panel; 1460 int ret; 1461 1462 if (!dev_priv->vbt.backlight.present) { 1463 if (dev_priv->quirks & QUIRK_BACKLIGHT_PRESENT) { 1464 DRM_DEBUG_KMS("no backlight present per VBT, but present per quirk\n"); 1465 } else { 1466 DRM_DEBUG_KMS("no backlight present per VBT\n"); 1467 return 0; 1468 } 1469 } 1470 1471 /* set level and max in panel struct */ 1472 mutex_lock(&dev_priv->backlight_lock); 1473 ret = dev_priv->display.setup_backlight(intel_connector, pipe); 1474 mutex_unlock(&dev_priv->backlight_lock); 1475 1476 if (ret) { 1477 DRM_DEBUG_KMS("failed to setup backlight for connector %s\n", 1478 connector->name); 1479 return ret; 1480 } 1481 1482 panel->backlight.present = true; 1483 1484 #ifdef __DragonFly__ 1485 SYSCTL_ADD_PROC(&connector->dev->sysctl->ctx, &sysctl__hw_children, 1486 OID_AUTO, "backlight_max", 1487 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_ANYBODY, 1488 connector, sizeof(int), 1489 sysctl_backlight_max, 1490 "I", "Max backlight level"); 1491 SYSCTL_ADD_PROC(&connector->dev->sysctl->ctx, &sysctl__hw_children, 1492 OID_AUTO, "backlight_level", 1493 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY, 1494 connector, sizeof(int), 1495 sysctl_backlight_handler, 1496 "I", "Backlight level"); 1497 #endif 1498 1499 DRM_DEBUG_KMS("Connector %s backlight initialized, %s, brightness %u/%u\n", 1500 connector->name, 1501 panel->backlight.enabled ? "enabled" : "disabled", 1502 panel->backlight.level, panel->backlight.max); 1503 1504 return 0; 1505 } 1506 1507 void intel_panel_destroy_backlight(struct drm_connector *connector) 1508 { 1509 struct intel_connector *intel_connector = to_intel_connector(connector); 1510 struct intel_panel *panel = &intel_connector->panel; 1511 1512 panel->backlight.present = false; 1513 } 1514 1515 /* Set up chip specific backlight functions */ 1516 void intel_panel_init_backlight_funcs(struct drm_device *dev) 1517 { 1518 struct drm_i915_private *dev_priv = dev->dev_private; 1519 1520 if (IS_BROXTON(dev)) { 1521 dev_priv->display.setup_backlight = bxt_setup_backlight; 1522 dev_priv->display.enable_backlight = bxt_enable_backlight; 1523 dev_priv->display.disable_backlight = bxt_disable_backlight; 1524 dev_priv->display.set_backlight = bxt_set_backlight; 1525 dev_priv->display.get_backlight = bxt_get_backlight; 1526 } else if (IS_BROADWELL(dev) || IS_SKYLAKE(dev)) { 1527 dev_priv->display.setup_backlight = bdw_setup_backlight; 1528 dev_priv->display.enable_backlight = bdw_enable_backlight; 1529 dev_priv->display.disable_backlight = pch_disable_backlight; 1530 dev_priv->display.set_backlight = bdw_set_backlight; 1531 dev_priv->display.get_backlight = bdw_get_backlight; 1532 } else if (HAS_PCH_SPLIT(dev)) { 1533 dev_priv->display.setup_backlight = pch_setup_backlight; 1534 dev_priv->display.enable_backlight = pch_enable_backlight; 1535 dev_priv->display.disable_backlight = pch_disable_backlight; 1536 dev_priv->display.set_backlight = pch_set_backlight; 1537 dev_priv->display.get_backlight = pch_get_backlight; 1538 } else if (IS_VALLEYVIEW(dev)) { 1539 dev_priv->display.setup_backlight = vlv_setup_backlight; 1540 dev_priv->display.enable_backlight = vlv_enable_backlight; 1541 dev_priv->display.disable_backlight = vlv_disable_backlight; 1542 dev_priv->display.set_backlight = vlv_set_backlight; 1543 dev_priv->display.get_backlight = vlv_get_backlight; 1544 } else if (IS_GEN4(dev)) { 1545 dev_priv->display.setup_backlight = i965_setup_backlight; 1546 dev_priv->display.enable_backlight = i965_enable_backlight; 1547 dev_priv->display.disable_backlight = i965_disable_backlight; 1548 dev_priv->display.set_backlight = i9xx_set_backlight; 1549 dev_priv->display.get_backlight = i9xx_get_backlight; 1550 } else { 1551 dev_priv->display.setup_backlight = i9xx_setup_backlight; 1552 dev_priv->display.enable_backlight = i9xx_enable_backlight; 1553 dev_priv->display.disable_backlight = i9xx_disable_backlight; 1554 dev_priv->display.set_backlight = i9xx_set_backlight; 1555 dev_priv->display.get_backlight = i9xx_get_backlight; 1556 } 1557 } 1558 1559 int intel_panel_init(struct intel_panel *panel, 1560 struct drm_display_mode *fixed_mode, 1561 struct drm_display_mode *downclock_mode) 1562 { 1563 panel->fixed_mode = fixed_mode; 1564 panel->downclock_mode = downclock_mode; 1565 1566 return 0; 1567 } 1568 1569 void intel_panel_fini(struct intel_panel *panel) 1570 { 1571 struct intel_connector *intel_connector = 1572 container_of(panel, struct intel_connector, panel); 1573 1574 if (panel->fixed_mode) 1575 drm_mode_destroy(intel_connector->base.dev, panel->fixed_mode); 1576 1577 if (panel->downclock_mode) 1578 drm_mode_destroy(intel_connector->base.dev, 1579 panel->downclock_mode); 1580 } 1581 1582 void intel_backlight_register(struct drm_device *dev) 1583 { 1584 struct intel_connector *connector; 1585 1586 list_for_each_entry(connector, &dev->mode_config.connector_list, base.head) 1587 intel_backlight_device_register(connector); 1588 } 1589 1590 void intel_backlight_unregister(struct drm_device *dev) 1591 { 1592 struct intel_connector *connector; 1593 1594 list_for_each_entry(connector, &dev->mode_config.connector_list, base.head) 1595 intel_backlight_device_unregister(connector); 1596 } 1597