1 /*
2 * Copyright © 2015 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 *
23 */
24
25 /*
26 * Laptops with Intel GPUs which have panels that support controlling the
27 * backlight through DP AUX can actually use two different interfaces: Intel's
28 * proprietary DP AUX backlight interface, and the standard VESA backlight
29 * interface. Unfortunately, at the time of writing this a lot of laptops will
30 * advertise support for the standard VESA backlight interface when they
31 * don't properly support it. However, on these systems the Intel backlight
32 * interface generally does work properly. Additionally, these systems will
33 * usually just indicate that they use PWM backlight controls in their VBIOS
34 * for some reason.
35 */
36
37 #include <linux/kconfig.h>
38 #include "i915_drv.h"
39 #include "intel_backlight.h"
40 #include "intel_display_types.h"
41 #include "intel_dp.h"
42 #include "intel_dp_aux_backlight.h"
43
44 /* TODO:
45 * Implement HDR, right now we just implement the bare minimum to bring us back into SDR mode so we
46 * can make people's backlights work in the mean time
47 */
48
49 /*
50 * DP AUX registers for Intel's proprietary HDR backlight interface. We define
51 * them here since we'll likely be the only driver to ever use these.
52 */
53 #define INTEL_EDP_HDR_TCON_CAP0 0x340
54
55 #define INTEL_EDP_HDR_TCON_CAP1 0x341
56 # define INTEL_EDP_HDR_TCON_2084_DECODE_CAP BIT(0)
57 # define INTEL_EDP_HDR_TCON_2020_GAMUT_CAP BIT(1)
58 # define INTEL_EDP_HDR_TCON_TONE_MAPPING_CAP BIT(2)
59 # define INTEL_EDP_HDR_TCON_SEGMENTED_BACKLIGHT_CAP BIT(3)
60 # define INTEL_EDP_HDR_TCON_BRIGHTNESS_NITS_CAP BIT(4)
61 # define INTEL_EDP_HDR_TCON_OPTIMIZATION_CAP BIT(5)
62 # define INTEL_EDP_HDR_TCON_SDP_COLORIMETRY_CAP BIT(6)
63 # define INTEL_EDP_HDR_TCON_SRGB_TO_PANEL_GAMUT_CONVERSION_CAP BIT(7)
64
65 #define INTEL_EDP_HDR_TCON_CAP2 0x342
66 # define INTEL_EDP_SDR_TCON_BRIGHTNESS_AUX_CAP BIT(0)
67
68 #define INTEL_EDP_HDR_TCON_CAP3 0x343
69
70 #define INTEL_EDP_HDR_GETSET_CTRL_PARAMS 0x344
71 # define INTEL_EDP_HDR_TCON_2084_DECODE_ENABLE BIT(0)
72 # define INTEL_EDP_HDR_TCON_2020_GAMUT_ENABLE BIT(1)
73 # define INTEL_EDP_HDR_TCON_TONE_MAPPING_ENABLE BIT(2) /* Pre-TGL+ */
74 # define INTEL_EDP_HDR_TCON_SEGMENTED_BACKLIGHT_ENABLE BIT(3)
75 # define INTEL_EDP_HDR_TCON_BRIGHTNESS_AUX_ENABLE BIT(4)
76 # define INTEL_EDP_HDR_TCON_SRGB_TO_PANEL_GAMUT_ENABLE BIT(5)
77 /* Bit 6 is reserved */
78 # define INTEL_EDP_HDR_TCON_SDP_COLORIMETRY_ENABLE BIT(7)
79
80 #define INTEL_EDP_HDR_CONTENT_LUMINANCE 0x346 /* Pre-TGL+ */
81 #define INTEL_EDP_HDR_PANEL_LUMINANCE_OVERRIDE 0x34A
82 #define INTEL_EDP_SDR_LUMINANCE_LEVEL 0x352
83 #define INTEL_EDP_BRIGHTNESS_NITS_LSB 0x354
84 #define INTEL_EDP_BRIGHTNESS_NITS_MSB 0x355
85 #define INTEL_EDP_BRIGHTNESS_DELAY_FRAMES 0x356
86 #define INTEL_EDP_BRIGHTNESS_PER_FRAME_STEPS 0x357
87
88 #define INTEL_EDP_BRIGHTNESS_OPTIMIZATION_0 0x358
89 # define INTEL_EDP_TCON_USAGE_MASK GENMASK(0, 3)
90 # define INTEL_EDP_TCON_USAGE_UNKNOWN 0x0
91 # define INTEL_EDP_TCON_USAGE_DESKTOP 0x1
92 # define INTEL_EDP_TCON_USAGE_FULL_SCREEN_MEDIA 0x2
93 # define INTEL_EDP_TCON_USAGE_FULL_SCREEN_GAMING 0x3
94 # define INTEL_EDP_TCON_POWER_MASK BIT(4)
95 # define INTEL_EDP_TCON_POWER_DC (0 << 4)
96 # define INTEL_EDP_TCON_POWER_AC (1 << 4)
97 # define INTEL_EDP_TCON_OPTIMIZATION_STRENGTH_MASK GENMASK(5, 7)
98
99 #define INTEL_EDP_BRIGHTNESS_OPTIMIZATION_1 0x359
100
101 enum intel_dp_aux_backlight_modparam {
102 INTEL_DP_AUX_BACKLIGHT_AUTO = -1,
103 INTEL_DP_AUX_BACKLIGHT_OFF = 0,
104 INTEL_DP_AUX_BACKLIGHT_ON = 1,
105 INTEL_DP_AUX_BACKLIGHT_FORCE_VESA = 2,
106 INTEL_DP_AUX_BACKLIGHT_FORCE_INTEL = 3,
107 };
108
is_intel_tcon_cap(const u8 tcon_cap[4])109 static bool is_intel_tcon_cap(const u8 tcon_cap[4])
110 {
111 return tcon_cap[0] >= 1;
112 }
113
114 /* Intel EDP backlight callbacks */
115 static bool
intel_dp_aux_supports_hdr_backlight(struct intel_connector * connector)116 intel_dp_aux_supports_hdr_backlight(struct intel_connector *connector)
117 {
118 struct drm_i915_private *i915 = to_i915(connector->base.dev);
119 struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
120 struct drm_dp_aux *aux = &intel_dp->aux;
121 struct intel_panel *panel = &connector->panel;
122 int ret;
123 u8 tcon_cap[4];
124
125 intel_dp_wait_source_oui(intel_dp);
126
127 ret = drm_dp_dpcd_read(aux, INTEL_EDP_HDR_TCON_CAP0, tcon_cap, sizeof(tcon_cap));
128 if (ret != sizeof(tcon_cap))
129 return false;
130
131 if (!(tcon_cap[1] & INTEL_EDP_HDR_TCON_BRIGHTNESS_NITS_CAP))
132 return false;
133
134 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] Detected %s HDR backlight interface version %d\n",
135 connector->base.base.id, connector->base.name,
136 is_intel_tcon_cap(tcon_cap) ? "Intel" : "unsupported", tcon_cap[0]);
137
138 if (!is_intel_tcon_cap(tcon_cap))
139 return false;
140
141 /*
142 * If we don't have HDR static metadata there is no way to
143 * runtime detect used range for nits based control. For now
144 * do not use Intel proprietary eDP backlight control if we
145 * don't have this data in panel EDID. In case we find panel
146 * which supports only nits based control, but doesn't provide
147 * HDR static metadata we need to start maintaining table of
148 * ranges for such panels.
149 */
150 if (i915->params.enable_dpcd_backlight != INTEL_DP_AUX_BACKLIGHT_FORCE_INTEL &&
151 !(connector->base.hdr_sink_metadata.hdmi_type1.metadata_type &
152 BIT(HDMI_STATIC_METADATA_TYPE1))) {
153 drm_info(&i915->drm,
154 "[CONNECTOR:%d:%s] Panel is missing HDR static metadata. Possible support for Intel HDR backlight interface is not used. If your backlight controls don't work try booting with i915.enable_dpcd_backlight=%d. needs this, please file a _new_ bug report on drm/i915, see " FDO_BUG_URL " for details.\n",
155 connector->base.base.id, connector->base.name,
156 INTEL_DP_AUX_BACKLIGHT_FORCE_INTEL);
157 return false;
158 }
159
160 panel->backlight.edp.intel.sdr_uses_aux =
161 tcon_cap[2] & INTEL_EDP_SDR_TCON_BRIGHTNESS_AUX_CAP;
162
163 return true;
164 }
165
166 static u32
intel_dp_aux_hdr_get_backlight(struct intel_connector * connector,enum pipe pipe)167 intel_dp_aux_hdr_get_backlight(struct intel_connector *connector, enum pipe pipe)
168 {
169 struct drm_i915_private *i915 = to_i915(connector->base.dev);
170 struct intel_panel *panel = &connector->panel;
171 struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
172 u8 tmp;
173 u8 buf[2] = { 0 };
174
175 if (drm_dp_dpcd_readb(&intel_dp->aux, INTEL_EDP_HDR_GETSET_CTRL_PARAMS, &tmp) != 1) {
176 drm_err(&i915->drm, "[CONNECTOR:%d:%s] Failed to read current backlight mode from DPCD\n",
177 connector->base.base.id, connector->base.name);
178 return 0;
179 }
180
181 if (!(tmp & INTEL_EDP_HDR_TCON_BRIGHTNESS_AUX_ENABLE)) {
182 if (!panel->backlight.edp.intel.sdr_uses_aux) {
183 u32 pwm_level = panel->backlight.pwm_funcs->get(connector, pipe);
184
185 return intel_backlight_level_from_pwm(connector, pwm_level);
186 }
187
188 /* Assume 100% brightness if backlight controls aren't enabled yet */
189 return panel->backlight.max;
190 }
191
192 if (drm_dp_dpcd_read(&intel_dp->aux, INTEL_EDP_BRIGHTNESS_NITS_LSB, buf,
193 sizeof(buf)) != sizeof(buf)) {
194 drm_err(&i915->drm, "[CONNECTOR:%d:%s] Failed to read brightness from DPCD\n",
195 connector->base.base.id, connector->base.name);
196 return 0;
197 }
198
199 return (buf[1] << 8 | buf[0]);
200 }
201
202 static void
intel_dp_aux_hdr_set_aux_backlight(const struct drm_connector_state * conn_state,u32 level)203 intel_dp_aux_hdr_set_aux_backlight(const struct drm_connector_state *conn_state, u32 level)
204 {
205 struct intel_connector *connector = to_intel_connector(conn_state->connector);
206 struct drm_device *dev = connector->base.dev;
207 struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
208 u8 buf[4] = { 0 };
209
210 buf[0] = level & 0xFF;
211 buf[1] = (level & 0xFF00) >> 8;
212
213 if (drm_dp_dpcd_write(&intel_dp->aux, INTEL_EDP_BRIGHTNESS_NITS_LSB, buf,
214 sizeof(buf)) != sizeof(buf))
215 drm_err(dev, "[CONNECTOR:%d:%s] Failed to write brightness level to DPCD\n",
216 connector->base.base.id, connector->base.name);
217 }
218
219 static void
intel_dp_aux_hdr_set_backlight(const struct drm_connector_state * conn_state,u32 level)220 intel_dp_aux_hdr_set_backlight(const struct drm_connector_state *conn_state, u32 level)
221 {
222 struct intel_connector *connector = to_intel_connector(conn_state->connector);
223 struct intel_panel *panel = &connector->panel;
224
225 if (panel->backlight.edp.intel.sdr_uses_aux) {
226 intel_dp_aux_hdr_set_aux_backlight(conn_state, level);
227 } else {
228 const u32 pwm_level = intel_backlight_level_to_pwm(connector, level);
229
230 intel_backlight_set_pwm_level(conn_state, pwm_level);
231 }
232 }
233
234 static void
intel_dp_aux_hdr_enable_backlight(const struct intel_crtc_state * crtc_state,const struct drm_connector_state * conn_state,u32 level)235 intel_dp_aux_hdr_enable_backlight(const struct intel_crtc_state *crtc_state,
236 const struct drm_connector_state *conn_state, u32 level)
237 {
238 struct intel_connector *connector = to_intel_connector(conn_state->connector);
239 struct intel_panel *panel = &connector->panel;
240 struct drm_i915_private *i915 = to_i915(connector->base.dev);
241 struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
242 int ret;
243 u8 old_ctrl, ctrl;
244
245 intel_dp_wait_source_oui(intel_dp);
246
247 ret = drm_dp_dpcd_readb(&intel_dp->aux, INTEL_EDP_HDR_GETSET_CTRL_PARAMS, &old_ctrl);
248 if (ret != 1) {
249 drm_err(&i915->drm, "[CONNECTOR:%d:%s] Failed to read current backlight control mode: %d\n",
250 connector->base.base.id, connector->base.name, ret);
251 return;
252 }
253
254 ctrl = old_ctrl;
255 if (panel->backlight.edp.intel.sdr_uses_aux) {
256 ctrl |= INTEL_EDP_HDR_TCON_BRIGHTNESS_AUX_ENABLE;
257 intel_dp_aux_hdr_set_aux_backlight(conn_state, level);
258 } else {
259 u32 pwm_level = intel_backlight_level_to_pwm(connector, level);
260
261 panel->backlight.pwm_funcs->enable(crtc_state, conn_state, pwm_level);
262
263 ctrl &= ~INTEL_EDP_HDR_TCON_BRIGHTNESS_AUX_ENABLE;
264 }
265
266 if (ctrl != old_ctrl &&
267 drm_dp_dpcd_writeb(&intel_dp->aux, INTEL_EDP_HDR_GETSET_CTRL_PARAMS, ctrl) != 1)
268 drm_err(&i915->drm, "[CONNECTOR:%d:%s] Failed to configure DPCD brightness controls\n",
269 connector->base.base.id, connector->base.name);
270 }
271
272 static void
intel_dp_aux_hdr_disable_backlight(const struct drm_connector_state * conn_state,u32 level)273 intel_dp_aux_hdr_disable_backlight(const struct drm_connector_state *conn_state, u32 level)
274 {
275 struct intel_connector *connector = to_intel_connector(conn_state->connector);
276 struct intel_panel *panel = &connector->panel;
277
278 /* Nothing to do for AUX based backlight controls */
279 if (panel->backlight.edp.intel.sdr_uses_aux)
280 return;
281
282 /* Note we want the actual pwm_level to be 0, regardless of pwm_min */
283 panel->backlight.pwm_funcs->disable(conn_state, intel_backlight_invert_pwm_level(connector, 0));
284 }
285
dpcd_vs_pwm_str(bool aux)286 static const char *dpcd_vs_pwm_str(bool aux)
287 {
288 return aux ? "DPCD" : "PWM";
289 }
290
291 static int
intel_dp_aux_hdr_setup_backlight(struct intel_connector * connector,enum pipe pipe)292 intel_dp_aux_hdr_setup_backlight(struct intel_connector *connector, enum pipe pipe)
293 {
294 struct drm_i915_private *i915 = to_i915(connector->base.dev);
295 struct intel_panel *panel = &connector->panel;
296 struct drm_luminance_range_info *luminance_range =
297 &connector->base.display_info.luminance_range;
298 int ret;
299
300 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] SDR backlight is controlled through %s\n",
301 connector->base.base.id, connector->base.name,
302 dpcd_vs_pwm_str(panel->backlight.edp.intel.sdr_uses_aux));
303
304 if (!panel->backlight.edp.intel.sdr_uses_aux) {
305 ret = panel->backlight.pwm_funcs->setup(connector, pipe);
306 if (ret < 0) {
307 drm_err(&i915->drm,
308 "[CONNECTOR:%d:%s] Failed to setup SDR backlight controls through PWM: %d\n",
309 connector->base.base.id, connector->base.name, ret);
310 return ret;
311 }
312 }
313
314 if (luminance_range->max_luminance) {
315 panel->backlight.max = luminance_range->max_luminance;
316 panel->backlight.min = luminance_range->min_luminance;
317 } else {
318 panel->backlight.max = 512;
319 panel->backlight.min = 0;
320 }
321
322 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] Using AUX HDR interface for backlight control (range %d..%d)\n",
323 connector->base.base.id, connector->base.name,
324 panel->backlight.min, panel->backlight.max);
325
326
327 panel->backlight.level = intel_dp_aux_hdr_get_backlight(connector, pipe);
328 panel->backlight.enabled = panel->backlight.level != 0;
329
330 return 0;
331 }
332
333 /* VESA backlight callbacks */
intel_dp_aux_vesa_get_backlight(struct intel_connector * connector,enum pipe unused)334 static u32 intel_dp_aux_vesa_get_backlight(struct intel_connector *connector, enum pipe unused)
335 {
336 return connector->panel.backlight.level;
337 }
338
339 static void
intel_dp_aux_vesa_set_backlight(const struct drm_connector_state * conn_state,u32 level)340 intel_dp_aux_vesa_set_backlight(const struct drm_connector_state *conn_state, u32 level)
341 {
342 struct intel_connector *connector = to_intel_connector(conn_state->connector);
343 struct intel_panel *panel = &connector->panel;
344 struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
345
346 if (!panel->backlight.edp.vesa.info.aux_set) {
347 const u32 pwm_level = intel_backlight_level_to_pwm(connector, level);
348
349 intel_backlight_set_pwm_level(conn_state, pwm_level);
350 }
351
352 drm_edp_backlight_set_level(&intel_dp->aux, &panel->backlight.edp.vesa.info, level);
353 }
354
355 static void
intel_dp_aux_vesa_enable_backlight(const struct intel_crtc_state * crtc_state,const struct drm_connector_state * conn_state,u32 level)356 intel_dp_aux_vesa_enable_backlight(const struct intel_crtc_state *crtc_state,
357 const struct drm_connector_state *conn_state, u32 level)
358 {
359 struct intel_connector *connector = to_intel_connector(conn_state->connector);
360 struct intel_panel *panel = &connector->panel;
361 struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
362
363 if (!panel->backlight.edp.vesa.info.aux_enable) {
364 u32 pwm_level;
365
366 if (!panel->backlight.edp.vesa.info.aux_set)
367 pwm_level = intel_backlight_level_to_pwm(connector, level);
368 else
369 pwm_level = intel_backlight_invert_pwm_level(connector,
370 panel->backlight.pwm_level_max);
371
372 panel->backlight.pwm_funcs->enable(crtc_state, conn_state, pwm_level);
373 }
374
375 drm_edp_backlight_enable(&intel_dp->aux, &panel->backlight.edp.vesa.info, level);
376 }
377
intel_dp_aux_vesa_disable_backlight(const struct drm_connector_state * old_conn_state,u32 level)378 static void intel_dp_aux_vesa_disable_backlight(const struct drm_connector_state *old_conn_state,
379 u32 level)
380 {
381 struct intel_connector *connector = to_intel_connector(old_conn_state->connector);
382 struct intel_panel *panel = &connector->panel;
383 struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
384
385 drm_edp_backlight_disable(&intel_dp->aux, &panel->backlight.edp.vesa.info);
386
387 if (!panel->backlight.edp.vesa.info.aux_enable)
388 panel->backlight.pwm_funcs->disable(old_conn_state,
389 intel_backlight_invert_pwm_level(connector, 0));
390 }
391
intel_dp_aux_vesa_setup_backlight(struct intel_connector * connector,enum pipe pipe)392 static int intel_dp_aux_vesa_setup_backlight(struct intel_connector *connector, enum pipe pipe)
393 {
394 struct intel_dp *intel_dp = intel_attached_dp(connector);
395 struct intel_panel *panel = &connector->panel;
396 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
397 u16 current_level;
398 u8 current_mode;
399 int ret;
400
401 ret = drm_edp_backlight_init(&intel_dp->aux, &panel->backlight.edp.vesa.info,
402 panel->vbt.backlight.pwm_freq_hz, intel_dp->edp_dpcd,
403 ¤t_level, ¤t_mode);
404 if (ret < 0)
405 return ret;
406
407 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] AUX VESA backlight enable is controlled through %s\n",
408 connector->base.base.id, connector->base.name,
409 dpcd_vs_pwm_str(panel->backlight.edp.vesa.info.aux_enable));
410 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] AUX VESA backlight level is controlled through %s\n",
411 connector->base.base.id, connector->base.name,
412 dpcd_vs_pwm_str(panel->backlight.edp.vesa.info.aux_set));
413
414 if (!panel->backlight.edp.vesa.info.aux_set || !panel->backlight.edp.vesa.info.aux_enable) {
415 ret = panel->backlight.pwm_funcs->setup(connector, pipe);
416 if (ret < 0) {
417 drm_err(&i915->drm,
418 "[CONNECTOR:%d:%s] Failed to setup PWM backlight controls for eDP backlight: %d\n",
419 connector->base.base.id, connector->base.name, ret);
420 return ret;
421 }
422 }
423
424 if (panel->backlight.edp.vesa.info.aux_set) {
425 panel->backlight.max = panel->backlight.edp.vesa.info.max;
426 panel->backlight.min = 0;
427 if (current_mode == DP_EDP_BACKLIGHT_CONTROL_MODE_DPCD) {
428 panel->backlight.level = current_level;
429 panel->backlight.enabled = panel->backlight.level != 0;
430 } else {
431 panel->backlight.level = panel->backlight.max;
432 panel->backlight.enabled = false;
433 }
434 } else {
435 panel->backlight.max = panel->backlight.pwm_level_max;
436 panel->backlight.min = panel->backlight.pwm_level_min;
437 if (current_mode == DP_EDP_BACKLIGHT_CONTROL_MODE_PWM) {
438 panel->backlight.level = panel->backlight.pwm_funcs->get(connector, pipe);
439 panel->backlight.enabled = panel->backlight.pwm_enabled;
440 } else {
441 panel->backlight.level = panel->backlight.max;
442 panel->backlight.enabled = false;
443 }
444 }
445
446 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] Using AUX VESA interface for backlight control\n",
447 connector->base.base.id, connector->base.name);
448
449 return 0;
450 }
451
452 static bool
intel_dp_aux_supports_vesa_backlight(struct intel_connector * connector)453 intel_dp_aux_supports_vesa_backlight(struct intel_connector *connector)
454 {
455 struct intel_dp *intel_dp = intel_attached_dp(connector);
456 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
457
458 if (drm_edp_backlight_supported(intel_dp->edp_dpcd)) {
459 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] AUX Backlight Control Supported!\n",
460 connector->base.base.id, connector->base.name);
461 return true;
462 }
463 return false;
464 }
465
466 static const struct intel_panel_bl_funcs intel_dp_hdr_bl_funcs = {
467 .setup = intel_dp_aux_hdr_setup_backlight,
468 .enable = intel_dp_aux_hdr_enable_backlight,
469 .disable = intel_dp_aux_hdr_disable_backlight,
470 .set = intel_dp_aux_hdr_set_backlight,
471 .get = intel_dp_aux_hdr_get_backlight,
472 };
473
474 static const struct intel_panel_bl_funcs intel_dp_vesa_bl_funcs = {
475 .setup = intel_dp_aux_vesa_setup_backlight,
476 .enable = intel_dp_aux_vesa_enable_backlight,
477 .disable = intel_dp_aux_vesa_disable_backlight,
478 .set = intel_dp_aux_vesa_set_backlight,
479 .get = intel_dp_aux_vesa_get_backlight,
480 };
481
intel_dp_aux_init_backlight_funcs(struct intel_connector * connector)482 int intel_dp_aux_init_backlight_funcs(struct intel_connector *connector)
483 {
484 struct drm_device *dev = connector->base.dev;
485 struct intel_panel *panel = &connector->panel;
486 struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
487 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
488 bool try_intel_interface = false, try_vesa_interface = false;
489
490 /* Check the VBT and user's module parameters to figure out which
491 * interfaces to probe
492 */
493 switch (i915->params.enable_dpcd_backlight) {
494 case INTEL_DP_AUX_BACKLIGHT_OFF:
495 return -ENODEV;
496 case INTEL_DP_AUX_BACKLIGHT_AUTO:
497 switch (panel->vbt.backlight.type) {
498 case INTEL_BACKLIGHT_VESA_EDP_AUX_INTERFACE:
499 try_vesa_interface = true;
500 break;
501 case INTEL_BACKLIGHT_DISPLAY_DDI:
502 try_intel_interface = true;
503 break;
504 default:
505 return -ENODEV;
506 }
507 break;
508 case INTEL_DP_AUX_BACKLIGHT_ON:
509 if (panel->vbt.backlight.type != INTEL_BACKLIGHT_VESA_EDP_AUX_INTERFACE)
510 try_intel_interface = true;
511
512 try_vesa_interface = true;
513 break;
514 case INTEL_DP_AUX_BACKLIGHT_FORCE_VESA:
515 try_vesa_interface = true;
516 break;
517 case INTEL_DP_AUX_BACKLIGHT_FORCE_INTEL:
518 try_intel_interface = true;
519 break;
520 }
521
522 /*
523 * Since Intel has their own backlight control interface, the majority of machines out there
524 * using DPCD backlight controls with Intel GPUs will be using this interface as opposed to
525 * the VESA interface. However, other GPUs (such as Nvidia's) will always use the VESA
526 * interface. This means that there's quite a number of panels out there that will advertise
527 * support for both interfaces, primarily systems with Intel/Nvidia hybrid GPU setups.
528 *
529 * There's a catch to this though: on many panels that advertise support for both
530 * interfaces, the VESA backlight interface will stop working once we've programmed the
531 * panel with Intel's OUI - which is also required for us to be able to detect Intel's
532 * backlight interface at all. This means that the only sensible way for us to detect both
533 * interfaces is to probe for Intel's first, and VESA's second.
534 */
535 if (try_intel_interface && intel_dp_aux_supports_hdr_backlight(connector)) {
536 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Using Intel proprietary eDP backlight controls\n",
537 connector->base.base.id, connector->base.name);
538 panel->backlight.funcs = &intel_dp_hdr_bl_funcs;
539 return 0;
540 }
541
542 if (try_vesa_interface && intel_dp_aux_supports_vesa_backlight(connector)) {
543 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Using VESA eDP backlight controls\n",
544 connector->base.base.id, connector->base.name);
545 panel->backlight.funcs = &intel_dp_vesa_bl_funcs;
546 return 0;
547 }
548
549 return -ENODEV;
550 }
551