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