1 /* 2 * (C) Copyright 2008-2017 Fuzhou Rockchip Electronics Co., Ltd 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <config.h> 8 #include <common.h> 9 #include <errno.h> 10 #include <malloc.h> 11 #include <asm/unaligned.h> 12 #include <asm/io.h> 13 #include <dm/device.h> 14 #include <dm/of_access.h> 15 #include <dm/read.h> 16 #include <linux/bitfield.h> 17 #include <linux/list.h> 18 #include <linux/media-bus-format.h> 19 #include <syscon.h> 20 #include <asm/arch-rockchip/clock.h> 21 #include <asm/gpio.h> 22 23 #include "rockchip_display.h" 24 #include "rockchip_crtc.h" 25 #include "rockchip_connector.h" 26 #include "analogix_dp.h" 27 28 #define RK3588_GRF_VO1_CON0 0x0000 29 #define EDP_MODE BIT(0) 30 #define RK3588_GRF_VO1_CON1 0x0004 31 32 /** 33 * struct rockchip_dp_chip_data - splite the grf setting of kind of chips 34 * @lcdsel_grf_reg: grf register offset of lcdc select 35 * @lcdsel_big: reg value of selecting vop big for eDP 36 * @lcdsel_lit: reg value of selecting vop little for eDP 37 * @chip_type: specific chip type 38 * @ssc: check if SSC is supported by source 39 * @max_link_rate: max supported link rate 40 * @max_lane_count: max supported lane count 41 * @format_yuv: check if yuv color format is supported 42 * @support_dp_mode: check if dp mode is supported 43 * @max_bpc: max supported bpc which set to 8 by default 44 */ 45 struct rockchip_dp_chip_data { 46 u32 lcdsel_grf_reg; 47 u32 lcdsel_big; 48 u32 lcdsel_lit; 49 u32 chip_type; 50 bool ssc; 51 52 u32 max_link_rate; 53 u32 max_lane_count; 54 bool format_yuv; 55 bool support_dp_mode; 56 u8 max_bpc; 57 }; 58 59 static const struct analogix_dp_output_format possible_output_fmts[] = { 60 { MEDIA_BUS_FMT_RGB101010_1X30, DRM_COLOR_FORMAT_RGB444, 10 }, 61 { MEDIA_BUS_FMT_RGB888_1X24, DRM_COLOR_FORMAT_RGB444, 8 }, 62 { MEDIA_BUS_FMT_RGB666_1X24_CPADHI, DRM_COLOR_FORMAT_RGB444, 6 }, 63 { MEDIA_BUS_FMT_YUV10_1X30, DRM_COLOR_FORMAT_YCRCB444, 10 }, 64 { MEDIA_BUS_FMT_YUV8_1X24, DRM_COLOR_FORMAT_YCRCB444, 8}, 65 { MEDIA_BUS_FMT_YUYV10_1X20, DRM_COLOR_FORMAT_YCRCB422, 10 }, 66 { MEDIA_BUS_FMT_YUYV8_1X16, DRM_COLOR_FORMAT_YCRCB422, 8 }, 67 }; 68 69 static u8 analogix_dp_get_output_bpp(const struct analogix_dp_output_format *fmt) 70 { 71 switch (fmt->color_format) { 72 case DRM_COLOR_FORMAT_YCRCB422: 73 return fmt->bpc * 2; 74 case DRM_COLOR_FORMAT_RGB444: 75 case DRM_COLOR_FORMAT_YCRCB444: 76 default: 77 return fmt->bpc * 3; 78 } 79 } 80 81 static int 82 analogix_dp_enable_rx_to_enhanced_mode(struct analogix_dp_device *dp, 83 bool enable) 84 { 85 u8 data; 86 int ret; 87 88 ret = drm_dp_dpcd_readb(&dp->aux, DP_LANE_COUNT_SET, &data); 89 if (ret != 1) 90 return ret; 91 92 if (enable) 93 ret = drm_dp_dpcd_writeb(&dp->aux, DP_LANE_COUNT_SET, 94 DP_LANE_COUNT_ENHANCED_FRAME_EN | 95 DPCD_LANE_COUNT_SET(data)); 96 else 97 ret = drm_dp_dpcd_writeb(&dp->aux, DP_LANE_COUNT_SET, 98 DPCD_LANE_COUNT_SET(data)); 99 100 return ret < 0 ? ret : 0; 101 } 102 103 static int analogix_dp_set_enhanced_mode(struct analogix_dp_device *dp) 104 { 105 bool enhanced_frame_en; 106 u8 data; 107 int ret; 108 109 enhanced_frame_en = drm_dp_enhanced_frame_cap(dp->dpcd); 110 111 ret = analogix_dp_enable_rx_to_enhanced_mode(dp, enhanced_frame_en); 112 if (ret < 0) 113 return ret; 114 115 if (!enhanced_frame_en) { 116 /* 117 * As the Table 3-4 in eDP v1.2 spec: 118 * DPCD 0000Dh: 119 * Bit 1 = FRAMING_CHANGE_CAPABLE 120 * A setting of 1 indicates that this is an eDP device that 121 * uses only Enhanced Framing, independently of the setting by 122 * the source of ENHANCED_FRAME_EN 123 * 124 * And as the Table 3-3 in eDP v1.4 spec: 125 * DPCD 0000Dh: 126 * Bit 1 = RESERVED for eDP 127 * New to eDP v1.4.(Read all 0s) 128 */ 129 ret = drm_dp_dpcd_readb(&dp->aux, DP_EDP_CONFIGURATION_CAP, 130 &data); 131 if (ret < 0) 132 return ret; 133 134 enhanced_frame_en = !!(data & DP_FRAMING_CHANGE_CAP); 135 } 136 137 analogix_dp_enable_enhanced_mode(dp, enhanced_frame_en); 138 139 return 0; 140 } 141 142 static int analogix_dp_training_pattern_dis(struct analogix_dp_device *dp) 143 { 144 int ret; 145 146 analogix_dp_set_training_pattern(dp, DP_NONE); 147 148 ret = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET, 149 DP_TRAINING_PATTERN_DISABLE); 150 151 return ret < 0 ? ret : 0; 152 } 153 154 static int analogix_dp_enable_sink_to_assr_mode(struct analogix_dp_device *dp, bool enable) 155 { 156 u8 data; 157 int ret; 158 159 ret = drm_dp_dpcd_readb(&dp->aux, DP_EDP_CONFIGURATION_SET, &data); 160 if (ret != 1) 161 return ret; 162 163 if (enable) 164 ret = drm_dp_dpcd_writeb(&dp->aux, DP_EDP_CONFIGURATION_SET, 165 data | DP_ALTERNATE_SCRAMBLER_RESET_ENABLE); 166 else 167 ret = drm_dp_dpcd_writeb(&dp->aux, DP_EDP_CONFIGURATION_SET, 168 data & ~DP_ALTERNATE_SCRAMBLER_RESET_ENABLE); 169 170 return ret < 0 ? ret : 0; 171 } 172 173 static int analogix_dp_set_assr_mode(struct analogix_dp_device *dp) 174 { 175 bool assr_en; 176 int ret; 177 178 assr_en = drm_dp_alternate_scrambler_reset_cap(dp->dpcd); 179 180 ret = analogix_dp_enable_sink_to_assr_mode(dp, assr_en); 181 if (ret < 0) 182 return ret; 183 184 analogix_dp_enable_assr_mode(dp, assr_en); 185 186 return 0; 187 } 188 189 static int analogix_dp_link_start(struct analogix_dp_device *dp) 190 { 191 u8 buf[4]; 192 int lane, lane_count, retval; 193 194 lane_count = dp->link_train.lane_count; 195 196 dp->link_train.lt_state = CLOCK_RECOVERY; 197 dp->link_train.eq_loop = 0; 198 199 for (lane = 0; lane < lane_count; lane++) 200 dp->link_train.cr_loop[lane] = 0; 201 202 /* Set link rate and count as you want to establish */ 203 analogix_dp_set_link_bandwidth(dp, dp->link_train.link_rate); 204 analogix_dp_set_lane_count(dp, dp->link_train.lane_count); 205 206 if (dp->nr_link_rate_table) { 207 /* Setup DP_LINK_RATE_SET for eDP 1.4 and later */ 208 drm_dp_dpcd_writeb(&dp->aux, DP_LANE_COUNT_SET, dp->link_train.lane_count); 209 drm_dp_dpcd_writeb(&dp->aux, DP_LINK_RATE_SET, dp->link_rate_select); 210 } else { 211 /* Setup DP_LINK_BW_SET for eDP 1.3 and earlier */ 212 buf[0] = dp->link_train.link_rate; 213 buf[1] = dp->link_train.lane_count; 214 retval = drm_dp_dpcd_write(&dp->aux, DP_LINK_BW_SET, buf, 2); 215 if (retval < 0) 216 return retval; 217 } 218 219 /* Spread AMP if required, enable 8b/10b coding */ 220 buf[0] = analogix_dp_ssc_supported(dp) ? DP_SPREAD_AMP_0_5 : 0; 221 buf[1] = DP_SET_ANSI_8B10B; 222 retval = drm_dp_dpcd_write(&dp->aux, DP_DOWNSPREAD_CTRL, buf, 2); 223 if (retval < 0) 224 return retval; 225 226 /* set ASSR if available */ 227 retval = analogix_dp_set_assr_mode(dp); 228 if (retval < 0) { 229 dev_err(dp->dev, "failed to set assr mode\n"); 230 return retval; 231 } 232 233 /* set enhanced mode if available */ 234 retval = analogix_dp_set_enhanced_mode(dp); 235 if (retval < 0) { 236 dev_err(dp->dev, "failed to set enhance mode\n"); 237 return retval; 238 } 239 240 /* Set TX voltage-swing and pre-emphasis to minimum */ 241 for (lane = 0; lane < lane_count; lane++) 242 dp->link_train.training_lane[lane] = 243 DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | 244 DP_TRAIN_PRE_EMPH_LEVEL_0; 245 analogix_dp_set_lane_link_training(dp); 246 247 /* Set training pattern 1 */ 248 analogix_dp_set_training_pattern(dp, TRAINING_PTN1); 249 250 /* Set RX training pattern */ 251 retval = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET, 252 DP_LINK_SCRAMBLING_DISABLE | DP_TRAINING_PATTERN_1); 253 if (retval < 0) 254 return retval; 255 256 for (lane = 0; lane < lane_count; lane++) 257 buf[lane] = DP_TRAIN_PRE_EMPH_LEVEL_0 | 258 DP_TRAIN_VOLTAGE_SWING_LEVEL_0; 259 260 retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET, buf, 261 lane_count); 262 if (retval < 0) 263 return retval; 264 265 return 0; 266 } 267 268 static unsigned char analogix_dp_get_lane_status(u8 link_status[2], int lane) 269 { 270 int shift = (lane & 1) * 4; 271 u8 link_value = link_status[lane >> 1]; 272 273 return (link_value >> shift) & 0xf; 274 } 275 276 static int analogix_dp_clock_recovery_ok(u8 link_status[2], int lane_count) 277 { 278 int lane; 279 u8 lane_status; 280 281 for (lane = 0; lane < lane_count; lane++) { 282 lane_status = analogix_dp_get_lane_status(link_status, lane); 283 if ((lane_status & DP_LANE_CR_DONE) == 0) 284 return -EINVAL; 285 } 286 return 0; 287 } 288 289 static int analogix_dp_channel_eq_ok(u8 link_status[2], u8 link_align, 290 int lane_count) 291 { 292 int lane; 293 u8 lane_status; 294 295 if ((link_align & DP_INTERLANE_ALIGN_DONE) == 0) 296 return -EINVAL; 297 298 for (lane = 0; lane < lane_count; lane++) { 299 lane_status = analogix_dp_get_lane_status(link_status, lane); 300 lane_status &= DP_CHANNEL_EQ_BITS; 301 if (lane_status != DP_CHANNEL_EQ_BITS) 302 return -EINVAL; 303 } 304 305 return 0; 306 } 307 308 static unsigned char 309 analogix_dp_get_adjust_request_voltage(u8 adjust_request[2], int lane) 310 { 311 int shift = (lane & 1) * 4; 312 u8 link_value = adjust_request[lane >> 1]; 313 314 return (link_value >> shift) & 0x3; 315 } 316 317 static unsigned char analogix_dp_get_adjust_request_pre_emphasis( 318 u8 adjust_request[2], 319 int lane) 320 { 321 int shift = (lane & 1) * 4; 322 u8 link_value = adjust_request[lane >> 1]; 323 324 return ((link_value >> shift) & 0xc) >> 2; 325 } 326 327 static void analogix_dp_reduce_link_rate(struct analogix_dp_device *dp) 328 { 329 analogix_dp_training_pattern_dis(dp); 330 analogix_dp_set_enhanced_mode(dp); 331 332 dp->link_train.lt_state = FAILED; 333 } 334 335 static void analogix_dp_get_adjust_training_lane(struct analogix_dp_device *dp, 336 u8 adjust_request[2]) 337 { 338 int lane, lane_count; 339 u8 voltage_swing, pre_emphasis, training_lane; 340 341 lane_count = dp->link_train.lane_count; 342 for (lane = 0; lane < lane_count; lane++) { 343 voltage_swing = analogix_dp_get_adjust_request_voltage( 344 adjust_request, lane); 345 pre_emphasis = analogix_dp_get_adjust_request_pre_emphasis( 346 adjust_request, lane); 347 training_lane = DPCD_VOLTAGE_SWING_SET(voltage_swing) | 348 DPCD_PRE_EMPHASIS_SET(pre_emphasis); 349 350 if (voltage_swing == VOLTAGE_LEVEL_3) 351 training_lane |= DP_TRAIN_MAX_SWING_REACHED; 352 if (pre_emphasis == PRE_EMPHASIS_LEVEL_3) 353 training_lane |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED; 354 355 dp->link_train.training_lane[lane] = training_lane; 356 } 357 } 358 359 static bool analogix_dp_tps3_supported(struct analogix_dp_device *dp) 360 { 361 bool source_tps3_supported, sink_tps3_supported; 362 u8 dpcd = 0; 363 364 source_tps3_supported = 365 dp->video_info.max_link_rate == DP_LINK_BW_5_4; 366 drm_dp_dpcd_readb(&dp->aux, DP_MAX_LANE_COUNT, &dpcd); 367 sink_tps3_supported = dpcd & DP_TPS3_SUPPORTED; 368 369 return source_tps3_supported && sink_tps3_supported; 370 } 371 372 static int analogix_dp_process_clock_recovery(struct analogix_dp_device *dp) 373 { 374 int lane, lane_count, retval; 375 u8 voltage_swing, pre_emphasis, training_lane; 376 u8 link_status[2], adjust_request[2]; 377 u8 training_pattern = TRAINING_PTN2; 378 379 drm_dp_link_train_clock_recovery_delay(dp->dpcd); 380 381 lane_count = dp->link_train.lane_count; 382 383 retval = drm_dp_dpcd_read(&dp->aux, DP_LANE0_1_STATUS, link_status, 2); 384 if (retval < 0) 385 return retval; 386 387 if (analogix_dp_clock_recovery_ok(link_status, lane_count) == 0) { 388 if (analogix_dp_tps3_supported(dp)) 389 training_pattern = TRAINING_PTN3; 390 391 /* set training pattern for EQ */ 392 analogix_dp_set_training_pattern(dp, training_pattern); 393 394 retval = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET, 395 DP_LINK_SCRAMBLING_DISABLE | 396 (training_pattern == TRAINING_PTN3 ? 397 DP_TRAINING_PATTERN_3 : DP_TRAINING_PATTERN_2)); 398 if (retval < 0) 399 return retval; 400 401 dev_info(dp->dev, "Link Training Clock Recovery success\n"); 402 dp->link_train.lt_state = EQUALIZER_TRAINING; 403 404 return 0; 405 } else { 406 retval = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1, 407 adjust_request, 2); 408 if (retval < 0) 409 return retval; 410 411 for (lane = 0; lane < lane_count; lane++) { 412 training_lane = analogix_dp_get_lane_link_training( 413 dp, lane); 414 voltage_swing = analogix_dp_get_adjust_request_voltage( 415 adjust_request, lane); 416 pre_emphasis = analogix_dp_get_adjust_request_pre_emphasis( 417 adjust_request, lane); 418 419 if (DPCD_VOLTAGE_SWING_GET(training_lane) == 420 voltage_swing && 421 DPCD_PRE_EMPHASIS_GET(training_lane) == 422 pre_emphasis) 423 dp->link_train.cr_loop[lane]++; 424 425 /* 426 * In DP spec 1.3, Condition of CR fail are 427 * outlined in section 3.5.1.2.2.1, figure 3-20: 428 * 429 * 1. Maximum Voltage Swing reached 430 * 2. Same Voltage five times 431 */ 432 if (dp->link_train.cr_loop[lane] == MAX_CR_LOOP || 433 DPCD_VOLTAGE_SWING_GET(training_lane) == VOLTAGE_LEVEL_3) { 434 dev_err(dp->dev, "CR Max reached (%d,%d,%d)\n", 435 dp->link_train.cr_loop[lane], 436 voltage_swing, pre_emphasis); 437 analogix_dp_reduce_link_rate(dp); 438 return -EIO; 439 } 440 } 441 } 442 443 analogix_dp_get_adjust_training_lane(dp, adjust_request); 444 analogix_dp_set_lane_link_training(dp); 445 446 retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET, 447 dp->link_train.training_lane, lane_count); 448 if (retval < 0) 449 return retval; 450 451 return 0; 452 } 453 454 static int analogix_dp_process_equalizer_training(struct analogix_dp_device *dp) 455 { 456 int lane_count, retval; 457 u32 reg; 458 u8 link_align, link_status[2], adjust_request[2]; 459 460 drm_dp_link_train_channel_eq_delay(dp->dpcd); 461 462 lane_count = dp->link_train.lane_count; 463 464 retval = drm_dp_dpcd_read(&dp->aux, DP_LANE0_1_STATUS, link_status, 2); 465 if (retval < 0) 466 return retval; 467 468 if (analogix_dp_clock_recovery_ok(link_status, lane_count)) { 469 analogix_dp_reduce_link_rate(dp); 470 return -EIO; 471 } 472 473 retval = drm_dp_dpcd_readb(&dp->aux, DP_LANE_ALIGN_STATUS_UPDATED, &link_align); 474 if (retval < 0) 475 return retval; 476 477 if (!analogix_dp_channel_eq_ok(link_status, link_align, lane_count)) { 478 /* traing pattern Set to Normal */ 479 retval = analogix_dp_training_pattern_dis(dp); 480 if (retval < 0) 481 return retval; 482 483 printf("Link Training success!\n"); 484 485 analogix_dp_get_link_bandwidth(dp, ®); 486 dp->link_train.link_rate = reg; 487 analogix_dp_get_lane_count(dp, ®); 488 dp->link_train.lane_count = reg; 489 490 printf("final link rate = 0x%.2x, lane count = 0x%.2x\n", 491 dp->link_train.link_rate, dp->link_train.lane_count); 492 493 dp->link_train.lt_state = FINISHED; 494 495 return 0; 496 } 497 498 /* not all locked */ 499 dp->link_train.eq_loop++; 500 501 if (dp->link_train.eq_loop > MAX_EQ_LOOP) { 502 dev_dbg(dp->dev, "EQ Max loop\n"); 503 analogix_dp_reduce_link_rate(dp); 504 return -EIO; 505 } 506 507 retval = drm_dp_dpcd_read(&dp->aux, DP_ADJUST_REQUEST_LANE0_1, adjust_request, 2); 508 if (retval < 0) 509 return retval; 510 511 analogix_dp_get_adjust_training_lane(dp, adjust_request); 512 analogix_dp_set_lane_link_training(dp); 513 514 retval = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET, 515 dp->link_train.training_lane, lane_count); 516 if (retval < 0) 517 return retval; 518 519 return 0; 520 } 521 522 static bool analogix_dp_bandwidth_ok(struct analogix_dp_device *dp, 523 const struct drm_display_mode *mode, u32 bpp, 524 unsigned int rate, unsigned int lanes) 525 { 526 u32 max_bw, req_bw; 527 528 req_bw = mode->clock * bpp / 8; 529 max_bw = lanes * rate; 530 if (req_bw > max_bw) 531 return false; 532 533 return true; 534 } 535 536 static bool analogix_dp_link_config_validate(u8 link_rate, u8 lane_count) 537 { 538 switch (link_rate) { 539 case DP_LINK_BW_1_62: 540 case DP_LINK_BW_2_7: 541 case DP_LINK_BW_5_4: 542 /* Supported link rate in eDP 1.4 */ 543 case EDP_LINK_BW_2_16: 544 case EDP_LINK_BW_2_43: 545 case EDP_LINK_BW_3_24: 546 case EDP_LINK_BW_4_32: 547 break; 548 default: 549 return false; 550 } 551 552 switch (lane_count) { 553 case LANE_COUNT1: 554 case LANE_COUNT2: 555 case LANE_COUNT4: 556 break; 557 default: 558 return false; 559 } 560 561 return true; 562 } 563 564 static int analogix_dp_select_link_rate_from_table(struct analogix_dp_device *dp) 565 { 566 int i; 567 u8 bw_code; 568 u32 max_link_rate = drm_dp_bw_code_to_link_rate(dp->video_info.max_link_rate); 569 570 for (i = 0; i < dp->nr_link_rate_table; i++) { 571 bw_code = drm_dp_link_rate_to_bw_code(dp->link_rate_table[i]); 572 573 if (!analogix_dp_bandwidth_ok(dp, &dp->video_info.mode, 574 analogix_dp_get_output_bpp(dp->output_fmt), 575 dp->link_rate_table[i], dp->link_train.lane_count)) 576 continue; 577 578 if (dp->link_rate_table[i] <= max_link_rate && 579 analogix_dp_link_config_validate(bw_code, dp->link_train.lane_count)) { 580 dp->link_rate_select = i; 581 return bw_code; 582 } 583 } 584 585 return 0; 586 } 587 588 static int analogix_dp_select_rx_bandwidth(struct analogix_dp_device *dp) 589 { 590 if (dp->nr_link_rate_table) 591 /* 592 * Select the smallest one among link rates which meet 593 * the bandwidth requirement for eDP 1.4 and later. 594 */ 595 dp->link_train.link_rate = analogix_dp_select_link_rate_from_table(dp); 596 else 597 /* 598 * Select the smaller one between rx DP_MAX_LINK_RATE 599 * and the max link rate supported by the platform. 600 */ 601 dp->link_train.link_rate = min_t(u32, dp->link_train.link_rate, 602 dp->video_info.max_link_rate); 603 if (!dp->link_train.link_rate) 604 return -EINVAL; 605 606 return 0; 607 } 608 609 static int analogix_dp_init_link_rate_table(struct analogix_dp_device *dp) 610 { 611 u8 link_rate_table[DP_MAX_SUPPORTED_RATES * 2]; 612 int i; 613 int ret; 614 615 ret = drm_dp_dpcd_read(&dp->aux, DP_SUPPORTED_LINK_RATES, link_rate_table, 616 sizeof(link_rate_table)); 617 if (ret < 0) 618 return ret; 619 620 for (i = 0; i < ARRAY_SIZE(link_rate_table) / 2; i++) { 621 int val = link_rate_table[2 * i] | link_rate_table[2 * i + 1] << 8; 622 623 if (val == 0) 624 break; 625 626 /* Convert to the link_rate as drm_dp_bw_code_to_link_rate() */ 627 dp->link_rate_table[i] = (val * 20); 628 } 629 dp->nr_link_rate_table = i; 630 631 return 0; 632 } 633 634 static int analogix_dp_get_max_rx_bandwidth(struct analogix_dp_device *dp, 635 u8 *bandwidth) 636 { 637 u8 data; 638 int ret; 639 640 ret = drm_dp_dpcd_readb(&dp->aux, DP_EDP_DPCD_REV, &data); 641 if (ret == 1 && data >= DP_EDP_14) { 642 u32 max_link_rate; 643 644 /* As the Table 4-23 in eDP 1.4 spec, the link rate table is required */ 645 if (!dp->nr_link_rate_table) { 646 dev_info(dp->dev, "eDP version: 0x%02x supports link rate table\n", 647 data); 648 649 if (analogix_dp_init_link_rate_table(dp)) 650 dev_err(dp->dev, "failed to read link rate table: %d\n", 651 ret); 652 } 653 max_link_rate = dp->link_rate_table[dp->nr_link_rate_table - 1]; 654 *bandwidth = drm_dp_link_rate_to_bw_code(max_link_rate); 655 } else { 656 /* 657 * For DP rev.1.1, Maximum link rate of Main Link lanes 658 * 0x06 = 1.62 Gbps, 0x0a = 2.7 Gbps 659 * For DP rev.1.2, Maximum link rate of Main Link lanes 660 * 0x06 = 1.62 Gbps, 0x0a = 2.7 Gbps, 0x14 = 5.4Gbps 661 */ 662 ret = drm_dp_dpcd_readb(&dp->aux, DP_MAX_LINK_RATE, &data); 663 if (ret < 0) 664 return ret; 665 666 *bandwidth = data; 667 } 668 669 return 0; 670 } 671 672 static int analogix_dp_get_max_rx_lane_count(struct analogix_dp_device *dp, 673 u8 *lane_count) 674 { 675 u8 data; 676 int ret; 677 678 /* 679 * For DP rev.1.1, Maximum number of Main Link lanes 680 * 0x01 = 1 lane, 0x02 = 2 lanes, 0x04 = 4 lanes 681 */ 682 ret = drm_dp_dpcd_readb(&dp->aux, DP_MAX_LANE_COUNT, &data); 683 if (ret < 0) 684 return ret; 685 686 *lane_count = DPCD_MAX_LANE_COUNT(data); 687 688 return 0; 689 } 690 691 static int analogix_dp_init_training(struct analogix_dp_device *dp, 692 enum link_lane_count_type max_lane, 693 int max_rate) 694 { 695 u8 dpcd; 696 697 /* 698 * MACRO_RST must be applied after the PLL_LOCK to avoid 699 * the DP inter pair skew issue for at least 10 us 700 */ 701 analogix_dp_reset_macro(dp); 702 703 /* Setup TX lane count */ 704 dp->link_train.lane_count = min_t(u32, dp->link_train.lane_count, max_lane); 705 706 /* Setup TX lane rate */ 707 if (analogix_dp_select_rx_bandwidth(dp)) { 708 dev_err(dp->dev, "Select rx bandwidth failed\n"); 709 return -EINVAL; 710 } 711 712 drm_dp_dpcd_readb(&dp->aux, DP_MAX_DOWNSPREAD, &dpcd); 713 dp->link_train.ssc = !!(dpcd & DP_MAX_DOWNSPREAD_0_5); 714 715 /* All DP analog module power up */ 716 analogix_dp_set_analog_power_down(dp, POWER_ALL, 0); 717 718 return 0; 719 } 720 721 static int analogix_dp_sw_link_training(struct analogix_dp_device *dp) 722 { 723 int retval = 0, training_finished = 0; 724 725 dp->link_train.lt_state = START; 726 727 /* Process here */ 728 while (!retval && !training_finished) { 729 switch (dp->link_train.lt_state) { 730 case START: 731 retval = analogix_dp_link_start(dp); 732 if (retval) 733 dev_err(dp->dev, "LT link start failed!\n"); 734 break; 735 case CLOCK_RECOVERY: 736 retval = analogix_dp_process_clock_recovery(dp); 737 if (retval) 738 dev_err(dp->dev, "LT CR failed!\n"); 739 break; 740 case EQUALIZER_TRAINING: 741 retval = analogix_dp_process_equalizer_training(dp); 742 if (retval) 743 dev_err(dp->dev, "LT EQ failed!\n"); 744 break; 745 case FINISHED: 746 training_finished = 1; 747 break; 748 case FAILED: 749 return -EREMOTEIO; 750 } 751 } 752 753 return retval; 754 } 755 756 static int analogix_dp_set_link_train(struct analogix_dp_device *dp, 757 u32 count, u32 bwtype) 758 { 759 int i, ret; 760 761 for (i = 0; i < 5; i++) { 762 ret = analogix_dp_init_training(dp, count, bwtype); 763 if (ret < 0) { 764 dev_err(dp->dev, "failed to init training\n"); 765 return ret; 766 } 767 768 ret = analogix_dp_sw_link_training(dp); 769 if (!ret) 770 break; 771 } 772 773 return ret; 774 } 775 776 static int analogix_dp_config_video(struct analogix_dp_device *dp) 777 { 778 int timeout_loop = 0; 779 int done_count = 0; 780 781 analogix_dp_config_video_slave_mode(dp); 782 783 analogix_dp_set_video_color_format(dp); 784 785 if (analogix_dp_get_pll_lock_status(dp) == PLL_UNLOCKED) { 786 dev_err(dp->dev, "PLL is not locked yet.\n"); 787 return -EINVAL; 788 } 789 790 for (;;) { 791 timeout_loop++; 792 if (analogix_dp_is_slave_video_stream_clock_on(dp) == 0) 793 break; 794 if (timeout_loop > DP_TIMEOUT_LOOP_COUNT) { 795 dev_err(dp->dev, "Timeout of video streamclk ok\n"); 796 return -ETIMEDOUT; 797 } 798 799 udelay(2); 800 } 801 802 /* Set to use the register calculated M/N video */ 803 analogix_dp_set_video_cr_mn(dp, CALCULATED_M, 0, 0); 804 805 /* For video bist, Video timing must be generated by register */ 806 analogix_dp_set_video_timing_mode(dp, VIDEO_TIMING_FROM_REGISTER); 807 808 /* Disable video mute */ 809 analogix_dp_enable_video_mute(dp, 0); 810 811 /* Configure video slave mode */ 812 analogix_dp_enable_video_master(dp, 0); 813 814 /* Enable video input */ 815 analogix_dp_start_video(dp); 816 817 timeout_loop = 0; 818 819 for (;;) { 820 timeout_loop++; 821 if (analogix_dp_is_video_stream_on(dp) == 0) { 822 done_count++; 823 if (done_count > 10) 824 break; 825 } else if (done_count) { 826 done_count = 0; 827 } 828 if (timeout_loop > DP_TIMEOUT_LOOP_COUNT) { 829 dev_err(dp->dev, "Timeout of video streamclk ok\n"); 830 return -ETIMEDOUT; 831 } 832 833 udelay(1001); 834 } 835 836 return 0; 837 } 838 839 static int analogix_dp_enable_scramble(struct analogix_dp_device *dp, 840 bool enable) 841 { 842 u8 data; 843 int ret; 844 845 if (enable) { 846 analogix_dp_enable_scrambling(dp); 847 848 ret = drm_dp_dpcd_readb(&dp->aux, DP_TRAINING_PATTERN_SET, 849 &data); 850 if (ret != 1) 851 return ret; 852 ret = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET, 853 (u8)(data & ~DP_LINK_SCRAMBLING_DISABLE)); 854 } else { 855 analogix_dp_disable_scrambling(dp); 856 857 ret = drm_dp_dpcd_readb(&dp->aux, DP_TRAINING_PATTERN_SET, 858 &data); 859 if (ret != 1) 860 return ret; 861 ret = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET, 862 (u8)(data | DP_LINK_SCRAMBLING_DISABLE)); 863 } 864 return ret < 0 ? ret : 0; 865 } 866 867 static void analogix_dp_init_dp(struct analogix_dp_device *dp) 868 { 869 analogix_dp_reset(dp); 870 871 analogix_dp_swreset(dp); 872 873 analogix_dp_init_analog_param(dp); 874 analogix_dp_init_interrupt(dp); 875 876 /* SW defined function Normal operation */ 877 analogix_dp_enable_sw_function(dp); 878 879 analogix_dp_config_interrupt(dp); 880 analogix_dp_init_analog_func(dp); 881 882 analogix_dp_init_hpd(dp); 883 analogix_dp_init_aux(dp); 884 } 885 886 static int analogix_dp_connector_init(struct rockchip_connector *conn, struct display_state *state) 887 { 888 struct connector_state *conn_state = &state->conn_state; 889 struct analogix_dp_device *dp = dev_get_priv(conn->dev); 890 int submode = PHY_SUBMODE_EDP; 891 892 if (!conn->panel) 893 dp->dp_mode = true; 894 895 if (dev_read_bool(conn->dev, "dp-mode")) 896 dp->dp_mode = true; 897 else if (dev_read_bool(conn->dev, "edp-mode")) 898 dp->dp_mode = false; 899 900 conn_state->output_if |= dp->id ? VOP_OUTPUT_IF_eDP1 : VOP_OUTPUT_IF_eDP0; 901 conn_state->output_mode = ROCKCHIP_OUT_MODE_AAAA; 902 conn_state->color_encoding = DRM_COLOR_YCBCR_BT709; 903 conn_state->color_range = DRM_COLOR_YCBCR_FULL_RANGE; 904 905 reset_assert_bulk(&dp->resets); 906 udelay(1); 907 reset_deassert_bulk(&dp->resets); 908 909 conn_state->disp_info = rockchip_get_disp_info(conn_state->type, dp->id); 910 if (dp->plat_data.support_dp_mode && dp->dp_mode) 911 submode = PHY_SUBMODE_DP; 912 generic_phy_set_mode_ext(&dp->phy, PHY_MODE_DP, submode); 913 generic_phy_power_on(&dp->phy); 914 analogix_dp_init_dp(dp); 915 916 return 0; 917 } 918 919 static int analogix_dp_connector_get_edid(struct rockchip_connector *conn, 920 struct display_state *state) 921 { 922 struct connector_state *conn_state = &state->conn_state; 923 struct analogix_dp_device *dp = dev_get_priv(conn->dev); 924 int ret; 925 926 ret = drm_do_get_edid(&dp->aux.ddc, conn_state->edid); 927 928 return ret; 929 } 930 931 static int analogix_dp_link_power_up(struct analogix_dp_device *dp) 932 { 933 u8 value; 934 int ret; 935 936 if (dp->dpcd[DP_DPCD_REV] < 0x11) 937 return 0; 938 939 ret = drm_dp_dpcd_readb(&dp->aux, DP_SET_POWER, &value); 940 if (ret < 0) 941 return ret; 942 943 value &= ~DP_SET_POWER_MASK; 944 value |= DP_SET_POWER_D0; 945 946 ret = drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER, value); 947 if (ret < 0) 948 return ret; 949 950 mdelay(1); 951 952 return 0; 953 } 954 955 static int analogix_dp_link_power_down(struct analogix_dp_device *dp) 956 { 957 u8 value; 958 int ret; 959 960 if (dp->dpcd[DP_DPCD_REV] < 0x11) 961 return 0; 962 963 ret = drm_dp_dpcd_readb(&dp->aux, DP_SET_POWER, &value); 964 if (ret < 0) 965 return ret; 966 967 value &= ~DP_SET_POWER_MASK; 968 value |= DP_SET_POWER_D3; 969 970 ret = drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER, value); 971 if (ret < 0) 972 return ret; 973 974 return 0; 975 } 976 977 static u32 analogix_dp_get_output_format(struct analogix_dp_device *dp, u32 bus_format) 978 { 979 unsigned int i; 980 981 for (i = 0; i < ARRAY_SIZE(possible_output_fmts); i++) { 982 const struct analogix_dp_output_format *fmt = &possible_output_fmts[i]; 983 984 if (fmt->bus_format == bus_format) 985 break; 986 } 987 988 if (i == ARRAY_SIZE(possible_output_fmts)) 989 return 1; 990 991 return i; 992 } 993 994 static u32 analogix_dp_get_output_format_by_edid(struct analogix_dp_device *dp, 995 struct hdmi_edid_data *edid_data) 996 { 997 unsigned int i; 998 999 for (i = 0; i < ARRAY_SIZE(possible_output_fmts); i++) { 1000 const struct analogix_dp_output_format *fmt = &possible_output_fmts[i]; 1001 1002 if (fmt->bpc > edid_data->display_info.bpc || fmt->bpc > dp->plat_data.max_bpc) 1003 continue; 1004 1005 if (!(edid_data->display_info.color_formats & fmt->color_format)) 1006 continue; 1007 1008 if (!analogix_dp_bandwidth_ok(dp, edid_data->preferred_mode, 1009 analogix_dp_get_output_bpp(fmt), 1010 drm_dp_bw_code_to_link_rate(dp->link_train.link_rate), 1011 dp->link_train.lane_count)) 1012 continue; 1013 1014 break; 1015 } 1016 1017 if (i == ARRAY_SIZE(possible_output_fmts)) 1018 return 1; 1019 1020 return i; 1021 } 1022 1023 static int analogix_dp_connector_enable(struct rockchip_connector *conn, 1024 struct display_state *state) 1025 { 1026 struct connector_state *conn_state = &state->conn_state; 1027 struct crtc_state *crtc_state = &state->crtc_state; 1028 const struct rockchip_dp_chip_data *pdata = 1029 (const struct rockchip_dp_chip_data *)dev_get_driver_data(conn->dev); 1030 struct analogix_dp_device *dp = dev_get_priv(conn->dev); 1031 struct video_info *video = &dp->video_info; 1032 struct drm_display_mode mode; 1033 u32 fmt_id; 1034 u32 val; 1035 int ret; 1036 1037 drm_mode_copy(&video->mode, &conn_state->mode); 1038 1039 if (pdata->lcdsel_grf_reg) { 1040 if (crtc_state->crtc_id) 1041 val = pdata->lcdsel_lit; 1042 else 1043 val = pdata->lcdsel_big; 1044 1045 regmap_write(dp->grf, pdata->lcdsel_grf_reg, val); 1046 } 1047 1048 if (pdata->chip_type == RK3588_EDP) 1049 regmap_write(dp->grf, dp->id ? RK3588_GRF_VO1_CON1 : RK3588_GRF_VO1_CON0, 1050 EDP_MODE << 16 | FIELD_PREP(EDP_MODE, 1)); 1051 1052 if (!dp->output_fmt) { 1053 fmt_id = analogix_dp_get_output_format(dp, conn_state->bus_format); 1054 dp->output_fmt = &possible_output_fmts[fmt_id]; 1055 } 1056 1057 switch (dp->output_fmt->bpc) { 1058 case 12: 1059 video->color_depth = COLOR_12; 1060 break; 1061 case 10: 1062 video->color_depth = COLOR_10; 1063 break; 1064 case 6: 1065 video->color_depth = COLOR_6; 1066 break; 1067 case 8: 1068 default: 1069 video->color_depth = COLOR_8; 1070 break; 1071 } 1072 if (dp->output_fmt->color_format == DRM_COLOR_FORMAT_YCRCB444) { 1073 video->color_space = COLOR_YCBCR444; 1074 video->ycbcr_coeff = COLOR_YCBCR709; 1075 } else if (dp->output_fmt->color_format == DRM_COLOR_FORMAT_YCRCB422) { 1076 video->color_space = COLOR_YCBCR422; 1077 video->ycbcr_coeff = COLOR_YCBCR709; 1078 } else { 1079 video->color_space = COLOR_RGB; 1080 video->ycbcr_coeff = COLOR_YCBCR601; 1081 } 1082 1083 ret = drm_dp_dpcd_read(&dp->aux, DP_DPCD_REV, dp->dpcd, DP_RECEIVER_CAP_SIZE); 1084 if (ret < 0) { 1085 dev_err(dp->dev, "failed to read dpcd caps: %d\n", ret); 1086 return ret; 1087 } 1088 1089 ret = analogix_dp_link_power_up(dp); 1090 if (ret) { 1091 dev_err(dp->dev, "failed to power up link: %d\n", ret); 1092 return ret; 1093 } 1094 1095 ret = analogix_dp_set_link_train(dp, dp->video_info.max_lane_count, 1096 dp->video_info.max_link_rate); 1097 if (ret) { 1098 dev_err(dp->dev, "unable to do link train\n"); 1099 return ret; 1100 } 1101 1102 ret = analogix_dp_enable_scramble(dp, 1); 1103 if (ret < 0) { 1104 dev_err(dp->dev, "can not enable scramble\n"); 1105 return ret; 1106 } 1107 1108 analogix_dp_init_video(dp); 1109 1110 drm_mode_copy(&mode, &conn_state->mode); 1111 if (conn->dual_channel_mode) 1112 drm_mode_convert_to_origin_mode(&mode); 1113 analogix_dp_set_video_format(dp, &mode); 1114 1115 if (dp->video_bist_enable) 1116 analogix_dp_video_bist_enable(dp); 1117 1118 ret = analogix_dp_config_video(dp); 1119 if (ret) { 1120 dev_err(dp->dev, "unable to config video\n"); 1121 return ret; 1122 } 1123 1124 return 0; 1125 } 1126 1127 static int analogix_dp_connector_disable(struct rockchip_connector *conn, 1128 struct display_state *state) 1129 { 1130 const struct rockchip_dp_chip_data *pdata = 1131 (const struct rockchip_dp_chip_data *)dev_get_driver_data(conn->dev); 1132 struct analogix_dp_device *dp = dev_get_priv(conn->dev); 1133 1134 if (!analogix_dp_get_plug_in_status(dp)) 1135 analogix_dp_link_power_down(dp); 1136 1137 if (pdata->chip_type == RK3588_EDP) 1138 regmap_write(dp->grf, dp->id ? RK3588_GRF_VO1_CON1 : RK3588_GRF_VO1_CON0, 1139 EDP_MODE << 16 | FIELD_PREP(EDP_MODE, 0)); 1140 1141 return 0; 1142 } 1143 1144 static int analogix_dp_connector_detect(struct rockchip_connector *conn, 1145 struct display_state *state) 1146 { 1147 struct analogix_dp_device *dp = dev_get_priv(conn->dev); 1148 int ret; 1149 1150 if (analogix_dp_detect(dp)) { 1151 /* Initialize by reading RX's DPCD */ 1152 ret = analogix_dp_get_max_rx_bandwidth(dp, &dp->link_train.link_rate); 1153 if (ret) { 1154 dev_err(dp->dev, "failed to read max link rate\n"); 1155 return 0; 1156 } 1157 1158 ret = analogix_dp_get_max_rx_lane_count(dp, &dp->link_train.lane_count); 1159 if (ret) { 1160 dev_err(dp->dev, "failed to read max lane count\n"); 1161 return 0; 1162 } 1163 1164 return 1; 1165 } else { 1166 return 0; 1167 } 1168 } 1169 1170 static int analogix_dp_connector_mode_valid(struct rockchip_connector *conn, 1171 struct display_state *state) 1172 { 1173 struct connector_state *conn_state = &state->conn_state; 1174 struct videomode vm; 1175 1176 drm_display_mode_to_videomode(&conn_state->mode, &vm); 1177 1178 if (!vm.hfront_porch || !vm.hback_porch || !vm.vfront_porch || !vm.vback_porch) { 1179 dev_err(dp->dev, "front porch or back porch can not be 0\n"); 1180 return MODE_BAD; 1181 } 1182 1183 return MODE_OK; 1184 } 1185 1186 static int analogix_dp_mode_valid(struct analogix_dp_device *dp, struct hdmi_edid_data *edid_data) 1187 { 1188 struct drm_display_info *di = &edid_data->display_info; 1189 u32 max_link_rate, max_lane_count; 1190 u32 min_bpp; 1191 int i; 1192 1193 if (di->color_formats & DRM_COLOR_FORMAT_YCRCB422) 1194 min_bpp = 16; 1195 else if (di->color_formats & DRM_COLOR_FORMAT_RGB444) 1196 min_bpp = 18; 1197 else 1198 min_bpp = 24; 1199 1200 max_link_rate = min_t(u32, dp->video_info.max_link_rate, dp->link_train.link_rate); 1201 max_lane_count = min_t(u32, dp->video_info.max_lane_count, dp->link_train.lane_count); 1202 for (i = 0; i < edid_data->modes; i++) { 1203 if (!analogix_dp_bandwidth_ok(dp, &edid_data->mode_buf[i], min_bpp, 1204 drm_dp_bw_code_to_link_rate(max_link_rate), 1205 max_lane_count)) 1206 edid_data->mode_buf[i].invalid = true; 1207 } 1208 1209 return 0; 1210 } 1211 1212 static int analogix_dp_connector_get_timing(struct rockchip_connector *conn, 1213 struct display_state *state) 1214 { 1215 struct connector_state *conn_state = &state->conn_state; 1216 const struct rockchip_dp_chip_data *pdata = 1217 (const struct rockchip_dp_chip_data *)dev_get_driver_data(conn->dev); 1218 struct analogix_dp_device *dp = dev_get_priv(conn->dev); 1219 struct drm_display_mode *mode = &conn_state->mode; 1220 struct hdmi_edid_data edid_data; 1221 struct drm_display_mode *mode_buf; 1222 struct vop_rect rect; 1223 u32 yuv_fmts_mask = DRM_COLOR_FORMAT_YCRCB444 | DRM_COLOR_FORMAT_YCRCB422; 1224 u32 fmt_id; 1225 int ret, i; 1226 1227 mode_buf = malloc(MODE_LEN * sizeof(struct drm_display_mode)); 1228 if (!mode_buf) 1229 return -ENOMEM; 1230 1231 memset(mode_buf, 0, MODE_LEN * sizeof(struct drm_display_mode)); 1232 memset(&edid_data, 0, sizeof(struct hdmi_edid_data)); 1233 edid_data.mode_buf = mode_buf; 1234 1235 ret = drm_do_get_edid(&dp->aux.ddc, conn_state->edid); 1236 if (!ret) 1237 ret = drm_add_edid_modes(&edid_data, conn_state->edid); 1238 1239 if (ret < 0) { 1240 printf("failed to get edid\n"); 1241 goto err; 1242 } 1243 1244 if (!pdata->format_yuv) { 1245 if (edid_data.display_info.color_formats & yuv_fmts_mask) { 1246 printf("Swapping display color format from YUV to RGB\n"); 1247 edid_data.display_info.color_formats &= ~yuv_fmts_mask; 1248 edid_data.display_info.color_formats |= DRM_COLOR_FORMAT_RGB444; 1249 } 1250 } 1251 1252 if (state->conn_state.secondary) { 1253 rect.width = state->crtc_state.max_output.width / 2; 1254 rect.height = state->crtc_state.max_output.height / 2; 1255 } else { 1256 rect.width = state->crtc_state.max_output.width; 1257 rect.height = state->crtc_state.max_output.height; 1258 } 1259 1260 drm_mode_max_resolution_filter(&edid_data, &rect); 1261 analogix_dp_mode_valid(dp, &edid_data); 1262 1263 if (!drm_mode_prune_invalid(&edid_data)) { 1264 printf("can't find valid dp mode\n"); 1265 ret = -EINVAL; 1266 goto err; 1267 } 1268 1269 for (i = 0; i < edid_data.modes; i++) 1270 edid_data.mode_buf[i].vrefresh = drm_mode_vrefresh(&edid_data.mode_buf[i]); 1271 1272 drm_mode_sort(&edid_data); 1273 memcpy(mode, edid_data.preferred_mode, sizeof(struct drm_display_mode)); 1274 1275 fmt_id = analogix_dp_get_output_format_by_edid(dp, &edid_data); 1276 dp->output_fmt = &possible_output_fmts[fmt_id]; 1277 1278 switch (dp->output_fmt->color_format) { 1279 case DRM_COLOR_FORMAT_YCRCB422: 1280 conn_state->output_mode = ROCKCHIP_OUT_MODE_YUV422; 1281 break; 1282 case DRM_COLOR_FORMAT_RGB444: 1283 case DRM_COLOR_FORMAT_YCRCB444: 1284 default: 1285 conn_state->output_mode = ROCKCHIP_OUT_MODE_AAAA; 1286 break; 1287 } 1288 1289 conn_state->bus_format = dp->output_fmt->bus_format; 1290 conn_state->bpc = dp->output_fmt->bpc; 1291 conn_state->color_encoding = DRM_COLOR_YCBCR_BT709; 1292 if (dp->output_fmt->color_format == DRM_COLOR_FORMAT_RGB444) 1293 conn_state->color_range = DRM_COLOR_YCBCR_FULL_RANGE; 1294 else 1295 conn_state->color_range = DRM_COLOR_YCBCR_LIMITED_RANGE; 1296 1297 err: 1298 free(mode_buf); 1299 1300 return 0; 1301 } 1302 1303 static const struct rockchip_connector_funcs analogix_dp_connector_funcs = { 1304 .init = analogix_dp_connector_init, 1305 .get_edid = analogix_dp_connector_get_edid, 1306 .enable = analogix_dp_connector_enable, 1307 .disable = analogix_dp_connector_disable, 1308 .detect = analogix_dp_connector_detect, 1309 .mode_valid = analogix_dp_connector_mode_valid, 1310 .get_timing = analogix_dp_connector_get_timing, 1311 }; 1312 1313 static u32 analogix_dp_parse_link_frequencies(struct analogix_dp_device *dp) 1314 { 1315 struct udevice *dev = dp->dev; 1316 const struct device_node *endpoint; 1317 u64 frequency = 0; 1318 1319 endpoint = rockchip_of_graph_get_endpoint_by_regs(dev->node, 1, 0); 1320 if (!endpoint) 1321 return 0; 1322 1323 if (of_property_read_u64(endpoint, "link-frequencies", &frequency) < 0) 1324 return 0; 1325 1326 if (!frequency) 1327 return 0; 1328 1329 do_div(frequency, 10 * 1000); /* symbol rate kbytes */ 1330 1331 switch (frequency) { 1332 case 162000: 1333 case 270000: 1334 case 540000: 1335 break; 1336 default: 1337 dev_err(dev, "invalid link frequency value: %llu\n", frequency); 1338 return 0; 1339 } 1340 1341 return frequency; 1342 } 1343 1344 static int analogix_dp_parse_dt(struct analogix_dp_device *dp) 1345 { 1346 struct udevice *dev = dp->dev; 1347 int len; 1348 u32 num_lanes; 1349 u32 max_link_rate; 1350 int ret; 1351 1352 dp->force_hpd = dev_read_bool(dev, "force-hpd"); 1353 dp->video_bist_enable = dev_read_bool(dev, "analogix,video-bist-enable"); 1354 dp->video_info.force_stream_valid = 1355 dev_read_bool(dev, "analogix,force-stream-valid"); 1356 1357 max_link_rate = analogix_dp_parse_link_frequencies(dp); 1358 if (max_link_rate && max_link_rate < drm_dp_bw_code_to_link_rate(dp->video_info.max_link_rate)) 1359 dp->video_info.max_link_rate = drm_dp_link_rate_to_bw_code(max_link_rate); 1360 1361 if (dev_read_prop(dev, "data-lanes", &len)) { 1362 num_lanes = len / sizeof(u32); 1363 if (num_lanes < 1 || num_lanes > 4 || num_lanes == 3) { 1364 dev_err(dev, "bad number of data lanes\n"); 1365 return -EINVAL; 1366 } 1367 1368 ret = dev_read_u32_array(dev, "data-lanes", dp->lane_map, 1369 num_lanes); 1370 if (ret) 1371 return ret; 1372 1373 dp->video_info.max_lane_count = num_lanes; 1374 } else { 1375 dp->lane_map[0] = 0; 1376 dp->lane_map[1] = 1; 1377 dp->lane_map[2] = 2; 1378 dp->lane_map[3] = 3; 1379 } 1380 1381 return 0; 1382 } 1383 1384 static int analogix_dp_ddc_init(struct analogix_dp_device *dp) 1385 { 1386 dp->aux.name = "analogix-dp"; 1387 dp->aux.dev = dp->dev; 1388 dp->aux.transfer = analogix_dp_aux_transfer; 1389 dp->aux.ddc.ddc_xfer = drm_dp_i2c_xfer; 1390 1391 return 0; 1392 } 1393 1394 static int analogix_dp_probe(struct udevice *dev) 1395 { 1396 struct analogix_dp_device *dp = dev_get_priv(dev); 1397 const struct rockchip_dp_chip_data *pdata = 1398 (const struct rockchip_dp_chip_data *)dev_get_driver_data(dev); 1399 struct udevice *syscon; 1400 int ret; 1401 1402 dp->reg_base = dev_read_addr_ptr(dev); 1403 1404 dp->id = of_alias_get_id(ofnode_to_np(dev->node), "edp"); 1405 if (dp->id < 0) 1406 dp->id = 0; 1407 1408 ret = uclass_get_device_by_phandle(UCLASS_SYSCON, dev, "rockchip,grf", 1409 &syscon); 1410 if (!ret) { 1411 dp->grf = syscon_get_regmap(syscon); 1412 if (!dp->grf) 1413 return -ENODEV; 1414 } 1415 1416 ret = reset_get_bulk(dev, &dp->resets); 1417 if (ret) { 1418 dev_err(dev, "failed to get reset control: %d\n", ret); 1419 return ret; 1420 } 1421 1422 ret = gpio_request_by_name(dev, "hpd-gpios", 0, &dp->hpd_gpio, 1423 GPIOD_IS_IN); 1424 if (ret && ret != -ENOENT) { 1425 dev_err(dev, "failed to get hpd GPIO: %d\n", ret); 1426 return ret; 1427 } 1428 1429 generic_phy_get_by_name(dev, "dp", &dp->phy); 1430 1431 dp->plat_data.dev_type = ROCKCHIP_DP; 1432 dp->plat_data.subdev_type = pdata->chip_type; 1433 dp->plat_data.ssc = pdata->ssc; 1434 dp->plat_data.support_dp_mode = pdata->support_dp_mode; 1435 dp->plat_data.max_bpc = pdata->max_bpc ? pdata->max_bpc : 8; 1436 1437 dp->video_info.max_link_rate = pdata->max_link_rate; 1438 dp->video_info.max_lane_count = pdata->max_lane_count; 1439 1440 dp->dev = dev; 1441 1442 ret = analogix_dp_parse_dt(dp); 1443 if (ret) { 1444 dev_err(dev, "failed to parse DT: %d\n", ret); 1445 return ret; 1446 } 1447 1448 analogix_dp_ddc_init(dp); 1449 1450 rockchip_connector_bind(&dp->connector, dev, dp->id, &analogix_dp_connector_funcs, 1451 NULL, DRM_MODE_CONNECTOR_eDP); 1452 1453 return 0; 1454 } 1455 1456 static const struct rockchip_dp_chip_data rk3288_edp_platform_data = { 1457 .lcdsel_grf_reg = 0x025c, 1458 .lcdsel_big = 0 | BIT(21), 1459 .lcdsel_lit = BIT(5) | BIT(21), 1460 .chip_type = RK3288_DP, 1461 1462 .max_link_rate = DP_LINK_BW_2_7, 1463 .max_lane_count = 4, 1464 }; 1465 1466 static const struct rockchip_dp_chip_data rk3368_edp_platform_data = { 1467 .chip_type = RK3368_EDP, 1468 1469 .max_link_rate = DP_LINK_BW_2_7, 1470 .max_lane_count = 4, 1471 }; 1472 1473 static const struct rockchip_dp_chip_data rk3399_edp_platform_data = { 1474 .lcdsel_grf_reg = 0x6250, 1475 .lcdsel_big = 0 | BIT(21), 1476 .lcdsel_lit = BIT(5) | BIT(21), 1477 .chip_type = RK3399_EDP, 1478 .ssc = true, 1479 1480 .max_link_rate = DP_LINK_BW_5_4, 1481 .max_lane_count = 4, 1482 }; 1483 1484 static const struct rockchip_dp_chip_data rk3568_edp_platform_data = { 1485 .chip_type = RK3568_EDP, 1486 .ssc = true, 1487 1488 .max_link_rate = DP_LINK_BW_2_7, 1489 .max_lane_count = 4, 1490 }; 1491 1492 static const struct rockchip_dp_chip_data rk3576_edp_platform_data = { 1493 .chip_type = RK3576_EDP, 1494 .ssc = true, 1495 1496 .max_link_rate = DP_LINK_BW_5_4, 1497 .max_lane_count = 4, 1498 .format_yuv = true, 1499 .support_dp_mode = true, 1500 .max_bpc = 10, 1501 }; 1502 1503 static const struct rockchip_dp_chip_data rk3588_edp_platform_data = { 1504 .chip_type = RK3588_EDP, 1505 .ssc = true, 1506 1507 .max_link_rate = DP_LINK_BW_5_4, 1508 .max_lane_count = 4, 1509 .format_yuv = true, 1510 .support_dp_mode = true, 1511 .max_bpc = 10, 1512 }; 1513 1514 static const struct udevice_id analogix_dp_ids[] = { 1515 { 1516 .compatible = "rockchip,rk3288-dp", 1517 .data = (ulong)&rk3288_edp_platform_data, 1518 }, { 1519 .compatible = "rockchip,rk3368-edp", 1520 .data = (ulong)&rk3368_edp_platform_data, 1521 }, { 1522 .compatible = "rockchip,rk3399-edp", 1523 .data = (ulong)&rk3399_edp_platform_data, 1524 }, { 1525 .compatible = "rockchip,rk3568-edp", 1526 .data = (ulong)&rk3568_edp_platform_data, 1527 }, { 1528 .compatible = "rockchip,rk3576-edp", 1529 .data = (ulong)&rk3576_edp_platform_data, 1530 }, { 1531 .compatible = "rockchip,rk3588-edp", 1532 .data = (ulong)&rk3588_edp_platform_data, 1533 }, 1534 {} 1535 }; 1536 1537 U_BOOT_DRIVER(analogix_dp) = { 1538 .name = "analogix_dp", 1539 .id = UCLASS_DISPLAY, 1540 .of_match = analogix_dp_ids, 1541 .probe = analogix_dp_probe, 1542 .priv_auto_alloc_size = sizeof(struct analogix_dp_device), 1543 }; 1544