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