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