xref: /linux/drivers/gpu/drm/i915/display/intel_display_debugfs.c (revision cb8fef4b07f71da01843457b66e579ad248a625e)
1 // SPDX-License-Identifier: MIT
2 /*
3  * Copyright © 2020 Intel Corporation
4  */
5 
6 #include <linux/debugfs.h>
7 #include <linux/string_choices.h>
8 #include <linux/string_helpers.h>
9 
10 #include <drm/drm_debugfs.h>
11 #include <drm/drm_drv.h>
12 #include <drm/drm_edid.h>
13 #include <drm/drm_file.h>
14 #include <drm/drm_fourcc.h>
15 #include <drm/drm_print.h>
16 #include <drm/intel/intel_gmd_misc_regs.h>
17 
18 #include "hsw_ips.h"
19 #include "i9xx_wm_regs.h"
20 #include "intel_alpm.h"
21 #include "intel_bo.h"
22 #include "intel_crtc.h"
23 #include "intel_crtc_state_dump.h"
24 #include "intel_de.h"
25 #include "intel_display_debugfs.h"
26 #include "intel_display_debugfs_params.h"
27 #include "intel_display_power.h"
28 #include "intel_display_power_well.h"
29 #include "intel_display_regs.h"
30 #include "intel_display_reset.h"
31 #include "intel_display_rpm.h"
32 #include "intel_display_types.h"
33 #include "intel_dmc.h"
34 #include "intel_dp.h"
35 #include "intel_dp_link_caps.h"
36 #include "intel_dp_link_training.h"
37 #include "intel_dp_mst.h"
38 #include "intel_dp_test.h"
39 #include "intel_drrs.h"
40 #include "intel_fb.h"
41 #include "intel_fbc.h"
42 #include "intel_fbdev.h"
43 #include "intel_hdcp.h"
44 #include "intel_hdmi.h"
45 #include "intel_hotplug.h"
46 #include "intel_link_bw.h"
47 #include "intel_panel.h"
48 #include "intel_pps.h"
49 #include "intel_psr.h"
50 #include "intel_psr_regs.h"
51 #include "intel_vdsc.h"
52 #include "intel_vrr.h"
53 #include "intel_wm.h"
54 #include "intel_tc.h"
55 
56 static struct intel_display *node_to_intel_display(struct drm_info_node *node)
57 {
58 	return to_intel_display(node->minor->dev);
59 }
60 
61 static int intel_display_caps(struct seq_file *m, void *data)
62 {
63 	struct intel_display *display = node_to_intel_display(m->private);
64 	struct drm_printer p = drm_seq_file_printer(m);
65 
66 	drm_printf(&p, "PCH type: %d\n", INTEL_PCH_TYPE(display));
67 
68 	intel_display_device_info_print(DISPLAY_INFO(display),
69 					DISPLAY_RUNTIME_INFO(display), &p);
70 	intel_display_params_dump(&display->params, display->drm->driver->name, &p);
71 
72 	return 0;
73 }
74 
75 static int i915_frontbuffer_tracking(struct seq_file *m, void *unused)
76 {
77 	struct intel_display *display = node_to_intel_display(m->private);
78 
79 	spin_lock(&display->fb_tracking.lock);
80 
81 	seq_printf(m, "FB tracking busy bits: 0x%08x\n",
82 		   display->fb_tracking.busy_bits);
83 
84 	spin_unlock(&display->fb_tracking.lock);
85 
86 	return 0;
87 }
88 
89 static int i915_sr_status(struct seq_file *m, void *unused)
90 {
91 	struct intel_display *display = node_to_intel_display(m->private);
92 	struct ref_tracker *wakeref;
93 	bool sr_enabled = false;
94 
95 	wakeref = intel_display_power_get(display, POWER_DOMAIN_INIT);
96 
97 	if (DISPLAY_VER(display) >= 9)
98 		/* no global SR status; inspect per-plane WM */;
99 	else if (HAS_PCH_SPLIT(display))
100 		sr_enabled = intel_de_read(display, WM1_LP_ILK) & WM_LP_ENABLE;
101 	else if (display->platform.i965gm || display->platform.g4x ||
102 		 display->platform.i945g || display->platform.i945gm)
103 		sr_enabled = intel_de_read(display, FW_BLC_SELF) & FW_BLC_SELF_EN;
104 	else if (display->platform.i915gm)
105 		sr_enabled = intel_de_read(display, INSTPM) & INSTPM_SELF_EN;
106 	else if (display->platform.pineview)
107 		sr_enabled = intel_de_read(display, DSPFW3(display)) & PINEVIEW_SELF_REFRESH_EN;
108 	else if (display->platform.valleyview || display->platform.cherryview)
109 		sr_enabled = intel_de_read(display, FW_BLC_SELF_VLV) & FW_CSPWRDWNEN;
110 
111 	intel_display_power_put(display, POWER_DOMAIN_INIT, wakeref);
112 
113 	seq_printf(m, "self-refresh: %s\n", str_enabled_disabled(sr_enabled));
114 
115 	return 0;
116 }
117 
118 static int i915_gem_framebuffer_info(struct seq_file *m, void *data)
119 {
120 	struct intel_display *display = node_to_intel_display(m->private);
121 	struct intel_framebuffer *fbdev_fb = NULL;
122 	struct drm_framebuffer *drm_fb;
123 
124 	fbdev_fb = intel_fbdev_framebuffer(display->fbdev.fbdev);
125 	if (fbdev_fb) {
126 		seq_printf(m, "fbcon size: %d x %d, depth %d, %d bpp, modifier 0x%llx, refcount %d, obj ",
127 			   fbdev_fb->base.width,
128 			   fbdev_fb->base.height,
129 			   fbdev_fb->base.format->depth,
130 			   fbdev_fb->base.format->cpp[0] * 8,
131 			   fbdev_fb->base.modifier,
132 			   drm_framebuffer_read_refcount(&fbdev_fb->base));
133 		intel_bo_describe(m, intel_fb_bo(&fbdev_fb->base));
134 		seq_putc(m, '\n');
135 	}
136 
137 	mutex_lock(&display->drm->mode_config.fb_lock);
138 	drm_for_each_fb(drm_fb, display->drm) {
139 		struct intel_framebuffer *fb = to_intel_framebuffer(drm_fb);
140 		if (fb == fbdev_fb)
141 			continue;
142 
143 		seq_printf(m, "user size: %d x %d, depth %d, %d bpp, modifier 0x%llx, refcount %d, obj ",
144 			   fb->base.width,
145 			   fb->base.height,
146 			   fb->base.format->depth,
147 			   fb->base.format->cpp[0] * 8,
148 			   fb->base.modifier,
149 			   drm_framebuffer_read_refcount(&fb->base));
150 		intel_bo_describe(m, intel_fb_bo(&fb->base));
151 		seq_putc(m, '\n');
152 	}
153 	mutex_unlock(&display->drm->mode_config.fb_lock);
154 
155 	return 0;
156 }
157 
158 static int i915_power_domain_info(struct seq_file *m, void *unused)
159 {
160 	struct intel_display *display = node_to_intel_display(m->private);
161 
162 	intel_display_power_debug(display, m);
163 
164 	return 0;
165 }
166 
167 static void intel_seq_print_mode(struct seq_file *m, int tabs,
168 				 const struct drm_display_mode *mode)
169 {
170 	int i;
171 
172 	for (i = 0; i < tabs; i++)
173 		seq_putc(m, '\t');
174 
175 	seq_printf(m, DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
176 }
177 
178 static void intel_encoder_info(struct seq_file *m,
179 			       struct intel_crtc *crtc,
180 			       struct intel_encoder *encoder)
181 {
182 	struct intel_display *display = node_to_intel_display(m->private);
183 	struct drm_connector_list_iter conn_iter;
184 	struct drm_connector *connector;
185 
186 	seq_printf(m, "\t[ENCODER:%d:%s]: connectors:\n",
187 		   encoder->base.base.id, encoder->base.name);
188 
189 	drm_connector_list_iter_begin(display->drm, &conn_iter);
190 	drm_for_each_connector_iter(connector, &conn_iter) {
191 		const struct drm_connector_state *conn_state =
192 			connector->state;
193 
194 		if (conn_state->best_encoder != &encoder->base)
195 			continue;
196 
197 		seq_printf(m, "\t\t[CONNECTOR:%d:%s]\n",
198 			   connector->base.id, connector->name);
199 	}
200 	drm_connector_list_iter_end(&conn_iter);
201 }
202 
203 static void intel_panel_info(struct seq_file *m,
204 			     struct intel_connector *connector)
205 {
206 	const struct drm_display_mode *fixed_mode;
207 
208 	if (list_empty(&connector->panel.fixed_modes))
209 		return;
210 
211 	seq_puts(m, "\tfixed modes:\n");
212 
213 	list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head)
214 		intel_seq_print_mode(m, 2, fixed_mode);
215 }
216 
217 static void intel_dp_info(struct seq_file *m, struct intel_connector *connector)
218 {
219 	struct intel_encoder *intel_encoder = intel_attached_encoder(connector);
220 	struct intel_dp *intel_dp = enc_to_intel_dp(intel_encoder);
221 
222 	seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]);
223 	seq_printf(m, "\taudio support: %s\n",
224 		   str_yes_no(connector->base.display_info.has_audio));
225 
226 	drm_dp_downstream_debug(m, intel_dp->dpcd, intel_dp->downstream_ports,
227 				connector->detect_edid, &intel_dp->aux);
228 }
229 
230 static void intel_dp_mst_info(struct seq_file *m,
231 			      struct intel_connector *connector)
232 {
233 	bool has_audio = connector->base.display_info.has_audio;
234 
235 	seq_printf(m, "\taudio support: %s\n", str_yes_no(has_audio));
236 }
237 
238 static void intel_hdmi_info(struct seq_file *m,
239 			    struct intel_connector *connector)
240 {
241 	bool has_audio = connector->base.display_info.has_audio;
242 
243 	seq_printf(m, "\taudio support: %s\n", str_yes_no(has_audio));
244 }
245 
246 static void intel_connector_info(struct seq_file *m,
247 				 struct drm_connector *connector)
248 {
249 	struct intel_connector *intel_connector = to_intel_connector(connector);
250 	const struct drm_display_mode *mode;
251 	struct drm_printer p = drm_seq_file_printer(m);
252 	struct intel_digital_port *dig_port = NULL;
253 
254 	seq_printf(m, "[CONNECTOR:%d:%s]: status: %s\n",
255 		   connector->base.id, connector->name,
256 		   drm_get_connector_status_name(connector->status));
257 
258 	if (connector->status == connector_status_disconnected)
259 		return;
260 
261 	seq_printf(m, "\tphysical dimensions: %dx%dmm\n",
262 		   connector->display_info.width_mm,
263 		   connector->display_info.height_mm);
264 	seq_printf(m, "\tsubpixel order: %s\n",
265 		   drm_get_subpixel_order_name(connector->display_info.subpixel_order));
266 	seq_printf(m, "\tCEA rev: %d\n", connector->display_info.cea_rev);
267 
268 	switch (connector->connector_type) {
269 	case DRM_MODE_CONNECTOR_DisplayPort:
270 	case DRM_MODE_CONNECTOR_eDP:
271 		if (intel_connector->mst.dp)
272 			intel_dp_mst_info(m, intel_connector);
273 		else
274 			intel_dp_info(m, intel_connector);
275 		dig_port = dp_to_dig_port(intel_attached_dp(intel_connector));
276 		break;
277 	case DRM_MODE_CONNECTOR_HDMIA:
278 		intel_hdmi_info(m, intel_connector);
279 		dig_port = hdmi_to_dig_port(intel_attached_hdmi(intel_connector));
280 		break;
281 	default:
282 		break;
283 	}
284 
285 	if (dig_port != NULL && intel_encoder_is_tc(&dig_port->base))
286 		intel_tc_info(&p, dig_port);
287 
288 	intel_hdcp_info(m, intel_connector);
289 
290 	seq_printf(m, "\tmax bpc: %u\n", connector->display_info.bpc);
291 
292 	intel_panel_info(m, intel_connector);
293 
294 	seq_printf(m, "\tmodes:\n");
295 	list_for_each_entry(mode, &connector->modes, head)
296 		intel_seq_print_mode(m, 2, mode);
297 }
298 
299 static const char *plane_type(enum drm_plane_type type)
300 {
301 	switch (type) {
302 	case DRM_PLANE_TYPE_OVERLAY:
303 		return "OVL";
304 	case DRM_PLANE_TYPE_PRIMARY:
305 		return "PRI";
306 	case DRM_PLANE_TYPE_CURSOR:
307 		return "CUR";
308 	/*
309 	 * Deliberately omitting default: to generate compiler warnings
310 	 * when a new drm_plane_type gets added.
311 	 */
312 	}
313 
314 	return "unknown";
315 }
316 
317 static void plane_rotation(char *buf, size_t bufsize, unsigned int rotation)
318 {
319 	/*
320 	 * According to doc only one DRM_MODE_ROTATE_ is allowed but this
321 	 * will print them all to visualize if the values are misused
322 	 */
323 	snprintf(buf, bufsize,
324 		 "%s%s%s%s%s%s(0x%08x)",
325 		 (rotation & DRM_MODE_ROTATE_0) ? "0 " : "",
326 		 (rotation & DRM_MODE_ROTATE_90) ? "90 " : "",
327 		 (rotation & DRM_MODE_ROTATE_180) ? "180 " : "",
328 		 (rotation & DRM_MODE_ROTATE_270) ? "270 " : "",
329 		 (rotation & DRM_MODE_REFLECT_X) ? "FLIPX " : "",
330 		 (rotation & DRM_MODE_REFLECT_Y) ? "FLIPY " : "",
331 		 rotation);
332 }
333 
334 static const char *plane_visibility(const struct intel_plane_state *plane_state)
335 {
336 	if (plane_state->uapi.visible)
337 		return "visible";
338 
339 	if (plane_state->is_y_plane)
340 		return "Y plane";
341 
342 	return "hidden";
343 }
344 
345 static void intel_plane_uapi_info(struct seq_file *m, struct intel_plane *plane)
346 {
347 	const struct intel_plane_state *plane_state =
348 		to_intel_plane_state(plane->base.state);
349 	const struct drm_framebuffer *fb = plane_state->uapi.fb;
350 	struct drm_rect src, dst;
351 	char rot_str[48];
352 
353 	src = drm_plane_state_src(&plane_state->uapi);
354 	dst = drm_plane_state_dest(&plane_state->uapi);
355 
356 	plane_rotation(rot_str, sizeof(rot_str),
357 		       plane_state->uapi.rotation);
358 
359 	seq_puts(m, "\t\tuapi: [FB:");
360 	if (fb)
361 		seq_printf(m, "%d] %p4cc,0x%llx,%dx%d", fb->base.id,
362 			   &fb->format->format, fb->modifier, fb->width,
363 			   fb->height);
364 	else
365 		seq_puts(m, "0] n/a,0x0,0x0,");
366 	seq_printf(m, ", visible=%s, src=" DRM_RECT_FP_FMT ", dst=" DRM_RECT_FMT
367 		   ", rotation=%s\n", plane_visibility(plane_state),
368 		   DRM_RECT_FP_ARG(&src), DRM_RECT_ARG(&dst), rot_str);
369 
370 	if (plane_state->planar_linked_plane)
371 		seq_printf(m, "\t\tplanar: Linked to [PLANE:%d:%s] as a %s\n",
372 			   plane_state->planar_linked_plane->base.base.id, plane_state->planar_linked_plane->base.name,
373 			   plane_state->is_y_plane ? "Y plane" : "UV plane");
374 }
375 
376 static void intel_plane_hw_info(struct seq_file *m, struct intel_plane *plane)
377 {
378 	const struct intel_plane_state *plane_state =
379 		to_intel_plane_state(plane->base.state);
380 	const struct drm_framebuffer *fb = plane_state->hw.fb;
381 	char rot_str[48];
382 
383 	if (!fb)
384 		return;
385 
386 	plane_rotation(rot_str, sizeof(rot_str),
387 		       plane_state->hw.rotation);
388 
389 	seq_printf(m, "\t\thw: [FB:%d] %p4cc,0x%llx,%dx%d, visible=%s, src="
390 		   DRM_RECT_FP_FMT ", dst=" DRM_RECT_FMT ", rotation=%s\n",
391 		   fb->base.id, &fb->format->format,
392 		   fb->modifier, fb->width, fb->height,
393 		   str_yes_no(plane_state->uapi.visible),
394 		   DRM_RECT_FP_ARG(&plane_state->uapi.src),
395 		   DRM_RECT_ARG(&plane_state->uapi.dst),
396 		   rot_str);
397 }
398 
399 static void intel_plane_info(struct seq_file *m, struct intel_crtc *crtc)
400 {
401 	struct intel_display *display = node_to_intel_display(m->private);
402 	struct intel_plane *plane;
403 
404 	for_each_intel_plane_on_crtc(display->drm, crtc, plane) {
405 		seq_printf(m, "\t[PLANE:%d:%s]: type=%s\n",
406 			   plane->base.base.id, plane->base.name,
407 			   plane_type(plane->base.type));
408 		intel_plane_uapi_info(m, plane);
409 		intel_plane_hw_info(m, plane);
410 	}
411 }
412 
413 static void intel_scaler_info(struct seq_file *m, struct intel_crtc *crtc)
414 {
415 	const struct intel_crtc_state *crtc_state =
416 		to_intel_crtc_state(crtc->base.state);
417 	int num_scalers = crtc->num_scalers;
418 	int i;
419 
420 	/* Not all platforms have a scaler */
421 	if (num_scalers) {
422 		seq_printf(m, "\tnum_scalers=%d, scaler_users=%x scaler_id=%d scaling_filter=%d sharpness_strength=%d",
423 			   num_scalers,
424 			   crtc_state->scaler_state.scaler_users,
425 			   crtc_state->scaler_state.scaler_id,
426 			   crtc_state->hw.scaling_filter,
427 			   crtc_state->hw.sharpness_strength);
428 
429 		for (i = 0; i < num_scalers; i++) {
430 			const struct intel_scaler *sc =
431 				&crtc_state->scaler_state.scalers[i];
432 
433 			seq_printf(m, ", scalers[%d]: use=%s, mode=%x",
434 				   i, str_yes_no(sc->in_use), sc->mode);
435 		}
436 		seq_puts(m, "\n");
437 	} else {
438 		seq_puts(m, "\tNo scalers available on this platform\n");
439 	}
440 }
441 
442 #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_VBLANK_EVADE)
443 static void crtc_updates_info(struct seq_file *m,
444 			      struct intel_crtc *crtc,
445 			      const char *hdr)
446 {
447 	u64 count;
448 	int row;
449 
450 	count = 0;
451 	for (row = 0; row < ARRAY_SIZE(crtc->debug.vbl.times); row++)
452 		count += crtc->debug.vbl.times[row];
453 	seq_printf(m, "%sUpdates: %llu\n", hdr, count);
454 	if (!count)
455 		return;
456 
457 	for (row = 0; row < ARRAY_SIZE(crtc->debug.vbl.times); row++) {
458 		char columns[80] = "       |";
459 		unsigned int x;
460 
461 		if (row & 1) {
462 			const char *units;
463 
464 			if (row > 10) {
465 				x = 1000000;
466 				units = "ms";
467 			} else {
468 				x = 1000;
469 				units = "us";
470 			}
471 
472 			snprintf(columns, sizeof(columns), "%4ld%s |",
473 				 DIV_ROUND_CLOSEST(BIT(row + 9), x), units);
474 		}
475 
476 		if (crtc->debug.vbl.times[row]) {
477 			x = ilog2(crtc->debug.vbl.times[row]);
478 			memset(columns + 8, '*', x);
479 			columns[8 + x] = '\0';
480 		}
481 
482 		seq_printf(m, "%s%s\n", hdr, columns);
483 	}
484 
485 	seq_printf(m, "%sMin update: %lluns\n",
486 		   hdr, crtc->debug.vbl.min);
487 	seq_printf(m, "%sMax update: %lluns\n",
488 		   hdr, crtc->debug.vbl.max);
489 	seq_printf(m, "%sAverage update: %lluns\n",
490 		   hdr, div64_u64(crtc->debug.vbl.sum, count));
491 	seq_printf(m, "%sOverruns > %uus: %u\n",
492 		   hdr, VBLANK_EVASION_TIME_US, crtc->debug.vbl.over);
493 }
494 
495 static int crtc_updates_show(struct seq_file *m, void *data)
496 {
497 	crtc_updates_info(m, m->private, "");
498 	return 0;
499 }
500 
501 static int crtc_updates_open(struct inode *inode, struct file *file)
502 {
503 	return single_open(file, crtc_updates_show, inode->i_private);
504 }
505 
506 static ssize_t crtc_updates_write(struct file *file,
507 				  const char __user *ubuf,
508 				  size_t len, loff_t *offp)
509 {
510 	struct seq_file *m = file->private_data;
511 	struct intel_crtc *crtc = m->private;
512 
513 	/* May race with an update. Meh. */
514 	memset(&crtc->debug.vbl, 0, sizeof(crtc->debug.vbl));
515 
516 	return len;
517 }
518 
519 static const struct file_operations crtc_updates_fops = {
520 	.owner = THIS_MODULE,
521 	.open = crtc_updates_open,
522 	.read = seq_read,
523 	.llseek = seq_lseek,
524 	.release = single_release,
525 	.write = crtc_updates_write
526 };
527 
528 static void crtc_updates_add(struct intel_crtc *crtc)
529 {
530 	debugfs_create_file("i915_update_info", 0644, crtc->base.debugfs_entry,
531 			    crtc, &crtc_updates_fops);
532 }
533 
534 #else
535 static void crtc_updates_info(struct seq_file *m,
536 			      struct intel_crtc *crtc,
537 			      const char *hdr)
538 {
539 }
540 
541 static void crtc_updates_add(struct intel_crtc *crtc)
542 {
543 }
544 #endif
545 
546 static void intel_crtc_info(struct seq_file *m, struct intel_crtc *crtc)
547 {
548 	struct intel_display *display = node_to_intel_display(m->private);
549 	struct drm_printer p = drm_seq_file_printer(m);
550 	const struct intel_crtc_state *crtc_state =
551 		to_intel_crtc_state(crtc->base.state);
552 	struct intel_encoder *encoder;
553 
554 	seq_printf(m, "[CRTC:%d:%s]:\n",
555 		   crtc->base.base.id, crtc->base.name);
556 
557 	seq_printf(m, "\tuapi: enable=%s, active=%s, mode=" DRM_MODE_FMT "\n",
558 		   str_yes_no(crtc_state->uapi.enable),
559 		   str_yes_no(crtc_state->uapi.active),
560 		   DRM_MODE_ARG(&crtc_state->uapi.mode));
561 
562 	seq_printf(m, "\thw: enable=%s, active=%s\n",
563 		   str_yes_no(crtc_state->hw.enable), str_yes_no(crtc_state->hw.active));
564 	seq_printf(m, "\tadjusted_mode=" DRM_MODE_FMT "\n",
565 		   DRM_MODE_ARG(&crtc_state->hw.adjusted_mode));
566 	seq_printf(m, "\tpipe__mode=" DRM_MODE_FMT "\n",
567 		   DRM_MODE_ARG(&crtc_state->hw.pipe_mode));
568 
569 	seq_printf(m, "\tpipe src=" DRM_RECT_FMT ", dither=%s, bpp=%d\n",
570 		   DRM_RECT_ARG(&crtc_state->pipe_src),
571 		   str_yes_no(crtc_state->dither), crtc_state->pipe_bpp);
572 	seq_printf(m, "\tport_clock=%d, lane_count=%d\n",
573 		   crtc_state->port_clock, crtc_state->lane_count);
574 
575 	intel_scaler_info(m, crtc);
576 
577 	if (DISPLAY_VER(display) >= 9) {
578 		u32 background = crtc_state->hw.background_color;
579 
580 		seq_printf(m, "\tbackground color (10bpc XRGB2101010): %08x\n", background);
581 	}
582 
583 	if (crtc_state->joiner_pipes)
584 		seq_printf(m, "\tLinked to 0x%x pipes as a %s\n",
585 			   crtc_state->joiner_pipes,
586 			   intel_crtc_is_joiner_secondary(crtc_state) ? "slave" : "master");
587 
588 	intel_vdsc_state_dump(&p, 1, crtc_state);
589 
590 	for_each_intel_encoder_mask(display->drm, encoder,
591 				    crtc_state->uapi.encoder_mask)
592 		intel_encoder_info(m, crtc, encoder);
593 
594 	intel_plane_info(m, crtc);
595 
596 	seq_printf(m, "\tunderrun reporting: cpu=%s pch=%s\n",
597 		   str_yes_no(!crtc->cpu_fifo_underrun_disabled),
598 		   str_yes_no(!crtc->pch_fifo_underrun_disabled));
599 
600 	crtc_updates_info(m, crtc, "\t");
601 }
602 
603 static int i915_display_info(struct seq_file *m, void *unused)
604 {
605 	struct intel_display *display = node_to_intel_display(m->private);
606 	struct intel_crtc *crtc;
607 	struct drm_connector *connector;
608 	struct drm_connector_list_iter conn_iter;
609 	struct ref_tracker *wakeref;
610 
611 	wakeref = intel_display_rpm_get(display);
612 
613 	drm_modeset_lock_all(display->drm);
614 
615 	seq_printf(m, "CRTC info\n");
616 	seq_printf(m, "---------\n");
617 	for_each_intel_crtc(display, crtc)
618 		intel_crtc_info(m, crtc);
619 
620 	seq_printf(m, "\n");
621 	seq_printf(m, "Connector info\n");
622 	seq_printf(m, "--------------\n");
623 	drm_connector_list_iter_begin(display->drm, &conn_iter);
624 	drm_for_each_connector_iter(connector, &conn_iter)
625 		intel_connector_info(m, connector);
626 	drm_connector_list_iter_end(&conn_iter);
627 
628 	drm_modeset_unlock_all(display->drm);
629 
630 	intel_display_rpm_put(display, wakeref);
631 
632 	return 0;
633 }
634 
635 static int i915_shared_dplls_info(struct seq_file *m, void *unused)
636 {
637 	struct intel_display *display = node_to_intel_display(m->private);
638 	struct drm_printer p = drm_seq_file_printer(m);
639 	struct intel_dpll *pll;
640 	int i;
641 
642 	drm_modeset_lock_all(display->drm);
643 
644 	drm_printf(&p, "PLL refclks: non-SSC: %d kHz, SSC: %d kHz\n",
645 		   display->dpll.ref_clks.nssc,
646 		   display->dpll.ref_clks.ssc);
647 
648 	for_each_dpll(display, pll, i) {
649 		drm_printf(&p, "DPLL%i: %s, id: %i\n", pll->index,
650 			   pll->info->name, pll->info->id);
651 		drm_printf(&p, " pipe_mask: 0x%x, active: 0x%x, on: %s\n",
652 			   pll->state.pipe_mask, pll->active_mask,
653 			   str_yes_no(pll->on));
654 		drm_printf(&p, " tracked hardware state:\n");
655 		intel_dpll_dump_hw_state(display, &p, &pll->state.hw_state);
656 	}
657 	drm_modeset_unlock_all(display->drm);
658 
659 	return 0;
660 }
661 
662 static int i915_ddb_info(struct seq_file *m, void *unused)
663 {
664 	struct intel_display *display = node_to_intel_display(m->private);
665 	struct skl_ddb_entry *entry;
666 	struct intel_crtc *crtc;
667 
668 	if (DISPLAY_VER(display) < 9)
669 		return -ENODEV;
670 
671 	drm_modeset_lock_all(display->drm);
672 
673 	seq_printf(m, "%-15s%8s%8s%8s\n", "", "Start", "End", "Size");
674 
675 	for_each_intel_crtc(display, crtc) {
676 		struct intel_crtc_state *crtc_state =
677 			to_intel_crtc_state(crtc->base.state);
678 		enum pipe pipe = crtc->pipe;
679 		enum plane_id plane_id;
680 
681 		seq_printf(m, "Pipe %c\n", pipe_name(pipe));
682 
683 		for_each_plane_id_on_crtc(crtc, plane_id) {
684 			entry = &crtc_state->wm.skl.plane_ddb[plane_id];
685 			seq_printf(m, "  Plane%-8d%8u%8u%8u\n", plane_id + 1,
686 				   entry->start, entry->end,
687 				   skl_ddb_entry_size(entry));
688 		}
689 
690 		entry = &crtc_state->wm.skl.plane_ddb[PLANE_CURSOR];
691 		seq_printf(m, "  %-13s%8u%8u%8u\n", "Cursor", entry->start,
692 			   entry->end, skl_ddb_entry_size(entry));
693 	}
694 
695 	drm_modeset_unlock_all(display->drm);
696 
697 	return 0;
698 }
699 
700 static bool
701 intel_lpsp_power_well_enabled(struct intel_display *display,
702 			      enum i915_power_well_id power_well_id)
703 {
704 	bool is_enabled;
705 
706 	with_intel_display_rpm(display)
707 		is_enabled = intel_display_power_well_is_enabled(display,
708 								 power_well_id);
709 
710 	return is_enabled;
711 }
712 
713 static int i915_lpsp_status(struct seq_file *m, void *unused)
714 {
715 	struct intel_display *display = node_to_intel_display(m->private);
716 	bool lpsp_enabled = false;
717 
718 	if (DISPLAY_VER(display) >= 13 || IS_DISPLAY_VER(display, 9, 10)) {
719 		lpsp_enabled = !intel_lpsp_power_well_enabled(display, SKL_DISP_PW_2);
720 	} else if (IS_DISPLAY_VER(display, 11, 12)) {
721 		lpsp_enabled = !intel_lpsp_power_well_enabled(display, ICL_DISP_PW_3);
722 	} else if (display->platform.haswell || display->platform.broadwell) {
723 		lpsp_enabled = !intel_lpsp_power_well_enabled(display, HSW_DISP_PW_GLOBAL);
724 	} else {
725 		seq_puts(m, "LPSP: not supported\n");
726 		return 0;
727 	}
728 
729 	seq_printf(m, "LPSP: %s\n", str_enabled_disabled(lpsp_enabled));
730 
731 	return 0;
732 }
733 
734 static int i915_dp_mst_info(struct seq_file *m, void *unused)
735 {
736 	struct intel_display *display = node_to_intel_display(m->private);
737 	struct intel_encoder *intel_encoder;
738 	struct intel_digital_port *dig_port;
739 	struct drm_connector *connector;
740 	struct drm_connector_list_iter conn_iter;
741 
742 	drm_connector_list_iter_begin(display->drm, &conn_iter);
743 	drm_for_each_connector_iter(connector, &conn_iter) {
744 		if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
745 			continue;
746 
747 		intel_encoder = intel_attached_encoder(to_intel_connector(connector));
748 		if (!intel_encoder || intel_encoder->type == INTEL_OUTPUT_DP_MST)
749 			continue;
750 
751 		dig_port = enc_to_dig_port(intel_encoder);
752 		if (!intel_dp_mst_source_support(&dig_port->dp))
753 			continue;
754 
755 		seq_printf(m, "MST Source Port [ENCODER:%d:%s]\n",
756 			   dig_port->base.base.base.id,
757 			   dig_port->base.base.name);
758 		drm_dp_mst_dump_topology(m, &dig_port->dp.mst.mgr);
759 	}
760 	drm_connector_list_iter_end(&conn_iter);
761 
762 	return 0;
763 }
764 
765 static ssize_t
766 i915_fifo_underrun_reset_write(struct file *filp,
767 			       const char __user *ubuf,
768 			       size_t cnt, loff_t *ppos)
769 {
770 	struct intel_display *display = filp->private_data;
771 	struct intel_crtc *crtc;
772 	int ret;
773 	bool reset;
774 
775 	ret = kstrtobool_from_user(ubuf, cnt, &reset);
776 	if (ret)
777 		return ret;
778 
779 	if (!reset)
780 		return cnt;
781 
782 	for_each_intel_crtc(display, crtc) {
783 		struct drm_crtc_commit *commit;
784 		struct intel_crtc_state *crtc_state;
785 
786 		ret = drm_modeset_lock_single_interruptible(&crtc->base.mutex);
787 		if (ret)
788 			return ret;
789 
790 		crtc_state = to_intel_crtc_state(crtc->base.state);
791 		commit = crtc_state->uapi.commit;
792 		if (commit) {
793 			ret = wait_for_completion_interruptible(&commit->hw_done);
794 			if (!ret)
795 				ret = wait_for_completion_interruptible(&commit->flip_done);
796 		}
797 
798 		if (!ret && crtc_state->hw.active) {
799 			drm_dbg_kms(display->drm,
800 				    "Re-arming FIFO underruns on pipe %c\n",
801 				    pipe_name(crtc->pipe));
802 
803 			intel_crtc_arm_fifo_underrun(crtc, crtc_state);
804 		}
805 
806 		drm_modeset_unlock(&crtc->base.mutex);
807 
808 		if (ret)
809 			return ret;
810 	}
811 
812 	intel_fbc_reset_underrun(display);
813 
814 	return cnt;
815 }
816 
817 static const struct file_operations i915_fifo_underrun_reset_ops = {
818 	.owner = THIS_MODULE,
819 	.open = simple_open,
820 	.write = i915_fifo_underrun_reset_write,
821 	.llseek = default_llseek,
822 };
823 
824 static const struct drm_info_list intel_display_debugfs_list[] = {
825 	{"intel_display_caps", intel_display_caps, 0},
826 	{"i915_frontbuffer_tracking", i915_frontbuffer_tracking, 0},
827 	{"i915_sr_status", i915_sr_status, 0},
828 	{"i915_gem_framebuffer", i915_gem_framebuffer_info, 0},
829 	{"i915_power_domain_info", i915_power_domain_info, 0},
830 	{"i915_display_info", i915_display_info, 0},
831 	{"i915_shared_dplls_info", i915_shared_dplls_info, 0},
832 	{"i915_dp_mst_info", i915_dp_mst_info, 0},
833 	{"i915_ddb_info", i915_ddb_info, 0},
834 	{"i915_lpsp_status", i915_lpsp_status, 0},
835 };
836 
837 void intel_display_debugfs_register(struct intel_display *display)
838 {
839 	struct dentry *debugfs_root = display->drm->debugfs_root;
840 
841 	debugfs_create_file("i915_fifo_underrun_reset", 0644, debugfs_root,
842 			    display, &i915_fifo_underrun_reset_ops);
843 
844 	drm_debugfs_create_files(intel_display_debugfs_list,
845 				 ARRAY_SIZE(intel_display_debugfs_list),
846 				 debugfs_root, display->drm->primary);
847 
848 	intel_bios_debugfs_register(display);
849 	intel_cdclk_debugfs_register(display);
850 	intel_display_reset_debugfs_register(display);
851 	intel_dmc_debugfs_register(display);
852 	intel_dp_test_debugfs_register(display);
853 	intel_fbc_debugfs_register(display);
854 	intel_hpd_debugfs_register(display);
855 	intel_opregion_debugfs_register(display);
856 	intel_psr_debugfs_register(display);
857 	intel_wm_debugfs_register(display);
858 	intel_display_debugfs_params(display);
859 }
860 
861 static int i915_lpsp_capability_show(struct seq_file *m, void *data)
862 {
863 	struct intel_connector *connector = m->private;
864 	struct intel_display *display = to_intel_display(connector);
865 	struct intel_encoder *encoder = intel_attached_encoder(connector);
866 	int connector_type = connector->base.connector_type;
867 	bool lpsp_capable = false;
868 
869 	if (!encoder)
870 		return -ENODEV;
871 
872 	if (connector->base.status != connector_status_connected)
873 		return -ENODEV;
874 
875 	if (DISPLAY_VER(display) >= 13)
876 		lpsp_capable = encoder->port <= PORT_B;
877 	else if (DISPLAY_VER(display) >= 12)
878 		/*
879 		 * Actually TGL can drive LPSP on port till DDI_C
880 		 * but there is no physical connected DDI_C on TGL sku's,
881 		 * even driver is not initializing DDI_C port for gen12.
882 		 */
883 		lpsp_capable = encoder->port <= PORT_B;
884 	else if (DISPLAY_VER(display) == 11)
885 		lpsp_capable = (connector_type == DRM_MODE_CONNECTOR_DSI ||
886 				connector_type == DRM_MODE_CONNECTOR_eDP);
887 	else if (IS_DISPLAY_VER(display, 9, 10))
888 		lpsp_capable = (encoder->port == PORT_A &&
889 				(connector_type == DRM_MODE_CONNECTOR_DSI ||
890 				 connector_type == DRM_MODE_CONNECTOR_eDP ||
891 				 connector_type == DRM_MODE_CONNECTOR_DisplayPort));
892 	else if (display->platform.haswell || display->platform.broadwell)
893 		lpsp_capable = connector_type == DRM_MODE_CONNECTOR_eDP;
894 
895 	seq_printf(m, "LPSP: %s\n", lpsp_capable ? "capable" : "incapable");
896 
897 	return 0;
898 }
899 DEFINE_SHOW_ATTRIBUTE(i915_lpsp_capability);
900 
901 static int i915_dsc_fec_support_show(struct seq_file *m, void *data)
902 {
903 	struct intel_connector *connector = m->private;
904 	struct intel_display *display = to_intel_display(connector);
905 	struct drm_crtc *crtc;
906 	struct intel_dp *intel_dp;
907 	struct drm_modeset_acquire_ctx ctx;
908 	struct intel_crtc_state *crtc_state = NULL;
909 	int ret = 0;
910 	bool try_again = false;
911 
912 	drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE);
913 
914 	do {
915 		try_again = false;
916 		ret = drm_modeset_lock(&display->drm->mode_config.connection_mutex,
917 				       &ctx);
918 		if (ret) {
919 			if (ret == -EDEADLK && !drm_modeset_backoff(&ctx)) {
920 				try_again = true;
921 				continue;
922 			}
923 			break;
924 		}
925 		crtc = connector->base.state->crtc;
926 		if (connector->base.status != connector_status_connected || !crtc) {
927 			ret = -ENODEV;
928 			break;
929 		}
930 		ret = drm_modeset_lock(&crtc->mutex, &ctx);
931 		if (ret == -EDEADLK) {
932 			ret = drm_modeset_backoff(&ctx);
933 			if (!ret) {
934 				try_again = true;
935 				continue;
936 			}
937 			break;
938 		} else if (ret) {
939 			break;
940 		}
941 		intel_dp = intel_attached_dp(connector);
942 		crtc_state = to_intel_crtc_state(crtc->state);
943 		seq_printf(m, "DSC_Enabled: %s\n",
944 			   str_yes_no(crtc_state->dsc.compression_enable));
945 		seq_printf(m, "DSC_Sink_Support: %s\n",
946 			   str_yes_no(drm_dp_sink_supports_dsc(connector->dp.dsc_dpcd)));
947 		seq_printf(m, "DSC_Output_Format_Sink_Support: RGB: %s YCBCR420: %s YCBCR444: %s\n",
948 			   str_yes_no(drm_dp_dsc_sink_supports_format(connector->dp.dsc_dpcd,
949 								      DP_DSC_RGB)),
950 			   str_yes_no(drm_dp_dsc_sink_supports_format(connector->dp.dsc_dpcd,
951 								      DP_DSC_YCbCr420_Native)),
952 			   str_yes_no(drm_dp_dsc_sink_supports_format(connector->dp.dsc_dpcd,
953 								      DP_DSC_YCbCr444)));
954 		seq_printf(m, "DSC_Sink_BPP_Precision: %d\n",
955 			   drm_dp_dsc_sink_bpp_incr(connector->dp.dsc_dpcd));
956 		seq_printf(m, "DSC_Sink_Max_Slice_Count: %d\n",
957 			   drm_dp_dsc_sink_max_slice_count((connector->dp.dsc_dpcd), intel_dp_is_edp(intel_dp)));
958 		seq_printf(m, "Force_DSC_Enable: %s\n",
959 			   str_yes_no(intel_dp->force_dsc_en));
960 		if (!intel_dp_is_edp(intel_dp))
961 			seq_printf(m, "FEC_Sink_Support: %s\n",
962 				   str_yes_no(drm_dp_sink_supports_fec(connector->dp.fec_capability)));
963 	} while (try_again);
964 
965 	drm_modeset_drop_locks(&ctx);
966 	drm_modeset_acquire_fini(&ctx);
967 
968 	return ret;
969 }
970 
971 static ssize_t i915_dsc_fec_support_write(struct file *file,
972 					  const char __user *ubuf,
973 					  size_t len, loff_t *offp)
974 {
975 	struct seq_file *m = file->private_data;
976 	struct intel_connector *connector = m->private;
977 	struct intel_display *display = to_intel_display(connector);
978 	struct intel_encoder *encoder = intel_attached_encoder(connector);
979 	struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
980 	bool dsc_enable = false;
981 	int ret;
982 
983 	if (len == 0)
984 		return 0;
985 
986 	drm_dbg(display->drm,
987 		"Copied %zu bytes from user to force DSC\n", len);
988 
989 	ret = kstrtobool_from_user(ubuf, len, &dsc_enable);
990 	if (ret < 0)
991 		return ret;
992 
993 	drm_dbg(display->drm, "Got %s for DSC Enable\n",
994 		str_true_false(dsc_enable));
995 	intel_dp->force_dsc_en = dsc_enable;
996 
997 	*offp += len;
998 	return len;
999 }
1000 
1001 static int i915_dsc_fec_support_open(struct inode *inode,
1002 				     struct file *file)
1003 {
1004 	return single_open(file, i915_dsc_fec_support_show,
1005 			   inode->i_private);
1006 }
1007 
1008 static const struct file_operations i915_dsc_fec_support_fops = {
1009 	.owner = THIS_MODULE,
1010 	.open = i915_dsc_fec_support_open,
1011 	.read = seq_read,
1012 	.llseek = seq_lseek,
1013 	.release = single_release,
1014 	.write = i915_dsc_fec_support_write
1015 };
1016 
1017 static int i915_dsc_bpc_show(struct seq_file *m, void *data)
1018 {
1019 	struct intel_connector *connector = m->private;
1020 	struct intel_display *display = to_intel_display(connector);
1021 	struct intel_encoder *encoder = intel_attached_encoder(connector);
1022 	struct drm_crtc *crtc;
1023 	struct intel_crtc_state *crtc_state;
1024 	int ret;
1025 
1026 	if (!encoder)
1027 		return -ENODEV;
1028 
1029 	ret = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
1030 	if (ret)
1031 		return ret;
1032 
1033 	crtc = connector->base.state->crtc;
1034 	if (connector->base.status != connector_status_connected || !crtc) {
1035 		ret = -ENODEV;
1036 		goto out;
1037 	}
1038 
1039 	crtc_state = to_intel_crtc_state(crtc->state);
1040 	seq_printf(m, "Input_BPC: %d\n", crtc_state->dsc.config.bits_per_component);
1041 
1042 out:	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
1043 
1044 	return ret;
1045 }
1046 
1047 static ssize_t i915_dsc_bpc_write(struct file *file,
1048 				  const char __user *ubuf,
1049 				  size_t len, loff_t *offp)
1050 {
1051 	struct seq_file *m = file->private_data;
1052 	struct intel_connector *connector = m->private;
1053 	struct intel_encoder *encoder = intel_attached_encoder(connector);
1054 	struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1055 	int dsc_bpc = 0;
1056 	int ret;
1057 
1058 	ret = kstrtoint_from_user(ubuf, len, 0, &dsc_bpc);
1059 	if (ret < 0)
1060 		return ret;
1061 
1062 	intel_dp->force_dsc_bpc = dsc_bpc;
1063 	*offp += len;
1064 
1065 	return len;
1066 }
1067 
1068 static int i915_dsc_bpc_open(struct inode *inode,
1069 			     struct file *file)
1070 {
1071 	return single_open(file, i915_dsc_bpc_show, inode->i_private);
1072 }
1073 
1074 static const struct file_operations i915_dsc_bpc_fops = {
1075 	.owner = THIS_MODULE,
1076 	.open = i915_dsc_bpc_open,
1077 	.read = seq_read,
1078 	.llseek = seq_lseek,
1079 	.release = single_release,
1080 	.write = i915_dsc_bpc_write
1081 };
1082 
1083 static int i915_dsc_output_format_show(struct seq_file *m, void *data)
1084 {
1085 	struct intel_connector *connector = m->private;
1086 	struct intel_display *display = to_intel_display(connector);
1087 	struct intel_encoder *encoder = intel_attached_encoder(connector);
1088 	struct drm_crtc *crtc;
1089 	struct intel_crtc_state *crtc_state;
1090 	int ret;
1091 
1092 	if (!encoder)
1093 		return -ENODEV;
1094 
1095 	ret = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
1096 	if (ret)
1097 		return ret;
1098 
1099 	crtc = connector->base.state->crtc;
1100 	if (connector->base.status != connector_status_connected || !crtc) {
1101 		ret = -ENODEV;
1102 		goto out;
1103 	}
1104 
1105 	crtc_state = to_intel_crtc_state(crtc->state);
1106 	seq_printf(m, "DSC_Output_Format: %s\n",
1107 		   intel_output_format_name(crtc_state->output_format));
1108 
1109 out:	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
1110 
1111 	return ret;
1112 }
1113 
1114 static ssize_t i915_dsc_output_format_write(struct file *file,
1115 					    const char __user *ubuf,
1116 					    size_t len, loff_t *offp)
1117 {
1118 	struct seq_file *m = file->private_data;
1119 	struct intel_connector *connector = m->private;
1120 	struct intel_encoder *encoder = intel_attached_encoder(connector);
1121 	struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1122 	int dsc_output_format = 0;
1123 	int ret;
1124 
1125 	ret = kstrtoint_from_user(ubuf, len, 0, &dsc_output_format);
1126 	if (ret < 0)
1127 		return ret;
1128 
1129 	intel_dp->force_dsc_output_format = dsc_output_format;
1130 	*offp += len;
1131 
1132 	return len;
1133 }
1134 
1135 static int i915_dsc_output_format_open(struct inode *inode,
1136 				       struct file *file)
1137 {
1138 	return single_open(file, i915_dsc_output_format_show, inode->i_private);
1139 }
1140 
1141 static const struct file_operations i915_dsc_output_format_fops = {
1142 	.owner = THIS_MODULE,
1143 	.open = i915_dsc_output_format_open,
1144 	.read = seq_read,
1145 	.llseek = seq_lseek,
1146 	.release = single_release,
1147 	.write = i915_dsc_output_format_write
1148 };
1149 
1150 static int i915_dsc_fractional_bpp_show(struct seq_file *m, void *data)
1151 {
1152 	struct intel_connector *connector = m->private;
1153 	struct intel_display *display = to_intel_display(connector);
1154 	struct intel_encoder *encoder = intel_attached_encoder(connector);
1155 	struct drm_crtc *crtc;
1156 	struct intel_dp *intel_dp;
1157 	int ret;
1158 
1159 	if (!encoder)
1160 		return -ENODEV;
1161 
1162 	ret = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
1163 	if (ret)
1164 		return ret;
1165 
1166 	crtc = connector->base.state->crtc;
1167 	if (connector->base.status != connector_status_connected || !crtc) {
1168 		ret = -ENODEV;
1169 		goto out;
1170 	}
1171 
1172 	intel_dp = intel_attached_dp(connector);
1173 	seq_printf(m, "Force_DSC_Fractional_BPP_Enable: %s\n",
1174 		   str_yes_no(intel_dp->force_dsc_fractional_bpp_en));
1175 
1176 out:
1177 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
1178 
1179 	return ret;
1180 }
1181 
1182 static ssize_t i915_dsc_fractional_bpp_write(struct file *file,
1183 					     const char __user *ubuf,
1184 					     size_t len, loff_t *offp)
1185 {
1186 	struct seq_file *m = file->private_data;
1187 	struct intel_connector *connector = m->private;
1188 	struct intel_display *display = to_intel_display(connector);
1189 	struct intel_encoder *encoder = intel_attached_encoder(connector);
1190 	struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1191 	bool dsc_fractional_bpp_enable = false;
1192 	int ret;
1193 
1194 	if (len == 0)
1195 		return 0;
1196 
1197 	drm_dbg(display->drm,
1198 		"Copied %zu bytes from user to force fractional bpp for DSC\n", len);
1199 
1200 	ret = kstrtobool_from_user(ubuf, len, &dsc_fractional_bpp_enable);
1201 	if (ret < 0)
1202 		return ret;
1203 
1204 	drm_dbg(display->drm, "Got %s for DSC Fractional BPP Enable\n",
1205 		str_true_false(dsc_fractional_bpp_enable));
1206 	intel_dp->force_dsc_fractional_bpp_en = dsc_fractional_bpp_enable;
1207 
1208 	*offp += len;
1209 
1210 	return len;
1211 }
1212 
1213 static int i915_dsc_fractional_bpp_open(struct inode *inode,
1214 					struct file *file)
1215 {
1216 	return single_open(file, i915_dsc_fractional_bpp_show, inode->i_private);
1217 }
1218 
1219 static const struct file_operations i915_dsc_fractional_bpp_fops = {
1220 	.owner = THIS_MODULE,
1221 	.open = i915_dsc_fractional_bpp_open,
1222 	.read = seq_read,
1223 	.llseek = seq_lseek,
1224 	.release = single_release,
1225 	.write = i915_dsc_fractional_bpp_write
1226 };
1227 
1228 /*
1229  * Returns the Current CRTC's bpc.
1230  * Example usage: cat /sys/kernel/debug/dri/0/crtc-0/i915_current_bpc
1231  */
1232 static int i915_current_bpc_show(struct seq_file *m, void *data)
1233 {
1234 	struct intel_crtc *crtc = m->private;
1235 	struct intel_crtc_state *crtc_state;
1236 	int ret;
1237 
1238 	ret = drm_modeset_lock_single_interruptible(&crtc->base.mutex);
1239 	if (ret)
1240 		return ret;
1241 
1242 	crtc_state = to_intel_crtc_state(crtc->base.state);
1243 	seq_printf(m, "Current: %u\n", crtc_state->pipe_bpp / 3);
1244 
1245 	drm_modeset_unlock(&crtc->base.mutex);
1246 
1247 	return ret;
1248 }
1249 DEFINE_SHOW_ATTRIBUTE(i915_current_bpc);
1250 
1251 /* Pipe may differ from crtc index if pipes are fused off */
1252 static int intel_crtc_pipe_show(struct seq_file *m, void *unused)
1253 {
1254 	struct intel_crtc *crtc = m->private;
1255 
1256 	seq_printf(m, "%c\n", pipe_name(crtc->pipe));
1257 
1258 	return 0;
1259 }
1260 DEFINE_SHOW_ATTRIBUTE(intel_crtc_pipe);
1261 
1262 static int i915_joiner_show(struct seq_file *m, void *data)
1263 {
1264 	struct intel_connector *connector = m->private;
1265 
1266 	seq_printf(m, "%d\n", connector->force_joined_pipes);
1267 
1268 	return 0;
1269 }
1270 
1271 static ssize_t i915_joiner_write(struct file *file,
1272 				 const char __user *ubuf,
1273 				 size_t len, loff_t *offp)
1274 {
1275 	struct seq_file *m = file->private_data;
1276 	struct intel_connector *connector = m->private;
1277 	struct intel_display *display = to_intel_display(connector);
1278 	int force_joined_pipes = 0;
1279 	int ret;
1280 
1281 	if (len == 0)
1282 		return 0;
1283 
1284 	ret = kstrtoint_from_user(ubuf, len, 0, &force_joined_pipes);
1285 	if (ret < 0)
1286 		return ret;
1287 
1288 	if (force_joined_pipes &&
1289 	    !intel_joiner_valid_primary_pipe_mask(display, force_joined_pipes))
1290 		return -EINVAL;
1291 
1292 	connector->force_joined_pipes = force_joined_pipes;
1293 
1294 	*offp += len;
1295 
1296 	return len;
1297 }
1298 
1299 static int i915_joiner_open(struct inode *inode, struct file *file)
1300 {
1301 	return single_open(file, i915_joiner_show, inode->i_private);
1302 }
1303 
1304 static const struct file_operations i915_joiner_fops = {
1305 	.owner = THIS_MODULE,
1306 	.open = i915_joiner_open,
1307 	.read = seq_read,
1308 	.llseek = seq_lseek,
1309 	.release = single_release,
1310 	.write = i915_joiner_write
1311 };
1312 
1313 /**
1314  * intel_connector_debugfs_add - add i915 specific connector debugfs files
1315  * @connector: pointer to a registered intel_connector
1316  *
1317  * Cleanup will be done by drm_connector_unregister() through a call to
1318  * drm_debugfs_connector_remove().
1319  */
1320 void intel_connector_debugfs_add(struct intel_connector *connector)
1321 {
1322 	struct intel_display *display = to_intel_display(connector);
1323 	struct dentry *root = connector->base.debugfs_entry;
1324 	int connector_type = connector->base.connector_type;
1325 
1326 	/* The connector must have been registered beforehands. */
1327 	if (!root)
1328 		return;
1329 
1330 	intel_drrs_connector_debugfs_add(connector);
1331 	intel_hdcp_connector_debugfs_add(connector);
1332 	intel_pps_connector_debugfs_add(connector);
1333 	intel_psr_connector_debugfs_add(connector);
1334 	intel_alpm_lobf_debugfs_add(connector);
1335 	intel_dp_link_training_debugfs_add(connector);
1336 	intel_dp_link_caps_debugfs_add(connector);
1337 	intel_link_bw_connector_debugfs_add(connector);
1338 
1339 	if (DISPLAY_VER(display) >= 11 &&
1340 	    ((connector_type == DRM_MODE_CONNECTOR_DisplayPort && !connector->mst.dp) ||
1341 	     connector_type == DRM_MODE_CONNECTOR_eDP)) {
1342 		debugfs_create_file("i915_dsc_fec_support", 0644, root,
1343 				    connector, &i915_dsc_fec_support_fops);
1344 
1345 		debugfs_create_file("i915_dsc_bpc", 0644, root,
1346 				    connector, &i915_dsc_bpc_fops);
1347 
1348 		debugfs_create_file("i915_dsc_output_format", 0644, root,
1349 				    connector, &i915_dsc_output_format_fops);
1350 
1351 		debugfs_create_file("i915_dsc_fractional_bpp", 0644, root,
1352 				    connector, &i915_dsc_fractional_bpp_fops);
1353 	}
1354 
1355 	if ((connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
1356 	     connector_type == DRM_MODE_CONNECTOR_eDP) &&
1357 	    intel_dp_has_joiner(intel_attached_dp(connector))) {
1358 		debugfs_create_file("i915_joiner_force_enable", 0644, root,
1359 				    connector, &i915_joiner_fops);
1360 	}
1361 
1362 	if (connector_type == DRM_MODE_CONNECTOR_DSI ||
1363 	    connector_type == DRM_MODE_CONNECTOR_eDP ||
1364 	    connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
1365 	    connector_type == DRM_MODE_CONNECTOR_HDMIA ||
1366 	    connector_type == DRM_MODE_CONNECTOR_HDMIB)
1367 		debugfs_create_file("i915_lpsp_capability", 0444, root,
1368 				    connector, &i915_lpsp_capability_fops);
1369 }
1370 
1371 /**
1372  * intel_crtc_debugfs_add - add i915 specific crtc debugfs files
1373  * @crtc: pointer to a drm_crtc
1374  *
1375  * Failure to add debugfs entries should generally be ignored.
1376  */
1377 void intel_crtc_debugfs_add(struct intel_crtc *crtc)
1378 {
1379 	struct dentry *root = crtc->base.debugfs_entry;
1380 
1381 	if (!root)
1382 		return;
1383 
1384 	crtc_updates_add(crtc);
1385 	intel_drrs_crtc_debugfs_add(crtc);
1386 	intel_fbc_crtc_debugfs_add(crtc);
1387 	hsw_ips_crtc_debugfs_add(crtc);
1388 	intel_vrr_crtc_debugfs_add(crtc);
1389 
1390 	debugfs_create_file("i915_current_bpc", 0444, root, crtc,
1391 			    &i915_current_bpc_fops);
1392 	debugfs_create_file("i915_pipe", 0444, root, crtc,
1393 			    &intel_crtc_pipe_fops);
1394 }
1395