1 /* 2 * Copyright (c) 2011-2013, NVIDIA Corporation. 3 * 4 * SPDX-License-Identifier: GPL-2.0 5 */ 6 7 #include <common.h> 8 #include <dm.h> 9 #include <errno.h> 10 #include <fdtdec.h> 11 #include <malloc.h> 12 #include <panel.h> 13 #include <video_bridge.h> 14 #include <asm/io.h> 15 #include <asm/arch/clock.h> 16 #include <asm/arch-tegra/dc.h> 17 #include "displayport.h" 18 #include "sor.h" 19 20 DECLARE_GLOBAL_DATA_PTR; 21 22 #define DEBUG_SOR 0 23 24 #define APBDEV_PMC_DPD_SAMPLE 0x20 25 #define APBDEV_PMC_DPD_SAMPLE_ON_DISABLE 0 26 #define APBDEV_PMC_DPD_SAMPLE_ON_ENABLE 1 27 #define APBDEV_PMC_SEL_DPD_TIM 0x1c8 28 #define APBDEV_PMC_SEL_DPD_TIM_SEL_DPD_TIM_DEFAULT 0x7f 29 #define APBDEV_PMC_IO_DPD2_REQ 0x1c0 30 #define APBDEV_PMC_IO_DPD2_REQ_LVDS_SHIFT 25 31 #define APBDEV_PMC_IO_DPD2_REQ_LVDS_OFF (0 << 25) 32 #define APBDEV_PMC_IO_DPD2_REQ_LVDS_ON (1 << 25) 33 #define APBDEV_PMC_IO_DPD2_REQ_CODE_SHIFT 30 34 #define APBDEV_PMC_IO_DPD2_REQ_CODE_DEFAULT_MASK (0x3 << 30) 35 #define APBDEV_PMC_IO_DPD2_REQ_CODE_IDLE (0 << 30) 36 #define APBDEV_PMC_IO_DPD2_REQ_CODE_DPD_OFF (1 << 30) 37 #define APBDEV_PMC_IO_DPD2_REQ_CODE_DPD_ON (2 << 30) 38 #define APBDEV_PMC_IO_DPD2_STATUS 0x1c4 39 #define APBDEV_PMC_IO_DPD2_STATUS_LVDS_SHIFT 25 40 #define APBDEV_PMC_IO_DPD2_STATUS_LVDS_OFF (0 << 25) 41 #define APBDEV_PMC_IO_DPD2_STATUS_LVDS_ON (1 << 25) 42 43 struct tegra_dc_sor_data { 44 void *base; 45 void *pmc_base; 46 u8 portnum; /* 0 or 1 */ 47 int power_is_up; 48 struct udevice *panel; 49 }; 50 51 static inline u32 tegra_sor_readl(struct tegra_dc_sor_data *sor, u32 reg) 52 { 53 return readl((u32 *)sor->base + reg); 54 } 55 56 static inline void tegra_sor_writel(struct tegra_dc_sor_data *sor, u32 reg, 57 u32 val) 58 { 59 writel(val, (u32 *)sor->base + reg); 60 } 61 62 static inline void tegra_sor_write_field(struct tegra_dc_sor_data *sor, 63 u32 reg, u32 mask, u32 val) 64 { 65 u32 reg_val = tegra_sor_readl(sor, reg); 66 reg_val &= ~mask; 67 reg_val |= val; 68 tegra_sor_writel(sor, reg, reg_val); 69 } 70 71 void tegra_dp_disable_tx_pu(struct udevice *dev) 72 { 73 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 74 75 tegra_sor_write_field(sor, DP_PADCTL(sor->portnum), 76 DP_PADCTL_TX_PU_MASK, DP_PADCTL_TX_PU_DISABLE); 77 } 78 79 void tegra_dp_set_pe_vs_pc(struct udevice *dev, u32 mask, u32 pe_reg, 80 u32 vs_reg, u32 pc_reg, u8 pc_supported) 81 { 82 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 83 84 tegra_sor_write_field(sor, PR(sor->portnum), mask, pe_reg); 85 tegra_sor_write_field(sor, DC(sor->portnum), mask, vs_reg); 86 if (pc_supported) { 87 tegra_sor_write_field(sor, POSTCURSOR(sor->portnum), mask, 88 pc_reg); 89 } 90 } 91 92 static int tegra_dc_sor_poll_register(struct tegra_dc_sor_data *sor, u32 reg, 93 u32 mask, u32 exp_val, 94 int poll_interval_us, int timeout_ms) 95 { 96 u32 reg_val = 0; 97 ulong start; 98 99 start = get_timer(0); 100 do { 101 reg_val = tegra_sor_readl(sor, reg); 102 if (((reg_val & mask) == exp_val)) 103 return 0; 104 udelay(poll_interval_us); 105 } while (get_timer(start) < timeout_ms); 106 107 debug("sor_poll_register 0x%x: timeout, (reg_val)0x%08x & (mask)0x%08x != (exp_val)0x%08x\n", 108 reg, reg_val, mask, exp_val); 109 110 return -ETIMEDOUT; 111 } 112 113 int tegra_dc_sor_set_power_state(struct udevice *dev, int pu_pd) 114 { 115 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 116 u32 reg_val; 117 u32 orig_val; 118 119 orig_val = tegra_sor_readl(sor, PWR); 120 121 reg_val = pu_pd ? PWR_NORMAL_STATE_PU : 122 PWR_NORMAL_STATE_PD; /* normal state only */ 123 124 if (reg_val == orig_val) 125 return 0; /* No update needed */ 126 127 reg_val |= PWR_SETTING_NEW_TRIGGER; 128 tegra_sor_writel(sor, PWR, reg_val); 129 130 /* Poll to confirm it is done */ 131 if (tegra_dc_sor_poll_register(sor, PWR, 132 PWR_SETTING_NEW_DEFAULT_MASK, 133 PWR_SETTING_NEW_DONE, 134 100, TEGRA_SOR_TIMEOUT_MS)) { 135 debug("dc timeout waiting for SOR_PWR = NEW_DONE\n"); 136 return -EFAULT; 137 } 138 139 return 0; 140 } 141 142 void tegra_dc_sor_set_dp_linkctl(struct udevice *dev, int ena, 143 u8 training_pattern, 144 const struct tegra_dp_link_config *link_cfg) 145 { 146 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 147 u32 reg_val; 148 149 reg_val = tegra_sor_readl(sor, DP_LINKCTL(sor->portnum)); 150 151 if (ena) 152 reg_val |= DP_LINKCTL_ENABLE_YES; 153 else 154 reg_val &= DP_LINKCTL_ENABLE_NO; 155 156 reg_val &= ~DP_LINKCTL_TUSIZE_MASK; 157 reg_val |= (link_cfg->tu_size << DP_LINKCTL_TUSIZE_SHIFT); 158 159 if (link_cfg->enhanced_framing) 160 reg_val |= DP_LINKCTL_ENHANCEDFRAME_ENABLE; 161 162 tegra_sor_writel(sor, DP_LINKCTL(sor->portnum), reg_val); 163 164 switch (training_pattern) { 165 case training_pattern_1: 166 tegra_sor_writel(sor, DP_TPG, 0x41414141); 167 break; 168 case training_pattern_2: 169 case training_pattern_3: 170 reg_val = (link_cfg->link_bw == SOR_LINK_SPEED_G5_4) ? 171 0x43434343 : 0x42424242; 172 tegra_sor_writel(sor, DP_TPG, reg_val); 173 break; 174 default: 175 tegra_sor_writel(sor, DP_TPG, 0x50505050); 176 break; 177 } 178 } 179 180 static int tegra_dc_sor_enable_lane_sequencer(struct tegra_dc_sor_data *sor, 181 int pu, int is_lvds) 182 { 183 u32 reg_val; 184 185 /* SOR lane sequencer */ 186 if (pu) { 187 reg_val = LANE_SEQ_CTL_SETTING_NEW_TRIGGER | 188 LANE_SEQ_CTL_SEQUENCE_DOWN | 189 LANE_SEQ_CTL_NEW_POWER_STATE_PU; 190 } else { 191 reg_val = LANE_SEQ_CTL_SETTING_NEW_TRIGGER | 192 LANE_SEQ_CTL_SEQUENCE_UP | 193 LANE_SEQ_CTL_NEW_POWER_STATE_PD; 194 } 195 196 if (is_lvds) 197 reg_val |= 15 << LANE_SEQ_CTL_DELAY_SHIFT; 198 else 199 reg_val |= 1 << LANE_SEQ_CTL_DELAY_SHIFT; 200 201 tegra_sor_writel(sor, LANE_SEQ_CTL, reg_val); 202 203 if (tegra_dc_sor_poll_register(sor, LANE_SEQ_CTL, 204 LANE_SEQ_CTL_SETTING_MASK, 205 LANE_SEQ_CTL_SETTING_NEW_DONE, 206 100, TEGRA_SOR_TIMEOUT_MS)) { 207 debug("dp: timeout while waiting for SOR lane sequencer to power down lanes\n"); 208 return -1; 209 } 210 211 return 0; 212 } 213 214 static int tegra_dc_sor_power_dplanes(struct udevice *dev, 215 u32 lane_count, int pu) 216 { 217 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 218 u32 reg_val; 219 220 reg_val = tegra_sor_readl(sor, DP_PADCTL(sor->portnum)); 221 222 if (pu) { 223 switch (lane_count) { 224 case 4: 225 reg_val |= (DP_PADCTL_PD_TXD_3_NO | 226 DP_PADCTL_PD_TXD_2_NO); 227 /* fall through */ 228 case 2: 229 reg_val |= DP_PADCTL_PD_TXD_1_NO; 230 case 1: 231 reg_val |= DP_PADCTL_PD_TXD_0_NO; 232 break; 233 default: 234 debug("dp: invalid lane number %d\n", lane_count); 235 return -1; 236 } 237 238 tegra_sor_writel(sor, DP_PADCTL(sor->portnum), reg_val); 239 tegra_dc_sor_set_lane_count(dev, lane_count); 240 } 241 242 return tegra_dc_sor_enable_lane_sequencer(sor, pu, 0); 243 } 244 245 void tegra_dc_sor_set_panel_power(struct udevice *dev, int power_up) 246 { 247 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 248 u32 reg_val; 249 250 reg_val = tegra_sor_readl(sor, DP_PADCTL(sor->portnum)); 251 252 if (power_up) 253 reg_val |= DP_PADCTL_PAD_CAL_PD_POWERUP; 254 else 255 reg_val &= ~DP_PADCTL_PAD_CAL_PD_POWERUP; 256 257 tegra_sor_writel(sor, DP_PADCTL(sor->portnum), reg_val); 258 } 259 260 static void tegra_dc_sor_config_pwm(struct tegra_dc_sor_data *sor, u32 pwm_div, 261 u32 pwm_dutycycle) 262 { 263 tegra_sor_writel(sor, PWM_DIV, pwm_div); 264 tegra_sor_writel(sor, PWM_CTL, 265 (pwm_dutycycle & PWM_CTL_DUTY_CYCLE_MASK) | 266 PWM_CTL_SETTING_NEW_TRIGGER); 267 268 if (tegra_dc_sor_poll_register(sor, PWM_CTL, 269 PWM_CTL_SETTING_NEW_SHIFT, 270 PWM_CTL_SETTING_NEW_DONE, 271 100, TEGRA_SOR_TIMEOUT_MS)) { 272 debug("dp: timeout while waiting for SOR PWM setting\n"); 273 } 274 } 275 276 static void tegra_dc_sor_set_dp_mode(struct udevice *dev, 277 const struct tegra_dp_link_config *link_cfg) 278 { 279 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 280 u32 reg_val; 281 282 tegra_dc_sor_set_link_bandwidth(dev, link_cfg->link_bw); 283 284 tegra_dc_sor_set_dp_linkctl(dev, 1, training_pattern_none, link_cfg); 285 reg_val = tegra_sor_readl(sor, DP_CONFIG(sor->portnum)); 286 reg_val &= ~DP_CONFIG_WATERMARK_MASK; 287 reg_val |= link_cfg->watermark; 288 reg_val &= ~DP_CONFIG_ACTIVESYM_COUNT_MASK; 289 reg_val |= (link_cfg->active_count << 290 DP_CONFIG_ACTIVESYM_COUNT_SHIFT); 291 reg_val &= ~DP_CONFIG_ACTIVESYM_FRAC_MASK; 292 reg_val |= (link_cfg->active_frac << 293 DP_CONFIG_ACTIVESYM_FRAC_SHIFT); 294 if (link_cfg->activepolarity) 295 reg_val |= DP_CONFIG_ACTIVESYM_POLARITY_POSITIVE; 296 else 297 reg_val &= ~DP_CONFIG_ACTIVESYM_POLARITY_POSITIVE; 298 reg_val |= (DP_CONFIG_ACTIVESYM_CNTL_ENABLE | 299 DP_CONFIG_RD_RESET_VAL_NEGATIVE); 300 301 tegra_sor_writel(sor, DP_CONFIG(sor->portnum), reg_val); 302 303 /* program h/vblank sym */ 304 tegra_sor_write_field(sor, DP_AUDIO_HBLANK_SYMBOLS, 305 DP_AUDIO_HBLANK_SYMBOLS_MASK, 306 link_cfg->hblank_sym); 307 308 tegra_sor_write_field(sor, DP_AUDIO_VBLANK_SYMBOLS, 309 DP_AUDIO_VBLANK_SYMBOLS_MASK, 310 link_cfg->vblank_sym); 311 } 312 313 static inline void tegra_dc_sor_super_update(struct tegra_dc_sor_data *sor) 314 { 315 tegra_sor_writel(sor, SUPER_STATE0, 0); 316 tegra_sor_writel(sor, SUPER_STATE0, 1); 317 tegra_sor_writel(sor, SUPER_STATE0, 0); 318 } 319 320 static inline void tegra_dc_sor_update(struct tegra_dc_sor_data *sor) 321 { 322 tegra_sor_writel(sor, STATE0, 0); 323 tegra_sor_writel(sor, STATE0, 1); 324 tegra_sor_writel(sor, STATE0, 0); 325 } 326 327 static int tegra_dc_sor_io_set_dpd(struct tegra_dc_sor_data *sor, int up) 328 { 329 u32 reg_val; 330 void *pmc_base = sor->pmc_base; 331 332 if (up) { 333 writel(APBDEV_PMC_DPD_SAMPLE_ON_ENABLE, 334 pmc_base + APBDEV_PMC_DPD_SAMPLE); 335 writel(10, pmc_base + APBDEV_PMC_SEL_DPD_TIM); 336 } 337 338 reg_val = readl(pmc_base + APBDEV_PMC_IO_DPD2_REQ); 339 reg_val &= ~(APBDEV_PMC_IO_DPD2_REQ_LVDS_ON || 340 APBDEV_PMC_IO_DPD2_REQ_CODE_DEFAULT_MASK); 341 342 reg_val = up ? APBDEV_PMC_IO_DPD2_REQ_LVDS_ON | 343 APBDEV_PMC_IO_DPD2_REQ_CODE_DPD_OFF : 344 APBDEV_PMC_IO_DPD2_REQ_LVDS_OFF | 345 APBDEV_PMC_IO_DPD2_REQ_CODE_DPD_ON; 346 347 writel(reg_val, pmc_base + APBDEV_PMC_IO_DPD2_REQ); 348 349 /* Polling */ 350 u32 temp = 10 * 1000; 351 do { 352 udelay(20); 353 reg_val = readl(pmc_base + APBDEV_PMC_IO_DPD2_STATUS); 354 if (temp > 20) 355 temp -= 20; 356 else 357 break; 358 } while ((reg_val & APBDEV_PMC_IO_DPD2_STATUS_LVDS_ON) != 0); 359 360 if ((reg_val & APBDEV_PMC_IO_DPD2_STATUS_LVDS_ON) != 0) { 361 debug("PMC_IO_DPD2 polling failed (0x%x)\n", reg_val); 362 return -EIO; 363 } 364 365 if (up) { 366 writel(APBDEV_PMC_DPD_SAMPLE_ON_DISABLE, 367 pmc_base + APBDEV_PMC_DPD_SAMPLE); 368 } 369 370 return 0; 371 } 372 373 void tegra_dc_sor_set_internal_panel(struct udevice *dev, int is_int) 374 { 375 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 376 u32 reg_val; 377 378 reg_val = tegra_sor_readl(sor, DP_SPARE(sor->portnum)); 379 if (is_int) 380 reg_val |= DP_SPARE_PANEL_INTERNAL; 381 else 382 reg_val &= ~DP_SPARE_PANEL_INTERNAL; 383 384 reg_val |= DP_SPARE_SOR_CLK_SEL_MACRO_SORCLK | 385 DP_SPARE_SEQ_ENABLE_YES; 386 tegra_sor_writel(sor, DP_SPARE(sor->portnum), reg_val); 387 } 388 389 void tegra_dc_sor_read_link_config(struct udevice *dev, u8 *link_bw, 390 u8 *lane_count) 391 { 392 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 393 u32 reg_val; 394 395 reg_val = tegra_sor_readl(sor, CLK_CNTRL); 396 *link_bw = (reg_val & CLK_CNTRL_DP_LINK_SPEED_MASK) 397 >> CLK_CNTRL_DP_LINK_SPEED_SHIFT; 398 reg_val = tegra_sor_readl(sor, 399 DP_LINKCTL(sor->portnum)); 400 401 switch (reg_val & DP_LINKCTL_LANECOUNT_MASK) { 402 case DP_LINKCTL_LANECOUNT_ZERO: 403 *lane_count = 0; 404 break; 405 case DP_LINKCTL_LANECOUNT_ONE: 406 *lane_count = 1; 407 break; 408 case DP_LINKCTL_LANECOUNT_TWO: 409 *lane_count = 2; 410 break; 411 case DP_LINKCTL_LANECOUNT_FOUR: 412 *lane_count = 4; 413 break; 414 default: 415 printf("Unknown lane count\n"); 416 } 417 } 418 419 void tegra_dc_sor_set_link_bandwidth(struct udevice *dev, u8 link_bw) 420 { 421 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 422 423 tegra_sor_write_field(sor, CLK_CNTRL, 424 CLK_CNTRL_DP_LINK_SPEED_MASK, 425 link_bw << CLK_CNTRL_DP_LINK_SPEED_SHIFT); 426 } 427 428 void tegra_dc_sor_set_lane_count(struct udevice *dev, u8 lane_count) 429 { 430 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 431 u32 reg_val; 432 433 reg_val = tegra_sor_readl(sor, DP_LINKCTL(sor->portnum)); 434 reg_val &= ~DP_LINKCTL_LANECOUNT_MASK; 435 switch (lane_count) { 436 case 0: 437 break; 438 case 1: 439 reg_val |= DP_LINKCTL_LANECOUNT_ONE; 440 break; 441 case 2: 442 reg_val |= DP_LINKCTL_LANECOUNT_TWO; 443 break; 444 case 4: 445 reg_val |= DP_LINKCTL_LANECOUNT_FOUR; 446 break; 447 default: 448 /* 0 should be handled earlier. */ 449 printf("dp: Invalid lane count %d\n", lane_count); 450 return; 451 } 452 tegra_sor_writel(sor, DP_LINKCTL(sor->portnum), reg_val); 453 } 454 455 /* 456 * The SOR power sequencer does not work for t124 so SW has to 457 * go through the power sequence manually 458 * Power up steps from spec: 459 * STEP PDPORT PDPLL PDBG PLLVCOD PLLCAPD E_DPD PDCAL 460 * 1 1 1 1 1 1 1 1 461 * 2 1 1 1 1 1 0 1 462 * 3 1 1 0 1 1 0 1 463 * 4 1 0 0 0 0 0 1 464 * 5 0 0 0 0 0 0 1 465 */ 466 static int tegra_dc_sor_power_up(struct udevice *dev, int is_lvds) 467 { 468 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 469 u32 reg; 470 int ret; 471 472 if (sor->power_is_up) 473 return 0; 474 475 /* 476 * If for some reason it is already powered up, don't do it again. 477 * This can happen if U-Boot is the secondary boot loader. 478 */ 479 reg = tegra_sor_readl(sor, DP_PADCTL(sor->portnum)); 480 if (reg & DP_PADCTL_PD_TXD_0_NO) 481 return 0; 482 483 /* Set link bw */ 484 tegra_dc_sor_set_link_bandwidth(dev, is_lvds ? 485 CLK_CNTRL_DP_LINK_SPEED_LVDS : 486 CLK_CNTRL_DP_LINK_SPEED_G1_62); 487 488 /* step 1 */ 489 tegra_sor_write_field(sor, PLL2, 490 PLL2_AUX7_PORT_POWERDOWN_MASK | /* PDPORT */ 491 PLL2_AUX6_BANDGAP_POWERDOWN_MASK | /* PDBG */ 492 PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_MASK, /* PLLCAPD */ 493 PLL2_AUX7_PORT_POWERDOWN_ENABLE | 494 PLL2_AUX6_BANDGAP_POWERDOWN_ENABLE | 495 PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_ENABLE); 496 tegra_sor_write_field(sor, PLL0, PLL0_PWR_MASK | /* PDPLL */ 497 PLL0_VCOPD_MASK, /* PLLVCOPD */ 498 PLL0_PWR_OFF | PLL0_VCOPD_ASSERT); 499 tegra_sor_write_field(sor, DP_PADCTL(sor->portnum), 500 DP_PADCTL_PAD_CAL_PD_POWERDOWN, /* PDCAL */ 501 DP_PADCTL_PAD_CAL_PD_POWERDOWN); 502 503 /* step 2 */ 504 ret = tegra_dc_sor_io_set_dpd(sor, 1); 505 if (ret) 506 return ret; 507 udelay(15); 508 509 /* step 3 */ 510 tegra_sor_write_field(sor, PLL2, 511 PLL2_AUX6_BANDGAP_POWERDOWN_MASK, 512 PLL2_AUX6_BANDGAP_POWERDOWN_DISABLE); 513 udelay(25); 514 515 /* step 4 */ 516 tegra_sor_write_field(sor, PLL0, 517 PLL0_PWR_MASK | /* PDPLL */ 518 PLL0_VCOPD_MASK, /* PLLVCOPD */ 519 PLL0_PWR_ON | PLL0_VCOPD_RESCIND); 520 /* PLLCAPD */ 521 tegra_sor_write_field(sor, PLL2, 522 PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_MASK, 523 PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_DISABLE); 524 udelay(225); 525 526 /* step 5 PDPORT */ 527 tegra_sor_write_field(sor, PLL2, 528 PLL2_AUX7_PORT_POWERDOWN_MASK, 529 PLL2_AUX7_PORT_POWERDOWN_DISABLE); 530 531 sor->power_is_up = 1; 532 533 return 0; 534 } 535 536 #if DEBUG_SOR 537 static void dump_sor_reg(struct tegra_dc_sor_data *sor) 538 { 539 #define DUMP_REG(a) printk(BIOS_INFO, "%-32s %03x %08x\n", \ 540 #a, a, tegra_sor_readl(sor, a)); 541 542 DUMP_REG(SUPER_STATE0); 543 DUMP_REG(SUPER_STATE1); 544 DUMP_REG(STATE0); 545 DUMP_REG(STATE1); 546 DUMP_REG(NV_HEAD_STATE0(0)); 547 DUMP_REG(NV_HEAD_STATE0(1)); 548 DUMP_REG(NV_HEAD_STATE1(0)); 549 DUMP_REG(NV_HEAD_STATE1(1)); 550 DUMP_REG(NV_HEAD_STATE2(0)); 551 DUMP_REG(NV_HEAD_STATE2(1)); 552 DUMP_REG(NV_HEAD_STATE3(0)); 553 DUMP_REG(NV_HEAD_STATE3(1)); 554 DUMP_REG(NV_HEAD_STATE4(0)); 555 DUMP_REG(NV_HEAD_STATE4(1)); 556 DUMP_REG(NV_HEAD_STATE5(0)); 557 DUMP_REG(NV_HEAD_STATE5(1)); 558 DUMP_REG(CRC_CNTRL); 559 DUMP_REG(CLK_CNTRL); 560 DUMP_REG(CAP); 561 DUMP_REG(PWR); 562 DUMP_REG(TEST); 563 DUMP_REG(PLL0); 564 DUMP_REG(PLL1); 565 DUMP_REG(PLL2); 566 DUMP_REG(PLL3); 567 DUMP_REG(CSTM); 568 DUMP_REG(LVDS); 569 DUMP_REG(CRCA); 570 DUMP_REG(CRCB); 571 DUMP_REG(SEQ_CTL); 572 DUMP_REG(LANE_SEQ_CTL); 573 DUMP_REG(SEQ_INST(0)); 574 DUMP_REG(SEQ_INST(1)); 575 DUMP_REG(SEQ_INST(2)); 576 DUMP_REG(SEQ_INST(3)); 577 DUMP_REG(SEQ_INST(4)); 578 DUMP_REG(SEQ_INST(5)); 579 DUMP_REG(SEQ_INST(6)); 580 DUMP_REG(SEQ_INST(7)); 581 DUMP_REG(SEQ_INST(8)); 582 DUMP_REG(PWM_DIV); 583 DUMP_REG(PWM_CTL); 584 DUMP_REG(MSCHECK); 585 DUMP_REG(XBAR_CTRL); 586 DUMP_REG(DP_LINKCTL(0)); 587 DUMP_REG(DP_LINKCTL(1)); 588 DUMP_REG(DC(0)); 589 DUMP_REG(DC(1)); 590 DUMP_REG(LANE_DRIVE_CURRENT(0)); 591 DUMP_REG(PR(0)); 592 DUMP_REG(LANE4_PREEMPHASIS(0)); 593 DUMP_REG(POSTCURSOR(0)); 594 DUMP_REG(DP_CONFIG(0)); 595 DUMP_REG(DP_CONFIG(1)); 596 DUMP_REG(DP_MN(0)); 597 DUMP_REG(DP_MN(1)); 598 DUMP_REG(DP_PADCTL(0)); 599 DUMP_REG(DP_PADCTL(1)); 600 DUMP_REG(DP_DEBUG(0)); 601 DUMP_REG(DP_DEBUG(1)); 602 DUMP_REG(DP_SPARE(0)); 603 DUMP_REG(DP_SPARE(1)); 604 DUMP_REG(DP_TPG); 605 606 return; 607 } 608 #endif 609 610 static void tegra_dc_sor_config_panel(struct tegra_dc_sor_data *sor, 611 int is_lvds, 612 const struct tegra_dp_link_config *link_cfg, 613 const struct display_timing *timing) 614 { 615 const int head_num = 0; 616 u32 reg_val = STATE1_ASY_OWNER_HEAD0 << head_num; 617 u32 vtotal, htotal; 618 u32 vsync_end, hsync_end; 619 u32 vblank_end, hblank_end; 620 u32 vblank_start, hblank_start; 621 622 reg_val |= is_lvds ? STATE1_ASY_PROTOCOL_LVDS_CUSTOM : 623 STATE1_ASY_PROTOCOL_DP_A; 624 reg_val |= STATE1_ASY_SUBOWNER_NONE | 625 STATE1_ASY_CRCMODE_COMPLETE_RASTER; 626 627 reg_val |= STATE1_ASY_HSYNCPOL_NEGATIVE_TRUE; 628 reg_val |= STATE1_ASY_VSYNCPOL_NEGATIVE_TRUE; 629 reg_val |= (link_cfg->bits_per_pixel > 18) ? 630 STATE1_ASY_PIXELDEPTH_BPP_24_444 : 631 STATE1_ASY_PIXELDEPTH_BPP_18_444; 632 633 tegra_sor_writel(sor, STATE1, reg_val); 634 635 /* 636 * Skipping programming NV_HEAD_STATE0, assuming: 637 * interlacing: PROGRESSIVE, dynamic range: VESA, colorspace: RGB 638 */ 639 vtotal = timing->vsync_len.typ + timing->vback_porch.typ + 640 timing->vactive.typ + timing->vfront_porch.typ; 641 htotal = timing->hsync_len.typ + timing->hback_porch.typ + 642 timing->hactive.typ + timing->hfront_porch.typ; 643 644 tegra_sor_writel(sor, NV_HEAD_STATE1(head_num), 645 vtotal << NV_HEAD_STATE1_VTOTAL_SHIFT | 646 htotal << NV_HEAD_STATE1_HTOTAL_SHIFT); 647 648 vsync_end = timing->vsync_len.typ - 1; 649 hsync_end = timing->hsync_len.typ - 1; 650 tegra_sor_writel(sor, NV_HEAD_STATE2(head_num), 651 vsync_end << NV_HEAD_STATE2_VSYNC_END_SHIFT | 652 hsync_end << NV_HEAD_STATE2_HSYNC_END_SHIFT); 653 654 vblank_end = vsync_end + timing->vback_porch.typ; 655 hblank_end = hsync_end + timing->hback_porch.typ; 656 tegra_sor_writel(sor, NV_HEAD_STATE3(head_num), 657 vblank_end << NV_HEAD_STATE3_VBLANK_END_SHIFT | 658 hblank_end << NV_HEAD_STATE3_HBLANK_END_SHIFT); 659 660 vblank_start = vblank_end + timing->vactive.typ; 661 hblank_start = hblank_end + timing->hactive.typ; 662 tegra_sor_writel(sor, NV_HEAD_STATE4(head_num), 663 vblank_start << NV_HEAD_STATE4_VBLANK_START_SHIFT | 664 hblank_start << NV_HEAD_STATE4_HBLANK_START_SHIFT); 665 666 /* TODO: adding interlace mode support */ 667 tegra_sor_writel(sor, NV_HEAD_STATE5(head_num), 0x1); 668 669 tegra_sor_write_field(sor, CSTM, 670 CSTM_ROTCLK_DEFAULT_MASK | 671 CSTM_LVDS_EN_ENABLE, 672 2 << CSTM_ROTCLK_SHIFT | 673 is_lvds ? CSTM_LVDS_EN_ENABLE : 674 CSTM_LVDS_EN_DISABLE); 675 676 tegra_dc_sor_config_pwm(sor, 1024, 1024); 677 } 678 679 static void tegra_dc_sor_enable_dc(struct dc_ctlr *disp_ctrl) 680 { 681 u32 reg_val = readl(&disp_ctrl->cmd.state_access); 682 683 writel(reg_val | WRITE_MUX_ACTIVE, &disp_ctrl->cmd.state_access); 684 writel(VSYNC_H_POSITION(1), &disp_ctrl->disp.disp_timing_opt); 685 686 /* Enable DC now - otherwise pure text console may not show. */ 687 writel(CTRL_MODE_C_DISPLAY << CTRL_MODE_SHIFT, 688 &disp_ctrl->cmd.disp_cmd); 689 writel(reg_val, &disp_ctrl->cmd.state_access); 690 } 691 692 int tegra_dc_sor_enable_dp(struct udevice *dev, 693 const struct tegra_dp_link_config *link_cfg) 694 { 695 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 696 int ret; 697 698 tegra_sor_write_field(sor, CLK_CNTRL, 699 CLK_CNTRL_DP_CLK_SEL_MASK, 700 CLK_CNTRL_DP_CLK_SEL_SINGLE_DPCLK); 701 702 tegra_sor_write_field(sor, PLL2, 703 PLL2_AUX6_BANDGAP_POWERDOWN_MASK, 704 PLL2_AUX6_BANDGAP_POWERDOWN_DISABLE); 705 udelay(25); 706 707 tegra_sor_write_field(sor, PLL3, 708 PLL3_PLLVDD_MODE_MASK, 709 PLL3_PLLVDD_MODE_V3_3); 710 tegra_sor_writel(sor, PLL0, 711 0xf << PLL0_ICHPMP_SHFIT | 712 0x3 << PLL0_VCOCAP_SHIFT | 713 PLL0_PLLREG_LEVEL_V45 | 714 PLL0_RESISTORSEL_EXT | 715 PLL0_PWR_ON | PLL0_VCOPD_RESCIND); 716 tegra_sor_write_field(sor, PLL2, 717 PLL2_AUX1_SEQ_MASK | 718 PLL2_AUX9_LVDSEN_OVERRIDE | 719 PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_MASK, 720 PLL2_AUX1_SEQ_PLLCAPPD_OVERRIDE | 721 PLL2_AUX9_LVDSEN_OVERRIDE | 722 PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_DISABLE); 723 tegra_sor_writel(sor, PLL1, PLL1_TERM_COMPOUT_HIGH | 724 PLL1_TMDS_TERM_ENABLE); 725 726 if (tegra_dc_sor_poll_register(sor, PLL2, 727 PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_MASK, 728 PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_DISABLE, 729 100, TEGRA_SOR_TIMEOUT_MS)) { 730 printf("DP failed to lock PLL\n"); 731 return -EIO; 732 } 733 734 tegra_sor_write_field(sor, PLL2, PLL2_AUX2_MASK | 735 PLL2_AUX7_PORT_POWERDOWN_MASK, 736 PLL2_AUX2_OVERRIDE_POWERDOWN | 737 PLL2_AUX7_PORT_POWERDOWN_DISABLE); 738 739 ret = tegra_dc_sor_power_up(dev, 0); 740 if (ret) { 741 debug("DP failed to power up\n"); 742 return ret; 743 } 744 745 /* re-enable SOR clock */ 746 clock_sor_enable_edp_clock(); 747 748 /* Power up lanes */ 749 tegra_dc_sor_power_dplanes(dev, link_cfg->lane_count, 1); 750 751 tegra_dc_sor_set_dp_mode(dev, link_cfg); 752 debug("%s ret\n", __func__); 753 754 return 0; 755 } 756 757 int tegra_dc_sor_attach(struct udevice *dc_dev, struct udevice *dev, 758 const struct tegra_dp_link_config *link_cfg, 759 const struct display_timing *timing) 760 { 761 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 762 const void *blob = gd->fdt_blob; 763 struct dc_ctlr *disp_ctrl; 764 u32 reg_val; 765 int node; 766 767 /* Use the first display controller */ 768 debug("%s\n", __func__); 769 node = dev_of_offset(dc_dev); 770 disp_ctrl = (struct dc_ctlr *)fdtdec_get_addr(blob, node, "reg"); 771 772 tegra_dc_sor_enable_dc(disp_ctrl); 773 tegra_dc_sor_config_panel(sor, 0, link_cfg, timing); 774 775 writel(0x9f00, &disp_ctrl->cmd.state_ctrl); 776 writel(0x9f, &disp_ctrl->cmd.state_ctrl); 777 778 writel(PW0_ENABLE | PW1_ENABLE | PW2_ENABLE | PW3_ENABLE | 779 PW4_ENABLE | PM0_ENABLE | PM1_ENABLE, 780 &disp_ctrl->cmd.disp_pow_ctrl); 781 782 reg_val = tegra_sor_readl(sor, TEST); 783 if (reg_val & TEST_ATTACHED_TRUE) 784 return -EEXIST; 785 786 tegra_sor_writel(sor, SUPER_STATE1, 787 SUPER_STATE1_ATTACHED_NO); 788 789 /* 790 * Enable display2sor clock at least 2 cycles before DC start, 791 * to clear sor internal valid signal. 792 */ 793 writel(SOR_ENABLE, &disp_ctrl->disp.disp_win_opt); 794 writel(GENERAL_ACT_REQ, &disp_ctrl->cmd.state_ctrl); 795 writel(0, &disp_ctrl->disp.disp_win_opt); 796 writel(GENERAL_ACT_REQ, &disp_ctrl->cmd.state_ctrl); 797 798 /* Attach head */ 799 tegra_dc_sor_update(sor); 800 tegra_sor_writel(sor, SUPER_STATE1, 801 SUPER_STATE1_ATTACHED_YES); 802 tegra_sor_writel(sor, SUPER_STATE1, 803 SUPER_STATE1_ATTACHED_YES | 804 SUPER_STATE1_ASY_HEAD_OP_AWAKE | 805 SUPER_STATE1_ASY_ORMODE_NORMAL); 806 tegra_dc_sor_super_update(sor); 807 808 /* Enable dc */ 809 reg_val = readl(&disp_ctrl->cmd.state_access); 810 writel(reg_val | WRITE_MUX_ACTIVE, &disp_ctrl->cmd.state_access); 811 writel(CTRL_MODE_C_DISPLAY << CTRL_MODE_SHIFT, 812 &disp_ctrl->cmd.disp_cmd); 813 writel(SOR_ENABLE, &disp_ctrl->disp.disp_win_opt); 814 writel(reg_val, &disp_ctrl->cmd.state_access); 815 816 if (tegra_dc_sor_poll_register(sor, TEST, 817 TEST_ACT_HEAD_OPMODE_DEFAULT_MASK, 818 TEST_ACT_HEAD_OPMODE_AWAKE, 819 100, 820 TEGRA_SOR_ATTACH_TIMEOUT_MS)) { 821 printf("dc timeout waiting for OPMOD = AWAKE\n"); 822 return -ETIMEDOUT; 823 } else { 824 debug("%s: sor is attached\n", __func__); 825 } 826 827 #if DEBUG_SOR 828 dump_sor_reg(sor); 829 #endif 830 debug("%s: ret=%d\n", __func__, 0); 831 832 return 0; 833 } 834 835 void tegra_dc_sor_set_lane_parm(struct udevice *dev, 836 const struct tegra_dp_link_config *link_cfg) 837 { 838 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 839 840 tegra_sor_writel(sor, LANE_DRIVE_CURRENT(sor->portnum), 841 link_cfg->drive_current); 842 tegra_sor_writel(sor, PR(sor->portnum), 843 link_cfg->preemphasis); 844 tegra_sor_writel(sor, POSTCURSOR(sor->portnum), 845 link_cfg->postcursor); 846 tegra_sor_writel(sor, LVDS, 0); 847 848 tegra_dc_sor_set_link_bandwidth(dev, link_cfg->link_bw); 849 tegra_dc_sor_set_lane_count(dev, link_cfg->lane_count); 850 851 tegra_sor_write_field(sor, DP_PADCTL(sor->portnum), 852 DP_PADCTL_TX_PU_ENABLE | 853 DP_PADCTL_TX_PU_VALUE_DEFAULT_MASK, 854 DP_PADCTL_TX_PU_ENABLE | 855 2 << DP_PADCTL_TX_PU_VALUE_SHIFT); 856 857 /* Precharge */ 858 tegra_sor_write_field(sor, DP_PADCTL(sor->portnum), 0xf0, 0xf0); 859 udelay(20); 860 861 tegra_sor_write_field(sor, DP_PADCTL(sor->portnum), 0xf0, 0x0); 862 } 863 864 int tegra_dc_sor_set_voltage_swing(struct udevice *dev, 865 const struct tegra_dp_link_config *link_cfg) 866 { 867 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 868 u32 drive_current = 0; 869 u32 pre_emphasis = 0; 870 871 /* Set to a known-good pre-calibrated setting */ 872 switch (link_cfg->link_bw) { 873 case SOR_LINK_SPEED_G1_62: 874 case SOR_LINK_SPEED_G2_7: 875 drive_current = 0x13131313; 876 pre_emphasis = 0; 877 break; 878 case SOR_LINK_SPEED_G5_4: 879 debug("T124 does not support 5.4G link clock.\n"); 880 default: 881 debug("Invalid sor link bandwidth: %d\n", link_cfg->link_bw); 882 return -ENOLINK; 883 } 884 885 tegra_sor_writel(sor, LANE_DRIVE_CURRENT(sor->portnum), drive_current); 886 tegra_sor_writel(sor, PR(sor->portnum), pre_emphasis); 887 888 return 0; 889 } 890 891 void tegra_dc_sor_power_down_unused_lanes(struct udevice *dev, 892 const struct tegra_dp_link_config *link_cfg) 893 { 894 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 895 u32 pad_ctrl = 0; 896 int err = 0; 897 898 switch (link_cfg->lane_count) { 899 case 4: 900 pad_ctrl = DP_PADCTL_PD_TXD_0_NO | 901 DP_PADCTL_PD_TXD_1_NO | 902 DP_PADCTL_PD_TXD_2_NO | 903 DP_PADCTL_PD_TXD_3_NO; 904 break; 905 case 2: 906 pad_ctrl = DP_PADCTL_PD_TXD_0_NO | 907 DP_PADCTL_PD_TXD_1_NO | 908 DP_PADCTL_PD_TXD_2_YES | 909 DP_PADCTL_PD_TXD_3_YES; 910 break; 911 case 1: 912 pad_ctrl = DP_PADCTL_PD_TXD_0_NO | 913 DP_PADCTL_PD_TXD_1_YES | 914 DP_PADCTL_PD_TXD_2_YES | 915 DP_PADCTL_PD_TXD_3_YES; 916 break; 917 default: 918 printf("Invalid sor lane count: %u\n", link_cfg->lane_count); 919 return; 920 } 921 922 pad_ctrl |= DP_PADCTL_PAD_CAL_PD_POWERDOWN; 923 tegra_sor_writel(sor, DP_PADCTL(sor->portnum), pad_ctrl); 924 925 err = tegra_dc_sor_enable_lane_sequencer(sor, 0, 0); 926 if (err) { 927 debug("Wait for lane power down failed: %d\n", err); 928 return; 929 } 930 } 931 932 int tegra_sor_precharge_lanes(struct udevice *dev, 933 const struct tegra_dp_link_config *cfg) 934 { 935 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 936 u32 val = 0; 937 938 switch (cfg->lane_count) { 939 case 4: 940 val |= (DP_PADCTL_PD_TXD_3_NO | 941 DP_PADCTL_PD_TXD_2_NO); 942 /* fall through */ 943 case 2: 944 val |= DP_PADCTL_PD_TXD_1_NO; 945 /* fall through */ 946 case 1: 947 val |= DP_PADCTL_PD_TXD_0_NO; 948 break; 949 default: 950 debug("dp: invalid lane number %d\n", cfg->lane_count); 951 return -EINVAL; 952 } 953 954 tegra_sor_write_field(sor, DP_PADCTL(sor->portnum), 955 (0xf << DP_PADCTL_COMODE_TXD_0_DP_TXD_2_SHIFT), 956 (val << DP_PADCTL_COMODE_TXD_0_DP_TXD_2_SHIFT)); 957 udelay(100); 958 tegra_sor_write_field(sor, DP_PADCTL(sor->portnum), 959 (0xf << DP_PADCTL_COMODE_TXD_0_DP_TXD_2_SHIFT), 960 0); 961 962 return 0; 963 } 964 965 static void tegra_dc_sor_enable_sor(struct dc_ctlr *disp_ctrl, bool enable) 966 { 967 u32 reg_val = readl(&disp_ctrl->disp.disp_win_opt); 968 969 reg_val = enable ? reg_val | SOR_ENABLE : reg_val & ~SOR_ENABLE; 970 writel(reg_val, &disp_ctrl->disp.disp_win_opt); 971 } 972 973 int tegra_dc_sor_detach(struct udevice *dc_dev, struct udevice *dev) 974 { 975 struct tegra_dc_sor_data *sor = dev_get_priv(dev); 976 int dc_reg_ctx[DC_REG_SAVE_SPACE]; 977 const void *blob = gd->fdt_blob; 978 struct dc_ctlr *disp_ctrl; 979 unsigned long dc_int_mask; 980 int node; 981 int ret; 982 983 debug("%s\n", __func__); 984 /* Use the first display controller */ 985 node = dev_of_offset(dc_dev); 986 disp_ctrl = (struct dc_ctlr *)fdtdec_get_addr(blob, node, "reg"); 987 988 /* Sleep mode */ 989 tegra_sor_writel(sor, SUPER_STATE1, SUPER_STATE1_ASY_HEAD_OP_SLEEP | 990 SUPER_STATE1_ASY_ORMODE_SAFE | 991 SUPER_STATE1_ATTACHED_YES); 992 tegra_dc_sor_super_update(sor); 993 994 tegra_dc_sor_disable_win_short_raster(disp_ctrl, dc_reg_ctx); 995 996 if (tegra_dc_sor_poll_register(sor, TEST, 997 TEST_ACT_HEAD_OPMODE_DEFAULT_MASK, 998 TEST_ACT_HEAD_OPMODE_SLEEP, 100, 999 TEGRA_SOR_ATTACH_TIMEOUT_MS)) { 1000 debug("dc timeout waiting for OPMOD = SLEEP\n"); 1001 ret = -ETIMEDOUT; 1002 goto err; 1003 } 1004 1005 tegra_sor_writel(sor, SUPER_STATE1, SUPER_STATE1_ASY_HEAD_OP_SLEEP | 1006 SUPER_STATE1_ASY_ORMODE_SAFE | 1007 SUPER_STATE1_ATTACHED_NO); 1008 1009 /* Mask DC interrupts during the 2 dummy frames required for detach */ 1010 dc_int_mask = readl(&disp_ctrl->cmd.int_mask); 1011 writel(0, &disp_ctrl->cmd.int_mask); 1012 1013 /* Stop DC->SOR path */ 1014 tegra_dc_sor_enable_sor(disp_ctrl, false); 1015 ret = tegra_dc_sor_general_act(disp_ctrl); 1016 if (ret) 1017 goto err; 1018 1019 /* Stop DC */ 1020 writel(CTRL_MODE_STOP << CTRL_MODE_SHIFT, &disp_ctrl->cmd.disp_cmd); 1021 ret = tegra_dc_sor_general_act(disp_ctrl); 1022 if (ret) 1023 goto err; 1024 1025 tegra_dc_sor_restore_win_and_raster(disp_ctrl, dc_reg_ctx); 1026 1027 writel(dc_int_mask, &disp_ctrl->cmd.int_mask); 1028 1029 return 0; 1030 err: 1031 debug("%s: ret=%d\n", __func__, ret); 1032 1033 return ret; 1034 } 1035 1036 static int tegra_sor_set_backlight(struct udevice *dev, int percent) 1037 { 1038 struct tegra_dc_sor_data *priv = dev_get_priv(dev); 1039 int ret; 1040 1041 ret = panel_enable_backlight(priv->panel); 1042 if (ret) { 1043 debug("sor: Cannot enable panel backlight\n"); 1044 return ret; 1045 } 1046 1047 return 0; 1048 } 1049 1050 static int tegra_sor_ofdata_to_platdata(struct udevice *dev) 1051 { 1052 struct tegra_dc_sor_data *priv = dev_get_priv(dev); 1053 const void *blob = gd->fdt_blob; 1054 int node; 1055 int ret; 1056 1057 priv->base = (void *)fdtdec_get_addr(blob, dev_of_offset(dev), "reg"); 1058 1059 node = fdtdec_next_compatible(blob, 0, COMPAT_NVIDIA_TEGRA124_PMC); 1060 if (node < 0) { 1061 debug("%s: Cannot find PMC\n", __func__); 1062 return -ENOENT; 1063 } 1064 priv->pmc_base = (void *)fdtdec_get_addr(blob, node, "reg"); 1065 1066 ret = uclass_get_device_by_phandle(UCLASS_PANEL, dev, "nvidia,panel", 1067 &priv->panel); 1068 if (ret) { 1069 debug("%s: Cannot find panel for '%s' (ret=%d)\n", __func__, 1070 dev->name, ret); 1071 return ret; 1072 } 1073 1074 return 0; 1075 } 1076 1077 static const struct video_bridge_ops tegra_sor_ops = { 1078 .set_backlight = tegra_sor_set_backlight, 1079 }; 1080 1081 static const struct udevice_id tegra_sor_ids[] = { 1082 { .compatible = "nvidia,tegra124-sor" }, 1083 { } 1084 }; 1085 1086 U_BOOT_DRIVER(sor_tegra) = { 1087 .name = "sor_tegra", 1088 .id = UCLASS_VIDEO_BRIDGE, 1089 .of_match = tegra_sor_ids, 1090 .ofdata_to_platdata = tegra_sor_ofdata_to_platdata, 1091 .ops = &tegra_sor_ops, 1092 .priv_auto_alloc_size = sizeof(struct tegra_dc_sor_data), 1093 }; 1094