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