Loading...
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_catalog.h"
13#include "dp_aux.h"
14#include "dp_ctrl.h"
15#include "dp_debug.h"
16#include "dp_display.h"
17
18#define DEBUG_NAME "msm_dp"
19
20struct msm_dp_debug_private {
21 struct msm_dp_link *link;
22 struct msm_dp_panel *panel;
23 struct drm_connector *connector;
24};
25
26static int msm_dp_debug_show(struct seq_file *seq, void *p)
27{
28 struct msm_dp_debug_private *debug = seq->private;
29 u64 lclk = 0;
30 u32 link_params_rate;
31 const struct drm_display_mode *drm_mode;
32
33 if (!debug)
34 return -ENODEV;
35
36 drm_mode = &debug->panel->msm_dp_mode.drm_mode;
37
38 seq_printf(seq, "\tname = %s\n", DEBUG_NAME);
39 seq_printf(seq, "\tdrm_dp_link\n\t\trate = %u\n",
40 debug->panel->link_info.rate);
41 seq_printf(seq, "\t\tnum_lanes = %u\n",
42 debug->panel->link_info.num_lanes);
43 seq_printf(seq, "\t\tcapabilities = %lu\n",
44 debug->panel->link_info.capabilities);
45 seq_printf(seq, "\tdp_panel_info:\n\t\tactive = %dx%d\n",
46 drm_mode->hdisplay,
47 drm_mode->vdisplay);
48 seq_printf(seq, "\t\tback_porch = %dx%d\n",
49 drm_mode->htotal - drm_mode->hsync_end,
50 drm_mode->vtotal - drm_mode->vsync_end);
51 seq_printf(seq, "\t\tfront_porch = %dx%d\n",
52 drm_mode->hsync_start - drm_mode->hdisplay,
53 drm_mode->vsync_start - drm_mode->vdisplay);
54 seq_printf(seq, "\t\tsync_width = %dx%d\n",
55 drm_mode->hsync_end - drm_mode->hsync_start,
56 drm_mode->vsync_end - drm_mode->vsync_start);
57 seq_printf(seq, "\t\tactive_low = %dx%d\n",
58 debug->panel->msm_dp_mode.h_active_low,
59 debug->panel->msm_dp_mode.v_active_low);
60 seq_printf(seq, "\t\th_skew = %d\n",
61 drm_mode->hskew);
62 seq_printf(seq, "\t\trefresh rate = %d\n",
63 drm_mode_vrefresh(drm_mode));
64 seq_printf(seq, "\t\tpixel clock khz = %d\n",
65 drm_mode->clock);
66 seq_printf(seq, "\t\tbpp = %d\n",
67 debug->panel->msm_dp_mode.bpp);
68
69 /* Link Information */
70 seq_printf(seq, "\tdp_link:\n\t\ttest_requested = %d\n",
71 debug->link->sink_request);
72 seq_printf(seq, "\t\tnum_lanes = %d\n",
73 debug->link->link_params.num_lanes);
74 link_params_rate = debug->link->link_params.rate;
75 seq_printf(seq, "\t\tbw_code = %d\n",
76 drm_dp_link_rate_to_bw_code(link_params_rate));
77 lclk = debug->link->link_params.rate * 1000;
78 seq_printf(seq, "\t\tlclk = %lld\n", lclk);
79 seq_printf(seq, "\t\tv_level = %d\n",
80 debug->link->phy_params.v_level);
81 seq_printf(seq, "\t\tp_level = %d\n",
82 debug->link->phy_params.p_level);
83
84 return 0;
85}
86DEFINE_SHOW_ATTRIBUTE(msm_dp_debug);
87
88static int msm_dp_test_data_show(struct seq_file *m, void *data)
89{
90 const struct msm_dp_debug_private *debug = m->private;
91 const struct drm_connector *connector = debug->connector;
92 u32 bpc;
93
94 if (connector->status == connector_status_connected) {
95 bpc = debug->link->test_video.test_bit_depth;
96 seq_printf(m, "hdisplay: %d\n",
97 debug->link->test_video.test_h_width);
98 seq_printf(m, "vdisplay: %d\n",
99 debug->link->test_video.test_v_height);
100 seq_printf(m, "bpc: %u\n",
101 msm_dp_link_bit_depth_to_bpp(bpc) / 3);
102 } else {
103 seq_puts(m, "0");
104 }
105
106 return 0;
107}
108DEFINE_SHOW_ATTRIBUTE(msm_dp_test_data);
109
110static int msm_dp_test_type_show(struct seq_file *m, void *data)
111{
112 const struct msm_dp_debug_private *debug = m->private;
113 const struct drm_connector *connector = debug->connector;
114
115 if (connector->status == connector_status_connected)
116 seq_printf(m, "%02x", DP_TEST_LINK_VIDEO_PATTERN);
117 else
118 seq_puts(m, "0");
119
120 return 0;
121}
122DEFINE_SHOW_ATTRIBUTE(msm_dp_test_type);
123
124static ssize_t msm_dp_test_active_write(struct file *file,
125 const char __user *ubuf,
126 size_t len, loff_t *offp)
127{
128 char *input_buffer;
129 int status = 0;
130 const struct msm_dp_debug_private *debug;
131 const struct drm_connector *connector;
132 int val = 0;
133
134 debug = ((struct seq_file *)file->private_data)->private;
135 connector = debug->connector;
136
137 if (len == 0)
138 return 0;
139
140 input_buffer = memdup_user_nul(ubuf, len);
141 if (IS_ERR(input_buffer))
142 return PTR_ERR(input_buffer);
143
144 DRM_DEBUG_DRIVER("Copied %d bytes from user\n", (unsigned int)len);
145
146 if (connector->status == connector_status_connected) {
147 status = kstrtoint(input_buffer, 10, &val);
148 if (status < 0) {
149 kfree(input_buffer);
150 return status;
151 }
152 DRM_DEBUG_DRIVER("Got %d for test active\n", val);
153 /* To prevent erroneous activation of the compliance
154 * testing code, only accept an actual value of 1 here
155 */
156 if (val == 1)
157 debug->panel->video_test = true;
158 else
159 debug->panel->video_test = false;
160 }
161 kfree(input_buffer);
162
163 *offp += len;
164 return len;
165}
166
167static int msm_dp_test_active_show(struct seq_file *m, void *data)
168{
169 struct msm_dp_debug_private *debug = m->private;
170 struct drm_connector *connector = debug->connector;
171
172 if (connector->status == connector_status_connected) {
173 if (debug->panel->video_test)
174 seq_puts(m, "1");
175 else
176 seq_puts(m, "0");
177 } else {
178 seq_puts(m, "0");
179 }
180
181 return 0;
182}
183
184static int msm_dp_test_active_open(struct inode *inode,
185 struct file *file)
186{
187 return single_open(file, msm_dp_test_active_show,
188 inode->i_private);
189}
190
191static const struct file_operations test_active_fops = {
192 .owner = THIS_MODULE,
193 .open = msm_dp_test_active_open,
194 .read = seq_read,
195 .llseek = seq_lseek,
196 .release = single_release,
197 .write = msm_dp_test_active_write
198};
199
200int msm_dp_debug_init(struct device *dev, struct msm_dp_panel *panel,
201 struct msm_dp_link *link,
202 struct drm_connector *connector,
203 struct dentry *root, bool is_edp)
204{
205 struct msm_dp_debug_private *debug;
206
207 if (!dev || !panel || !link) {
208 DRM_ERROR("invalid input\n");
209 return -EINVAL;
210 }
211
212 debug = devm_kzalloc(dev, sizeof(*debug), GFP_KERNEL);
213 if (!debug)
214 return -ENOMEM;
215
216 debug->link = link;
217 debug->panel = panel;
218
219 debugfs_create_file("dp_debug", 0444, root,
220 debug, &msm_dp_debug_fops);
221
222 if (!is_edp) {
223 debugfs_create_file("dp_test_active", 0444,
224 root,
225 debug, &test_active_fops);
226
227 debugfs_create_file("dp_test_data", 0444,
228 root,
229 debug, &msm_dp_test_data_fops);
230
231 debugfs_create_file("dp_test_type", 0444,
232 root,
233 debug, &msm_dp_test_type_fops);
234 }
235
236 return 0;
237}
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
21struct 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
34static 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
46static 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
206static 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}
239DEFINE_SHOW_ATTRIBUTE(dp_test_data);
240
241static 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}
264DEFINE_SHOW_ATTRIBUTE(dp_test_type);
265
266static 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
319static 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
345static 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
352static const struct file_operations dp_debug_fops = {
353 .open = simple_open,
354 .read = dp_debug_read_info,
355};
356
357static 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
366static 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
372 debugfs_create_file("dp_debug", 0444, minor->debugfs_root,
373 debug, &dp_debug_fops);
374
375 debugfs_create_file("msm_dp_test_active", 0444,
376 minor->debugfs_root,
377 debug, &test_active_fops);
378
379 debugfs_create_file("msm_dp_test_data", 0444,
380 minor->debugfs_root,
381 debug, &dp_test_data_fops);
382
383 debugfs_create_file("msm_dp_test_type", 0444,
384 minor->debugfs_root,
385 debug, &dp_test_type_fops);
386
387 debug->root = minor->debugfs_root;
388
389 return rc;
390}
391
392struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
393 struct dp_usbpd *usbpd, struct dp_link *link,
394 struct drm_connector **connector, struct drm_minor *minor)
395{
396 int rc = 0;
397 struct dp_debug_private *debug;
398 struct dp_debug *dp_debug;
399
400 if (!dev || !panel || !usbpd || !link) {
401 DRM_ERROR("invalid input\n");
402 rc = -EINVAL;
403 goto error;
404 }
405
406 debug = devm_kzalloc(dev, sizeof(*debug), GFP_KERNEL);
407 if (!debug) {
408 rc = -ENOMEM;
409 goto error;
410 }
411
412 debug->dp_debug.debug_en = false;
413 debug->usbpd = usbpd;
414 debug->link = link;
415 debug->panel = panel;
416 debug->dev = dev;
417 debug->drm_dev = minor->dev;
418 debug->connector = connector;
419
420 dp_debug = &debug->dp_debug;
421 dp_debug->vdisplay = 0;
422 dp_debug->hdisplay = 0;
423 dp_debug->vrefresh = 0;
424
425 rc = dp_debug_init(dp_debug, minor);
426 if (rc) {
427 devm_kfree(dev, debug);
428 goto error;
429 }
430
431 return dp_debug;
432 error:
433 return ERR_PTR(rc);
434}
435
436static int dp_debug_deinit(struct dp_debug *dp_debug)
437{
438 struct dp_debug_private *debug;
439
440 if (!dp_debug)
441 return -EINVAL;
442
443 debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
444
445 debugfs_remove_recursive(debug->root);
446
447 return 0;
448}
449
450void dp_debug_put(struct dp_debug *dp_debug)
451{
452 struct dp_debug_private *debug;
453
454 if (!dp_debug)
455 return;
456
457 debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
458
459 dp_debug_deinit(dp_debug);
460
461 devm_kfree(debug->dev, debug);
462}