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