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