msm/dp/dp_debug.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
0004  */
0005
0006 #define pr_fmt(fmt)"[drm-dp] %s: " fmt, __func__
0007
0008 #include <linux/debugfs.h>
0009 #include <drm/drm_connector.h>
0010 #include <drm/drm_file.h>
0011
0012 #include "dp_parser.h"
0013 #include "dp_catalog.h"
0014 #include "dp_aux.h"
0015 #include "dp_ctrl.h"
0016 #include "dp_debug.h"
0017 #include "dp_display.h"
0018
0019 #define DEBUG_NAME "msm_dp"
0020
0021 struct dp_debug_private {
0022     struct dentry *root;
0023
0024     struct dp_usbpd *usbpd;
0025     struct dp_link *link;
0026     struct dp_panel *panel;
0027     struct drm_connector *connector;
0028     struct device *dev;
0029     struct drm_device *drm_dev;
0030
0031     struct dp_debug dp_debug;
0032 };
0033
0034 static int dp_debug_show(struct seq_file *seq, void *p)
0035 {
0036     struct dp_debug_private *debug = seq->private;
0037     u64 lclk = 0;
0038     u32 link_params_rate;
0039     const struct drm_display_mode *drm_mode;
0040
0041     if (!debug)
0042         return -ENODEV;
0043
0044     drm_mode = &debug->panel->dp_mode.drm_mode;
0045
0046     seq_printf(seq, "\tname = %s\n", DEBUG_NAME);
0047     seq_printf(seq, "\tdrm_dp_link\n\t\trate = %u\n",
0048             debug->panel->link_info.rate);
0049     seq_printf(seq, "\t\tnum_lanes = %u\n",
0050             debug->panel->link_info.num_lanes);
0051     seq_printf(seq, "\t\tcapabilities = %lu\n",
0052             debug->panel->link_info.capabilities);
0053     seq_printf(seq, "\tdp_panel_info:\n\t\tactive = %dx%d\n",
0054             drm_mode->hdisplay,
0055             drm_mode->vdisplay);
0056     seq_printf(seq, "\t\tback_porch = %dx%d\n",
0057             drm_mode->htotal - drm_mode->hsync_end,
0058             drm_mode->vtotal - drm_mode->vsync_end);
0059     seq_printf(seq, "\t\tfront_porch = %dx%d\n",
0060             drm_mode->hsync_start - drm_mode->hdisplay,
0061             drm_mode->vsync_start - drm_mode->vdisplay);
0062     seq_printf(seq, "\t\tsync_width = %dx%d\n",
0063             drm_mode->hsync_end - drm_mode->hsync_start,
0064             drm_mode->vsync_end - drm_mode->vsync_start);
0065     seq_printf(seq, "\t\tactive_low = %dx%d\n",
0066             debug->panel->dp_mode.h_active_low,
0067             debug->panel->dp_mode.v_active_low);
0068     seq_printf(seq, "\t\th_skew = %d\n",
0069             drm_mode->hskew);
0070     seq_printf(seq, "\t\trefresh rate = %d\n",
0071             drm_mode_vrefresh(drm_mode));
0072     seq_printf(seq, "\t\tpixel clock khz = %d\n",
0073             drm_mode->clock);
0074     seq_printf(seq, "\t\tbpp = %d\n",
0075             debug->panel->dp_mode.bpp);
0076
0077     /* Link Information */
0078     seq_printf(seq, "\tdp_link:\n\t\ttest_requested = %d\n",
0079             debug->link->sink_request);
0080     seq_printf(seq, "\t\tnum_lanes = %d\n",
0081             debug->link->link_params.num_lanes);
0082     link_params_rate = debug->link->link_params.rate;
0083     seq_printf(seq, "\t\tbw_code = %d\n",
0084             drm_dp_link_rate_to_bw_code(link_params_rate));
0085     lclk = debug->link->link_params.rate * 1000;
0086     seq_printf(seq, "\t\tlclk = %lld\n", lclk);
0087     seq_printf(seq, "\t\tv_level = %d\n",
0088             debug->link->phy_params.v_level);
0089     seq_printf(seq, "\t\tp_level = %d\n",
0090             debug->link->phy_params.p_level);
0091
0092     return 0;
0093 }
0094 DEFINE_SHOW_ATTRIBUTE(dp_debug);
0095
0096 static int dp_test_data_show(struct seq_file *m, void *data)
0097 {
0098     const struct dp_debug_private *debug = m->private;
0099     const struct drm_connector *connector = debug->connector;
0100     u32 bpc;
0101
0102     if (connector->status == connector_status_connected) {
0103         bpc = debug->link->test_video.test_bit_depth;
0104         seq_printf(m, "hdisplay: %d\n",
0105                 debug->link->test_video.test_h_width);
0106         seq_printf(m, "vdisplay: %d\n",
0107                 debug->link->test_video.test_v_height);
0108         seq_printf(m, "bpc: %u\n",
0109                 dp_link_bit_depth_to_bpc(bpc));
0110     } else {
0111         seq_puts(m, "0");
0112     }
0113
0114     return 0;
0115 }
0116 DEFINE_SHOW_ATTRIBUTE(dp_test_data);
0117
0118 static int dp_test_type_show(struct seq_file *m, void *data)
0119 {
0120     const struct dp_debug_private *debug = m->private;
0121     const struct drm_connector *connector = debug->connector;
0122
0123     if (connector->status == connector_status_connected)
0124         seq_printf(m, "%02x", DP_TEST_LINK_VIDEO_PATTERN);
0125     else
0126         seq_puts(m, "0");
0127
0128     return 0;
0129 }
0130 DEFINE_SHOW_ATTRIBUTE(dp_test_type);
0131
0132 static ssize_t dp_test_active_write(struct file *file,
0133         const char __user *ubuf,
0134         size_t len, loff_t *offp)
0135 {
0136     char *input_buffer;
0137     int status = 0;
0138     const struct dp_debug_private *debug;
0139     const struct drm_connector *connector;
0140     int val = 0;
0141
0142     debug = ((struct seq_file *)file->private_data)->private;
0143     connector = debug->connector;
0144
0145     if (len == 0)
0146         return 0;
0147
0148     input_buffer = memdup_user_nul(ubuf, len);
0149     if (IS_ERR(input_buffer))
0150         return PTR_ERR(input_buffer);
0151
0152     DRM_DEBUG_DRIVER("Copied %d bytes from user\n", (unsigned int)len);
0153
0154     if (connector->status == connector_status_connected) {
0155         status = kstrtoint(input_buffer, 10, &val);
0156         if (status < 0) {
0157             kfree(input_buffer);
0158             return status;
0159         }
0160         DRM_DEBUG_DRIVER("Got %d for test active\n", val);
0161         /* To prevent erroneous activation of the compliance
0162          * testing code, only accept an actual value of 1 here
0163          */
0164         if (val == 1)
0165             debug->panel->video_test = true;
0166         else
0167             debug->panel->video_test = false;
0168     }
0169     kfree(input_buffer);
0170
0171     *offp += len;
0172     return len;
0173 }
0174
0175 static int dp_test_active_show(struct seq_file *m, void *data)
0176 {
0177     struct dp_debug_private *debug = m->private;
0178     struct drm_connector *connector = debug->connector;
0179
0180     if (connector->status == connector_status_connected) {
0181         if (debug->panel->video_test)
0182             seq_puts(m, "1");
0183         else
0184             seq_puts(m, "0");
0185     } else {
0186         seq_puts(m, "0");
0187     }
0188
0189     return 0;
0190 }
0191
0192 static int dp_test_active_open(struct inode *inode,
0193         struct file *file)
0194 {
0195     return single_open(file, dp_test_active_show,
0196             inode->i_private);
0197 }
0198
0199 static const struct file_operations test_active_fops = {
0200     .owner = THIS_MODULE,
0201     .open = dp_test_active_open,
0202     .read = seq_read,
0203     .llseek = seq_lseek,
0204     .release = single_release,
0205     .write = dp_test_active_write
0206 };
0207
0208 static void dp_debug_init(struct dp_debug *dp_debug, struct drm_minor *minor)
0209 {
0210     char path[64];
0211     struct dp_debug_private *debug = container_of(dp_debug,
0212             struct dp_debug_private, dp_debug);
0213
0214     snprintf(path, sizeof(path), "msm_dp-%s", debug->connector->name);
0215
0216     debug->root = debugfs_create_dir(path, minor->debugfs_root);
0217
0218     debugfs_create_file("dp_debug", 0444, debug->root,
0219             debug, &dp_debug_fops);
0220
0221     debugfs_create_file("msm_dp_test_active", 0444,
0222             debug->root,
0223             debug, &test_active_fops);
0224
0225     debugfs_create_file("msm_dp_test_data", 0444,
0226             debug->root,
0227             debug, &dp_test_data_fops);
0228
0229     debugfs_create_file("msm_dp_test_type", 0444,
0230             debug->root,
0231             debug, &dp_test_type_fops);
0232 }
0233
0234 struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
0235         struct dp_usbpd *usbpd, struct dp_link *link,
0236         struct drm_connector *connector, struct drm_minor *minor)
0237 {
0238     struct dp_debug_private *debug;
0239     struct dp_debug *dp_debug;
0240     int rc;
0241
0242     if (!dev || !panel || !usbpd || !link) {
0243         DRM_ERROR("invalid input\n");
0244         rc = -EINVAL;
0245         goto error;
0246     }
0247
0248     debug = devm_kzalloc(dev, sizeof(*debug), GFP_KERNEL);
0249     if (!debug) {
0250         rc = -ENOMEM;
0251         goto error;
0252     }
0253
0254     debug->dp_debug.debug_en = false;
0255     debug->usbpd = usbpd;
0256     debug->link = link;
0257     debug->panel = panel;
0258     debug->dev = dev;
0259     debug->drm_dev = minor->dev;
0260     debug->connector = connector;
0261
0262     dp_debug = &debug->dp_debug;
0263     dp_debug->vdisplay = 0;
0264     dp_debug->hdisplay = 0;
0265     dp_debug->vrefresh = 0;
0266
0267     dp_debug_init(dp_debug, minor);
0268
0269     return dp_debug;
0270  error:
0271     return ERR_PTR(rc);
0272 }
0273
0274 static int dp_debug_deinit(struct dp_debug *dp_debug)
0275 {
0276     struct dp_debug_private *debug;
0277
0278     if (!dp_debug)
0279         return -EINVAL;
0280
0281     debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
0282
0283     debugfs_remove_recursive(debug->root);
0284
0285     return 0;
0286 }
0287
0288 void dp_debug_put(struct dp_debug *dp_debug)
0289 {
0290     struct dp_debug_private *debug;
0291
0292     if (!dp_debug)
0293         return;
0294
0295     debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
0296
0297     dp_debug_deinit(dp_debug);
0298
0299     devm_kfree(debug->dev, debug);
0300 }