1 /* 2 * Copyright (C) 2012 Samsung Electronics 3 * 4 * Author: Donghwa Lee <dh09.lee@samsung.com> 5 * 6 * SPDX-License-Identifier: GPL-2.0+ 7 */ 8 9 #include <config.h> 10 #include <dm.h> 11 #include <common.h> 12 #include <display.h> 13 #include <fdtdec.h> 14 #include <libfdt.h> 15 #include <malloc.h> 16 #include <video_bridge.h> 17 #include <linux/compat.h> 18 #include <linux/err.h> 19 #include <asm/arch/clk.h> 20 #include <asm/arch/cpu.h> 21 #include <asm/arch/dp_info.h> 22 #include <asm/arch/dp.h> 23 #include <asm/arch/pinmux.h> 24 #include <asm/arch/power.h> 25 26 #include "exynos_dp_lowlevel.h" 27 28 DECLARE_GLOBAL_DATA_PTR; 29 30 static void exynos_dp_disp_info(struct edp_disp_info *disp_info) 31 { 32 disp_info->h_total = disp_info->h_res + disp_info->h_sync_width + 33 disp_info->h_back_porch + disp_info->h_front_porch; 34 disp_info->v_total = disp_info->v_res + disp_info->v_sync_width + 35 disp_info->v_back_porch + disp_info->v_front_porch; 36 37 return; 38 } 39 40 static int exynos_dp_init_dp(struct exynos_dp *regs) 41 { 42 int ret; 43 exynos_dp_reset(regs); 44 45 /* SW defined function Normal operation */ 46 exynos_dp_enable_sw_func(regs, DP_ENABLE); 47 48 ret = exynos_dp_init_analog_func(regs); 49 if (ret != EXYNOS_DP_SUCCESS) 50 return ret; 51 52 exynos_dp_init_hpd(regs); 53 exynos_dp_init_aux(regs); 54 55 return ret; 56 } 57 58 static unsigned char exynos_dp_calc_edid_check_sum(unsigned char *edid_data) 59 { 60 int i; 61 unsigned char sum = 0; 62 63 for (i = 0; i < EDID_BLOCK_LENGTH; i++) 64 sum = sum + edid_data[i]; 65 66 return sum; 67 } 68 69 static unsigned int exynos_dp_read_edid(struct exynos_dp *regs) 70 { 71 unsigned char edid[EDID_BLOCK_LENGTH * 2]; 72 unsigned int extend_block = 0; 73 unsigned char sum; 74 unsigned char test_vector; 75 int retval; 76 77 /* 78 * EDID device address is 0x50. 79 * However, if necessary, you must have set upper address 80 * into E-EDID in I2C device, 0x30. 81 */ 82 83 /* Read Extension Flag, Number of 128-byte EDID extension blocks */ 84 exynos_dp_read_byte_from_i2c(regs, I2C_EDID_DEVICE_ADDR, 85 EDID_EXTENSION_FLAG, &extend_block); 86 87 if (extend_block > 0) { 88 printf("DP EDID data includes a single extension!\n"); 89 90 /* Read EDID data */ 91 retval = exynos_dp_read_bytes_from_i2c(regs, 92 I2C_EDID_DEVICE_ADDR, 93 EDID_HEADER_PATTERN, 94 EDID_BLOCK_LENGTH, 95 &edid[EDID_HEADER_PATTERN]); 96 if (retval != 0) { 97 printf("DP EDID Read failed!\n"); 98 return -1; 99 } 100 sum = exynos_dp_calc_edid_check_sum(edid); 101 if (sum != 0) { 102 printf("DP EDID bad checksum!\n"); 103 return -1; 104 } 105 106 /* Read additional EDID data */ 107 retval = exynos_dp_read_bytes_from_i2c(regs, 108 I2C_EDID_DEVICE_ADDR, 109 EDID_BLOCK_LENGTH, 110 EDID_BLOCK_LENGTH, 111 &edid[EDID_BLOCK_LENGTH]); 112 if (retval != 0) { 113 printf("DP EDID Read failed!\n"); 114 return -1; 115 } 116 sum = exynos_dp_calc_edid_check_sum(&edid[EDID_BLOCK_LENGTH]); 117 if (sum != 0) { 118 printf("DP EDID bad checksum!\n"); 119 return -1; 120 } 121 122 exynos_dp_read_byte_from_dpcd(regs, DPCD_TEST_REQUEST, 123 &test_vector); 124 if (test_vector & DPCD_TEST_EDID_READ) { 125 exynos_dp_write_byte_to_dpcd(regs, 126 DPCD_TEST_EDID_CHECKSUM, 127 edid[EDID_BLOCK_LENGTH + EDID_CHECKSUM]); 128 exynos_dp_write_byte_to_dpcd(regs, 129 DPCD_TEST_RESPONSE, 130 DPCD_TEST_EDID_CHECKSUM_WRITE); 131 } 132 } else { 133 debug("DP EDID data does not include any extensions.\n"); 134 135 /* Read EDID data */ 136 retval = exynos_dp_read_bytes_from_i2c(regs, 137 I2C_EDID_DEVICE_ADDR, 138 EDID_HEADER_PATTERN, 139 EDID_BLOCK_LENGTH, 140 &edid[EDID_HEADER_PATTERN]); 141 142 if (retval != 0) { 143 printf("DP EDID Read failed!\n"); 144 return -1; 145 } 146 sum = exynos_dp_calc_edid_check_sum(edid); 147 if (sum != 0) { 148 printf("DP EDID bad checksum!\n"); 149 return -1; 150 } 151 152 exynos_dp_read_byte_from_dpcd(regs, DPCD_TEST_REQUEST, 153 &test_vector); 154 if (test_vector & DPCD_TEST_EDID_READ) { 155 exynos_dp_write_byte_to_dpcd(regs, 156 DPCD_TEST_EDID_CHECKSUM, edid[EDID_CHECKSUM]); 157 exynos_dp_write_byte_to_dpcd(regs, 158 DPCD_TEST_RESPONSE, 159 DPCD_TEST_EDID_CHECKSUM_WRITE); 160 } 161 } 162 163 debug("DP EDID Read success!\n"); 164 165 return 0; 166 } 167 168 static unsigned int exynos_dp_handle_edid(struct exynos_dp *regs, 169 struct exynos_dp_priv *priv) 170 { 171 unsigned char buf[12]; 172 unsigned int ret; 173 unsigned char temp; 174 unsigned char retry_cnt; 175 unsigned char dpcd_rev[16]; 176 unsigned char lane_bw[16]; 177 unsigned char lane_cnt[16]; 178 179 memset(dpcd_rev, 0, 16); 180 memset(lane_bw, 0, 16); 181 memset(lane_cnt, 0, 16); 182 memset(buf, 0, 12); 183 184 retry_cnt = 5; 185 while (retry_cnt) { 186 /* Read DPCD 0x0000-0x000b */ 187 ret = exynos_dp_read_bytes_from_dpcd(regs, DPCD_DPCD_REV, 12, 188 buf); 189 if (ret != EXYNOS_DP_SUCCESS) { 190 if (retry_cnt == 0) { 191 printf("DP read_byte_from_dpcd() failed\n"); 192 return ret; 193 } 194 retry_cnt--; 195 } else 196 break; 197 } 198 199 /* */ 200 temp = buf[DPCD_DPCD_REV]; 201 if (temp == DP_DPCD_REV_10 || temp == DP_DPCD_REV_11) 202 priv->dpcd_rev = temp; 203 else { 204 printf("DP Wrong DPCD Rev : %x\n", temp); 205 return -ENODEV; 206 } 207 208 temp = buf[DPCD_MAX_LINK_RATE]; 209 if (temp == DP_LANE_BW_1_62 || temp == DP_LANE_BW_2_70) 210 priv->lane_bw = temp; 211 else { 212 printf("DP Wrong MAX LINK RATE : %x\n", temp); 213 return -EINVAL; 214 } 215 216 /* Refer VESA Display Port Standard Ver1.1a Page 120 */ 217 if (priv->dpcd_rev == DP_DPCD_REV_11) { 218 temp = buf[DPCD_MAX_LANE_COUNT] & 0x1f; 219 if (buf[DPCD_MAX_LANE_COUNT] & 0x80) 220 priv->dpcd_efc = 1; 221 else 222 priv->dpcd_efc = 0; 223 } else { 224 temp = buf[DPCD_MAX_LANE_COUNT]; 225 priv->dpcd_efc = 0; 226 } 227 228 if (temp == DP_LANE_CNT_1 || temp == DP_LANE_CNT_2 || 229 temp == DP_LANE_CNT_4) { 230 priv->lane_cnt = temp; 231 } else { 232 printf("DP Wrong MAX LANE COUNT : %x\n", temp); 233 return -EINVAL; 234 } 235 236 ret = exynos_dp_read_edid(regs); 237 if (ret != EXYNOS_DP_SUCCESS) { 238 printf("DP exynos_dp_read_edid() failed\n"); 239 return -EINVAL; 240 } 241 242 return ret; 243 } 244 245 static void exynos_dp_init_training(struct exynos_dp *regs) 246 { 247 /* 248 * MACRO_RST must be applied after the PLL_LOCK to avoid 249 * the DP inter pair skew issue for at least 10 us 250 */ 251 exynos_dp_reset_macro(regs); 252 253 /* All DP analog module power up */ 254 exynos_dp_set_analog_power_down(regs, POWER_ALL, 0); 255 } 256 257 static unsigned int exynos_dp_link_start(struct exynos_dp *regs, 258 struct exynos_dp_priv *priv) 259 { 260 unsigned char buf[5]; 261 unsigned int ret = 0; 262 263 debug("DP: %s was called\n", __func__); 264 265 priv->lt_info.lt_status = DP_LT_CR; 266 priv->lt_info.ep_loop = 0; 267 priv->lt_info.cr_loop[0] = 0; 268 priv->lt_info.cr_loop[1] = 0; 269 priv->lt_info.cr_loop[2] = 0; 270 priv->lt_info.cr_loop[3] = 0; 271 272 /* Set sink to D0 (Sink Not Ready) mode. */ 273 ret = exynos_dp_write_byte_to_dpcd(regs, DPCD_SINK_POWER_STATE, 274 DPCD_SET_POWER_STATE_D0); 275 if (ret != EXYNOS_DP_SUCCESS) { 276 printf("DP write_dpcd_byte failed\n"); 277 return ret; 278 } 279 280 /* Set link rate and count as you want to establish */ 281 exynos_dp_set_link_bandwidth(regs, priv->lane_bw); 282 exynos_dp_set_lane_count(regs, priv->lane_cnt); 283 284 /* Setup RX configuration */ 285 buf[0] = priv->lane_bw; 286 buf[1] = priv->lane_cnt; 287 288 ret = exynos_dp_write_bytes_to_dpcd(regs, DPCD_LINK_BW_SET, 2, buf); 289 if (ret != EXYNOS_DP_SUCCESS) { 290 printf("DP write_dpcd_byte failed\n"); 291 return ret; 292 } 293 294 exynos_dp_set_lane_pre_emphasis(regs, PRE_EMPHASIS_LEVEL_0, 295 priv->lane_cnt); 296 297 /* Set training pattern 1 */ 298 exynos_dp_set_training_pattern(regs, TRAINING_PTN1); 299 300 /* Set RX training pattern */ 301 buf[0] = DPCD_SCRAMBLING_DISABLED | DPCD_TRAINING_PATTERN_1; 302 303 buf[1] = DPCD_PRE_EMPHASIS_SET_PATTERN_2_LEVEL_0 | 304 DPCD_VOLTAGE_SWING_SET_PATTERN_1_LEVEL_0; 305 buf[2] = DPCD_PRE_EMPHASIS_SET_PATTERN_2_LEVEL_0 | 306 DPCD_VOLTAGE_SWING_SET_PATTERN_1_LEVEL_0; 307 buf[3] = DPCD_PRE_EMPHASIS_SET_PATTERN_2_LEVEL_0 | 308 DPCD_VOLTAGE_SWING_SET_PATTERN_1_LEVEL_0; 309 buf[4] = DPCD_PRE_EMPHASIS_SET_PATTERN_2_LEVEL_0 | 310 DPCD_VOLTAGE_SWING_SET_PATTERN_1_LEVEL_0; 311 312 ret = exynos_dp_write_bytes_to_dpcd(regs, DPCD_TRAINING_PATTERN_SET, 313 5, buf); 314 if (ret != EXYNOS_DP_SUCCESS) { 315 printf("DP write_dpcd_byte failed\n"); 316 return ret; 317 } 318 319 return ret; 320 } 321 322 static unsigned int exynos_dp_training_pattern_dis(struct exynos_dp *regs) 323 { 324 unsigned int ret = EXYNOS_DP_SUCCESS; 325 326 exynos_dp_set_training_pattern(regs, DP_NONE); 327 328 ret = exynos_dp_write_byte_to_dpcd(regs, DPCD_TRAINING_PATTERN_SET, 329 DPCD_TRAINING_PATTERN_DISABLED); 330 if (ret != EXYNOS_DP_SUCCESS) { 331 printf("DP request_link_training_req failed\n"); 332 return -EAGAIN; 333 } 334 335 return ret; 336 } 337 338 static unsigned int exynos_dp_enable_rx_to_enhanced_mode( 339 struct exynos_dp *regs, unsigned char enable) 340 { 341 unsigned char data; 342 unsigned int ret = EXYNOS_DP_SUCCESS; 343 344 ret = exynos_dp_read_byte_from_dpcd(regs, DPCD_LANE_COUNT_SET, 345 &data); 346 if (ret != EXYNOS_DP_SUCCESS) { 347 printf("DP read_from_dpcd failed\n"); 348 return -EAGAIN; 349 } 350 351 if (enable) 352 data = DPCD_ENHANCED_FRAME_EN | DPCD_LN_COUNT_SET(data); 353 else 354 data = DPCD_LN_COUNT_SET(data); 355 356 ret = exynos_dp_write_byte_to_dpcd(regs, DPCD_LANE_COUNT_SET, data); 357 if (ret != EXYNOS_DP_SUCCESS) { 358 printf("DP write_to_dpcd failed\n"); 359 return -EAGAIN; 360 361 } 362 363 return ret; 364 } 365 366 static unsigned int exynos_dp_set_enhanced_mode(struct exynos_dp *regs, 367 unsigned char enhance_mode) 368 { 369 unsigned int ret = EXYNOS_DP_SUCCESS; 370 371 ret = exynos_dp_enable_rx_to_enhanced_mode(regs, enhance_mode); 372 if (ret != EXYNOS_DP_SUCCESS) { 373 printf("DP rx_enhance_mode failed\n"); 374 return -EAGAIN; 375 } 376 377 exynos_dp_enable_enhanced_mode(regs, enhance_mode); 378 379 return ret; 380 } 381 382 static int exynos_dp_read_dpcd_lane_stat(struct exynos_dp *regs, 383 struct exynos_dp_priv *priv, 384 unsigned char *status) 385 { 386 unsigned int ret, i; 387 unsigned char buf[2]; 388 unsigned char lane_stat[DP_LANE_CNT_4] = {0,}; 389 unsigned char shift_val[DP_LANE_CNT_4] = {0,}; 390 391 shift_val[0] = 0; 392 shift_val[1] = 4; 393 shift_val[2] = 0; 394 shift_val[3] = 4; 395 396 ret = exynos_dp_read_bytes_from_dpcd(regs, DPCD_LANE0_1_STATUS, 2, 397 buf); 398 if (ret != EXYNOS_DP_SUCCESS) { 399 printf("DP read lane status failed\n"); 400 return ret; 401 } 402 403 for (i = 0; i < priv->lane_cnt; i++) { 404 lane_stat[i] = (buf[(i / 2)] >> shift_val[i]) & 0x0f; 405 if (lane_stat[0] != lane_stat[i]) { 406 printf("Wrong lane status\n"); 407 return -EINVAL; 408 } 409 } 410 411 *status = lane_stat[0]; 412 413 return ret; 414 } 415 416 static unsigned int exynos_dp_read_dpcd_adj_req(struct exynos_dp *regs, 417 unsigned char lane_num, unsigned char *sw, unsigned char *em) 418 { 419 unsigned int ret = EXYNOS_DP_SUCCESS; 420 unsigned char buf; 421 unsigned int dpcd_addr; 422 unsigned char shift_val[DP_LANE_CNT_4] = {0, 4, 0, 4}; 423 424 /* lane_num value is used as array index, so this range 0 ~ 3 */ 425 dpcd_addr = DPCD_ADJUST_REQUEST_LANE0_1 + (lane_num / 2); 426 427 ret = exynos_dp_read_byte_from_dpcd(regs, dpcd_addr, &buf); 428 if (ret != EXYNOS_DP_SUCCESS) { 429 printf("DP read adjust request failed\n"); 430 return -EAGAIN; 431 } 432 433 *sw = ((buf >> shift_val[lane_num]) & 0x03); 434 *em = ((buf >> shift_val[lane_num]) & 0x0c) >> 2; 435 436 return ret; 437 } 438 439 static int exynos_dp_equalizer_err_link(struct exynos_dp *regs, 440 struct exynos_dp_priv *priv) 441 { 442 int ret; 443 444 ret = exynos_dp_training_pattern_dis(regs); 445 if (ret != EXYNOS_DP_SUCCESS) { 446 printf("DP training_pattern_disable() failed\n"); 447 priv->lt_info.lt_status = DP_LT_FAIL; 448 } 449 450 ret = exynos_dp_set_enhanced_mode(regs, priv->dpcd_efc); 451 if (ret != EXYNOS_DP_SUCCESS) { 452 printf("DP set_enhanced_mode() failed\n"); 453 priv->lt_info.lt_status = DP_LT_FAIL; 454 } 455 456 return ret; 457 } 458 459 static int exynos_dp_reduce_link_rate(struct exynos_dp *regs, 460 struct exynos_dp_priv *priv) 461 { 462 int ret; 463 464 if (priv->lane_bw == DP_LANE_BW_2_70) { 465 priv->lane_bw = DP_LANE_BW_1_62; 466 printf("DP Change lane bw to 1.62Gbps\n"); 467 priv->lt_info.lt_status = DP_LT_START; 468 ret = EXYNOS_DP_SUCCESS; 469 } else { 470 ret = exynos_dp_training_pattern_dis(regs); 471 if (ret != EXYNOS_DP_SUCCESS) 472 printf("DP training_patter_disable() failed\n"); 473 474 ret = exynos_dp_set_enhanced_mode(regs, priv->dpcd_efc); 475 if (ret != EXYNOS_DP_SUCCESS) 476 printf("DP set_enhanced_mode() failed\n"); 477 478 priv->lt_info.lt_status = DP_LT_FAIL; 479 } 480 481 return ret; 482 } 483 484 static unsigned int exynos_dp_process_clock_recovery(struct exynos_dp *regs, 485 struct exynos_dp_priv *priv) 486 { 487 unsigned int ret = EXYNOS_DP_SUCCESS; 488 unsigned char lane_stat; 489 unsigned char lt_ctl_val[DP_LANE_CNT_4] = {0, }; 490 unsigned int i; 491 unsigned char adj_req_sw; 492 unsigned char adj_req_em; 493 unsigned char buf[5]; 494 495 debug("DP: %s was called\n", __func__); 496 mdelay(1); 497 498 ret = exynos_dp_read_dpcd_lane_stat(regs, priv, &lane_stat); 499 if (ret != EXYNOS_DP_SUCCESS) { 500 printf("DP read lane status failed\n"); 501 priv->lt_info.lt_status = DP_LT_FAIL; 502 return ret; 503 } 504 505 if (lane_stat & DP_LANE_STAT_CR_DONE) { 506 debug("DP clock Recovery training succeed\n"); 507 exynos_dp_set_training_pattern(regs, TRAINING_PTN2); 508 509 for (i = 0; i < priv->lane_cnt; i++) { 510 ret = exynos_dp_read_dpcd_adj_req(regs, i, 511 &adj_req_sw, &adj_req_em); 512 if (ret != EXYNOS_DP_SUCCESS) { 513 priv->lt_info.lt_status = DP_LT_FAIL; 514 return ret; 515 } 516 517 lt_ctl_val[i] = 0; 518 lt_ctl_val[i] = adj_req_em << 3 | adj_req_sw; 519 520 if ((adj_req_sw == VOLTAGE_LEVEL_3) 521 || (adj_req_em == PRE_EMPHASIS_LEVEL_3)) { 522 lt_ctl_val[i] |= MAX_DRIVE_CURRENT_REACH_3 | 523 MAX_PRE_EMPHASIS_REACH_3; 524 } 525 exynos_dp_set_lanex_pre_emphasis(regs, 526 lt_ctl_val[i], i); 527 } 528 529 buf[0] = DPCD_SCRAMBLING_DISABLED | DPCD_TRAINING_PATTERN_2; 530 buf[1] = lt_ctl_val[0]; 531 buf[2] = lt_ctl_val[1]; 532 buf[3] = lt_ctl_val[2]; 533 buf[4] = lt_ctl_val[3]; 534 535 ret = exynos_dp_write_bytes_to_dpcd(regs, 536 DPCD_TRAINING_PATTERN_SET, 5, buf); 537 if (ret != EXYNOS_DP_SUCCESS) { 538 printf("DP write training pattern1 failed\n"); 539 priv->lt_info.lt_status = DP_LT_FAIL; 540 return ret; 541 } else 542 priv->lt_info.lt_status = DP_LT_ET; 543 } else { 544 for (i = 0; i < priv->lane_cnt; i++) { 545 lt_ctl_val[i] = exynos_dp_get_lanex_pre_emphasis( 546 regs, i); 547 ret = exynos_dp_read_dpcd_adj_req(regs, i, 548 &adj_req_sw, &adj_req_em); 549 if (ret != EXYNOS_DP_SUCCESS) { 550 printf("DP read adj req failed\n"); 551 priv->lt_info.lt_status = DP_LT_FAIL; 552 return ret; 553 } 554 555 if ((adj_req_sw == VOLTAGE_LEVEL_3) || 556 (adj_req_em == PRE_EMPHASIS_LEVEL_3)) 557 ret = exynos_dp_reduce_link_rate(regs, 558 priv); 559 560 if ((DRIVE_CURRENT_SET_0_GET(lt_ctl_val[i]) == 561 adj_req_sw) && 562 (PRE_EMPHASIS_SET_0_GET(lt_ctl_val[i]) == 563 adj_req_em)) { 564 priv->lt_info.cr_loop[i]++; 565 if (priv->lt_info.cr_loop[i] == MAX_CR_LOOP) 566 ret = exynos_dp_reduce_link_rate( 567 regs, priv); 568 } 569 570 lt_ctl_val[i] = 0; 571 lt_ctl_val[i] = adj_req_em << 3 | adj_req_sw; 572 573 if ((adj_req_sw == VOLTAGE_LEVEL_3) || 574 (adj_req_em == PRE_EMPHASIS_LEVEL_3)) { 575 lt_ctl_val[i] |= MAX_DRIVE_CURRENT_REACH_3 | 576 MAX_PRE_EMPHASIS_REACH_3; 577 } 578 exynos_dp_set_lanex_pre_emphasis(regs, 579 lt_ctl_val[i], i); 580 } 581 582 ret = exynos_dp_write_bytes_to_dpcd(regs, 583 DPCD_TRAINING_LANE0_SET, 4, lt_ctl_val); 584 if (ret != EXYNOS_DP_SUCCESS) { 585 printf("DP write training pattern2 failed\n"); 586 priv->lt_info.lt_status = DP_LT_FAIL; 587 return ret; 588 } 589 } 590 591 return ret; 592 } 593 594 static unsigned int exynos_dp_process_equalizer_training( 595 struct exynos_dp *regs, struct exynos_dp_priv *priv) 596 { 597 unsigned int ret = EXYNOS_DP_SUCCESS; 598 unsigned char lane_stat, adj_req_sw, adj_req_em, i; 599 unsigned char lt_ctl_val[DP_LANE_CNT_4] = {0,}; 600 unsigned char interlane_aligned = 0; 601 unsigned char f_bw; 602 unsigned char f_lane_cnt; 603 unsigned char sink_stat; 604 605 mdelay(1); 606 607 ret = exynos_dp_read_dpcd_lane_stat(regs, priv, &lane_stat); 608 if (ret != EXYNOS_DP_SUCCESS) { 609 printf("DP read lane status failed\n"); 610 priv->lt_info.lt_status = DP_LT_FAIL; 611 return ret; 612 } 613 614 debug("DP lane stat : %x\n", lane_stat); 615 616 if (lane_stat & DP_LANE_STAT_CR_DONE) { 617 ret = exynos_dp_read_byte_from_dpcd(regs, 618 DPCD_LN_ALIGN_UPDATED, 619 &sink_stat); 620 if (ret != EXYNOS_DP_SUCCESS) { 621 priv->lt_info.lt_status = DP_LT_FAIL; 622 623 return ret; 624 } 625 626 interlane_aligned = (sink_stat & DPCD_INTERLANE_ALIGN_DONE); 627 628 for (i = 0; i < priv->lane_cnt; i++) { 629 ret = exynos_dp_read_dpcd_adj_req(regs, i, 630 &adj_req_sw, &adj_req_em); 631 if (ret != EXYNOS_DP_SUCCESS) { 632 printf("DP read adj req 1 failed\n"); 633 priv->lt_info.lt_status = DP_LT_FAIL; 634 635 return ret; 636 } 637 638 lt_ctl_val[i] = 0; 639 lt_ctl_val[i] = adj_req_em << 3 | adj_req_sw; 640 641 if ((adj_req_sw == VOLTAGE_LEVEL_3) || 642 (adj_req_em == PRE_EMPHASIS_LEVEL_3)) { 643 lt_ctl_val[i] |= MAX_DRIVE_CURRENT_REACH_3; 644 lt_ctl_val[i] |= MAX_PRE_EMPHASIS_REACH_3; 645 } 646 } 647 648 if (((lane_stat&DP_LANE_STAT_CE_DONE) && 649 (lane_stat&DP_LANE_STAT_SYM_LOCK)) 650 && (interlane_aligned == DPCD_INTERLANE_ALIGN_DONE)) { 651 debug("DP Equalizer training succeed\n"); 652 653 f_bw = exynos_dp_get_link_bandwidth(regs); 654 f_lane_cnt = exynos_dp_get_lane_count(regs); 655 656 debug("DP final BandWidth : %x\n", f_bw); 657 debug("DP final Lane Count : %x\n", f_lane_cnt); 658 659 priv->lt_info.lt_status = DP_LT_FINISHED; 660 661 exynos_dp_equalizer_err_link(regs, priv); 662 663 } else { 664 priv->lt_info.ep_loop++; 665 666 if (priv->lt_info.ep_loop > MAX_EQ_LOOP) { 667 if (priv->lane_bw == DP_LANE_BW_2_70) { 668 ret = exynos_dp_reduce_link_rate( 669 regs, priv); 670 } else { 671 priv->lt_info.lt_status = 672 DP_LT_FAIL; 673 exynos_dp_equalizer_err_link(regs, 674 priv); 675 } 676 } else { 677 for (i = 0; i < priv->lane_cnt; i++) 678 exynos_dp_set_lanex_pre_emphasis( 679 regs, lt_ctl_val[i], i); 680 681 ret = exynos_dp_write_bytes_to_dpcd(regs, 682 DPCD_TRAINING_LANE0_SET, 683 4, lt_ctl_val); 684 if (ret != EXYNOS_DP_SUCCESS) { 685 printf("DP set lt pattern failed\n"); 686 priv->lt_info.lt_status = 687 DP_LT_FAIL; 688 exynos_dp_equalizer_err_link(regs, 689 priv); 690 } 691 } 692 } 693 } else if (priv->lane_bw == DP_LANE_BW_2_70) { 694 ret = exynos_dp_reduce_link_rate(regs, priv); 695 } else { 696 priv->lt_info.lt_status = DP_LT_FAIL; 697 exynos_dp_equalizer_err_link(regs, priv); 698 } 699 700 return ret; 701 } 702 703 static unsigned int exynos_dp_sw_link_training(struct exynos_dp *regs, 704 struct exynos_dp_priv *priv) 705 { 706 unsigned int ret = 0; 707 int training_finished; 708 709 /* Turn off unnecessary lane */ 710 if (priv->lane_cnt == 1) 711 exynos_dp_set_analog_power_down(regs, CH1_BLOCK, 1); 712 713 training_finished = 0; 714 715 priv->lt_info.lt_status = DP_LT_START; 716 717 /* Process here */ 718 while (!training_finished) { 719 switch (priv->lt_info.lt_status) { 720 case DP_LT_START: 721 ret = exynos_dp_link_start(regs, priv); 722 if (ret != EXYNOS_DP_SUCCESS) { 723 printf("DP LT:link start failed\n"); 724 return ret; 725 } 726 break; 727 case DP_LT_CR: 728 ret = exynos_dp_process_clock_recovery(regs, 729 priv); 730 if (ret != EXYNOS_DP_SUCCESS) { 731 printf("DP LT:clock recovery failed\n"); 732 return ret; 733 } 734 break; 735 case DP_LT_ET: 736 ret = exynos_dp_process_equalizer_training(regs, 737 priv); 738 if (ret != EXYNOS_DP_SUCCESS) { 739 printf("DP LT:equalizer training failed\n"); 740 return ret; 741 } 742 break; 743 case DP_LT_FINISHED: 744 training_finished = 1; 745 break; 746 case DP_LT_FAIL: 747 return -1; 748 } 749 } 750 751 return ret; 752 } 753 754 static unsigned int exynos_dp_set_link_train(struct exynos_dp *regs, 755 struct exynos_dp_priv *priv) 756 { 757 unsigned int ret; 758 759 exynos_dp_init_training(regs); 760 761 ret = exynos_dp_sw_link_training(regs, priv); 762 if (ret != EXYNOS_DP_SUCCESS) 763 printf("DP dp_sw_link_training() failed\n"); 764 765 return ret; 766 } 767 768 static void exynos_dp_enable_scramble(struct exynos_dp *regs, 769 unsigned int enable) 770 { 771 unsigned char data; 772 773 if (enable) { 774 exynos_dp_enable_scrambling(regs, DP_ENABLE); 775 776 exynos_dp_read_byte_from_dpcd(regs, 777 DPCD_TRAINING_PATTERN_SET, &data); 778 exynos_dp_write_byte_to_dpcd(regs, DPCD_TRAINING_PATTERN_SET, 779 (u8)(data & ~DPCD_SCRAMBLING_DISABLED)); 780 } else { 781 exynos_dp_enable_scrambling(regs, DP_DISABLE); 782 exynos_dp_read_byte_from_dpcd(regs, 783 DPCD_TRAINING_PATTERN_SET, &data); 784 exynos_dp_write_byte_to_dpcd(regs, DPCD_TRAINING_PATTERN_SET, 785 (u8)(data | DPCD_SCRAMBLING_DISABLED)); 786 } 787 } 788 789 static unsigned int exynos_dp_config_video(struct exynos_dp *regs, 790 struct exynos_dp_priv *priv) 791 { 792 unsigned int ret = 0; 793 unsigned int retry_cnt; 794 795 mdelay(1); 796 797 if (priv->video_info.master_mode) { 798 printf("DP does not support master mode\n"); 799 return -ENODEV; 800 } else { 801 /* debug slave */ 802 exynos_dp_config_video_slave_mode(regs, 803 &priv->video_info); 804 } 805 806 exynos_dp_set_video_color_format(regs, &priv->video_info); 807 808 if (priv->video_info.bist_mode) { 809 if (exynos_dp_config_video_bist(regs, priv) != 0) 810 return -1; 811 } 812 813 ret = exynos_dp_get_pll_lock_status(regs); 814 if (ret != PLL_LOCKED) { 815 printf("DP PLL is not locked yet\n"); 816 return -EIO; 817 } 818 819 if (priv->video_info.master_mode == 0) { 820 retry_cnt = 10; 821 while (retry_cnt) { 822 ret = exynos_dp_is_slave_video_stream_clock_on(regs); 823 if (ret != EXYNOS_DP_SUCCESS) { 824 if (retry_cnt == 0) { 825 printf("DP stream_clock_on failed\n"); 826 return ret; 827 } 828 retry_cnt--; 829 mdelay(1); 830 } else 831 break; 832 } 833 } 834 835 /* Set to use the register calculated M/N video */ 836 exynos_dp_set_video_cr_mn(regs, CALCULATED_M, 0, 0); 837 838 /* For video bist, Video timing must be generated by register */ 839 exynos_dp_set_video_timing_mode(regs, VIDEO_TIMING_FROM_CAPTURE); 840 841 /* Enable video bist */ 842 if (priv->video_info.bist_pattern != COLOR_RAMP && 843 priv->video_info.bist_pattern != BALCK_WHITE_V_LINES && 844 priv->video_info.bist_pattern != COLOR_SQUARE) 845 exynos_dp_enable_video_bist(regs, 846 priv->video_info.bist_mode); 847 else 848 exynos_dp_enable_video_bist(regs, DP_DISABLE); 849 850 /* Disable video mute */ 851 exynos_dp_enable_video_mute(regs, DP_DISABLE); 852 853 /* Configure video Master or Slave mode */ 854 exynos_dp_enable_video_master(regs, 855 priv->video_info.master_mode); 856 857 /* Enable video */ 858 exynos_dp_start_video(regs); 859 860 if (priv->video_info.master_mode == 0) { 861 retry_cnt = 100; 862 while (retry_cnt) { 863 ret = exynos_dp_is_video_stream_on(regs); 864 if (ret != EXYNOS_DP_SUCCESS) { 865 if (retry_cnt == 0) { 866 printf("DP Timeout of video stream\n"); 867 return ret; 868 } 869 retry_cnt--; 870 mdelay(5); 871 } else 872 break; 873 } 874 } 875 876 return ret; 877 } 878 879 static int exynos_dp_ofdata_to_platdata(struct udevice *dev) 880 { 881 struct exynos_dp_priv *priv = dev_get_priv(dev); 882 const void *blob = gd->fdt_blob; 883 unsigned int node = dev_of_offset(dev); 884 fdt_addr_t addr; 885 886 addr = dev_get_addr(dev); 887 if (addr == FDT_ADDR_T_NONE) { 888 debug("Can't get the DP base address\n"); 889 return -EINVAL; 890 } 891 priv->regs = (struct exynos_dp *)addr; 892 priv->disp_info.h_res = fdtdec_get_int(blob, node, 893 "samsung,h-res", 0); 894 priv->disp_info.h_sync_width = fdtdec_get_int(blob, node, 895 "samsung,h-sync-width", 0); 896 priv->disp_info.h_back_porch = fdtdec_get_int(blob, node, 897 "samsung,h-back-porch", 0); 898 priv->disp_info.h_front_porch = fdtdec_get_int(blob, node, 899 "samsung,h-front-porch", 0); 900 priv->disp_info.v_res = fdtdec_get_int(blob, node, 901 "samsung,v-res", 0); 902 priv->disp_info.v_sync_width = fdtdec_get_int(blob, node, 903 "samsung,v-sync-width", 0); 904 priv->disp_info.v_back_porch = fdtdec_get_int(blob, node, 905 "samsung,v-back-porch", 0); 906 priv->disp_info.v_front_porch = fdtdec_get_int(blob, node, 907 "samsung,v-front-porch", 0); 908 priv->disp_info.v_sync_rate = fdtdec_get_int(blob, node, 909 "samsung,v-sync-rate", 0); 910 911 priv->lt_info.lt_status = fdtdec_get_int(blob, node, 912 "samsung,lt-status", 0); 913 914 priv->video_info.master_mode = fdtdec_get_int(blob, node, 915 "samsung,master-mode", 0); 916 priv->video_info.bist_mode = fdtdec_get_int(blob, node, 917 "samsung,bist-mode", 0); 918 priv->video_info.bist_pattern = fdtdec_get_int(blob, node, 919 "samsung,bist-pattern", 0); 920 priv->video_info.h_sync_polarity = fdtdec_get_int(blob, node, 921 "samsung,h-sync-polarity", 0); 922 priv->video_info.v_sync_polarity = fdtdec_get_int(blob, node, 923 "samsung,v-sync-polarity", 0); 924 priv->video_info.interlaced = fdtdec_get_int(blob, node, 925 "samsung,interlaced", 0); 926 priv->video_info.color_space = fdtdec_get_int(blob, node, 927 "samsung,color-space", 0); 928 priv->video_info.dynamic_range = fdtdec_get_int(blob, node, 929 "samsung,dynamic-range", 0); 930 priv->video_info.ycbcr_coeff = fdtdec_get_int(blob, node, 931 "samsung,ycbcr-coeff", 0); 932 priv->video_info.color_depth = fdtdec_get_int(blob, node, 933 "samsung,color-depth", 0); 934 return 0; 935 } 936 937 static int exynos_dp_bridge_init(struct udevice *dev) 938 { 939 const int max_tries = 10; 940 int num_tries; 941 int ret; 942 943 debug("%s\n", __func__); 944 ret = video_bridge_attach(dev); 945 if (ret) { 946 debug("video bridge init failed: %d\n", ret); 947 return ret; 948 } 949 950 /* 951 * We need to wait for 90ms after bringing up the bridge since there 952 * is a phantom "high" on the HPD chip during its bootup. The phantom 953 * high comes within 7ms of de-asserting PD and persists for at least 954 * 15ms. The real high comes roughly 50ms after PD is de-asserted. The 955 * phantom high makes it hard for us to know when the NXP chip is up. 956 */ 957 mdelay(90); 958 959 for (num_tries = 0; num_tries < max_tries; num_tries++) { 960 /* Check HPD. If it's high, or we don't have it, all is well */ 961 ret = video_bridge_check_attached(dev); 962 if (!ret || ret == -ENOENT) 963 return 0; 964 965 debug("%s: eDP bridge failed to come up; try %d of %d\n", 966 __func__, num_tries, max_tries); 967 } 968 969 /* Immediately go into bridge reset if the hp line is not high */ 970 return -EIO; 971 } 972 973 static int exynos_dp_bridge_setup(const void *blob) 974 { 975 const int max_tries = 2; 976 int num_tries; 977 struct udevice *dev; 978 int ret; 979 980 /* Configure I2C registers for Parade bridge */ 981 ret = uclass_get_device(UCLASS_VIDEO_BRIDGE, 0, &dev); 982 if (ret) { 983 debug("video bridge init failed: %d\n", ret); 984 return ret; 985 } 986 987 if (strncmp(dev->driver->name, "parade", 6)) { 988 /* Mux HPHPD to the special hotplug detect mode */ 989 exynos_pinmux_config(PERIPH_ID_DPHPD, 0); 990 } 991 992 for (num_tries = 0; num_tries < max_tries; num_tries++) { 993 ret = exynos_dp_bridge_init(dev); 994 if (!ret) 995 return 0; 996 if (num_tries == max_tries - 1) 997 break; 998 999 /* 1000 * If we're here, the bridge chip failed to initialise. 1001 * Power down the bridge in an attempt to reset. 1002 */ 1003 video_bridge_set_active(dev, false); 1004 1005 /* 1006 * Arbitrarily wait 300ms here with DP_N low. Don't know for 1007 * sure how long we should wait, but we're being paranoid. 1008 */ 1009 mdelay(300); 1010 } 1011 1012 return ret; 1013 } 1014 int exynos_dp_enable(struct udevice *dev, int panel_bpp, 1015 const struct display_timing *timing) 1016 { 1017 struct exynos_dp_priv *priv = dev_get_priv(dev); 1018 struct exynos_dp *regs = priv->regs; 1019 unsigned int ret; 1020 1021 debug("%s: start\n", __func__); 1022 exynos_dp_disp_info(&priv->disp_info); 1023 1024 ret = exynos_dp_bridge_setup(gd->fdt_blob); 1025 if (ret && ret != -ENODEV) 1026 printf("LCD bridge failed to enable: %d\n", ret); 1027 1028 exynos_dp_phy_ctrl(1); 1029 1030 ret = exynos_dp_init_dp(regs); 1031 if (ret != EXYNOS_DP_SUCCESS) { 1032 printf("DP exynos_dp_init_dp() failed\n"); 1033 return ret; 1034 } 1035 1036 ret = exynos_dp_handle_edid(regs, priv); 1037 if (ret != EXYNOS_DP_SUCCESS) { 1038 printf("EDP handle_edid fail\n"); 1039 return ret; 1040 } 1041 1042 ret = exynos_dp_set_link_train(regs, priv); 1043 if (ret != EXYNOS_DP_SUCCESS) { 1044 printf("DP link training fail\n"); 1045 return ret; 1046 } 1047 1048 exynos_dp_enable_scramble(regs, DP_ENABLE); 1049 exynos_dp_enable_rx_to_enhanced_mode(regs, DP_ENABLE); 1050 exynos_dp_enable_enhanced_mode(regs, DP_ENABLE); 1051 1052 exynos_dp_set_link_bandwidth(regs, priv->lane_bw); 1053 exynos_dp_set_lane_count(regs, priv->lane_cnt); 1054 1055 exynos_dp_init_video(regs); 1056 ret = exynos_dp_config_video(regs, priv); 1057 if (ret != EXYNOS_DP_SUCCESS) { 1058 printf("Exynos DP init failed\n"); 1059 return ret; 1060 } 1061 1062 debug("Exynos DP init done\n"); 1063 1064 return ret; 1065 } 1066 1067 1068 static const struct dm_display_ops exynos_dp_ops = { 1069 .enable = exynos_dp_enable, 1070 }; 1071 1072 static const struct udevice_id exynos_dp_ids[] = { 1073 { .compatible = "samsung,exynos5-dp" }, 1074 { } 1075 }; 1076 1077 U_BOOT_DRIVER(exynos_dp) = { 1078 .name = "eexynos_dp", 1079 .id = UCLASS_DISPLAY, 1080 .of_match = exynos_dp_ids, 1081 .ops = &exynos_dp_ops, 1082 .ofdata_to_platdata = exynos_dp_ofdata_to_platdata, 1083 .priv_auto_alloc_size = sizeof(struct exynos_dp_priv), 1084 }; 1085