1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
4 */
5
6 #define pr_fmt(fmt) "[drm-dp] %s: " fmt, __func__
7
8 #include <drm/drm_print.h>
9
10 #include "dp_reg.h"
11 #include "dp_link.h"
12 #include "dp_panel.h"
13
14 #define DP_TEST_REQUEST_MASK 0x7F
15
16 enum audio_sample_rate {
17 AUDIO_SAMPLE_RATE_32_KHZ = 0x00,
18 AUDIO_SAMPLE_RATE_44_1_KHZ = 0x01,
19 AUDIO_SAMPLE_RATE_48_KHZ = 0x02,
20 AUDIO_SAMPLE_RATE_88_2_KHZ = 0x03,
21 AUDIO_SAMPLE_RATE_96_KHZ = 0x04,
22 AUDIO_SAMPLE_RATE_176_4_KHZ = 0x05,
23 AUDIO_SAMPLE_RATE_192_KHZ = 0x06,
24 };
25
26 enum audio_pattern_type {
27 AUDIO_TEST_PATTERN_OPERATOR_DEFINED = 0x00,
28 AUDIO_TEST_PATTERN_SAWTOOTH = 0x01,
29 };
30
31 struct dp_link_request {
32 u32 test_requested;
33 u32 test_link_rate;
34 u32 test_lane_count;
35 };
36
37 struct dp_link_private {
38 u32 prev_sink_count;
39 struct drm_device *drm_dev;
40 struct drm_dp_aux *aux;
41 struct dp_link dp_link;
42
43 struct dp_link_request request;
44 struct mutex psm_mutex;
45 u8 link_status[DP_LINK_STATUS_SIZE];
46 };
47
dp_aux_link_power_up(struct drm_dp_aux * aux,struct dp_link_info * link)48 static int dp_aux_link_power_up(struct drm_dp_aux *aux,
49 struct dp_link_info *link)
50 {
51 u8 value;
52 ssize_t len;
53 int i;
54
55 if (link->revision < 0x11)
56 return 0;
57
58 len = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value);
59 if (len < 0)
60 return len;
61
62 value &= ~DP_SET_POWER_MASK;
63 value |= DP_SET_POWER_D0;
64
65 /* retry for 1ms to give the sink time to wake up */
66 for (i = 0; i < 3; i++) {
67 len = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value);
68 usleep_range(1000, 2000);
69 if (len == 1)
70 break;
71 }
72
73 return 0;
74 }
75
dp_aux_link_power_down(struct drm_dp_aux * aux,struct dp_link_info * link)76 static int dp_aux_link_power_down(struct drm_dp_aux *aux,
77 struct dp_link_info *link)
78 {
79 u8 value;
80 int err;
81
82 if (link->revision < 0x11)
83 return 0;
84
85 err = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value);
86 if (err < 0)
87 return err;
88
89 value &= ~DP_SET_POWER_MASK;
90 value |= DP_SET_POWER_D3;
91
92 err = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value);
93 if (err < 0)
94 return err;
95
96 return 0;
97 }
98
dp_link_get_period(struct dp_link_private * link,int const addr)99 static int dp_link_get_period(struct dp_link_private *link, int const addr)
100 {
101 int ret = 0;
102 u8 data;
103 u32 const max_audio_period = 0xA;
104
105 /* TEST_AUDIO_PERIOD_CH_XX */
106 if (drm_dp_dpcd_readb(link->aux, addr, &data) < 0) {
107 DRM_ERROR("failed to read test_audio_period (0x%x)\n", addr);
108 ret = -EINVAL;
109 goto exit;
110 }
111
112 /* Period - Bits 3:0 */
113 data = data & 0xF;
114 if ((int)data > max_audio_period) {
115 DRM_ERROR("invalid test_audio_period_ch_1 = 0x%x\n", data);
116 ret = -EINVAL;
117 goto exit;
118 }
119
120 ret = data;
121 exit:
122 return ret;
123 }
124
dp_link_parse_audio_channel_period(struct dp_link_private * link)125 static int dp_link_parse_audio_channel_period(struct dp_link_private *link)
126 {
127 int ret = 0;
128 struct dp_link_test_audio *req = &link->dp_link.test_audio;
129
130 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH1);
131 if (ret == -EINVAL)
132 goto exit;
133
134 req->test_audio_period_ch_1 = ret;
135 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_1 = 0x%x\n", ret);
136
137 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH2);
138 if (ret == -EINVAL)
139 goto exit;
140
141 req->test_audio_period_ch_2 = ret;
142 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_2 = 0x%x\n", ret);
143
144 /* TEST_AUDIO_PERIOD_CH_3 (Byte 0x275) */
145 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH3);
146 if (ret == -EINVAL)
147 goto exit;
148
149 req->test_audio_period_ch_3 = ret;
150 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_3 = 0x%x\n", ret);
151
152 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH4);
153 if (ret == -EINVAL)
154 goto exit;
155
156 req->test_audio_period_ch_4 = ret;
157 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_4 = 0x%x\n", ret);
158
159 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH5);
160 if (ret == -EINVAL)
161 goto exit;
162
163 req->test_audio_period_ch_5 = ret;
164 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_5 = 0x%x\n", ret);
165
166 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH6);
167 if (ret == -EINVAL)
168 goto exit;
169
170 req->test_audio_period_ch_6 = ret;
171 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_6 = 0x%x\n", ret);
172
173 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH7);
174 if (ret == -EINVAL)
175 goto exit;
176
177 req->test_audio_period_ch_7 = ret;
178 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_7 = 0x%x\n", ret);
179
180 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH8);
181 if (ret == -EINVAL)
182 goto exit;
183
184 req->test_audio_period_ch_8 = ret;
185 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_8 = 0x%x\n", ret);
186 exit:
187 return ret;
188 }
189
dp_link_parse_audio_pattern_type(struct dp_link_private * link)190 static int dp_link_parse_audio_pattern_type(struct dp_link_private *link)
191 {
192 int ret = 0;
193 u8 data;
194 ssize_t rlen;
195 int const max_audio_pattern_type = 0x1;
196
197 rlen = drm_dp_dpcd_readb(link->aux,
198 DP_TEST_AUDIO_PATTERN_TYPE, &data);
199 if (rlen < 0) {
200 DRM_ERROR("failed to read link audio mode. rlen=%zd\n", rlen);
201 return rlen;
202 }
203
204 /* Audio Pattern Type - Bits 7:0 */
205 if ((int)data > max_audio_pattern_type) {
206 DRM_ERROR("invalid audio pattern type = 0x%x\n", data);
207 ret = -EINVAL;
208 goto exit;
209 }
210
211 link->dp_link.test_audio.test_audio_pattern_type = data;
212 drm_dbg_dp(link->drm_dev, "audio pattern type = 0x%x\n", data);
213 exit:
214 return ret;
215 }
216
dp_link_parse_audio_mode(struct dp_link_private * link)217 static int dp_link_parse_audio_mode(struct dp_link_private *link)
218 {
219 int ret = 0;
220 u8 data;
221 ssize_t rlen;
222 int const max_audio_sampling_rate = 0x6;
223 int const max_audio_channel_count = 0x8;
224 int sampling_rate = 0x0;
225 int channel_count = 0x0;
226
227 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_AUDIO_MODE, &data);
228 if (rlen < 0) {
229 DRM_ERROR("failed to read link audio mode. rlen=%zd\n", rlen);
230 return rlen;
231 }
232
233 /* Sampling Rate - Bits 3:0 */
234 sampling_rate = data & 0xF;
235 if (sampling_rate > max_audio_sampling_rate) {
236 DRM_ERROR("sampling rate (0x%x) greater than max (0x%x)\n",
237 sampling_rate, max_audio_sampling_rate);
238 ret = -EINVAL;
239 goto exit;
240 }
241
242 /* Channel Count - Bits 7:4 */
243 channel_count = ((data & 0xF0) >> 4) + 1;
244 if (channel_count > max_audio_channel_count) {
245 DRM_ERROR("channel_count (0x%x) greater than max (0x%x)\n",
246 channel_count, max_audio_channel_count);
247 ret = -EINVAL;
248 goto exit;
249 }
250
251 link->dp_link.test_audio.test_audio_sampling_rate = sampling_rate;
252 link->dp_link.test_audio.test_audio_channel_count = channel_count;
253 drm_dbg_dp(link->drm_dev,
254 "sampling_rate = 0x%x, channel_count = 0x%x\n",
255 sampling_rate, channel_count);
256 exit:
257 return ret;
258 }
259
dp_link_parse_audio_pattern_params(struct dp_link_private * link)260 static int dp_link_parse_audio_pattern_params(struct dp_link_private *link)
261 {
262 int ret = 0;
263
264 ret = dp_link_parse_audio_mode(link);
265 if (ret)
266 goto exit;
267
268 ret = dp_link_parse_audio_pattern_type(link);
269 if (ret)
270 goto exit;
271
272 ret = dp_link_parse_audio_channel_period(link);
273
274 exit:
275 return ret;
276 }
277
dp_link_is_video_pattern_valid(u32 pattern)278 static bool dp_link_is_video_pattern_valid(u32 pattern)
279 {
280 switch (pattern) {
281 case DP_NO_TEST_PATTERN:
282 case DP_COLOR_RAMP:
283 case DP_BLACK_AND_WHITE_VERTICAL_LINES:
284 case DP_COLOR_SQUARE:
285 return true;
286 default:
287 return false;
288 }
289 }
290
291 /**
292 * dp_link_is_bit_depth_valid() - validates the bit depth requested
293 * @tbd: bit depth requested by the sink
294 *
295 * Returns true if the requested bit depth is supported.
296 */
dp_link_is_bit_depth_valid(u32 tbd)297 static bool dp_link_is_bit_depth_valid(u32 tbd)
298 {
299 /* DP_TEST_VIDEO_PATTERN_NONE is treated as invalid */
300 switch (tbd) {
301 case DP_TEST_BIT_DEPTH_6:
302 case DP_TEST_BIT_DEPTH_8:
303 case DP_TEST_BIT_DEPTH_10:
304 return true;
305 default:
306 return false;
307 }
308 }
309
dp_link_parse_timing_params1(struct dp_link_private * link,int addr,int len,u32 * val)310 static int dp_link_parse_timing_params1(struct dp_link_private *link,
311 int addr, int len, u32 *val)
312 {
313 u8 bp[2];
314 int rlen;
315
316 if (len != 2)
317 return -EINVAL;
318
319 /* Read the requested video link pattern (Byte 0x221). */
320 rlen = drm_dp_dpcd_read(link->aux, addr, bp, len);
321 if (rlen < len) {
322 DRM_ERROR("failed to read 0x%x\n", addr);
323 return -EINVAL;
324 }
325
326 *val = bp[1] | (bp[0] << 8);
327
328 return 0;
329 }
330
dp_link_parse_timing_params2(struct dp_link_private * link,int addr,int len,u32 * val1,u32 * val2)331 static int dp_link_parse_timing_params2(struct dp_link_private *link,
332 int addr, int len,
333 u32 *val1, u32 *val2)
334 {
335 u8 bp[2];
336 int rlen;
337
338 if (len != 2)
339 return -EINVAL;
340
341 /* Read the requested video link pattern (Byte 0x221). */
342 rlen = drm_dp_dpcd_read(link->aux, addr, bp, len);
343 if (rlen < len) {
344 DRM_ERROR("failed to read 0x%x\n", addr);
345 return -EINVAL;
346 }
347
348 *val1 = (bp[0] & BIT(7)) >> 7;
349 *val2 = bp[1] | ((bp[0] & 0x7F) << 8);
350
351 return 0;
352 }
353
dp_link_parse_timing_params3(struct dp_link_private * link,int addr,u32 * val)354 static int dp_link_parse_timing_params3(struct dp_link_private *link,
355 int addr, u32 *val)
356 {
357 u8 bp;
358 u32 len = 1;
359 int rlen;
360
361 rlen = drm_dp_dpcd_read(link->aux, addr, &bp, len);
362 if (rlen < 1) {
363 DRM_ERROR("failed to read 0x%x\n", addr);
364 return -EINVAL;
365 }
366 *val = bp;
367
368 return 0;
369 }
370
371 /**
372 * dp_link_parse_video_pattern_params() - parses video pattern parameters from DPCD
373 * @link: Display Port Driver data
374 *
375 * Returns 0 if it successfully parses the video link pattern and the link
376 * bit depth requested by the sink and, and if the values parsed are valid.
377 */
dp_link_parse_video_pattern_params(struct dp_link_private * link)378 static int dp_link_parse_video_pattern_params(struct dp_link_private *link)
379 {
380 int ret = 0;
381 ssize_t rlen;
382 u8 bp;
383
384 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_PATTERN, &bp);
385 if (rlen < 0) {
386 DRM_ERROR("failed to read link video pattern. rlen=%zd\n",
387 rlen);
388 return rlen;
389 }
390
391 if (!dp_link_is_video_pattern_valid(bp)) {
392 DRM_ERROR("invalid link video pattern = 0x%x\n", bp);
393 ret = -EINVAL;
394 return ret;
395 }
396
397 link->dp_link.test_video.test_video_pattern = bp;
398
399 /* Read the requested color bit depth and dynamic range (Byte 0x232) */
400 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_MISC0, &bp);
401 if (rlen < 0) {
402 DRM_ERROR("failed to read link bit depth. rlen=%zd\n", rlen);
403 return rlen;
404 }
405
406 /* Dynamic Range */
407 link->dp_link.test_video.test_dyn_range =
408 (bp & DP_TEST_DYNAMIC_RANGE_CEA);
409
410 /* Color bit depth */
411 bp &= DP_TEST_BIT_DEPTH_MASK;
412 if (!dp_link_is_bit_depth_valid(bp)) {
413 DRM_ERROR("invalid link bit depth = 0x%x\n", bp);
414 ret = -EINVAL;
415 return ret;
416 }
417
418 link->dp_link.test_video.test_bit_depth = bp;
419
420 /* resolution timing params */
421 ret = dp_link_parse_timing_params1(link, DP_TEST_H_TOTAL_HI, 2,
422 &link->dp_link.test_video.test_h_total);
423 if (ret) {
424 DRM_ERROR("failed to parse test_htotal(DP_TEST_H_TOTAL_HI)\n");
425 return ret;
426 }
427
428 ret = dp_link_parse_timing_params1(link, DP_TEST_V_TOTAL_HI, 2,
429 &link->dp_link.test_video.test_v_total);
430 if (ret) {
431 DRM_ERROR("failed to parse test_v_total(DP_TEST_V_TOTAL_HI)\n");
432 return ret;
433 }
434
435 ret = dp_link_parse_timing_params1(link, DP_TEST_H_START_HI, 2,
436 &link->dp_link.test_video.test_h_start);
437 if (ret) {
438 DRM_ERROR("failed to parse test_h_start(DP_TEST_H_START_HI)\n");
439 return ret;
440 }
441
442 ret = dp_link_parse_timing_params1(link, DP_TEST_V_START_HI, 2,
443 &link->dp_link.test_video.test_v_start);
444 if (ret) {
445 DRM_ERROR("failed to parse test_v_start(DP_TEST_V_START_HI)\n");
446 return ret;
447 }
448
449 ret = dp_link_parse_timing_params2(link, DP_TEST_HSYNC_HI, 2,
450 &link->dp_link.test_video.test_hsync_pol,
451 &link->dp_link.test_video.test_hsync_width);
452 if (ret) {
453 DRM_ERROR("failed to parse (DP_TEST_HSYNC_HI)\n");
454 return ret;
455 }
456
457 ret = dp_link_parse_timing_params2(link, DP_TEST_VSYNC_HI, 2,
458 &link->dp_link.test_video.test_vsync_pol,
459 &link->dp_link.test_video.test_vsync_width);
460 if (ret) {
461 DRM_ERROR("failed to parse (DP_TEST_VSYNC_HI)\n");
462 return ret;
463 }
464
465 ret = dp_link_parse_timing_params1(link, DP_TEST_H_WIDTH_HI, 2,
466 &link->dp_link.test_video.test_h_width);
467 if (ret) {
468 DRM_ERROR("failed to parse test_h_width(DP_TEST_H_WIDTH_HI)\n");
469 return ret;
470 }
471
472 ret = dp_link_parse_timing_params1(link, DP_TEST_V_HEIGHT_HI, 2,
473 &link->dp_link.test_video.test_v_height);
474 if (ret) {
475 DRM_ERROR("failed to parse test_v_height\n");
476 return ret;
477 }
478
479 ret = dp_link_parse_timing_params3(link, DP_TEST_MISC1,
480 &link->dp_link.test_video.test_rr_d);
481 link->dp_link.test_video.test_rr_d &= DP_TEST_REFRESH_DENOMINATOR;
482 if (ret) {
483 DRM_ERROR("failed to parse test_rr_d (DP_TEST_MISC1)\n");
484 return ret;
485 }
486
487 ret = dp_link_parse_timing_params3(link, DP_TEST_REFRESH_RATE_NUMERATOR,
488 &link->dp_link.test_video.test_rr_n);
489 if (ret) {
490 DRM_ERROR("failed to parse test_rr_n\n");
491 return ret;
492 }
493
494 drm_dbg_dp(link->drm_dev,
495 "link video pattern = 0x%x\n"
496 "link dynamic range = 0x%x\n"
497 "link bit depth = 0x%x\n"
498 "TEST_H_TOTAL = %d, TEST_V_TOTAL = %d\n"
499 "TEST_H_START = %d, TEST_V_START = %d\n"
500 "TEST_HSYNC_POL = %d\n"
501 "TEST_HSYNC_WIDTH = %d\n"
502 "TEST_VSYNC_POL = %d\n"
503 "TEST_VSYNC_WIDTH = %d\n"
504 "TEST_H_WIDTH = %d\n"
505 "TEST_V_HEIGHT = %d\n"
506 "TEST_REFRESH_DENOMINATOR = %d\n"
507 "TEST_REFRESH_NUMERATOR = %d\n",
508 link->dp_link.test_video.test_video_pattern,
509 link->dp_link.test_video.test_dyn_range,
510 link->dp_link.test_video.test_bit_depth,
511 link->dp_link.test_video.test_h_total,
512 link->dp_link.test_video.test_v_total,
513 link->dp_link.test_video.test_h_start,
514 link->dp_link.test_video.test_v_start,
515 link->dp_link.test_video.test_hsync_pol,
516 link->dp_link.test_video.test_hsync_width,
517 link->dp_link.test_video.test_vsync_pol,
518 link->dp_link.test_video.test_vsync_width,
519 link->dp_link.test_video.test_h_width,
520 link->dp_link.test_video.test_v_height,
521 link->dp_link.test_video.test_rr_d,
522 link->dp_link.test_video.test_rr_n);
523
524 return ret;
525 }
526
527 /**
528 * dp_link_parse_link_training_params() - parses link training parameters from
529 * DPCD
530 * @link: Display Port Driver data
531 *
532 * Returns 0 if it successfully parses the link rate (Byte 0x219) and lane
533 * count (Byte 0x220), and if these values parse are valid.
534 */
dp_link_parse_link_training_params(struct dp_link_private * link)535 static int dp_link_parse_link_training_params(struct dp_link_private *link)
536 {
537 u8 bp;
538 ssize_t rlen;
539
540 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_LINK_RATE, &bp);
541 if (rlen < 0) {
542 DRM_ERROR("failed to read link rate. rlen=%zd\n", rlen);
543 return rlen;
544 }
545
546 if (!is_link_rate_valid(bp)) {
547 DRM_ERROR("invalid link rate = 0x%x\n", bp);
548 return -EINVAL;
549 }
550
551 link->request.test_link_rate = bp;
552 drm_dbg_dp(link->drm_dev, "link rate = 0x%x\n",
553 link->request.test_link_rate);
554
555 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_LANE_COUNT, &bp);
556 if (rlen < 0) {
557 DRM_ERROR("failed to read lane count. rlen=%zd\n", rlen);
558 return rlen;
559 }
560 bp &= DP_MAX_LANE_COUNT_MASK;
561
562 if (!is_lane_count_valid(bp)) {
563 DRM_ERROR("invalid lane count = 0x%x\n", bp);
564 return -EINVAL;
565 }
566
567 link->request.test_lane_count = bp;
568 drm_dbg_dp(link->drm_dev, "lane count = 0x%x\n",
569 link->request.test_lane_count);
570 return 0;
571 }
572
573 /**
574 * dp_link_parse_phy_test_params() - parses the phy link parameters
575 * @link: Display Port Driver data
576 *
577 * Parses the DPCD (Byte 0x248) for the DP PHY link pattern that is being
578 * requested.
579 */
dp_link_parse_phy_test_params(struct dp_link_private * link)580 static int dp_link_parse_phy_test_params(struct dp_link_private *link)
581 {
582 u8 data;
583 ssize_t rlen;
584
585 rlen = drm_dp_dpcd_readb(link->aux, DP_PHY_TEST_PATTERN,
586 &data);
587 if (rlen < 0) {
588 DRM_ERROR("failed to read phy link pattern. rlen=%zd\n", rlen);
589 return rlen;
590 }
591
592 link->dp_link.phy_params.phy_test_pattern_sel = data & 0x07;
593
594 drm_dbg_dp(link->drm_dev, "phy_test_pattern_sel = 0x%x\n", data);
595
596 switch (data) {
597 case DP_PHY_TEST_PATTERN_SEL_MASK:
598 case DP_PHY_TEST_PATTERN_NONE:
599 case DP_PHY_TEST_PATTERN_D10_2:
600 case DP_PHY_TEST_PATTERN_ERROR_COUNT:
601 case DP_PHY_TEST_PATTERN_PRBS7:
602 case DP_PHY_TEST_PATTERN_80BIT_CUSTOM:
603 case DP_PHY_TEST_PATTERN_CP2520:
604 return 0;
605 default:
606 return -EINVAL;
607 }
608 }
609
610 /**
611 * dp_link_is_video_audio_test_requested() - checks for audio/video link request
612 * @link: link requested by the sink
613 *
614 * Returns true if the requested link is a permitted audio/video link.
615 */
dp_link_is_video_audio_test_requested(u32 link)616 static bool dp_link_is_video_audio_test_requested(u32 link)
617 {
618 u8 video_audio_test = (DP_TEST_LINK_VIDEO_PATTERN |
619 DP_TEST_LINK_AUDIO_PATTERN |
620 DP_TEST_LINK_AUDIO_DISABLED_VIDEO);
621
622 return ((link & video_audio_test) &&
623 !(link & ~video_audio_test));
624 }
625
626 /**
627 * dp_link_parse_request() - parses link request parameters from sink
628 * @link: Display Port Driver data
629 *
630 * Parses the DPCD to check if an automated link is requested (Byte 0x201),
631 * and what type of link automation is being requested (Byte 0x218).
632 */
dp_link_parse_request(struct dp_link_private * link)633 static int dp_link_parse_request(struct dp_link_private *link)
634 {
635 int ret = 0;
636 u8 data;
637 ssize_t rlen;
638
639 /**
640 * Read the device service IRQ vector (Byte 0x201) to determine
641 * whether an automated link has been requested by the sink.
642 */
643 rlen = drm_dp_dpcd_readb(link->aux,
644 DP_DEVICE_SERVICE_IRQ_VECTOR, &data);
645 if (rlen < 0) {
646 DRM_ERROR("aux read failed. rlen=%zd\n", rlen);
647 return rlen;
648 }
649
650 drm_dbg_dp(link->drm_dev, "device service irq vector = 0x%x\n", data);
651
652 if (!(data & DP_AUTOMATED_TEST_REQUEST)) {
653 drm_dbg_dp(link->drm_dev, "no test requested\n");
654 return 0;
655 }
656
657 /**
658 * Read the link request byte (Byte 0x218) to determine what type
659 * of automated link has been requested by the sink.
660 */
661 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_REQUEST, &data);
662 if (rlen < 0) {
663 DRM_ERROR("aux read failed. rlen=%zd\n", rlen);
664 return rlen;
665 }
666
667 if (!data || (data == DP_TEST_LINK_FAUX_PATTERN)) {
668 drm_dbg_dp(link->drm_dev, "link 0x%x not supported\n", data);
669 goto end;
670 }
671
672 drm_dbg_dp(link->drm_dev, "Test:(0x%x) requested\n", data);
673 link->request.test_requested = data;
674 if (link->request.test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) {
675 ret = dp_link_parse_phy_test_params(link);
676 if (ret)
677 goto end;
678 ret = dp_link_parse_link_training_params(link);
679 if (ret)
680 goto end;
681 }
682
683 if (link->request.test_requested == DP_TEST_LINK_TRAINING) {
684 ret = dp_link_parse_link_training_params(link);
685 if (ret)
686 goto end;
687 }
688
689 if (dp_link_is_video_audio_test_requested(
690 link->request.test_requested)) {
691 ret = dp_link_parse_video_pattern_params(link);
692 if (ret)
693 goto end;
694
695 ret = dp_link_parse_audio_pattern_params(link);
696 }
697 end:
698 /*
699 * Send a DP_TEST_ACK if all link parameters are valid, otherwise send
700 * a DP_TEST_NAK.
701 */
702 if (ret) {
703 link->dp_link.test_response = DP_TEST_NAK;
704 } else {
705 if (link->request.test_requested != DP_TEST_LINK_EDID_READ)
706 link->dp_link.test_response = DP_TEST_ACK;
707 else
708 link->dp_link.test_response =
709 DP_TEST_EDID_CHECKSUM_WRITE;
710 }
711
712 return ret;
713 }
714
dp_link_parse_sink_status_field(struct dp_link_private * link)715 static int dp_link_parse_sink_status_field(struct dp_link_private *link)
716 {
717 int len;
718
719 link->prev_sink_count = link->dp_link.sink_count;
720 len = drm_dp_read_sink_count(link->aux);
721 if (len < 0) {
722 DRM_ERROR("DP parse sink count failed\n");
723 return len;
724 }
725 link->dp_link.sink_count = len;
726
727 len = drm_dp_dpcd_read_link_status(link->aux,
728 link->link_status);
729 if (len < DP_LINK_STATUS_SIZE) {
730 DRM_ERROR("DP link status read failed\n");
731 return len;
732 }
733
734 return dp_link_parse_request(link);
735 }
736
737 /**
738 * dp_link_process_link_training_request() - processes new training requests
739 * @link: Display Port link data
740 *
741 * This function will handle new link training requests that are initiated by
742 * the sink. In particular, it will update the requested lane count and link
743 * rate, and then trigger the link retraining procedure.
744 *
745 * The function will return 0 if a link training request has been processed,
746 * otherwise it will return -EINVAL.
747 */
dp_link_process_link_training_request(struct dp_link_private * link)748 static int dp_link_process_link_training_request(struct dp_link_private *link)
749 {
750 if (link->request.test_requested != DP_TEST_LINK_TRAINING)
751 return -EINVAL;
752
753 drm_dbg_dp(link->drm_dev,
754 "Test:0x%x link rate = 0x%x, lane count = 0x%x\n",
755 DP_TEST_LINK_TRAINING,
756 link->request.test_link_rate,
757 link->request.test_lane_count);
758
759 link->dp_link.link_params.num_lanes = link->request.test_lane_count;
760 link->dp_link.link_params.rate =
761 drm_dp_bw_code_to_link_rate(link->request.test_link_rate);
762
763 return 0;
764 }
765
dp_link_send_test_response(struct dp_link * dp_link)766 bool dp_link_send_test_response(struct dp_link *dp_link)
767 {
768 struct dp_link_private *link = NULL;
769 int ret = 0;
770
771 if (!dp_link) {
772 DRM_ERROR("invalid input\n");
773 return false;
774 }
775
776 link = container_of(dp_link, struct dp_link_private, dp_link);
777
778 ret = drm_dp_dpcd_writeb(link->aux, DP_TEST_RESPONSE,
779 dp_link->test_response);
780
781 return ret == 1;
782 }
783
dp_link_psm_config(struct dp_link * dp_link,struct dp_link_info * link_info,bool enable)784 int dp_link_psm_config(struct dp_link *dp_link,
785 struct dp_link_info *link_info, bool enable)
786 {
787 struct dp_link_private *link = NULL;
788 int ret = 0;
789
790 if (!dp_link) {
791 DRM_ERROR("invalid params\n");
792 return -EINVAL;
793 }
794
795 link = container_of(dp_link, struct dp_link_private, dp_link);
796
797 mutex_lock(&link->psm_mutex);
798 if (enable)
799 ret = dp_aux_link_power_down(link->aux, link_info);
800 else
801 ret = dp_aux_link_power_up(link->aux, link_info);
802
803 if (ret)
804 DRM_ERROR("Failed to %s low power mode\n", enable ?
805 "enter" : "exit");
806
807 mutex_unlock(&link->psm_mutex);
808 return ret;
809 }
810
dp_link_send_edid_checksum(struct dp_link * dp_link,u8 checksum)811 bool dp_link_send_edid_checksum(struct dp_link *dp_link, u8 checksum)
812 {
813 struct dp_link_private *link = NULL;
814 int ret = 0;
815
816 if (!dp_link) {
817 DRM_ERROR("invalid input\n");
818 return false;
819 }
820
821 link = container_of(dp_link, struct dp_link_private, dp_link);
822
823 ret = drm_dp_dpcd_writeb(link->aux, DP_TEST_EDID_CHECKSUM,
824 checksum);
825 return ret == 1;
826 }
827
dp_link_parse_vx_px(struct dp_link_private * link)828 static void dp_link_parse_vx_px(struct dp_link_private *link)
829 {
830 drm_dbg_dp(link->drm_dev, "vx: 0=%d, 1=%d, 2=%d, 3=%d\n",
831 drm_dp_get_adjust_request_voltage(link->link_status, 0),
832 drm_dp_get_adjust_request_voltage(link->link_status, 1),
833 drm_dp_get_adjust_request_voltage(link->link_status, 2),
834 drm_dp_get_adjust_request_voltage(link->link_status, 3));
835
836 drm_dbg_dp(link->drm_dev, "px: 0=%d, 1=%d, 2=%d, 3=%d\n",
837 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 0),
838 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 1),
839 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 2),
840 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 3));
841
842 /**
843 * Update the voltage and pre-emphasis levels as per DPCD request
844 * vector.
845 */
846 drm_dbg_dp(link->drm_dev,
847 "Current: v_level = 0x%x, p_level = 0x%x\n",
848 link->dp_link.phy_params.v_level,
849 link->dp_link.phy_params.p_level);
850 link->dp_link.phy_params.v_level =
851 drm_dp_get_adjust_request_voltage(link->link_status, 0);
852 link->dp_link.phy_params.p_level =
853 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 0);
854
855 link->dp_link.phy_params.p_level >>= DP_TRAIN_PRE_EMPHASIS_SHIFT;
856
857 drm_dbg_dp(link->drm_dev,
858 "Requested: v_level = 0x%x, p_level = 0x%x\n",
859 link->dp_link.phy_params.v_level,
860 link->dp_link.phy_params.p_level);
861 }
862
863 /**
864 * dp_link_process_phy_test_pattern_request() - process new phy link requests
865 * @link: Display Port Driver data
866 *
867 * This function will handle new phy link pattern requests that are initiated
868 * by the sink. The function will return 0 if a phy link pattern has been
869 * processed, otherwise it will return -EINVAL.
870 */
dp_link_process_phy_test_pattern_request(struct dp_link_private * link)871 static int dp_link_process_phy_test_pattern_request(
872 struct dp_link_private *link)
873 {
874 if (!(link->request.test_requested & DP_TEST_LINK_PHY_TEST_PATTERN)) {
875 drm_dbg_dp(link->drm_dev, "no phy test\n");
876 return -EINVAL;
877 }
878
879 if (!is_link_rate_valid(link->request.test_link_rate) ||
880 !is_lane_count_valid(link->request.test_lane_count)) {
881 DRM_ERROR("Invalid: link rate = 0x%x,lane count = 0x%x\n",
882 link->request.test_link_rate,
883 link->request.test_lane_count);
884 return -EINVAL;
885 }
886
887 drm_dbg_dp(link->drm_dev,
888 "Current: rate = 0x%x, lane count = 0x%x\n",
889 link->dp_link.link_params.rate,
890 link->dp_link.link_params.num_lanes);
891
892 drm_dbg_dp(link->drm_dev,
893 "Requested: rate = 0x%x, lane count = 0x%x\n",
894 link->request.test_link_rate,
895 link->request.test_lane_count);
896
897 link->dp_link.link_params.num_lanes = link->request.test_lane_count;
898 link->dp_link.link_params.rate =
899 drm_dp_bw_code_to_link_rate(link->request.test_link_rate);
900
901 dp_link_parse_vx_px(link);
902
903 return 0;
904 }
905
dp_link_read_psr_error_status(struct dp_link_private * link)906 static bool dp_link_read_psr_error_status(struct dp_link_private *link)
907 {
908 u8 status;
909
910 drm_dp_dpcd_read(link->aux, DP_PSR_ERROR_STATUS, &status, 1);
911
912 if (status & DP_PSR_LINK_CRC_ERROR)
913 DRM_ERROR("PSR LINK CRC ERROR\n");
914 else if (status & DP_PSR_RFB_STORAGE_ERROR)
915 DRM_ERROR("PSR RFB STORAGE ERROR\n");
916 else if (status & DP_PSR_VSC_SDP_UNCORRECTABLE_ERROR)
917 DRM_ERROR("PSR VSC SDP UNCORRECTABLE ERROR\n");
918 else
919 return false;
920
921 return true;
922 }
923
dp_link_psr_capability_changed(struct dp_link_private * link)924 static bool dp_link_psr_capability_changed(struct dp_link_private *link)
925 {
926 u8 status;
927
928 drm_dp_dpcd_read(link->aux, DP_PSR_ESI, &status, 1);
929
930 if (status & DP_PSR_CAPS_CHANGE) {
931 drm_dbg_dp(link->drm_dev, "PSR Capability Change\n");
932 return true;
933 }
934
935 return false;
936 }
937
get_link_status(const u8 link_status[DP_LINK_STATUS_SIZE],int r)938 static u8 get_link_status(const u8 link_status[DP_LINK_STATUS_SIZE], int r)
939 {
940 return link_status[r - DP_LANE0_1_STATUS];
941 }
942
943 /**
944 * dp_link_process_link_status_update() - processes link status updates
945 * @link: Display Port link module data
946 *
947 * This function will check for changes in the link status, e.g. clock
948 * recovery done on all lanes, and trigger link training if there is a
949 * failure/error on the link.
950 *
951 * The function will return 0 if the a link status update has been processed,
952 * otherwise it will return -EINVAL.
953 */
dp_link_process_link_status_update(struct dp_link_private * link)954 static int dp_link_process_link_status_update(struct dp_link_private *link)
955 {
956 bool channel_eq_done = drm_dp_channel_eq_ok(link->link_status,
957 link->dp_link.link_params.num_lanes);
958
959 bool clock_recovery_done = drm_dp_clock_recovery_ok(link->link_status,
960 link->dp_link.link_params.num_lanes);
961
962 drm_dbg_dp(link->drm_dev,
963 "channel_eq_done = %d, clock_recovery_done = %d\n",
964 channel_eq_done, clock_recovery_done);
965
966 if (channel_eq_done && clock_recovery_done)
967 return -EINVAL;
968
969 return 0;
970 }
971
972 /**
973 * dp_link_process_ds_port_status_change() - process port status changes
974 * @link: Display Port Driver data
975 *
976 * This function will handle downstream port updates that are initiated by
977 * the sink. If the downstream port status has changed, the EDID is read via
978 * AUX.
979 *
980 * The function will return 0 if a downstream port update has been
981 * processed, otherwise it will return -EINVAL.
982 */
dp_link_process_ds_port_status_change(struct dp_link_private * link)983 static int dp_link_process_ds_port_status_change(struct dp_link_private *link)
984 {
985 if (get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) &
986 DP_DOWNSTREAM_PORT_STATUS_CHANGED)
987 goto reset;
988
989 if (link->prev_sink_count == link->dp_link.sink_count)
990 return -EINVAL;
991
992 reset:
993 /* reset prev_sink_count */
994 link->prev_sink_count = link->dp_link.sink_count;
995
996 return 0;
997 }
998
dp_link_is_video_pattern_requested(struct dp_link_private * link)999 static bool dp_link_is_video_pattern_requested(struct dp_link_private *link)
1000 {
1001 return (link->request.test_requested & DP_TEST_LINK_VIDEO_PATTERN)
1002 && !(link->request.test_requested &
1003 DP_TEST_LINK_AUDIO_DISABLED_VIDEO);
1004 }
1005
dp_link_is_audio_pattern_requested(struct dp_link_private * link)1006 static bool dp_link_is_audio_pattern_requested(struct dp_link_private *link)
1007 {
1008 return (link->request.test_requested & DP_TEST_LINK_AUDIO_PATTERN);
1009 }
1010
dp_link_reset_data(struct dp_link_private * link)1011 static void dp_link_reset_data(struct dp_link_private *link)
1012 {
1013 link->request = (const struct dp_link_request){ 0 };
1014 link->dp_link.test_video = (const struct dp_link_test_video){ 0 };
1015 link->dp_link.test_video.test_bit_depth = DP_TEST_BIT_DEPTH_UNKNOWN;
1016 link->dp_link.test_audio = (const struct dp_link_test_audio){ 0 };
1017 link->dp_link.phy_params.phy_test_pattern_sel = 0;
1018 link->dp_link.sink_request = 0;
1019 link->dp_link.test_response = 0;
1020 }
1021
1022 /**
1023 * dp_link_process_request() - handle HPD IRQ transition to HIGH
1024 * @dp_link: pointer to link module data
1025 *
1026 * This function will handle the HPD IRQ state transitions from LOW to HIGH
1027 * (including cases when there are back to back HPD IRQ HIGH) indicating
1028 * the start of a new link training request or sink status update.
1029 */
dp_link_process_request(struct dp_link * dp_link)1030 int dp_link_process_request(struct dp_link *dp_link)
1031 {
1032 int ret = 0;
1033 struct dp_link_private *link;
1034
1035 if (!dp_link) {
1036 DRM_ERROR("invalid input\n");
1037 return -EINVAL;
1038 }
1039
1040 link = container_of(dp_link, struct dp_link_private, dp_link);
1041
1042 dp_link_reset_data(link);
1043
1044 ret = dp_link_parse_sink_status_field(link);
1045 if (ret)
1046 return ret;
1047
1048 if (link->request.test_requested == DP_TEST_LINK_EDID_READ) {
1049 dp_link->sink_request |= DP_TEST_LINK_EDID_READ;
1050 } else if (!dp_link_process_ds_port_status_change(link)) {
1051 dp_link->sink_request |= DS_PORT_STATUS_CHANGED;
1052 } else if (!dp_link_process_link_training_request(link)) {
1053 dp_link->sink_request |= DP_TEST_LINK_TRAINING;
1054 } else if (!dp_link_process_phy_test_pattern_request(link)) {
1055 dp_link->sink_request |= DP_TEST_LINK_PHY_TEST_PATTERN;
1056 } else if (dp_link_read_psr_error_status(link)) {
1057 DRM_ERROR("PSR IRQ_HPD received\n");
1058 } else if (dp_link_psr_capability_changed(link)) {
1059 drm_dbg_dp(link->drm_dev, "PSR Capability changed\n");
1060 } else {
1061 ret = dp_link_process_link_status_update(link);
1062 if (!ret) {
1063 dp_link->sink_request |= DP_LINK_STATUS_UPDATED;
1064 } else {
1065 if (dp_link_is_video_pattern_requested(link)) {
1066 ret = 0;
1067 dp_link->sink_request |= DP_TEST_LINK_VIDEO_PATTERN;
1068 }
1069 if (dp_link_is_audio_pattern_requested(link)) {
1070 dp_link->sink_request |= DP_TEST_LINK_AUDIO_PATTERN;
1071 ret = -EINVAL;
1072 }
1073 }
1074 }
1075
1076 drm_dbg_dp(link->drm_dev, "sink request=%#x\n",
1077 dp_link->sink_request);
1078 return ret;
1079 }
1080
dp_link_get_colorimetry_config(struct dp_link * dp_link)1081 int dp_link_get_colorimetry_config(struct dp_link *dp_link)
1082 {
1083 u32 cc = DP_MISC0_COLORIMERY_CFG_LEGACY_RGB;
1084 struct dp_link_private *link;
1085
1086 if (!dp_link) {
1087 DRM_ERROR("invalid input\n");
1088 return -EINVAL;
1089 }
1090
1091 link = container_of(dp_link, struct dp_link_private, dp_link);
1092
1093 /*
1094 * Unless a video pattern CTS test is ongoing, use RGB_VESA
1095 * Only RGB_VESA and RGB_CEA supported for now
1096 */
1097 if (dp_link_is_video_pattern_requested(link)) {
1098 if (link->dp_link.test_video.test_dyn_range &
1099 DP_TEST_DYNAMIC_RANGE_CEA)
1100 cc = DP_MISC0_COLORIMERY_CFG_CEA_RGB;
1101 }
1102
1103 return cc;
1104 }
1105
dp_link_adjust_levels(struct dp_link * dp_link,u8 * link_status)1106 int dp_link_adjust_levels(struct dp_link *dp_link, u8 *link_status)
1107 {
1108 int i;
1109 u8 max_p_level;
1110 int v_max = 0, p_max = 0;
1111 struct dp_link_private *link;
1112
1113 if (!dp_link) {
1114 DRM_ERROR("invalid input\n");
1115 return -EINVAL;
1116 }
1117
1118 link = container_of(dp_link, struct dp_link_private, dp_link);
1119
1120 /* use the max level across lanes */
1121 for (i = 0; i < dp_link->link_params.num_lanes; i++) {
1122 u8 data_v = drm_dp_get_adjust_request_voltage(link_status, i);
1123 u8 data_p = drm_dp_get_adjust_request_pre_emphasis(link_status,
1124 i);
1125 drm_dbg_dp(link->drm_dev,
1126 "lane=%d req_vol_swing=%d req_pre_emphasis=%d\n",
1127 i, data_v, data_p);
1128 if (v_max < data_v)
1129 v_max = data_v;
1130 if (p_max < data_p)
1131 p_max = data_p;
1132 }
1133
1134 dp_link->phy_params.v_level = v_max >> DP_TRAIN_VOLTAGE_SWING_SHIFT;
1135 dp_link->phy_params.p_level = p_max >> DP_TRAIN_PRE_EMPHASIS_SHIFT;
1136
1137 /**
1138 * Adjust the voltage swing and pre-emphasis level combination to within
1139 * the allowable range.
1140 */
1141 if (dp_link->phy_params.v_level > DP_TRAIN_LEVEL_MAX) {
1142 drm_dbg_dp(link->drm_dev,
1143 "Requested vSwingLevel=%d, change to %d\n",
1144 dp_link->phy_params.v_level,
1145 DP_TRAIN_LEVEL_MAX);
1146 dp_link->phy_params.v_level = DP_TRAIN_LEVEL_MAX;
1147 }
1148
1149 if (dp_link->phy_params.p_level > DP_TRAIN_LEVEL_MAX) {
1150 drm_dbg_dp(link->drm_dev,
1151 "Requested preEmphasisLevel=%d, change to %d\n",
1152 dp_link->phy_params.p_level,
1153 DP_TRAIN_LEVEL_MAX);
1154 dp_link->phy_params.p_level = DP_TRAIN_LEVEL_MAX;
1155 }
1156
1157 max_p_level = DP_TRAIN_LEVEL_MAX - dp_link->phy_params.v_level;
1158 if (dp_link->phy_params.p_level > max_p_level) {
1159 drm_dbg_dp(link->drm_dev,
1160 "Requested preEmphasisLevel=%d, change to %d\n",
1161 dp_link->phy_params.p_level,
1162 max_p_level);
1163 dp_link->phy_params.p_level = max_p_level;
1164 }
1165
1166 drm_dbg_dp(link->drm_dev, "adjusted: v_level=%d, p_level=%d\n",
1167 dp_link->phy_params.v_level, dp_link->phy_params.p_level);
1168
1169 return 0;
1170 }
1171
dp_link_reset_phy_params_vx_px(struct dp_link * dp_link)1172 void dp_link_reset_phy_params_vx_px(struct dp_link *dp_link)
1173 {
1174 dp_link->phy_params.v_level = 0;
1175 dp_link->phy_params.p_level = 0;
1176 }
1177
dp_link_get_test_bits_depth(struct dp_link * dp_link,u32 bpp)1178 u32 dp_link_get_test_bits_depth(struct dp_link *dp_link, u32 bpp)
1179 {
1180 u32 tbd;
1181 struct dp_link_private *link;
1182
1183 link = container_of(dp_link, struct dp_link_private, dp_link);
1184
1185 /*
1186 * Few simplistic rules and assumptions made here:
1187 * 1. Test bit depth is bit depth per color component
1188 * 2. Assume 3 color components
1189 */
1190 switch (bpp) {
1191 case 18:
1192 tbd = DP_TEST_BIT_DEPTH_6;
1193 break;
1194 case 24:
1195 tbd = DP_TEST_BIT_DEPTH_8;
1196 break;
1197 case 30:
1198 tbd = DP_TEST_BIT_DEPTH_10;
1199 break;
1200 default:
1201 drm_dbg_dp(link->drm_dev, "bpp=%d not supported, use bpc=8\n",
1202 bpp);
1203 tbd = DP_TEST_BIT_DEPTH_8;
1204 break;
1205 }
1206
1207 tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT);
1208
1209 return tbd;
1210 }
1211
dp_link_get(struct device * dev,struct drm_dp_aux * aux)1212 struct dp_link *dp_link_get(struct device *dev, struct drm_dp_aux *aux)
1213 {
1214 struct dp_link_private *link;
1215 struct dp_link *dp_link;
1216
1217 if (!dev || !aux) {
1218 DRM_ERROR("invalid input\n");
1219 return ERR_PTR(-EINVAL);
1220 }
1221
1222 link = devm_kzalloc(dev, sizeof(*link), GFP_KERNEL);
1223 if (!link)
1224 return ERR_PTR(-ENOMEM);
1225
1226 link->aux = aux;
1227
1228 mutex_init(&link->psm_mutex);
1229 dp_link = &link->dp_link;
1230
1231 return dp_link;
1232 }
1233