1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. 4 */ 5 6 #define pr_fmt(fmt)"[drm-dp] %s: " fmt, __func__ 7 8 #include <linux/debugfs.h> 9 #include <drm/drm_connector.h> 10 #include <drm/drm_file.h> 11 12 #include "dp_parser.h" 13 #include "dp_catalog.h" 14 #include "dp_aux.h" 15 #include "dp_ctrl.h" 16 #include "dp_debug.h" 17 #include "dp_display.h" 18 19 #define DEBUG_NAME "msm_dp" 20 21 struct dp_debug_private { 22 struct dentry *root; 23 24 struct dp_usbpd *usbpd; 25 struct dp_link *link; 26 struct dp_panel *panel; 27 struct drm_connector **connector; 28 struct device *dev; 29 struct drm_device *drm_dev; 30 31 struct dp_debug dp_debug; 32 }; 33 34 static int dp_debug_check_buffer_overflow(int rc, int *max_size, int *len) 35 { 36 if (rc >= *max_size) { 37 DRM_ERROR("buffer overflow\n"); 38 return -EINVAL; 39 } 40 *len += rc; 41 *max_size = SZ_4K - *len; 42 43 return 0; 44 } 45 46 static ssize_t dp_debug_read_info(struct file *file, char __user *user_buff, 47 size_t count, loff_t *ppos) 48 { 49 struct dp_debug_private *debug = file->private_data; 50 char *buf; 51 u32 len = 0, rc = 0; 52 u64 lclk = 0; 53 u32 max_size = SZ_4K; 54 u32 link_params_rate; 55 struct drm_display_mode *drm_mode; 56 57 if (!debug) 58 return -ENODEV; 59 60 if (*ppos) 61 return 0; 62 63 buf = kzalloc(SZ_4K, GFP_KERNEL); 64 if (!buf) 65 return -ENOMEM; 66 67 drm_mode = &debug->panel->dp_mode.drm_mode; 68 69 rc = snprintf(buf + len, max_size, "\tname = %s\n", DEBUG_NAME); 70 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 71 goto error; 72 73 rc = snprintf(buf + len, max_size, 74 "\tdp_panel\n\t\tmax_pclk_khz = %d\n", 75 debug->panel->max_pclk_khz); 76 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 77 goto error; 78 79 rc = snprintf(buf + len, max_size, 80 "\tdrm_dp_link\n\t\trate = %u\n", 81 debug->panel->link_info.rate); 82 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 83 goto error; 84 85 rc = snprintf(buf + len, max_size, 86 "\t\tnum_lanes = %u\n", 87 debug->panel->link_info.num_lanes); 88 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 89 goto error; 90 91 rc = snprintf(buf + len, max_size, 92 "\t\tcapabilities = %lu\n", 93 debug->panel->link_info.capabilities); 94 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 95 goto error; 96 97 rc = snprintf(buf + len, max_size, 98 "\tdp_panel_info:\n\t\tactive = %dx%d\n", 99 drm_mode->hdisplay, 100 drm_mode->vdisplay); 101 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 102 goto error; 103 104 rc = snprintf(buf + len, max_size, 105 "\t\tback_porch = %dx%d\n", 106 drm_mode->htotal - drm_mode->hsync_end, 107 drm_mode->vtotal - drm_mode->vsync_end); 108 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 109 goto error; 110 111 rc = snprintf(buf + len, max_size, 112 "\t\tfront_porch = %dx%d\n", 113 drm_mode->hsync_start - drm_mode->hdisplay, 114 drm_mode->vsync_start - drm_mode->vdisplay); 115 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 116 goto error; 117 118 rc = snprintf(buf + len, max_size, 119 "\t\tsync_width = %dx%d\n", 120 drm_mode->hsync_end - drm_mode->hsync_start, 121 drm_mode->vsync_end - drm_mode->vsync_start); 122 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 123 goto error; 124 125 rc = snprintf(buf + len, max_size, 126 "\t\tactive_low = %dx%d\n", 127 debug->panel->dp_mode.h_active_low, 128 debug->panel->dp_mode.v_active_low); 129 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 130 goto error; 131 132 rc = snprintf(buf + len, max_size, 133 "\t\th_skew = %d\n", 134 drm_mode->hskew); 135 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 136 goto error; 137 138 rc = snprintf(buf + len, max_size, 139 "\t\trefresh rate = %d\n", 140 drm_mode_vrefresh(drm_mode)); 141 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 142 goto error; 143 144 rc = snprintf(buf + len, max_size, 145 "\t\tpixel clock khz = %d\n", 146 drm_mode->clock); 147 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 148 goto error; 149 150 rc = snprintf(buf + len, max_size, 151 "\t\tbpp = %d\n", 152 debug->panel->dp_mode.bpp); 153 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 154 goto error; 155 156 /* Link Information */ 157 rc = snprintf(buf + len, max_size, 158 "\tdp_link:\n\t\ttest_requested = %d\n", 159 debug->link->sink_request); 160 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 161 goto error; 162 163 rc = snprintf(buf + len, max_size, 164 "\t\tnum_lanes = %d\n", 165 debug->link->link_params.num_lanes); 166 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 167 goto error; 168 169 link_params_rate = debug->link->link_params.rate; 170 rc = snprintf(buf + len, max_size, 171 "\t\tbw_code = %d\n", 172 drm_dp_link_rate_to_bw_code(link_params_rate)); 173 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 174 goto error; 175 176 lclk = debug->link->link_params.rate * 1000; 177 rc = snprintf(buf + len, max_size, 178 "\t\tlclk = %lld\n", lclk); 179 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 180 goto error; 181 182 rc = snprintf(buf + len, max_size, 183 "\t\tv_level = %d\n", 184 debug->link->phy_params.v_level); 185 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 186 goto error; 187 188 rc = snprintf(buf + len, max_size, 189 "\t\tp_level = %d\n", 190 debug->link->phy_params.p_level); 191 if (dp_debug_check_buffer_overflow(rc, &max_size, &len)) 192 goto error; 193 194 if (copy_to_user(user_buff, buf, len)) 195 goto error; 196 197 *ppos += len; 198 199 kfree(buf); 200 return len; 201 error: 202 kfree(buf); 203 return -EINVAL; 204 } 205 206 static int dp_test_data_show(struct seq_file *m, void *data) 207 { 208 struct drm_device *dev; 209 struct dp_debug_private *debug; 210 struct drm_connector *connector; 211 struct drm_connector_list_iter conn_iter; 212 u32 bpc; 213 214 debug = m->private; 215 dev = debug->drm_dev; 216 drm_connector_list_iter_begin(dev, &conn_iter); 217 drm_for_each_connector_iter(connector, &conn_iter) { 218 219 if (connector->connector_type != 220 DRM_MODE_CONNECTOR_DisplayPort) 221 continue; 222 223 if (connector->status == connector_status_connected) { 224 bpc = debug->link->test_video.test_bit_depth; 225 seq_printf(m, "hdisplay: %d\n", 226 debug->link->test_video.test_h_width); 227 seq_printf(m, "vdisplay: %d\n", 228 debug->link->test_video.test_v_height); 229 seq_printf(m, "bpc: %u\n", 230 dp_link_bit_depth_to_bpc(bpc)); 231 } else 232 seq_puts(m, "0"); 233 } 234 235 drm_connector_list_iter_end(&conn_iter); 236 237 return 0; 238 } 239 DEFINE_SHOW_ATTRIBUTE(dp_test_data); 240 241 static int dp_test_type_show(struct seq_file *m, void *data) 242 { 243 struct dp_debug_private *debug = m->private; 244 struct drm_device *dev = debug->drm_dev; 245 struct drm_connector *connector; 246 struct drm_connector_list_iter conn_iter; 247 248 drm_connector_list_iter_begin(dev, &conn_iter); 249 drm_for_each_connector_iter(connector, &conn_iter) { 250 251 if (connector->connector_type != 252 DRM_MODE_CONNECTOR_DisplayPort) 253 continue; 254 255 if (connector->status == connector_status_connected) 256 seq_printf(m, "%02x", DP_TEST_LINK_VIDEO_PATTERN); 257 else 258 seq_puts(m, "0"); 259 } 260 drm_connector_list_iter_end(&conn_iter); 261 262 return 0; 263 } 264 DEFINE_SHOW_ATTRIBUTE(dp_test_type); 265 266 static ssize_t dp_test_active_write(struct file *file, 267 const char __user *ubuf, 268 size_t len, loff_t *offp) 269 { 270 char *input_buffer; 271 int status = 0; 272 struct dp_debug_private *debug; 273 struct drm_device *dev; 274 struct drm_connector *connector; 275 struct drm_connector_list_iter conn_iter; 276 int val = 0; 277 278 debug = ((struct seq_file *)file->private_data)->private; 279 dev = debug->drm_dev; 280 281 if (len == 0) 282 return 0; 283 284 input_buffer = memdup_user_nul(ubuf, len); 285 if (IS_ERR(input_buffer)) 286 return PTR_ERR(input_buffer); 287 288 DRM_DEBUG_DRIVER("Copied %d bytes from user\n", (unsigned int)len); 289 290 drm_connector_list_iter_begin(dev, &conn_iter); 291 drm_for_each_connector_iter(connector, &conn_iter) { 292 if (connector->connector_type != 293 DRM_MODE_CONNECTOR_DisplayPort) 294 continue; 295 296 if (connector->status == connector_status_connected) { 297 status = kstrtoint(input_buffer, 10, &val); 298 if (status < 0) 299 break; 300 DRM_DEBUG_DRIVER("Got %d for test active\n", val); 301 /* To prevent erroneous activation of the compliance 302 * testing code, only accept an actual value of 1 here 303 */ 304 if (val == 1) 305 debug->panel->video_test = true; 306 else 307 debug->panel->video_test = false; 308 } 309 } 310 drm_connector_list_iter_end(&conn_iter); 311 kfree(input_buffer); 312 if (status < 0) 313 return status; 314 315 *offp += len; 316 return len; 317 } 318 319 static int dp_test_active_show(struct seq_file *m, void *data) 320 { 321 struct dp_debug_private *debug = m->private; 322 struct drm_device *dev = debug->drm_dev; 323 struct drm_connector *connector; 324 struct drm_connector_list_iter conn_iter; 325 326 drm_connector_list_iter_begin(dev, &conn_iter); 327 drm_for_each_connector_iter(connector, &conn_iter) { 328 if (connector->connector_type != 329 DRM_MODE_CONNECTOR_DisplayPort) 330 continue; 331 332 if (connector->status == connector_status_connected) { 333 if (debug->panel->video_test) 334 seq_puts(m, "1"); 335 else 336 seq_puts(m, "0"); 337 } else 338 seq_puts(m, "0"); 339 } 340 drm_connector_list_iter_end(&conn_iter); 341 342 return 0; 343 } 344 345 static int dp_test_active_open(struct inode *inode, 346 struct file *file) 347 { 348 return single_open(file, dp_test_active_show, 349 inode->i_private); 350 } 351 352 static const struct file_operations dp_debug_fops = { 353 .open = simple_open, 354 .read = dp_debug_read_info, 355 }; 356 357 static const struct file_operations test_active_fops = { 358 .owner = THIS_MODULE, 359 .open = dp_test_active_open, 360 .read = seq_read, 361 .llseek = seq_lseek, 362 .release = single_release, 363 .write = dp_test_active_write 364 }; 365 366 static int dp_debug_init(struct dp_debug *dp_debug, struct drm_minor *minor) 367 { 368 int rc = 0; 369 struct dp_debug_private *debug = container_of(dp_debug, 370 struct dp_debug_private, dp_debug); 371 struct dentry *file; 372 struct dentry *test_active; 373 struct dentry *test_data, *test_type; 374 375 file = debugfs_create_file("dp_debug", 0444, minor->debugfs_root, 376 debug, &dp_debug_fops); 377 if (IS_ERR_OR_NULL(file)) { 378 rc = PTR_ERR(file); 379 DRM_ERROR("[%s] debugfs create file failed, rc=%d\n", 380 DEBUG_NAME, rc); 381 } 382 383 test_active = debugfs_create_file("msm_dp_test_active", 0444, 384 minor->debugfs_root, 385 debug, &test_active_fops); 386 if (IS_ERR_OR_NULL(test_active)) { 387 rc = PTR_ERR(test_active); 388 DRM_ERROR("[%s] debugfs test_active failed, rc=%d\n", 389 DEBUG_NAME, rc); 390 } 391 392 test_data = debugfs_create_file("msm_dp_test_data", 0444, 393 minor->debugfs_root, 394 debug, &dp_test_data_fops); 395 if (IS_ERR_OR_NULL(test_data)) { 396 rc = PTR_ERR(test_data); 397 DRM_ERROR("[%s] debugfs test_data failed, rc=%d\n", 398 DEBUG_NAME, rc); 399 } 400 401 test_type = debugfs_create_file("msm_dp_test_type", 0444, 402 minor->debugfs_root, 403 debug, &dp_test_type_fops); 404 if (IS_ERR_OR_NULL(test_type)) { 405 rc = PTR_ERR(test_type); 406 DRM_ERROR("[%s] debugfs test_type failed, rc=%d\n", 407 DEBUG_NAME, rc); 408 } 409 410 debug->root = minor->debugfs_root; 411 412 return rc; 413 } 414 415 struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel, 416 struct dp_usbpd *usbpd, struct dp_link *link, 417 struct drm_connector **connector, struct drm_minor *minor) 418 { 419 int rc = 0; 420 struct dp_debug_private *debug; 421 struct dp_debug *dp_debug; 422 423 if (!dev || !panel || !usbpd || !link) { 424 DRM_ERROR("invalid input\n"); 425 rc = -EINVAL; 426 goto error; 427 } 428 429 debug = devm_kzalloc(dev, sizeof(*debug), GFP_KERNEL); 430 if (!debug) { 431 rc = -ENOMEM; 432 goto error; 433 } 434 435 debug->dp_debug.debug_en = false; 436 debug->usbpd = usbpd; 437 debug->link = link; 438 debug->panel = panel; 439 debug->dev = dev; 440 debug->drm_dev = minor->dev; 441 debug->connector = connector; 442 443 dp_debug = &debug->dp_debug; 444 dp_debug->vdisplay = 0; 445 dp_debug->hdisplay = 0; 446 dp_debug->vrefresh = 0; 447 448 rc = dp_debug_init(dp_debug, minor); 449 if (rc) { 450 devm_kfree(dev, debug); 451 goto error; 452 } 453 454 return dp_debug; 455 error: 456 return ERR_PTR(rc); 457 } 458 459 static int dp_debug_deinit(struct dp_debug *dp_debug) 460 { 461 struct dp_debug_private *debug; 462 463 if (!dp_debug) 464 return -EINVAL; 465 466 debug = container_of(dp_debug, struct dp_debug_private, dp_debug); 467 468 debugfs_remove_recursive(debug->root); 469 470 return 0; 471 } 472 473 void dp_debug_put(struct dp_debug *dp_debug) 474 { 475 struct dp_debug_private *debug; 476 477 if (!dp_debug) 478 return; 479 480 debug = container_of(dp_debug, struct dp_debug_private, dp_debug); 481 482 dp_debug_deinit(dp_debug); 483 484 devm_kfree(debug->dev, debug); 485 } 486